What's a Monad

Basically a reprint from https://vimeo.com/152110601

The motivation is to pass some info down the stack, but without the tedious syntax of extra arguments. The gist, as I understand, is to capture the extra argument in a function, treated as a single argument (function as first-class citizen), and pass that down the stack.

Still, the function-as-monad thing isn’t very intuitive; container metaphor serves me pretty mostly.

import Prelude hiding ((>>=), return)

-- f :: Int -> Int
-- f x =
--   let r = g x
--    in r

-- g :: Int -> Int
-- g x =
--   let r = h x
--    in r

-- h :: Int -> Int
-- h x = x


-- f :: Int -> Bool -> Int
-- f x y =
--   let r = g x y
--    in r

-- g :: Int -> Bool -> Int
-- g x y =
--   let r = h x y
--    in r

-- h :: Int -> Bool -> Int
-- h x y = if y then x else x

-- type MyBool a = Bool -> a

-- f :: Int -> MyBool Int
-- f x y =
--   let r = g x y
--    in r

-- g :: Int -> MyBool Int
-- g x y =
--   let r = h x y
--    in r

-- h :: Int -> MyBool Int
-- h x y = if y then x else x

type MyBool a = Bool -> a

(>>=) :: MyBool a -> (a -> MyBool b) -> MyBool b
l >>= f = \x -> f (l x) x

return :: a -> MyBool a
return x _ = x

f :: Int -> MyBool Int
f x =
  (g x) >>=
    (\r -> return r)

g :: Int -> MyBool Int
g x =
  (h x) >>=
    (\r -> return r)

h :: Int -> MyBool Int
-- h x y = if y then x else x
h x = ask >>= (\y -> return $ if y then x else x)

ask :: MyBool Bool
ask = id

main = undefined