Introduction:
Pattern Matching is one of
the most important tools of F Sharp programming. It
allows a programmer to make different computations, depending on matching patterns. It
decomposes data structures into their component parts. It is similar to a if..else
or switch statement in C or C++. It allows the programmer to test a value against a series of conditions and extract information depending on which conditions match.
Syntax for Pattern Matching
match exp with
| pattern1 -> result
| pattern2 -> result
|------------------
|------------------
| _ -> default
Here match and with are keyword.
Each rule of match is represented by | followed by arrow (->). Like
| pattern1 -> result meaning - if pattern
is matched (condition is true) then return result. ( _ ) denotes the default
pattern.
Different Ways to Form Patterns:-
Constant Pattern:
Input is compared with Constant pattern like, numeric, character,
string constants. If matched, then the corresponding value is returned. Note here,
the type of literal must be same type of input. We write a simple program for
constant matching.
//Constant pattern
let cons n =
match n with
| 1 -> "One"
| 2 -> "Two"
| 3 ->
"Three"
| 4 ->
"Four"
| 5 ->
"Five"
for i
in 1..5 do
printfn "%s" (cons i)
Output:
Variable Pattern:
The variable pattern assigns the
matching value to a variable which is used as result.
let vari x =
match x
with
| (fisrt, second) when first > second
-> "first number is greater"
| (first, second) when first < second
-> "second number is greater"
| (first, second) ->
"both are equal"
printfn "%s" ( vari( 1 , 2) )
Output:
OR Pattern:
The Or pattern works the same as the logical OR operator in C, C++. It is
used when the input data has multiple pattern and we want the same result for all. It is
denoted with the | operator between matching pattern.
AND Pattern:
The AND pattern works the same as logical AND operator. It is used when input
has to match with more than one pattern.
List Pattern:
The list pattern decomposes the list into the number of elements. The list
pattern matches with only the specific number of elements.
let listpattrn
n =
match n with
| [] -> 0
| [_] -> 1
| [_; _] -> 2
| [_; _; _] -> 3
printfn
" Number of element is %d" (listpattrn [ ])
printfn " Number of element is %d" (listpattrn
[ 1 ])
printfn " Number of element is %d" (listpattrn
[ 1; 1 ])
printfn " Number of element is %d" (listpattrn
[ 1; 1; 1; ])
Output:
Array pattern:
The array pattern is the same as the list pattern.
let
arrpattrn n =
match n with
| [| |] -> 0
| [|_|] -> 1
| [|_; _|] -> 2
| [|_; _; _|] -> 3
printfn " Number of Array element is %d" (arrpattrn
[| |])
printfn " Number of Array element is %d" (arrpattrn
[| 1 |])
printfn " Number of Array element is %d" (arrpattrn
[| 1; 1 |])
printfn " Number of Array element is %d" (arrpattrn
[| 1; 1; 1; |])
Output: