Hi.

I'm an italian student and I'm trying to write a quotations interpreter (evalutator) in F#.

You know, an f# namespace with some functions used to evalutate quotations already exists, thus FSharp.PowerPack.Linq.

Anyway, i'd like to develop an alternative evaluator for myself.

I wrote a function which takes an Expr and return it's value (an Object), matching the expression againts all the possible patterns.

This is a part of the function implementation:

let rec eval e =

let environment = new Dictionary<String, Object>()

let rec ieval (expr:Expr) =

match expr with

| Patterns.Var (var) ->

Console.WriteLine("Variable:: variable = {0}", var)

environment.[var.Name]

| Patterns.Value (obj, t) ->

Console.WriteLine("Value:: object = {0}, type = {1}", obj, t)

obj

| Patterns.Sequential (expr1, expr2) ->

Console.WriteLine("Sequential:: first = {0}, second = {1}", expr1, expr2)

ieval expr1 |> ignore

ieval expr2

....

ieval e

Everything seems to work except for the evalutation of lambdas.

When i try to evaluate something like:

eval <@ List.map (fun item -> 2 + item) [0..10] @>

i get an exception:

> System.ArgumentException: Object of type 'FSI_0012+QuotationEval+ieval@84-5' cannot be converted to type 'Microsoft.FSharp.Core.FastFunc`2[System.Int32,System.Int32]'.

at System.RuntimeType.CheckValue(Object value, Binder binder, CultureInfo culture, BindingFlags invokeAttr)

at System.Reflection.MethodBase.CheckArguments(Object[] parameters, Binder binder, BindingFlags invokeAttr, CultureInfo culture, Signature sig)

at System.Reflection.RuntimeMethodInfo.Invoke(Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture, Boolean skipVisibilityChecks)

at System.Reflection.RuntimeMethodInfo.Invoke(Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture)

at System.Reflection.MethodBase.Invoke(Object obj, Object[] parameters)

at <StartupCode$FSI_0013>.$FSI_0013.main@()

This exception is raised only when the map is executed. If i try to run:

eval <@ let f () = List.map (fun item -> 2 + item) [0..10] in f @>

f is not executed and so the exception is never raised.

No exception is raised also if the lambda is the top level definition in the quotation. For example:

eval <@ fun item -> item * item @>

I'm not sure how to evaluate a lambda (problems with the concept of closure). I think that, the evaluation of:

| Patterns.Lambda (var, body) ->

is a function (a FastFunc in CLI) which takes a value, bind it to var (in the environment) and return the evaluation of body made in that environment, thus:

fun (item) -> (environment.Add(var.Name, item); ieval body)

but this raises the exception above.

I also tried to construct a "context", or better a class which inherits FastFunc, with a member "var", a member "body" (both assigned in the constructor) and an overridden method (Invoke) which takes a value and returns the evaluation of body in the environment where that value is bound to "var". That's something similar to what the compiler does (it creates an on-the-fly class deriving from FastFunc).

But this raises that exception too.

Can you help me to figure out why that exception is raised and how to get things work?

Thank you really much.