module Sample where

comp :: (b->c, a->b) -> (a->c)
comp (f,g) y = f (g y)

swap :: (a,b) -> (b,a)
swap (x,y) = (y,x)

assocr :: ((a,b),c) -> (a,(b,c))
assocr ((x,y),z) = (x,(y,z))

distr :: (a, Either b c) -> Either (a,b) (a,c)
distr (x, Left  y) = Left (x,y)
distr (x, Right y) = Right (x,y)

coswap :: Either a b -> Either b a
coswap (Left  y) = Right y
coswap (Right y) = Left  y

undistr :: Either (a,b) (a,c) -> (a, Either b c)
undistr (Left  (y,z)) = (y, Left  z)
undistr (Right (x,z)) = (x, Right z)

data Nat = Zero | Succ Nat deriving Show

plus :: (Nat, Nat) -> Nat
plus (Zero,   z) = z
plus (Succ n, z) = Succ (plus (n,z))

mult :: (Nat, Nat) -> Nat
mult (Zero,   x) = Zero
mult (Succ n, x) = plus (x, mult (n, x))

fact :: Nat -> Nat
fact Zero = Succ Zero
fact (Succ n) = mult (Succ n, fact n)

len :: [a] -> Nat
len []    = Zero
len (h:t) = Succ (len t)

fib :: Nat -> Nat
fib Zero            = Succ Zero
fib (Succ Zero)     = Succ Zero
fib (Succ (Succ x)) = plus (fib x, fib (Succ x))

cat :: [a] -> [a] -> [a]
cat []    l = l
cat (h:t) l = h:(cat t l)

data Tree a = Leaf | Node a (Tree a) (Tree a) deriving Show

inorder :: Tree a -> [a]
inorder Leaf = []
inorder (Node x l r) = cat (inorder l) (x:(inorder r))