Differences

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

Link to this comparison view

Next revision		Previous revision
teaching:cc4101:tareas:2022-1:tarea3 [2022/06/07 16:48] – created rodrigo.urreateaching:cc4101:tareas:2022-1:tarea3 [2023/06/14 20:55] (current) – [Tarea 3 (Entrega: 9 de julio de 2023)] rodrigo.urrea
Line 8: Line 8:
  
 **¡Los tests, los contratos y las descripciones forman parte de su evaluación!** **¡Los tests, los contratos y las descripciones forman parte de su evaluación!**
 +
 +====== Resumen ======
 +
 +El objetivo de la tarea es extender un lenguaje base para soportar clases y objetos. El lenguaje base tiene números, booleanos y operaciones sobre ellos. Además contiene expresiones ''begin''y ''with'' para definir múltiples identificadores, pero  no tiene soporte para funciones. Tome un tiempo de experimentar con el lenguaje entregado antes de comenzar a implementar las extensiones requeridas.
 + 
 +
 +La tarea está dividida en 2 secciones,  las cuales se describen a continuación:
 +
 +- **Clases y objetos**: En esta sección se pide extender el lenguaje base con clases y objetos. En particular las clases deben ser entidades de primera clase, es decir, son valores del lenguaje.
 +
 +- **Herencia Simple **: El objetivo de esta sección es extender el lenguaje con herencia simple, incluyendo //field shadowing// y llamados con ''super''.
 +
 +===== Clases y objetos (3,0 ptos.) =====
 +A continuación se presenta la sintaxis del lenguaje extendido (se omiten las del lenguaje base): 
 +<code scheme>
 +<expr> ::= ... (expresiones del lenguaje entregado) ...
 +        | {class {<id>*} <method>*}
 +        | {new <expr> <expr>*}
 +        | {get <expr> <id>}
 +        | {set <id> <expr>}
 +        | {-> <expr> <id> <expr>*}
 +        | self
 +        | null
 + 
 +<method> ::= {def <id> {<id>*} <expr>}
 +
 +</code>
 +Donde:
 +  * ''class'' permite crear una nueva clase anónima, con una lista de identificadores para los campos y 0 o más de métodos.
 +  * ''new'' permite crear una instancia de una clase dada, dada una lista de argumentos para un constructor (ver más abajo). 
 +  * ''get'' permite acceder a un campo de un objeto dado.
 +  * ''set'' permite modificar un campo de un objeto. Solamente es válido usar ''set'' dentro del cuerpo de un método y para modificar campos propios del objeto desde donde se llama. No es posible modificar campos de un objeto externo.
 +  * ''->'' permite invocar un método de un objeto dado, con 0 o más argumentos.
 +  * ''self'' permite acceder al objeto actual. Solamente es válido usar ''self'' dentro del cuerpo de un método.
 +  * ''def'' permite definir un método, donde se especifica el nombre del método, 0 o más parámetros, y el cuerpo del método.
 +  * ''null'' es un valor especial que se usa únicamente como valor por defecto de los campos de un objeto; cualquier operación sobre ''null'' es un error en tiempo de ejecución.
 + 
 +Además, para la creación de un objeto, los constructores son simplemente métodos llamados ''init''. Cuando se ejecuta un ''new'', se selecciona el constructor que corresponda al número de argumentos pasados (error si no hay ninguno que calza). Si no hay ningún constructor declarado, solo se puede usar ''(new c)'' sin argumentos. Definir varios constructores con la misma aridad es un error (//en tiempo de creación de la clase//).
 +
 +**Extienda el lenguaje para soportar estas expresiones, donde tanto clases y objetos son valores.** Usted debe decidir los atributos que tendrán sus respectivos nodos en el AST. Modifique el parser y el intérprete para soportar el lenguaje extendido.
 +Además, los errores deben manejarse de la siguiente forma:
 +  * El acceso a un campo inexistente de un objeto debe arrojar el error ''field not found exception''.
 +  * La invocación de un método inexistente debe lanzar el error ''method not found exception''.
 +  * La creación de un objeto con un número invalido de argumentos debe lanzar el error ''constructor not found exception''.
 +  * Invocar un método sobre ''null'', o realizar una operación (como adición), debe lanzar el error ''null pointer exception''.
 +  * Al crear una clase con 2 o más constructores de igual aridad, debe lanzar el error ''same arity constructor exception''
 +
 +Veamos algunos ejemplos de clases y objetos en acción:
 +
 +
 +<code scheme>
 +;; comportamiento esperado
 +> (run-val '{with {{c {class {x y}
 +                        {def init {}
 +                          {begin {set x 1} {set y 2}}}
 +                        {def init {init-x init-y}
 +                          {begin {set x init-x} {set y init-y}}}  
 +                        {def sum {z} {+ {get self x} {+ {get self y} z}}}
 +                        {def set-x {val} {set x val}}}}
 +                   {o {new c {3 4}}}}
 +              {begin
 +                {-> o set-x {+ 1 3}}
 +                {+ {-> o sum 3} {get o y}}}})
 +15
 +</code>
 +
 +<code scheme>
 +;; las clases son valores
 +> (run-val '{with {{A {class {}
 +                        {def apply {c} {-> {new c} m}}}}
 +                   {o {new A}}}
 +              {-> o apply {class {x}
 +                            {def init {} {set x 2}}
 +                            {def m {} {get self x}}}}})
 +2
 +</code>
 +
 +
 +<code scheme>
 +;;la definición de la clase tiene scope léxico
 +> (run-val '{begin {with {{A {class {x}
 +                               {def init {} {set x 2}}
 +                               {def init {init-x} {set x init-x}}
 +                               {def m {} {get self x}}}}}
 +                     10}
 +                   {new A}})
 +"free identifier: A"
 +</code>
 +
 +<code scheme>
 +;; los identificadores dentro de una clase tienen scope léxico 
 +;; (note el uso de la “x” en la definición del método “m”
 +> (run-val '{with {{x 10}
 +                   {A {class {}
 +                        {def m {y} {+ x y}}}}
 +                   {o {new A}}}
 +              {-> o m 1}})
 +11            
 +</code>
 +
 +<code scheme>
 +;; no se pueden repetir los constructores con mismo número de parámetros
 +> (run-val '{begin {with {{A {class {x y}
 +                               {def init {init-x init-y} 
 +                                 {begin {set x init-x} {set y init-y}}}
 +                               {def init {init-x init-y} 
 +                                 {begin {set x 12} {set y 3}}}
 +                               {def init {init-x} {set x init-x}}
 +                               {def m {} {get self x}}}}}
 +                     10}
 +                   {new A}})
 +"error: same arity constructor exception"
 +</code>
 +
 +<code scheme>
 +;; Una clase sin constructores puede ser creado solo con {new class}, sin argumentos
 +> (run-val '{with {{x 10}
 +                 {A {class {z}
 +                      {def m {y} {+ x y}}}}
 +                 {o {new A {x}}}}
 +              {-> o m 1}})
 +"error: constructor not found exception"
 +</code>
 +
 +===== Herencia Simple (3,0 ptos.) =====
 +Extienda su lenguaje con herencia simple, incluyendo //field shadowing// y llamados con ''super''. Asegúrese de estudiar la sección de herencia del OOPLAI(([[http://users.dcc.uchile.cl/~etanter/ooplai/Inheritance.html|Inheritance]])) para comprender la semántica deseada.
 +
 +La sintaxis extendida es: <code scheme>
 +<expr> ::= ... (todo lo anterior) ...
 +         ;; Cambio para incluir superclase
 +         | {class [: <expr>] {<id>*} <method>*} 
 +         | {super <id> <expr>*}
 +</code>
 +Se modifica la forma ''class'' para incluir un parametro opcional donde irá la superclase de la clase que se crea. En caso de no incluir una superclase, se debe extender la clase raíz ''Object'', que usted tendrá que definir.
 +  - (1.0) Implemente la búsqueda de métodos (([[http://users.dcc.uchile.cl/~etanter/ooplai/Inheritance.html#%28part._.Method_.Lookup%29|Method Lookup]])) correspondiente a la herencia <code scheme>
 +
 +;; el método f se busca en c y luego en su superclase
 +> (run-val '{with {{c1 {class {}
 +                       {def f {z} {< z 7}}}}
 +                 {c {class : c1 {}}}
 +                 {o {new c}}}
 +              {-> o f 20}})
 +#f
 +</code>
 +  - (1.0) Implemente el soporte para llamados con ''super'' (([[http://users.dcc.uchile.cl/~etanter/ooplai/Inheritance.html#%28part._.Super_.Sends%29| Super sends]])).<code scheme>
 +;; llamada a super de método no definido en el padre directo
 +(run-val '{with {{c2 {class {}
 +                       {def h {x} {+ x 1}}}}
 +                 {c1 {class : c2 {}
 +                       {def f {} #f}}}
 +                 {c {class : c1 {}                     
 +                       {def g {} {super h 10}}}}
 +                 {o {new c}}}
 +            {-> o g}})
 +11
 +</code>
 +  - (1.0) Implemente la semántica de field shadowing (([[http://users.dcc.uchile.cl/~etanter/ooplai/Inheritance.html#%28part._.Field_.Shadowing%29|Field Shadowing]])) para sobreescritura de campos. <code scheme>
 +> (run-val '{with {{A {class {x y}
 +                        {def init {} {begin {set x 1} {set y 0}}}
 +                        {def ax {} {get self x}}}}
 +                 {B {class : A {x}
 +                        {def init {} {set x 2}}
 +                        {def bx {} {get self x}}}}
 +                 {b {new B}}}
 +              {-> b ax}})
 +1
 +</code>
 +Nota:
 +  * Los llamados con ''super'' solo pueden ocurrir desde los métodos.
 +  * No olvide incluir a la clase ''Object'' en el ambiente inicial de ejecución.
 +