datatype expression = Add     of expression * expression
    |                 Sub     of expression * expression
    |                 Mul     of expression * expression
    |                 Div     of expression * expression
    |                 Greater of expression * expression
    |                 Lesser  of expression * expression
    |                 Equal   of expression * expression
    |                 Var     of string
    |                 Num     of int

datatype direction = WEST
    |                EAST
    |                NORTH
    |                SOUTH

datatype statement = Move       of direction * expression
    |                Vardec     of string * expression
    |                Loop       of statement list
    |                Break      of expression
    |                Assignment of string * bool
    |                STOP

type programState =  {
    grid:           int * int,
    robotPosition:  int * int,
    vars:           (string * int) list

}

val prog1 = [
    Move (WEST,  Num (15)),
    Move (SOUTH, Num (15)),
    Move (EAST,  Add (Num (2), Num (3))),
    Move (NORTH, Add (Num (10), Num (27))),
    STOP
]

val state1 = {grid = (64, 64), robotPosition = (23, 30), vars = []}

fun    move (x, y) WEST  distance bounds  = (x - distance, y)
    |  move (x, y) NORTH distance bounds  = (x, y + distance)
    |  move (x, y) EAST  distance bounds  = (x + distance, y)
    |  move (x, y) SOUTH distance bounds  = (x, y - distance)

fun   evalExpr (Num (num)) programState = num
    | evalExpr (Add (left, right)) programState = (evalExpr(left) programState) + (evalExpr(right) programState)

fun   evalStatement (Move (dir, exp)) (state: programState) =
    {
        grid = #grid state,
        robotPosition = move (#robotPosition state) dir (evalExpr exp state) (#grid state),
        vars = #vars state
    }

fun   interpret nil (state: programState) = evalStatement x state
    | interpret (x::xs)  (state: programState) = interpret xs (evalStatement x)