-- Polymorphic twice

twice :: (a -> a) -> a -> a
twice x y = x (x y)

inc :: Int -> Int
inc x = x + 1

doubleVec :: (Float,Float) -> (Float,Float)
doubleVec (x,y) = (2*x,2*y)

applyn :: Int -> (a -> a) -> a -> a
applyn 0 _ x = x
applyn n f x = f (applyn (n-1) f x)

-- twice inc :: Int -> Int
-- twice twice :: (a -> a) -> a -> a

-- Polymorphic tuples

firstOf3 :: (a,b,c) -> a
firstOf3 (x,_,_) = x

-- Polymorphic vector

type Vector3 a = (a,a,a)

vecx :: Vector3 a -> a
vecx (x,_,_) = x

vecy :: Vector3 a -> a
vecy (_,y,_) = y

vecz :: Vector3 a -> a
vecz (_,_,z) = z

vecCoord :: Int -> Vector3 a -> a
vecCoord 1 (x,_,_) = x
vecCoord 2 (_,y,_) = y
vecCoord 3 (_,_,z) = z

-- Polymorphic tree

data BiTree a = Leaf a | BiTree a (BiTree a) (BiTree a)

-- Type classes

square :: Num a => a -> a
square x = x * x

minP :: Ord a => a -> a -> a
minP a b | a <= b = a
         | a >  b = b

maxP :: Ord a => a -> a -> a
maxP a b | a >= b = a
         | a <  b = b

fact :: (Num a,Ord a) => a -> a
fact 0 = 1
fact n | n > 0 = n * fact (n - 1)
       | n < 0 = error "Negative number!"

maxCoord :: Ord a => Vector3 a  -> a
maxCoord (a,b,c) | a >= b && a >= c = a
                 | b >= a && b >= c = b
                 | otherwise = c

maxCoord1 :: Ord a => Vector3 a  -> a
maxCoord1 (a,b,c) = max a (max b c)

-- Search in polymorphic tree

hasValueB :: Eq a => BiTree a -> a -> Bool
hasValueB (Leaf v) x = v == x
hasValueB (BiTree v l r) x = v == x || hasValueB l x || hasValueB r x

-- Polymorphic search tree

data SearchTree a = EmptyTree | SearchTree a (SearchTree a) (SearchTree a)

hasValueS :: Ord a => SearchTree a -> a -> Bool
hasValueS EmptyTree _ = False
hasValueS (SearchTree i t1 t2) x | i > x = hasValueS t1 x
                                 | i < x = hasValueS t2 x
                                 | otherwise = True

-- Either

data Either a b = Left a | Right b

-- Left 1 :: Num a => Either a b
-- Right 'a' :: Either a Char