Is it possible to use patterns for an active pattern's argument?

Question

I have the following active pattern:

let (|IgnoreCase|_|) (arg: string) (input: string) 
    if String.Equals(argument, input, StringComparison.OrdinalIgnoreCase)
    then Some()
    else None

Normally, you would have to use this pattern individually for each case and do something like this:

function
| IgnoreCase "string1" 
| IgnoreCase "string2" 

What I would like to do is be able to use other matching expressions with the active pattern, for example:

function
| IgnoreCase ("string1" | "string2") // OR pattern
| IgnoreCase ("string1" & "string2") // AND pattern

That returns the error "Invalid argument to parameterized pattern label". I know you can do that using discriminated unions, so it seems like it should be possible using active patterns.

Answer 1

The way you've written the active pattern, it takes a string argument and checks if the input matches the string - this way, there is no way of turning the argument into a pattern itself.

In this particular case, & does not really make sense - but if you just wanted to support |, you could pass a list of arguments:

let (|IgnoreCase|_|) (args: string list) (input: string) =
  if args |> List.exists (fun arg -> 
    String.Equals(arg, input, StringComparison.OrdinalIgnoreCase))
  then Some() else None

function
| IgnoreCase ["string1"; "string2"] -> 1
| _ -> 0

If you wanted something more sophisticated, you would need to structure the logic so that the active pattern returns something that can be further matched. One option might be to have pattern that turns the input into lower-case, because then you can specify composed pattern for the lower-cased string:

let (|AsLowerCase|_|) (input: string) =
  Some(input.ToLowerInvariant())

function
| AsLowerCase("string1" | "string2") -> 1
| AsLowerCase("string1" & "string2") -> 1 
| _ -> 0

This makes the syntax with & syntactically valid, but it will never match. You could however have other patterns like StartsWith and EndsWith so this would then make sense, e.g. to write AsLowerCase(StartsWith "foo" & EndsWith "bar")