shade: A control structure used to combine heterogenous types with delayed effects.

{-# LANGUAGE MultiParamTypeClasses #-}
module Main ( main ) where

import Data.Functor.Identity
import Control.Monad

import Control.Monad.Shade

A shade can be used to save heterogeneous types in containers with the same type e.g. using a type-class as a common denominator:

showshade :: Applicative m => Show a => a -> Shade m String
showshade a = pure (show a)

hetero :: Shade Identity String
hetero = mconcat [ showshade () , showshade 2 , showshade "hej" ]

The values inside a shade are stored in a context. We can swap this context by defining a transfer function:

idToIO :: Identity b -> IO b
idToIO (Identity v) = putStrLn "Transferring" *> pure v

The context is switched using transfer and we can access the value in this new context by using shadow:

runInIO :: Shade Identity a -> IO a
runInIO = shadow . transfer idToIO

The point to note about this example is that the values are stored in an shades with the identity as context. We can manipulate this context including the value. We cannot, however inspect the value since it is universally quantified.

noisy :: String -> Shade Identity (IO ())
noisy s = pure (putStrLn s)

main :: IO ()
main = do
  r <- runInIO hetero
  putStrLn r
  join . runInIO . mconcat . map (noisy . show) $ [0..10]