Agent Work: Imperative Jam (Mutable References)

Claude Haiku 4.5 · COMP 411: Principles of Programming Languages

Assignment 4: Imperative Jam

Overview

Testing: Use bin/grade or the grade tool to run the test suite.

Prerequisite: This assignment builds on Assignment 3. A complete solution to Assignment 3 is provided in the assignment-3-solution-src/ folder. You must extend the Jam language from Assignment 3 by implementing new constructs that support mutable cells. The tests in Assign4Test.java exercise these extensions, but are not comprehensive.

Overview

Task Your task is to extend and modify the nine interpreters from Project 3 (using either your solution or the posted class solution for Project 3) to support imperative programming by adding ML-style reference cells and blocks. In particular, you will add the unary operators ref and !, the binary assignment operator <-, and *blocks* consisting of non-empty sequences of expressions enclosed in braces ({ and }) and separated by semicolons (the final expression in the sequence does NOT have a semicolon following it). In other words

Exp           ::= ...
                  | Block
Block         ::= '{' PropStmtList '}'
PropStmtList  ::= Exp { ; Exp}*
Unop          ::= ... | ref | !
Binop         ::= ... | <-
Prim          ::= ... | ref?

Note that a PropStatList is identical to a PropExpList except for the separator symbol ; instead of ,. You may want to exploit the commonality in your parser. We will often use the term "Stmt" instead of "Exp" because with the addition of mutable cells, evaluating an expression can modify program state (the contents of mutable cells). From a strictly syntactic viewpoint, there is no difference between statements and expressions. But we still try to use the term *statement* to refer to expressions where mutation is common and the term expression (more accurately *pure expression*) where no mutation is necessary in well-written code.

You must modify your lexer and parser to accept Blocks as well as the new unary operators ref and !, the new binary operator <-, and the new primitive function ref?. The parser and lexer for Assignment 3 already include commented-out code that supports parsing Assignment 4 Jam with the exception that the lexer must recognize ! followed by any character other than = is the unary prefix operator ! rather than a ParseException.

Adding ref cells and assignment The unary operation ref E evaluates the expression E to produce an arbitrary value V, creates a new box b holding V and returns the box b.

The unary operation ! E evaluates the expression E to produce a value which must be a box and returns the contents of the box. If the value of E is not a box, the interpreter generates a run-time error (an EvalException).

The binary operation E1 <- E2 evaluates the expression E1 to produce a value V1 that must be a box, evaluates E2 to produce an arbitrary value V2, stores V2 in box V1, and returns the special value JamUnit (which is a *legal Jam value* that is rejected by most primitive operations as an invalid input). If V1 is not a box, then the interpreter must generate a run-time error. JamUnit can conveniently be represented as singleton subclass of JamVal. If you follow this recommendation, you may need to modify the JamValVisitor interface to include a forXXXX method for JamUnit. (The class solution avoid this complication since it never uses the JamValVisitor interface. In your solution, you can delete this interface if it not used. We recommend that you use a different representation (from JamUnit) for the dummy binding value in a recursive let, and classify any attempt to access this value in the environment as a run-time error. Since attempting to access this dummy value is a run-time error, the representation of this dummy value does not need to be a JamVal. The null pointer in Java can be used to represent the dummy bound value in the implementation of recursive let; you can also introduce a special object (as long as it is not a JamVal) for this purpose.

The special value JamUnit can bound to a variable, returned by a map, and appear as an expression in a block. We recommend throwing an EvalException if JamUnit is passed as the input to any operation other than the block construct, =, and type recognizers like number?. Scheme is more liberal in its treatment of the (void) value (which is the Scheme analog of JamUnit). Scheme supports embedding (void) inside any data structure. You can follow this option in implementing Jam if you choose. (You can use DrRacket as a guide.) The behavior of JamUnit will be tested in our grading suites other than its return as the value of a block.

A box (reference cell) is a Jam value and can be returned as the result of an expression. When converted to a string, the output of a box should appear as (ref <value>). This expression

let x := ref 10; in {x <- ref 17; x}

should evaluate to the JamVal that is displayed as the string

(ref (ref 17))

in call-by-value and call-by-need. In call-by-name evaluation, your interpreter should display the string

(ref 10)

since the binding of x is re-evaluated for every occurrence.

You will have to modify your toString method to support the correct display of boxes. Equality for boxes is based on the address of the box, not the contents, i.e. the expression

let x := ref 10; y := ref 10; in x = y

evaluates to false regardless of the semantics for let (call-by-value, call-by-name, call-by-need).

The primitive function ref? acts like all other type recognizers, e.g., number?, in that it accepts one argument, which can be of any type, but only returns true if that argument is a box, and false in all other cases.

Adding blocks The block { e1; ...; en }, *n > 0*, evaluates e1, ..., en in left-to-right order and returns the value of en. The expressions e1, ..., en may evaluate to JamUnit (returned by the assignment operator) without aborting the computation. In the Jam grammar, a Block is an additional form for an expression analogous to map, if, and let. Hence, it cannot appear as the first argument in a binary expression unless it is enclosed in parentheses. The "empty block" is a parser error (a ParseException).

Optional extra credit (10 points) Devise a small set of programs that exhibits different behavior for eight of the nine modes of interpretation and run them (unless they diverge) from a unit test suite. For any test that diverges result include a commented out test case with an explanation. Your programs should not generate any run-time errors.

Testing You are expected to write unit tests for all of your non-trivial methods or functions *and submit your test code as part of your program*. For more information, refer back to Project 1.

Testing Your Program

Make sure that your program passes the sample unit tests in Assign1Test.java, Assign2Test.java, Assign3Test.java, and Assign4Test.java. You need to thoroughly test the interpretation of each new construct, notably boxes and mutation.

Each class and method in your program should be preceded by a short javadoc comment stating precisely what it does.

Please make sure to remove or disable all debugging output generated by your program. Excessive use of print statements considerably slows down your interpreter.

---

Implementation Hints

1. Lexer: Search for commented-out code handling ! and {/}. The ! token needs special handling: != is not-equals, but ! alone is dereference.

2. Parser: Look for commented-out parseBlock() or similar. Block parsing is like parseExpList() but uses ; separator.

3. AST: Add a Block class (holds AST[] expressions). Add JamRef class to ValuesTokens.java for box values. Add JamUnit singleton.

4. Interpreter: Add visitor cases for ref (create new JamRef), ! (return JamRef contents), <- (mutate JamRef, return JamUnit), and Block (eval all, return last).

5. Key insight: JamRef uses Java's reference equality (don't override equals()), so two ref 10 expressions create different boxes.

--- *COMP 411: Principles of Programming Languages, Rice University*

AST.java8.0 KB

java

/* The file defining the AST classes including the visitor interface, except for AST classes that are Token classes 
 * as well. */

/** AST ::= BoolConstant | IntConstant | EmptyConstant | Variable | PrimFun | UnOpApp | BinOpApp | App | Map | If | Let */

/** AST class definitions */

/** The AST type which support a visitor interface */
interface AST {
  public <ResType> ResType accept(ASTVisitor<ResType> v);
}

interface ASTVisitor<ResType> {
  ResType forBoolConstant(BoolConstant b);
  ResType forIntConstant(IntConstant i);
  ResType forEmptyConstant(EmptyConstant n);
  ResType forVariable(Variable v);
  ResType forPrimFun(PrimFun f);
  ResType forUnOpApp(UnOpApp u);
  ResType forBinOpApp(BinOpApp b);
  ResType forApp(App a);
  ResType forMap(Map m);
  ResType forIf(If i);
  ResType forLet(Let l);
}

/* The Term interface correspond to AST's that when output as concrete syntax by toString() can be used as terms 
 * in an iterative binary expression without enclosing parentheses. We enclose all binary expressions in parentheses
 * so we do not presume either left or right associativity for infix binary operators. */
/** Term ::= Constant | PrimFun | Variable | UnOpApp |  App */
interface Term extends AST {}

/* NOTE: all Constant objects belong to the types Token and AST; Constant tokens evaluate to themselves.
 * The variant classes (IntConstant, BoolConstant, EmptyConstant) are defined in the file ValuesTokens.java */

/** Constant ::= IntConstant | BoolConstant | EmptyConstant */
interface Constant extends Term {}

/** UnOp ::= UnOpPlus | UnOpMinus | OpTilde */
/** Class representing the unary operator within a UnOppApp. */
abstract class UnOp {
  String name;
  public UnOp(String s) { name = s; }
  public String toString() { return name; }
  public abstract <ResType> ResType accept(UnOpVisitor<ResType> v);
}

/** Visitor for the UnOp union type. */
interface UnOpVisitor<ResType> {
  ResType forUnOpPlus();
  ResType forUnOpMinus();
  ResType forOpTilde();
  // ResType forOpBang();  // Supports ref cell extension to Jam
  // ResType forOpRef();    // Supports ref cell extension to Jam
}

/** BinOp ::= BinOpPlus | BinOpMinus | OpTimes | OpDivide | OpEquals | OpNotEquals | OpLessThan | OpGreaterThan |
  *           OpLessThanOrEquals OpGreaterThanOrEquals | OpAnd | OpOr */

/** Class representing the binary operator within a BinOppApp. */
abstract class BinOp {
  String name;
  public BinOp(String s) { name = s; }
  public String toString() { return name; }
  public abstract <ResType> ResType accept(BinOpVisitor<ResType> v);
}

/** Visitor for the BinOp union type. */
interface BinOpVisitor<ResType> {
  ResType forBinOpPlus();
  ResType forBinOpMinus();
  ResType forOpTimes();
  ResType forOpDivide();
  ResType forOpEquals();
  ResType forOpNotEquals();
  ResType forOpLessThan();
  ResType forOpGreaterThan();
  ResType forOpLessThanEquals();
  ResType forOpGreaterThanEquals();
  ResType forOpAnd();
  ResType forOpOr();
  // ResType forOpGets();  // Supports the ref cell extension to Jam
}

class UnOpPlus extends UnOp {
  public static final UnOpPlus ONLY = new UnOpPlus();
  private UnOpPlus() { super("+"); }
  public <ResType> ResType accept(UnOpVisitor<ResType> v) {
    return v.forUnOpPlus(); 
  }
}

class UnOpMinus extends UnOp {
  public static final UnOpMinus ONLY = new UnOpMinus();
  private UnOpMinus() { super("-"); }
  public <ResType> ResType accept(UnOpVisitor<ResType> v) {
    return v.forUnOpMinus(); 
  }
}

class OpTilde extends UnOp {
  public static final OpTilde ONLY = new OpTilde();
  private OpTilde() { super("~"); }
  public <ResType> ResType accept(UnOpVisitor<ResType> v) {
    return v.forOpTilde(); 
  }
}

/*  Supports ref cell extension to Jam
  class OpBang extends UnOp {
  public static final OpBang ONLY = new OpBang();
  private OpBang() { super("!"); }
  public <ResType> ResType accept(UnOpVisitor<ResType> v) {
    return v.forOpBang(); 
  }
}

class OpRef extends UnOp {
  public static final OpRef ONLY = new OpRef();
  private OpRef() { super("ref"); }
  public <ResType> ResType accept(UnOpVisitor<ResType> v) {
    return v.forOpRef(); 
  }
}
*/

class BinOpPlus extends BinOp {
  public static final BinOpPlus ONLY = new BinOpPlus();
  private BinOpPlus() { super("+"); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forBinOpPlus(); 
  }
}

class BinOpMinus extends BinOp {
  public static final BinOpMinus ONLY = new BinOpMinus();
  private BinOpMinus() { super("-"); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forBinOpMinus(); 
  }
}

class OpTimes extends BinOp {
  public static final OpTimes ONLY = new OpTimes();
  private OpTimes() { super("*"); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpTimes(); 
  }
}

class OpDivide extends BinOp {
  public static final OpDivide ONLY = new OpDivide();
  private OpDivide() { super("/"); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpDivide(); 
  }
}

class OpEquals extends BinOp {
  public static final OpEquals ONLY = new OpEquals();
  private OpEquals() { super("="); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpEquals(); 
  }
}

class OpNotEquals extends BinOp {
  public static final OpNotEquals ONLY = new OpNotEquals();
  private OpNotEquals() { super("!="); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpNotEquals(); 
  }
}

class OpLessThan extends BinOp {
  public static final OpLessThan ONLY = new OpLessThan();
  private OpLessThan() { super("<"); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpLessThan(); 
  }
}

class OpGreaterThan extends BinOp {
  public static final OpGreaterThan ONLY = new OpGreaterThan();
  private OpGreaterThan() { super(">"); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpGreaterThan(); 
  }
}

class OpLessThanEquals extends BinOp {
  public static final OpLessThanEquals ONLY = new OpLessThanEquals();
  private OpLessThanEquals() { super("<="); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpLessThanEquals(); 
  }
}

class OpGreaterThanEquals extends BinOp {
  public static final OpGreaterThanEquals ONLY = new OpGreaterThanEquals();
  private OpGreaterThanEquals() { super(">="); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpGreaterThanEquals(); 
  }
}

class OpAnd extends BinOp {
  public static final OpAnd ONLY = new OpAnd();
  private OpAnd() { super("&"); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpAnd(); 
  }
}

class OpOr extends BinOp {
  public static final OpOr ONLY = new OpOr();
  private OpOr() { super("|"); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpOr(); 
  }
}

/* Supports the ref cell extension to Jam
class OpGets extends BinOp {
  public static final OpGets ONLY = new OpGets();
  private OpGets() { super("<-"); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpGets(this); 
  }
}
*/

/* UnOpApp is a Term because it does not need enclosing parentheses when appearing in a binary expression */
class UnOpApp implements Term {
  private UnOp rator;
  private AST arg;
  
  UnOpApp(UnOp r, AST a) { rator = r; arg = a; }
  
  public UnOp rator() { return rator; }
  public AST arg() { return arg; }
  public <ResType> ResType accept(ASTVisitor<ResType> v) { return v.forUnOpApp(this); }
  public String toString() { return rator + " " + arg; }
}

class BinOpApp implements Term {
  private BinOp rator;
  private AST arg1, arg2;
  
  BinOpApp(BinOp r, AST a1, AST a2) { rator = r; arg1 = a1; arg2 = a2; }
  
  public BinOp rator() { return rator; }
  public AST arg1() { return arg1; }
  public AST arg2() { return arg2; }
  public <ResType> ResType accept(ASTVisitor<ResType> v) { return v.forBinOpApp(this); }
  public String toString() {
    return "(" + toString(arg1) + " " + rator + " " + toString(arg2) + ")"; 
  }
  private String toString(AST arg) {
    String argString = arg.toString();
   26
... (truncated 4753 chars)

AST.java8.0 KB

java

/* The file defining the AST classes including the visitor interface, except for AST classes that are Token classes 
 * as well. */

/** AST ::= BoolConstant | IntConstant | EmptyConstant | Variable | PrimFun | UnOpApp | BinOpApp | App | Map | If | Let */

/** AST class definitions */

/** The AST type which support a visitor interface */
interface AST {
  public <ResType> ResType accept(ASTVisitor<ResType> v);
}

interface ASTVisitor<ResType> {
  ResType forBoolConstant(BoolConstant b);
  ResType forIntConstant(IntConstant i);
  ResType forEmptyConstant(EmptyConstant n);
  ResType forVariable(Variable v);
  ResType forPrimFun(PrimFun f);
  ResType forUnOpApp(UnOpApp u);
  ResType forBinOpApp(BinOpApp b);
  ResType forApp(App a);
  ResType forMap(Map m);
  ResType forIf(If i);
  ResType forLet(Let l);
}

/* The Term interface correspond to AST's that when output as concrete syntax by toString() can be used as terms 
 * in an iterative binary expression without enclosing parentheses. We enclose all binary expressions in parentheses
 * so we do not presume either left or right associativity for infix binary operators. */
/** Term ::= Constant | PrimFun | Variable | UnOpApp |  App */
interface Term extends AST {}

/* NOTE: all Constant objects belong to the types Token and AST; Constant tokens evaluate to themselves.
 * The variant classes (IntConstant, BoolConstant, EmptyConstant) are defined in the file ValuesTokens.java */

/** Constant ::= IntConstant | BoolConstant | EmptyConstant */
interface Constant extends Term {}

/** UnOp ::= UnOpPlus | UnOpMinus | OpTilde */
/** Class representing the unary operator within a UnOppApp. */
abstract class UnOp {
  String name;
  public UnOp(String s) { name = s; }
  public String toString() { return name; }
  public abstract <ResType> ResType accept(UnOpVisitor<ResType> v);
}

/** Visitor for the UnOp union type. */
interface UnOpVisitor<ResType> {
  ResType forUnOpPlus();
  ResType forUnOpMinus();
  ResType forOpTilde();
  // ResType forOpBang();  // Supports ref cell extension to Jam
  // ResType forOpRef();    // Supports ref cell extension to Jam
}

/** BinOp ::= BinOpPlus | BinOpMinus | OpTimes | OpDivide | OpEquals | OpNotEquals | OpLessThan | OpGreaterThan |
  *           OpLessThanOrEquals OpGreaterThanOrEquals | OpAnd | OpOr */

/** Class representing the binary operator within a BinOppApp. */
abstract class BinOp {
  String name;
  public BinOp(String s) { name = s; }
  public String toString() { return name; }
  public abstract <ResType> ResType accept(BinOpVisitor<ResType> v);
}

/** Visitor for the BinOp union type. */
interface BinOpVisitor<ResType> {
  ResType forBinOpPlus();
  ResType forBinOpMinus();
  ResType forOpTimes();
  ResType forOpDivide();
  ResType forOpEquals();
  ResType forOpNotEquals();
  ResType forOpLessThan();
  ResType forOpGreaterThan();
  ResType forOpLessThanEquals();
  ResType forOpGreaterThanEquals();
  ResType forOpAnd();
  ResType forOpOr();
  // ResType forOpGets();  // Supports the ref cell extension to Jam
}

class UnOpPlus extends UnOp {
  public static final UnOpPlus ONLY = new UnOpPlus();
  private UnOpPlus() { super("+"); }
  public <ResType> ResType accept(UnOpVisitor<ResType> v) {
    return v.forUnOpPlus(); 
  }
}

class UnOpMinus extends UnOp {
  public static final UnOpMinus ONLY = new UnOpMinus();
  private UnOpMinus() { super("-"); }
  public <ResType> ResType accept(UnOpVisitor<ResType> v) {
    return v.forUnOpMinus(); 
  }
}

class OpTilde extends UnOp {
  public static final OpTilde ONLY = new OpTilde();
  private OpTilde() { super("~"); }
  public <ResType> ResType accept(UnOpVisitor<ResType> v) {
    return v.forOpTilde(); 
  }
}

/*  Supports ref cell extension to Jam
  class OpBang extends UnOp {
  public static final OpBang ONLY = new OpBang();
  private OpBang() { super("!"); }
  public <ResType> ResType accept(UnOpVisitor<ResType> v) {
    return v.forOpBang(); 
  }
}

class OpRef extends UnOp {
  public static final OpRef ONLY = new OpRef();
  private OpRef() { super("ref"); }
  public <ResType> ResType accept(UnOpVisitor<ResType> v) {
    return v.forOpRef(); 
  }
}
*/

class BinOpPlus extends BinOp {
  public static final BinOpPlus ONLY = new BinOpPlus();
  private BinOpPlus() { super("+"); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forBinOpPlus(); 
  }
}

class BinOpMinus extends BinOp {
  public static final BinOpMinus ONLY = new BinOpMinus();
  private BinOpMinus() { super("-"); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forBinOpMinus(); 
  }
}

class OpTimes extends BinOp {
  public static final OpTimes ONLY = new OpTimes();
  private OpTimes() { super("*"); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpTimes(); 
  }
}

class OpDivide extends BinOp {
  public static final OpDivide ONLY = new OpDivide();
  private OpDivide() { super("/"); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpDivide(); 
  }
}

class OpEquals extends BinOp {
  public static final OpEquals ONLY = new OpEquals();
  private OpEquals() { super("="); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpEquals(); 
  }
}

class OpNotEquals extends BinOp {
  public static final OpNotEquals ONLY = new OpNotEquals();
  private OpNotEquals() { super("!="); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpNotEquals(); 
  }
}

class OpLessThan extends BinOp {
  public static final OpLessThan ONLY = new OpLessThan();
  private OpLessThan() { super("<"); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpLessThan(); 
  }
}

class OpGreaterThan extends BinOp {
  public static final OpGreaterThan ONLY = new OpGreaterThan();
  private OpGreaterThan() { super(">"); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpGreaterThan(); 
  }
}

class OpLessThanEquals extends BinOp {
  public static final OpLessThanEquals ONLY = new OpLessThanEquals();
  private OpLessThanEquals() { super("<="); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpLessThanEquals(); 
  }
}

class OpGreaterThanEquals extends BinOp {
  public static final OpGreaterThanEquals ONLY = new OpGreaterThanEquals();
  private OpGreaterThanEquals() { super(">="); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpGreaterThanEquals(); 
  }
}

class OpAnd extends BinOp {
  public static final OpAnd ONLY = new OpAnd();
  private OpAnd() { super("&"); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpAnd(); 
  }
}

class OpOr extends BinOp {
  public static final OpOr ONLY = new OpOr();
  private OpOr() { super("|"); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpOr(); 
  }
}

/* Supports the ref cell extension to Jam
class OpGets extends BinOp {
  public static final OpGets ONLY = new OpGets();
  private OpGets() { super("<-"); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpGets(this); 
  }
}
*/

/* UnOpApp is a Term because it does not need enclosing parentheses when appearing in a binary expression */
class UnOpApp implements Term {
  private UnOp rator;
  private AST arg;
  
  UnOpApp(UnOp r, AST a) { rator = r; arg = a; }
  
  public UnOp rator() { return rator; }
  public AST arg() { return arg; }
  public <ResType> ResType accept(ASTVisitor<ResType> v) { return v.forUnOpApp(this); }
  public String toString() { return rator + " " + arg; }
}

class BinOpApp implements Term {
  private BinOp rator;
  private AST arg1, arg2;
  
  BinOpApp(BinOp r, AST a1, AST a2) { rator = r; arg1 = a1; arg2 = a2; }
  
  public BinOp rator() { return rator; }
  public AST arg1() { return arg1; }
  public AST arg2() { return arg2; }
  public <ResType> ResType accept(ASTVisitor<ResType> v) { return v.forBinOpApp(this); }
  public String toString() {
    return "(" + toString(arg1) + " " + rator + " " + toString(arg2) + ")"; 
  }
  private String toString(AST arg) {
    String argString = arg.toString();
   26
... (truncated 4753 chars)

AST.java11.8 KB

java

/* The file defining the AST classes including the visitor interface, except for AST classes that are Token classes 
 * as well. */

/** AST ::= BoolConstant | IntConstant | EmptyConstant | Variable | PrimFun | UnOpApp | BinOpApp | App | Map | If | Let */

/** AST class definitions */

/** The AST type which support a visitor interface */
interface AST {
  public <ResType> ResType accept(ASTVisitor<ResType> v);
}

interface ASTVisitor<ResType> {
  ResType forBoolConstant(BoolConstant b);
  ResType forIntConstant(IntConstant i);
  ResType forEmptyConstant(EmptyConstant n);
  ResType forVariable(Variable v);
  ResType forPrimFun(PrimFun f);
  ResType forUnOpApp(UnOpApp u);
  ResType forBinOpApp(BinOpApp b);
  ResType forApp(App a);
  ResType forMap(Map m);
  ResType forIf(If i);
  ResType forLet(Let l);
  ResType forBlock(Block b);
}

/* The Term interface correspond to AST's that when output as concrete syntax by toString() can be used as terms 
 * in an iterative binary expression without enclosing parentheses. We enclose all binary expressions in parentheses
 * so we do not presume either left or right associativity for infix binary operators. */
/** Term ::= Constant | PrimFun | Variable | UnOpApp |  App */
interface Term extends AST {}

/* NOTE: all Constant objects belong to the types Token and AST; Constant tokens evaluate to themselves.
 * The variant classes (IntConstant, BoolConstant, EmptyConstant) are defined in the file ValuesTokens.java */

/** Constant ::= IntConstant | BoolConstant | EmptyConstant */
interface Constant extends Term {}

/** UnOp ::= UnOpPlus | UnOpMinus | OpTilde */
/** Class representing the unary operator within a UnOppApp. */
abstract class UnOp {
  String name;
  public UnOp(String s) { name = s; }
  public String toString() { return name; }
  public abstract <ResType> ResType accept(UnOpVisitor<ResType> v);
}

/** Visitor for the UnOp union type. */
interface UnOpVisitor<ResType> {
  ResType forUnOpPlus();
  ResType forUnOpMinus();
  ResType forOpTilde();
  ResType forOpBang();  // Supports ref cell extension to Jam
  ResType forOpRef();    // Supports ref cell extension to Jam
}

/** BinOp ::= BinOpPlus | BinOpMinus | OpTimes | OpDivide | OpEquals | OpNotEquals | OpLessThan | OpGreaterThan |
  *           OpLessThanOrEquals OpGreaterThanOrEquals | OpAnd | OpOr */

/** Class representing the binary operator within a BinOppApp. */
abstract class BinOp {
  String name;
  public BinOp(String s) { name = s; }
  public String toString() { return name; }
  public abstract <ResType> ResType accept(BinOpVisitor<ResType> v);
}

/** Visitor for the BinOp union type. */
interface BinOpVisitor<ResType> {
  ResType forBinOpPlus();
  ResType forBinOpMinus();
  ResType forOpTimes();
  ResType forOpDivide();
  ResType forOpEquals();
  ResType forOpNotEquals();
  ResType forOpLessThan();
  ResType forOpGreaterThan();
  ResType forOpLessThanEquals();
  ResType forOpGreaterThanEquals();
  ResType forOpAnd();
  ResType forOpOr();
  ResType forOpGets();  // Supports the ref cell extension to Jam
}

class UnOpPlus extends UnOp {
  public static final UnOpPlus ONLY = new UnOpPlus();
  private UnOpPlus() { super("+"); }
  public <ResType> ResType accept(UnOpVisitor<ResType> v) {
    return v.forUnOpPlus(); 
  }
}

class UnOpMinus extends UnOp {
  public static final UnOpMinus ONLY = new UnOpMinus();
  private UnOpMinus() { super("-"); }
  public <ResType> ResType accept(UnOpVisitor<ResType> v) {
    return v.forUnOpMinus(); 
  }
}

class OpTilde extends UnOp {
  public static final OpTilde ONLY = new OpTilde();
  private OpTilde() { super("~"); }
  public <ResType> ResType accept(UnOpVisitor<ResType> v) {
    return v.forOpTilde();
  }
}

/*  Supports ref cell extension to Jam */
class OpBang extends UnOp {
  public static final OpBang ONLY = new OpBang();
  private OpBang() { super("!"); }
  public <ResType> ResType accept(UnOpVisitor<ResType> v) {
    return v.forOpBang();
  }
}

class OpRef extends UnOp {
  public static final OpRef ONLY = new OpRef();
  private OpRef() { super("ref"); }
  public <ResType> ResType accept(UnOpVisitor<ResType> v) {
    return v.forOpRef();
  }
}

class BinOpPlus extends BinOp {
  public static final BinOpPlus ONLY = new BinOpPlus();
  private BinOpPlus() { super("+"); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forBinOpPlus(); 
  }
}

class BinOpMinus extends BinOp {
  public static final BinOpMinus ONLY = new BinOpMinus();
  private BinOpMinus() { super("-"); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forBinOpMinus(); 
  }
}

class OpTimes extends BinOp {
  public static final OpTimes ONLY = new OpTimes();
  private OpTimes() { super("*"); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpTimes(); 
  }
}

class OpDivide extends BinOp {
  public static final OpDivide ONLY = new OpDivide();
  private OpDivide() { super("/"); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpDivide(); 
  }
}

class OpEquals extends BinOp {
  public static final OpEquals ONLY = new OpEquals();
  private OpEquals() { super("="); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpEquals(); 
  }
}

class OpNotEquals extends BinOp {
  public static final OpNotEquals ONLY = new OpNotEquals();
  private OpNotEquals() { super("!="); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpNotEquals(); 
  }
}

class OpLessThan extends BinOp {
  public static final OpLessThan ONLY = new OpLessThan();
  private OpLessThan() { super("<"); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpLessThan(); 
  }
}

class OpGreaterThan extends BinOp {
  public static final OpGreaterThan ONLY = new OpGreaterThan();
  private OpGreaterThan() { super(">"); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpGreaterThan(); 
  }
}

class OpLessThanEquals extends BinOp {
  public static final OpLessThanEquals ONLY = new OpLessThanEquals();
  private OpLessThanEquals() { super("<="); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpLessThanEquals(); 
  }
}

class OpGreaterThanEquals extends BinOp {
  public static final OpGreaterThanEquals ONLY = new OpGreaterThanEquals();
  private OpGreaterThanEquals() { super(">="); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpGreaterThanEquals(); 
  }
}

class OpAnd extends BinOp {
  public static final OpAnd ONLY = new OpAnd();
  private OpAnd() { super("&"); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpAnd(); 
  }
}

class OpOr extends BinOp {
  public static final OpOr ONLY = new OpOr();
  private OpOr() { super("|"); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpOr();
  }
}

/* Supports the ref cell extension to Jam */
class OpGets extends BinOp {
  public static final OpGets ONLY = new OpGets();
  private OpGets() { super("<-"); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpGets();
  }
}

/* UnOpApp is a Term because it does not need enclosing parentheses when appearing in a binary expression */
class UnOpApp implements Term {
  private UnOp rator;
  private AST arg;
  
  UnOpApp(UnOp r, AST a) { rator = r; arg = a; }
  
  public UnOp rator() { return rator; }
  public AST arg() { return arg; }
  public <ResType> ResType accept(ASTVisitor<ResType> v) { return v.forUnOpApp(this); }
  public String toString() { return rator + " " + arg; }
}

class BinOpApp implements Term {
  private BinOp rator;
  private AST arg1, arg2;
  
  BinOpApp(BinOp r, AST a1, AST a2) { rator = r; arg1 = a1; arg2 = a2; }
  
  public BinOp rator() { return rator; }
  public AST arg1() { return arg1; }
  public AST arg2() { return arg2; }
  public <ResType> ResType accept(ASTVisitor<ResType> v) { return v.forBinOpApp(this); }
  public String toString() {
    return "(" + toString(arg1) + " " + rator + " " + toString(arg2) + ")"; 
  }
  private String toString(AST arg) {
    String argString = arg.toString();
    if (! (arg instanceof Term)) return "(" + argString + ")";
    else return argString;
  }
}

class Map implements AST {
  private Variable[] vars;
  private AST body;
  
  Map(Variable[] v, AST b) { vars = v; body = b; }
  public Variable[] vars() { return vars; }
  public AST body() { return body; }
  public <ResType> ResType accept(ASTVisitor<ResType> v) { return v.forMap(this); }
  public String toString() { 
    return "map " + ToString.toString(vars,",") + " to " + body;
  }
}  

class App implements Term {
  private AST rator;
  private AST[] args;
  
  App(AST r, AST[] a) { rator = r; args = a; }
  
  public AST rator() { return rator; }
  public AST[] args() { return args; }
  
  public <ResType> ResType accept(ASTVisitor<ResType> v) { return v.forApp(this); }
  public String toString() { 
    if ((rator instanceof PrimFun) || (rator instanceof Variable))
      return rator + "(" + ToString.toString(args,", ") + ")"; 
    else
      return "(" +  rator + ")(" + ToString.toString(args,", ") + ")"; 
  }
}  

class If implements AST {
  private AST test, conseq, alt;
  If(AST t, AST c, AST a) { test = t; conseq = c; alt = a; }
  
  public AST test() { return test; }
  public AST conseq() { return conseq; }
  public AST alt() { return alt; }
  public <ResType> ResType accept(ASTVisitor<ResType> v) { return v.forIf(this); }
  public String toString() { 
    return "if " + test + " then " + conseq + " else " + alt ; 
  }
}  

class Let implements AST {
  private Def[] defs;
  private AST body;
  Let(Def[] d, AST b) { defs = d; body = b; }
  
  public <ResType> ResType accept(ASTVisitor<ResType> v) { return v.forLet(this); }
  public Def[] defs() { return defs; }
  public AST body() { return body; }
  public String toString() { 
    return "let " + ToString.toString(defs," ") + " in " + body; 
  }
  
  /* Commonly used non-essential methods */
  /** Returns the vars that are locally defined in this Let. */
  public Variable[] vars() {
    int n = defs.length;
    Variable[] vars = new Variable[n];
    for(int i = 0; i < n; i++) { vars[i] = defs[i].lhs(); }
    return vars;
  }
  /** Returns the exps that appear on the rhs of defs in this Let. */
  public AST[] exps() {
    int n = defs.length;
    AST[] exps = new AST[n];
    for(int i = 0; i < n; i++) { exps[i] = defs[i].rhs(); }
    return exps;
  }
}

/* Supports the addition of blocks in Assignment 4 */
/** A Block is a non-empty sequence of statements (expressions) that returns the value of the last
  * statement (expression).  The preceding statements are included solely for their side-effect
  * (changes to the values stored in boxes)
  * Hence, a block cannot appear as the first argument in a binary operation unless it is
  * enclosed in parentheses. The empty block is a parser error (ParseException).
  */
class Block implements AST{
  private AST[] exps;
  public Block(AST[] es) {
    exps = es;
  }

  @Override
  public <ResType> ResType accept(ASTVisitor<ResType> v) { return v.forBlock(this);}

  public AST[] exps() { return exps; }
}


/** Def class representing a definition embedded inside a Let. */
class Def {
  private Variable lhs;
  private AST rhs;  
  
  Def(Variable l, AST r) { lhs = l; rhs = r; }
  public Variable lhs() { return lhs; }
  public AST rhs() { return rhs; }
  
  public String toString() { return lhs + " := " + rhs + ";"; }
}

/** Dummy class containing an improved toString method for arrays. */
class ToString {
  
  public static String toString(Object[] a, String s) {
    StringBuffer result = new StringBuffer();
    for (int i = 0; i < a.length; i++) {
      if (i > 0) result.append(s);
      Object elt = a[i];
      String eltString = (elt instanceof Object[]) ?
        toString((Object[]) elt, s) : elt.toString();
      result.append(eltString);
    }
    return result.toString();
  }
}

AST.java11.8 KB

java

/* The file defining the AST classes including the visitor interface, except for AST classes that are Token classes 
 * as well. */

/** AST ::= BoolConstant | IntConstant | EmptyConstant | Variable | PrimFun | UnOpApp | BinOpApp | App | Map | If | Let */

/** AST class definitions */

/** The AST type which support a visitor interface */
interface AST {
  public <ResType> ResType accept(ASTVisitor<ResType> v);
}

interface ASTVisitor<ResType> {
  ResType forBoolConstant(BoolConstant b);
  ResType forIntConstant(IntConstant i);
  ResType forEmptyConstant(EmptyConstant n);
  ResType forVariable(Variable v);
  ResType forPrimFun(PrimFun f);
  ResType forUnOpApp(UnOpApp u);
  ResType forBinOpApp(BinOpApp b);
  ResType forApp(App a);
  ResType forMap(Map m);
  ResType forIf(If i);
  ResType forLet(Let l);
  ResType forBlock(Block b);
}

/* The Term interface correspond to AST's that when output as concrete syntax by toString() can be used as terms 
 * in an iterative binary expression without enclosing parentheses. We enclose all binary expressions in parentheses
 * so we do not presume either left or right associativity for infix binary operators. */
/** Term ::= Constant | PrimFun | Variable | UnOpApp |  App */
interface Term extends AST {}

/* NOTE: all Constant objects belong to the types Token and AST; Constant tokens evaluate to themselves.
 * The variant classes (IntConstant, BoolConstant, EmptyConstant) are defined in the file ValuesTokens.java */

/** Constant ::= IntConstant | BoolConstant | EmptyConstant */
interface Constant extends Term {}

/** UnOp ::= UnOpPlus | UnOpMinus | OpTilde */
/** Class representing the unary operator within a UnOppApp. */
abstract class UnOp {
  String name;
  public UnOp(String s) { name = s; }
  public String toString() { return name; }
  public abstract <ResType> ResType accept(UnOpVisitor<ResType> v);
}

/** Visitor for the UnOp union type. */
interface UnOpVisitor<ResType> {
  ResType forUnOpPlus();
  ResType forUnOpMinus();
  ResType forOpTilde();
  ResType forOpBang();  // Supports ref cell extension to Jam
  ResType forOpRef();    // Supports ref cell extension to Jam
}

/** BinOp ::= BinOpPlus | BinOpMinus | OpTimes | OpDivide | OpEquals | OpNotEquals | OpLessThan | OpGreaterThan |
  *           OpLessThanOrEquals OpGreaterThanOrEquals | OpAnd | OpOr */

/** Class representing the binary operator within a BinOppApp. */
abstract class BinOp {
  String name;
  public BinOp(String s) { name = s; }
  public String toString() { return name; }
  public abstract <ResType> ResType accept(BinOpVisitor<ResType> v);
}

/** Visitor for the BinOp union type. */
interface BinOpVisitor<ResType> {
  ResType forBinOpPlus();
  ResType forBinOpMinus();
  ResType forOpTimes();
  ResType forOpDivide();
  ResType forOpEquals();
  ResType forOpNotEquals();
  ResType forOpLessThan();
  ResType forOpGreaterThan();
  ResType forOpLessThanEquals();
  ResType forOpGreaterThanEquals();
  ResType forOpAnd();
  ResType forOpOr();
  ResType forOpGets();  // Supports the ref cell extension to Jam
}

class UnOpPlus extends UnOp {
  public static final UnOpPlus ONLY = new UnOpPlus();
  private UnOpPlus() { super("+"); }
  public <ResType> ResType accept(UnOpVisitor<ResType> v) {
    return v.forUnOpPlus(); 
  }
}

class UnOpMinus extends UnOp {
  public static final UnOpMinus ONLY = new UnOpMinus();
  private UnOpMinus() { super("-"); }
  public <ResType> ResType accept(UnOpVisitor<ResType> v) {
    return v.forUnOpMinus(); 
  }
}

class OpTilde extends UnOp {
  public static final OpTilde ONLY = new OpTilde();
  private OpTilde() { super("~"); }
  public <ResType> ResType accept(UnOpVisitor<ResType> v) {
    return v.forOpTilde();
  }
}

/*  Supports ref cell extension to Jam */
class OpBang extends UnOp {
  public static final OpBang ONLY = new OpBang();
  private OpBang() { super("!"); }
  public <ResType> ResType accept(UnOpVisitor<ResType> v) {
    return v.forOpBang();
  }
}

class OpRef extends UnOp {
  public static final OpRef ONLY = new OpRef();
  private OpRef() { super("ref"); }
  public <ResType> ResType accept(UnOpVisitor<ResType> v) {
    return v.forOpRef();
  }
}

class BinOpPlus extends BinOp {
  public static final BinOpPlus ONLY = new BinOpPlus();
  private BinOpPlus() { super("+"); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forBinOpPlus(); 
  }
}

class BinOpMinus extends BinOp {
  public static final BinOpMinus ONLY = new BinOpMinus();
  private BinOpMinus() { super("-"); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forBinOpMinus(); 
  }
}

class OpTimes extends BinOp {
  public static final OpTimes ONLY = new OpTimes();
  private OpTimes() { super("*"); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpTimes(); 
  }
}

class OpDivide extends BinOp {
  public static final OpDivide ONLY = new OpDivide();
  private OpDivide() { super("/"); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpDivide(); 
  }
}

class OpEquals extends BinOp {
  public static final OpEquals ONLY = new OpEquals();
  private OpEquals() { super("="); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpEquals(); 
  }
}

class OpNotEquals extends BinOp {
  public static final OpNotEquals ONLY = new OpNotEquals();
  private OpNotEquals() { super("!="); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpNotEquals(); 
  }
}

class OpLessThan extends BinOp {
  public static final OpLessThan ONLY = new OpLessThan();
  private OpLessThan() { super("<"); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpLessThan(); 
  }
}

class OpGreaterThan extends BinOp {
  public static final OpGreaterThan ONLY = new OpGreaterThan();
  private OpGreaterThan() { super(">"); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpGreaterThan(); 
  }
}

class OpLessThanEquals extends BinOp {
  public static final OpLessThanEquals ONLY = new OpLessThanEquals();
  private OpLessThanEquals() { super("<="); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpLessThanEquals(); 
  }
}

class OpGreaterThanEquals extends BinOp {
  public static final OpGreaterThanEquals ONLY = new OpGreaterThanEquals();
  private OpGreaterThanEquals() { super(">="); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpGreaterThanEquals(); 
  }
}

class OpAnd extends BinOp {
  public static final OpAnd ONLY = new OpAnd();
  private OpAnd() { super("&"); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpAnd(); 
  }
}

class OpOr extends BinOp {
  public static final OpOr ONLY = new OpOr();
  private OpOr() { super("|"); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpOr();
  }
}

/* Supports the ref cell extension to Jam */
class OpGets extends BinOp {
  public static final OpGets ONLY = new OpGets();
  private OpGets() { super("<-"); }
  public <ResType> ResType accept(BinOpVisitor<ResType> v) {
    return v.forOpGets();
  }
}

/* UnOpApp is a Term because it does not need enclosing parentheses when appearing in a binary expression */
class UnOpApp implements Term {
  private UnOp rator;
  private AST arg;
  
  UnOpApp(UnOp r, AST a) { rator = r; arg = a; }
  
  public UnOp rator() { return rator; }
  public AST arg() { return arg; }
  public <ResType> ResType accept(ASTVisitor<ResType> v) { return v.forUnOpApp(this); }
  public String toString() { return rator + " " + arg; }
}

class BinOpApp implements Term {
  private BinOp rator;
  private AST arg1, arg2;
  
  BinOpApp(BinOp r, AST a1, AST a2) { rator = r; arg1 = a1; arg2 = a2; }
  
  public BinOp rator() { return rator; }
  public AST arg1() { return arg1; }
  public AST arg2() { return arg2; }
  public <ResType> ResType accept(ASTVisitor<ResType> v) { return v.forBinOpApp(this); }
  public String toString() {
    return "(" + toString(arg1) + " " + rator + " " + toString(arg2) + ")"; 
  }
  private String toString(AST arg) {
    String argString = arg.toString();
    if (! (arg instanceof Term)) return "(" + argString + ")";
    else return argString;
  }
}

class Map implements AST {
  private Variable[] vars;
  private AST body;
  
  Map(Variable[] v, AST b) { vars = v; body = b; }
  public Variable[] vars() { return vars; }
  public AST body() { return body; }
  public <ResType> ResType accept(ASTVisitor<ResType> v) { return v.forMap(this); }
  public String toString() { 
    return "map " + ToString.toString(vars,",") + " to " + body;
  }
}  

class App implements Term {
  private AST rator;
  private AST[] args;
  
  App(AST r, AST[] a) { rator = r; args = a; }
  
  public AST rator() { return rator; }
  public AST[] args() { return args; }
  
  public <ResType> ResType accept(ASTVisitor<ResType> v) { return v.forApp(this); }
  public String toString() { 
    if ((rator instanceof PrimFun) || (rator instanceof Variable))
      return rator + "(" + ToString.toString(args,", ") + ")"; 
    else
      return "(" +  rator + ")(" + ToString.toString(args,", ") + ")"; 
  }
}  

class If implements AST {
  private AST test, conseq, alt;
  If(AST t, AST c, AST a) { test = t; conseq = c; alt = a; }
  
  public AST test() { return test; }
  public AST conseq() { return conseq; }
  public AST alt() { return alt; }
  public <ResType> ResType accept(ASTVisitor<ResType> v) { return v.forIf(this); }
  public String toString() { 
    return "if " + test + " then " + conseq + " else " + alt ; 
  }
}  

class Let implements AST {
  private Def[] defs;
  private AST body;
  Let(Def[] d, AST b) { defs = d; body = b; }
  
  public <ResType> ResType accept(ASTVisitor<ResType> v) { return v.forLet(this); }
  public Def[] defs() { return defs; }
  public AST body() { return body; }
  public String toString() { 
    return "let " + ToString.toString(defs," ") + " in " + body; 
  }
  
  /* Commonly used non-essential methods */
  /** Returns the vars that are locally defined in this Let. */
  public Variable[] vars() {
    int n = defs.length;
    Variable[] vars = new Variable[n];
    for(int i = 0; i < n; i++) { vars[i] = defs[i].lhs(); }
    return vars;
  }
  /** Returns the exps that appear on the rhs of defs in this Let. */
  public AST[] exps() {
    int n = defs.length;
    AST[] exps = new AST[n];
    for(int i = 0; i < n; i++) { exps[i] = defs[i].rhs(); }
    return exps;
  }
}

/* Supports the addition of blocks in Assignment 4 */
/** A Block is a non-empty sequence of statements (expressions) that returns the value of the last
  * statement (expression).  The preceding statements are included solely for their side-effect
  * (changes to the values stored in boxes)
  * Hence, a block cannot appear as the first argument in a binary operation unless it is
  * enclosed in parentheses. The empty block is a parser error (ParseException).
  */
class Block implements AST{
  private AST[] exps;
  public Block(AST[] es) {
    exps = es;
  }

  @Override
  public <ResType> ResType accept(ASTVisitor<ResType> v) { return v.forBlock(this);}

  public AST[] exps() { return exps; }
}


/** Def class representing a definition embedded inside a Let. */
class Def {
  private Variable lhs;
  private AST rhs;  
  
  Def(Variable l, AST r) { lhs = l; rhs = r; }
  public Variable lhs() { return lhs; }
  public AST rhs() { return rhs; }
  
  public String toString() { return lhs + " := " + rhs + ";"; }
}

/** Dummy class containing an improved toString method for arrays. */
class ToString {
  
  public static String toString(Object[] a, String s) {
    StringBuffer result = new StringBuffer();
    for (int i = 0; i < a.length; i++) {
      if (i > 0) result.append(s);
      Object elt = a[i];
      String eltString = (elt instanceof Object[]) ?
        toString((Object[]) elt, s) : elt.toString();
      result.append(eltString);
    }
    return result.toString();
  }
}

.mcp.json

diff --git a/.mcp.json b/.mcp.json
deleted file mode 100644
index d64fcf2..0000000
--- a/.mcp.json
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-  "mcpServers": {
-    "bscs-bench": {
-      "command": "/Users/bebe/Code/bscs-bench/bin/bscs-mcp",
-      "args": [
-        "--workspace",
-        "/Users/bebe/Code/bscs-bench/workspaces/comp411_assignment4_haiku"
-      ]
-    }
-  }
-}
\ No newline at end of file

Agent Work: Imperative Jam (Mutable References)

Assignment 4: Imperative Jam

Overview

Overview

Testing Your Program

Implementation Hints

Sub-Model Usage