OCAML getElement typeerror

type ide = string;;
type integer = int;;

(*Eccezioni*)
exception WrongMatchException;;
exception EmptyEnvException;;
exception TypeErrorException;;
exception UnboundRecordException;;
exception OutOfBoundException;;

type exp =
    | Ide of ide (*Identificatore*)
    | Int of int (*Valori Interi*)
    | Bool of int (*Valori Booleani*)
    | Add of exp * exp (*Operatori Matematici*)
    | Sub of exp * exp
    | Mul of exp * exp
    | Eq of exp * exp
    | Leq of exp * exp
    | And of exp * exp (*Operatori Logici*)
    | Or of exp * exp
    | Not of exp
    | Fun of ide * exp (*Funzione con un parametro, non ricorsiva*)
    | IfThenElse of exp * exp * exp (*Classico If Then Else *)
    | LetIn of ide * exp * exp (*Blocco Let*)
    | Function of ide * exp (*Applicazione funzionale Ide(E)*)
    | CreateTuple of ide * exp (*Espressione Tupla*)
    | GetIndex of elts * exp (*Accesso Elemento Tupla*)
    | GetFirstN of exp * integer (* Seleziona elementi Tupla*)
    | TupleEquals of exp * exp (*Confronto tra tuple*)
    | Map of ide * exp (*Applica funzione ad elementi tupla*)
and
(*Elementi di una tupla*)
 elts = exp list
;;


    (* the empty environment *)
    (* emptyEnv: 'a -> 'b *)
let emptyEnv = fun x -> raise EmptyEnvException;;
let emptyFunEnv = fun x -> raise EmptyEnvException;;
    (*bind: ('a -> 'b) -> ide -> exp -> (ide -> exp ) *)
let bind env (variable: ide) value = fun y ->
            if variable = y then value else env y;;

    (*Funzioni di supporto*)
let rec getElement lista index = match lista with
    | [] -> raise OutOfBoundException
    | primo::elems -> if index = 0 then primo else getElement elems (index-1);;

let rec map lista funct = match lista with
    | [] -> []
    | elem::elems -> (funct elem)::(map elems funct);;

let rec eval (expression: exp) env funenv =
    match expression with
    | Int i -> i
    | Ide i -> env i
    | Bool i -> (match i with
                | 0 -> 0
                | 1 -> 1
                | _ -> raise TypeErrorException)
    | Add (e1, e2) -> (eval e1 env funenv) + (eval e2 env funenv)
    | Sub (e1, e2) -> (eval e1 env funenv) - (eval e2 env funenv)
    | Mul (e1, e2) -> (eval e1 env funenv) * (eval e2 env funenv)
    | Eq (e1, e2) -> if (eval e1 env funenv) = (eval e2 env funenv) then 1 else 0
    | Leq (e1, e2) -> if (eval e1 env funenv) <= (eval e2 env funenv) then 1 else 0
    | And (e1, e2) -> if eval e1 env funenv = 1 then eval e2 env funenv else 0
    | Or (e1, e2) -> if eval e1 env funenv = 1 then eval e2 env funenv else 0
    | Not (e1) -> if (eval e1 env funenv) = 1 then 0 else 1
    | Fun (funName, arg) -> (*Chiamata di funzione*)
        let value = eval arg env funenv in
                let (param, body, ambiente) = funenv funName in
                        let env1 = bind env param value in
                            eval body env1 funenv
    | IfThenElse (e1, e2, e3) -> if eval e1 env funenv = 1 then eval e2 env funenv
                                                    else eval e3 env funenv
    | LetIn (id, value, body) -> let value = eval value env funenv in
                                    let env1 = bind env id value in
                                        eval body env1 funenv
    | GetIndex (id, i) -> getElement id (eval i env funenv)
    (*| GetFirstN (exp, i) -> (eval exp env funenv) fst (eval i env funenv) *)
    | TupleEquals (exp1, exp2) -> if (eval exp1 env funenv) = (eval exp2 env funenv) then 1 else 0
    | Map (funx, exp) -> map (eval exp env funenv) (eval exp env funenv)
    | _ -> raise WrongMatchException
;;

(**TEST**)
let simpleAnd = And(Int 1, Int 1);;
let doubleAnd = And(Int 1, And(Int 1, Int 0));;
eval simpleAnd emptyEnv emptyFunEnv;;
eval doubleAnd emptyEnv emptyFunEnv;;