module Prelude where

id x = x
const x y = x

--type Char = Prelude.Char
--type String = [Char]
--type List a = [a]
data [] a = [] | a : [a]
data () = ()

--type Bool = Prelude.Bool
data Bool = True | False
data Maybe a = Nothing | Just a
data Nat = Zero | Succ Nat
data Either a b = Left a | Right b
n = Nothing

tr = True
fa = False
not b = if b then fa else tr

add Zero b = b
add (Succ n) b = Succ (add n b)

length xs = case xs of
              [] -> Zero
	      (x:xs) -> Succ (length xs)

z = length []

foldr f z [] = z
foldr f z (x:xs) = f x (foldr f z xs)

even Zero = True
even (Succ n) = odd n

odd Zero = False
odd (Succ n) = even n

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

data App f a = App (f a)

xs = [Nothing,Just ()]

four = let z = Zero
           s x = Succ x
       in s ( s ( s (s z)))

map f [] = []
map f (x:xs) = f x:map f xs

x = id four

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

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

instance Functor Maybe where
  fmap g m = case m of
	       Nothing -> Nothing
	       Just x -> Just (g x)

instance Functor [] where fmap = map

isJust m = case m of Just x -> True ; Nothing -> False

--n' = fmap id n
ys = fmap isJust xs

class Num a where
  (+) :: a -> a -> a

infixl 6 +

instance Num Nat where
  (+) = add

double x = x+x