====== Haskell Lecture 6 ======

types, definitions of functions, pattern matching, lists, basic built-in functions and operators: :load, :type (:t)

<code haskell>
fact :: Integer -> Integer
fact n = if n == 0 then 1 else n*(fact (n-1))

fact1 n | n==0 = 1
	| otherwise = n*(fact1 (n-1))

fact'' 0 = 1
fact'' n = n*(fact'' (n-1))

</code>
<code haskell>
	
data MyColor = Red | Green | Blue

-- some sort of list of MyColor
data MyListColor = CCons MyColor MyListColor | EmptyListColor

data MyList a = Cons a (MyList a) | EmptyList

</code>
<code haskell>
[1..100]     -- list of numbers from 1 to 100 with step 1.
[1,3..100]   -- list of odd numbers from  1 to 100 (with step 2)
[2,4..100]   -- list of even numbers from  2 to 100 (with step 2)
[1..]        -- list of all numbers from 1 with step 1
[1,3..]      -- list of all odd numbers from 1 (with step 2)

</code>
<code haskell>
 
-- QuickSort in Haskell:
quicksort [] = []
quicksort (e:ls) = (quicksort [x|x<-ls,x<e]) ++ [e] ++ (quicksort [x|x<-ls,x>=e])

</code>

====== Haskell Lecture 7 ======
lambda terms, curryfication, graphical syntax, @, let, where, type classes (class, instance, deriving), basic built-in type classes (Eq, Ord, Num, Show), :info (:i), lazy evaluation

<code haskell>
-- Example of lambda term
Main> map (\ x -> -x) [1..10]
[-1,-2,-3,-4,-5,-6,-7,-8,-9,-10]

-- Example of curryfication of -
Main> map ((-) 0) [1..10]
[-1,-2,-3,-4,-5,-6,-7,-8,-9,-10]

-- Example of curryfication of infix -
Main> map (0-) [1..10]
[-1,-2,-3,-4,-5,-6,-7,-8,-9,-10]

-- Example of let 
Main> let minus = (0-) in map minus [1..10]
[-1,-2,-3,-4,-5,-6,-7,-8,-9,-10]

-- Example of let
Main> let {minus = (0-); ls = [1..10]} in map minus ls
[-1,-2,-3,-4,-5,-6,-7,-8,-9,-10]

-- Example of where
Main> map minus ls where {minus = (0-); ls = [1..10]}
[-1,-2,-3,-4,-5,-6,-7,-8,-9,-10]
</code>

<code haskell>
msort [] = []
msort [x] = [x]
msort ls = merge sas sbs where
        (xs,ys) = split ls where
        	split [] = ([],[])
        	split [x] = ([x],[])
        	split (x:y:ls) = ((x:xs),(y:ys)) where
        		(xs,ys) = split ls
	sas = msort xs
	sbs = msort ys
	merge [] ls = ls
	merge ls [] = ls
	merge ws@(x:xs) zs@(y:ys) | (x<=y) = (x : merge xs zs)
	                          | otherwise = merge zs ws 

-- Example:
Main> :t msort
msort :: Ord a => [a] -> [a]

Main> msort [6,4,1,3]
[1,3,4,6]
</code>

<code haskell>
-- automated instantiation of Eq, Ord, and Show class for NTree type using: deriving
data NaryTree a = NaryNode a [NaryTree a] | NaryLeaf a deriving (Eq,Ord,Show)


-- Example:
Main> :t NaryNode 1 [NaryLeaf 2]
NaryNode 1 [NaryLeaf 2] :: Num a => NaryTree a

Main> NaryNode 2 [NaryLeaf 2] == NaryNode 1 [NaryLeaf 2]
False

Main> NaryNode 2 [NaryNode 2] <= NaryNode 1 [NaryLeaf 2]
False

Main> NaryNode 1 [NaryLeaf 2]
NaryNode 1 [NaryLeaf 2]
</code>

<code haskell>
data NaryTree a = NaryNode a [NaryTree a] | NaryLeaf a

numberLeafs (NaryLeaf _) = 1
numberLeafs (NaryNode _ ls) = sum [numberLeafs x| x <- ls]

-- custom instantiation of Eq, Ord, and Show class for NaryTree type using: instance
instance (Eq a) => Eq (NaryTree a) where
	x == y = numberLeafs x == numberLeafs y

instance (Ord a) => Ord (NaryTree a) where
	x <= y = numberLeafs x <= numberLeafs y

instance (Show a) => Show (NaryTree a) where
	show (NaryLeaf x) = "<" ++ (show x) ++ ">"
	show (NaryNode x ls) = "{" ++ (show x) ++ ":" ++ (show ls) ++ "}"


-- Example:
Main> :t NaryNode 1 [NaryLeaf 2]
NaryNode 1 [NaryLeaf 2] :: Num a => NaryTree a

Main> NaryNode 2 [NaryLeaf 2] == NaryNode 1 [NaryLeaf 2]
True

Main> NaryNode 2 [NaryNode 2] <= NaryNode 1 [NaryLeaf 2]]
True

Main> NaryNode 1 [NaryLeaf 2]
{1:[<2>]}

</code>

<code haskell>
-- custom definition of some class W with one function w
class W a where
	w :: a -> Bool

-- instantiation of class W for type NTree a
instance W (NaryTree a) where
	w (NaryLeaf _) = True 
	w _ = False
</code>