Esta tarea se distribuye con un archivo zip ( base) que contiene 4 archivos: main_p1.rkt, tests_p1.rkt, main_p2.rkt y tests_p2.rkt. Los archivos están incompletos, y en ellos tienen que implementar lo que se solicita en las preguntas siguientes.
Deben entregar via U-cursos un archivo .zip que contenga los archivos main_p1.rkt, tests_p1.rkt, main_p2.rkt y tests_p2.rkt.
¡Los tests, los contratos y las descripciones forman parte de su evaluación!
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
.
A continuación se presenta la sintaxis del lenguaje extendido (se omiten las del lenguaje base):
<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>}
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:
field not found exception
.method not found exception
.constructor not found exception
.null
, o realizar una operación (como adición), debe lanzar el error null pointer exception
.same arity constructor exception
Veamos algunos ejemplos de clases y objetos en acción:
;; 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
;; 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
;;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"
;; 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
;; 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"
;; 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"
Extienda su lenguaje con herencia simple, incluyendo field shadowing y llamados con super
. Asegúrese de estudiar la sección de herencia del OOPLAI1) para comprender la semántica deseada.
La sintaxis extendida es:
<expr> ::= ... (todo lo anterior) ... ;; Cambio para incluir superclase | {class [: <expr>] {<id>*} <method>*} | {super <id> <expr>*}
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.
;; 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
super
3).;; 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
> (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
Nota:
super
solo pueden ocurrir desde los métodos.Object
en el ambiente inicial de ejecución.