sig Monad where
  type t : * -> *
  return : a -> t a
  bind   : t a -> (a -> t b) -> t b

return : { M : Monad } -> a -> M.t a
return x = M.return x

(>>=) : { M : Monad } -> M.t a -> (a -> M.t b) -> M.t b
(>>=) x f = M.bind x f

map : { M : Monad } -> M.t a -> (a -> b) -> Mt. b
map m f = m >>= (\ x -> return (f x))

join : { M : Monad } -> M.t (M.t a) -> M.t a
join m = m >>= id

unless : { M : Monad } -> Bool -> M.t () -> M.t ()
unless True  _ = return ()
unless False m = m

implicit struct MonadOpen where
  type t a = Option a
  return = Some
  bind (Some x) f = f x
  bind None     _ = None

implicit struct MonadList where
  type t a = List a
  return x = [x]
  bind x f = concat (map f x)