Discussion: Improve F# to C# interoperability

[smoothdeveloper]

Issue with overloads and lambdas

I'm trying to make this same call: https://github.com/picoe/Eto/blob/develop/Samples/Tutorials/Tutorial4/Main.cs#L55

textBox.TextBinding.BindDataContext<MyObject>(
    r => r.TextProperty
    , (r, val) => r.TextProperty = val
);

I can write this easily in C#.

To get there in F#, this is what I would initially get working (after trying the same thing as C# code):

textBox.TextBinding.BindDataContext<_>(
            Func<MyObject,_>(fun (r) -> r.TextProperty)
            , Action<MyObject,_>(fun (r) value -> r.TextProperty <- value)
        ) |> ignore

With help of more experienced F# user I attempted this:

textBox.TextBinding.BindDataContext<MyObject>(
    fun (r : MyObject) -> r.TextProperty
    , fun (r: MyObject) value -> r.TextProperty <- value
) |> ignore

which fails due to tuple mishaps (which is easy to troubleshoot), finally settled to

textBox.TextBinding.BindDataContext<_>(
    (fun (r : MyObject) -> r.TextProperty)
    , (fun (r: MyObject) value -> r.TextProperty <- value)
) |> ignore

Is there something we can do to make C# idiomatic and FP oriented code easy to consume from F#?

This is guaranteed to annoy C# developer trying out to call their nice FP enabled API from F#, at least in cases where overload resolution or type inference significantly differs from C#/VB.NET.

Related

• F# adoption (1 - 4) How to drive F# Adoption - Part 1? #798 How to drive F# Adoption Part 2 #803 How to drive F# Adoption - Part 3 #809 How to drive F# Adoption - Part 4 #1339
• Improve C# to F# interoperability (Discussion: Improve C# to F# interoperability #1254)

[vivainio]

Naive suggestion without knowing all the type inference details: seems like a function that takes a delegate, when passed a lambda, could infer the types of the lambda arguments (and expected return value) from the generic parameters of the delegate

[smoothdeveloper]

Adding some info for that specific use case, this is what is defined in Eto.Forms:

DualBinding<TValue> BindDataContext(IndirectBinding<TValue> dataContextBinding, DualBindingMode mode = DualBindingMode.TwoWay, TValue defaultControlValue = default(TValue), TValue defaultContextValue = default(TValue))
DualBinding<TValue> BindDataContext(string propertyName, DualBindingMode mode = DualBindingMode.TwoWay)
DualBinding<TValue> BindDataContext<TObject>(Expression<Func<TObject, TValue>> propertyExpression, DualBindingMode mode = DualBindingMode.TwoWay)
DualBinding<TValue> BindDataContext<TObject>(Func<TObject, TValue> getValue, Action<TObject, TValue> setValue, Action<TObject, EventHandler<EventArgs>> addChangeEvent = null, Action<TObject, EventHandler<EventArgs>> removeChangeEvent = null, DualBindingMode mode = DualBindingMode.TwoWay, TValue defaultGetValue = default(TValue), TValue defaultSetValue = default(TValue))

(Looking at the signatures, this gives back some faith in F# 🙂)

I can understand that the compiler has work picking the correct overload, although C# handles it gracefully with less information.

The issue I intend to discuss is what can we do in F# to smoothen the interop with Func / Action / delegates as lambda and make the F# code look closer to the idiomatic C# call?

[dsyme]

Can you do this?

textBox.TextBinding.BindDataContext<MyObject>(
    (fun r -> r.TextProperty), (fun r value -> r.TextProperty <- value)
) |> ignore

If so this boils down to existing suggestions to allow fun x -> y to be x => y with different precedence (i.e. no parentheses)?

[dsyme]

(Note language design should really be discussed in fslang-suggestions, slack, stackoverflow etc please, though some discussion threads are used in this repo)

[smoothdeveloper]

@dsyme I can't do that, it was my initial attempt, it fails to infer MyObject on .TextProperty

Lookup on object of indeterminate type based on information prior to this program point. A type annotation may be needed prior to this program point to constrain the type of the object. This may allow the lookup to be resolved.

For both call sites.

Sorry I'm using this repository as I intended to have discussion before we can identify if a plausible language suggestion can be drafted.

[ReedCopsey]

@dsyme That works (even without specifying ) in a simple case - I'm not sure if it's one of the overloads, or the optional arguments, that breaks it.

For example, this works fine:

open System

type Test<'b> () =
    member __.BindDataContext<'a> (getValue : Func<'a,'b>, setValue : Action<'a,'b>) = ()
    member __.BindDataContext (setValue : 'b) = ()
    
type R = { mutable Foo : string }
let r = { Foo = "Foo" }
let t = Test<string> ()

t.BindDataContext( (fun f -> f.Foo), (fun f v -> f.Foo <- v) )

[smoothdeveloper]

I confirm the case I'm facing is a bit ill due to presence of complex overloads, but I've seen similar cases where lambda syntax won't work as I'd expect (with C# background), requiring more annotations.

It would be great if we could identify some ways to make inference and lambda work in more cases (when overload resolution is involved), if we have good certainty this won't be breaking change, which I understand this could be tricky.

In this case, we have only 2 overloads with a generic parameter, and only one can accept 2 delegates, so we might be able to get it work in this specific case.

[smoothdeveloper]

@dsyme regarding the extra parens around fun x -> y, I don't consider it a big issue (although for C# users, this is a bit odd), I guess it would be breaking change if there was an overload taking a Tuple<Func<TObject,TValue>, Action<TObject,TValue>> so I don't think it is needed.

I'll search the suggestion and put a 👎 on it 😄

[cartermp]

Closing old discussion

[smoothdeveloper]

Another head scratching overload resolution situation:

open System
open System.Threading.Tasks
let makeTask () = new Task<_>(fun () -> 1)
let task = makeTask()
//let runningTask = Task.Run(fun () -> task) // can't find overload
//let runningTask = Task.Run(Func<_>(fun () -> task)) // can't find overload
//let runningTask = Task.Run<_>(Func<_>(fun () -> task)) // can't find overload
//let runningTask : Task<_> = Task.Run<_>(Func<_>(fun () -> task)) // can't find overload
//let runningTask = Task.Run(Func<Task<_>>(fun () -> task)) // can't find overload
//let runningTask = Task.Run(Func<Task<int>>(fun () -> task)) // can't find overload
//let runningTask = Task.Run<int>(Func<Task<int>>(fun () -> task)) // can find overload!
//let runningTask = Task.Run<int>(Func<Task<_>>(fun () -> task)) // can find overload!
//let runningTask = Task.Run<int>(Func<_>(fun () -> task)) // can find overload!
let runningTask = Task.Run<int>(fun () -> task) // can find overload!

there is no way to use type inference to omit the return type of the task in this example.

[smoothdeveloper]

The equivalent C#:

using System;
using System.Threading.Tasks;
Task<int> makeTask => new Task<int>(() => 1);
var task = makeTask();
var runningTask = Task.Run(() => task);

I got the code checking on first attempt and without annotating the call to Task.Run.

@dsyme is there any plan to make the overload resolution work better in such cases? Many C# APIs rely on similar overloads and calling it from F# is a tedious exercise in fighting with the compiler to make it pick the correct one.