@@ -20,7 +20,7 @@ module Prelude
2020 , negate
2121 , DivisionRing
2222 , Num
23− , Eq, (==), (/=), refEq, refIneq
23+ , Eq, (==), (/=)
2424 , Ord, Ordering(..), compare, (<), (>), (<=), (>=)
2525 , Bits, (.&.), (.|.), (.^.), shl, shr, zshr, complement
2626 , BoolLike, (&&), (||)
@@ -170,7 +170,7 @@ module Prelude
170170
171171 -- | The `Show` type class represents those types which can be converted into a human-readable `String` representation.
172172 -- |
173− -- | While not required, it is recommended that for any expression `x`, the string `show x` be executable PureScript code
173+ -- | While not required, it is recommended that for any expression `x`, the string `show x` be executable PureScript code
174174 -- | which evaluates to the same value as the expression `x`.
175175 class Show a where
176176 show :: a -> String
@@ -222,7 +222,7 @@ module Prelude
222222 infixl 1 <#>
223223
224224 -- | A `Functor` is a type constructor which supports a mapping operation `(<$>)`.
225− -- |
225+ -- |
226226 -- | `(<$>)` can be used to turn functions `a -> b` into functions `f a -> f b` whose argument and return
227227 -- | types use the type constructor `f` to represent some computational context.
228228 -- |
@@ -235,14 +235,14 @@ module Prelude
235235 (<$>) :: forall a b. (a -> b) -> f a -> f b
236236
237237 -- | `(<#>)` is `(<$>)` with its arguments reversed. For example:
238− -- |
238+ -- |
239239 -- | ```purescript
240240 -- | [1, 2, 3] <#> \n -> n * n
241241 -- | ```
242242 (<#>) :: forall f a b. (Functor f) => f a -> (a -> b) -> f b
243243 (<#>) fa f = f <$> fa
244244
245− -- | The `void` function is used to ignore the type wrapped by a [`Functor`](#functor), replacing it with `Unit` and
245+ -- | The `void` function is used to ignore the type wrapped by a [`Functor`](#functor), replacing it with `Unit` and
246246 -- | keeping only the type information provided by the type constructor itself.
247247 -- |
248248 -- | `void` is often useful when using `do` notation to change the return type of a monadic computation:
@@ -258,7 +258,7 @@ module Prelude
258258 infixl 4 <*>
259259
260260 -- | The `Apply` class provides the `(<*>)` which is used to apply a function to an argument under a type constructor.
261− -- |
261+ -- |
262262 -- | `Apply` can be used to lift functions of two or more arguments to work on values wrapped with the type constructor `f`.
263263 -- | It might also be understood in terms of the `lift2` function:
264264 -- |
@@ -266,7 +266,7 @@ module Prelude
266266 -- | lift2 :: forall f a b c. (Apply f) => (a -> b -> c) -> f a -> f b -> f c
267267 -- | lift2 f a b = f <$> a <*> b
268268 -- | ```
269− -- |
269+ -- |
270270 -- | `(<*>)` is recovered from `lift2` as `lift2 ($)`. That is, `(<*>)` lifts the function application operator `($)` to arguments
271271 -- | wrapped with the type constructor `f`.
272272 -- |
@@ -280,9 +280,9 @@ module Prelude
280280
281281 -- | The `Applicative` type class extends the [`Apply`](#apply) type class with a `pure` function, which can be used to
282282 -- | create values of type `f a` from values of type `a`.
283− -- |
284− -- | Where [`Apply`](#apply) provides the ability to lift functions of two or more arguments to functions whose arguments are wrapped using `f`,
285− -- | and [`Functor`](#functor) provides the ability to lift functions of one argument, `pure` can be seen as the function which lifts functions of
283+ -- |
284+ -- | Where [`Apply`](#apply) provides the ability to lift functions of two or more arguments to functions whose arguments are wrapped using `f`,
285+ -- | and [`Functor`](#functor) provides the ability to lift functions of one argument, `pure` can be seen as the function which lifts functions of
286286 -- | _zero_ arguments. That is, `Applicative` functors support a lifting operation for any number of function arguments.
287287 -- |
288288 -- | `Applicative` instances should satisfy the following laws:
@@ -297,9 +297,9 @@ module Prelude
297297
298298 -- | `liftA1` provides a default implementation of `(<$>)` for any [`Applicative`](#applicative) functor,
299299 -- | without using `(<$>)` as provided by the [`Functor`](#functor)-[`Applicative`](#applicative) superclass relationship.
300− -- |
300+ -- |
301301 -- | `liftA1` can therefore be used to write [`Functor`](#functor) instances as follows:
302− -- |
302+ -- |
303303 -- | ```purescript
304304 -- | instance functorF :: Functor F where
305305 -- | (<$>) = liftA1
@@ -311,26 +311,26 @@ module Prelude
311311
312312 -- | The `Bind` type class extends the [`Apply`](#apply) type class with a "bind" operation `(>>=)` which composes computations
313313 -- | in sequence, using the return value of one computation to determine the next computation.
314− -- |
314+ -- |
315315 -- | The `>>=` operator can also be expressed using `do` notation, as follows:
316− -- |
316+ -- |
317317 -- | ```purescript
318318 -- | x >>= f = do y <- x
319319 -- | f y
320320 -- | ```
321− -- |
321+ -- |
322322 -- | where the function argument of `f` is given the name `y`.
323− -- |
323+ -- |
324324 -- | `Bind` instances should satisfy the following law:
325325 -- |
326326 -- | - Associativity: `(x >>= f) >>= g = x >>= (\k => f k >>= g)`
327327 -- |
328− -- | Or, expressed using `do` notation:
329− -- |
328+ -- | Or, expressed using `do` notation:
329+ -- |
330330 -- | - Associativity: `do { z <- do { y <- x ; f y } ; g z } = do { k <- x ; do { y <- f k ; g y } }`
331− -- |
331+ -- |
332332 -- | Associativity tells us that we can regroup operations which use do-notation, so that we can unambiguously write, for example:
333− -- |
333+ -- |
334334 -- | ```purescript
335335 -- | do x <- m1
336336 -- | y <- m2 x
@@ -347,11 +347,11 @@ module Prelude
347347 -- | - Left Identity: `pure x >>= f = f x`
348348 -- | - Right Identity: `x >>= pure = x`
349349 -- |
350− -- | Or, expressed using `do` notation:
351− -- |
350+ -- | Or, expressed using `do` notation:
351+ -- |
352352 -- | - Left Identity: `do { y <- pure x ; f y } = f x`
353353 -- | - Right Identity: `do { y <- x ; pure y } = x`
354− -- |
354+ -- |
355355 class (Applicative m, Bind m) <= Monad m
356356
357357 -- | `return` is an alias for `pure`.
@@ -360,9 +360,9 @@ module Prelude
360360
361361 -- | `liftM1` provides a default implementation of `(<$>)` for any [`Monad`](#monad),
362362 -- | without using `(<$>)` as provided by the [`Functor`](#functor)-[`Monad`](#monad) superclass relationship.
363− -- |
363+ -- |
364364 -- | `liftM1` can therefore be used to write [`Functor`](#functor) instances as follows:
365− -- |
365+ -- |
366366 -- | ```purescript
367367 -- | instance functorF :: Functor F where
368368 -- | (<$>) = liftM1
@@ -374,9 +374,9 @@ module Prelude
374374
375375 -- | `ap` provides a default implementation of `(<*>)` for any [`Monad`](#monad),
376376 -- | without using `(<*>)` as provided by the [`Apply`](#apply)-[`Monad`](#monad) superclass relationship.
377− -- |
377+ -- |
378378 -- | `ap` can therefore be used to write [`Apply`](#apply) instances as follows:
379− -- |
379+ -- |
380380 -- | ```purescript
381381 -- | instance applyF :: Apply F where
382382 -- | (<*>) = ap
@@ -515,7 +515,7 @@ module Prelude
515515 instance numNumber :: Num Number
516516
517517 -- | The `Unit` type has a single inhabitant, called `unit`. It represents values with no computational content.
518− -- |
518+ -- |
519519 -- | `Unit` is often used, wrapped in a monadic type constructor, as the return type of a computation where only
520520 -- | the _effects_ are important.
521521 newtype Unit = Unit {}
@@ -530,13 +530,13 @@ module Prelude
530530 -- | The `Eq` type class represents types which support decidable equality.
531531 -- |
532532 -- | `Eq` instances should satisfy the following laws:
533− -- |
533+ -- |
534534 -- | - Reflexivity: `x == x = true`
535535 -- | - Symmetry: `x == y = y == x`
536536 -- | - Transitivity: if `x == y` and `y == z` then `x == z`
537537 -- | - Negation: `x /= y = not (x == y)`
538538 -- |
539− -- | `(/=)` may be implemented in terms of `(==)`, but it might give a performance improvement to implement it separately.
539+ -- | `(/=)` may be implemented in terms of `(==)`, but it might give a performance improvement to implement it separately.
540540 class Eq a where
541541 (==) :: a -> a -> Boolean
542542 (/=) :: a -> a -> Boolean
@@ -595,7 +595,7 @@ module Prelude
595595 (/=) xs ys = not (xs == ys)
596596
597597 -- | The `Ordering` data type represents the three possible outcomes of comparing two values:
598− -- |
598+ -- |
599599 -- | `LT` - The first value is _less than_ the second.
600600 -- | `GT` - The first value is _greater than_ the second.
601601 -- | `EQ` - The first value is _equal to_ or _incomparable to_ the second.
@@ -790,9 +790,9 @@ module Prelude
790790 infixr 3 &&
791791
792792 -- | The `BoolLike` type class identifies types which support Boolean operations.
793− -- |
793+ -- |
794794 -- | `BoolLike` instances are required to satisfy the laws of a _Boolean algebra_.
795− -- |
795+ -- |
796796 class BoolLike b where
797797 (&&) :: b -> b -> b
798798 (||) :: b -> b -> b
@@ -831,12 +831,12 @@ module Prelude
831831 infixr 5 <>
832832
833833 -- | The `Semigroup` type class identifies an associative operation on a type.
834− -- |
834+ -- |
835835 -- | `Semigroup` instances are required to satisfy the following law:
836− -- |
836+ -- |
837837 -- | - Associativity: `(x <> y) <> z = x <> (y <> z)`
838− -- |
839− -- | For example, the `String` type is an instance of `Semigroup`, where `(<>)` is defined to be string concatenation.
838+ -- |
839+ -- | For example, the `String` type is an instance of `Semigroup`, where `(<>)` is defined to be string concatenation.
840840 class Semigroup a where
841841 (<>) :: a -> a -> a
842842
@@ -867,9 +867,9 @@ module Prelude
867867module Data.Function where
868868
869869 -- | The `on` function is used to change the domain of a binary operator.
870− -- |
870+ -- |
871871 -- | For example, we can create a function which compares two records based on the values of their `x` properties:
872− -- |
872+ -- |
873873 -- | ```purescript
874874 -- | compareX :: forall r. { x :: Number | r } -> { x :: Number | r } -> Ordering
875875 -- | compareX = compare `on` _.x
@@ -1221,7 +1221,7 @@ module Data.Function where
12211221module Prelude.Unsafe where
12221222
12231223 -- | Find the element of an array at the specified index.
1224− -- |
1224+ -- |
12251225 -- | Note: this function can cause unpredictable failure at runtime if the index is out-of-bounds.
12261226 foreign import unsafeIndex
12271227 """
@@ -1232,7 +1232,7 @@ module Prelude.Unsafe where
12321232 }
12331233 """ :: forall a. [a] -> Number -> a
12341234
1235−module Control.Monad.Eff
1235+module Control.Monad.Eff
12361236 ( Eff()
12371237 , Pure()
12381238 , runPure
@@ -1297,8 +1297,8 @@ module Control.Monad.Eff
12971297 instance monadEff :: Monad (Eff e)
12981298
12991299 -- | Loop until a condition becomes `true`.
1300− -- |
1301− -- | `untilE b` is an effectful computation which repeatedly runs the effectful computation `b`,
1300+ -- |
1301+ -- | `untilE b` is an effectful computation which repeatedly runs the effectful computation `b`,
13021302 -- | until its return value is `true`.
13031303 foreign import untilE
13041304 """
@@ -1311,8 +1311,8 @@ module Control.Monad.Eff
13111311 """ :: forall e. Eff e Boolean -> Eff e Unit
13121312
13131313 -- | Loop while a condition is `true`.
1314− -- |
1315− -- | `whileE b m` is effectful computation which runs the effectful computation `b`. If its result is
1314+ -- |
1315+ -- | `whileE b m` is effectful computation which runs the effectful computation `b`. If its result is
13161316 -- | `true`, it runs the effectful computation `m` and loops. If not, the computation ends.
13171317 foreign import whileE
13181318 """
@@ -1329,7 +1329,7 @@ module Control.Monad.Eff
13291329 """ :: forall e a. Eff e Boolean -> Eff e a -> Eff e Unit
13301330
13311331 -- | Loop over a consecutive collection of numbers.
1332− -- |
1332+ -- |
13331333 -- | `forE lo hi f` runs the computation returned by the function `f` for each of the inputs
13341334 -- | between `lo` (inclusive) and `hi` (exclusive).
13351335 foreign import forE
@@ -1348,7 +1348,7 @@ module Control.Monad.Eff
13481348 """ :: forall e. Number -> Number -> (Number -> Eff e Unit) -> Eff e Unit
13491349
13501350 -- | Loop over an array of values.
1351− -- |
1351+ -- |
13521352 -- | `foreach xs f` runs the computation returned by the function `f` for each of the inputs `xs`.
13531353 foreign import foreachE
13541354 """
@@ -1368,7 +1368,7 @@ module Control.Monad.Eff.Unsafe where
13681368 import Control.Monad.Eff
13691369
13701370 -- | Change the type of an effectful computation, allowing it to be run in another context.
1371− -- |
1371+ -- |
13721372 -- | Note: use of this function can result in arbitrary side-effects.
13731373 foreign import unsafeInterleaveEff
13741374 """
@@ -1404,9 +1404,9 @@ module Control.Monad.ST where
14041404 import Control.Monad.Eff
14051405
14061406 -- | The `ST` effect represents _local mutation_, i.e. mutation which does not "escape" into the surrounding computation.
1407− -- |
1407+ -- |
14081408 -- | An `ST` computation is parameterized by a phantom type which is used to restrict the set of reference cells it is allowed to access.
1409− -- |
1409+ -- |
14101410 -- | The `runST` function can be used to handle the `ST` effect.
14111411 foreign import data ST :: * -> !
14121412
@@ -1458,10 +1458,10 @@ module Control.Monad.ST where
14581458 """ :: forall a h r. STRef h a -> a -> Eff (st :: ST h | r) a
14591459
14601460 -- | Run an `ST` computation.
1461− -- |
1461+ -- |
14621462 -- | Note: the type of `runST` uses a rank-2 type to constrain the phantom type `s`, such that the computation must not leak any mutable references
14631463 -- | to the surrounding computation.
1464− -- |
1464+ -- |
14651465 -- | It may cause problems to apply this function using the `$` operator. The recommended approach is to use parentheses instead.
14661466 foreign import runST
14671467 """