Mine

-- an abstract syntax for Pal

data Value = Num Float | FuncVal  Idlist  Exprlist | None
             deriving (Eq, Show)

data Expr  = Lit Float | FuncDef  Idlist Exprlist 
             | Var String | Dcl String Expr | Assign String Expr 
             | FuncCall String Exprlist
             deriving (Eq, Show)

type Exprlist = [ Expr ]
type Idlist   = [ String ]

type Frame    = [ (String, Value) ]
type State    = [ Frame ]

-- functions adapated from Clite

find :: String -> Frame -> Value
find var [ ] = None
find var (s:ss)
    |  var == (fst s)    = snd s
    |  otherwise         = find var ss

get :: String -> State -> Value
get var (s:ss)
    | findem /= None     = findem 
    | otherwise          = get var ss
    where
        findem = find var s

onion :: String -> Value -> Frame -> Frame
onion var val [ ]       = [ ]
onion var val (s:ss)
    | var == (fst s)    = (var, val) : ss
    | otherwise         = s : (onion var val ss)

put :: String -> Value -> State -> State
put var val (s:ss)
    | onionem /= s      = onionem : ss
    | otherwise         = s : (put var val ss)
    where
        onionem = onion var val s

-- basic interpretor functions
-- as you start to implement each function, first uncommnet prototyep

val :: Expr -> State -> Value
val exp stat = 5

env :: Expr -> State -> State
env exp stat = 5

interp :: (Value, State) -> Exprlist -> (Value, State)
interp (vl, st) (s:es)
    | null es /= True   = interp (v, en)
    | otherwise         = (v, en)
    where
        v = val s st
        en = env s st

pal :: Exprlist -> (Value, State)
pal es = interp (None, [[]]) es