Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision		Previous revision
teaching:cc4101:tareas:2025-1:tarea2:parte3 [2025/05/11 15:25] – msegurteaching:cc4101:tareas:2025-1:tarea2:parte3 [2025/05/14 17:03] (current) – [3.3 Transformación a CL] dibanez
Line 5: Line 5:
 En esta sección van a extender el lenguaje SL para que se pueda especificar la estrategia de evaluación de cada argumento si es necesario, ya sea con semántica //call-by-need// o //call-by-name//.  En esta sección van a extender el lenguaje SL para que se pueda especificar la estrategia de evaluación de cada argumento si es necesario, ya sea con semántica //call-by-need// o //call-by-name//. 
  
-La extensión de SL consiste en agregar //modificadores// a los tipos declarados por las funciones funciones, los que especifican el tipo de estrategia a utilizar para los argumentos. A continuación les proveemos una ilustración de este mecanismo y qué es lo que debieran obtener al finalizar esta sección. +La extensión de SL consiste en agregar //modificadores// a los tipos declarados por las funciones, los que especifican qué estrategia se debe utilizar para los argumentos. A continuación les proveemos una ilustración de este mecanismo y qué es lo que debieran obtener al finalizar esta sección.  
 + 
 +Nota: ''run-p-sl'' es similar a ''run-sl'', pero utilizando la función ''interp-p'' implementada en la parte 1.
 <code scheme> <code scheme>
 ;; Una función de tipo Num -> Num significa que se aplicará con evaluación temprana. ;; Una función de tipo Num -> Num significa que se aplicará con evaluación temprana.
Line 12: Line 14:
 (result 20 '("10"))   ;; Se imprime una vez, al evaluar el argumento en la aplicación (result 20 '("10"))   ;; Se imprime una vez, al evaluar el argumento en la aplicación
  
-;; Una función de tipo (lazy Num -> Num), usará evaluación lazy/call-by-need para su argumento.+;; Una función de tipo ((lazy Num) -> Num), usará evaluación lazy/call-by-need para su argumento.
 > (run-p-sl '{with {f {fun {x : {lazy Num}} -> Num : {+ x x}}}    > (run-p-sl '{with {f {fun {x : {lazy Num}} -> Num : {+ x x}}}   
                      {f {printn 10}}})                      {f {printn 10}}})
 (result 20 '("10"))   ;; Se imprime una vez cuando se usa el argumento dentro del cuerpo (result 20 '("10"))   ;; Se imprime una vez cuando se usa el argumento dentro del cuerpo
  
-;; Una función de tipo (name Num -> Num), usará evaluación name/call-by-name para su argumento.+;; Una función de tipo ((name Num) -> Num), usará evaluación name/call-by-name para su argumento.
 > (run-p-sl '{with {f {fun {x : {name Num}} -> Num : {+ x x}}}  > (run-p-sl '{with {f {fun {x : {name Num}} -> Num : {+ x x}}} 
                      {f {printn 10}}})                      {f {printn 10}}})
Line 23: Line 25:
  
 ;; Otro ejemplo de lazy. Note que efectivamente al evaluarla se comporta correctamente. ;; Otro ejemplo de lazy. Note que efectivamente al evaluarla se comporta correctamente.
-> (run-p-sl '{with {f {fun {x : {lazy Num} -> Num : 1}}}   +> (run-p-sl '{with {f {fun {x : {lazy Num}} -> Num : 1}}   
                      {f {printn 10}}})                      {f {printn 10}}})
 (result 1 '())   ;; No se imprime porque el argumento nunca se usa dentro del cuerpo (result 1 '())   ;; No se imprime porque el argumento nunca se usa dentro del cuerpo
Line 71: Line 73:
    
   * (0.2 ptos) Implemente la función ''compatible?'' que, dados dos tipos, determina si son compatibles, es decir, iguales sin considerar sus modificadores.   * (0.2 ptos) Implemente la función ''compatible?'' que, dados dos tipos, determina si son compatibles, es decir, iguales sin considerar sus modificadores.
 +
 +<note important>
 +La función ''compatible?'' sólo debe comprobar la compatibilidad //top-level//, es decir, fuera el modificador exterior, los tipos deben ser iguales. \\ 
 +Por ejemplo, ''{lazy Num} -> Num'' **no** es compatible con ''Num -> Num'', pero \\ 
 +''{lazy {Num -> Num}}'' sí es compatible con ''Num -> Num''.
 +</note>
 +
   * (0.1 ptos) Actualice ''type-ast'' para que considere tipos compatibles, en vez de iguales.   * (0.1 ptos) Actualice ''type-ast'' para que considere tipos compatibles, en vez de iguales.
-  * (0.1 ptos) Escriba tests que demuestran el buen funcionamiento del typechecker en presencia de modificadores. 
  
 ---- ----
Line 79: Line 87:
  
 Ahora que el lenguaje soporta tipos con modificadores, es necesario implementar las semánticas correspondientes. Esto se va a realizar en la transformación de un programa SL a un programa CL. Ahora que el lenguaje soporta tipos con modificadores, es necesario implementar las semánticas correspondientes. Esto se va a realizar en la transformación de un programa SL a un programa CL.
-  * (1.0 pto) Modifique la función de transformación para que se apliquen los ajustes necesarios. +  * (1.4 pto) Modifique la función de transformación para que se apliquen los ajustes necesarios. 
-  * (0.3 ptos) Escriba tests, usando lo implementado en la Parte 1, que evidencien la nueva funcionalidad. Considere todos los casos posibles (incluyendo con funciones de orden superior!).+ 
 +<note important> 
 +Asegúrese de realizar los ajustes apropiados en el caso ''if''.  
 +</note>
  
 <note tip> <note tip>
Line 88: Line 99:
   * Si se requiere una evaluación temprana y el argumento fue declarado lazy o by-name, entonces es necesario ajustarlo para que efectivamente se evalúe en ese punto.   * Si se requiere una evaluación temprana y el argumento fue declarado lazy o by-name, entonces es necesario ajustarlo para que efectivamente se evalúe en ese punto.
   * Si tanto la función como el argumento calzan en la estrategia, entonces no hay nada que hacer.   * Si tanto la función como el argumento calzan en la estrategia, entonces no hay nada que hacer.
-  * Recuerde que la diferencia entre lazy (a.k.a. by-need) y by-name es que la primera evalúa una sola vez la expresión y luego "recuerda" el valor para próximos usos. Acuérdese de lo realizado en la Parte 2 con funciones memoizadas!+  * Recuerde que la diferencia entre lazy (a.k.a. by-need) y by-name es que la primera evalúa una sola vez la expresión y luego "recuerda" el valor para próximos usos. Le puede ser útil lo realizado en la Parte 2 con funciones memoizadas!
  
 </note> </note>