# User:Benmachine/Cont

### From HaskellWiki

Benmachine (Talk | contribs) (→Some real examples) |
Benmachine (Talk | contribs) |
||

(2 intermediate revisions by one user not shown) | |||

Line 46: | Line 46: | ||

<haskell> |
<haskell> |
||

instance Functor (Cont r) where |
instance Functor (Cont r) where |
||

− | fmap f (Cont g) = -- ... |
+ | fmap f (Cont x) = -- ... |

</haskell> |
</haskell> |
||

Well, we've got to build a <hask>Cont</hask> value, and those always start the same way: |
Well, we've got to build a <hask>Cont</hask> value, and those always start the same way: |
||

<haskell> |
<haskell> |
||

− | fmap f (Cont g) = Cont $ \rest -> -- ... |
+ | fmap f (Cont x) = Cont $ \rest -> -- ... |

</haskell> |
</haskell> |
||

− | Now what? Well, remember what <hask>g</hask> is. It comes from inside a <hask>Cont</hask>, so it looks like <hask>\rest -> stuffWith (rest val)</hask>, where <hask>val</hask> is the 'value' of the computation (what would be bound with <hask><-</hask>). So we want to give it a <hask>rest</hask>, but we don't want it to be called with the 'value' of the computation - we want <hask>f</hask> to be applied to it first. Well, that's easy: |
+ | Now what? Well, remember what <hask>x</hask> is. It comes from inside a <hask>Cont</hask>, so it looks like <hask>\rest -> stuffWith (rest val)</hask>, where <hask>val</hask> is the 'value' of the computation (what would be bound with <hask><-</hask>). So we want to give it a <hask>rest</hask>, but we don't want it to be called with the 'value' of the computation - we want <hask>f</hask> to be applied to it first. Well, that's easy: |

<haskell> |
<haskell> |
||

fmap f (Cont x) = Cont $ \rest -> x (\val -> rest (f val)) |
fmap f (Cont x) = Cont $ \rest -> x (\val -> rest (f val)) |
||

Line 132: | Line 132: | ||

</haskell> |
</haskell> |
||

− | In <hask>faff</has>, the <hask>return</hask> statement is run with <hask>test = n</hask>: if it succeeds then we subtract 10 from the result and return it. If it fails we try again, but with <hask>(2*n)</hask>: note that if this succeeds, we don't subtract 10. |
+ | In <hask>faff</hask>, the <hask>return</hask> statement is run with <hask>test = n</hask>: if it succeeds then we subtract 10 from the result and return it. If it fails we try again, but with <hask>(2*n)</hask>: note that if this succeeds, we don't subtract 10. |

− | As an exercise, work out how to make the function return: |
+ | As an exercise, see if you can work out, without using <tt>ghci</tt>, how to make the function return: (a) <tt>Nothing</tt>, (b) <tt>Just 12</tt>, (c) <tt>Just 0</tt>. |

− | # <tt>Nothing</tt> |
||

− | # <tt>Just 12</tt> |
||

− | # <tt>Just 0</tt> |
||

− | (just mapping it over a large range and filtering the results is discouraged!) |
||

=== Acknowledgements === |
=== Acknowledgements === |

## Latest revision as of 21:34, 20 January 2012

## Contents |

## [edit] 1 A practical Cont tutorial

It seems to me like**Warning:** I'm going to use some metaphors here, like the `Magic` type, that probably shouldn't be interpreted perfectly literally. Try to understand the gist, rather than worrying about the details.

contstuff :: Magic contstuff = do thing1 thing2 -- Now I want to manipulate the rest of the computation. -- So I want a magic function that will give me the future to -- play with. magic $ \rest -> -- 'rest' is the rest of the computation. Now I can just do it, -- or do it twice and combine the results, or discard it entirely, -- or do it and then use the result to do it again... it's easy to -- imagine why this might be useful. messAboutWith rest thing3 -- these might get done once, several times, thing4 -- or not at all.

x <- magic $ \rest -> -- ... thingInvolving x

*this*looks familiar...

newtype Cont r a = Cont { runCont :: (a -> r) -> r } -- Magic = Cont r a magic = Cont

Tada! The moral of the story is, if you got up one morning and said to yourself "I want to stop in the middle of a do-block and play about with the last half of it", then `Cont` is the type you would have come up with.

Now you know what the `Cont` type is, you can implement pretty much all of its type class instances just from there, since the types force you to apply this to that and compose that with this. But that doesn't really help you to understand what's going on: here's a way of using the intuition introduced above to implement `Functor` without thinking about the types too much:

instance Functor (Cont r) where fmap f (Cont x) = -- ...

fmap f (Cont x) = Cont $ \rest -> -- ...

fmap f (Cont x) = Cont $ \rest -> x (\val -> rest (f val))

instance Applicative (Cont r) where pure x = Cont $ \rest -> -- ...

We don't want to do anything special here. The rest of the computation wants a value, let's just give it one:

pure x = Cont $ \rest -> rest x

Cont f <*> Cont x = Cont $ \rest -> -- ...

Cont f <*> Cont x = Cont $ \rest -> f (\fn -> x (\val -> rest (fn val)))

### [edit] 1.1 So what's callCC?

"Call with current continuation". Basically, you useret <- callCC $ \exit -> do -- A mini Cont block. -- You can bind things to ret in one of two ways: either return -- something at the end as usual, or call exit with something of -- the appropriate type, and the rest of the block will be ignored. when (n < 10) $ exit "small!" when (n > 100) $ exit "big!" return "somewhere in between!"

*too*much: they will tell you

*what*to write, but not

*why*. Think instead about the strategies we used above, and what each bit

*means*. Hints: remember that

### [edit] 1.2 What about ContT?

The thing to understand with*think*the following definition works fine:

newtype ContT r m a = ContT (Cont (m r) a) deriving (Functor, Applicative, Monad) runContT :: ContT r m a -> (a -> m r) -> m r runContT (ContT m) = runCont m

### [edit] 1.3 Some real examples

I find he examples in the mtl doc unconvincing. They don't do anything genuinely daring, and some of them don't use the features of `Cont` at all – they work in any monad! Here's a more complex example:

-- This tends to be useful. runC :: Cont a a -> a runC c = runCont c id faff :: Integer -> Maybe Integer faff n = runC $ do test <- Cont $ \try -> case try n of Nothing -> try (2*n) res -> fmap (subtract 10) res return $ if test < 10 then Nothing else Just test

As an exercise, see if you can work out, without using `ghci`, how to make the function return: (a) `Nothing`, (b) `Just 12`, (c) `Just 0`.

### [edit] 1.4 Acknowledgements

I think it was the legendary sigfpe who made this click for me, after thinking about how this works:

and there's also this:

which is more-or-less the above trick but in a bit more detail.