fpc-15-11-2017.hs

 import Control.Monad

-- filter :: (a -> Bool) -> [a] -> [a]
-- replicate :: Int -> a -> [a]

filter' :: (a -> Bool) -> [a] -> [a]
filter' f m = do
  x <- m
  {-
  True <- return (f x)
  return x
  -}
  if f x
  then return x
  else []

replicate' :: Int -> a -> [a]
replicate' n x = do
  _ <- [1..n]
  return x

-- (>>=), return
fmap' :: Monad m => (a -> b) -> m a -> m b
fmap' f ma = ma >>= return . f

fmap'' :: Monad m => (a -> b) -> m a -> m b
fmap'' f ma = do
  x <- ma
  return $ f x

-- (>>=), return
ap' :: Monad m => m (a -> b) -> m a -> m b
ap' mf ma = do
  f <- mf
  a <- ma
  return $ f a

ap'' mf ma = mf >>= \f -> ma >>= \a -> return (f a)

-- (>>=)
(>==>) :: Monad m => (a -> m b) -> (b -> m c) -> (a -> m c)
f >==> g = \x -> f x >>= g

-- return >=> g    = g
-- f >=> return    = f
-- (f >=> g) >=> h = f >=> (g >=> h)
--
-- return >=> g = g
-- \x -> return x >>= g = g
-- 1. return a >>= g = g a
--
-- f >=> return = f
-- \x -> f x >>= return = f
-- 2. f a >>= return = f a
--
-- (f >=> g) >=> h = f >=> (g >=> h)
-- \x -> (f >=> g) x >>= h = \x -> f x >>= (g >=> h)
-- (f >=> g) a >>= h = f a >>= (g >=> h)
-- (\x -> f x >>= g) a >>= h = f a >>= (\x -> g x >>= h)
-- (f a >>= g) >>= h = f a >>= (\x -> g x >>= h)
-- 3. (m >>= g) >>= h = m >>= (\x -> g x >>= h)

-- (>>=)
join' :: Monad m => m (m a) -> m a
join' mma = mma >>= id

(>=^=>) :: Monad m => (a -> m b) -> (b -> m c) -> (a -> m c)
f >=^=> g = \x -> join' (fmap g (f x))