PROMENLIVI

name :: type
name = expression

FUNKCII
name :: t1 -> t2 -> ... -> tk -> t - rezultat
name x1 x2 ... xk = e...

div - div 14 3 = 4
mod - mod 14 3 = 3
abs, negate. /= not equal

ord :: Char -> Int
chr :: Int -> Char

GUARDS

'switch' == guards

name :: t1 -> t2 -> ..
name t1 t2
| <uslovie>  = <izxod>
|..
| otherwise = ...

IF THEN ELSE

if condition then m else n

VEKTORI

vektori = (....)
tipizirane - type <..> = (String ,Int, ...) - to4no n broq s to4ni tipove
a = ("aaaa",3,...)

fst (x,y) => x
snd (x,y) => y

addPair :: (Int,Int) -> Int
addPair p = fst p + snd p

addPair :: (Int,Int) -> Int
addPair (x,y) = x+y

shift :: ((Int,Int),Int) -> (Int,(Int,Int))
shift ((x,y),z) = (x,(y,z))

SPISAK

spisak - x elementa ot 1 tip
[] - prazen spisak
[a1,a2,a3 ...aX] - x elementa ot  tip a
[n .. m] = [n, n+1, ... m]

: - add an element to the front a:[b,v] = [a b v] a:b:[] => [a, b]
++ - join two lists [a]++[b,v] = [a, b, v]
!! - returns x element - [a,b,v]!!1 = b
concat - concat a list of lists [ [a] [] [b] ] to a single list [a, b]
length - real length of the list length [a, b] = 2
head
last
tail - tail [a,b,v] = [b,v]
init - bez posleden init[a,b,v] = [a,b]
replicate - replicate 3 [a] = [a,a,a]
take - slice from the front - take 2 [a,b,v,g] = [a,b]
drop - reverse take - drop 2 [a,b,v,g] = [v ,g] 
splitAt - split at position - split 2 [a,b,v,g] = ( [a,b] [v,g] )
reverse
zip - pair of lists to list of pair
unzip
and 
or
sum
product
min - po malkoto ot 2 4isla - min 2 3 = 2


LIST COMPREHENSION

[expr| q1,..,qk]
expr == map
q1 ... qk == filter
q1 = generator- p <- LExpr
q1 = test - v qi u4astvat do qi-1

ex [2,4,7]
[2*n | n <- ex] => [4,8,14]  savpada s map
[isEven n| n <- ex] => [true, true, false]
[2*n | n <- ex, isEven n, n > 3] => [8] filtrirat se ot q1 kam qk

addPairs :: [(Int,Int)] -> [Int]
addPairs pairList = [m+n | (m,n) <- pairList]
addPairs [(2,3),(2,1),(7,8)] => [5,3,15]

LOCALNI DEFINICII

a + b + c 
where
a= ...
b= ...

addPairwise’ :: [Int] -> [Int] -> [Int]
addPairwise’ intList1 intList2
= front ++ rear
where
minLength = min (length intList1)
(length intList2)
front = addPairwise front1 front2
rear = rear1 ++ rear2
(front1,rear1) = splitAt minLength intList1
(front2,rear2) = splitAt minLength intList2

LET

let x = 3+2 in x^2 + 2*x – 4 => 31
let x = 3+2; y = 5-1 in x^2 + 2*x -y - mnojestvo definicii se razdelqt s ;

OBRAZCI

literali - konkretna stoinost
promenliva - x
wildcard _ - zamestva vsi4ko
vektor (x,0) - sapostavq sprqmo dr vektor
konstruktori na spisaci - (x:xs) - uslovie za na4alo i opa6ka - 
head (x:_) = x vra6ta 1vi element
x i xs sami po sebe si mogat da sa obrazci

CASE

case e of //e = izraz  pn - obrazec en - return
p1 -> e1
p2 -> e2
...
pk -> ek


firstDigit :: String -> Char
firstDigit str
= case (digits str) of
[] -> ‘\0’
(x:_) -> x
where
digits :: String -> String
digits st = [ch | ch <- st, isDigit ch]

MAP & FILTER

map :: (a -> b) -> [a] -> [b]
map f xs = [f x| x <- xs]

filter :: (a -> Bool) -> [a] -> [a]
filter p xs = [x | x <- xs, p x]

FUNKCII KATO PARAMETRI

funk1 :: (a->b) -> c -> d
funk1 funk2 z = ....

id - identitet , vgradena funkciq
'.' - vgradeno f(g(x)) = (f.g) x

LAMBDA

\l -> .....


anonimno
doubleAll :: [Int] -> [Int]
doubleAll = map (multiply 2)

BEZKRAINI SPISACI

ones :: [Int]
ones = 1 : ones

TREE & GRAPH

data NTree = NilT |
Node Int NTree NTree

sumTree,depth :: NTree -> Int
sumTree NilT = 0
sumTree (Node n t1 t2) = n + sumTree t1 + sumTree t2

depth NilT = 0
depth (Node n t1 t2) = 1 + max (depth t1) (depth t2)

occurs :: NTree -> Int -> Int
occurs NilT p = 0
occurs (Node n t1 t2) p
| n==p = 1 + occurs t1 p + occurs t2 p
| otherwise = occurs t1 p + occurs t2 p

data Tree a = Nil | Node a (Tree a) (Tree a)
deriving (Eq,Ord,Show,Read)

numberOfElements :: Tree a -> Int
numberOfElements Nil = 0
numberOfElements (Node n leftTree rightTree)
= 1 + numberOfElements leftTree +
numberOfElements rightTree

sumOfElements :: Tree Int -> Int
sumOfElements Nil = 0
sumOfElements (Node n leftTree rightTree)
= n + numberOfElements leftTree +
numberOfElements rightTree

countLeaves :: Tree a -> Int
countLeaves Nil = 0
countLeaves (Node _ Nil Nil) = 1
countLeaves (Node _ leftTree rightTree)
= countLeaves leftTree + countLeaves rightTree

mapTree :: (a -> b) -> Tree a -> Tree b
mapTree f Nil = Nil
mapTree f (Node x tl t2)
= Node (f x) (mapTree f tl) (mapTree f t2)

onKLevel :: Tree a -> Int -> [a]
onKLevel Nil _ = []
onKLevel (Node n lt rt) 1 = [n]
onKLevel (Node _ lt rt) k
= (onKLevel lt (k-1)) ++ (onKLevel rt (k-1))

kLevelLeaves :: Tree a -> Int -> Int
kLevelLeaves Nil _ = 0
kLevelLeaves (Node _ Nil Nil) 1 = 1
kLevelLeaves (Node _ lt rt) k
= (kLevelLeaves lt (k-1)) +
(kLevelLeaves rt (k-1))

createTree :: [a] -> Tree a
createTree [] = Nil
createTree list
= Node root (createTree leftList)
(createTree rightList)
where
mid = div (length list) 2
secondPart = drop mid list
leftList = take mid list
root = head secondPart
rightList = tail secondPart