How to solve this interop issue regarding out and tuple form?

Question

I made a function in F#

let tryParseArray tryParse (separator:char) (line: string) =
    // inside the function I use the tuple form of tryParse

It works fine if I call it in such way: tryParseArray Int32.TryParse ',' "2,3,2,3,2"

Now I would like this function to be available in C# as well, so I did this:

static member TryParseArray (line, tryParse, separator) =
    line |> tryParseArray tryParse separator

Then I realized that TryParseArray actually takes tryParse argument as FSharpFunc, which is not friendly to C# at all, so I tried this:

static member TryParseArray (line, [<Out>] tryParse: (string * byref<'a> -> bool), separator) =
    line |> tryParseArray tryParse separator

but now tryParseArray doesn't accept tryParse as a valid argument (type error)

What should I do?

I wish in C# I can call TryParseArray("2,3,2,3,2", Int32.TryParse, ',') as well

score 5 · Accepted Answer · edited May 23 '17 at 12:21

5

You can expose this function to C# using custom delegate type :

EDITED

// F#
module Lib

let tryParseArray parser (line : string) (sep : char) = 
    // don't know your exact implementation so again just guessing...
    line.Split sep
    |> Array.choose (fun el ->
        match parser el with
        | true, el -> Some el
        | false, _ -> None
        )

open System.Runtime.InteropServices
type TryParse<'R>  = delegate of str : string * [<Out>] res : byref<'R> -> bool

type T = 
    static member TryParse(line : string, tryParse : TryParse<'R>, separator : char) : 'R[] = 
        tryParseArray tryParse.Invoke line separator


 //C# 
 var r = Lib.T.TryParse<int>("1,2,3", int.TryParse, ',');

NOTE: on the C# side you'll need to specify type parameter for TryParse explicitly (Why don't anonymous delegates/lambdas infer types on out/ref parameters?)

edited May 23 '17 at 12:21

Community

1
1

answered Jan 25 '13 at 01:37

desco

16,642
1
45
56

1

+1 For showing how to put the `[]` attribute on a delegate param. – Daniel Jan 25 '13 at 19:04
thx, that basically solved my problem. A side query, though, in F# I am not able to `let r = Lib.T.TryParse("1,2,3", int.TryParse, ',')`, any work around? (I know I can just call `tryParseArray`) – colinfang Jan 26 '13 at 01:15
Lib.T.TryParse ("1,2,3", (fun s r -> System.Int32.TryParse(s, r)), ',') ? – desco Jan 26 '13 at 01:37
that doesn't work. I can make another TryParse for overloading specifically for F#, just wondering if there is any simplier alternative – colinfang Jan 26 '13 at 18:53

Daniel · Answer 2 · 2013-01-25T19:05:36.190

desco's solution is good, but if you wanted to avoid byref you could do something like this:

type TryParse<'R>  = delegate of string -> bool * 'R

module Util =
  [<CompiledName("TryParseArray")>]
  let tryParseArray (tryParse: TryParse<_>) (separator:char) (line: string) = ...

which can be called from F# like this:

let res = Util.tryParseArray (TryParse(Int32.TryParse)) ',' "1,2,3"

and, with the following wrapper method:

static class TryParse {
    public static Tuple<bool, int> Int32(string s) {
        int i;
        var b = System.Int32.TryParse(s, out i);
        return Tuple.Create(b, i);
    }
}

like this, from C#:

var res = Util.TryParseArray(TryParse.Int32, ',', "1,2,3");

How to solve this interop issue regarding out and tuple form?

2 Answers2