Documentation

>>> import Prelude (Int, pure, Maybe(Just, Nothing), const, replicate, String)
>>> import Control.Arrow (Kleisli(Kleisli), runKleisli)

>>> runKleisli (Kleisli pure *** Kleisli pure) (1,2) :: [(Int, Int)]
[(1,2)]

>>> runKleisli (Kleisli pure *** Kleisli pure) (1,2) :: Maybe (Int, Int)
Just (1,2)

>>> runKleisli (Kleisli pure *** Kleisli (const Nothing)) (1,2) :: Maybe (Int, Int)
Nothing

>>> runKleisli (Kleisli (replicate 2) *** Kleisli (replicate 3)) ("a","b") :: [(String, String)]
[("a","b"),("a","b"),("a","b"),("a","b"),("a","b"),("a","b")]

>>> import Prelude (Int, pure, Maybe(..), const, replicate, String, (+), (++), Functor, Show, show, (==), (-))
>>> import Control.Comonad (Cokleisli(Cokleisli), runCokleisli, extract, duplicate, (=>=))
>>> import Control.Comonad.Store (store, seek, runStore, Store, StoreT)
>>> import Control.Category ((>>>))

>>> runCokleisli (Cokleisli extract *** Cokleisli extract) (store (\x -> (x + 1, x + 2)) 3) :: (Int, Int)
(4,5)

>>> :{
up :: Int -> Cokleisli (Store Int) Int Int
up n = Cokleisli $ \st -> let (ws, s) = runStore st in ws (s + n)
:}

>>> runCokleisli ((up 3 *** up 5) >>> (up 2 *** up 4)) (store (\x -> (x + 1, x + 2)) 0) :: (Int, Int)
(6,11)

>>> runCokleisli ((up 3 >>> up 2) *** (up 5 >>> up 4)) (store (\x -> (x + 1, x + 2)) 0) :: (Int, Int)
(6,11)

>>> :{
data Stream a = Cons a (Stream a)
tail :: Stream a -> Stream a
tail (Cons _ xs) = xs
instance Show a => Show (Stream a) where
  show (Cons x0 (Cons x1 (Cons x2 (Cons x3 (Cons x4 _))))) = show [x0, x1, x2, x3, x4] ++ "..."
instance Functor Stream where
  fmap f (Cons x xs) = Cons (f x) (fmap f xs)
instance Comonad Stream where
  extract (Cons x _ ) = x
  duplicate xs = Cons xs (duplicate (tail xs))
:}

>>> :{
dup :: a -> (a, a)
dup x = (x, x)
naturals :: Int -> Stream Int
naturals n = Cons n (naturals (n + 1))
take :: Int -> Stream a -> a
take n (Cons x xs) = if n == 0
  then x
  else take (n - 1) xs
:}

>>> naturals 0
[0,1,2,3,4]...

>>> take 5 (naturals 0)
5

>>> ((take 3) =>= (take 4)) (naturals 0)
7

>>> runCokleisli (Cokleisli (take 3) *** Cokleisli (take 4)) (fmap dup (naturals 0)) :: (Int, Int)
(3,4)

>>> streamN n = Cokleisli (take n)

>>> runCokleisli ((streamN 3 *** streamN 5) >>> (streamN 2 *** streamN 4)) (fmap dup (naturals 0)) :: (Int, Int)
(5,9)

>>> runCokleisli ((streamN 3 >>> streamN 2) *** (streamN 5 >>> streamN 4)) (fmap dup (naturals 0)) :: (Int, Int)
(5,9)

>>> import Prelude (Int, pure, Maybe(Just, Nothing), const, replicate, String)
>>> import Control.Arrow (Kleisli(Kleisli), runKleisli)

>>> runKleisli (Kleisli pure *** Kleisli pure) (Left "a") :: [Either String Int]
[Left "a"]

>>> runKleisli (Kleisli pure *** Kleisli pure) (Right 1) :: Maybe (Either String Int)
Just (Right 1)