@@ -1,1551 +0,0 @@
1−module Prelude
2− ( Unit(..), unit
3− , ($), (#)
4− , flip
5− , const
6− , asTypeOf
7− , otherwise
8− , (:), cons
9− , Semigroupoid, (<<<), (>>>)
10− , Category, id
11− , Functor, (<$>), (<#>), void
12− , Apply, (<*>)
13− , Applicative, pure, liftA1
14− , Bind, (>>=)
15− , Monad, return, liftM1, ap
16− , Semigroup, (<>), (++)
17− , Semiring, (+), zero, (*), one
18− , ModuloSemiring, (/), mod
19− , Ring, (-), negate
20− , Num
21− , DivisionRing
22− , Eq, (==), (/=)
23− , Ordering(..), Ord, compare, (<), (>), (<=), (>=)
24− , Bounded, top, bottom
25− , Lattice, sup, inf, (||), (&&)
26− , BoundedLattice
27− , ComplementedLattice, not
28− , DistributiveLattice
29− , BooleanAlgebra
30− , Show, show
31− ) where
32−
33− -- | The `Unit` type has a single inhabitant, called `unit`. It represents
34− -- | values with no computational content.
35− -- |
36− -- | `Unit` is often used, wrapped in a monadic type constructor, as the
37− -- | return type of a computation where only
38− -- | the _effects_ are important.
39− newtype Unit = Unit {}
40−
41− -- | `unit` is the sole inhabitant of the `Unit` type.
42− unit :: Unit
43− unit = Unit {}
44−
45− infixr 0 $
46− infixl 0 #
47−
48− -- | Applies a function to its argument.
49− -- |
50− -- | ```purescript
51− -- | length $ groupBy productCategory $ filter isInStock $ products
52− -- | ```
53− -- |
54− -- | is equivalent to:
55− -- |
56− -- | ```purescript
57− -- | length (groupBy productCategory (filter isInStock products))
58− -- | ```
59− -- |
60− -- | `($)` is different from [`(#)`](#-2) because it is right-infix instead of
61− -- | left: `a $ b $ c $ d x = a $ (b $ (c $ (d $ x))) = a (b (c (d x)))`
62− ($) :: forall a b. (a -> b) -> a -> b
63− ($) f x = f x
64−
65− -- | Applies an argument to a function.
66− -- |
67− -- | ```purescript
68− -- | products # filter isInStock # groupBy productCategory # length
69− -- | ```
70− -- |
71− -- | is equivalent to:
72− -- |
73− -- | ```purescript
74− -- | length (groupBy productCategory (filter isInStock products))
75− -- | ```
76− -- |
77− -- | `(#)` is different from [`($)`](#-1) because it is left-infix instead of
78− -- | right: `x # a # b # c # d = (((x # a) # b) # c) # d = d (c (b (a x)))`
79− (#) :: forall a b. a -> (a -> b) -> b
80− (#) x f = f x
81−
82− -- | Flips the order of the arguments to a function of two arguments.
83− -- |
84− -- | ```purescript
85− -- | flip const 1 2 = const 2 1 = 2
86− -- | ```
87− flip :: forall a b c. (a -> b -> c) -> b -> a -> c
88− flip f b a = f a b
89−
90− -- | Returns its first argument and ignores its second.
91− -- |
92− -- | ```purescript
93− -- | const 1 "hello" = 1
94− -- | ```
95− const :: forall a b. a -> b -> a
96− const a _ = a
97−
98− -- | This function returns its first argument, and can be used to assert type
99− -- | equalities. This can be useful when types are otherwise ambiguous.
100− -- |
101− -- | ```purescript
102− -- | main = print $ [] `asTypeOf` [0]
103− -- | ```
104− -- |
105− -- | If instead, we had written `main = print []`, the type of the argument
106− -- | `[]` would have been ambiguous, resulting in a compile-time error.
107− asTypeOf :: forall a. a -> a -> a
108− asTypeOf x _ = x
109−
110− -- | An alias for `true`, which can be useful in guard clauses:
111− -- |
112− -- | ```purescript
113− -- | max x y | x >= y = x
114− -- | | otherwise = y
115− -- | ```
116− otherwise :: Boolean
117− otherwise = true
118−
119− -- | Attaches an element to the front of an array, creating a new array.
120− -- |
121− -- | ```purescript
122− -- | cons 1 [2, 3, 4] = [1, 2, 3, 4]
123− -- | ```
124− -- |
125− -- | Note, the running time of this function is `O(n)`.
126− foreign import cons
127− """
128− function cons(e) {
129− return function(l) {
130− return [e].concat(l);
131− };
132− }
133− """ :: forall a. a -> [a] -> [a]
134−
135− infixr 6 :
136−
137− -- | An infix alias for `cons`.
138− -- |
139− -- | Note, the running time of this function is `O(n)`.
140− (:) :: forall a. a -> [a] -> [a]
141− (:) = cons
142−
143− infixr 9 >>>
144− infixr 9 <<<
145−
146− -- | A `Semigroupoid` is similar to a [`Category`](#category) but does not
147− -- | require an identity element `id`, just composable morphisms.
148− -- |
149− -- | `Semigroupoid`s must satisfy the following law:
150− -- |
151− -- | - Associativity: `p <<< (q <<< r) = (p <<< q) <<< r`
152− -- |
153− -- | One example of a `Semigroupoid` is the function type constructor `(->)`,
154− -- | with `(<<<)` defined as function composition.
155− class Semigroupoid a where
156− (<<<) :: forall b c d. a c d -> a b c -> a b d
157−
158− instance semigroupoidArr :: Semigroupoid (->) where
159− (<<<) f g x = f (g x)
160−
161− -- | Forwards composition, or `(<<<)` with its arguments reversed.
162− (>>>) :: forall a b c d. (Semigroupoid a) => a b c -> a c d -> a b d
163− (>>>) f g = g <<< f
164−
165− -- | `Category`s consist of objects and composable morphisms between them, and
166− -- | as such are [`Semigroupoids`](#semigroupoid), but unlike `semigroupoids`
167− -- | must have an identity element.
168− -- |
169− -- | Instances must satisfy the following law in addition to the
170− -- | `Semigroupoid` law:
171− -- |
172− -- | - Identity: `id <<< p = p <<< id = p`
173− class (Semigroupoid a) <= Category a where
174− id :: forall t. a t t
175−
176− instance categoryArr :: Category (->) where
177− id x = x
178−
179− infixl 4 <$>
180− infixl 1 <#>
181−
182− -- | A `Functor` is a type constructor which supports a mapping operation
183− -- | `(<$>)`.
184− -- |
185− -- | `(<$>)` can be used to turn functions `a -> b` into functions
186− -- | `f a -> f b` whose argument and return types use the type constructor `f`
187− -- | to represent some computational context.
188− -- |
189− -- | Instances must satisfy the following laws:
190− -- |
191− -- | - Identity: `(<$>) id = id`
192− -- | - Composition: `(<$>) (f <<< g) = (f <$>) <<< (g <$>)`
193− class Functor f where
194− (<$>) :: forall a b. (a -> b) -> f a -> f b
195−
196− instance functorArr :: Functor ((->) r) where
197− (<$>) = (<<<)
198−
199− -- | `(<#>)` is `(<$>)` with its arguments reversed. For example:
200− -- |
201− -- | ```purescript
202− -- | [1, 2, 3] <#> \n -> n * n
203− -- | ```
204− (<#>) :: forall f a b. (Functor f) => f a -> (a -> b) -> f b
205− (<#>) fa f = f <$> fa
206−
207− -- | The `void` function is used to ignore the type wrapped by a
208− -- | [`Functor`](#functor), replacing it with `Unit` and keeping only the type
209− -- | information provided by the type constructor itself.
210− -- |
211− -- | `void` is often useful when using `do` notation to change the return type
212− -- | of a monadic computation:
213− -- |
214− -- | ```purescript
215− -- | main = forE 1 10 \n -> void do
216− -- | print n
217− -- | print (n * n)
218− -- | ```
219− void :: forall f a. (Functor f) => f a -> f Unit
220− void fa = const unit <$> fa
221−
222− infixl 4 <*>
223−
224− -- | The `Apply` class provides the `(<*>)` which is used to apply a function
225− -- | to an argument under a type constructor.
226− -- |
227− -- | `Apply` can be used to lift functions of two or more arguments to work on
228− -- | values wrapped with the type constructor `f`. It might also be understood
229− -- | in terms of the `lift2` function:
230− -- |
231− -- | ```purescript
232− -- | lift2 :: forall f a b c. (Apply f) => (a -> b -> c) -> f a -> f b -> f c
233− -- | lift2 f a b = f <$> a <*> b
234− -- | ```
235− -- |
236− -- | `(<*>)` is recovered from `lift2` as `lift2 ($)`. That is, `(<*>)` lifts
237− -- | the function application operator `($)` to arguments wrapped with the
238− -- | type constructor `f`.
239− -- |
240− -- | Instances must satisfy the following law in addition to the `Functor`
241− -- | laws:
242− -- |
243− -- | - Associative composition: `(<<<) <$> f <*> g <*> h = f <*> (g <*> h)`
244− -- |
245− -- | Formally, `Apply` represents a strong lax semi-monoidal endofunctor.
246− class (Functor f) <= Apply f where
247− (<*>) :: forall a b. f (a -> b) -> f a -> f b
248−
249− instance applyArr :: Apply ((->) r) where
250− (<*>) f g x = f x (g x)
251−
252− -- | The `Applicative` type class extends the [`Apply`](#apply) type class
253− -- | with a `pure` function, which can be used to create values of type `f a`
254− -- | from values of type `a`.
255− -- |
256− -- | Where [`Apply`](#apply) provides the ability to lift functions of two or
257− -- | more arguments to functions whose arguments are wrapped using `f`, and
258− -- | [`Functor`](#functor) provides the ability to lift functions of one
259− -- | argument, `pure` can be seen as the function which lifts functions of
260− -- | _zero_ arguments. That is, `Applicative` functors support a lifting
261− -- | operation for any number of function arguments.
262− -- |
263− -- | Instances must satisfy the following laws in addition to the `Apply`
264− -- | laws:
265− -- |
266− -- | - Identity: `(pure id) <*> v = v`
267− -- | - Composition: `(pure <<<) <*> f <*> g <*> h = f <*> (g <*> h)`
268− -- | - Homomorphism: `(pure f) <*> (pure x) = pure (f x)`
269− -- | - Interchange: `u <*> (pure y) = (pure ($ y)) <*> u`
270− class (Apply f) <= Applicative f where
271− pure :: forall a. a -> f a
272−
273− instance applicativeArr :: Applicative ((->) r) where
274− pure = const
275−
276− -- | `return` is an alias for `pure`.
277− return :: forall m a. (Applicative m) => a -> m a
278− return = pure
279−
280− -- | `liftA1` provides a default implementation of `(<$>)` for any
281− -- | [`Applicative`](#applicative) functor, without using `(<$>)` as provided
282− -- | by the [`Functor`](#functor)-[`Applicative`](#applicative) superclass
283− -- | relationship.
284− -- |
285− -- | `liftA1` can therefore be used to write [`Functor`](#functor) instances
286− -- | as follows:
287− -- |
288− -- | ```purescript
289− -- | instance functorF :: Functor F where
290− -- | (<$>) = liftA1
291− -- | ```
292− liftA1 :: forall f a b. (Applicative f) => (a -> b) -> f a -> f b
293− liftA1 f a = pure f <*> a
294−
295− infixl 1 >>=
296−
297− -- | The `Bind` type class extends the [`Apply`](#apply) type class with a
298− -- | "bind" operation `(>>=)` which composes computations in sequence, using
299− -- | the return value of one computation to determine the next computation.
300− -- |
301− -- | The `>>=` operator can also be expressed using `do` notation, as follows:
302− -- |
303− -- | ```purescript
304− -- | x >>= f = do y <- x
305− -- | f y
306− -- | ```
307− -- |
308− -- | where the function argument of `f` is given the name `y`.
309− -- |
310− -- | Instances must satisfy the following law in addition to the `Apply`
311− -- | laws:
312− -- |
313− -- | - Associativity: `(x >>= f) >>= g = x >>= (\k => f k >>= g)`
314− -- |
315− -- | Associativity tells us that we can regroup operations which use `do`
316− -- | notation so that we can unambiguously write, for example:
317− -- |
318− -- | ```purescript
319− -- | do x <- m1
320− -- | y <- m2 x
321− -- | m3 x y
322− -- | ```
323− class (Apply m) <= Bind m where
324− (>>=) :: forall a b. m a -> (a -> m b) -> m b
325−
326− instance bindArr :: Bind ((->) r) where
327− (>>=) m f x = f (m x) x
328−
329− -- | The `Monad` type class combines the operations of the `Bind` and
330− -- | `Applicative` type classes. Therefore, `Monad` instances represent type
331− -- | constructors which support sequential composition, and also lifting of
332− -- | functions of arbitrary arity.
333− -- |
334− -- | Instances must satisfy the following laws in addition to the
335− -- | `Applicative` and `Bind` laws:
336− -- |
337− -- | - Left Identity: `pure x >>= f = f x`
338− -- | - Right Identity: `x >>= pure = x`
339− class (Applicative m, Bind m) <= Monad m
340−
341− instance monadArr :: Monad ((->) r)
342−
343− -- | `liftM1` provides a default implementation of `(<$>)` for any
344− -- | [`Monad`](#monad), without using `(<$>)` as provided by the
345− -- | [`Functor`](#functor)-[`Monad`](#monad) superclass relationship.
346− -- |
347− -- | `liftM1` can therefore be used to write [`Functor`](#functor) instances
348− -- | as follows:
349− -- |
350− -- | ```purescript
351− -- | instance functorF :: Functor F where
352− -- | (<$>) = liftM1
353− -- | ```
354− liftM1 :: forall m a b. (Monad m) => (a -> b) -> m a -> m b
355− liftM1 f a = do
356− a' <- a
357− return (f a')
358−
359− -- | `ap` provides a default implementation of `(<*>)` for any
360− -- | [`Monad`](#monad), without using `(<*>)` as provided by the
361− -- | [`Apply`](#apply)-[`Monad`](#monad) superclass relationship.
362− -- |
363− -- | `ap` can therefore be used to write [`Apply`](#apply) instances as
364− -- | follows:
365− -- |
366− -- | ```purescript
367− -- | instance applyF :: Apply F where
368− -- | (<*>) = ap
369− -- | ```
370− ap :: forall m a b. (Monad m) => m (a -> b) -> m a -> m b
371− ap f a = do
372− f' <- f
373− a' <- a
374− return (f' a')
375−
376− infixr 5 <>
377− infixr 5 ++
378−
379− -- | The `Semigroup` type class identifies an associative operation on a type.
380− -- |
381− -- | Instances are required to satisfy the following law:
382− -- |
383− -- | - Associativity: `(x <> y) <> z = x <> (y <> z)`
384− -- |
385− -- | One example of a `Semigroup` is `String`, with `(<>)` defined as string
386− -- | concatenation.
387− class Semigroup a where
388− (<>) :: a -> a -> a
389−
390− -- | `(++)` is an alias for `(<>)`.
391− (++) :: forall s. (Semigroup s) => s -> s -> s
392− (++) = (<>)
393−
394− instance semigroupString :: Semigroup String where
395− (<>) = concatString
396−
397− instance semigroupUnit :: Semigroup Unit where
398− (<>) _ _ = unit
399−
400− instance semigroupArr :: (Semigroup s') => Semigroup (s -> s') where
401− (<>) f g = \x -> f x <> g x
402−
403− instance semigroupOrdering :: Semigroup Ordering where
404− (<>) LT _ = LT
405− (<>) GT _ = GT
406− (<>) EQ y = y
407−
408− foreign import concatString
409− """
410− function concatString(s1) {
411− return function(s2) {
412− return s1 + s2;
413− };
414− }
415− """ :: String -> String -> String
416−
417− infixl 6 +
418− infixl 7 *
419−
420− -- | The `Semiring` class is for types that support an addition and
421− -- | multiplication operation.
422− -- |
423− -- | Instances must satisfy the following laws:
424− -- |
425− -- | - Commutative monoid under addition:
426− -- | - Associativity: `(a + b) + c = a + (b + c)`
427− -- | - Identity: `zero + a = a + zero = a`
428− -- | - Commutative: `a + b = b + a`
429− -- | - Monoid under multiplication:
430− -- | - Associativity: `(a * b) * c = a * (b * c)`
431− -- | - Identity: `one * a = a * one = a`
432− -- | - Multiplication distributes over addition:
433− -- | - Left distributivity: `a * (b + c) = (a * b) + (a * c)`
434− -- | - Right distributivity: `(a + b) * c = (a * c) + (b * c)`
435− -- | - Annihiliation: `zero * a = a * zero = zero`
436− class Semiring a where
437− (+) :: a -> a -> a
438− zero :: a
439− (*) :: a -> a -> a
440− one :: a
441−
442− instance semiringNumber :: Semiring Number where
443− (+) = numAdd
444− zero = 0
445− (*) = numMul
446− one = 1
447−
448− instance semiringUnit :: Semiring Unit where
449− (+) _ _ = unit
450− zero = unit
451− (*) _ _ = unit
452− one = unit
453−
454− infixl 6 -
455−
456− -- | The `Ring` class is for types that support addition, multiplication,
457− -- | and subtraction operations.
458− -- |
459− -- | Instances must satisfy the following law in addition to the `Semiring`
460− -- | laws:
461− -- |
462− -- | - Additive inverse: `a + (-a) = (-a) + a = zero`
463− class (Semiring a) <= Ring a where
464− (-) :: a -> a -> a
465−
466− instance ringNumber :: Ring Number where
467− (-) = numSub
468−
469− instance ringUnit :: Ring Unit where
470− (-) _ _ = unit
471−
472− negate :: forall a. (Ring a) => a -> a
473− negate a = zero - a
474−
475− infixl 7 /
476−
477− -- | The `ModuloSemiring` class is for types that support addition,
478− -- | multiplication, division, and modulo (division remainder) operations.
479− -- |
480− -- | Instances must satisfy the following law in addition to the `Semiring`
481− -- | laws:
482− -- |
483− -- | - Remainder: `a / b * b + (a `mod` b) = a`
484− class (Semiring a) <= ModuloSemiring a where
485− (/) :: a -> a -> a
486− mod :: a -> a -> a
487−
488− instance moduloSemiringNumber :: ModuloSemiring Number where
489− (/) = numDiv
490− mod _ _ = 0
491−
492− instance moduloSemiringUnit :: ModuloSemiring Unit where
493− (/) _ _ = unit
494− mod _ _ = unit
495−
496− -- | A `Ring` where every nonzero element has a multiplicative inverse.
497− -- |
498− -- | Instances must satisfy the following law in addition to the `Ring` and
499− -- | `ModuloSemiring` laws:
500− -- |
501− -- | - Multiplicative inverse: `(one / x) * x = one`
502− -- |
503− -- | As a consequence of this ```a `mod` b = zero``` as no divide operation
504− -- | will have a remainder.
505− class (Ring a, ModuloSemiring a) <= DivisionRing a
506−
507− instance divisionRingNumber :: DivisionRing Number
508−
509− instance divisionRingUnit :: DivisionRing Unit
510−
511− -- | The `Num` class is for types that are commutative fields.
512− -- |
513− -- | Instances must satisfy the following law in addition to the
514− -- | `DivisionRing` laws:
515− -- |
516− -- | - Commutative multiplication: `a * b = b * a`
517− class (DivisionRing a) <= Num a
518−
519− instance numNumber :: Num Number
520−
521− instance numUnit :: Num Unit
522−
523− foreign import numAdd
524− """
525− function numAdd(n1) {
526− return function(n2) {
527− return n1 + n2;
528− };
529− }
530− """ :: Number -> Number -> Number
531−
532− foreign import numMul
533− """
534− function numMul(n1) {
535− return function(n2) {
536− return n1 * n2;
537− };
538− }
539− """ :: Number -> Number -> Number
540−
541− foreign import numDiv
542− """
543− function numDiv(n1) {
544− return function(n2) {
545− return n1 / n2;
546− };
547− }
548− """ :: Number -> Number -> Number
549−
550− foreign import numSub
551− """
552− function numSub(n1) {
553− return function(n2) {
554− return n1 - n2;
555− };
556− }
557− """ :: Number -> Number -> Number
558−
559− infix 4 ==
560− infix 4 /=
561−
562− -- | The `Eq` type class represents types which support decidable equality.
563− -- |
564− -- | `Eq` instances should satisfy the following laws:
565− -- |
566− -- | - Reflexivity: `x == x = true`
567− -- | - Symmetry: `x == y = y == x`
568− -- | - Transitivity: if `x == y` and `y == z` then `x == z`
569− -- | - Negation: `x /= y = not (x == y)`
570− -- |
571− -- | `(/=)` may be implemented in terms of `(==)`, but it might give a performance improvement to implement it separately.
572− class Eq a where
573− (==) :: a -> a -> Boolean
574− (/=) :: a -> a -> Boolean
575−
576− instance eqBoolean :: Eq Boolean where
577− (==) = refEq
578− (/=) = refIneq
579−
580− instance eqNumber :: Eq Number where
581− (==) = refEq
582− (/=) = refIneq
583−
584− instance eqString :: Eq String where
585− (==) = refEq
586− (/=) = refIneq
587−
588− instance eqUnit :: Eq Unit where
589− (==) _ _ = true
590− (/=) _ _ = false
591−
592− instance eqArray :: (Eq a) => Eq [a] where
593− (==) = eqArrayImpl (==)
594− (/=) xs ys = not (xs == ys)
595−
596− instance eqOrdering :: Eq Ordering where
597− (==) LT LT = true
598− (==) GT GT = true
599− (==) EQ EQ = true
600− (==) _ _ = false
601− (/=) x y = not (x == y)
602−
603− foreign import refEq
604− """
605− function refEq(r1) {
606− return function(r2) {
607− return r1 === r2;
608− };
609− }
610− """ :: forall a. a -> a -> Boolean
611−
612− foreign import refIneq
613− """
614− function refIneq(r1) {
615− return function(r2) {
616− return r1 !== r2;
617− };
618− }
619− """ :: forall a. a -> a -> Boolean
620−
621− foreign import eqArrayImpl
622− """
623− function eqArrayImpl(f) {
624− return function(xs) {
625− return function(ys) {
626− if (xs.length !== ys.length) return false;
627− for (var i = 0; i < xs.length; i++) {
628− if (!f(xs[i])(ys[i])) return false;
629− }
630− return true;
631− };
632− };
633− }
634− """ :: forall a. (a -> a -> Boolean) -> [a] -> [a] -> Boolean
635−
636− -- | The `Ordering` data type represents the three possible outcomes of
637− -- | comparing two values:
638− -- |
639− -- | `LT` - The first value is _less than_ the second.
640− -- | `GT` - The first value is _greater than_ the second.
641− -- | `EQ` - The first value is _equal to_ or _incomparable to_ the second.
642− data Ordering = LT | GT | EQ
643−
644− -- | The `Ord` type class represents types which support comparisons.
645− -- |
646− -- | `Ord` instances should satisfy the laws of _partially orderings_:
647− -- |
648− -- | - Reflexivity: `a <= a`
649− -- | - Antisymmetry: if `a <= b` and `b <= a` then `a = b`
650− -- | - Transitivity: if `a <= b` and `b <= c` then `a <= c`
651− class (Eq a) <= Ord a where
652− compare :: a -> a -> Ordering
653−
654− instance ordBoolean :: Ord Boolean where
655− compare false false = EQ
656− compare false true = LT
657− compare true true = EQ
658− compare true false = GT
659−
660− instance ordNumber :: Ord Number where
661− compare = unsafeCompare
662−
663− instance ordString :: Ord String where
664− compare = unsafeCompare
665−
666− instance ordUnit :: Ord Unit where
667− compare _ _ = EQ
668−
669− instance ordArray :: (Ord a) => Ord [a] where
670− compare [] [] = EQ
671− compare [] _ = LT
672− compare _ [] = GT
673− compare (x:xs) (y:ys) = case compare x y of
674− EQ -> compare xs ys
675− other -> other
676−
677− instance ordOrdering :: Ord Ordering where
678− compare LT LT = EQ
679− compare EQ EQ = EQ
680− compare GT GT = EQ
681− compare LT _ = LT
682− compare EQ LT = GT
683− compare EQ GT = LT
684− compare GT _ = GT
685−
686− infixl 4 <
687− infixl 4 >
688− infixl 4 <=
689− infixl 4 >=
690−
691− -- | Test whether one value is _strictly less than_ another.
692− (<) :: forall a. (Ord a) => a -> a -> Boolean
693− (<) a1 a2 = case a1 `compare` a2 of
694− LT -> true
695− _ -> false
696−
697− -- | Test whether one value is _strictly greater than_ another.
698− (>) :: forall a. (Ord a) => a -> a -> Boolean
699− (>) a1 a2 = case a1 `compare` a2 of
700− GT -> true
701− _ -> false
702−
703− -- | Test whether one value is _non-strictly less than_ another.
704− (<=) :: forall a. (Ord a) => a -> a -> Boolean
705− (<=) a1 a2 = case a1 `compare` a2 of
706− GT -> false
707− _ -> true
708−
709− -- | Test whether one value is _non-strictly greater than_ another.
710− (>=) :: forall a. (Ord a) => a -> a -> Boolean
711− (>=) a1 a2 = case a1 `compare` a2 of
712− LT -> false
713− _ -> true
714−
715− unsafeCompare :: forall a. a -> a -> Ordering
716− unsafeCompare = unsafeCompareImpl LT EQ GT
717−
718− foreign import unsafeCompareImpl
719− """
720− function unsafeCompareImpl(lt) {
721− return function(eq) {
722− return function(gt) {
723− return function(x) {
724− return function(y) {
725− return x < y ? lt : x > y ? gt : eq;
726− };
727− };
728− };
729− };
730− }
731− """ :: forall a. Ordering -> Ordering -> Ordering -> a -> a -> Ordering
732−
733− -- | The `Bounded` type class represents types that are finite partially
734− -- | ordered sets.
735− -- |
736− -- | Instances should satisfy the following law in addition to the `Ord` laws:
737− -- |
738− -- | - Ordering: `bottom <= a <= top`
739− class (Ord a) <= Bounded a where
740− top :: a
741− bottom :: a
742−
743− instance boundedBoolean :: Bounded Boolean where
744− top = true
745− bottom = false
746−
747− instance boundedUnit :: Bounded Unit where
748− top = unit
749− bottom = unit
750−
751− instance boundedOrdering :: Bounded Ordering where
752− top = GT
753− bottom = LT
754−
755− -- | The `Lattice` type class represents types that are partially ordered
756− -- | sets with a supremum (`sup` or `||`) and infimum (`inf` or `&&`).
757− -- |
758− -- | Instances should satisfy the following laws in addition to the `Ord`
759− -- | laws:
760− -- |
761− -- | - Associativity:
762− -- | - `a || (b || c) = (a || b) || c`
763− -- | - `a && (b && c) = (a && b) && c`
764− -- | - Commutativity:
765− -- | - `a || b = b || a`
766− -- | - `a && b = b && a`
767− -- | - Absorption:
768− -- | - `a || (a && b) = a`
769− -- | - `a && (a || b) = a`
770− -- | - Idempotent:
771− -- | - `a || a = a`
772− -- | - `a && a = a`
773− class (Ord a) <= Lattice a where
774− sup :: a -> a -> a
775− inf :: a -> a -> a
776−
777− instance latticeBoolean :: Lattice Boolean where
778− sup = boolOr
779− inf = boolAnd
780−
781− instance latticeUnit :: Lattice Unit where
782− sup _ _ = unit
783− inf _ _ = unit
784−
785− infixr 2 ||
786− infixr 3 &&
787−
788− -- | The `sup` operator.
789− (||) :: forall a. (Lattice a) => a -> a -> a
790− (||) = sup
791−
792− -- | The `inf` operator.
793− (&&) :: forall a. (Lattice a) => a -> a -> a
794− (&&) = inf
795−
796− -- | The `BoundedLattice` type class represents types that are finite
797− -- | lattices.
798− -- |
799− -- | Instances should satisfy the following law in addition to the `Lattice`
800− -- | and `Bounded` laws:
801− -- |
802− -- | - Identity:
803− -- | - `a || bottom = a`
804− -- | - `a && top = a`
805− -- | - Annihiliation:
806− -- | - `a || top = top`
807− -- | - `a && bottom = bottom`
808− class (Bounded a, Lattice a) <= BoundedLattice a
809−
810− instance boundedLatticeBoolean :: BoundedLattice Boolean
811−
812− instance boundedLatticeUnit :: BoundedLattice Unit
813−
814− -- | The `ComplementedLattice` type class represents types that are lattices
815− -- | where every member is also uniquely complemented.
816− -- |
817− -- | Instances should satisfy the following law in addition to the
818− -- | `BoundedLattice` laws:
819− -- |
820− -- | - Complemented:
821− -- | - `not a || a == top`
822− -- | - `not a && a == bottom`
823− -- | - Double negation:
824− -- | - `not <<< not == id`
825− class (BoundedLattice a) <= ComplementedLattice a where
826− not :: a -> a
827−
828− instance complementedLatticeBoolean :: ComplementedLattice Boolean where
829− not = boolNot
830−
831− instance complementedLatticeUnit :: ComplementedLattice Unit where
832− not _ = unit
833−
834− -- | The `DistributiveLattice` type class represents types that are lattices
835− -- | where the `&&` and `||` distribute over each other.
836− -- |
837− -- | Instances should satisfy the following law in addition to the `Lattice`
838− -- | laws:
839− -- |
840− -- | - Distributivity: `x && (y || z) = (x && y) || (x && z)`
841− class (Lattice a) <= DistributiveLattice a
842−
843− instance distributiveLatticeBoolean :: DistributiveLattice Boolean
844−
845− instance distributiveLatticeUnit :: DistributiveLattice Unit
846−
847− -- | The `BooleanAlgebra` type class represents types that are Boolean
848− -- | algebras, also known as Boolean lattices.
849− -- |
850− -- | Instances should satisfy the `ComplementedLattice` and
851− -- | `DistributiveLattice` laws.
852− class (ComplementedLattice a, DistributiveLattice a) <= BooleanAlgebra a
853−
854− instance booleanAlgebraBoolean :: BooleanAlgebra Boolean
855−
856− instance booleanAlgebraUnit :: BooleanAlgebra Unit
857−
858− foreign import boolOr
859− """
860− function boolOr(b1) {
861− return function(b2) {
862− return b1 || b2;
863− };
864− }
865− """ :: Boolean -> Boolean -> Boolean
866−
867− foreign import boolAnd
868− """
869− function boolAnd(b1) {
870− return function(b2) {
871− return b1 && b2;
872− };
873− }
874− """ :: Boolean -> Boolean -> Boolean
875−
876− foreign import boolNot
877− """
878− function boolNot(b) {
879− return !b;
880− }
881− """ :: Boolean -> Boolean
882−
883− -- | The `Show` type class represents those types which can be converted into
884− -- | a human-readable `String` representation.
885− -- |
886− -- | While not required, it is recommended that for any expression `x`, the
887− -- | string `show x` be executable PureScript code which evaluates to the same
888− -- | value as the expression `x`.
889− class Show a where
890− show :: a -> String
891−
892− instance showBoolean :: Show Boolean where
893− show true = "true"
894− show false = "false"
895−
896− instance showNumber :: Show Number where
897− show = showNumberImpl
898−
899− instance showString :: Show String where
900− show = showStringImpl
901−
902− instance showUnit :: Show Unit where
903− show _ = "unit"
904−
905− instance showArray :: (Show a) => Show [a] where
906− show = showArrayImpl show
907−
908− instance showOrdering :: Show Ordering where
909− show LT = "LT"
910− show GT = "GT"
911− show EQ = "EQ"
912−
913− foreign import showNumberImpl
914− """
915− function showNumberImpl(n) {
916− return n.toString();
917− }
918− """ :: Number -> String
919−
920− foreign import showStringImpl
921− """
922− function showStringImpl(s) {
923− return JSON.stringify(s);
924− }
925− """ :: String -> String
926−
927− foreign import showArrayImpl
928− """
929− function showArrayImpl(f) {
930− return function(xs) {
931− var ss = [];
932− for (var i = 0, l = xs.length; i < l; i++) {
933− ss[i] = f(xs[i]);
934− }
935− return '[' + ss.join(',') + ']';
936− };
937− }
938− """ :: forall a. (a -> String) -> [a] -> String
939−
940−module Data.Function where
941−
942− -- | The `on` function is used to change the domain of a binary operator.
943− -- |
944− -- | For example, we can create a function which compares two records based on the values of their `x` properties:
945− -- |
946− -- | ```purescript
947− -- | compareX :: forall r. { x :: Number | r } -> { x :: Number | r } -> Ordering
948− -- | compareX = compare `on` _.x
949− -- | ```
950− on :: forall a b c. (b -> b -> c) -> (a -> b) -> a -> a -> c
951− on f g x y = g x `f` g y
952−
953− -- | A function of zero arguments
954− foreign import data Fn0 :: * -> *
955−
956− -- | A function of one argument
957− foreign import data Fn1 :: * -> * -> *
958−
959− -- | A function of two arguments
960− foreign import data Fn2 :: * -> * -> * -> *
961−
962− -- | A function of three arguments
963− foreign import data Fn3 :: * -> * -> * -> * -> *
964−
965− -- | A function of four arguments
966− foreign import data Fn4 :: * -> * -> * -> * -> * -> *
967−
968− -- | A function of five arguments
969− foreign import data Fn5 :: * -> * -> * -> * -> * -> * -> *
970−
971− -- | A function of six arguments
972− foreign import data Fn6 :: * -> * -> * -> * -> * -> * -> * -> *
973−
974− -- | A function of seven arguments
975− foreign import data Fn7 :: * -> * -> * -> * -> * -> * -> * -> * -> *
976−
977− -- | A function of eight arguments
978− foreign import data Fn8 :: * -> * -> * -> * -> * -> * -> * -> * -> * -> *
979−
980− -- | A function of nine arguments
981− foreign import data Fn9 :: * -> * -> * -> * -> * -> * -> * -> * -> * -> * -> *
982−
983− -- | A function of ten arguments
984− foreign import data Fn10 :: * -> * -> * -> * -> * -> * -> * -> * -> * -> * -> * -> *
985−
986− -- | Create a function of no arguments
987− foreign import mkFn0
988− """
989− function mkFn0(fn) {
990− return function() {
991− return fn({});
992− };
993− }
994− """ :: forall a. (Unit -> a) -> Fn0 a
995−
996− -- | Create a function of one argument
997− foreign import mkFn1
998− """
999− function mkFn1(fn) {
1000− return function(a) {
1001− return fn(a);
1002− };
1003− }
1004− """ :: forall a b. (a -> b) -> Fn1 a b
1005−
1006− -- | Create a function of two arguments from a curried function
1007− foreign import mkFn2
1008− """
1009− function mkFn2(fn) {
1010− return function(a, b) {
1011− return fn(a)(b);
1012− };
1013− }
1014− """ :: forall a b c. (a -> b -> c) -> Fn2 a b c
1015−
1016− -- | Create a function of three arguments from a curried function
1017− foreign import mkFn3
1018− """
1019− function mkFn3(fn) {
1020− return function(a, b, c) {
1021− return fn(a)(b)(c);
1022− };
1023− }
1024− """ :: forall a b c d. (a -> b -> c -> d) -> Fn3 a b c d
1025−
1026− -- | Create a function of four arguments from a curried function
1027− foreign import mkFn4
1028− """
1029− function mkFn4(fn) {
1030− return function(a, b, c, d) {
1031− return fn(a)(b)(c)(d);
1032− };
1033− }
1034− """ :: forall a b c d e. (a -> b -> c -> d -> e) -> Fn4 a b c d e
1035−
1036− -- | Create a function of five arguments from a curried function
1037− foreign import mkFn5
1038− """
1039− function mkFn5(fn) {
1040− return function(a, b, c, d, e) {
1041− return fn(a)(b)(c)(d)(e);
1042− };
1043− }
1044− """ :: forall a b c d e f. (a -> b -> c -> d -> e -> f) -> Fn5 a b c d e f
1045−
1046− -- | Create a function of six arguments from a curried function
1047− foreign import mkFn6
1048− """
1049− function mkFn6(fn) {
1050− return function(a, b, c, d, e, f) {
1051− return fn(a)(b)(c)(d)(e)(f);
1052− };
1053− }
1054− """ :: forall a b c d e f g. (a -> b -> c -> d -> e -> f -> g) -> Fn6 a b c d e f g
1055−
1056− -- | Create a function of seven arguments from a curried function
1057− foreign import mkFn7
1058− """
1059− function mkFn7(fn) {
1060− return function(a, b, c, d, e, f, g) {
1061− return fn(a)(b)(c)(d)(e)(f)(g);
1062− };
1063− }
1064− """ :: forall a b c d e f g h. (a -> b -> c -> d -> e -> f -> g -> h) -> Fn7 a b c d e f g h
1065−
1066− -- | Create a function of eight arguments from a curried function
1067− foreign import mkFn8
1068− """
1069− function mkFn8(fn) {
1070− return function(a, b, c, d, e, f, g, h) {
1071− return fn(a)(b)(c)(d)(e)(f)(g)(h);
1072− };
1073− }
1074− """ :: forall a b c d e f g h i. (a -> b -> c -> d -> e -> f -> g -> h -> i) -> Fn8 a b c d e f g h i
1075−
1076− -- | Create a function of nine arguments from a curried function
1077− foreign import mkFn9
1078− """
1079− function mkFn9(fn) {
1080− return function(a, b, c, d, e, f, g, h, i) {
1081− return fn(a)(b)(c)(d)(e)(f)(g)(h)(i);
1082− };
1083− }
1084− """ :: forall a b c d e f g h i j. (a -> b -> c -> d -> e -> f -> g -> h -> i -> j) -> Fn9 a b c d e f g h i j
1085−
1086− -- | Create a function of ten arguments from a curried function
1087− foreign import mkFn10
1088− """
1089− function mkFn10(fn) {
1090− return function(a, b, c, d, e, f, g, h, i, j) {
1091− return fn(a)(b)(c)(d)(e)(f)(g)(h)(i)(j);
1092− };
1093− }
1094− """ :: forall a b c d e f g h i j k. (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k) -> Fn10 a b c d e f g h i j k
1095−
1096− -- | Apply a function of no arguments
1097− foreign import runFn0
1098− """
1099− function runFn0(fn) {
1100− return fn();
1101− }
1102− """ :: forall a. Fn0 a -> a
1103−
1104− -- | Apply a function of one argument
1105− foreign import runFn1
1106− """
1107− function runFn1(fn) {
1108− return function(a) {
1109− return fn(a);
1110− };
1111− }
1112− """ :: forall a b. Fn1 a b -> a -> b
1113−
1114− -- | Apply a function of two arguments
1115− foreign import runFn2
1116− """
1117− function runFn2(fn) {
1118− return function(a) {
1119− return function(b) {
1120− return fn(a, b);
1121− };
1122− };
1123− }
1124− """ :: forall a b c. Fn2 a b c -> a -> b -> c
1125−
1126− -- | Apply a function of three arguments
1127− foreign import runFn3
1128− """
1129− function runFn3(fn) {
1130− return function(a) {
1131− return function(b) {
1132− return function(c) {
1133− return fn(a, b, c);
1134− };
1135− };
1136− };
1137− }
1138− """ :: forall a b c d. Fn3 a b c d -> a -> b -> c -> d
1139−
1140− -- | Apply a function of four arguments
1141− foreign import runFn4
1142− """
1143− function runFn4(fn) {
1144− return function(a) {
1145− return function(b) {
1146− return function(c) {
1147− return function(d) {
1148− return fn(a, b, c, d);
1149− };
1150− };
1151− };
1152− };
1153− }
1154− """ :: forall a b c d e. Fn4 a b c d e -> a -> b -> c -> d -> e
1155−
1156− -- | Apply a function of five arguments
1157− foreign import runFn5
1158− """
1159− function runFn5(fn) {
1160− return function(a) {
1161− return function(b) {
1162− return function(c) {
1163− return function(d) {
1164− return function(e) {
1165− return fn(a, b, c, d, e);
1166− };
1167− };
1168− };
1169− };
1170− };
1171− }
1172− """ :: forall a b c d e f. Fn5 a b c d e f -> a -> b -> c -> d -> e -> f
1173−
1174− -- | Apply a function of six arguments
1175− foreign import runFn6
1176− """
1177− function runFn6(fn) {
1178− return function(a) {
1179− return function(b) {
1180− return function(c) {
1181− return function(d) {
1182− return function(e) {
1183− return function(f) {
1184− return fn(a, b, c, d, e, f);
1185− };
1186− };
1187− };
1188− };
1189− };
1190− };
1191− }
1192− """ :: forall a b c d e f g. Fn6 a b c d e f g -> a -> b -> c -> d -> e -> f -> g
1193−
1194− -- | Apply a function of seven arguments
1195− foreign import runFn7
1196− """
1197− function runFn7(fn) {
1198− return function(a) {
1199− return function(b) {
1200− return function(c) {
1201− return function(d) {
1202− return function(e) {
1203− return function(f) {
1204− return function(g) {
1205− return fn(a, b, c, d, e, f, g);
1206− };
1207− };
1208− };
1209− };
1210− };
1211− };
1212− };
1213− }
1214− """ :: forall a b c d e f g h. Fn7 a b c d e f g h -> a -> b -> c -> d -> e -> f -> g -> h
1215−
1216− -- | Apply a function of eight arguments
1217− foreign import runFn8
1218− """
1219− function runFn8(fn) {
1220− return function(a) {
1221− return function(b) {
1222− return function(c) {
1223− return function(d) {
1224− return function(e) {
1225− return function(f) {
1226− return function(g) {
1227− return function(h) {
1228− return fn(a, b, c, d, e, f, g, h);
1229− };
1230− };
1231− };
1232− };
1233− };
1234− };
1235− };
1236− };
1237− }
1238− """ :: forall a b c d e f g h i. Fn8 a b c d e f g h i -> a -> b -> c -> d -> e -> f -> g -> h -> i
1239−
1240− -- | Apply a function of nine arguments
1241− foreign import runFn9
1242− """
1243− function runFn9(fn) {
1244− return function(a) {
1245− return function(b) {
1246− return function(c) {
1247− return function(d) {
1248− return function(e) {
1249− return function(f) {
1250− return function(g) {
1251− return function(h) {
1252− return function(i) {
1253− return fn(a, b, c, d, e, f, g, h, i);
1254− };
1255− };
1256− };
1257− };
1258− };
1259− };
1260− };
1261− };
1262− };
1263− }
1264− """ :: forall a b c d e f g h i j. Fn9 a b c d e f g h i j -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j
1265−
1266− -- | Apply a function of ten arguments
1267− foreign import runFn10
1268− """
1269− function runFn10(fn) {
1270− return function(a) {
1271− return function(b) {
1272− return function(c) {
1273− return function(d) {
1274− return function(e) {
1275− return function(f) {
1276− return function(g) {
1277− return function(h) {
1278− return function(i) {
1279− return function(j) {
1280− return fn(a, b, c, d, e, f, g, h, i, j);
1281− };
1282− };
1283− };
1284− };
1285− };
1286− };
1287− };
1288− };
1289− };
1290− };
1291− }
1292− """ :: forall a b c d e f g h i j k. Fn10 a b c d e f g h i j k -> a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k
1293−
1294−module Prelude.Unsafe where
1295−
1296− -- | Find the element of an array at the specified index.
1297− -- |
1298− -- | Note: this function can cause unpredictable failure at runtime if the index is out-of-bounds.
1299− foreign import unsafeIndex
1300− """
1301− function unsafeIndex(xs) {
1302− return function(n) {
1303− return xs[n];
1304− };
1305− }
1306− """ :: forall a. [a] -> Number -> a
1307−
1308−module Control.Monad.Eff
1309− ( Eff()
1310− , Pure()
1311− , runPure
1312− , untilE, whileE, forE, foreachE
1313− ) where
1314−
1315− -- | The `Eff` type constructor is used to represent _native_ effects.
1316− -- |
1317− -- | See [Handling Native Effects with the Eff Monad](https://github.com/purescript/purescript/wiki/Handling-Native-Effects-with-the-Eff-Monad) for more details.
1318− -- |
1319− -- | The first type parameter is a row of effects which represents the contexts in which a computation can be run, and the second type parameter is the return type.
1320− foreign import data Eff :: # ! -> * -> *
1321−
1322− foreign import returnE
1323− """
1324− function returnE(a) {
1325− return function() {
1326− return a;
1327− };
1328− }
1329− """ :: forall e a. a -> Eff e a
1330−
1331− foreign import bindE
1332− """
1333− function bindE(a) {
1334− return function(f) {
1335− return function() {
1336− return f(a())();
1337− };
1338− };
1339− }
1340− """ :: forall e a b. Eff e a -> (a -> Eff e b) -> Eff e b
1341−
1342− -- | The `Pure` type synonym represents _pure_ computations, i.e. ones in which all effects have been handled.
1343− -- |
1344− -- | The `runPure` function can be used to run pure computations and obtain their result.
1345− type Pure a = forall e. Eff e a
1346−
1347− -- | Run a pure computation and return its result.
1348− -- |
1349− -- | Note: since this function has a rank-2 type, it may cause problems to apply this function using the `$` operator. The recommended approach
1350− -- | is to use parentheses instead.
1351− foreign import runPure
1352− """
1353− function runPure(f) {
1354− return f();
1355− }
1356− """ :: forall a. Pure a -> a
1357−
1358− instance functorEff :: Functor (Eff e) where
1359− (<$>) = liftA1
1360−
1361− instance applyEff :: Apply (Eff e) where
1362− (<*>) = ap
1363−
1364− instance applicativeEff :: Applicative (Eff e) where
1365− pure = returnE
1366−
1367− instance bindEff :: Bind (Eff e) where
1368− (>>=) = bindE
1369−
1370− instance monadEff :: Monad (Eff e)
1371−
1372− -- | Loop until a condition becomes `true`.
1373− -- |
1374− -- | `untilE b` is an effectful computation which repeatedly runs the effectful computation `b`,
1375− -- | until its return value is `true`.
1376− foreign import untilE
1377− """
1378− function untilE(f) {
1379− return function() {
1380− while (!f());
1381− return {};
1382− };
1383− }
1384− """ :: forall e. Eff e Boolean -> Eff e Unit
1385−
1386− -- | Loop while a condition is `true`.
1387− -- |
1388− -- | `whileE b m` is effectful computation which runs the effectful computation `b`. If its result is
1389− -- | `true`, it runs the effectful computation `m` and loops. If not, the computation ends.
1390− foreign import whileE
1391− """
1392− function whileE(f) {
1393− return function(a) {
1394− return function() {
1395− while (f()) {
1396− a();
1397− }
1398− return {};
1399− };
1400− };
1401− }
1402− """ :: forall e a. Eff e Boolean -> Eff e a -> Eff e Unit
1403−
1404− -- | Loop over a consecutive collection of numbers.
1405− -- |
1406− -- | `forE lo hi f` runs the computation returned by the function `f` for each of the inputs
1407− -- | between `lo` (inclusive) and `hi` (exclusive).
1408− foreign import forE
1409− """
1410− function forE(lo) {
1411− return function(hi) {
1412− return function(f) {
1413− return function() {
1414− for (var i = lo; i < hi; i++) {
1415− f(i)();
1416− }
1417− };
1418− };
1419− };
1420− }
1421− """ :: forall e. Number -> Number -> (Number -> Eff e Unit) -> Eff e Unit
1422−
1423− -- | Loop over an array of values.
1424− -- |
1425− -- | `foreach xs f` runs the computation returned by the function `f` for each of the inputs `xs`.
1426− foreign import foreachE
1427− """
1428− function foreachE(as) {
1429− return function(f) {
1430− return function() {
1431− for (var i = 0; i < as.length; i++) {
1432− f(as[i])();
1433− }
1434− };
1435− };
1436− }
1437− """ :: forall e a. [a] -> (a -> Eff e Unit) -> Eff e Unit
1438−
1439−module Control.Monad.Eff.Unsafe where
1440−
1441− import Control.Monad.Eff
1442−
1443− -- | Change the type of an effectful computation, allowing it to be run in another context.
1444− -- |
1445− -- | Note: use of this function can result in arbitrary side-effects.
1446− foreign import unsafeInterleaveEff
1447− """
1448− function unsafeInterleaveEff(f) {
1449− return f;
1450− }
1451− """ :: forall eff1 eff2 a. Eff eff1 a -> Eff eff2 a
1452−
1453−module Debug.Trace where
1454−
1455− import Control.Monad.Eff
1456−
1457− -- | The `Trace` effect represents those computations which write to the console.
1458− foreign import data Trace :: !
1459−
1460− -- | Write a `String` to the console.
1461− foreign import trace
1462− """
1463− function trace(s) {
1464− return function() {
1465− console.log(s);
1466− return {};
1467− };
1468− }
1469− """ :: forall r. String -> Eff (trace :: Trace | r) Unit
1470−
1471− -- | Write a value to the console, using its `Show` instance to produce a `String`.
1472− print :: forall a r. (Show a) => a -> Eff (trace :: Trace | r) Unit
1473− print o = trace (show o)
1474−
1475−module Control.Monad.ST where
1476−
1477− import Control.Monad.Eff
1478−
1479− -- | The `ST` effect represents _local mutation_, i.e. mutation which does not "escape" into the surrounding computation.
1480− -- |
1481− -- | An `ST` computation is parameterized by a phantom type which is used to restrict the set of reference cells it is allowed to access.
1482− -- |
1483− -- | The `runST` function can be used to handle the `ST` effect.
1484− foreign import data ST :: * -> !
1485−
1486− -- | The type `STRef s a` represents a mutable reference holding a value of type `a`, which can be used with the `ST s` effect.
1487− foreign import data STRef :: * -> * -> *
1488−
1489− -- | Create a new mutable reference.
1490− foreign import newSTRef
1491− """
1492− function newSTRef(val) {
1493− return function() {
1494− return { value: val };
1495− };
1496− }
1497− """ :: forall a h r. a -> Eff (st :: ST h | r) (STRef h a)
1498−
1499− -- | Read the current value of a mutable reference.
1500− foreign import readSTRef
1501− """
1502− function readSTRef(ref) {
1503− return function() {
1504− return ref.value;
1505− };
1506− }
1507− """ :: forall a h r. STRef h a -> Eff (st :: ST h | r) a
1508−
1509− -- | Modify the value of a mutable reference by applying a function to the current value.
1510− foreign import modifySTRef
1511− """
1512− function modifySTRef(ref) {
1513− return function(f) {
1514− return function() {
1515− return ref.value = f(ref.value);
1516− };
1517− };
1518− }
1519− """ :: forall a h r. STRef h a -> (a -> a) -> Eff (st :: ST h | r) a
1520−
1521− -- | Set the value of a mutable reference.
1522− foreign import writeSTRef
1523− """
1524− function writeSTRef(ref) {
1525− return function(a) {
1526− return function() {
1527− return ref.value = a;
1528− };
1529− };
1530− }
1531− """ :: forall a h r. STRef h a -> a -> Eff (st :: ST h | r) a
1532−
1533− -- | Run an `ST` computation.
1534− -- |
1535− -- | 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
1536− -- | to the surrounding computation.
1537− -- |
1538− -- | It may cause problems to apply this function using the `$` operator. The recommended approach is to use parentheses instead.
1539− foreign import runST
1540− """
1541− function runST(f) {
1542− return f;
1543− }
1544− """ :: forall a r. (forall h. Eff (st :: ST h | r) a) -> Eff r a
1545−
1546− -- | A convenience function which combines `runST` with `runPure`, which can be used when the only required effect is `ST`.
1547− -- |
1548− -- | Note: since this function has a rank-2 type, it may cause problems to apply this function using the `$` operator. The recommended approach
1549− -- | is to use parentheses instead.
1550− pureST :: forall a. (forall h r. Eff (st :: ST h | r) a) -> a
1551− pureST st = runPure (runST st)