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:2023-1:tarea2:parte3 [2023/05/11 16:24] – etanterteaching:cc4101:tareas:2023-1:tarea2:parte3 [2023/05/11 16:50] (current) – [Parte 3. Estrategias de evaluación (2 ptos.)] tvallejos
Line 7: Line 7:
 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 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. 
 <code scheme> <code scheme>
-;; La función se declara de tipo (Num -> Num). Sin modificadores significa evaluación temprana. +;; Una función de tipo Num -> Num significa que se aplicará con evaluación temprana. 
-> (run-p-sl '{with {f {fun {Num -> Num} {x} {+ x x}}}   +> (run-p-sl '{with {f {fun {x : Num} -> Num : {+ x x}}}   
                      {f {printn 10}}})                        {f {printn 10}}})  
 (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
  
-;; La función se declara (lazy Num -> Num), es decir, se declara el argumento como lazy/call-by-need. +;; Una función de tipo (lazy Num -> Num), usará evaluación lazy/call-by-need para su argumento. 
-> (run-p-sl '{with {f {fun {{lazy Num} -> Num} {x} {+ 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
  
-;; La función se declara (name Num -> Num), es decir, se declara el argumento como name/call-by-name. +;; Una función de tipo (name Num -> Num), usará evaluación name/call-by-name para su argumento. 
-> (run-p-sl '{with {f {fun {{name Num} -> Num} {x} {+ x x}}} +> (run-p-sl '{with {f {fun {x : {name Num}} -> Num : {+ x x}}} 
                      {f {printn 10}}})                      {f {printn 10}}})
 (result 20 '("10" "10"))   ;; Se imprime dos veces, una por cada uso que se hace del argumento, dentro del cuerpo (result 20 '("10" "10"))   ;; Se imprime dos veces, una por cada uso que se hace del argumento, dentro del cuerpo
  
 ;; 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 {{lazy Num} -> Num} {x} 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 41: Line 41:
          | <id>          | <id>
          | {<SL> <SL>}          | {<SL> <SL>}
-         | {fun {<sym> : <mtype>} : <mtype> <SL>}  ;; note el uso de mtype (tipos con modificadores)+         | {fun {<sym> : <mtype>} → <mtype> : <SL>}  ;; note el uso de mtype (tipos con modificadores)
          | {printn <SL>}          | {printn <SL>}