Arguments in active recognizers cannot be with parens, throws wrongful type mismatch FS0001 #4828

When you have an active pattern and you want to match against it, an argument cannot be placed within parens, making it impossible to use anything else than literals or variable references.

Repro steps

Consider an active pattern like this:

module Str =
    let (|ContainsAt|_|) position search (original: string) =
        if String.IsNullOrEmpty search then Some ContainsAt
        elif original.LastIndexOf search = position then Some ContainsAt
        else None

And now you apply the pattern:

module testPatterns =
    /// Fails with syntax error
    let testPattern value =
        match value with
        | Str.ContainsAt (Str.length value - 3) ":" -> ()  // FS0001, active recognizer type error

    /// Works
    let testPattern value =
        let pos = (Str.length value - 3)
        match value with
        | Str.ContainsAt pos ":" -> ()

Expected behavior

Parens are meant to group arguments, among others, so I'd expect this to work.

Actual behavior

Instead, I receive an FS0001:

In text:

Error FS0001 Type mismatch. Expecting a
'string -> 'a option'
but given a
'int -> string -> string -> unit option'
The type 'string' does not match the type 'int'

Known workarounds

Create variable bindings instead. I don't know of any workaround with syntax alone.

Related information

Recent F# versions.