Accepting FSharpFunc where Func is expected

Question

As mentioned in this question, methods expecting a Func will not accept an F# function value.

What's a good approach to overloading a method such that it will accept F# function values?

Balsam

Answer 1

I know this is not what you're asking, but instead of directly attempting to support F# from code written in C# (as I get the impression that you're trying to do), it would be more idiomatic to provide a small adapter module to make functional composition easier from F#.

There are many examples of this, such as FSharp.Reactive, which provides functions to make it easier to use Reactive Extensions from F#.

For example, if you want to access Enumerable.All from F#, you could write a little adapter function, e.g.

let all f (s : 'a seq) = s.All (fun x -> f x)

which you could then use like this:-

seqA |> all abc

However, in the case of All, you can use the built-in F# functions for that:

seqA |> Seq.forall abc

Pretty

Answer 2

Wouldn't just creating a Func<,> be enough?

let doSomethingWithFunc (f : System.Func<_,_>) =
    42

let doSomethingWithFSharpFunc (f : 'a -> 'b) =
    System.Func<_,_>(f) |> doSomethingWithFunc

(fun x -> 42) |> doSomethingWithFSharpFunc

Granese

Answer 3

Using the code from your initial question, the easiest solution is to create an instance of the expected delegate (Func<int, bool> in this case) and pass the function value as the argument.

let seqA = { 1..10 }
let abc = fun n -> n > 0
seqA.All (Func<_,_> abc)

Patryk noted this syntax in his comment, but I thought I'd add an explanation of what is truly happening.

Nattie

Answer 4

Here's another approach:

open System
open System.Collections.Generic
open System.Linq

type IEnumerable<'T> with
    member this.All(pred: 'T -> bool) = this.All(Func<_,_> pred)

let even n = n % 2 = 0

let seqA = seq { 0..2..10 }

seqA.All(even) |> printfn "%A"

Balsam

Answer 5

Here's an example of passing an F# function value to IEnumerable.All:

open System.Linq
open IEnumerableAllFSharpFunc

let seqA = seq { 1..10 }

let abc n = n > 0

seqA.All abc |> printfn "%A"

given this extension method on IEnumerable.All:

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.FSharp.Core;

namespace IEnumerableAllFSharpFunc
{
    public static class Utils
    {
        public static bool All<T>(this IEnumerable<T> seq, FSharpFunc<T, bool> pred)
        {
            var converter = FSharpFunc<T, bool>.ToConverter(pred);

            Func<T, bool> func = (elt) => converter(elt);

            return seq.All(func);
        }
    }
}

More elegant approaches welcome. :-)

Balsam

@PatrykĆwiek: That works, but is actually not a cast. It's equivalent to seqA.All(new Func<_,_>(abc)). Casts in F# take the form x <op> 'T where <op> is :> or :?>. – Nattie