Haskell extensions

Posted: 2016-12-25 , Modified: 2016-12-25

ConstraintKinds
- GHC
- TypeFamilies or GADTs allow equality constraints a ~ Int.
- Tuples whose components have type Constraint.
- Anything declared to have type constraint:
```
type family Typ a b :: Constraint
type instance Typ Int  b = Show b
type instance Typ Bool b = Num b

func :: Typ a b => a -> b -> b
func = ...
```
- Allows type constraint synonyms type Stringy a = (Read a, Show a)
DataKinds
- Suitable (?) types (ex. algebraic data types) automatically get promoted to kinds. Here Nat goes from a type to a kind and Ze goes from a value of type Nat, to a type of kind Nat.
- Example: data Nat = Ze | Su Nat data Vec :: * -> Nat -> * where Nil :: Vec a Ze Cons :: a -> Vec a n -> Vec a (Su n)
DeriveFunctor
- SO
FlexibleContexts
- Allows non-type variables in constraints.
- g :: (C [a], D (a -> b)) => [a] -> b
- Prime
- SO
FunctionalDependencies
- Specify that some parameters of a type class determine others.
- class Mult a b c | a b -> c
- class Extract container elem | container -> elem
- Wiki

GADTs

Wikibooks

Example:

data List a where
Nil  :: List a
Cons :: a -> List a -> List a

Example that can’t be done with regular ADTs:

data Expr a where
I   :: Int  -> Expr Int
B   :: Bool -> Expr Bool
Add :: Expr Int -> Expr Int -> Expr Int
Mul :: Expr Int -> Expr Int -> Expr Int
Eq  :: Expr Int -> Expr Int -> Expr Bool

GeneralizedNewtypeDeriving
- Haskell
- A newtype can derive anything from the type that it wraps. (Normally you’d have to write an instance, by unwrapping.)
MultiParamTypeClasses
- Type classes which can take multiple arguments.
- Wiki
PolyKinds
- Allow kind polymorphism: a type variable doesn’t have to be restricted to one kind.
RebindableSyntax
- 24
- Overload >> and return in order to make do notation do - basically - whatever we want it to!
- Example: composition
```
(>>)    = flip (.)
return  = id
```
- Example: Kleisli arrows: (>>) = (<=<)
- It’s a relatively common problem in Haskell to think you have a Monad instance for some data type, but in reality, additional constraints make this impossible.
- Example:
```
setBind :: Ord b => Set a -> (a -> Set b) -> Set b
```
RecordWildCards
- 24
- For data Record = Record {a :: A, b :: b} and a function f r = g (a w) (b w) you can save writing the w by: f Record{..} = g a b.
- To also be able to refer to the variable, do f r@Record{..} =
- Create a Record field by field
```
do
  a <- ...
  b <- ...
  return Record{..}
```
- See also Gabriel’s blog post.
StandaloneDeriving
- Allow nonempty contexts when deriving
```
data T m = MkT (m Int)
deriving instance Eq (m Int) => Eq (T m)
```
- May need FlexibleContexts and UndecideableInstances
- Haskell
TypeOperators
- Reference
- data a + b = Plus a b.
- (+) can be used both as a function and as a type operator - they are in different namespaces. To export the type operator, use ExplicitNamespaces, import M( type (+)).