GHC Language extensions

GHC implements many extensions to Haskell, enabled by
- Placing {-# LANGUAGE ExtensionName #-} at top of file (recommended)
- Compiling with -XExtensionName (less recommended, except for -XSafe)
- Typing :set -XExtensionName at ghci prompt (or running ghci with -X…)
Complete list at Language options section of GHC’s option summary
Some extensions are very safe to use
- E.g., core libraries depend on extension in a deep way
- Extension very superficial, easily de-sugars into Haskell2010
Other extensions less widely accepted
- E.g., makes type inference/checking undecidable or non-deterministic
- Undermines type safety
- A work in progress that could never be incorporated into standard
Many extensions in a middle/gray area

Background: Monad transformers

Type constructors building monads parameterized by other monads
- Method lift executes actions from underlying transformed monad:
```
class MonadTrans t where
    lift :: Monad m => m a -> t m a
```
- Note monads have kind ∗ → ∗, so transformers have kind (∗ → ∗) → ∗ → ∗

Example: State transformer monad, StateT

newtype StateT s m a = StateT { runStateT :: s -> m (a,s) }

instance (Monad m) => Monad (StateT s m) where
    return a = StateT $ \s -> return (a, s)
    m >>= k  = StateT $ \s0 -> do          -- in monad m
                 ~(a, s1) <- runStateT m s0
                 runStateT (k a) s1

instance MonadTrans (StateT s) where
    lift ma = StateT $ \s -> do            -- in monad m
                a <- ma
                return (a, s)

Using `StateT`

get and put allow you to modify state

get :: (Monad m) => StateT s m s
put :: (Monad m) => s -> StateT s m ()

Example: Haskell equivalent of x++ in C

import Control.Monad.Trans
import Control.Monad.Trans.State

main :: IO ()
main = runStateT go 0 >>= print
  where go = do xplusplus >>= lift . print
                xplusplus >>= lift . print
        xplusplus = do n <- get; put (n + 1); return n

*Main> main
0
1
((),2)

Exercise: Implement `get` and `put`

Recall StateT implementation

newtype StateT s m a = StateT { runStateT :: s -> m (a,s) }

instance (Monad m) => Monad (StateT s m) where
    return a = StateT $ \s -> return (a, s)
    m >>= k  = StateT $ \s0 -> do          -- in monad m
                 ~(a, s1) <- runStateT m s0
                 runStateT (k a) s1

How to implement the following?

get :: (Monad m) => StateT s m s


put :: (Monad m) => s -> StateT s m ()

Exercise: Implement `get` and `put`

Recall StateT implementation

newtype StateT s m a = StateT { runStateT :: s -> m (a,s) }

instance (Monad m) => Monad (StateT s m) where
    return a = StateT $ \s -> return (a, s)
    m >>= k  = StateT $ \s0 -> do          -- in monad m
                 ~(a, s1) <- runStateT m s0
                 runStateT (k a) s1

How to implement the following?

get :: (Monad m) => StateT s m s
get = StateT $ \s -> return (s, s)

put :: (Monad m) => s -> StateT s m ()
put s = StateT $ \_ -> return ((), s)

The `MonadIO` class

Remember liftIO? Lets you execute IO regardless of current monad

class (Monad m) => MonadIO m where
    liftIO :: IO a -> m a

instance MonadIO IO where
    liftIO = id

Let’s make liftIO work for StateT

instance (MonadIO m) => MonadIO (StateT s m) where
    liftIO = lift . liftIO

Now can write functions that use IO and work in many monads:

myprint :: (Show a, MonadIO m) => a -> m ()
myprint a = liftIO $ print $ show a

All standard Monad transformers implement class MonadIO
- ContT, ErrorT, ListT, RWST, ReaderT, StateT, WriterT, …

Background: recursive bindings

Top-level, let, and where bindings are all recursive in Haskell, e.g.:

oneTwo :: (Int, Int)
oneTwo = (fst y, snd x)
    where x = (1, snd y)    -- mutual recursion
          y = (fst x, 2)

nthFib :: Int -> Integer
nthFib n = fibList !! n
    where fibList = 1 : 1 : zipWith (+) fibList (tail fibList)

Recursion can be implemented using a fixed-point combinator

Function fix calls a function with its own result, use to re-implement above:

fix :: (a -> a) -> a
fix f = let x = f x in x

oneTwo' :: (Int, Int)
oneTwo' = (fst y, snd x)
    where (x, y) = fix $ \ ~(x0, y0) -> let x1 = (1, snd y0)
                                            y1 = (fst x0, 2)
                                        in (x1, y1)
nthFib' n = fibList !! n
    where fibList = fix $ \l -> 1 : 1 : zipWith (+) l (tail l)

Recursion and monadic bindings

By contrast, monadic bindings are not recursive

do fibList <- return $ 1 : 1 : zipWith (+) fibList (tail fibList)
   ...     -- error, fibList not in scope  ^^^^^^^       ^^^^^^^

But monads in the MonadFix class have a fixed-point combinator

class Monad m => MonadFix m where
    mfix :: (a -> m a) -> m a

mfix can be used to implement recursive monadic bindings [Erkök00], e.g.:

mfib :: (MonadFix m) => Int -> m Integer
mfib n = do
  fibList <- mfix $ \l -> return $ 1 : 1 : zipWith (+) l (tail l)
  return $ fibList !! n -- ^^^^^

Why? E.g., might want to simulate circuits with monads
- Need recursion if there is a loop in your circuit
- Might want recursion anyway to avoid worrying about order of statements

The `RecursiveDo` extension

New rec keyword introduces recursive bindings in a do block [Erkök02]

Monad must be an instance of MonadFix (rec desugars to mfix calls)

oneTwo'' :: (MonadFix m) => m (Int, Int)
oneTwo'' = do
  rec x <- return (1, snd y)
      y <- return (fst x, 2)
  return (fst y, snd x)

Desugars to:

oneTwo''' :: (MonadFix m) => m (Int, Int)
oneTwo''' = do
  (x, y) <- mfix $ \ ~(x0, y0) -> do x1 <- return (1, snd y0)
                                     y1 <- return (fst x0, 2)
                                     return (x1, y1)
  return (fst y, snd x)

In practice RecursiveDo helps structure thinking
- Then can manually desugar rather than require a language extension
- But mfix on its own is quite useful

Example uses of `mfix` and `rec`

Create recursive data structures in one shot

data Link a = Link !a !(MVar (Link a)) -- note ! is okay

mkCycle :: IO (MVar (Link Int))
mkCycle = do
  rec l1 <- newMVar $ Link 1 l2        -- but $! would diverge
      l2 <- newMVar $ Link 2 l1
  return l1

Call non-strict methods of classes (easy access to return-type dictionary)

class MyClass t where
    myTypeName :: t -> String        -- non-strict in argument
    myDefaultValue :: t
instance MyClass Int where
    myTypeName _ = "Int"
    myDefaultValue = 0

getVal :: (MyClass t) => IO t
getVal = mfix $ \t -> do      -- doesn't use mfix's full power
  putStrLn $ "Caller wants type " ++ myTypeName t
  return myDefaultValue

Implementing `mfix`

Warm-up: The Identity monad

newtype Identity a = Identity { runIdentity :: a }
instance Monad Identity where
    return = Identity
    m >>= k = k (runIdentity m)

newtype compiles to nothing, so basically same as fix:

instance MonadFix Identity where
    mfix f = let x = f (runIdentity x) in x

`fixIO` – `IO` Monad fixed point

Remember magic unsafeInterleaveIO used for lazy IO?
```
unsafeInterleaveIO :: IO a -> IO a
```
- Looks like an IO identify function, but defers IO until the thunk forced
- Danger—don’t try this at home! No longer a functional language
```
weird :: IO String
weird = do
  xxx <- unsafeInterleaveIO $ do putStrLn "Gotcha!"; return []
  return $ 'a':'b':'c':xxx
```

For IO, mfix = fixIO:

fixIO :: (a -> IO a) -> IO a
fixIO k = do
    ref <- newIORef (throw NonTermination)
    ans <- unsafeInterleaveIO (readIORef ref)
    result <- k ans
    writeIORef ref result
    return result

This is quite similar to what the compiler does for pure fix

A generic `mfix` is not possible

What if we tried to define an mfix-like function for all monads?

mbroken :: (Monad m) => (a -> m a) -> m a -- equivalent to mfix?
mbroken f = fix (>>= f)

This is equivalent to

mbroken f = mbroken f >>= f

But >>= is strict in its first argument for many monads, so

*Main> mfix $ const (return 0)
0
*Main> mbroken $ const (return 0)
*** Exception: stack overflow

So mfix needs to take fixed point over value, not over monadic action
- How to do this is monad-specific
- Doesn’t work for all monads (ContT, ListT)

`MonadFix` instance for `StateT`

What about the StateT monad?

newtype StateT s m a = StateT { runStateT :: s -> m (a,s) }

instance (Monad m) => Monad (StateT s m) where
    return a = StateT $ \s -> return (a, s)
    m >>= k  = StateT $ \s0 -> do          -- in monad m
                 ~(a, s1) <- runStateT m s0
                 runStateT (k a) s1

Possibly easiest to see using rec notation

instance MonadFix m => MonadFix (StateT s m) where
    mfix f = StateT $ \s0 -> do            -- in monad m
               rec ~(a, s1) <- runStateT (f a) s0
               return (a, s1)

But easily implemented with no language extensions

instance MonadFix m => MonadFix (StateT s m) where
    mfix f = StateT $ \s -> mfix $ \ ~(a, _) -> runStateT (f a) s

Review: Type classes

A Haskell 2010 type class declaration can take the form:

class ClassName var where
    methodName :: Type {- where type references var -}

class (SuperClass var) => ClassName var where ...
class (Super1 var, Super2 var) => ClassName var where ...
...

Note that var need not have kind ∗
However, the type of each method must mention var and an implicit (Classname var) is added to the context of each method, e.g.:
```
Prelude> :t return
return :: Monad m => a -> m a
```

A Haskell 2010 instance declaration has the form:
```
instance [context =>] ClassName (TypeCon v1 ... vk) where ...
```
- Note v1 … vk are all variables and all distinct, ruling out, e.g., instance C (a,a) or instance C (Int a) or instance [[a]]

`MultiParamTypeClasses` extension

Enables type classes with multiple parameters, E.g.:

{-# LANGUAGE MultiParamTypeClasses #-}
class Convert a b where convert :: a -> b
instance Convert Int Bool where convert = (/= 0)
instance Convert Int Integer where convert = toInteger
instance (Convert a b) => Convert [a] [b] where
    convert = map convert

Extension itself is relatively safe, but encourages other extensions
- E.g., each method’s type must use every type parameter
```
class MyClass a b where
    aDefault :: a  -- can never use (without more extensions...)
```
- All types (argument and return) must be fully determined
```
       convert 0 :: Bool   -- error, 0 has type (Num a) => a
```
- And the usual instance restrictions still apply
```
instance Convert Int [Char] where convert = show  -- error bad param
```
  - [Char]–i.e., ([] Char)–is not a valid instance parameter, would have to be ([] a)

`FlexibleInstances` extension

Allows more specific type paremeters (relatively safe extension)

E.g., now we can say:

{-# LANGUAGE FlexibleInstances #-}

instance Convert Int [Char] where
    convert = show

And we can make all types convert to themselves:

instance Convert a a where convert a = a

*Main> convert () :: ()
()
*Main> convert ([1,2,3]::[Int]) :: [Integer]
[1,2,3]
*Main> convert ([1,2,3]::[Int]) :: [Int]
<interactive>:1:1:
    Overlapping instances for Convert [Int] [Int]
      instance Convert a a
      instance Convert a b => Convert [a] [b]

Oops, two instances apply; GHC doesn’t know which to choose

`OverlappingInstances` extension

This extension is used, but also widely frowned upon
- Only need this extension if overlapping instances actually used
- Enable extension where instances defined, not where used
- Compiler picks the most specific matching instance. I₁ is more specific than I₂ when I₁ can be created by substituting for the variables of I₂ and not vice versa
- Contexts (part before =>) not considered when selecting instances

Example: Do something like Show for String vs. [a]

class MyShow a where myShow :: a -> String
instance MyShow Char where myShow = show
instance MyShow Int where myShow = show
instance MyShow [Char] where myShow = id
instance (MyShow a) => MyShow [a] where
    myShow []     = "[]"
    myShow (x:xs) = "[" ++ myShow x ++ go xs
        where go (y:ys) = "," ++ myShow y ++ go ys
              go []     = "]"

So does enabling OverlappingInstances fix Convert?

Most specific instances

What is the most specific instance?

{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE OverlappingInstances #-}
instance Convert a a where ...
instance (Convert a b) => Convert [a] [b] where ...

*Main> convert ([1,2,3]::[Int]) :: [Int]
<interactive>:1:1:
    Overlapping instances for Convert [Int] [Int]
      instance [overlap ok] Convert a a
      instance [overlap ok] Convert a b => Convert [a] [b]

Neither instance is most specific!
We have to add a third instance to break the tie–one that can be created by substituting for variables in either of the other two overlapping instances

instance Convert [a] [a] where convert = id

*Main> convert ([1,2,3]::[Int]) :: [Int]
[1,2,3]

A case against `OverlappingInstances`

module Help where
    class MyShow a where
      myshow :: a -> String
    instance MyShow a => MyShow [a] where
      myshow xs = concatMap myshow xs

    showHelp :: MyShow a => [a] -> String
    showHelp xs = myshow xs     -- doesn't see overlapping instance

module Main where
    import Help

    data T = MkT
    instance MyShow T where
      myshow x = "Used generic instance"
    instance MyShow [T] where
      myshow xs = "Used more specific instance"

    main = do { print (myshow [MkT]); print (showHelp [MkT]) }

*Main> main
"Used more specific instance"
"Used generic instance"

Aside: How `Show` actually works

Add an extra helper method, showList, with a default definition:

class Show a where
  show :: a -> String
  showList :: [a] -> ShowS
  showList as = '[' : intercalate ", " (map show as) ++ "]"
  -- Note actual implementation more efficient but equivalent

instance (Show a) => Show [a] where
  show as = showList as

Show instance for Char overrides default showList
But had to plan all this out from the start
- Want an easy way to special-case trees or other data structures besides lists?
- Then you are stuck using overlapping instances

`FlexibleContexts` extension

MultiParamTypeClasses leads to inexpressible types
```
toInt val = convert val :: Int
```
- What is the type of function toInt? Would like to write:
```
toInt :: (Convert a Int) => a -> Int
```
- But (Convert a Int) => is an illegal context, as Int not a type variable
FlexibleContexts extension makes the above type legal to write
- Is a relatively safe extension to use
Still a couple of restrictions
- Each type variable in context must be “reachable” from a type variable in type
  (Reachable = explicitly used, or in another constraint with a reachable variable.)
```
sym :: forall a. Eq a => Int   -- illegal
```
- Every constraint must have a type variable
```
sym :: Eq Int => Bool          -- illegal
```

Monad classes

It’s neat that liftIO works from so many monads

Why not do something similar for StateT? Make get/set methods

{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FlexibleInstances #-}

class (Monad m) => MonadState s m where
    get :: m s
    put :: s -> m ()
instance (Monad m) => MonadState s (StateT s m) where
    get = StateT $ \s -> return (s, s)
    put s = StateT $ \_ -> return ((), s)

Now for each other MonadTrans, pass requests down

This is just like liftIO. E.g., for ReaderT:

instance (MonadIO m) => MonadIO (ReaderT r m) where
    liftIO = lift . liftIO

instance (MonadState s m) => MonadState s (ReaderT r m) where
    get = lift get
    put = lift . put

Problem: we’ve defeated type inference

Remember xplusplus?
```
        xplusplus = do n <- get; put (n + 1); return n
```
- The compiler knows we are in StateT Int IO monad
- So can infer that the type of get is Num s => StateT Int IO s
- But need to know s in order to select an instance of MonadState!
- For all compiler knows, might be other matching instances, e.g.,
```
instance MonadState Double (StateT Int IO) where
    -- would be legal, but exists only in compiler's imagination
```

Since compiler can’t infer return type of get, must type it manually:

    xplusplus = do n <- get :: StateT Int IO Int
                   put (n + 1)
                   return n

Yuck! Lack of type inference gets old fast!

`FunctionalDependencies` extension

Widely used & frowned upon (not as bad as OverlappingInstances)
- Also referred to as “fundeps”
Lets a class declare some parameters to be functions of others
```
class (Monad m) => MonadState s m | m -> s where
    get :: m s
    put :: s -> m ()
```
- The best way to think of this is in terms of instance selection
- “| m -> s” says can select an instance based on m without considering s, because s is a function of m
- Once you’ve selected the instance, you can use s for type inference
Disallows conflicting instances (even w. OverlappingInstances)
Also allows arbitrary computation at the type level [Hallgren]
- But language committee wants compilation to be decidable and deterministic
- So need to add some restrictions

Sufficient conditions of decidable instances

Anatomy of an instance: instance [context =>] head [where body]
- context consists of zero or more comma-separated assertions

The Paterson Conditions: for each assertion in the context

No type variable has more occurrences in the assertion than in the head

class Class a b
instance (Class a a) => Class [a] Bool  -- bad: 2 * a > 1 * a
instance (Class a b) => Class [a] Bool  -- bad: 1 * b > 0 * b

The assertion has fewer constructors and variables than the head

instance (Class a Int) => Class a Integer   -- bad: 2 >= 2

The Coverage Condition: For each fundep left -> right, the types in right cannot have type variables not mentioned in left

class Class a b | a -> b
instance Class a (Maybe a)       -- ok: a "covered" by left
instance Class Int (Maybe b)     -- bad: b not covered
instance Class a (Either a b)    -- bad: b not covered

Undecidable vs. exponential – who cares?

Editorial: maybe decidability of language is overrated
- Computers aren’t Turing machines with infinite tapes, after all

This legal, decidable program will crash your Haskell compiler

crash = f5 ()
    where f0 x = (x, x)      -- type size 2^{2^0}
          f1 x = f0 (f0 x)   -- type size 2^{2^1}
          f2 x = f1 (f1 x)   -- type size 2^{2^2}
          f3 x = f2 (f2 x)   -- type size 2^{2^3}
          f4 x = f3 (f3 x)   -- type size 2^{2^4}
          f5 x = f4 (f4 x)   -- type size 2^{2^5}

While plenty of not a priori provably decidable programs happily compile
- The conditions of the last slide are sufficient, not necessary
- Might have other ways of knowing your program can compile
- Or maybe figure it out from trial and error?

`UndecidableInstances` extension

Lifts the Paterson and Coverage conditions
- Also enables FlexibleContexts when enabled
Instead, imposes a maximum recursion depth
- Default maximum depth is 20
- Can increase with -fcontext-stack=n option, e.g.:
```
{-# OPTIONS_GHC -fcontext-stack=1024 #-}
{-# LANGUAGE UndecidableInstances #-}
```
A bit reminiscent of C++ templates
- gcc has a -ftemplate-depth= option
- Note C++11 raises minimum depth from 17 to 1024
- Similarly, people have talked of increasing GHC’s default context-stack

`MonadIO` revisited

Recall definition of MonadIO

class (Monad m) => MonadIO m where
    liftIO :: IO a -> m a
instance MonadIO IO where
    liftIO = id

Currently must define an instance for every transformer

instance MonadIO m => MonadIO (StateT s m) where liftIO = lift . liftIO
instance MonadIO m => MonadIO (ReaderT t m) where liftIO = lift . liftIO
instance MonadIO m => MonadIO (WriterT w m) where liftIO = lift . liftIO
...

With UndecidableInstances, one instance can cover all transformers!

{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE UndecidableInstances #-}

-- undecidable: assertion Monad (t m) no smaller than head
instance (MonadTrans t, MonadIO m, Monad (t m)) =>
    MonadIO (t m) where liftIO = lift . liftIO

Summary of extensions

We’ve seen 6 typeclass-related extensions

{-# LANGUAGE MultiParamTypeClasses #-}  -- very conservative
{-# LANGUAGE FlexibleInstances #-}      -- conservative
{-# LANGUAGE FlexibleContexts #-}       -- conservative
{-# LANGUAGE FunctionalDependencies #-} -- frowned upon
{-# LANGUAGE UndecidableInstances #-}   -- very frowned upon
{-# LANGUAGE OverlappingInstances #-}   -- the most controversial

Not all of these are looked upon kindly by the community
But if you enable all six, can be very powerful

Remainder of lecture looks at what you can do with all 6 enabled
- Much inspired by [Hlist] and [OOHaskell]

Warm-up: Type-level booleans

data HFalse = HFalse deriving Show
data HTrue = HTrue deriving Show

class HNot a b | a -> b where hNot :: a -> b
instance HNot HFalse HTrue where hNot _ = HTrue
instance HNot HTrue HFalse where hNot _ = HFalse

*Main> hNot HTrue
HFalse
*Main> hNot HFalse
HTrue

Note how fundep in HNot b nb computes negation of b at the type level
Haven’t used OverlappingInstances yet, let’s start…

Computing over types

Can we compute whether two types are equal? First attempt:

class TypeEq a b c | a b -> c where typeEq :: a -> b -> c
instance TypeEq a a HTrue where typeEq _ _ = HTrue
instance TypeEq a b HFalse where typeEq _ _ = HFalse

Problem: TypeEq a a HTrue not more specific than TypeEq a b HFalse
… but TypeEq a a HTrue is more specific than TypeEq a b c

Recall that context is never consulted for instance selection

Only afterwards to reject failed assertions or infer types from fundeps
Solution: compute c after instance selection using another fundep

class TypeCast a b | a -> b where typeCast :: a -> b
instance TypeCast a a where typeCast = id

instance TypeEq a a HTrue where typeEq _ _ = HTrue -- as before
instance (TypeCast HFalse c) => TypeEq a b c where
    typeEq _ _ = typeCast HFalse

The utility of `TypeEq`

Editorial: TypeEq is kind of the holy grail of fundeps
- If you can implement TypeEq, you can program recursively at type level by distinguishing base and recursive cases!
- But relies deeply on OverlappingInstances…

Example: Let’s do for MonadState what we did for MonadIO

-- If t is StateT, then do one thing for (t s m) (base case):
instance (Monad m) => MonadState s (StateT s m) where
    get = StateT $ \s -> return (s, s)
    put = StateT $ \_ -> return ((), s)
-- If t is not StateT, do something else (recursive case):
instance (MonadTrans t, MonadState s m, Monad (t m)) =>
    MonadState s (t m) where
        get = lift get
        put = lift . put

MonadIO was easier because type IO can’t match parameter (t m)
Unfortunately, StateT s m matches both of above instance heads
So need OverlappingInstances to select first instance for StateT s m

Heterogeneous lists

Last extension: TypeOperators allows infix types starting with “:”
```
data a :*: b = Foo a b
type a :+: b = Either a b
```

Let’s use an infix constructor to define a heterogeneous list

data HNil = HNil deriving Show
data (:*:) h t = h :*: !t deriving Show
infixr 9 :*:

-- Example:
data A = A deriving Show
data B = B deriving Show
data C = C deriving Show

foo = (A, "Hello") :*: (B, 7) :*: (C, 3.0) :*: HNil

*Main> foo
(A,"Hello") :*: ((B,7) :*: ((C,3.0) :*: HNil))
*Main> :t foo
foo :: (A, [Char]) :*: ((B, Integer) :*: ((C, Double) :*: HNil))

Operations on heterogeneous lists

Notice our list consisted of pairs

foo :: (A, [Char]) :*: (B, Integer) :*: (C, Double) :*: HNil
foo = (A, "Hello") :*: (B, 7) :*: (C, 3.0) :*: HNil

View first element as a key or tag, second as a value—How to look up value?

class Select k h v | k h -> v where
    (.!) :: h -> k -> v
instance Select k ((k, v) :*: t) v where
    (.!) ((_, v) :*: _) _ = v
instance (Select k h v) => Select k (kv' :*: h) v where
    (.!) (kv' :*: h) k = h .! k

*Main> foo .! A
"Hello"

Once again, note the importance of OverlappingInstances
- Needed to break recursion when type of lookup tag matches head of list
Can use to implement all sorts of other features (concatenation, etc.)

Object-oriented programming

Heterogeneous lists can implement object-oriented programming!

returnIO :: a -> IO a
returnIO = return

data GetVal = GetVal deriving Show
data SetVal = SetVal deriving Show
data ClearVal = ClearVal deriving Show

mkVal n self = do
  val <- newIORef (n :: Int)
  returnIO $ (GetVal, readIORef val)
           :*: (SetVal, writeIORef val)
           :*: (ClearVal, self .! SetVal $ 0)
           :*: HNil

test = do               -- prints 7, then 0
  x <- mfix $ mkVal 7
  x .! GetVal >>= print
  x .! ClearVal
  x .! GetVal >>= print

But why mfix?

“Tying the recursive knot”

mfix allows you to override methods with inheritance

Example, create a “const val” that ignores SetVal messages

mkConstVal n self = do
  super <- mkVal n self
  returnIO $ (SetVal, const $ return ())
           :*: super

test2 = do
  x <- mfix $ mkConstVal 7
  x .! GetVal >>= print
  x .! ClearVal
  x .! GetVal >>= print

*Main> test
7
0
*Main> test2
7
7

mkVal’s call to SetVal was properly overridden by mkConstVal

GHC Language extensions

Background: Monad transformers

Using StateT

Exercise: Implement get and put

Exercise: Implement get and put

The MonadIO class

Background: recursive bindings

Recursion and monadic bindings

The RecursiveDo extension

Example uses of mfix and rec

Implementing mfix

fixIO – IO Monad fixed point

A generic mfix is not possible

MonadFix instance for StateT

Review: Type classes

MultiParamTypeClasses extension

FlexibleInstances extension

OverlappingInstances extension

Most specific instances

A case against OverlappingInstances

Aside: How Show actually works

FlexibleContexts extension

Monad classes

Problem: we’ve defeated type inference

FunctionalDependencies extension

Sufficient conditions of decidable instances

Undecidable vs. exponential – who cares?

UndecidableInstances extension

MonadIO revisited

Summary of extensions

Warm-up: Type-level booleans

Computing over types

The utility of TypeEq

Heterogeneous lists

Operations on heterogeneous lists

Object-oriented programming

“Tying the recursive knot”

Using `StateT`

Exercise: Implement `get` and `put`

Exercise: Implement `get` and `put`

The `MonadIO` class

The `RecursiveDo` extension

Example uses of `mfix` and `rec`

Implementing `mfix`

`fixIO` – `IO` Monad fixed point

A generic `mfix` is not possible

`MonadFix` instance for `StateT`

`MultiParamTypeClasses` extension

`FlexibleInstances` extension

`OverlappingInstances` extension

A case against `OverlappingInstances`

Aside: How `Show` actually works

`FlexibleContexts` extension

`FunctionalDependencies` extension

`UndecidableInstances` extension

`MonadIO` revisited

The utility of `TypeEq`