-- :help
-- :set prompt "λ> "

-- :r (:reload) pentru reîncărcarea sursei
-- :! com -- pentru rularea unei comenzi a sistemului de operare
--   (e.g. :! clear / :! cls  sau  :! ls / :! dir)
-- :t add1  -- (:type) -- află tipul oricărei expresii
-- :t (+) -- pentru operatori trebuie dați în forma prefixată

-- :: înseamnă "are tipul"
-- v :: <ceva> => tip     = v are tipul tip, în contextul de tip <ceva>

-- de asemenea:
-- :i add1 -- (:info)
-- funcționează și pentru operatori, e.g. :i +

-- încarc cu
-- stack exec ghci <nume-fisier>

-- Funcții

-- \ stă pentru lambda

add1 :: Num t => t -> t -> t
add1 = \x y -> ((+) x y)

-- în Haskell toate funcțiile sunt funcții curry

add2 = \x -> \y -> (((+) x) y)

add3 = \x y -> x + y

-- PATTERN MATCHING

add4 x y = x + y

-- (define (plus x y) (+ x y))

add5 = (+)

-- p-m incomplet (non-exhaustiv)

addX 1 2 = 5
addX 1 x = x + 1
addX 5 6 = 11

-- în Haskell toți identificatorii încep cu literă MICĂ
-- în Haskell CONTEAZĂ INDENTAREA

len1 l = if l == [] then 0 else 
        1 + len1 (tail l)

-- pattern-matching
len2 [] = 0
len2 (h:t) = 1 + len2 t
-- "dacă len2 este aplicat pe o listă care a fost obținută prin aplicarea lui :
-- între ceva și altceva, atunci leagă ceva la h și leagă altceva la t și evaluează
-- corpul"
-- parantezele sunt puse doar pentru asociativitate

-- p-m face o legare a variabilelor din pattern în așa fel încât să se potrivească cu valoarea parametrului actual
-- când apelez len2 [1,2,3], haskell leagă în așa fel încât [1,2,3] să fie rezultatul expresiei h:t
-- "ce ar trebui să fie h și t astfel încât h:t -> [1,2,3]

-- paranteză: acces în triplete
el1 (a,b,c) = a
el2 (a,b,c) = b
el3 (a,b,c) = c

-- twisted length
len2b [] = 0
len2b [x] = x
len2b (h1:h2:_) = 5

-- \> len2b [last [1..], last [1..], 3, 4]


len3 l = case l of
  [] -> 0
  otherwise -> 1 + len3 (tail l)

len3a l = case l of [] -> 0 ; otherwise -> 1 + len3a (tail l)

-- let <legări> in <expr>   este o expresie
len3b l = let t = tail l in case l of
  [] -> 0
  _ -> 1 + len3b t

-- gărzile sunt legate de un =
-- în gărzi pot pune condiții complete (în case pot pune doar patter-match pe valoarea unei variabile, după care fac case)
-- where se folosește împreună cu un = sau cu o serie de gărzi
len4 l
    | l == [] = 0
    | otherwise = len4 t + 1
    where t = tail l
    
len4a l | null l = 0 | True = len4a t + 1 where t = tail l