{-#Differences

# Differences from Haskell 98

## Language Differences

* Class contexts on data types are silently ignored.

* Class methods are fully 'eta expanded' out to the argument count specified
  by the type. This is often beneficial as instances that need to share
  partial applications are rare. This behavior can be turned off with the
  NOETA pragma for specific methods.

## Library Changes

In addition to a larger set of base libraries roughly modeled on GHC's base.
Jhc provides a number of extensions/minor modifications to the standard
libraries. These are designed to be mostly backwards compatible and most are
to the class system.

* Data.Bits
    * Num is no longer a super class of Data.Bits. It never should have been.
    * There are new methods logicalShiftR and arithmeticShiftR that do a logical and
      arithmetic shift respectively. shiftR will always map to one of those as
      appropriate.
    * shiftR and shiftL do not check for negative arguments, if you might want
      negative arguments, use the general 'shift' routine. 'shift' also comes
      in logical and arithmetic varieties.


## Library Additions

There are many other additional libraries provided with jhc, here I list only
changes that affect modules that are defined by the haskell 98 or FFI
specifications.

* Data.Int and Data.Word provide WordPtr, WordMax, IntPtr, and IntMax that
   correspond to the C types uintptr_t, uintmax_t, intptr_t, and intmax_t
   respectively.

* fromInt,toInt,fromDouble,toDouble have been added
   alongside Integer and Rational routines in their respective classes.

* floating point truncation and rounding functions have varieties that don't
   return an integral type, but rather return something of the same type
   as its argument. These have the same name but end in 'f'.

# Notable Differences from GHC

Jhc differs from GHC in certain ways that are allowed by Haskell 98, but might
come as a surprise to some.

 * An Int may be only 30 bits and may not observe simple binary truncation on
   overflow. If you need known bit width and binary semantics for your numbers
   then use the types in Data.Int and Data.Word. Overflow on Int or Word has
   undefined results.

 * A Char may only preserve values within the Unicode range. Storing
   values greater than 0x10FFFF has undefined results.

 * The Int and Word types are at most 32 bits, even on 64 bit architectures.

 * All text based IO is performed according to the current locale. This means
   that Unicode works seamlessly, but older programs that assumed IO was
   performed by simple truncation of chars down to 8 bits will fail. Use the
   explicit binary routines if you need binary IO.


# Differences That are Considered Misfeatures

These misfeatures will be fixed at some point.

 * Integer corresponds to IntMax rather than an arbitrary precision type. As
   soon as a suitable arbitrary precision library emerges, it will be
   replaced.

 * Ix is not derivable.

