1
2
3
4
5
6
7
8

let foo x y =
    // how to define an open type (or more specifically generic method)
    // inside a function?  
    let pa (f: 'a->'b)  c = 
        f c
    // .....
    // ... ignore
    ()

The function foo in this snippet has the following signature

1

val foo : x:'t1 -> y:'t2 -> unit 

Within the scope of foo we have pa to be defined as an open type function

1

val pa : f:('t3 -> 't4) -> e:'t3 -> 't4 

Please notice that 't3 and 't4 are completely independent from 't1 and 't2.

Please correct me if I am wrong, but it is impossible to achieve this goal with the current C# type system.

Thank you.

Motivation behind the snippet:
Given:
a legacy api with a large set of methods like T ExtractXXX(...).
all of them have the same signature but different return values.
In addition,in our case all of the input parameters will be repeated in all ExtractXXX calls
we know parameters only at the runtime.
I want to define a generic helper pa such that it wraps all calls with the same signature

instead :
x = Extract_X(very long and SAME set of parameters).
y = Extract_Y(very long and SAME set of parameters).
...
z = Extract_Z(very long and SAME set of parameters).

we have
pa = ....
...
x=pa(Extract_X)
y=pa(Extract_Y)
z=pa(Extract_Z)