Back to Questions
7.1k
views8
comments
Using F#-Functions in C#
f#c#

Hi,
I have a module "MyModule.fs" with:

1
2
3

let f1 a b = a * b
let f2 a b = a + b
let f3 f a b = f a b

Now I can use the function (inside F#-Code) like this:

1
2

let a = MyModule.f3 MyModule.f2 10 20
a |> printfn "%A"

When I try to get this into C# I get a compile-error:

1
2
3

int a = MyModule.f3(MyModule.f2, 10, 20));

Error	1	The type arguments for method 'MyModule.f3<t,u,v>(Microsoft.FSharp.Core.FastFunc<t,microsoft.fsharp.core.fastfunc><u,v>>, T, U)' cannot be inferred from the usage. Try specifying the type arguments explicitly.

When I use Reflector on the F#-Code then the get:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

[CompilationMapping(SourceConstructFlags.Module)]
public static class Program
{
    // Properties
    [CompilationMapping(SourceConstructFlags.Value)]
    public static ConsoleKeyInfo a
    {
        get
        {
            return $Program.a@28;
        }
    }
    [CompilationMapping(SourceConstructFlags.Value)]
    public static int t
    {
        get
        {
            return $Program.t@24;
        }
    }
    // Nested Types
    [Serializable]
    internal class clo@24 : OptimizedClosures.FastFunc2<int, int, int>
    {
        // Methods
        public override int Invoke(int a@595, int b@595)
        {
            return Euler.f2(a@595, b@595);
        }
    }
}

public static void _main()
{
  t@24 = MyModule.f3<int, int,="" int="">(new Program.clo@24(), 10, 20);
  int num = Program.get_t();
    
  FastFunc<int, unit=""> func = Pervasives.printfn<fastfunc><int, unit="">>(
     new Format<fastfunc><int, unit="">, TextWriter, Unit, Unit, int>("%A"));
  int num2 = num;
    
  func.Invoke(num2);
  a@28 = Console.ReadKey();
}

What can I do?

.

It's because FastFunc isn't a delegate type, you'll need to convert your delegate using the FuncConvert.ToFastFunc.

Cheers,

Rob

By on 9/8/2008 4:42 AM ()

Thanks Rob. Can you write a piece of code how you would convert the function MyModule.f2 in this sample?

By on 9/8/2008 5:11 AM ()

It's actually harder than I thought:

1

int a = Module1.f3(FuncConvert.FuncFromTupled(FuncConvert.ToFastFunc(delegate(Tuple<int, int> ab) { return Module1.f2(ab.Item1, ab.Item2); })), 10, 20);

You need to supply an anonymous delegate that takes a tuple of arguments then wrap this in FuncConvert.ToFastFunc and then FuncConvert.FuncFromTupled.

Cheers,

Rob

By on 9/8/2008 6:12 AM ()

Hi,
just a short addition - if your primary goal is to use the library from C# then it may be worth to design it in a more "C#-friendly" way. Instead of using F# functions in the arguments, you can declare delegate type and using the functions from C# will then be straightforward:

1
2
3
4
5
6
7

 
> type FCallback = delegate of int*int -> int;;
type FCallback =
  delegate of int * int -> int

> let f3 (f:FCallback) a b = f.Invoke(a,b);;
val f3 : FCallback -> int -> int -> int

The C# code could then use the usual style:

1
2

 
int a = Module1.f3(Module1.f2, 10, 20); // method gets converted to the delegate automatically in C#

Hope this helps!
T.

By on 9/8/2008 6:57 AM ()

Thanks a lot.

@tomasp:
- but with your method I can't write my call in F#:

1

  let a = MyModule.f3 MyModule.f2 10 20
By on 9/8/2008 8:21 AM ()

Ok my MyModule is now:

1
2
3
4
5
6
7

let f3 f a b = f a b 

let f1 a b = a * b
let f2 a b = a + b  

let t1 = f3 f1 10 20
let t2 = f3 f2 10 20

and in C#:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

            var f2 =
                FuncConvert.FuncFromTupled(
                  FuncConvert.ToFastFunc((Tuple<int, int> ab) => MyModule1.f2(ab.Item1, ab.Item2)));

            var f1 =
                FuncConvert.FuncFromTupled(
                  FuncConvert.ToFastFunc((Tuple<int, int> ab) => MyModule1.f1(ab.Item1, ab.Item2)));

            int a = MyModule1.f3(f2, 10, 20);
            Console.WriteLine(a);

            a = MyModule1.f3(f1, 10, 20);
            Console.WriteLine(a);
            Console.ReadKey();

This works correct, but maybe there is a better solution....

By on 9/8/2008 8:41 AM ()

I think Tomas' solution is going in the right direction, you can call f3 from F# but it's a little more complex:

1

f3 (new FCallback(fun a b -> f2 a b)) 10 20;;

So you'd probably just create a version to be used from F#:

1

let f3' f = f3 (new FCallback(f));;
By on 9/8/2008 8:51 AM ()

Thank you very much.

By on 9/10/2008 5:21 AM ()

    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