git.iko.soy/rowtype-yoga/purescript-native
on cd3b4ee help sign in
rowtype-yoga/purescript-native/docs/source/syntax.rst
241 lines 6.4 kB history raw
1Syntax
2======
4Whitespace Rules
5----------------
7Syntax 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.
9That is, the following is valid::
11 foo = bar(x) +
12 baz(x)
14But this is not::
16 foo = bar(x) +
17 baz(x)
19Operators
20---------
22Binary operators in PureScript are just regular functions. The Prelude defines a number of operators which correspond to Javascript's operators.
24The Prelude defines the following functions which correspond to Javascript's unary operators:
26========== ======== =======================
27Function Operator Meaning
28========== ======== =======================
29negate \- Numeric negation
30not ! Boolean negation
31complement ~ Binary negation
32========== ======== =======================
34and the following binary operators:
36========== =========== =====================
37Function JS Operator Meaning
38========== =========== =====================
39(\+) \+ Numeric addition
40(\-) \- Numeric subtraction
41(\*) \* Numeric multiplication
42(/) / Numeric division
43(%) % Numeric modulus
44(==) == Equality check
45(/=) != Inequality check
46(<) < Less than
47(<=) <= Less than or equal
48(>) > Greater than
49(>=) >= Greater than or equal
50(&&) && Boolean AND
51(||) || Boolean OR
52(&) & Binary AND
53(\|) \| Binary OR
54(^) ^ Binary XOR
55shl << Shift Left
56shr >> Shift Right
57zshr \>>> Zero-Fill Shift Right
58(++) + String concatenation
59========== =========== =====================
61Literal Values
62--------------
64Numeric literals can be integers or floating point numbers. Numbers in hexadecimal notation should be preceded by the characters ``0x``::
66 16
67 16.0
68 0xF0
70String literals are enclosed in double-quotes and may extend over multiple lines. Line breaks should be surrounded by slashes as follows::
72 "Hello World"
74 "Hello \
75 \World"
77The two boolean literals are ``true`` and ``false``.
79Array Literals
80--------------
82Array literals are surrounded by square brackets, as in Javascript::
84 []
85 [1, 2, 3]
87Record Literals
88---------------
90Record literals are surrounded by braces, as in Javascript::
92 {}
93 { foo: "Foo", bar: 1 }
95Array Indexing
96--------------
98To retrieve the element of an array at an index, use the ``!!`` operator::
100 arr !! 0
102This example corresponds to the Javascript ``arr[0]``.
104Property Accessors
105------------------
107To access a property of a record, use a dot, followed by the property name, as in Javascript::
109 rec.propertyName
111Functions
112---------
114Functions are introduced by using a backslash followed by a list of argument names::
116 example1 = \a b -> a + b
118which would correspond to the following Javascript::
120 function example1(a) {
121 return function (b) {
122 return a + b;
123 }
124 }
126Function application is indicated by just the juxtaposition of a function with its arugments::
128 example1 10 20
130Functions can also be defined at the top level by providing a list of patterns and an optional guard on the left hand side of the equals sign::
132 f [] [] = []
133 f (x:xs) (y:ys) = x + y : f xs ys
135If-Then-Else Expressions
136------------------------
138The ``if``, ``then`` and ``else`` keywords can be used to create conditional expressions. In this case, the ``else`` block is always required.
140For example::
142 conditional = if 2 > 1 then "ok" else "oops"
144Do Notation
145-----------
147The ``do`` keyword introduces simple syntactic sugar for monadic expressions.
149Here is an example, using the maybe monad::
151 data Maybe a = Nothing | Just a
153 instance Monad Maybe where
154 ret = Just
155 (>>=) Nothing _ = Nothing
156 (>>=) (Just a) f = f a
158 isEven n | n % 2 == 0 = Just {}
159 isEven _ = Nothing
161 evenSum a b = do
162 n <- a
163 m <- b
164 let sum = n + m
165 isEven sum
166 ret sum
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``.
170When using ``do`` notation, the corresponding type constructor must be an instance of the ``Prelude.Monad`` type class, which defines the ``ret`` and ``>>=`` functions.
172Statements 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.
178Binders can be used on the left hand side of ``<-`` or ``=``. For example::
180 test arr = do
181 (x:y:_) <- arr
182 ret (x + y)
184A pattern match failure will generate a runtime exception, just as in the case of a regular ``case`` statement.
186Operators
187---------
189User-defined infix operators can be created by enclosing names in parentheses.
191E.g. to create a synonym for string concatenation::
193 (<>) = \s1 s2 -> s1 ++ s2
195 greeting = "Hello" <> "World!"
197Regular functions can be used as operators by enclosing their names in backticks::
199 foo = \x y -> x * y + y
201 test = 10 `foo` 20
203Fixity declarations can associate a precedence level, which is a natural number, to a user-defined operator, and specify which way it associates::
205 infixl 5 <>
206 infixr 7 %%
208Record Updates
209--------------
211Properties on records can be updated using the following syntax::
213 o { key = value, ..., key = value }
215For example, the following function increments the ``foo`` property on its argument::
217 incr o = o { foo = o.foo + 1 }
219Let Bindings
220------------
222The ``let`` keywords a collection of local declarations, which may be mutually recursive, and which may include type declarations::
224 factorial :: Number -> Number
225 factorial =
226 let
227 go :: Number -> Number -> Number
228 go acc 1 = acc
229 go acc n = go (acc * n) (n - 1)
230 in
231 go 1
233The ``where`` keyword can also be used to introduce local declarations `at the end of a value declaration`::
235 factorial :: Number -> Number
236 factorial = go 1
237 where
238 go :: Number -> Number -> Number
239 go acc 1 = acc
240 go acc n = go (acc * n) (n - 1)