The significant changes to the various parts of the compiler are listed in the following sections.
The major changes in this release are adding Haskell Program Coverage (hpc) support to the compiler, adding a debugger to GHCi, the first phase of the base package split, and pointer tagging in the code generator (which should mean most code improves by 10-15%, and as a result the compiler is also faster).
The GHC version numbering policy has been changed so 6.8.1 is the first release in this branch; see Section 1.3, “GHC version numbering policy” for details.
Registerised builds with gcc >= 4.2 now work.
While older releases did mostly work on Windows Vista, 6.8.1 fixes some issues, e.g. Windows used to think that cabal Setup programs were installers and refused to run them. However, Win9x support has now officially been dropped, as we are not able to test on that platform.
Haskell Program Coverage Adding hpc tools, as a single program GHC now comes with “Haskell Program Coverage”, a code coverage tool. This is in the form of a new -fhpc flag and an hpc program. See Section 6.6, “Observing Code Coverage” for more details.
There is the beginnings of support for “associated types” in GHC. However, this is incomplete and not a supported feature.
There is the beginnings of support for “nested data parallelism” in GHC. However, this is incomplete and not a supported feature.
It is now possible to derive class instances with standalone top-level declarations, rather than having to attach a deriving clause to the datatype declaration. The syntax is
deriving instance Cxt => Head
For more details see Section 8.5.2, “Stand-alone deriving declarations”.
GHC now does left-to-right impredicative instantiation, so for example
runST $ foo
will now work. Don't rely on this, though, as it is subject to change in the future!
A new extension OverloadedStrings means that string literals have type
Data.String.IsString t => t
where Data.String.IsString is a new class with a single method
fromString :: String -> a
There is a new record field disambiguation extension, enabled by -fdisambiguate-record-fields, which allows normally-ambiguous field names to be used when it is clear which is meant due to the use of a constructor. See Section 8.3.7, “Record field disambiguation” for more details.
There are also new flags -frecord-puns and -frecord-dot-dot for record punninng, but these do not work correctly yet, and so are not supported.
GHC now has an --info flag which prints information about the settings used to build the compiler. The information is in a machine-parsable (Haskell) format. For example,
$ ghc --info [("Project name","The Glorious Glasgow Haskell Compilation System") ,("Project version","6.8.1") ,("Booter version","6.6") ,("Stage","2") ,("Interface file version","6") ,("Have interpreter","YES") ,("Object splitting","NO") ,("Have native code generator","YES") ,("Support SMP","YES") ,("Unregisterised","NO") ,("Tables next to code","YES") ,("Win32 DLLs","") ,("RTS ways"," debug thr thr_p thr_debug") ,("Leading underscore","NO") ]
The runtime system now has an --info flag which prints various information about the way it was compiled. Thus you can give +RTS --info flags to any Haskell program, e.g.
$ darcs +RTS --info [("GHC RTS", "Yes") ,("GHC version", "6.8.1") ,("RTS way", "rts_thr") ,("Host platform", "x86_64-unknown-linux") ,("Build platform", "x86_64-unknown-linux") ,("Target platform", "x86_64-unknown-linux") ,("Compiler unregisterised", "NO") ,("Tables next to code", "YES") ]
GHC now accepts -XFoo and -XNoFoo flags, where Foo is any extension that can be listed in a LANGUAGE pragma. As a result the following flags are now deprecated:
-fth (use -XTemplateHaskell)
-ffi, -fffi (use -XForeignFunctionInterface)
-farrows (use -XArrows)
-fgenerics (use -XGenerics)
-fimplicit-prelude (use -XImplicitPrelude)
-fbang-patterns (use -XBangPatterns)
-fmonomorphism-restriction (use -XMonomorphismRestriction)
-fmono-pat-binds (use -XMonoPatBinds)
-fextended-default-rules (use -XExtendedDefaultRules)
-fimplicit-params (use -XImplicitParams)
-fscoped-type-variables (use -XScopedTypeVariables)
-fparr (use -XPArr)
-fallow-overlapping-instances (use -XOverlappingInstances)
-fallow-undecidable-instances (use -XUndecidableInstances)
-fallow-incoherent-instances (use -XIncoherentInstances)
GHC now has a --supported-languages flag which lists the strings it understands as a -X flag and in a LANGUAGE pragma. You can prepend NO to any of the strings. LANGUAGE pragmas also only turn on exactly what you asked for now; many of them used to just enable -fglasgow-exts before.
GHC now understands GENERATED pragmas, which are used to indicate to tools like HPC where some tool-generated code came from. They look like
{-# GENERATED "SourceFile" 12:3-14:8 #-} expr
GHC now has a --print-docdir flag which prints to stdout where GHC believes its documentation is located.
The -O no longer enables -fvia-C.
There is a new flag -fobject-code, which uses the default of -fasm or -fvia-C, and -fbyte-code, which only works in GHCi and sets byte-code as the target.
The warning for importing T(..) when T is an abstract type used to be enabled only by -W or -Wall. It no has its own flag -fwarn-dodgy-imports.
A new flag -fwarn-tabs warns if there are tab characters in your source files.
A new flag -fwarn-implicit-prelude warns if your module implicitly imports the Prelude.
A new flag -fwarn-monomorphism-restriction warns if the monomorphism restriction applies to your code.
The “missing type-signature” warning now tells you what type GHC inferred for the function.
The -w flag now turns off all options, not just those that are enabled by -Wall.
A new flag -Wwarn makes warnings just warn (the default). It can be used to override -Werror.
The -keep-hc-file, -keep-s-file and -keep-raw-s-file flags can now have an s appended to their name (which reads better when using --make). None of them, nor -keep-tmp-files, can have any other suffix.
There is a new flag -fspec-threshold which subsumes the now-deprecated -fliberate-case-threshold.
A new flag -fprint-explicit-foralls controls whether or not GHC prints explicit foralls when printing types.
A new flag -ddump-to-file allows you to specify that the output of the various ddump flags should be put in a given file.
A new flag -ddump-rule-firings makes GHC print out when its RULEs fire.
A new flag -ddump-mod-cycles, used with the -M mode, make GHC print out any module import loops.
The -fasm flag no longer takes an argument (which it always used to ignore anyway).
The new -fhardwire-lib-paths flag means the path to libraries are baked in, using the -rpath linker option.
A new RTS flag +RTS --install-signal-handlers=>yes|no< tells the RTS whether or not to install signal handlers (default is yes). When making a DLL you will probably want to set this to no.
When using runghc you can now leave a space after the -f argument telling it where to find GHC. You can now use -- to separate the -f argument from the GHC arguments, and the GHC arguments from the program to run.
ghc-pkg has a new command check which prints a list of all packages that are broken and which dependencies they are missing. Additionally, the list command now puts braces around broken packages.
ghc-pkg now has a new flag --names-only, used in conjunction with list --simple-output, which prints package names only, i.e. without their version numbers.
Some parts of the documentation, notably the building guide, have been moved to the wiki.
Linear implicit parameter support has been removed.
A new RTS flag +RTS -xbXXXXX hints to the OS that we'd like the heap to start at address 0xXXXXX. This is mainly of use to people debugging GHC.
It is now possible to get basic per-constructor profiling information from programs not compiled with -prof, by using the +RTS -hT flag. This is possible even when running code in GHCi.
There is now support in the run-time system for using PAPI to do CPU performance counter measurements. This is controlled via the +RTS -aX options. Note that it must be enabled when the compiler is built, and is still very experimental.
Ticky-ticky profiling, mainly for use by GHC developers, has been revived. See Section 6.7, “Using “ticky-ticky” profiling (for implementors)” for more information.
It is now possible to have the key on a different page in a graph generated by hp2ps, meaning the graph can be larger and the cost centre names longer. The +RTS -L flag can be used to specify the maximum length of a cost-centre stack name.
Uses of _scc_ now give a deprecated warning. Use SCC pragmas instead.
GHCi now includes an interactive debugger. See Section 3.5, “The GHCi Debugger” for more information.
The GHCi startup banner has been replaced with a single line. Avid fans of the banner can add
putStrLn " ___ ___ _" putStrLn " / _ \\ /\\ /\\/ __(_)" putStrLn " / /_\\// /_/ / / | | GHC Interactive, for Haskell 98." putStrLn "/ /_\\\\/ __ / /___| | http://www.haskell.org/ghc/" putStrLn "\\____/\\/ /_/\\____/|_| Type :? for help." putStrLn ""
to their ~/.ghci.
GHCi now has () as the first type in its defaulting list. See Section 3.4.5, “Type defaulting in GHCi” for more information.
GHCi now treats import M at its prompt the same as :module +M.
As well as :set -fno<foo>, you can now also say :unset -f<foo>.
These used to be called “core libraries”, but we now call them “boot libraries” (or, more precisely, “GHC boot libraries”) instead.
We now build the libraries with Cabal, rather than our own build system, so it should no longer be possible for differences to creep in between the libraries as built with GHC and as built with Cabal.
The following new boot libraries have been added:
hpc
The following boot libraries have been removed:
parsec
regex-base
regex-compat
regex-posix
stm
The following boot libraries are new, but composed of modules that used to be in the base library:
array (Data.Array*)
bytestring (Data.ByteString*)
containers (Data.Graph, Data.IntMap, Data.IntSet, Data.Map, Data.Sequence, Data.Set, Data.Tree)
directory (System.Directory)
old-locale (System.Locale)
old-time (System.Time)
packedstring (Data.PackedString)
pretty (Text.PrettyPrint*)
process (System.Cmd, System.Process*)
random (System.Random)
Additionally, Control.Parallel* have been moved to a new package “parallel” which is not a boot library.
Version number 0.1 (new library, split off from base).
The newArray_ method returns a deterministic result in the ST monad, and behaves as before in other contexts. The old newArray_ is now called unsafeNewArray_; the MArray class therefore has one more method than before.
In order to avoid problems where unusual Ix instances could cause the array code to access memory it shouldn't, a number of changes have been made:
A method
numElements :: Ix i => a i e -> Int
has been added to the IArray class.
Data.Array.Base has a new function
safeRangeSize :: Ix i => (i, i) -> Int
which always returns a non-negative result.
Data.Array.Base has a new function
safeIndex :: Ix i => (i, i) -> Int -> i -> Int
which only returns a result that is non-negative and not less than its second argument.
The unsafeForeignPtrToStorableArray function now has an Ix i constraint.
Version number 3.0 (was 2.1.1).
A new function
System.Timeout.timeout :: Int -> IO a -> IO (Maybe a)
allows a computation to be timed out after a given number of microseconds.
There is a new module Data.String, which defines the new IsString(fromString) class. This class is used by the new overloaded strings extension (see Section 8.6.4, “Overloaded string literals ”).
The Data.List module now exports a function
stripPrefix :: Eq a => [a] -> [a] -> Maybe [a]
which drops the given prefix from a list.
The System.IO.Error module now exports new functions ioeGetLocation and ioeSetLocation, for manipulating the “location” of an IOError.
The functions throwErrnoPath, throwErrnoPathIf, throwErrnoPathIf_, throwErrnoPathIfNull, throwErrnoPathIfMinus1, throwErrnoPathIfMinus1_ have moved from unix:System.Posix.Error to Foreign.C.Error.
The System.Posix.Signals module has moved to the unix package.
The Text.Printf.printf function now handles
The Int8, Int16, Int32, Int64, Word, Word8, Word16, Word32 and Word64 types.
The + flag.
The X, E and G formatting characters.
The hash functions in Data.HashTable have been improved.
The Kleisli composition functions
(>=>) :: (Monad m) => (a -> m b) -> (b -> m c) -> (a -> m c) (<=<) :: (Monad m) => (b -> m c) -> (a -> m b) -> (a -> m c)
together with the combinator
forever :: (Monad m) => m a -> m ()
have been added to Control.Monad.
There is now a Monoid instance for the Maybe type.
Data.Monoid now includes two types First and Last, which both newtype Maybe and return the first and last Just respectively when used a a Monoid.
Data.Monoid.Dual now derives Eq, Ord, Read, Show and Bounded.
We no longer put stdin, stdout and stderr into non-blocking mode, so piping Haskell program output through programs like tee works properly.
The type of Data.Generics.Schemes.synthesize has been generalised from
s -> (s -> s -> s) -> GenericQ (s -> s) -> GenericQ s
to
s -> (t -> s -> s) -> GenericQ (s -> t) -> GenericQ t
GHC.Exts now exports uncheckedShiftL64#, uncheckedShiftRL64#, uncheckedIShiftL64# and uncheckedIShiftRA64#.
GHC.Exts no longer defines the Splittable(split) class, which used to be used for linear implicit parameters.
The new value GHC.Conc.numCapabilities :: Int is the argument of the +RTS -N flag, i.e. the number of Haskell threads that can run simultaneously.
The new function GHC.Environment.getFullArgs returns the complete arguments that the program was invoked with, including any +RTS arguments etc.
GHC.Handle.openFd has been renamed to GHC.Handle.fdToHandle' to avoid confusion with System.Posix.IO.openFd.
Version number 0.9 (new library, split off from base).
Data.ByteString.packCStringLen is no longer a pure function; its signature has changed from
packCStringLen :: Foreign.C.String.CStringLen -> ByteString
to
packCStringLen :: Foreign.C.String.CStringLen -> IO ByteString
The Data.ByteString.Base module has been split in two. The unsafe functions are now in Data.ByteString.Unsafe (now part of the stable API), and the others are in Data.ByteString.Internal (not part of the stable API.
The internal lazy bytestring representation type has changed; rather than
newtype ByteString = LPS [Strict.ByteString]
it is now
data ByteString = Empty | Chunk !Strict.ByteString ByteString
Version number 1.2.2.0 (was 1.1.6.2).
Configurations have been implemented; these allow things to be set conditionally in .cabal files.
A new --executable flag for the haddock command also builds documentation for executables.
A new --hyperlink-source flag for the haddock command makes the docs link to the source code, rendered by hscolour.
A new --html-location flag for the haddock command allows you to say where documentation for packages we depend on is.
A new field pkgconfig-depends allows you to specify C libraries you use. The pkg-config command is used to find what C flags etc are needed to use this library.
A new field build-tools allows you to specify tool dependencies such as cpphs.
The includes field now only specifes which include files are automatically included when compiling the package. A new install-includes field determines which include files are also installed.
There are new flags --docdir and --htmldir for the configure command.
The configure command now has --with-prog, --prog-option and --prog-options flags for each program prog.
A new field cpp-options is used when preprocessing Haskell modules.
Many bug fixes.
The Cabal API is not yet stable. There have been many API changes.
Version number 0.1 (new library, split off from base).
Data.Tree.Tree now has Applicative and Monad instances.
In Data.Map the old functions
minView :: Monad m => Map k a -> m (Map k a, (k, a)) maxView :: Monad m => Map k a -> m (Map k a, (k, a))
have been replaced with
minView :: Monad m => Map k a -> m (a, Map k a) maxView :: Monad m => Map k a -> m (a, Map k a) minViewWithKey :: Monad m => Map k a -> m ((k, a), Map k a) maxViewWithKey :: Monad m => Map k a -> m ((k, a), Map k a)
In Data.Set the old functions
minView :: Monad m => Set a -> m (Set a, a) maxView :: Monad m => Set a -> m (Set a, a)
have had their result orders reversed:
maxView :: Monad m => Set a -> m (a, Set a) minView :: Monad m => Set a -> m (a, Set a)
The following are new functions in Data.IntMap:
maxView :: Monad m => IntMap a -> m (a, IntMap a) minView :: Monad m => IntMap a -> m (a, IntMap a) findMin :: IntMap a -> a findMax :: IntMap a -> a deleteMin :: IntMap a -> IntMap a deleteMax :: IntMap a -> IntMap a deleteFindMin :: IntMap a -> (a, IntMap a) deleteFindMax :: IntMap a -> (a, IntMap a) updateMin :: (a -> a) -> IntMap a -> IntMap a updateMax :: (a -> a) -> IntMap a -> IntMap a updateMinWithKey :: (Key -> a -> a) -> IntMap a -> IntMap a updateMaxWithKey :: (Key -> a -> a) -> IntMap a -> IntMap a minViewWithKey :: (Monad m) => IntMap a -> m ((Key, a), IntMap a) maxViewWithKey :: (Monad m) => IntMap a -> m ((Key, a), IntMap a)
The following are new functions in Data.IntSet:
findMin :: IntSet -> Int findMax :: IntSet -> Int deleteMin :: IntSet -> IntSet deleteMax :: IntSet -> IntSet deleteFindMin :: IntSet -> (Int, IntSet) deleteFindMax :: IntSet -> (Int, IntSet) maxView :: Monad m => IntSet -> m (Int, IntSet) minView :: Monad m => IntSet -> m (Int, IntSet)
Version number 1.0 (new library, split off from base).
The function
makeRelativeToCurrentDirectory :: FilePath -> IO FilePath
has been moved from the filepath library to System.Directory.
Version number 1.1 (was 1.0).
Removed makeRelativeToCurrentDirectory (it has moved to directory:System.Directory).
A number of driver-related functions have been added:
splitDrive :: FilePath -> (FilePath, FilePath) joinDrive :: FilePath -> FilePath -> FilePath takeDrive :: FilePath -> FilePath hasDrive :: FilePath -> Bool dropDrive :: FilePath -> FilePath isDrive :: FilePath -> Bool
Version number 0.1 (new library, split off from base).
There is now a Data instance for the PackedString type.
Version number 2.2 (was 2.1).
We now derive Data and Typeable instances for all the TH types.
There is now a Functor instance for Q, and Quasi instances have a Functor constraint.
Version number 2.2 (was 2.1).
System.Posix.Unistd now exports
nanosleep :: Integer -> IO ()
(which throws an exception if the OS doesn't provide it).
System.Posix.Files now exports
fileTypeModes :: FileMode blockSpecialMode :: FileMode characterSpecialMode :: FileMode namedPipeMode :: FileMode regularFileMode :: FileMode directoryMode :: FileMode symbolicLinkMode :: FileMode socketMode :: FileMode
for use with functions like createDevice.
There is a new module System.Posix.Semaphore providing POSIX named semaphore support.
There is a new module System.Posix.SharedMem providing POSIX shared memory support.
System.Posix.Terminal now exports
openPseudoTerminal :: IO (Fd, Fd) getSlaveTerminalName :: Fd -> IO FilePath
The functions throwErrnoPath, throwErrnoPathIf, throwErrnoPathIf_, throwErrnoPathIfNull, throwErrnoPathIfMinus1, throwErrnoPathIfMinus1_ have been removed from System.Posix.Error; they are now available from base:Foreign.C.Error.
The System.Posix.Signals module has been moved here from the base package.
Version number 6.8.1.
The API should now be much more usable than in previous releases.
There is a new function
compileToCore :: Session -> FilePath -> IO (Maybe [CoreBind])
which compiles a file to core.
There is a new value defaultObjectTarget that gives the HscTarget used by default. This name is now preferred to defaultHscTarget.
The old
data GhcMode = BatchCompile | Interactive | OneShot | JustTypecheck | MkDepend
has now been refactored into
data GhcMode = CompManager -- ^ --make, GHCi, etc. | OneShot -- ^ ghc -c Foo.hs | MkDepend -- ^ ghc -M, see Finder for why we need this
and
data GhcLink = NoLink | StaticLink
is now
data GhcLink = NoLink | LinkBinary | LinkInMemory
The HsSyn types now include all of the haddock comments.
As the GHC API exposes all the compiler internals there are numerous other changes that is would be impractical to list, but will have little effect on users of the API.