Why Does F# Pattern Matching for a String Type Match a ReadOnlySpan<char>?

Let's say I wanted to find a particular TryParse method for a given type, namely the one that parses from a string. To my surprise, the following code returns 2 methods: one with a string as first parameter, but also one with a ReadOnlySpan<char> as first parameter.

I include this not-so-minimal example because it turns out to be somewhat hard to 'just' create ReadOnlySpans in F# on the fly.

The second element in the result list is unexpected for me. How would I change the pattern matching at [1] to exclude it?

typeof<uint64>.GetMember("TryParse")
|> Seq.cast<MethodBase>
|> Seq.choose (fun m ->
    let parameterTypes =
        m.GetParameters()
        |> Array.map (fun p -> (p.ParameterType, p.Attributes))
    // [1]
    match parameterTypes with
    | [| (string, ParameterAttributes.None); (uint64, ParameterAttributes.Out) |] -> Some m
    | _ -> None)
|> Seq.toList
|> List.map (fun m -> (m.Name, m.GetParameters() |> Array.map (fun p -> p.ParameterType.FullName)))

(*
val it: (string * string array) list =
  [("TryParse", [|"System.String"; "System.UInt64&"|]);
   ("TryParse",
    [|"System.ReadOnlySpan`1[[System.Char, System.Private.CoreLib, Version=7.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e]]";
      "System.UInt64&"|])]
*)

Your code finds both versions of TryParse because you've declared variables named string and uint64, which match on any value. To fix this, you need to compare against the actual types:

typeof<uint64>.GetMember("TryParse")
|> Seq.cast<MethodBase>
|> Seq.choose (fun m ->
    let parameterTypes =
        m.GetParameters()
        |> Array.map (fun p -> (p.ParameterType, p.Attributes))
    if parameterTypes = [| (typeof<string>, ParameterAttributes.None); (typeof<uint64>.MakeByRefType(), ParameterAttributes.Out) |] then
        Some m
    else
        None)
|> Seq.toList
|> List.map (fun m -> (m.Name, m.GetParameters() |> Array.map (fun p -> p.ParameterType.FullName)))

Note that you have to use typeof to get a type at runtime, and then call MakeByRefType.

When you use an identifier in a pattern, you're not testing equality with an existing value (or type). Instead, you're defining a pattern that always matches, and giving the matched value the given name in the scope following the pattern.

To test for equality, you need to use a when guard instead:

    match parameterTypes with
    | [| (arg1, ParameterAttributes.None); (arg2, ParameterAttributes.Out) |]
        when arg1 = typeof<string> && arg2 = typeof<uint64>.MakeByRefType()
        -> Some m
    | _ -> None