Linguaggi di Programmazione (4 Ottobre 2013)

Esercizio 1
Definire formalmente la nozione di sostituzione nel λ-calcolo.
Effettuare la seguente sostituzione e ridurre il termine ottenuto, se possibile, in forma normale.

((λw.(xw))(λy.(yx)))[λx.(w(xy))/x]

Esercizio 2
Cosa restituisce Haskell se forniamo all'interprete la seguente espressione?

:type (>>=)

Quando viene utilizzato in Haskell l'operatore >>= ?

Esercizio 3
Si considerino i due seguenti processi PICT.

run ( x!y
    | x?z = z!u
    | y?w = print!"Got it!"
    )


run ( x!y
    | x?z = a!z
    | a?w = print!"Got it!"
    )

Tali processi, se eseguiti isolatamente, hanno lo stesso effetto. Giustificare tale affermazione.
Definire poi un processo PICT che si comporti in modo differente a seconda che il primo o il secondo dei processi precedenti viene utilizzato come sottoprocesso.
Giustificare la risposta.

Esercizio 4
Definire il Session Type che fornisce la descrizione parziale (dal punto di vista del Bancomat) del protocollo di interazione tra un cliente ed un Bancomat su un canale.

Esercizio 5
Il seguente modulo Erlang permette di calcolare una funzione map che restituisce lo stesso valore della funzione Haskell

map f [] = []

map f (x:xs) = (f x):(map f xs)

ma in modo tale che ogni valore della lista di output viene calcolato da un processo (Actor) differente.

-module(mapfun).
-export([map/2,compute/3]).


collectRes([]) -> [];

collectRes([ID|IDs]) -> receive
                           {ID,Res} -> [Res|collectRes(IDs)]
                        end.


map(_,[]) -> [];

map(F,List) ->

         ComputingActors = [spawn(mapfun,compute,[F,X,self()]) || X <- List ], 
         
         collectRes(ComputingActors).                             



compute(F,X,Collector) -> Res = F(X),
                          Collector!{self(),Res}.

Modificare il modulo Erlang in modo che i risultati vengano ricevuti dalla funzione collectRes in qualsiasi ordine e poi riordinati correttamente.

Esercizio 6
Cosa si intende per Subtyping Polymorphism?
Le due seguenti funzioni OCaml hanno lo stesso body, ma comportamenti differenti. Perche?

let bumpd1 (p:< get_x : int; get_y : int; setcoord : int -> int -> unit >)     
             = p#setcoord (p#get_x +1) (p#get_y +1);;

let bumpd2 p = p#setcoord (p#get_x +1) (p#get_y +1);;

Definire un elemento myPoint tale che bump2 myPoint risulti un'applicazione corretta, mentre bump1 myPoint no.
C'e' un modo per poter applicare correttamente la funzione bump1 all'argomento myPoint? Giustificare.

Linguaggi di Programmazione (4 Ottobre 2013)