Back to Questions
1.1k
views2
comments
Quotations - Call active pattern in CTP
f#

Hello guys !

I just would like to do as a learning exercise a basic printf of a simple quoted function, but I can't figure out how to use the new Call active pattern.

#light

open System
open System.Collections.Generic

open Microsoft.FSharp.Quotations
open Microsoft.FSharp.Quotations.Patterns
open Microsoft.FSharp.Quotations.DerivedPatterns
open Microsoft.FSharp.Quotations.ExprShape

[<ReflectedDefinition>]
let foobar x =
let i = if (x = 0.5f) then 0.0f else 1.0f
let j = 4.0f
(i + j)

let interpret expr =
let rec interpretInner uexpr =
match uexpr with
| Let (var, value, body) ->
// Recognizes: let <var> = <value> in <body>
sprintf "let %s = %s in %s" var.Name (interpretInner value) (interpretInner body)

| Int32 x ->
// Recognizes a 32 bits signed integer
sprintf "%d" x

| UInt32 x ->
// Recognizes a 32 bits unsigned integer
sprintf "%d" x

| Single x ->
// Recognizes a 32 bits float
sprintf "%.1ff" x

| IfThenElse (c, a, b) ->
sprintf "if (%s) then %s else %s" (interpretInner c) (interpretInner a) (interpretInner b)

| Var(var) ->
// Recognizes a variable reference
sprintf "%s" var.Name

| Lambda(var, body) ->
// Recognizes a lambda function
sprintf "fun %s -> %s" var.Name (interpretInner body)

| Application(x, y) ->
// Recognizes an application of an lambda expression
sprintf "%s (%s)" (interpretInner x) (interpretInner y)

| Call (ex, mi, l) ->
match ex with
| Some(e) -> "?"
| None -> "Help I'm stuck!"

expr |> interpretInner

printf "%s" (interpret <@@foobar@@>)

let a = Console.ReadLine()

thanks!

Russell Bell

.

Hi Russell,
The Call pattern represents any invocation (in CTP, the thing that is being called is represented as a standard .NET MethodInfo object, which represents information about method). The first argument (ex) is an instance of an object if the call is a method call (or None for an ordinary function call). The second argument is MethodInfo and the last argument is the list of arguments.

To extract the quotation of a function with "ReflectedDefnition" attribute, you can use MethodWithReflectedDefinition pattern. The Call case for your code would look like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

 
    | Call(inst, meth, l) ->
        // extract the body - 
        //  for ReflectedDefinition, extract the lambda expression representing the function
        //  otherwise, we just return the name of the function/method
        let body =
          match meth with 
          | MethodWithReflectedDefinition(expr) ->
              sprintf "(%s)" (interpretInner expr)
          | _ -> meth.Name
          
        // Convert all arguments to string and separate them with spaces
        let args = l |> List.fold_left (fun s ex -> 
          sprintf "%s (%s)" s (interpretInner ex) ) ""
        
        // Extract the instance (returns either "obj." or just empty string)
        let instance = 
          match inst with
          | Some(e) -> (interpretInner e) + "."
          | _ -> ""
          
        sprintf "%s%s %s" instance body args

Hope this helps!
T.

By on 9/3/2008 4:23 PM ()

Thanks Tomáลก! I appreciated your help.

Now, I would like, as a learning exercise again, to transform the F# AST in a procedural code, something like C++ or Java.
What are the best practices for this kind of task ?

Many thanks.

Russell

By on 9/10/2008 3:41 PM ()

    Topic tags

    IntelliFactory Offices Copyright (c) 2011-2012 IntelliFactory. All rights reserved.
    Home | Products | Consulting | Trainings | Blogs | Jobs | Contact Us | Terms of Use | Privacy Policy | Cookie Policy     		Built with WebSharper