Funcție curry - o funcție care își primește parametrii pe rând
Dacă funcția are mai mulți parametri (e.g. vreau să fac o adunare) atunci apelul pe un parametru va întoarce o altă funcție de un singur parametru (și așa mai departe)

Funcție uncurry -- își primește toți parametrii odată


Utilitatea funcții curry: apeluri parțiale


Funcționale -- funcții care iau alte funcții ca argument

(filter f L)
  f are un singur argument
  L listă de n elemente e1...en
  întoarce (ei, f(ei) != #f)
  întoarce lista cu acele elemente din L pentru care f nu întoarce #f
  
  *apelează f de n ori*
  *rezultatul este format doar din elemente din L*
  *fiecare element este verificat independent de celelalte*
  
  
(map f L)
  f are un singur argument
  L listă de n elemente e1...en
  întoarce o listă de n elemente de forma:
    (list (f e1) (f e2) ... (f en))
  nu putem face ca prelucrarea unui element din listă să depindă de un alt element din listă
  
  *apelează f de n ori*
  *rezultatul este format doar din rezultate de apeluri de f*
  *fiecare element este prelucrat independent de celelalte*

(map f L1 L2 ... Lm) ->
  unde L1 = (list e11 e12 ... e1n)
  cu |L1| = |L2| = ... = |Lm| = n
  și f ia m argumente (funcție uncurry)

  (list (f e11 e21 ... em1)
        (f e12 e22 ... em2)
        ...
        (f e1n e2n ... emn))

(apply f L)
  cu L = (list e1 .. en)
  și cu f o funcți de n argumente
  
  apply realizează apelul:
  (f e1 e2 ... en)
  
  *! nu realizează o prelucrare iterativă*
  
  apelează f o *singură* dată
  
  funcționează doar pe funcții *stricte*.
  
(apply f a1 ... am L)
  => (f a1 a2 ... am e1 e2 ... en)
  



foldl / foldr
	realizarea unei prelucări iterative arbitrare fără funcții recursive explictii

	(foldl f v0 L)
	f funcție de 2 argumente
	L este (list e1 ... en)
	
	întoarce:
	(f en ... (f e3 (f e2 (f e1 v0)))...)
	
	foldr întoarce:
	(f e1 (f e2 (... (f en v0)...)))
	
	*fold aplează f de n ori*
	*și întoarce rezultatul unui apel de f*