Monadic Call/CC?

[Ashley Yakeley]

>Given this:
>
>    class (Monad m) => PeirceMonad m where
>	      	{
>	      	peirceM :: ((a -> m b) -> m a) -> m a;
>	      	};
>
>...which Monads can be made PeirceMonads?

Here's one:

    data ContMonad p a = MkContMonad ((a -> p) -> p);
    
    unContMonad (MkContMonad app) = app;
    
    instance Monad (ContMonad p) where
        {
        return a = MkContMonad (\cont -> cont a);
        
        (MkContMonad ma) >>= bf = MkContMonad (\cont -> ma (\a -> 
unContMonad (bf a) cont));
        };
    
    instance PeirceMonad m where
        {
        peirceM foo = MkContMonad (\cont -> unContMonad (foo (\a -> 
MkContMonad (\_ -> (cont a)))) cont);
        };
    
    doContMonad :: ContMonad p p -> p;
    doContMonad cm = unContMonad cm id;
    
    test1 = doContMonad (peirceM (\continuation -> do
        {
        continuation 1;
        continuation 2;
        continuation 3;
        })); -- returns 1
 
Now here's the interesting thing. The usual way to represent "real-world" 
functions (i.e. with side-effects, or changing the world) from a to b is 
to define a special _type constructor_, 'IO', and define the function as 
'a -> IO b'. But an alternative, would have been to define a special 
_type_, Action, and define the function as 'a -> (b -> Action) -> 
Action'. And then your 'main' function has type 'Action'.

Nor do we have to declare special >>= and return functions as we do for 
IO.

Here's how it's equivalent:
   
    type Action = IO ();
    
    type ActionMonad = ContMonad Action;
    
    doActionMonad :: ActionMonad () -> Action;
    doActionMonad cm = unContMonad cm return;
    
    liftIO :: IO a -> ActionMonad a;
    liftIO ioa = MkContMonad (\cont -> ioa >>= cont);

...and note that we get Peirce continuations for free:

    peirce foo cont = foo (\a _ -> (cont a)) cont; -- constructors removed


-- 
Ashley Yakeley, Seattle WA