git.iko.soy/rowtype-yoga/purescript-native
on golang help sign in
Create patterns.rst
7086b56Phil Freeman
docs/source/patterns.rstnew file+161
compare with golang
unifiedsplit
@@ -0,0 +1,161 @@
1+## Pattern Matching
2+
3+Pattern matching deconstructs a value to bring zero or more expressions into scope. Pattern matches are introduced with the `case` keyword.
4+
5+Pattern matches have the following general form
6+
7+```haskell
8+case value of
9+ pattern -> result
10+ -- ...
11+ pattern -> result
12+```
13+
14+Pattern matching can also be used in the declaration of functions, as we have already seen:
15+
16+```haskell
17+fn pattern_1 ... pattern_n = result
18+```
19+
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,
21+
22+```haskell
23+example x (y, z) w = x * y + z * w
24+```
25+
26+The following pattern types are supported:
27+
28+- Wildcard pattern
29+- Literal patterns
30+- Variable pattern
31+- Array patterns
32+- Cons patterns
33+- Record patterns
34+- Named patterns
35+- Guards
36+
37+Patterns need not be exhaustive. A pattern match failed exception will be thrown at runtime if no pattern matches the input.
38+
39+## Wildcard Patterns
40+
41+The wilcard `_` matches any input and brings nothing into scope:
42+
43+```haskell
44+case x of
45+ _ -> 0
46+```
47+
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
60+
61+case numericValue of
62+ 0 -> 0
63+ _ -> 1
64+```
65+
66+## Variable Pattern
67+
68+A variable pattern matches any input and binds that input to its name:
69+
70+```haskell
71+case foo(x) of
72+ result -> bar(result)
73+```
74+
75+## Array Patterns
76+
77+Array patterns match an input which is an array, and bring its elements into scope.
78+
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+```
87+
88+Here, the first pattern only matches arrays of length one, and brings the first element of the array into scope.
89+
90+The second pattern matches arrays with two elements, and brings the first and second elements into scope.
91+
92+## Cons Patterns
93+
94+The head and tail of a non-empty array can be matched by using a cons pattern:
95+
96+```haskell
97+add = \arr -> case arr of
98+ [] -> 0
99+ x : xs -> x + add xs
100+```
101+
102+`:` associates to the right:
103+
104+```haskell
105+addPairs = \arr -> case arr of
106+ x : y : xs -> x * y + addPairs xs
107+ _ -> 0
108+```
109+
110+## Record Patterns
111+
112+Record patterns match an input which is a record, and bring its properties into scope.
113+
114+```haskell
115+f = \o -> case o of
116+ { foo = "Foo" } -> o.bar
117+ _ -> 0
118+```
119+
120+## Nested Patterns
121+
122+The patterns above can be combined to create larger patterns.
123+
124+For example:
125+
126+```haskell
127+f = \o -> case o of
128+ { arr = x : _, take = "car" } -> x
129+ { arr = _ : x : _, take = "cadr" } -> x
130+ _ -> 0
131+```
132+
133+## Named Patterns
134+
135+Named patterns bring additional names into scope when using nested patterns. Any pattern can be named by using the `@` symbol:
136+
137+```haskell
138+f = \arr -> case arr of
139+ a@(_ : _ : _) -> true
140+ a -> false
141+```
142+
143+Here, in the first pattern, any array with two or more elements will be matched and bound to the variable `a`.
144+
145+## Guards
146+
147+Guards are used to impose additional constraints inside a pattern using boolean-valued expressions, and are introduced with a pipe after the pattern:
148+
149+```haskell
150+evens = \arr -> case arr of
151+ [] -> 0
152+ x : xs | x % 2 == 0 -> 1 + evens xs
153+ _ : xs -> evens xs
154+```
155+
156+When defining a function, guards appear after all patterns:
157+
158+```haskell
159+greater x y | x > y = true
160+greater _ _ = false
161+```