関手 - Functor

class Functor f where
    fmap :: (a -> b) -> f a -> f b

Bifunctor

Profunctor

Contravariant

Representable Functor

class Functor f => Representable f where
  type Log f
  lookup   :: f a -> (Log f -> a)
  tabulate :: (Log f -> a) -> f a

  -- 米田の補題によりtabulateと同型
  positions :: f (Log f)
  tabulate h = fmap h positions
  positions  = tabulate id

Applicative

class Functor f => Applicative f where
    pure :: a -> f a
    (<*>) :: f (a -> b) -> f a -> f b

Day convolution

Free Applicative

Discrimination

自然変換

type (~>) f g = forall x. f x -> g x

モナド

「環」の理論を知らなくても整数の足し算掛け算が出来るように、モナドの数学的な側面を知らなくてもモナドを使うことは出来る。

盲目の男たちがいました。彼らは象を知ったばかりでした。

1人は「あれば大木だ」と両足を腕で包みながら言いました。
もう1人は「あれば大蛇だ」と胸を包みながら言いました。
3人目の男は「うーん」と言いながら、ほうきか扇か何かを想像しました。

出典: モナドは象だ

まずは、型クラスと高階関数を使ってプログラムを書いてみてください。そうすれば、モナドは自然と使えるようになるよ、というのが今日の私の主張です。

出典: 初心者のモナド

class Monad m where
  return :: a -> m a
  (>>=)  :: m a -> (a -> m b) -> b

do x <- mx
   y <- my
   z

-- ... desugars to:
mx >>= (\x ->
my >>= (\y ->
z ))

出典: How to desugar Haskell code

Maybe Monad

Either Monad

List Monad

instance Monad [] where
  return x = [x]
  xs >>= f = concat (map f xs)

LogicT

Reader Monad

newtype Reader e a = Reader { runReader :: (e -> a) }

instance Monad (Reader e) where
    return a         = Reader $ \e -> a
    (Reader r) >>= f = Reader $ \e -> runReader (f (r e)) e

Writer Monad

随伴

今回は話の中でいきなりWriterとReaderが出てきて、この2つで随伴になると説明しましたが、実際はStateモナドやStoreコモナドからこの2つの関手を導くことができますです。 随伴がモテないのはどう考えてもモナドが悪い！（モナドとコモナドの関係が分かる話）

State Monad

newtype State s a = State { runState :: s -> (a, s) }

instance Monad (State s) where
  return a = State $ \s -> (a, s)
  m >>= k  = State $ \s ->
               let (a, s') = runState m s
               in runState (k a) s'

RWS Monad

Reader + Writer + State

ST Monad

IO Monad

乱数

Monad*

MonadFail

MonadPlus

MonadBase

MonadIO

MonadThrow

MonadCatch

MonadMask

MonadFix

Indexed Monad

Super Monad

Arrow

Others