git.iko.soy/rowtype-yoga/purescript-native
on golang help sign in
Update syntax.rst
fbb9e25Phil Freeman
docs/source/syntax.rst+68−192
compare with golang
unifiedsplit
@@ -1,231 +1,107 @@
1−## Whitespace
1+Syntax
2+======
2
3
3−Syntax is whitespace sensitive. The general rule of thumb is that declarations which span multiple lines should be indented past the column on which they were first defined on their subsequent lines.
4+Whitespace Rules
4−
5+----------------
5−That is, the following is valid:
6−
7−```haskell
8−foo = bar(x) +
9− baz(x)
10−```
11−
12−But this is not:
13−
14−```haskell
15−foo = bar(x) +
16−baz(x)
17−```
18−
19−## Blocks
20−
21−Blocks are collections of statements wrapped in braces `{ ... }`. Blocks must return a value of the same type on every branch of execution.
22−
23−The following types of statement are supported:
24−
25−- Variable introduction
26−- Variable assignment
27−- For loops
28−- For-each loops
29−- While loops
30−- If-Then-Else statements
31−
32−Here is an example of a power function defined using a block:
33−
34−```haskell
35−pow n p = {
36− var m = n;
37− for (i <- 0 until p) {
38− m = m * n;
39− }
40− return m;
41− }
42−```
43−
44−Blocks enable local mutation of their variables, but mutation is not allowed in general. The type system prevents mutable variables from escaping their scope.
45−
46−That is, while the example above is valid, the following does not compile:
47
6
48−```haskell
7+Syntax is whitespace sensitive. The general rule of thumb is that declarations which span multiple lines should be indented past the column on which they were first defined on their subsequent lines.
49−incr n = {
50− n = n + 1;
51− return n;
52− }
53−```
54−
55−The variable `n` is not mutable, and so the assignment in the first line of the `do` block is not allowed.
56−
57−This function can be rewritten as follows:
58−
59−```haskell
60−incr n = {
61− var m = n;
62− m = m + 1;
63− return m;
64− }
65−```
66
8
67−## For Loops
9+That is, the following is valid::
68
10
69−For loops look like this:
11+ foo = bar(x) +
12+ baz(x)
70
13
71−```haskell
14+But this is not::
72−total = {
73− var n = 0;
74− for (i <- 0 until 10) {
75− n = n + i;
76− }
77− return n;
78− }
79−```
80
15
81−The bounds `0` and `10` are inclusive and exclusive respectively.
16+ foo = bar(x) +
82−
17+ baz(x)
83−## For-Each Loops
84−
85−For each loops loop over the elements in an array using the `Object.forEach` method. A polyfill may be required for some browsers:
86−
87−```haskell
88−total arr = {
89− var n = 0;
90− foreach (i in arr) {
91− n = n + i;
92− }
93− return n;
94− }
95−```
96−
97−## While Loops
98−
99−The syntax of a while loop is similar to a foreach loop:
100−
101−```haskell
102−log2 n = {
103− var count = 0;
104− var m = n;
105− while (m > 1) {
106− m = m / 2;
107− count = count + 1;
108− }
109− return count;
110− }
111−```
112−
113−## If-Then-Else Statements
114−
115−Else branches are optional, and may contain further `if` statements, just as in Javascript:
116−
117−```haskell
118−collatz n = {
119− var count = 0;
120− var m = n;
121− while (m > 1) {
122− if (m % 2 == 0) {
123− m = m / 2;
124− } else {
125− m = m * 3 + 1;
126− }
127− count = count + 1;
128− }
129− return count;
130− }
131−```
132
18
133−## If-Then-Else Expressions
19+If-Then-Else Expressions
20+------------------------
134
21
135−The `if`, `then` and `else` keywords can also be used to create conditional expressions. In this case, the `else` block is always required.
22+The `if`, `then` and `else` keywords can be used to create conditional expressions. In this case, the `else` block is always required.
136
23
137−For example,
24+For example::
138
25
139−```haskell
140−conditional = if 2 > 1 then "ok" else "oops"
26+ conditional = if 2 > 1 then "ok" else "oops"
141−```
142
27
143−## Do Notation
28+Do Notation
29+-----------
144
30
145The `do` keyword introduces simple syntactic sugar for monadic expressions.
31The `do` keyword introduces simple syntactic sugar for monadic expressions.
146
32
147−Here is an example, using the maybe monad:
33+Here is an example, using the maybe monad::
148−
34+
149−```haskell
150−data Maybe a = Nothing | Just a
35+ data Maybe a = Nothing | Just a
151−
36+
152−instance Monad Maybe where
37+ instance Monad Maybe where
153− ret = Just
38+ ret = Just
154− (>>=) Nothing _ = Nothing
39+ (>>=) Nothing _ = Nothing
155− (>>=) (Just a) f = f a
40+ (>>=) (Just a) f = f a
156−
41+
157−isEven n | n % 2 == 0 = Just {}
42+ isEven n | n % 2 == 0 = Just {}
158−isEven _ = Nothing
43+ isEven _ = Nothing
159−
44+
160−evenSum a b = do
45+ evenSum a b = do
161− n <- a
46+ n <- a
162− m <- b
47+ m <- b
163− let sum = n + m
48+ let sum = n + m
164− isEven sum
49+ isEven sum
165− ret sum
50+ ret sum
166−```
167
51
168`isEven` adds two values of type `Maybe Number` and returns their sum, if the sum is even. If the sum is odd, `evenSum` returns `Nothing`.
52`isEven` adds two values of type `Maybe Number` and returns their sum, if the sum is even. If the sum is odd, `evenSum` returns `Nothing`.
169
53
170−This example illustrates the following aspects of `do` notation:
54+When using `do` notation, the corresponding type constructor must be an instance of the `Prelude.Monad` type class, which defines the `ret` and `>>=` functions.
171
55
172−- The corresponding type constructor must be an instance of the `Prelude.Monad` type class, which defines the `ret` and `>>=` functions.
173−- Statements can have the following form:
56+Statements can have the following form:
174− - `a <- x` which desugars to `m.bind x (\a -> ...)`
175− - `let a = x` which desugars to `(\a -> ...)(x)`
176− - `x` which desugars to `m.bind x (\_ -> ...)` or just `x` if this is the last statement.
177
57
178−Not illustrated here, but equally valid is the use of a binder on the left hand side of `<-` or `=`. For example:
58+- `a <- x` which desugars to `m.bind x (\a -> ...)`
59+- `let a = x` which desugars to `(\a -> ...)(x)`
60+- `x` which desugars to `m.bind x (\_ -> ...)` or just `x` if this is the last statement.
179
61
180−```haskell
62+Binders can be used on the left hand side of `<-` or `=`. For example::
181−test arr = do
182− (x:y:_) <- arr
183− ret (x + y)
184−```
185
63
186−A pattern match failure will generate a runtime exception, just as in the case of a regular `case` statement.
64+ test arr = do
65+ (x:y:_) <- arr
66+ ret (x + y)
187
67
188−## Operators
68+A pattern match failure will generate a runtime exception, just as in the case of a regular `case` statement.
189−
190−In addition to the standard operators, user-defined infix operators can be created by enclosing names in parentheses:
191
69
192−E.g. to create a synonym for string concatenation:
70+Operators
71+---------
193
72
194−```haskell
73+In addition to the standard operators, user-defined infix operators can be created by enclosing names in parentheses.
195−(<>) = \s1 s2 -> s1 ++ s2
196
74
197−greeting = "Hello" <> "World!"
75+E.g. to create a synonym for string concatenation::
198−```
199
76
200−Regular functions can be used as operators by enclosing their names in backticks:
77+ (<>) = \s1 s2 -> s1 ++ s2
78+
79+ greeting = "Hello" <> "World!"
201
80
202−```haskell
81+Regular functions can be used as operators by enclosing their names in backticks::
203−foo = \x y -> x * y + y
204
82
83+ foo = \x y -> x * y + y
84+
205−test = 10 `foo` 20
85+ test = 10 `foo` 20
206−```
207
86
208−Fixity declarations can associate a precedence level, which is a natural number, to a user-defined operator, and specify which way it associates:
87+Fixity declarations can associate a precedence level, which is a natural number, to a user-defined operator, and specify which way it associates::
88+
89+ infixl 5 <>
90+ infixr 7 %%
209
91
210−```haskell
92+Record Updates
211−infixl 5 <>
93+--------------
212−infixr 7 %%
213−```
214
94
215−## Record Updates
95+Properties on records can be updated using the following syntax::
216
96
217−Properties on records can be updated using the following syntax: `o { key = value, ..., key = value }`
97+ o { key = value, ..., key = value }
218
98
219−For example, the following function increments the `foo` property on its argument:
99+For example, the following function increments the `foo` property on its argument::
220
100
221−```haskell
222−incr = \o -> o { foo = o.foo + 1 }
101+ incr = \o -> o { foo = o.foo + 1 }
223−```
224
102
225−The generated Javascript assumes the existence of a method called `Object.extend` such that `Object.extend(o, p)` takes an object `o` and generates a shallow copy of `o` including the properties of `p`. A simple JQuery implementation of this specification is
103+The generated Javascript assumes the existence of a method called `Object.extend` such that `Object.extend(o, p)` takes an object `o` and generates a shallow copy of `o` including the properties of `p`. A simple JQuery implementation of this specification is::
226
104
227−```haskell
228Object.prototype.extend = function(o, p) {
105Object.prototype.extend = function(o, p) {
229 return $.extend({}, o, p);
106 return $.extend({}, o, p);
230};
107};
231−```