在F＃中你如何获得函数的参数？

Question

Given a list of functions, how do you extract a list containing the type of the first parameter for each function in the list?

The list is defined as:

let messageHandlers = [
    fun (message: MessageA) -> (), // Cast
    fun (message: MessageB) -> () // Cast
]

The list of types could then be defined as:

let getFirstParam x = x.GetType().UseReflectionToGetTheParameters

let types = List.map getFirstParam messageHandlers

I would have expected a list called Parameters or something similar on the FSharpFunc however I can't find one.

Answer 1

How about getting the types statically instead, to avoid the risk of error, like this:

let messageHandlers, types =
    let withArgType (f: 'T -> unit) = (f :> obj, typeof<'T>)
    [
        withArgType (fun (param1: MessageA) -> ())
        withArgType (fun (param1: MessageB) -> ())
    ]
    |> List.unzip

Answer 2

Firstly, a list can't contain elements of different types. Therefore, all the functions in your methods list will have the exact same first parameter.

But ok, you can technically get around that by erasing the type of the functions (ie casting them to obj ):

let methods = [
   (fun (param1: MyRecordType) -> ()) :> obj
   (fun (param1: AnotherType) -> ()) :> obj
]

Now you've got yourself a nice obj list , in which every element is actually a function. Except that's not known at compile time, because you've casted them to obj .

Now, functions in F# are represented by the class FSharpFunc<_,_> . The first generic parameter is input, the second - output. So you can just take the first generic argument, and that's your answer:

let paramType = fn.GetType().GetGenericArguments().[0]

Except I would also put a safeguard in place to make sure that the obj I'm passed is actually a function:

let funcType = typeof<FSharpFunc<_,_>>.GetGenericTypeDefinition()

let getFunctionParamType fn =
   let fnType = fn.GetType()
   if fnType.IsGenericType && 
      funcType.IsAssignableFrom (fnType.GetGenericTypeDefinition())
   then
      Some (fnType.GetGenericArguments().[0])
   else
      None

NOTE: it is necessary to use funcType.IsAssignableFrom (as opposed to just comparing with funcType = ), because some functions could be implemented as a custom class that's derived from FSharpFunc<_,_> .

Update : as kvb points out in the comments, for a more solid solution, one may use FSharpType.GetFunctionElements and FSharpType.IsFunction functions, which essentially wrap the above logic in a more convenient, F#-friendly way:

let getFunctionParamType fn =
   if FSharpType.IsFunction fn && 
      let input, output = FSharpType.GetFunctionElements fn
      Some input
   else
      None

Beware though: reflection is a tricky thing, easy to get wrong and prone to silent failures. Judging by your question, you don't really understand how it all works, which would be a strong contraindication for using it. Perhaps if you described your overarching problem, someone would be able to offer a better solution.

Answer 3

Inspired by Tarmil's great answer I ended up getting the types statically but I also wrapped each function in a more general function.

let messageHandlers, types =
    let withArgType (f: 'T -> unit) = 
        let genericFunc = fun (o: obj) -> (f (o :?> 'T))
        (genericFunc, typeof<'T>)
    [
        withArgType (fun (message: MessageA) -> ())
        withArgType (fun (message: MessageB) -> ())
    ]
    |> List.unzip