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 21:19] – [3.2 Chequeo de tipos] 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. Nota: ''run-p-sl'' es similar a ''run-sl'', pero utilizando la función ''interp-p'' implementada en la parte 1.
Line 14: 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 25: 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 75: Line 75:
  
 <note important> <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.  +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 \\ 
-Por ejemplo, ''{lazy Num} -> Num'' **no** es compatible con ''Num -> Num'', pero \+
 ''{lazy {Num -> Num}}'' sí es compatible con ''Num -> Num''. ''{lazy {Num -> Num}}'' sí es compatible con ''Num -> Num''.
 </note> </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 89: 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>