sameTwoP :: Parser (Char, Char)

sameTwoP =  twinCharP 'a'
        <|> twinCharP 'b'
        <|> twinCharP 'c'
          -- ...

itemP :: Parser Char  -- parse one of any Char

oneMore :: Char -> Parser (Char, Char)
oneMore c = addC <$> charP c
    where addC = \x -> (c, x)

sameTwoP = combiner itemP oneMore

combiner :: Parser Char
         -> (Char -> Parser (Char, Char))
         -> Parser (Char, Char)

foo :: a -> Maybe b
bar :: b -> Maybe c

foo :: a -> Maybe b
bar :: b -> Maybe c
baz :: c -> Maybe d

foobarbaz :: a -> Maybe d
foobarbaz x = case foo x of
              Nothing -> Nothing
              Just y  -> case bar y of
                         Nothing -> Nothing
                         Just z  -> case baz z of
                                    Nothing -> Nothing
                                    Just w  -> Just w

foo :: a -> (b, String)
bar :: b -> (c, String)

foobar :: a -> (c, String)
foobar x = let (y, log1) = foo x in
             let (z, log2) = bar y in
               (z, log1 ++ log2)

foo :: a -> (b, String)
bar :: b -> (c, String)
baz :: c -> (d, String)

foobarbaz :: a -> (c, String)
foobarbaz x = let (y, log1) = foo x in
                let (z, log2) = bar y in
                  let (w, log3) = bar y in
                    (w, log1 ++ log2 ++ log3)

-- Input: init counter. Output: updated counter + output string
foo :: Int -> (Int, String)
bar :: Int -> (Int, String)

-- Input: init counter. Output: updated counter + output string
foo :: Int -> (Int, String)
bar :: Int -> (Int, String)
baz :: Int -> (Int, String)

foobarbaz :: Int -> String
foobarbaz c = let (c', out') = foo c in
                let (c'', out'') = bar c'' in
                  let (c''', out''') = bar c''' in
                    out'''

class Applicative m => Monad m where
  return :: a -> m a                 -- Required op. 1: return
  (>>=)  :: m a -> (a -> m b) -> m b -- Required op. 2: bind

  (>>)   :: m a -> m b -> m b        -- Special case of bind

data WithLog a = MkWithLog (a, String)

data State s a = MkState (s -> (a, s))

foo :: a -> Maybe b
bar :: b -> Maybe c
baz :: c -> Maybe d

foobarbaz :: a -> Maybe d
foobarbaz x = case foo x of
              Nothing -> Nothing
              Just y  -> case bar y of
                         Nothing -> Nothing
                         Just z  -> case baz z of
                                    Nothing -> Nothing
                                    Just w  -> Just w

foo :: a -> Maybe b
bar :: b -> Maybe c
baz :: c -> Maybe d

foobarbaz :: a -> Maybe d
foobarbaz x = foo x >>= (\y ->
                bar y >>= (\z ->
                  baz z >>= (\w ->
                    return w)))

do var <- monVal
   ...

foobarbaz x = foo x >>= (\y ->
                bar y >>= (\z ->
                  baz z >>= (\w ->
                    return w)))

foobarbaz x = do y <- foo x
                 z <- bar y
                 w <- baz z
                 return w

foobarbaz x = do y <- foo x
                 z <- bar y
                 w <- baz z
                 return w

foobarbaz x = do { y <- foo x ;
 z <- bar y ; w <- baz z ;
        return w }

data Either a b = Left a | Right b

type OrErr a = Either String a  -- give type a new name

actualInt :: OrErr Int
actualInt = Right 5000  -- Actual number 5000

errorInt :: OrErr Int
errorInt = Left "Couldn't think of a number"  -- Error string

concat :: [[a]] -> [a]

map :: (a -> b) -> [a] -> [b]

data Parser a  = MkParser (String -> Maybe (a, String))

data State s a = MkState  (s      ->       (a, s))