Haskell 98

At the 1997 Haskell Workshop in Amsterdam, several concerns were expressed about the development of Haskell:

The language was still changing too quickly, throwing text books out of date before they are even completed, and making it hard for serious users to keep up.
The language has become more complex, making it hard for beginners to master.
It contains traps for the unwary, simple programs which fail in strange and unexpected ways, with error messages referring to concepts far beyond the beginner's grasp.

Haskell 98 is an attempt to address these concerns. It is intended to be a minor revision of Haskell 1.4, cleaning up traps but not adding major new functionality.

Haskell 98 will by no means be the last revision of Haskell. On the contrary, we design it knowing that new language extensions (multi-parameter type classes, universal and existential quantification, pattern guards, etc, etc) are well on the way. However, Haskell 98 will have a special status: the intention is that Haskell compilers will continue to support Haskell 98 (given an appropriate flag) even after later versions of the language have been defined, and so the name `Haskell 98' will refer to a fixed, stable language.

This document exhaustively lists all the differences between Haskell 1.4 and Haskell 98. Only a very short summary is given here, together with references to the report text. All section numbers refer to the Haskell 98 language and library reports.

Chapter 2: lexical structure

Section 2.3. Maximal munch rule for '--' comments.
Section 2.4. Treat underscore, _, as a lower-case letter. The lexeme "_" is a reserved identifer. Compilers that offer warnings for unused variables are encouraged to suppress such warnings for unused variables that begin with an underscore.
Section 2.4. Clarify that : is reserved solely for Haskell list construction.
Section 2.7. A more precise specification of the layout rule.

Chapter 3: expressions

Section 3.5. Specify the syntactic rules for sections more clearly and precisely. The resulting rule differs in minor respects from Haskell 1.4.
Section 3.7. Clarify that : is reserved solely for Haskell list construction. It cannot be hidden or redefined, any more than [] or (,,) can.
Section 3.11. Comprehensions are list comprehensions, not monad comprehensions.
Section 3.11. Permit empty qualifiers in a comprehension.
Section 3.13. Permit empty alternatives in a case.
Section 3.14, 6.3.6. Typing of do expressions, and the MonadZero class.
- The Monad class is extended, thus:
```
      class Monad m where
	  return :: a -> m a
	  (>>=)  :: m a -> (a -> m b) -> m b
	  (>>)   :: m a -> m b -> m b
	  fail   :: String -> m a

	  m1 >> m2 = m1 >>= \ _ -> m2
	  fail s = error s
```
- All do expressions have a type in class Monad (never MonadZero as in Haskell 1.4). Pattern match failure invokes fail passing a string suitable for printing out in an error message.
- The Monad instances for list, Maybe, and IO define fail to return [], return Nothing, and call error respectively.
- Class MonadZero is abolished.
- Class MonadPlus is moved to library Monad and defined thus:
```
      class Monad m => MonadPlus m where
	  mzero :: m a
	  mplus :: m a -> m a -> m a
```
To convert existing Haskell programs that use do notation: add fail s = mzero to any instances for Monad that are already instances of MonadZero; combine existing instances of MonadPlus and MonadZero, and rename the methods to mzero and mplus.
Section 3.14. Permit empty statements in a do expression.
Section 3.15. Remove ``punning'' for records. Quick reminder: punning allows one to abbreviate record pattern matches, construction, and updates:
```
	data Point = MkPoint { x,y :: Float }

	f1 :: Point -> Point
	f1 (MkPoint {x=xval, y=yval}) = MkPoint {x=xval+10, y=yval}

	f2 :: Point -> Point
	f2 (MkPoint {x, y}) = MkPoint {x=x+10, y}
```
In f2 the names of the values held in the fields 'punned' with the field labels themselves, both in the pattern match (which binds x,y and in the record construction on the right hand side. This feature is the one that has been removed.
Section 3.17.1. The production for fpat is:
```
  fpat -> qvar = pat
```
where we have qvar rather than var. Reason: the field name might only be in scope in qualified form.

Chapter 4: declarations

Section 4. Empty declarations are permitted.
Section 4.1.2. An empty context is permitted in a type.
Section 4.1.2. The simple-context restriction. Generalise type contexts to permit constraints of the form: (C (a t1 ... tn)), where a is a type variable and t1, ..., tn are types.
Section 4.2.1. A record may have no fields.
Section 4.2.3. Permit newtype declarations to use field-naming syntax.
Section 4.3.1. Class declarations can contain intermingled type signatures, fixity declarations, and value declarations for default class methods.
Section 4.3.2. A qualified name is permitted as the method name in the method bindings of an instance declaration.
Setion 4.3.1, 4.3.2. Pattern bindings are prohibited in the methods of a class or instance declaration.
Section 4.3.4. Change the 'default default' to (Integer, Double).
Section 4.4.2. Allow infix declarations anywhere type signatures are allowed. Fixity attaches to an entity, not to its name.
Section 4.4.3. Add a production for funlhs:
```
  funlhs	-> ( funlhs ) {apat}
```
This permits definitions like:
```
  (a &&& b) x = a x && b x
```
Section 4.5.5. No change to design, but the section is hopefully more clearly written.

Chapter 5: modules

Section 5. Generalise the type of main to IO t for any type t.
Section 5.3. An empty import declaration is permitted. This permits extra semicolons:
```
	module M where { import A; ; import B; f x = x }
```
Section 5.3.2. Two or more imported modules can share the same local alias, via an as clause.
Section 5.3.2. A module imported without a qualified clause can still have a local alias.
Section 5.5.1. The top-level declarations of a module bring into scope a qualified name as well as an unqualified one.
Section 5.5.2. Name clashes only cause an error if the offending name is actually mentioned.

Chapter 6: basic types

Remove the Void type.
Remove class Eval (but still describe seq).
Section 6.2. Rename strict to $!.
Section 6.3.3, and Fig 5, and module PreludeText. Remove functions and IO from class Show.
Section 6.3.4. Ord is not a superclass of Enum.
Section 6.3.4. Make it clear that the Enum class methods enumFrom... should obey the semantics described in Chapter 3 (Arithmetic sequences).
Section 6.3.4. Move succ, pred into class Enum. The current implementation (using toEnum,fromEnum) can't be made efficient for data types like
```
	data Nat = Zero | Succ Nat
```
Furthermore, the current implementation doesn't even work for Integer.
Section 6.4.5. Move atan2 into class RealFloat, and improve its default declaration. (Particular thanks to Kent Karlsson and Jerzy Karczmarczuk.)

Appendix A: standard prelude

Some of these changes have a minor equivalent change in Section 6.

Don't export the type Rational from the Prelude. It isn't useful unless you import the library Ratio. (We still export Rational on the grounds that it keeps the property that you can write a type signature for anything imported from the Prelude without importing anything else.)

Un-overload map, filter, (++), concat. The new signatures are:

	map :: (a -> b) -> [a] -> [b]
	filter :: (a -> Bool) -> [a] -> [a]
	(++) :: [a] -> [a] -> [a]
	concat :: [[a]] -> [a]

Rename the operation of class Functor as fmap

	class Functor f where
	  fmap :: (a -> b) -> f a -> f b
	  -- was map

For each class declaration, say which methods constitute a "minimum complete definition". For example:

    class  (Real a, Enum a) => Integral a  where
	quot, rem        :: a -> a -> a   
	div, mod         :: a -> a -> a
	quotRem, divMod  :: a -> a -> (a,a)
	toInteger        :: a -> Integer
    
	    -- Minimal complete definition:
	    --	quotRem, toInteger
	n `quot` d       =  ...
	n `rem` d        =  ...
	n `div` d        =  ...
	n `mod` d        =  ...
	divMod n d       =  ...

Monad classes:
- Augment class Monad (adding fail). (See also do expressions above.)
- Augment class MonadPlus (adding mzero), and rename ++ to mplus. Move class MonadPlus to library Monad.
- Remove class MonadZero.
- Modify functions with MonadZero contexts to MonadPlus.
Rename sequence to sequence_; and rename accumulate to sequence.
In module PreludeIO, rename fail to ioError.
Add filterM; replace old concat by msum; delete old filter; move filterM, msum, guard to library Monad.
```
	filterM :: (a -> m Bool) -> [a] -> m [a]
	-- didn't exist before

	msum :: MonadPlus m => [m a] -> m a
	-- was concat

	guard :: MonadPlus m => Bool -> m ()
```
Notice that guard remains in MonadPlus and uses mzero not fail. The latter is reserved exclusively for pattern-match failure.

Replace applyM with:

	(=<<)    :: Monad m => (a -> m b) -> m a -> m b
	f =<< x  =  x >>= f

Add default declaration for (/) in class Fractional
```
	    x / y	     =  x * recip y
```
Add default declaration for negate in class Num
```
	   negate x	     = 0 - x
```

Fix typo in unionBy

unionBy                 :: (a -> a -> Bool) -> [a] -> [a] -> [a]
unionBy eq xs ys         = xs ++ foldl (flip (deleteBy eq)) (nubBy eq ys) xs

Generalise the type of fromRealFrac and rename it as realToFrac.

	realToFrac :: (Real a, Fractional b) => a -> b
	realToFrac	=  fromRational . toRational

Fix bug in definition of span. The new definition is:

	span p []            = ([],[])
	span p xs@(x:xs') 
		    | p x       =  (x:ys,zs) 
		    | otherwise =  ([],xs)
				   where (ys,zs) = span p xs'

Provide a default declaration for == in class Eq.

The definition of enumFromThen is missing a map toEnum:

    enumFromThen c c' =  map toEnum [fromEnum c,
                                     fromEnum c' .. fromEnum lastChar]
                         where lastChar :: Char
                               lastChar | c' < c    = minBound
                                        | otherwise = maxBound

Improve definition of numericEnumFromTo and numericEnumFromThenTo:

	numericEnumFromTo n m   =  takeWhile (<= m+1/2) (numericEnumFrom n)
	numericEnumFromThenTo n n' m = takeWhile p (numericEnumFromThen n n')
				     where
				       p | n' > n    = (<= m + (n'-n)/2)
				     	 | otherwise = (>= m + (n'-n)/2)

The extra 1/2 gives better behaviour at the edges of the range.

Don't import isHexDigit into PreludeList.
Typo in instance Show Float and instance Show Double: needs parameter p.

Bug in instance Read Char. Should be:

    readsPrec p = readParen False
                            (\r -> [(c,t) | ('\'':s,t)<- lex r,
                                            (c,"\'")  <- readLitChar s])

Define cycle to give an error on the empty list.

	cycle :: [a] -> [a]
	cycle [] = error "Prelude.cycle: empty list"
	cycle xs = xs' where xs' = xs ++ xs'

Add show to class Show, together with the default declarations:

    show :: a -> String

    showsPrec _ x s   = show x ++ s
    show x 	      = showsPrec 0 x ""

Remove redundant spaces in showList

	showList []     = showString "[]"
	showList (x:xs) = showChar '[' . shows x . showl xs
			  where 
			    showl  []     = showChar ']'
			    showl  (x:xs) = showChar ',' . shows x .
					    showl xs

Replace the definition of isSym in lex with
```
   isSym c     =  c `elem` "!@#$%&*+./<=>?\\^|:-~"
```
(The Haskell 1.4 version treated space as a symbol character.)
In error messages, refer to Prelude.foo rather than (say) PreludeList.foo. The sub-modules in the Prelude do not form part of its specfication.

Appendix B: syntax

Syntactic changes mentioned above are not repeated here.

Specify that for layout purposes a Unicode character is treated as having the width of an ASCII character.
Delete fbinds from the syntax. It is not used.

Appendix D: derived instances

Specify that derived instances of Show add no unnecessary spaces.

Haskell 98 libraries

Make each module export all the relevant types and functions that the Prelude defines, so that a programmer who does not import the Prelude can get access to all the (say) list types and functions by saying import List. This involves extra exports from modules List, Monad, IO, Maybe, Char.

Module `Array`

Section 6.1. If, in any dimension, the lower bound is greater than the upper bound, then the array is legal, but empty. Indexing an empty array always gives an array-bounds error, but bounds still yields the bounds with which the array was constructed.

Module `Ix`

Remove Show from superclasses of Ix.
Fix defn of rangeSize. See the adjacent comments in the code for details.

Module `Char`

Rename isAlphanum as isAlphaNum. (This entails fixing importers of Char as well.
Remove parameter c from isLower. (Typo.)
Fix typo in showLitChar (was sshowLitChar).
In readLitChar use ordinary pairs instead of the obselete pairing constructor ":=".

Add defnition of missing helper function, match:

    match                         :: (Eq a) => [a] -> [a] -> ([a],[a])
    match (x:xs) (y:ys) | x == y  =  match xs ys
    match xs     ys               =  (xs,ys)

Module `List`

Add to genericTake the clause:
```
   genericTake 0 _         =  []
```

Add the following definition of unfoldr. (It differs slightly from that previously found in library Maybe.

	unfoldr :: (b -> Maybe (a,b)) -> b -> [a]
	unfoldr f b = case (f b) of
      			Nothing    -> []
				Just (a,b) -> a : unfoldr f b

Add insert to List.
```
    insert :: Ord a => a -> [a] -> [a]
```
This is consistent with the other `By' functions, which all have a non-By version.

Make transpose lazy in its second argument, so as to allow transpositions of 2d list matrices with infinite no. of rows as well as columns,

	-- transpose is lazy in both rows and columns,
	-- 	 and works for non-rectangular 'matrices'
	-- For example, transpose [[1,2],[3,4,5],[]]  =  [[1,3],[2,4],[5]]
    transpose                :: [[a]] -> [[a]]
    transpose []		 = []
    transpose ([]     : xss) = transpose xss
    transpose ((x:xs) : xss) = (x : [h | (h:t) <- xss]) : 
			     : transpose (xs : [t | (h:t) <- xss])

Fix isPrefixOf bug, defining it instead as:

  isPrefixOf               :: (Eq a) => [a] -> [a] -> Bool
  isPrefixOf []     _      =  True
  isPrefixOf _      []     =  False
  isPrefixOf (x:xs) (y:ys) =  x == y && isPrefixOf xs ys

Module `Complex`

Make (phase (0::Complex)) well defined,

    phase :: RealFloat a => Complex a -> a
    phase (0 :+ 0) = 0
    phase (x :+ y) = atan2 y x

Module `Maybe`

Remove the definition of unfoldr (reappears in List).
Add isNothing :: Maybe a -> Bool

Module `System`

Add exitFailure to the module header:
```
    exitFailure :: IO a
```

Module `Directory`

Clarify the specification of doesFileExist, doesDirectoryExist, as follows. The operation doesDirectoryExist returns True if the argument file exists and is a directory, and False otherwise. The operation doesFileExist returns True if the argument file exists and is not a directory, and False otherwise.
Make type Permissions abstract.

Module `Time`

Export the fields of CalendarTime and TimeDiff.

Module `Random`

This library has been completely re-specified.

Reversed decisions

I finally decided not to implement two proposed decisions:

Remove the concept of "special identifiers". Doing so consumes two new keywords (qualified, and hiding) without making programs any clearer. I judged the clean-up factor not worth the cost.
Put type constructors and classes in separate name spaces. This involved decorating imports and exports with class. It also involves a decision about whether type constructors in export lists should be decorated with type or data or nothing. Finally, type constructors and classes are more easily confused than type constructors/classes and data constructors. So I decided to let it lie.

Comments welcome.

Haskell 98

Chapter 2: lexical structure

Chapter 3: expressions

Chapter 4: declarations

Chapter 5: modules

Chapter 6: basic types

Appendix A: standard prelude

Appendix B: syntax

Appendix D: derived instances

Haskell 98 libraries

Module Array

Module Ix

Module Char

Module List

Module Complex

Module Maybe

Module System

Module Directory

Module Time

Module Random