OCaml interpeter error, too many argument on "eval FunCall R"

Question

I am writing a language interpeter with OCaml.

With ApplyOver I have to map a function on every value of the type dictionary, which is made of (ide * exp) -> ("key", value).

If the function is "fun x-> x+1" on a dictionary ("key1", Eint 2), ("key2", Eint 3), then ApplyOver will add +1 to 2 and +1 to 3.

I have this error on the last line, This function has type exp -> evT env -> evT It is applied to too many arguments; maybe you forgot a `;'.

Code (without standard evaluations):

type exp = ... | Dict of (ide * exp) list | ApplyOver of exp * exp;;
type evT = ... | DictVal of (ide * exp) list

let rec eval (e : exp) (r : evT env) : evT = match e with

Dict(pairs) -> 
    if invariant pairs then DictVal(evalDictList pairs r) 
    else failwith("The Dictionary has multiple copy of the same key")|
ApplyOver(ex, dict) ->
    (match (eval dict r) with
        DictVal(pairs) -> DictVal(applyover ex pairs)|
        _-> failwith ("not a dictionary"))|
Estring s -> String s |
Eint n -> Int n |
Ebool b -> Bool b |
IsZero a -> iszero (eval a r) |
Den i -> applyenv r i |
Eq(a, b) -> eq (eval a r) (eval b r) |
Prod(a, b) -> prod (eval a r) (eval b r) |
Sum(a, b) -> sum (eval a r) (eval b r) |
Diff(a, b) -> diff (eval a r) (eval b r) |
Minus a -> minus (eval a r) |
And(a, b) -> et (eval a r) (eval b r) |
Or(a, b) -> vel (eval a r) (eval b r) |
Not a -> non (eval a r) |
Ifthenelse(a, b, c) -> 
    let g = (eval a r) in
        if (typecheck "bool" g) 
            then (if g = Bool(true) then (eval b r) else (eval c r))
            else failwith ("nonboolean guard") |
Let(i, e1, e2) -> eval e2 (bind r i (eval e1 r)) |
Fun(i, a) -> FunVal(i, a, r) |
FunCall(f, eArg) -> 
    let fClosure = (eval f r) in
        (match fClosure with
            FunVal(arg, fBody, fDecEnv) -> 
                eval fBody (bind fDecEnv arg (eval eArg r)) |
            RecFunVal(g, (arg, fBody, fDecEnv)) -> 
                let aVal = (eval eArg r) in
                    let rEnv = (bind fDecEnv g fClosure) in
                        let aEnv = (bind rEnv arg aVal) in
                            eval fBody aEnv |
            _ -> failwith("non functional value")) |
    Letrec(f, funDef, letBody) ->
            (match funDef with
                Fun(i, fBody) -> let r1 = (bind r f (RecFunVal(f, (i, fBody, r)))) in
                                                eval letBody r1 |
                _ -> failwith("non functional def"))

and evalDictList (pairs : (ide * exp) list) (r : evT env) : (ide * evT) list = match pairs with
    [ ] -> [ ] |
    (key,value) :: other -> (key, eval value r) :: evalDictList other r

and applyover (ex : exp) (listtoscan : (ide * evT) list) : (ide * evT) list = match listtoscan with
    [ ] -> [ ] |
    (key,value) :: other -> (key, eval FunCall(ex, value) r) :: applyover ex other;;

Answer 1

Function application has the second highest precedence after method calls (and similar user-defined operators). Thus the compiler reads eval FunCall(ex, value) r as

 (eval FunCall) (ex, value) r

while you intended to write

 eval (Funcall(ex,value)) r