Edición de «Final 22/12/2014 (Paradigmas)»

1) Extender el cálculo Lambda con referencias para que soporte cosas del tipo <math>for(i:=M_1|M_2|M_3)</math>. Te dejaba usar un for'(M|M') como auxiliar.

Aximoas de tipado:

<math>\frac{\Gamma |> M_1 : Nat, \Gamma \cup \{i: Ref Nat\} |> M_2 : Bool, \Gamma \cup \{i: Ref Nat\} |> M_3 : Unit}{\Gamma |> for(i:=M1|M2|M3) : Unit}</math>

Semántica operacional:

<math>\frac{M_1|\mu \rightarrow M_1'|\mu'}{for(i:=M_1|M_2|M_3)|\mu \rightarrow for(i:=M_1'|M_2|M_3)|\mu'}</math>


<math>\frac{.}{for(i:=V|M_2|M_3)|\mu \rightarrow for'(M_2|M_3)|(\mu \oplus \{i \leftarrow v\})}</math>

Esto es porque si reducimos <math>M_2</math> entonces siempre va a evaluar a lo mismo y o no corre o no termina el for.

<math>\frac{.}{for'(M_2|M_3)|\mu \rightarrow if M_2 then M_3;for'(M_2|M_3) else unit | \mu}</math>

Algoritmo de inferencia

<math>W(U_1) = \Gamma_1 |> M_1 : \sigma</math>

<math>W(U_2) = \Gamma_1 |> M_2 : \tau</math>

<math>W(U_3) = \Gamma_1 |> M_3 : \rho</math>

<math>S = mgu(\sigma = Nat, \tau = Bool, \rho = Unit)</math> (falta ver que los tipos de la misma variable en distintos contexto sean el mismo tipo y que i sea de tipo ref Nat en <math>\Gamma_2</math> y <math>\Gamma_3</math>.

<math>(for(i:=U_1|U_2|U_3)) = S\Gamma_1 \cup S\Gamma_2 \cup S\Gamma_3 |> for(i:=M_1|M_2|M_3) : Unit</math>

2) Escribir en prolog la función esCamino(+Path,+Graph,+NodoInicial) donde Graph es lista de ejes.

esCamino([N],G,N).

esCamino([A,B|C],G,A) :- member((A,B),G), esCamino([B|C],G,B).

3) ¿Es tipable foldr map? ¿Qué representa foldr map?

foldr :: (a -> b -> b) -> b -> [a] -> b
map :: (a->b) -> [a] -> [b] 

Entonces podemos reemplazar por

foldr :: ((a->a) -> [a] -> [a]) -> [a] -> [a->a] -> [a]
map :: (a->a) -> [a] -> [a]

y foldr map va a tener tipo [a] -> [a->a] -> [a]

El resultado de foldr map va a ser aplicarle las funciones de la lista [a->a] una atrás de la otra (como foldr) a los elementos de la lista [a] (como map).

Por ejemplo, foldr map [0,1] (+1,+2,+3) va a hacer [0,1] -> [1,2] -> [3,4] -> [6,7].
@@ Línea 49: / Línea 49: @@
 Por ejemplo, foldr map [0,1] (+1,+2,+3) va a hacer [0,1] -> [1,2] -> [3,4] -> [6,7].
-------------------------------------------------------------
-Eso es lo que me tomó a mí, a algunos les tomó Curry y Uncurry (dar las funciones, los tipos de las mismas, dar ejemplos), también les tomó algo parecido al de for pero con árboles binarios que tenían un tipo en los nodos internos y otro en las hojas, por ejemplo: Bin A B := Hoja A | Nodo B (Bin A B) (Bin A B).
-También tomó algo de resolución bastante sencillo por lo que me dijeron y algo de armar un árbol de Prolog.