22.10.

2013

OCaml - elemente de limbaj (recapitulare)

OCaml - elemente de limbaj (recapitulare)

Funcii
n ML putem defini expresii de tip funcie: fun x -> x + 3. Acestea pot fi aplicate ca atare: (fun x -> x +
3) 2este 5, sau transmise ca parametru: List.map (fun x -> x + 3) [1;2;4]e lista [4; 5; 8].
Definiiile let f x = x + 3i let f = fun x -> x + 3sunt echivalente (prima e mai scurt i cu sintax
mai familiar).
ML are, strict vorbind, doar funcii cu un singur parametru, ceea ce e suficient. O funcie "cu mai muli parametri"
let add x y = x + ye de fapt doar o scriere simplificat pentru let add = fun x -> fun y -> x + y
. S-a definit de fapt o funcie care, aplicat primului parametru xreturneaz o funcie, care aplicat nc unui
parametru yproduce suma. Putem deci aplica parial o funcie la mai puini parametri dect cei din definiie, i
obinem o funcie (care se poate apoi aplica mai departe).
let add3 = add 3 (* adica fun y -> 3 + y *)
add3 2 (* rezult 3 + 2 = 5 *)

Aplicarea funciei (apelul de funcie) e asociativ la stnga, deci add 2 3nseamn (add 2) 3, consistent cu
cele explicate mai sus: se evalueaz add 2, care returneaz o funcie, care e apoi aplicat lui 3.
Notaia obinuit din matematic f (x, y) = x + yproduce n ML altceva, o funcie cu un singur
parametru, care e o pereche (n notaia uzual cu paranteze i virgul). Funcia addde mai sus are tipul int ->
int -> int(funcie de ntreg care returneaz int -> int, adic o funcie de ntre, iar funcia fare tipul int
* int -> int: e definit pe produsul cartezian int * int(perechi de ntregi) cu valori ntregi.

Potrivirea de tipare
n OCaml, potrivirea de tipare e un mecanism foarte expresiv; ne ajut s scriem cod concis, iar compilatorul
verific dac am tratat toate cazurile. Prin potrivirea de tipare identificm valori cu o anumit structur (liste,
perechi, etc.), i dm nume elementelor componente, pe care le folosim pentru a calcula valori (rezultatul dorit).
Sintaxa general e
match expresie0 with
| tipar1 -> rezultat1
| tipar2 -> rezultat2
...

Aceasta e o expresie care, n funcie de valoarea lui expresie0are unul din rezultatele indicate; acestea trebuie
s fie de acelai tip. Una din cele mai frecvente erori este de a ncerca s dm rezultate de tipuri diferite.
Compilatorul va raporta eroarea: This expression has type tip2 but an expression was
expected of type tip1

ncercarea tiparelor se face n ordine; se va ajunge la tiparul 2 doar dac tiparul 1 nu s-a potrivit, etc. Deci,
dac avem tipare cu valori comune, ordinea scrierii lor conteaz!
Bara |indic nceputul fiecrui tipar; primul |e opional.
bigfoot.cs.upt.ro/~marius/curs/lsd/ocaml-intro.html

1/3

22.10.2013

OCaml - elemente de limbaj (recapitulare)

Putem avea i mai multe tipare cu acelai rezultat: | tipar1 | ... | tiparN -> rezultat.
Ilustrm potrivirea prin tipare n cteva funcii simple (cum toate calculele n ML se fac n funcii). Cea mai simpl
potrivire de tipare se face pe constante:
let not b = match b with
| false -> true
| true -> false

Am definit astfel negaia boolean, o funcie bool -> bool. Dealtfel, noteste un operator predefinit n ML.
Mai sus, singura folosire a argumentului ba fost pentru potrivirea de tipare: match b with. Mai departe,
numele bnu a fost folosit. Acelai tipar se poate scrie mai simplu:
let not = function
| false -> true
| true -> false

Cuvntul cheie functiondefinete o funcie, dar argumentul ei nu este numit (spre deosebire de fun x ->
...), ci e identificat prin tiparele care urmeaz. Citim: note o funcie care dac ia argumentul false
returneaz true, etc.
Folosim deci functionpentru funciile la care facem potrivire de tipare pe ultimul argument (pe care nu l mai
indicm n lista de argumente, altfel funcia va avea un argument n plus!).
Fiecare parte din tiparul potrivit primete (e legat de) un nume care poate fi folosit ulterior n expresia
rezultatului.
Potrivirea de tipare se face dup structuravalorii (constant, sau compus din elemente: pereche, list, etc.);
nu n funcie de o relaie pe acea valoare. Nu putem scrie deci
let sign = function
| n > 0 -> 1

dar putem scrie

let sign = function
| 0 -> 0 (* tipar cu valoare constanta *)
| n -> if n > 0 then 1 else -1

Fiecare nume poate aparrea o singur dat n tipar: nu putem identifica o list cu primele dou elemente egale
cu:
| h :: h :: t -> ...

Putem ns folosi condiia when:

| e1 :: e2 :: t when e1 = e2 -> rezultat1
| e1 :: e2 :: t -> rezultat2

Cum tiparele se evalueaz n ordine, al doilea tipar, dei nu are nicio condiie suplimentar, se va potrivi doar
pentru elemente diferite (adic atunci cnd nu s-a potrivit tiparul 1).
Desigur se poate folosi i testul n expresia rezultat:
| e1 :: e2 :: t -> if e1 = e2 then ... else ...

Putem indica prin tipare i structura parametrilor unei funcii, ca n exemplul urmtor, unde tiparul spune c
bigfoot.cs.upt.ro/~marius/curs/lsd/ocaml-intro.html

2/3

22.10.2013

OCaml - elemente de limbaj (recapitulare)

argumentul funciei e o pereche. Funcia returneaz o pereche cu elementele n ordine invers (interschimbate):
let swap (x, y) = (y, x)

Marius Minea
Last modified: Mon Oct 14 23:10:00 EEST 2013

bigfoot.cs.upt.ro/~marius/curs/lsd/ocaml-intro.html

3/3