{-|
Main> :type 7
7 :: Num a => a
Main> :type 6.7
6.7 :: Fractional a => a
Main> :type pi
pi :: Floating a => a
Main> :type True
True :: Bool
Main> :type "t3634"
"t3634" :: String
Main> :type ["t3634","gdsg"]
["t3634","gdsg"] :: [[Char]]
Main> :type ["t3634","gdsg",3]
ERROR - Cannot infer instance
*** Instance   : Num [Char]
*** Expression : ["t3634","gdsg",3]

-}
-- eksplicitno navodjenje potpisa funkcije
addPair :: (Int,Int)->Int
addPair (x,y) = x+y 

add3Num x y z = x+y+z

add4 = (add3Num 4)  

-- neka konstantna funkcija koja predstavlja listu
l1 = [1,2,3,5]

-- lista je kompozicija konstantnih funkcija, i to binarnih
-- funkcija za dodavanje elementa na pocetak liste (:)
-- ispod zita [1,2,3,5] = 1:2:3:5:[]
-- prazna lista [] je ugradjeni vec mehanizam koji predstavjla
-- konstantnu funkciju

--len (1:(2:(3:(5:[]))))

len [] = 0
-- h se unifikuje sa 1, t se unifikuje se (2:(3:(5:[])))
len (h:t) = len t + 1

-- "_" - anonimna konstanta jer nas ne zanima
head1 (h:_) = h

take1 _ [] = []
take1 0 (h:t) = []
take1 n (h:t) = h:(take1 (n-1) t)

last1 [h] = h
last1 (h:t) = last1 t

contains1 _ [] = False
contains1 x (h:t) = if x == h then True else (contains1 x t)

eliminate min max [] = []
eliminate min max (h:t) = if (h>min && h<max) 
				then h:(eliminate min max t) 
				else (eliminate min max t)

number [] = 0
number (h:t) = (number t) * 10 + h

-- length l vraca previse specifican tip Int, a 
-- operator (/) zahteva opstiji tip Num
-- fromIntegral ga zato prebacuje iz Int-a u odgovarajuci
-- tip dinamicki
avg l = (sum l) / (fromIntegral (length l))

join [] l = l
join (h:t) l = h:(join t l)

reverse1 [] = []
-- operator (++) spaja dve liste!
-- to je ovaj join sto smo implementirali gore
reverse1 (h:t) = (reverse1 t)++[h]

suf [] = [[]]
suf (h:t) = (h:t):(suf t)