Agent Work: Statically Typed Jam

Claude Sonnet 4.6 · COMP 411: Principles of Programming Languages

Assignment 5: Typed Jam

Overview

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

Prerequisite: This assignment builds on Assignment 4. You must start with a working solution to Assignment 4 (use the solution provided with Assignment 4 if needed) and revise the code to add static typing. A skeleton JUnit test file Assign5Test.java is provided.

Overview

Task Your assignment is to convert Jam to a statically typed programming language.

Step 1 As the first step in the project, you will strip your solution for Project 4 down to a family of two interpreters: call-by-value/eager (value/value) and call-by-value/lazy (value/need).

The public interface to the interpreter is the same as in Assignment 4 except for the fact the the Interpreter class will only support two public methods: eagerEval() and lazyEval() which correspond to valueValue() and valueNeed() in Assignment 4.

Save your solution to this step in a separate directory. You will use it as the starting point for Project 6.

Step 2 As the second step of the assignment, you will modify the parser and AST representation to:

eliminate the primitives list?, number?, function?, ref?, and arity from the language syntax (because they are not typable in a conventional static type system);
require the syntax Id : Type for *binding occurrences* of variables, which occur on the left-hand side of definitions and in the parameter lists of map expressions;
require the syntax empty : Type in place of empty, where Type indicates the element type of the list type to which empty belongs;
force any Factor that is a Prim to be followed by an application argument list. This restriction prevents a Prim from being used as a general value.

Hence, the grammar looks like this:

*Expressions*

Exp               ::= Term { Binop Exp }
                    | if Exp then Exp else Exp
                    | let Def+ in Exp
                    | map TypedIdList to Exp
                    | "{" PropStatementList "}"
Term              ::= Unop Term
                    | Factor { ( ExpList ) }
                    | Prim ( ExpList )
                    | Empty
                    | Int
                    | Bool
Factor            ::= ( Exp ) | Id
ExpList           ::= { PropExpList }
PropExpList       ::= Exp | Exp , PropExpList
TypedIdList       ::= { PropTypedIdList }
PropTypedIdList   ::= TypedId | TypedId, PropTypedIdList
PropStatementList ::= Exp | Exp ; PropStatementList
TypedId           ::= Id : Type

*Definitions*

Def               ::= TypedId := Exp ;

*Primitive Constants, Operators, and Operations*

Empty             ::= empty : Type
Bool              ::= true | false
Unop              ::= Sign | ~ | ! | ref
Sign              ::= "+" | -
Binop             ::= Sign | "*" | / | = | != | < | > | <= | >= | & | "|" | <-
Prim              ::= empty? | cons? | cons | first | rest

*Identifiers*

Id ::= AlphaOther {AlphaOther | Digit}*

Please note that Id does *not* contain anything that matches Prim or the keywords if, then, else, map, to, let, in, empty, true, and false.

*Types*

Type              ::= unit | int | bool | list Type | ref Type | (TypeList -> Type)
TypeList          ::= { PropTypeList }
PropTypeList      ::= Type | Type, PropTypeList

*Numbers*

Int ::= Digit+

Note that there are three type constructors list, ->, and ref. You will need to define an abstract syntax for types.

You are not responsible for producing slick error diagnostics for syntax errors. You should still prohibit the omitted primitive operations recognized by the lexer/parser from being used as variable names.

Step 3 Before you can interpret a typed program, you must type check it.

Define a method in the Interpreter class called checkTypes that takes an expression (an AST) as an argument, type checks it, and returns an expression suitable for interpretation. You can simply use inheritance to define an AST representation for typed program syntax that extends the untyped AST representation. If your type checker encounters a type error, it should abort the computation by throwing a TypeException with an error message explaining the type error. TypeException looks like this:

class TypeException extends RuntimeException {
    TypeException(String msg) { super(msg); }
}

The top-level methods eagerEval() and lazyEval() should first invoke the parser, then the context-sensitive syntax checker from Assignment 3, then the type checker, and finally the appropriate evaluation method.

The type-checking method should rely on the same tree-walking methods that you developed for checking syntax in Assignment 3. It behaves like an "abstract" interpreter that takes a type environment (mapping variables to types) as input and returns a type instead of a value as output. Note that the primitive operations and operators all have types. Moreover, the primitives cons, first, rest, empty?, and cons? and the operators !, ref, <-, = have schematic types that must be matched against their contexts to determine how they are instantiated:

cons      : 'a , list 'a -> list 'a
first     : list 'a      -> 'a
rest      : list 'a      -> list 'a
ref       : 'a           -> ref 'a
empty?    : list 'a      -> bool
cons?     : list 'a      -> bool
!         : ref 'a       -> 'a
<-        : ref 'a , 'a  -> unit
=         : 'a , 'a      -> bool
!=        : 'a , 'a      -> bool

In these type declarations, the symbol 'a stands for any specific type (a specific type cannot contain the special symbol 'a). Only these primitives and binary operators have polymorphic type; every program-defined function must have a specific (non-polymorphic) type. The symbol 'a designating an undetermined type never appears in actual program text.

To simplify the type checking process, the syntax prohibits these polymorphic operations from being used as data values (stored in data structures, passed as arguments, or returned as results). Hence, to use cons as a data value, you must wrap it in a map which forces it to have a specific type. Hindley-Milner polymorphism (used in ML) is slightly more flexible; it allows you to use polymorphic operations as data values, but their reconstructed types must not be polymorphic!

From the perspective of type-checking, the if-then-else construct behaves like a ternary polymorphic function with type:

if-then-else : (bool, 'a, 'a -> 'a)

The remaining primitives and operators have the following specific types:

(unary) -  : (int -> int)
~          : (bool -> bool)
+          : (int, int -> int)
(binary) - : (int, int -> int)
*          : (int, int -> int)
/          : (int, int -> int)
<          : (int, int -> bool)
<=         : (int, int -> bool)
>          : (int, int -> bool)
>=         : (int, int -> bool)
&          : (bool, bool -> bool)
|          : (bool, bool -> bool)

Some type correct applications of primitives can still generate run-time errors because the collection of definable types and type-checking machinery are too weak to capture the domain of primitive functions precisely. For example, the following expressions are all type-correct:

1/0
first(empty : int)
rest(empty : int)

To type the applications of polymorphic primitives and operators, your type checker will need to match their schematic types against the types the checker produces for their inputs. Every program sub-expression other than one of the schematic primitives or operators has a specific (non-schematic) type. We augmented empty with type annotation to obtain this property.

Consider the following example. Assume that the type environment assigns x the type int, then the unary operator ref in the application ref x has type (int -> ref int).

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 Assignment 1.

Test that your type checker works and produces code suitable for your interpreter. As usual we are providing a sample Unit testing suite Assign5Test.java to help you get started on writing your unit tests and sample grading scripts so you can test that your program supports the proper interfaces before submitting it for grading.

Testing Your Program

JUnit test files from earlier assignments will generally fail because the Assignment 5 interpreter supports different (and fewer) evaluation methods. You need to add more test cases to Assign5Test.java. Test that your type checker works and produces code suitable for your interpreter.

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. Type AST: Create a Type interface with classes: IntType, BoolType, UnitType, ListType(Type elem), RefType(Type elem), FunType(Type[] params, Type result). Use singletons for IntType, BoolType, UnitType.

2. Step 1 simplification: Keep only valueValue() and valueNeed() evaluation logic, rename to eagerEval() and lazyEval(). Delete the other 7 modes.

3. Parser changes: Modify Def and Variable to include a Type. Parse types after : in bindings. Parse empty : Type as a typed empty list.

4. TypeChecker pattern: Create a visitor that takes a type environment Map<String, Type> and returns a Type. For each AST node, check operand types match expected types, return result type.

5. Polymorphic matching: For cons(x, y) where y : list int, infer 'a = int, so result is list int. For first(x) where x : list bool, result is bool. Match the concrete type against the schema to find 'a.

6. TypeException: Throw when types don't match, e.g., if 5 then ... (condition not bool), 1 + true (operands not int).

--- *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);
  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();
  ResType forOpRef();
}

/** 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();
}

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(); 
  }
}

/** UnOp for dereference operator '!' */
class OpBang extends UnOp {
  public static final OpBang ONLY = new OpBang();
  private OpBang() { super("!"); }
  public <ResType> ResType accept(UnOpVisitor<ResType> v) {
    return v.forOpBang();
  }
}

/** UnOp for ref creation operator 'ref' */
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(); 
  }
}

/** BinOp for assignment operator '<-' */
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 + ")";

... (truncated 4685 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);
  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();
  ResType forOpRef();
}

/** 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();
}

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(); 
  }
}

/** UnOp for dereference operator '!' */
class OpBang extends UnOp {
  public static final OpBang ONLY = new OpBang();
  private OpBang() { super("!"); }
  public <ResType> ResType accept(UnOpVisitor<ResType> v) {
    return v.forOpBang();
  }
}

/** UnOp for ref creation operator 'ref' */
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(); 
  }
}

/** BinOp for assignment operator '<-' */
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 + ")";

... (truncated 4685 chars)

AST.java15.1 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();
  ResType forOpRef();
}

/** 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();
}

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(); 
  }
}

/** UnOp for dereference operator '!' */
class OpBang extends UnOp {
  public static final OpBang ONLY = new OpBang();
  private OpBang() { super("!"); }
  public <ResType> ResType accept(UnOpVisitor<ResType> v) {
    return v.forOpBang();
  }
}

/** UnOp for ref creation operator 'ref' */
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(); 
  }
}

/** BinOp for assignment operator '<-' */
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 JamType[] types;  // param type annotations (may be null for untyped)
  private AST body;

  Map(Variable[] v, AST b) { vars = v; types = null; body = b; }
  Map(Variable[] v, JamType[] t, AST b) { vars = v; types = t; body = b; }

  public Variable[] vars() { return vars; }
  public JamType[] types() { return types; }
  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;
  }
}

/** 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;
  }

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

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

  public String toString() {
    return "{" + ToString.toString(exps, "; ") + "}";
  }
}


/** Def class representing a definition embedded inside a Let. */
class Def {
  private Variable lhs;
  private JamType type;  // type annotation (may be null for untyped)
  private AST rhs;

  Def(Variable l, AST r) { lhs = l; type = null; rhs = r; }
  Def(Variable l, JamType t, AST r) { lhs = l; type = t; rhs = r; }

  public Variable lhs() { return lhs; }
  public JamType type() { return type; }
  public AST rhs() { return rhs; }

  public String toString() {
    if (type != null) return lhs + ": " + type + " := " + rhs + ";";
    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();
  }
}

/* ============================================================
 *  JamType hierarchy for Typed Jam (Assignment 5)
 * ============================================================ */

/** Interface for Jam types. */
interface JamType {
  boolean equals(Object other);
  String toString();
}

/** Singleton class for the integer type. */
class IntType implements JamType {
  public static final IntType ONLY = new IntType();
  private IntType() {}
  public boolean equals(Object o) { return o instanceof IntType; }
  public int hashCode() { return 1; }
  public String toString() { return "int"; }
}

/** Singleton class for the boolean type. */
class BoolType implements JamType {
  public static final BoolType ONLY = new BoolType();
  private BoolType() {}
  public boolean equals(Object o) { return o instanceof BoolType; }
  public int hashCode() { return 2; }
  public String toString() { return "bool"; }
}

/** Singleton class for the unit type. */
class UnitType implements JamType {
  public static final UnitType ONLY = new UnitType();
  private UnitType() {}
  public boolean equals(Object o) { return o instanceof UnitType; }
  public int hashCode() { return 3; }
  public String toString() { return "unit"; }
}

/** Class for list types: list elemType. */
class ListType implements JamType {
  private JamType elemType;
  ListType(JamType t) { elemType = t; }
  public JamType elemType() { return elemType; }
  public boolean equals(Object o) {
    if (!(o instanceof ListType)) return false;
    return elemType.equals(((ListType) o).elemType);
  }
  public int hashCode() { return 7 + elemType.hashCode(); }
  public String toString() { return "list " + elemType; }
}

/** Class for reference types: ref elemType. */
class RefType implements JamType {
  private JamType elemType;
  RefType(JamType t) { elemType = t; }
  public JamType elemType() { return elemType; }
  public boolean equals(Object o) {
    if (!(o instanceof RefType)) return false;
    return elemType.equals(((RefType) o).elemType);
  }
  public int hashCode() { return 11 + elemType.hashCode(); }
  public String toString() { return "ref " + elemType; }
}

/** Class for function types: (params -> result). */
class FunType implements JamType {
  private JamType[] params;
  private JamType result;
  FunType(JamType[] p, JamType r) { params = p; result = r; }
  public JamType[] params() { return params; }
  public JamType result() { return result; }
  public boolean equals(Object o) {
    if (!(o instanceof FunType)) return false;
    FunType f = (FunType) o;
    if (params.length != f.params.length) return false;
    for (int i = 0; i < params.length; i++) {
      if (!params[i].equals(f.params[i])) return false;
    }
    return result.equals(f.result);
  }
  public int hashCode() {
    int h = result.hashCode();
    for (JamType p : params) h = 31 * h + p.hashCode();
    return h;
  }
  public String toString() {
    return "(" + ToString.toString(params, ", ") + " -> " + result + ")";
  }
}

AST.java15.1 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();
  ResType forOpRef();
}

/** 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();
}

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(); 
  }
}

/** UnOp for dereference operator '!' */
class OpBang extends UnOp {
  public static final OpBang ONLY = new OpBang();
  private OpBang() { super("!"); }
  public <ResType> ResType accept(UnOpVisitor<ResType> v) {
    return v.forOpBang();
  }
}

/** UnOp for ref creation operator 'ref' */
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(); 
  }
}

/** BinOp for assignment operator '<-' */
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 JamType[] types;  // param type annotations (may be null for untyped)
  private AST body;

  Map(Variable[] v, AST b) { vars = v; types = null; body = b; }
  Map(Variable[] v, JamType[] t, AST b) { vars = v; types = t; body = b; }

  public Variable[] vars() { return vars; }
  public JamType[] types() { return types; }
  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;
  }
}

/** 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;
  }

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

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

  public String toString() {
    return "{" + ToString.toString(exps, "; ") + "}";
  }
}


/** Def class representing a definition embedded inside a Let. */
class Def {
  private Variable lhs;
  private JamType type;  // type annotation (may be null for untyped)
  private AST rhs;

  Def(Variable l, AST r) { lhs = l; type = null; rhs = r; }
  Def(Variable l, JamType t, AST r) { lhs = l; type = t; rhs = r; }

  public Variable lhs() { return lhs; }
  public JamType type() { return type; }
  public AST rhs() { return rhs; }

  public String toString() {
    if (type != null) return lhs + ": " + type + " := " + rhs + ";";
    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();
  }
}

/* ============================================================
 *  JamType hierarchy for Typed Jam (Assignment 5)
 * ============================================================ */

/** Interface for Jam types. */
interface JamType {
  boolean equals(Object other);
  String toString();
}

/** Singleton class for the integer type. */
class IntType implements JamType {
  public static final IntType ONLY = new IntType();
  private IntType() {}
  public boolean equals(Object o) { return o instanceof IntType; }
  public int hashCode() { return 1; }
  public String toString() { return "int"; }
}

/** Singleton class for the boolean type. */
class BoolType implements JamType {
  public static final BoolType ONLY = new BoolType();
  private BoolType() {}
  public boolean equals(Object o) { return o instanceof BoolType; }
  public int hashCode() { return 2; }
  public String toString() { return "bool"; }
}

/** Singleton class for the unit type. */
class UnitType implements JamType {
  public static final UnitType ONLY = new UnitType();
  private UnitType() {}
  public boolean equals(Object o) { return o instanceof UnitType; }
  public int hashCode() { return 3; }
  public String toString() { return "unit"; }
}

/** Class for list types: list elemType. */
class ListType implements JamType {
  private JamType elemType;
  ListType(JamType t) { elemType = t; }
  public JamType elemType() { return elemType; }
  public boolean equals(Object o) {
    if (!(o instanceof ListType)) return false;
    return elemType.equals(((ListType) o).elemType);
  }
  public int hashCode() { return 7 + elemType.hashCode(); }
  public String toString() { return "list " + elemType; }
}

/** Class for reference types: ref elemType. */
class RefType implements JamType {
  private JamType elemType;
  RefType(JamType t) { elemType = t; }
  public JamType elemType() { return elemType; }
  public boolean equals(Object o) {
    if (!(o instanceof RefType)) return false;
    return elemType.equals(((RefType) o).elemType);
  }
  public int hashCode() { return 11 + elemType.hashCode(); }
  public String toString() { return "ref " + elemType; }
}

/** Class for function types: (params -> result). */
class FunType implements JamType {
  private JamType[] params;
  private JamType result;
  FunType(JamType[] p, JamType r) { params = p; result = r; }
  public JamType[] params() { return params; }
  public JamType result() { return result; }
  public boolean equals(Object o) {
    if (!(o instanceof FunType)) return false;
    FunType f = (FunType) o;
    if (params.length != f.params.length) return false;
    for (int i = 0; i < params.length; i++) {
      if (!params[i].equals(f.params[i])) return false;
    }
    return result.equals(f.result);
  }
  public int hashCode() {
    int h = result.hashCode();
    for (JamType p : params) h = 31 * h + p.hashCode();
    return h;
  }
  public String toString() {
    return "(" + ToString.toString(params, ", ") + " -> " + result + ")";
  }
}

.mcp.json

diff --git a/.mcp.json b/.mcp.json
deleted file mode 100644
index cb95374..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_assignment5_sonnet"
-      ]
-    }
-  }
-}
\ No newline at end of file

Agent Work: Statically Typed Jam

Assignment 5: Typed Jam

Overview

Overview

Testing

Testing Your Program

Implementation Hints

Sub-Model Usage