Question: What is the difference between as and & in pattern matching?

[xp44mm]

I found that as and & were very similar in pattern matching, so I did the test.

let testP1(x) =
    match (x) with
    | [a] & c -> //&
        Console.WriteLine(Literal.stringify a)
        Console.WriteLine(Literal.stringify c)
    | c -> ()

let testK1(x) =
    match (x) with
    | [a] as c -> //as
        Console.WriteLine(Literal.stringify a)
        Console.WriteLine(Literal.stringify c)
    | c -> ()

let testP2(x) =
    match (x) with
    | (a,b) & c -> //&
        Console.WriteLine(Literal.stringify a)
        Console.WriteLine(Literal.stringify b)
        Console.WriteLine(Literal.stringify c)

let testK2(x) =
    match (x) with
    | (a,b) as c -> //as
        Console.WriteLine(Literal.stringify a)
        Console.WriteLine(Literal.stringify b)
        Console.WriteLine(Literal.stringify c)

run it:

    let x = [1]
    testP1 x
    testK1 x

    let y = (2,3)
    testP2 y
    testK2 y

Unsurprisingly, the outputs are the same for both.

With & can implement the function, why define an additional as? Which is the official recommended way of writing?

[Happypig375]

Different syntactical precedence. Try inserting | on the left hand side.

[Happypig375]

Also, if left hand side is a type test, :? int as x has type of x as int, while :? int & x has type of x uncasted.

[xp44mm]

@Happypig375 Punctuation & requires parentheses, while keyword as do not require parentheses.

let testP3(x) =
    match (x) with
    | ([a] | [a;_]) & c -> 
        Console.WriteLine(Literal.stringify c)

let testK3(x) =
    match (x) with
    | [a] | [a;_] as c -> 
        Console.WriteLine(Literal.stringify c)

[Happypig375]

Yes, this is one of the differences.

[Happypig375]

Also, if left hand side is a type test, :? int as x has type of x as int, while :? int & x has type of x uncasted.

[abelbraaksma]

Good question! Here's my way of understanding these constructs:

• | inside patterns is an OR-pattern: match x with 1 | 2 | 3 -> "good" means: 1 or 2 or 3
• & inside patterns is an AND-pattern: match x with 1 & 2 & 3 -> "impossible" means: 1 and 2 and 3, which is impossible
• as grabs the outer pattern and captures it in the variable name. Inside an OR- or AND-pattern, all branches must be of equal type. match x with Some 1 as y -> ... grabs the whole option in variable y, in other words, y and x are copies of one another here.
• Any lower-case identifier works as a catch-all variable. If you have match 12 with 1 & 2 & x -> x, the last x does not add to your business logic, it is always true, as it catches any value. The expression as a whole will still be false, as 1 & 2 can never be true.

Note that you can mix and match:

match x with
| Ok(Some y as opt) as res -> ...
    // res is a Result<Option, _>.Ok
    // opt is an Option.Some
    // y is the value inside Option.Some

Using the "catch-all" variable, you can get the same with OR or AND patterns, but they're subtly different, because AND requires all items to be true, so it looks as if it is similar to as when you add a & x to your pattern, as that clause will always be true.

For OR patterns, that doesn't work, because the lh-side may be false and the rh-side may be true. So, for OR patterns, all captures must be of the same type on each branch:

AND

Here's where & is used for the sole purpose of capturing. I'd advise against this use as there's no added benefit in doing so, where you could just as easily have used as to explicitly bind to a variable.

match x with
| Ok(Some y & opt) & res -> ...
   // same as above, but for different reasons, the rh-side of '&' is always true as we just capture to a variable

Should note that a more sensible use of & is its boolean logic meaning:

match x with
| Ok(StartsWith "foo" & EndsWith "bar") as res -> ...
   // now, a string needs to start with "foo" AND end with "bar"

OR

Here you can see that you can capture just as well to a variable using |, but as mentioned above, all parts of the | must bind to the same variable type and set, or you will get compile errors.

Note that the last as res captures the state of either of both preceding |-clauses.

match x with
| Ok(Some _ as opt | opt) | Error(Some _ | None as opt) as res -> ...
    // opt can be both None or Some here
    // res is a Result<Option, Option>
    // y is not here, because there's no sensible way to use it as above