MITTutorialApril2009: interpreterExercise.fss

component interpreterExercise
export Executable

trait Ast comprises { Expr, Type }
  getter asString(): String
end

(* expressions *)
(* e ::= s
       | n
       | n + n
       | n - n
 *)
trait Expr extends Ast comprises { Val, BinOpApp } excludes Type end

trait Val extends Expr comprises { Str, Num }
  getter asValue(): Object
end

object Str(string: String) extends Val
  getter asString() = string
  getter asValue() = string
end

(* Define an object Num.
 * Take some hints from the object Str.
 *)

trait BinOpApp extends Expr comprises { Plus, Minus }
  abstract getter left(): Expr
  abstract getter op(): String
  abstract getter right(): Expr
  getter asString() = self.left.asString self.op self.right.asString
end

(* Define objects Plus and Minus.
 * Note that they have two parameters.
 *)

(* types *)
(* t ::= StringType
       | IntegerType
 *)
trait Type extends Ast comprises { StringType, IntegerType } excludes Expr end
object StringType extends Type end
object IntegerType extends Type end

(* Define an evaluator as overloaded function declarations. *)
eval(e: Expr): Object =
    fail("You still need to implement an eval function.")

(* Define a type checker as overloaded function declarations. *)
typecheck(e: Expr): Type =
    fail("You still need to implement a typecheck function.")

(**********************************************************************************
 * TESTS
 **********************************************************************************)

run(): () = do
  eight = Plus(Num(3), Num(5))
  hello = Str("Hello")
  wrong = Minus(eight, hello)

  assert(eight.asString, "3+5")
  assert(hello.asString, "Hello")
  assert(wrong.asString, "3+5-Hello")
  println("Your objects appear to work.")

  (* test: eval *)
  assert(eval(eight), 8)
  assert(eval(hello), "Hello")
  println("Your eval appears to work.")

  (* test: typecheck *)
  assert(typecheck(eight), IntegerType)
  assert(typecheck(hello), StringType)
  try
    typecheck(wrong)
  catch x
    FailCalled => ()
  end
  println("Your typecheck appears to work.")
end

end