GHC previously accepted this code: data T f = T class C a where t :: f a -> T f inferring the kind of f as * -> * , but it now (correctly, according to the Haskell 98 and Haskell 2010 standards) rejects it. You need to write this instead: {-# LANGUAGE KindSignatures #-} data T (f :: * -> *) = T class C a where t :: f a -> T f

When the new DataKinds extension is enabled, suitable user-defined datatypes are automatically "promoted" to kinds, e.g. Nat here: data Nat = Zero | Succ Nat data Vector :: * -> Nat -> * where VNil :: Vector a Zero VCons :: a -> Vector a n -> Vector a (Succ n) See Section 7.8.2, “Datatype promotion” for more information.

There is a new extension PolyKinds which make it possible for kinds to be polymorphic. For example, instead of class Typeable (t :: *) where typeOf :: t -> TypeRep class Typeable1 (t :: * -> *) where typeOf1 :: t a -> TypeRep [...] instance Typeable Int where typeOf _ = TypeRep instance Typeable1 [] where typeOf _ = TypeRep you can now say data Proxy t = Proxy class Typeable t where typeOf :: Proxy t -> TypeRep instance Typeable Int where typeOf _ = TypeRep instance Typeable [] where typeOf _ = TypeRep and the kind of Proxy is polymorphic: forall k. k -> * . This feature is not yet fully mature, but please do file bug reports if you run into problems. See Section 7.8.1, “Kind polymorphism” for more information.

The Safe Haskell feature, new in GHC 7.2, has been redesigned in GHC 7.4. The motivation was to stop Safe Haskell from causing compilation failures for people not interested in using it. GHC now tries to infer whether a module is safe, unless the new -fno-safe-infer flag is given. Therefore, as well as the old -XSafe , there is now a -XUnsafe flag to explicitly state that a module should be treated as unsafe. The old -XSafeImports has been removed. The new flags -fwarn-safe and -fwarn-unsafe give warnings when a module is inferred to be safe or unsafe, respectively. There is a new flag -fpackage-trust . This controls whether packages containing imported trustworthy modules must be marked as trusted .

There is now a NOUNPACK pragma, which does the opposite of the existing PACK pragma. It is mainly useful when -funbox-strict-fields has been used, allowing you to declare that certain fields should not be unpacked.

GHC now requires, as per the standard, that if a newtype is used in an FFI declaration, then the constructor for that type must be in scope. For now you only get a warning if it is not, but in the future this will be an error.

There is a new extension ConstraintKind which adds a new kind, called Constraint , to GHC's type system. Then, for example, Show :: * -> Constraint (?x::Int) :: Constraint (Int ~ a) :: Constraint You can now write <em>any</em> type with kind Constraint on the left of => , i.e. you can use type synonyms, type variables, indexed types, etc.

It is now possible to derive an Eq instance for types with no constructors.

In the MonadComprehensions extension, the then group by e form has been removed. You now need to explicitly say then group by e using groupWith .

There is a new extension TraditionalRecordSyntax which is on by default. When turned off, the standard Haskell record syntax cannot be used.

In DPH, it is now possible to vectorise things imported from other modules.

In DPH, the VECTORISE and VECTORISE SCALAR pragmas now have type , class and instance variants. See VectPragma for more details.

The -fdph-seq , -fdph-par , -fdph-this and -fdph-none flags have been removed. The vectoriser is now controlled by which Data.Array.Parallel and Data.Array.Parallel.Prim modules are in scope.

GHC now warns consistently about unused type variables.

GHC now implements the static pattern semantics as clarified by the Haskell' committee, i.e. the binding p = e is now equivalent to t = e f = case t of p -> f g = case t of p -> g where f and g are the variables bound by p .

The MonoPatBinds extension is now deprecated, and has no effect.

GHC will now reject a declaration if it infers a type for it that is impossible to use unambiguously. For example, given class Wob a b where to :: a -> b from :: b -> a foo x = [x, to (from x)] GHC would infer the ambiguous type foo :: forall a b. Wob a b => b -> [b] but it is impossible to use foo as a will always be ambiguous, so the declaration is rejected.

It is now possible for associated types to have fresh parameters, e.g. this is now allowed: class C a where type T a b :: * instance C Int type T Int b = b -> b where T has a type index b that is not one of the class variables.

It is now possible for multiple associated type declarations to be given in a single instance, e.g. class C a where type T a x :: * data A data B instance C Int where type T Int A = Int type T Int B = Bool

The import and export of type family data constructors has been refined. You now need to be more explicit about what should be exported.

Associated type default declarations are now fully supported. These allow you to specify a default definition for a type that will be used if an instance doesn't define its own type, e.g. class Cls a where type Typ a type Typ a = Maybe a instance Cls Int where See Section 7.7.3.2, “Associated type synonym defaults” for more information.

You can now specify what simplifier phases SPECIALISE pragmas should be applied in, in the same way that you could for RULE pragmas, e.g. to specialise foo only in phase 1 use: {-# SPECIALISE [1] foo :: Int -> Int #-}

The typechecker is now able to do full constraint solving under a for-all, i.e. it can cope with the unification forall a. t1 ~ forall a. t2 .