@@ -1,27 +1,22 @@
1−## Pattern Matching
1+Pattern Matching
2+================
23
34Pattern matching deconstructs a value to bring zero or more expressions into scope. Pattern matches are introduced with the `case` keyword.
45
5−Pattern matches have the following general form
6+Pattern matches have the following general form::
67
7−```haskell
8−case value of
9− pattern -> result
10− -- ...
11− pattern -> result
12−```
8+ case value of
9+ pattern -> result
10+ ...
11+ pattern -> result
1312
14−Pattern matching can also be used in the declaration of functions, as we have already seen:
13+Pattern matching can also be used in the declaration of functions, as we have already seen::
1514
16−```haskell
17−fn pattern_1 ... pattern_n = result
18−```
15+ fn pattern_1 ... pattern_n = result
1916
20−Any of the above types of pattern are also valid when introducing functions. In addition, patterns can also be grouped in parentheses to introduce multiple-arugument functions. For example,
17+Any of the above types of pattern are also valid when introducing functions. In addition, patterns can also be grouped in parentheses to introduce multiple-arugument functions. For example::
2118
22−```haskell
23−example x (y, z) w = x * y + z * w
24−```
19+ example x (y, z) w = x * y + z * w
2520
2621The following pattern types are supported:
2722
@@ -36,126 +31,109 @@ The following pattern types are supported:
3631
3732Patterns need not be exhaustive. A pattern match failed exception will be thrown at runtime if no pattern matches the input.
3833
39−## Wildcard Patterns
34+Wildcard Patterns
35+-----------------
4036
41−The wilcard `_` matches any input and brings nothing into scope:
37+The wilcard `_` matches any input and brings nothing into scope::
4238
43−```haskell
44−case x of
45− _ -> 0
46−```
39+ case x of
40+ _ -> 0
4741
48−## Literal Patterns
49−
50−Literal patterns are provided to match on primitives:
51−
52−```haskell
53−case booleanValue of
54− true -> 0
55− false -> 1
56−
57−case stringValue of
58− "Foo" -> 0
59− _ -> 1
42+Literal Patterns
43+----------------
44+
45+Literal patterns are provided to match on primitives::
46+
47+ case booleanValue of
48+ true -> 0
49+ false -> 1
50+
51+ case stringValue of
52+ "Foo" -> 0
53+ _ -> 1
6054
61−case numericValue of
62− 0 -> 0
63− _ -> 1
64−```
55+ case numericValue of
56+ 0 -> 0
57+ _ -> 1
6558
66−## Variable Pattern
59+Variable Patterns
60+-----------------
6761
68−A variable pattern matches any input and binds that input to its name:
62+A variable pattern matches any input and binds that input to its name::
6963
70−```haskell
71−case foo(x) of
72− result -> bar(result)
73−```
64+ case foo(x) of
65+ result -> bar(result)
7466
75−## Array Patterns
67+Array Patterns
68+--------------
7669
77−Array patterns match an input which is an array, and bring its elements into scope.
70+Array patterns match an input which is an array, and bring its elements into scope. For example::
7871
79−For example:
80−
81−```haskell
82−f = \arr -> case arr of
83− [x] -> x
84− [x, y] -> x * y + f xs
85− _ -> 0
86−```
72+ f = \arr -> case arr of
73+ [x] -> x
74+ [x, y] -> x * y + f xs
75+ _ -> 0
8776
8877Here, the first pattern only matches arrays of length one, and brings the first element of the array into scope.
8978
9079The second pattern matches arrays with two elements, and brings the first and second elements into scope.
9180
92−## Cons Patterns
93−
94−The head and tail of a non-empty array can be matched by using a cons pattern:
81+Cons Patterns
82+-------------
9583
96−```haskell
97−add = \arr -> case arr of
98− [] -> 0
99− x : xs -> x + add xs
100−```
84+The head and tail of a non-empty array can be matched by using a cons pattern::
10185
102−`:` associates to the right:
86+ add = \arr -> case arr of
87+ [] -> 0
88+ x : xs -> x + add xs
10389
104−```haskell
105−addPairs = \arr -> case arr of
106− x : y : xs -> x * y + addPairs xs
107− _ -> 0
108−```
90+`:` associates to the right::
10991
110−## Record Patterns
92+ addPairs = \arr -> case arr of
93+ x : y : xs -> x * y + addPairs xs
94+ _ -> 0
11195
112−Record patterns match an input which is a record, and bring its properties into scope.
96+Record Patterns
97+---------------
11398
114−```haskell
115−f = \o -> case o of
116− { foo = "Foo" } -> o.bar
117− _ -> 0
118−```
99+Record patterns match an input which is a record, and bring its properties into scope::
119100
120−## Nested Patterns
101+ f = \o -> case o of
102+ { foo = "Foo" } -> o.bar
103+ _ -> 0
121104
122−The patterns above can be combined to create larger patterns.
105+Nested Patterns
106+---------------
123107
124−For example:
108+The patterns above can be combined to create larger patterns. For example::
125109
126−```haskell
127−f = \o -> case o of
128− { arr = x : _, take = "car" } -> x
129− { arr = _ : x : _, take = "cadr" } -> x
130− _ -> 0
131−```
110+ f = \o -> case o of
111+ { arr = x : _, take = "car" } -> x
112+ { arr = _ : x : _, take = "cadr" } -> x
113+ _ -> 0
132114
133−## Named Patterns
115+Named Patterns
116+--------------
134117
135−Named patterns bring additional names into scope when using nested patterns. Any pattern can be named by using the `@` symbol:
118+Named patterns bring additional names into scope when using nested patterns. Any pattern can be named by using the `@` symbol::
136119
137−```haskell
138−f = \arr -> case arr of
139− a@(_ : _ : _) -> true
140− a -> false
141−```
120+ f = \arr -> case arr of
121+ a@(_ : _ : _) -> true
122+ a -> false
142123
143124Here, in the first pattern, any array with two or more elements will be matched and bound to the variable `a`.
144125
145−## Guards
126+Guards
127+------
146128
147−Guards are used to impose additional constraints inside a pattern using boolean-valued expressions, and are introduced with a pipe after the pattern:
129+Guards are used to impose additional constraints inside a pattern using boolean-valued expressions, and are introduced with a pipe after the pattern::
148130
149−```haskell
150−evens = \arr -> case arr of
151− [] -> 0
152− x : xs | x % 2 == 0 -> 1 + evens xs
153− _ : xs -> evens xs
154−```
131+ evens = \arr -> case arr of
132+ [] -> 0
133+ x : xs | x % 2 == 0 -> 1 + evens xs
134+ _ : xs -> evens xs
155135
156−When defining a function, guards appear after all patterns:
136+When using patterns to define a function at the top level, guards appear after all patterns::
157137
158−```haskell
159−greater x y | x > y = true
160−greater _ _ = false
161−```
138+ greater x y | x > y = true
139+ greater _ _ = false