| Revisión actual |
Tu texto |
| Línea 1: |
Línea 1: |
| ===== Diferencia entre la regla de resolución de lógica proposicional y de lógica de primer orden. =====
| | # Diferencia entre la regla de resolución de lógica proposicional y de lógica de primer orden. |
| | | # Arbolito SLD y que ramas no se recorrían con un cut (es el arbolito que está como ejemplo de cut de SLD) |
| La respondí mal. Era algo así como que en lógica proposicional podes tomar de a un átomo, mientras que en lógica de primer orden la regla de resolución puede tomar más de un átomo (revisalo porque me equivoqué así que puedo estar equivocándome nuevamente)
| | # Qué pasa con not(not(p(X))? |
| | | # Si definieras elem :: a -> [a] -> bool con fix, como un fix M, que tipo tiene M ? |
| ===== Arbolito SLD y que ramas no se recorrían con un cut (es el arbolito que está como ejemplo de cut de SLD) =====
| | # Un seguimiento con clases C1,C2,C3,C4 donde le mandas un mensaje a C4: |
| | | # Que es que con subtipado algo sea covariante |
| La respuesta es exacta la que está en ese ejemplo
| | # Ref que es? covariante? contravariante? |
| | | # Que pierdes al agregar referencias a un cálculo lambda normalito (con bool y nat ponele) |
| ===== Qué pasa con not(not(p(X))? =====
| | # Pregunta compuesta: |
| | | ## Si tenés cálculo lambda de bool y naturales, sin el fix, podés tener recursión? |
| Si tenés sólo un hecho que es p(juan), not(p(X)) falla, porque p(X) es exitoso con X=juan. not(not(p(X)) es exitoso, pero no instancia X=juan, sólamente retorna true. Es decir, not(not(p(X)) != p(X). Cuando se refiere a que no se liga X, es lo siguiente:
| | ## Si agregás referencias pero no agregas el fix, podes tener recursión? |
| | | # Qué es método dispatch estatico vs. dinamico. |
| not(G) :- G, !, fail
| | # Para que se quiere subtipado |
| not(G).
| |
| Cuando se llama a G, es un llamado de G normal, es decir ahí sí vale que se ligan las variables (por eso not(p(X)) falla, porque p(X) es exitoso con X=juan)
| |
| Pero si G falla, entonces se descartan las sustituciones, se va a la segunda línea y el not es exitoso, sin ligar ninguna variable de G. Por eso not(not(p(X)) daría true sin ninguna instanciación.
| |
| Mandale un mail a Hernán porque me retó en el final por decirle que no lo había entendido y no mandarle consulta.
| |
| | |
| ===== Si definieras elem :: a -> [a] -> bool con fix, como un fix M, que tipo tiene M ? =====
| |
| | |
| | |
| M:\sigma->sigma
| |
| fix M: \sigma
| |
| M::(a->[a]->bool)->a->[a]->bool
| |
| La respuesta era M :: (a->[a]->bool)->a->[a]->bool
| |
| Cuando le dije ese tipo, me dijo “y si después tenés que hacer que elem tenga el mismo tipo de fix M?” Me confundió un poco eso, era simplemente decir que fix M si M es de tipo sigma en sigma, es sigma. (como escribiste arriba) fix M :: (a->[a]->bool)->a->[a]->bool
| |
| | |
| ===== Un seguimiento con clases C1,C2,C3,C4 donde le mandas un mensaje a C4: =====
| |
| | |
| C4 no tiene definido el mensaje, lo tiene C3. C3 tiene un super, entonces vas a buscar el mensaje a C2. C2 tiene un self de ese mensaje, pero como self se bindea al empezar el envío del mensaje, tenes que buscarlo en C4.
| |
| | |
| ===== Qué es que con subtipado algo sea covariante =====
| |
| | |
| Básicamente que el orden de los tipos “abajo” de la regla es el mismo que el de “arriba”. No me salía un ejemplo pero le dije que sería algo así
| |
| sigma <: tau
| |
| -----------------
| |
| algo con sigma <: algo con tau
| |
| | |
| ===== Ref que es? covariante? contravariante? =====
| |
| Solo compara tipos equivalentes (es decir covariante y contravariante al mismo tiempo)
| |
| | |
| ===== Que perdés al agregar referencias a un cálculo lambda normalito (con bool y nat ponele) =====
| |
| | |
| Dije primero que había que tener cuidado de “tipar la memoria” porque si no podías perder progreso y preservación (algo así, está mejor dicho en el resumen). Después me avivé y le dije que con referencias te salías de un lenguaje funcional “puro” porque te empiezan a importar los efectos de las operaciones y no tanto los valores. Es decir empieza a haber un “estado” del programa, que no hay en lenguajes funcionales puros. De nuevo, está mejor explicado en el resumen.
| |
| | |
| ===== Si tenés cálculo lambda de bool y naturales, sin el fix, podés tener recursión? =====
| |
| No
| |
| ===== Si agregás referencias pero no agregas el fix, podes tener recursión? =====
| |
| ACA FUE TIPO WTF?!?!?! Le dije que no, y me dijo “si porque podrías guardar funciones en las referencias dado que son valores, y con eso hacer recursión” tipo OK
| |
| | |
| ===== Qué es método dispatch estatico vs. dinamico. =====
| |
| La respuesta era super. Ponele que tenés en una clase C2 que hereda de C1 y tiene un método que llama a super, siempre se va a ir a buscar esa definición a C1. En eso se “parece” a dispatch estatico
| |
| | |
| ===== Para que se quiere subtipado =====
| |
| Dije que, por ejemplo, para no tener que redefinir operaciones para todos los tipos específicos. Es decir poder escribir algo general que aplique a muchas cosas. Igual me costó porque tuve miedo de meterme con la regla de subtipado de funciones jaja
| |
