3. Release notes for version 8.6.1

The significant changes to the various parts of the compiler are listed in the following sections. There have also been numerous bug fixes and performance improvements over the 8.4.1 release.

3.1. Highlights

The highlights, since the 8.4.1 release, are:

  • Programs are no longer constrained by the Windows MAX_PATH file path length limit. The file path limit is now approximately 32,767 characters. Note that GHC itself is still somewhat limited due to GCC not supporting file namespaced paths. Paths that are passed directly to the compiler, linker or other GNU tools are currently still constrained. See File paths under Windows for details.
  • Many, many bug fixes.

3.2. Full details

3.2.1. Language

  • Use of quantified type variables in constraints is now allowed via the QuantifiedConstraints language extension. This long-awaited feature enables users to encode significantly more precision in their types. For instance, the common MonadTrans typeclass could now make the expectation that an applied transformer is must be a Monad

    class (forall m. Monad m => Monad (t m)) => MonadTrans t where {- ... -}

    Additionally, quantification can enable terminating instance resolution where this previously was not possible. See Quantified constraints for details.

  • A new DerivingVia language extension has been added which allows the use of the via deriving strategy. For instance:

    newtype T = MkT Int
      deriving Monoid via (Sum Int)

    See Deriving via for more information.

  • A new StarIsType language extension has been added which controls whether * is parsed as Data.Kind.Type or a regular type operator. StarIsType is enabled by default.

  • GHC now permits the use of a wildcard type as the context of a standalone deriving declaration with the use of the PartialTypeSignatures language extension. For instance, this declaration:

    deriving instance _ => Eq (Foo a)

    Denotes a derived Eq (Foo a) instance, where the context is inferred in much the same way as ordinary deriving clauses do. See Partial Type Signatures.

  • Data declarations with empty where clauses are no longer valid without the extension GADTSyntax enabled. For instance, consider the following,

    data T where

    The grammar is invalid in Haskell2010. Previously it could be compiled successfully without GADTs. As of GHC 8.6.1, this is a parse error.

  • Incomplete patterns warning -Wincomplete-patterns is extended to guards in pattern bindings and if alternatives of MultiWayIf. For instance, consider the following,

    foo :: Bool -> Int
    foo b = if | b -> 1

    In GHC 8.6.1, it will raise the warning:

    <interactive>:2:12: warning: [-Wincomplete-patterns]
        Pattern match(es) are non-exhaustive
        In a multi-way if alternative:
            Guards do not cover entire pattern space

    See Trac #14773.

  • Scoped type variables now work in default methods of class declarations and in pattern synonyms in Template Haskell. See Trac #14885.

  • do expressions, lambda expressions, etc. to be directly used as a function argument, enabled with BlockArguments. See More liberal syntax for function arguments for the full details.

  • Underscores in numeric literals (e.g. 1_000_000), enabled with NumericUnderscores. See Numeric underscores for the full details.

  • CUSKs now require all kind variables to be explicitly quantified. This was already the case with TypeInType, but now PolyKinds also exhibits this behavior. This means that the following example is no longer considered to have a CUSK:

    data T1 :: k -> Type       -- No CUSK: `k` is not explicitly quantified
  • Functionality of TypeInType has been subsumed by PolyKinds, and it is now merely a shorthand for PolyKinds, DataKinds, and NoStarIsType. The users are advised to avoid TypeInType due to its misleading name: the Type :: Type axiom holds regardless of whether it is enabled.

  • GHC has become more diligent about catching illegal uses of kind polymorphism. For instance, GHC 8.4 would accept the following without the use of PolyKinds:

    f :: forall k (a :: k). Proxy a
    f = Proxy

    This is now an error unless PolyKinds is enabled.

  • The plugin mechanism has been extended to allow plugins to run between frontend phases. Of particular note are the parser and typechecker plugins which run after parsing and typechecking have completed. Collectively, these new extension points are called source plugins.

  • Type literals now could be used in type class instances without the extension FlexibleInstances.

    See Trac #13833.

  • MonadFailDesugaring is now enabled by default. See MonadFail Proposal (MFP) for more details.

3.2.2. Compiler

  • GHC now no longer adds the current file’s directory as a general include path calling the C compiler. Instead we use -iquote to only add it as an include path for #include “”. See Trac #14312.
  • GHC now supports British spelling of GeneralizedNewtypeDeriving.
  • GHC now does significantly more constant folding in its core-to-core optimiser. This will result in significantly better code being generated for some programs. See Trac #9136.
  • GHC now offers significantly more information about typed holes such as valid hole fits and refinement hole fits. See Valid Hole Fits for more information.
  • The code-generation effects of -dynamic can now be enabled independently by the flag -fexternal-dynamic-refs. If you don’t know why you might need this, you don’t need it.
  • -Wcompat now includes -Wimplicit-kind-vars to provide early detection of breakage that will be caused by implementation of GHC proposal #24 in a future release.

3.2.3. Plugins

  • GHC’s plugin mechanism now offers plugin authors control over their plugin’s effect on recompilation checking. Specifically the Plugin record name has a new field

    data Plugin = Plugin {
        pluginRecompile :: [CommandLineOption] -> IO PluginRecompile
      , {- ... -}
    data PluginRecompile = ForceRecompile | NoForceRecompile | MaybeRecompile Fingerprint

    Plugin based on defaultPlugin will have their previous recompilation behavior (ForceRecompile) preserved. However, plugins that are “pure” are encouraged to override this to either NoForceRecompile or MaybeRecompile. See Controlling Recompilation for details.

  • GHC now provides a class of new plugins: source plugins. These plugins can inspect and modify a variety of intermediate representations used by the compiler’s frontend. These include:

    • The ability to modify the parser output
    • The ability to inspect the renamer output
    • The ability to modify the typechecked AST
    • The ability to modify Template Haskell splices
    • The ability to modify interface files as they are loaded

    See Source plugins for details.

3.2.4. GHCi

  • Added an experimental :doc command that displays the documentation for a declaration.

3.2.5. Runtime system

  • The GHC runtime linker now prefers user shared libraries above system ones. When extra search directories are specified these are searched before anything else. This fixes iuuc on Windows given the proper search directories (e.g -L/mingw64/lib).
  • The GHC runtime linker now uses LIBRARY_PATH and the runtime loader now also searches LD_LIBRARY_PATH.
  • The GHC runtime on Windows is no longer constrained by the MAX_PATH file path length limitation. See File paths under Windows.
  • The runtime now allows use of the -hT profiling variety on programs built with -prof.
  • The STM assertions mechanism (namely the always and alwaysSucceeds functions) has been removed. This happened a bit earlier than proposed in the deprecation pragma included in GHC 8.4, but due to community feedback we decided to move ahead with the early removal.

3.2.6. Template Haskell

3.2.7. ghc library

3.2.8. base library

  • ($!) is now representation-polymorphic like ($).
  • The module Data.Functor.Contravariant has been moved from the contravariant package into base. All the other modules in contravariant (Data.Functor.Contravariant.Divisible, etc.) have not been moved to base, and they still reside in contravariant.

3.2.9. ghc-prim library

  • Version number (was
  • Added new addWordC# operation for unsigned addition with carry.

3.2.10. Build system

3.3. Included libraries

The package database provided with this distribution also contains a number of packages other than GHC itself. See the changelogs provided with these packages for further change information.

Package Version Reason for inclusion
ghc 8.7 The compiler itself
Cabal Dependency of ghc-pkg utility
Win32 Dependency of ghc library
array Dependency of ghc library
base Core library
binary Dependency of ghc library
bytestring Dependency of ghc library
containers Dependency of ghc library
deepseq Dependency of ghc library
directory Dependency of ghc library
filepath Dependency of ghc library
ghc-boot 8.7 Internal compiler library
ghc-compact Core library
ghc-prim 0.5.3 Core library
ghci 8.7 The REPL interface
haskeline Dependency of ghci executable
hpc Dependency of hpc executable
integer-gmp Core library
mtl 2.2.2 Dependency of Cabal library
parsec Dependency of Cabal library
process Dependency of ghc library
template-haskell Core library
text Dependency of Cabal library
time 1.9.2 Dependency of ghc library
transformers Dependency of ghc library
unix Dependency of ghc library
xhtml 3000.2.2.1 Dependency of haddock executable