ES. 1
Pixel p ::= <r,g,b>, r,g,b in {0,1,...,255}
Identificatori I ::= ...
Espressioni e ::= I | p | lighten e | darken e | let I = e1 in e2
Lighten produce un pixel in cui ogni componente è incrementata di 1; incremento di 255 = 255.
Darken produce un pixel in cui ogni componente è decrementata di 1; decremento di 0 = 0.
Si definisca l'interprete.
Codice: Seleziona tutto
type 't env = (string * 't) list;;
type pixel = { r : int; g : int; b : int};;
type ide = string;;
type expr =
Int of int
|Pixel of pixel
|Ide of ide
|Lighten of expr
|Darken of expr
|Let of expr * expr * expr
let rec lookup (x : ide) (env : expr env) =
match env with
[] -> failwith "error"
|(y,g)::r -> if x=y then g else lookup x r;;Codice: Seleziona tutto
let rec sem (e: expr) (env : expr env) =
match e with
Ide x -> lookup x env
|Int i -> i
|Pixel p -> match (sem p env) with
(r : int, g : int, b : int) -> (sem r env, sem g env, sem b env)
| _ -> failwith "Wrong type"
|Lighten p -> match p with
(r : int, g : int, b : int) -> (if r<255 then r+1 else r, if g<255 then g+1 else g, if b<255 then b+1 else b)
|_ -> failwith "Wrong type"
|Darken p -> match (sem p env) with
(r : int, g : int, b : int) -> (if r>0 then r-1 else r, etc)
|_ -> failwith "Wrong type"
|Let (id, e1, e2) -> let val = sem e1 env in
let new_env = (id, val)::env in
sem e2 new_env;;ES. 2
let x = v;;
let f1 = fun z -> z*x;;
let f2 = fun z -> let x = 2 in (f1 z) * x;;
f2 4;;
Il valore di v per cui il programma produce come risultato 40 è 5, no? con scoping statico, intendo.
Punto 2: Si descriva lo stato dello stack dei record di attivazione nella simulazione della valutazione del programma.
Va bene così? (linee piene a sinistra: link catena dinamica; linee tratteggiate a destra: link catena statica)
