@@ -2,684 +2,1146 @@
22
33## Module Prelude
44
5−### Types
65
7−#### `Ordering`
86
9− data Ordering
10− = LT
11− | GT
12− | EQ
7+#### `otherwise`
138
14−#### `Unit`
9+``` purescript
10+otherwise :: Boolean
11+```
1512
16− newtype Unit
17− = Unit { }
13+An alias for `true`, which can be useful in guard clauses:
1814
15+E.g.
1916
20−### Type Classes
17+ max x y | x >= y = x
18+ | otherwise = y
2119
22−
20+#### `flip`
2321
24−#### `Applicative`
22+``` purescript
23+flip :: forall a b c. (a -> b -> c) -> b -> a -> c
24+```
2525
26− class (Apply f) <= Applicative f where
27− pure :: forall a. a -> f a
26+Flips the order of the arguments to a function of two arguments.
2827
29−#### `Apply`
28+#### `const`
3029
31− class (Functor f) <= Apply f where
32− (<*>) :: forall a b. f (a -> b) -> f a -> f b
30+``` purescript
31+const :: forall a b. a -> b -> a
32+```
3333
34−#### `Bind`
34+Returns its first argument and ignores its second.
35+
36+#### `asTypeOf`
3537
36− class (Apply m) <= Bind m where
37− (>>=) :: forall a b. m a -> (a -> m b) -> m b
38+``` purescript
39+asTypeOf :: forall a. a -> a -> a
40+```
3841
39−#### `Bits`
42+This function returns its first argument, and can be used to assert type equalities.
43+This can be useful when types are otherwise ambiguous.
4044
41− class Bits b where
42− (.&.) :: b -> b -> b
43− (.|.) :: b -> b -> b
44− (.^.) :: b -> b -> b
45− shl :: b -> Number -> b
46− shr :: b -> Number -> b
47− zshr :: b -> Number -> b
48− complement :: b -> b
45+E.g.
46+
47+ main = print $ [] `asTypeOf` [0]
48+
49+If instead, we had written `main = print []`, the type of the argument `[]` would have
50+been ambiguous, resulting in a compile-time error.
51+
52+#### `Semigroupoid`
53+
54+``` purescript
55+class Semigroupoid a where
56+ (<<<) :: forall b c d. a c d -> a b c -> a b d
57+```
58+
59+A `Semigroupoid` is similar to a [`Category`](#Category) but does not require an identity
60+element `id`, just composable morphisms.
61+
62+`Semigroupoid`s should obey the following rule:
63+
64+Association:
65+ `forall p q r. p <<< (q <<< r) = (p <<< q) <<< r`
66+
67+
68+#### `semigroupoidArr`
69+
70+``` purescript
71+instance semigroupoidArr :: Semigroupoid Prim.Function
72+```
4973
50−#### `BoolLike`
5174
52− class BoolLike b where
53− (&&) :: b -> b -> b
54− (||) :: b -> b -> b
55− not :: b -> b
75+#### `(>>>)`
76+
77+``` purescript
78+(>>>) :: forall a b c d. (Semigroupoid a) => a b c -> a c d -> a b d
79+```
80+
5681
5782#### `Category`
5883
59− class (Semigroupoid a) <= Category a where
60− id :: forall t. a t t
84+``` purescript
85+class (Semigroupoid a) <= Category a where
86+ id :: forall t. a t t
87+```
6188
62−#### `DivisionRing`
89+`Category`s consist of objects and composable morphisms between them, and as such are
90+[`Semigroupoids`](#Semigroupoid), but unlike `semigroupoids` must have an identity element.
6391
64−Ring where every nonzero element has a multiplicative inverse (possibly
65−a non-commutative field) so that ```a `mod` b = zero```
92+`Category`s should obey the following rules.
6693
67− class (Ring a, ModuloSemiring a) <= DivisionRing a where
94+Left Identity:
95+ `forall p. id <<< p = p`
6896
69−#### `Eq`
97+Right Identity:
98+ `forall p. p <<< id = p`
99+
100+
101+#### `categoryArr`
102+
103+``` purescript
104+instance categoryArr :: Category Prim.Function
105+```
106+
107+
108+#### `($)`
109+
110+``` purescript
111+($) :: forall a b. (a -> b) -> a -> b
112+```
113+
114+
115+#### `(#)`
116+
117+``` purescript
118+(#) :: forall a b. a -> (a -> b) -> b
119+```
120+
121+
122+#### `(:)`
123+
124+``` purescript
125+(:) :: forall a. a -> [a] -> [a]
126+```
127+
128+
129+#### `cons`
130+
131+``` purescript
132+cons :: forall a. a -> [a] -> [a]
133+```
134+
135+
136+#### `Show`
137+
138+``` purescript
139+class Show a where
140+ show :: a -> String
141+```
142+
143+
144+#### `showUnit`
145+
146+``` purescript
147+instance showUnit :: Show Unit
148+```
149+
150+
151+#### `showString`
152+
153+``` purescript
154+instance showString :: Show String
155+```
156+
157+
158+#### `showBoolean`
159+
160+``` purescript
161+instance showBoolean :: Show Boolean
162+```
163+
164+
165+#### `showNumber`
166+
167+``` purescript
168+instance showNumber :: Show Number
169+```
170+
171+
172+#### `showArray`
173+
174+``` purescript
175+instance showArray :: (Show a) => Show [a]
176+```
70177
71− class Eq a where
72− (==) :: a -> a -> Boolean
73− (/=) :: a -> a -> Boolean
74178
75179#### `Functor`
76180
77− class Functor f where
78− (<$>) :: forall a b. (a -> b) -> f a -> f b
181+``` purescript
182+class Functor f where
183+ (<$>) :: forall a b. (a -> b) -> f a -> f b
184+```
79185
80−#### `ModuloSemiring`
186+A `Functor` is intuitively a type which can be mapped over, and more formally a mapping
187+between [`Category`](#Category)s that preserves structure.
81188
82−Semiring with modulo operation and division where
83−```a / b * b + (a `mod` b) = a```
189+`Functor`s should obey the following rules.
84190
85− class (Semiring a) <= ModuloSemiring a where
86− (/) :: a -> a -> a
87− mod :: a -> a -> a
191+Identity:
192+ `(<$>) id = id`
88193
89−#### `Monad`
194+Composition:
195+ `forall f g. (<$>) (f . g) = ((<$>) f) . ((<$>) g)`
90196
91− class (Applicative m, Bind m) <= Monad m where
92197
93−#### `Num`
198+#### `(<#>)`
94199
95−A commutative field
200+``` purescript
201+(<#>) :: forall f a b. (Functor f) => f a -> (a -> b) -> f b
202+```
96203
97− class (DivisionRing a) <= Num a where
98204
99−#### `Ord`
205+#### `void`
100206
101− class (Eq a) <= Ord a where
102− compare :: a -> a -> Ordering
207+``` purescript
208+void :: forall f a. (Functor f) => f a -> f Unit
209+```
103210
104−#### `Ring`
105211
106−Addition, multiplication, and subtraction
212+#### `Apply`
107213
108− class (Semiring a) <= Ring a where
109− (-) :: a -> a -> a
214+``` purescript
215+class (Functor f) <= Apply f where
216+ (<*>) :: forall a b. f (a -> b) -> f a -> f b
217+```
110218
111−#### `Semigroup`
219+`Apply`s are intuitively [`Applicative`](#Applicative)s less `pure`, and more formally a
220+strong lax semi-monoidal endofunctor.
112221
113− class Semigroup a where
114− (<>) :: a -> a -> a
222+`Apply`s should obey the following rules.
115223
116−#### `Semigroupoid`
224+Associative Composition:
225+ `forall f g h. (.) <$> f <*> g <*> h = f <*> (g <*> h)`
117226
118− class Semigroupoid a where
119− (<<<) :: forall b c d. a c d -> a b c -> a b d
120227
121−#### `Semiring`
228+#### `Applicative`
122229
123−Addition and multiplication
230+``` purescript
231+class (Apply f) <= Applicative f where
232+ pure :: forall a. a -> f a
233+```
124234
125− class Semiring a where
126− (+) :: a -> a -> a
127− zero :: a
128− (*) :: a -> a -> a
129− one :: a
235+`Applicative`s are [`Functor`](#Functor)s which can be "applied" by sequencing composition
236+(`<*>`) or embedding pure expressions (`pure`).
130237
131−#### `Show`
238+`Applicative`s should obey the following rules.
132239
133− class Show a where
134− show :: a -> String
240+Identity:
241+ `forall v. (pure id) <*> v = v`
135242
243+Composition:
244+ `forall f g h. (pure (.)) <*> f <*> g <*> h = f <*> (g <*> h)`
136245
137−### Type Class Instances
246+Homomorphism:
247+ `forall f x. (pure f) <*> (pure x) = pure (f x)`
248+
249+Interchange:
250+ `forall u y. u <*> (pure y) = (pure (($) y)) <*> u`
138251
139−#### `applicativeArr`
140252
141− instance applicativeArr :: Applicative (Prim.Function r)
253+#### `liftA1`
254+
255+``` purescript
256+liftA1 :: forall f a b. (Applicative f) => (a -> b) -> f a -> f b
257+```
258+
259+
260+#### `Bind`
261+
262+``` purescript
263+class (Apply m) <= Bind m where
264+ (>>=) :: forall a b. m a -> (a -> m b) -> m b
265+```
266+
267+A `Bind` is an [`Apply`](#Apply) with a bind operation which sequentially composes actions.
268+
269+`Bind`s should obey the following rule.
270+
271+Associativity:
272+ `forall f g x. (x >>= f) >>= g = x >>= (\k => f k >>= g)`
273+
274+
275+#### `Monad`
276+
277+``` purescript
278+class (Applicative m, Bind m) <= Monad m where
279+```
280+
281+`Monad` is a class which can be intuitively thought of as an abstract datatype of actions or
282+more formally though of as a monoid in the category of endofunctors.
283+
284+`Monad`s should obey the following rules.
285+
286+Left Identity:
287+ `forall f x. pure x >>= f = f x`
288+
289+Right Identity:
290+ `forall x. x >>= pure = x`
291+
292+
293+#### `return`
294+
295+``` purescript
296+return :: forall m a. (Monad m) => a -> m a
297+```
298+
299+
300+#### `liftM1`
301+
302+``` purescript
303+liftM1 :: forall m a b. (Monad m) => (a -> b) -> m a -> m b
304+```
305+
306+
307+#### `ap`
308+
309+``` purescript
310+ap :: forall m a b. (Monad m) => m (a -> b) -> m a -> m b
311+```
312+
313+
314+#### `functorArr`
315+
316+``` purescript
317+instance functorArr :: Functor (Prim.Function r)
318+```
319+
142320
143321#### `applyArr`
144322
145− instance applyArr :: Apply (Prim.Function r)
323+``` purescript
324+instance applyArr :: Apply (Prim.Function r)
325+```
326+
327+
328+#### `applicativeArr`
329+
330+``` purescript
331+instance applicativeArr :: Applicative (Prim.Function r)
332+```
333+
146334
147335#### `bindArr`
148336
149− instance bindArr :: Bind (Prim.Function r)
337+``` purescript
338+instance bindArr :: Bind (Prim.Function r)
339+```
150340
151−#### `bitsNumber`
152341
153− instance bitsNumber :: Bits Number
342+#### `monadArr`
154343
155−#### `boolLikeBoolean`
344+``` purescript
345+instance monadArr :: Monad (Prim.Function r)
346+```
156347
157− instance boolLikeBoolean :: BoolLike Boolean
158348
159−#### `categoryArr`
349+#### `Semiring`
160350
161− instance categoryArr :: Category Prim.Function
351+``` purescript
352+class Semiring a where
353+ (+) :: a -> a -> a
354+ zero :: a
355+ (*) :: a -> a -> a
356+ one :: a
357+```
162358
163−#### `divisionRingNumber`
359+Addition and multiplication
164360
165− instance divisionRingNumber :: DivisionRing Number
361+#### `ModuloSemiring`
166362
167−#### `eqArray`
363+``` purescript
364+class (Semiring a) <= ModuloSemiring a where
365+ (/) :: a -> a -> a
366+ mod :: a -> a -> a
367+```
168368
169− instance eqArray :: (Eq a) => Eq [a]
369+Semiring with modulo operation and division where
370+```a / b * b + (a `mod` b) = a```
170371
171−#### `eqBoolean`
372+#### `Ring`
172373
173− instance eqBoolean :: Eq Boolean
374+``` purescript
375+class (Semiring a) <= Ring a where
376+ (-) :: a -> a -> a
377+```
174378
175−#### `eqNumber`
379+Addition, multiplication, and subtraction
176380
177− instance eqNumber :: Eq Number
381+#### `negate`
178382
179−#### `eqOrdering`
383+``` purescript
384+negate :: forall a. (Ring a) => a -> a
385+```
180386
181− instance eqOrdering :: Eq Ordering
182387
183−#### `eqString`
388+#### `DivisionRing`
184389
185− instance eqString :: Eq String
390+``` purescript
391+class (Ring a, ModuloSemiring a) <= DivisionRing a where
392+```
186393
187−#### `eqUnit`
394+Ring where every nonzero element has a multiplicative inverse (possibly
395+a non-commutative field) so that ```a `mod` b = zero```
396+
397+#### `Num`
188398
189− instance eqUnit :: Eq Unit
399+``` purescript
400+class (DivisionRing a) <= Num a where
401+```
190402
191−#### `functorArr`
403+A commutative field
404+
405+#### `semiringNumber`
406+
407+``` purescript
408+instance semiringNumber :: Semiring Number
409+```
410+
411+
412+#### `ringNumber`
413+
414+``` purescript
415+instance ringNumber :: Ring Number
416+```
192417
193− instance functorArr :: Functor (Prim.Function r)
194418
195419#### `moduloSemiringNumber`
196420
197− instance moduloSemiringNumber :: ModuloSemiring Number
421+``` purescript
422+instance moduloSemiringNumber :: ModuloSemiring Number
423+```
198424
199−#### `monadArr`
200425
201− instance monadArr :: Monad (Prim.Function r)
426+#### `divisionRingNumber`
427+
428+``` purescript
429+instance divisionRingNumber :: DivisionRing Number
430+```
431+
202432
203433#### `numNumber`
204434
205− instance numNumber :: Num Number
435+``` purescript
436+instance numNumber :: Num Number
437+```
206438
207−#### `ordArray`
208439
209− instance ordArray :: (Ord a) => Ord [a]
440+#### `Unit`
210441
211−#### `ordBoolean`
442+``` purescript
443+newtype Unit
444+ = Unit { }
445+```
212446
213− instance ordBoolean :: Ord Boolean
214447
215−#### `ordNumber`
448+#### `unit`
216449
217− instance ordNumber :: Ord Number
450+``` purescript
451+unit :: Unit
452+```
218453
219−#### `ordString`
220454
221− instance ordString :: Ord String
455+#### `Eq`
222456
223−#### `ordUnit`
457+``` purescript
458+class Eq a where
459+ (==) :: a -> a -> Boolean
460+ (/=) :: a -> a -> Boolean
461+```
224462
225− instance ordUnit :: Ord Unit
226463
227−#### `ringNumber`
464+#### `refEq`
228465
229− instance ringNumber :: Ring Number
466+``` purescript
467+refEq :: forall a. a -> a -> Boolean
468+```
230469
231−#### `semigroupArr`
232470
233− instance semigroupArr :: (Semigroup s') => Semigroup (s -> s')
471+#### `refIneq`
234472
235−#### `semigroupString`
473+``` purescript
474+refIneq :: forall a. a -> a -> Boolean
475+```
236476
237− instance semigroupString :: Semigroup String
238477
239−#### `semigroupUnit`
478+#### `eqUnit`
240479
241− instance semigroupUnit :: Semigroup Unit
480+``` purescript
481+instance eqUnit :: Eq Unit
482+```
242483
243−#### `semigroupoidArr`
244484
245− instance semigroupoidArr :: Semigroupoid Prim.Function
485+#### `eqString`
246486
247−#### `semiringNumber`
487+``` purescript
488+instance eqString :: Eq String
489+```
248490
249− instance semiringNumber :: Semiring Number
250491
251−#### `showArray`
492+#### `eqNumber`
252493
253− instance showArray :: (Show a) => Show [a]
494+``` purescript
495+instance eqNumber :: Eq Number
496+```
254497
255−#### `showBoolean`
256498
257− instance showBoolean :: Show Boolean
499+#### `eqBoolean`
258500
259−#### `showNumber`
501+``` purescript
502+instance eqBoolean :: Eq Boolean
503+```
260504
261− instance showNumber :: Show Number
262505
263−#### `showOrdering`
506+#### `eqArray`
264507
265− instance showOrdering :: Show Ordering
508+``` purescript
509+instance eqArray :: (Eq a) => Eq [a]
510+```
266511
267−#### `showString`
268512
269− instance showString :: Show String
513+#### `Ordering`
270514
271−#### `showUnit`
515+``` purescript
516+data Ordering
517+ = LT
518+ | GT
519+ | EQ
520+```
272521
273− instance showUnit :: Show Unit
274522
523+#### `eqOrdering`
275524
276−### Values
525+``` purescript
526+instance eqOrdering :: Eq Ordering
527+```
277528
278−#### `(#)`
279529
280− (#) :: forall a b. a -> (a -> b) -> b
530+#### `showOrdering`
281531
282−#### `($)`
532+``` purescript
533+instance showOrdering :: Show Ordering
534+```
283535
284− ($) :: forall a b. (a -> b) -> a -> b
285536
286−#### `(++)`
537+#### `semigroupOrdening`
287538
288− (++) :: forall s. (Semigroup s) => s -> s -> s
539+``` purescript
540+instance semigroupOrdening :: Semigroup Ordering
541+```
289542
290−#### `(:)`
291543
292− (:) :: forall a. a -> [a] -> [a]
544+#### `Ord`
293545
294−#### `(<#>)`
546+``` purescript
547+class (Eq a) <= Ord a where
548+ compare :: a -> a -> Ordering
549+```
295550
296− (<#>) :: forall f a b. (Functor f) => f a -> (a -> b) -> f b
297551
298552#### `(<)`
299553
300− (<) :: forall a. (Ord a) => a -> a -> Boolean
554+``` purescript
555+(<) :: forall a. (Ord a) => a -> a -> Boolean
556+```
301557
302−#### `(<=)`
303−
304− (<=) :: forall a. (Ord a) => a -> a -> Boolean
305558
306559#### `(>)`
307560
308− (>) :: forall a. (Ord a) => a -> a -> Boolean
561+``` purescript
562+(>) :: forall a. (Ord a) => a -> a -> Boolean
563+```
564+
565+
566+#### `(<=)`
567+
568+``` purescript
569+(<=) :: forall a. (Ord a) => a -> a -> Boolean
570+```
571+
309572
310573#### `(>=)`
311574
312− (>=) :: forall a. (Ord a) => a -> a -> Boolean
575+``` purescript
576+(>=) :: forall a. (Ord a) => a -> a -> Boolean
577+```
313578
314−#### `(>>>)`
315579
316− (>>>) :: forall a b c d. (Semigroupoid a) => a b c -> a c d -> a b d
580+#### `ordUnit`
317581
318−#### `ap`
582+``` purescript
583+instance ordUnit :: Ord Unit
584+```
319585
320− ap :: forall m a b. (Monad m) => m (a -> b) -> m a -> m b
321586
322−#### `asTypeOf`
587+#### `ordBoolean`
323588
324−This function returns its first argument, and can be used to assert type equalities.
325−This can be useful when types are otherwise ambiguous.
589+``` purescript
590+instance ordBoolean :: Ord Boolean
591+```
326592
327−E.g.
328593
329− main = print $ [] `asTypeOf` [0]
594+#### `ordNumber`
330595
331−If instead, we had written `main = print []`, the type of the argument `[]` would have
332−been ambiguous, resulting in a compile-time error.
596+``` purescript
597+instance ordNumber :: Ord Number
598+```
333599
334− asTypeOf :: forall a. a -> a -> a
335600
336−#### `cons`
601+#### `ordString`
337602
338− cons :: forall a. a -> [a] -> [a]
603+``` purescript
604+instance ordString :: Ord String
605+```
339606
340−#### `const`
341607
342−Returns its first argument and ignores its second.
608+#### `ordArray`
343609
344− const :: forall a b. a -> b -> a
610+``` purescript
611+instance ordArray :: (Ord a) => Ord [a]
612+```
345613
346−#### `flip`
347614
348−Flips the order of the arguments to a function of two arguments.
615+#### `Bits`
349616
350− flip :: forall a b c. (a -> b -> c) -> b -> a -> c
617+``` purescript
618+class Bits b where
619+ (.&.) :: b -> b -> b
620+ (.|.) :: b -> b -> b
621+ (.^.) :: b -> b -> b
622+ shl :: b -> Number -> b
623+ shr :: b -> Number -> b
624+ zshr :: b -> Number -> b
625+ complement :: b -> b
626+```
351627
352−#### `liftA1`
353628
354− liftA1 :: forall f a b. (Applicative f) => (a -> b) -> f a -> f b
629+#### `bitsNumber`
355630
356−#### `liftM1`
631+``` purescript
632+instance bitsNumber :: Bits Number
633+```
357634
358− liftM1 :: forall m a b. (Monad m) => (a -> b) -> m a -> m b
359635
360−#### `negate`
636+#### `BoolLike`
361637
362− negate :: forall a. (Ring a) => a -> a
638+``` purescript
639+class BoolLike b where
640+ (&&) :: b -> b -> b
641+ (||) :: b -> b -> b
642+ not :: b -> b
643+```
363644
364−#### `otherwise`
365645
366−An alias for `true`, which can be useful in guard clauses:
646+#### `boolLikeBoolean`
367647
368−E.g.
648+``` purescript
649+instance boolLikeBoolean :: BoolLike Boolean
650+```
369651
370− max x y | x >= y = x
371− | otherwise = y
372652
373− otherwise :: Boolean
653+#### `Semigroup`
374654
375−#### `refEq`
655+``` purescript
656+class Semigroup a where
657+ (<>) :: a -> a -> a
658+```
376659
377− refEq :: forall a. a -> a -> Boolean
378660
379−#### `refIneq`
661+#### `semigroupUnit`
380662
381− refIneq :: forall a. a -> a -> Boolean
663+``` purescript
664+instance semigroupUnit :: Semigroup Unit
665+```
382666
383−#### `return`
384667
385− return :: forall m a. (Monad m) => a -> m a
668+#### `semigroupString`
386669
387−#### `unit`
670+``` purescript
671+instance semigroupString :: Semigroup String
672+```
388673
389− unit :: Unit
390674
391−#### `void`
675+#### `semigroupArr`
676+
677+``` purescript
678+instance semigroupArr :: (Semigroup s') => Semigroup (s -> s')
679+```
680+
681+
682+#### `(++)`
683+
684+``` purescript
685+(++) :: forall s. (Semigroup s) => s -> s -> s
686+```
392687
393− void :: forall f a. (Functor f) => f a -> f Unit
394688
395689
396690## Module Data.Function
397691
398−### Types
692+
693+
694+#### `on`
695+
696+``` purescript
697+on :: forall a b c. (b -> b -> c) -> (a -> b) -> a -> a -> c
698+```
699+
399700
400701#### `Fn0`
401702
402− data Fn0 :: * -> *
703+``` purescript
704+data Fn0 :: * -> *
705+```
403706
404−#### `Fn1`
405707
406− data Fn1 :: * -> * -> *
708+#### `Fn1`
407709
408−#### `Fn10`
710+``` purescript
711+data Fn1 :: * -> * -> *
712+```
409713
410− data Fn10 :: * -> * -> * -> * -> * -> * -> * -> * -> * -> * -> * -> *
411714
412715#### `Fn2`
413716
414− data Fn2 :: * -> * -> * -> *
717+``` purescript
718+data Fn2 :: * -> * -> * -> *
719+```
720+
415721
416722#### `Fn3`
417723
418− data Fn3 :: * -> * -> * -> * -> *
724+``` purescript
725+data Fn3 :: * -> * -> * -> * -> *
726+```
727+
419728
420729#### `Fn4`
421730
422− data Fn4 :: * -> * -> * -> * -> * -> *
731+``` purescript
732+data Fn4 :: * -> * -> * -> * -> * -> *
733+```
734+
423735
424736#### `Fn5`
425737
426− data Fn5 :: * -> * -> * -> * -> * -> * -> *
738+``` purescript
739+data Fn5 :: * -> * -> * -> * -> * -> * -> *
740+```
741+
427742
428743#### `Fn6`
429744
430− data Fn6 :: * -> * -> * -> * -> * -> * -> * -> *
745+``` purescript
746+data Fn6 :: * -> * -> * -> * -> * -> * -> * -> *
747+```
748+
431749
432750#### `Fn7`
433751
434− data Fn7 :: * -> * -> * -> * -> * -> * -> * -> * -> *
752+``` purescript
753+data Fn7 :: * -> * -> * -> * -> * -> * -> * -> * -> *
754+```
755+
435756
436757#### `Fn8`
437758
438− data Fn8 :: * -> * -> * -> * -> * -> * -> * -> * -> * -> *
759+``` purescript
760+data Fn8 :: * -> * -> * -> * -> * -> * -> * -> * -> * -> *
761+```
762+
439763
440764#### `Fn9`
441765
442− data Fn9 :: * -> * -> * -> * -> * -> * -> * -> * -> * -> * -> *
766+``` purescript
767+data Fn9 :: * -> * -> * -> * -> * -> * -> * -> * -> * -> * -> *
768+```
769+
443770
771+#### `Fn10`
772+
773+``` purescript
774+data Fn10 :: * -> * -> * -> * -> * -> * -> * -> * -> * -> * -> * -> *
775+```
444776
445−### Values
446777
447778#### `mkFn0`
448779
449− mkFn0 :: forall a. (Unit -> a) -> Fn0 a
780+``` purescript
781+mkFn0 :: forall a. (Unit -> a) -> Fn0 a
782+```
450783
451−#### `mkFn1`
452784
453− mkFn1 :: forall a b. (a -> b) -> Fn1 a b
785+#### `mkFn1`
454786
455−#### `mkFn10`
787+``` purescript
788+mkFn1 :: forall a b. (a -> b) -> Fn1 a b
789+```
456790
457− mkFn10 :: 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
458791
459792#### `mkFn2`
460793
461− mkFn2 :: forall a b c. (a -> b -> c) -> Fn2 a b c
794+``` purescript
795+mkFn2 :: forall a b c. (a -> b -> c) -> Fn2 a b c
796+```
797+
462798
463799#### `mkFn3`
464800
465− mkFn3 :: forall a b c d. (a -> b -> c -> d) -> Fn3 a b c d
801+``` purescript
802+mkFn3 :: forall a b c d. (a -> b -> c -> d) -> Fn3 a b c d
803+```
804+
466805
467806#### `mkFn4`
468807
469− mkFn4 :: forall a b c d e. (a -> b -> c -> d -> e) -> Fn4 a b c d e
808+``` purescript
809+mkFn4 :: forall a b c d e. (a -> b -> c -> d -> e) -> Fn4 a b c d e
810+```
811+
470812
471813#### `mkFn5`
472814
473− mkFn5 :: forall a b c d e f. (a -> b -> c -> d -> e -> f) -> Fn5 a b c d e f
815+``` purescript
816+mkFn5 :: forall a b c d e f. (a -> b -> c -> d -> e -> f) -> Fn5 a b c d e f
817+```
818+
474819
475820#### `mkFn6`
476821
477− mkFn6 :: forall a b c d e f g. (a -> b -> c -> d -> e -> f -> g) -> Fn6 a b c d e f g
822+``` purescript
823+mkFn6 :: forall a b c d e f g. (a -> b -> c -> d -> e -> f -> g) -> Fn6 a b c d e f g
824+```
825+
478826
479827#### `mkFn7`
480828
481− mkFn7 :: 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
829+``` purescript
830+mkFn7 :: 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
831+```
832+
482833
483834#### `mkFn8`
484835
485− mkFn8 :: 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
836+``` purescript
837+mkFn8 :: 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
838+```
839+
486840
487841#### `mkFn9`
488842
489− mkFn9 :: 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
843+``` purescript
844+mkFn9 :: 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
845+```
490846
491−#### `on`
492847
493− on :: forall a b c. (b -> b -> c) -> (a -> b) -> a -> a -> c
848+#### `mkFn10`
849+
850+``` purescript
851+mkFn10 :: 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
852+```
853+
494854
495855#### `runFn0`
496856
497− runFn0 :: forall a. Fn0 a -> a
857+``` purescript
858+runFn0 :: forall a. Fn0 a -> a
859+```
498860
499−#### `runFn1`
500861
501− runFn1 :: forall a b. Fn1 a b -> a -> b
862+#### `runFn1`
502863
503−#### `runFn10`
864+``` purescript
865+runFn1 :: forall a b. Fn1 a b -> a -> b
866+```
504867
505− runFn10 :: 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
506868
507869#### `runFn2`
508870
509− runFn2 :: forall a b c. Fn2 a b c -> a -> b -> c
871+``` purescript
872+runFn2 :: forall a b c. Fn2 a b c -> a -> b -> c
873+```
874+
510875
511876#### `runFn3`
512877
513− runFn3 :: forall a b c d. Fn3 a b c d -> a -> b -> c -> d
878+``` purescript
879+runFn3 :: forall a b c d. Fn3 a b c d -> a -> b -> c -> d
880+```
881+
514882
515883#### `runFn4`
516884
517− runFn4 :: forall a b c d e. Fn4 a b c d e -> a -> b -> c -> d -> e
885+``` purescript
886+runFn4 :: forall a b c d e. Fn4 a b c d e -> a -> b -> c -> d -> e
887+```
888+
518889
519890#### `runFn5`
520891
521− runFn5 :: forall a b c d e f. Fn5 a b c d e f -> a -> b -> c -> d -> e -> f
892+``` purescript
893+runFn5 :: forall a b c d e f. Fn5 a b c d e f -> a -> b -> c -> d -> e -> f
894+```
895+
522896
523897#### `runFn6`
524898
525− runFn6 :: forall a b c d e f g. Fn6 a b c d e f g -> a -> b -> c -> d -> e -> f -> g
899+``` purescript
900+runFn6 :: forall a b c d e f g. Fn6 a b c d e f g -> a -> b -> c -> d -> e -> f -> g
901+```
902+
526903
527904#### `runFn7`
528905
529− runFn7 :: 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
906+``` purescript
907+runFn7 :: 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
908+```
909+
530910
531911#### `runFn8`
532912
533− runFn8 :: 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
913+``` purescript
914+runFn8 :: 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
915+```
916+
534917
535918#### `runFn9`
536919
537− runFn9 :: 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
920+``` purescript
921+runFn9 :: 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
922+```
923+
924+
925+#### `runFn10`
926+
927+``` purescript
928+runFn10 :: 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
929+```
930+
538931
539932
540933## Module Prelude.Unsafe
541934
542−### Values
935+
543936
544937#### `unsafeIndex`
545938
546− unsafeIndex :: forall a. [a] -> Number -> a
939+``` purescript
940+unsafeIndex :: forall a. [a] -> Number -> a
941+```
942+
547943
548944
549945## Module Control.Monad.Eff
550946
551−### Types
947+
552948
553949#### `Eff`
554950
555− data Eff :: # ! -> * -> *
951+``` purescript
952+data Eff :: # ! -> * -> *
953+```
556954
557−#### `Pure`
558955
559− type Pure a = forall e. Eff e a
956+#### `returnE`
560957
958+``` purescript
959+returnE :: forall e a. a -> Eff e a
960+```
561961
562−### Type Class Instances
563962
564−#### `applicativeEff`
963+#### `bindE`
565964
566− instance applicativeEff :: Applicative (Eff e)
965+``` purescript
966+bindE :: forall e a b. Eff e a -> (a -> Eff e b) -> Eff e b
967+```
567968
568−#### `applyEff`
569969
570− instance applyEff :: Apply (Eff e)
970+#### `Pure`
571971
572−#### `bindEff`
972+``` purescript
973+type Pure a = forall e. Eff e a
974+```
573975
574− instance bindEff :: Bind (Eff e)
575976
576−#### `functorEff`
977+#### `runPure`
577978
578− instance functorEff :: Functor (Eff e)
979+``` purescript
980+runPure :: forall a. Pure a -> a
981+```
579982
580−#### `monadEff`
581983
582− instance monadEff :: Monad (Eff e)
984+#### `functorEff`
583985
986+``` purescript
987+instance functorEff :: Functor (Eff e)
988+```
584989
585−### Values
586990
587−#### `bindE`
991+#### `applyEff`
588992
589− bindE :: forall e a b. Eff e a -> (a -> Eff e b) -> Eff e b
993+``` purescript
994+instance applyEff :: Apply (Eff e)
995+```
590996
591−#### `forE`
592997
593− forE :: forall e. Number -> Number -> (Number -> Eff e Unit) -> Eff e Unit
998+#### `applicativeEff`
594999
595−#### `foreachE`
1000+``` purescript
1001+instance applicativeEff :: Applicative (Eff e)
1002+```
5961003
597− foreachE :: forall e a. [a] -> (a -> Eff e Unit) -> Eff e Unit
5981004
599−#### `returnE`
1005+#### `bindEff`
6001006
601− returnE :: forall e a. a -> Eff e a
1007+``` purescript
1008+instance bindEff :: Bind (Eff e)
1009+```
6021010
603−#### `runPure`
6041011
605− runPure :: forall a. Pure a -> a
1012+#### `monadEff`
1013+
1014+``` purescript
1015+instance monadEff :: Monad (Eff e)
1016+```
1017+
6061018
6071019#### `untilE`
6081020
609− untilE :: forall e. Eff e Boolean -> Eff e Unit
1021+``` purescript
1022+untilE :: forall e. Eff e Boolean -> Eff e Unit
1023+```
1024+
6101025
6111026#### `whileE`
6121027
613− whileE :: forall e a. Eff e Boolean -> Eff e a -> Eff e Unit
1028+``` purescript
1029+whileE :: forall e a. Eff e Boolean -> Eff e a -> Eff e Unit
1030+```
1031+
1032+
1033+#### `forE`
1034+
1035+``` purescript
1036+forE :: forall e. Number -> Number -> (Number -> Eff e Unit) -> Eff e Unit
1037+```
1038+
1039+
1040+#### `foreachE`
1041+
1042+``` purescript
1043+foreachE :: forall e a. [a] -> (a -> Eff e Unit) -> Eff e Unit
1044+```
1045+
6141046
6151047
6161048## Module Control.Monad.Eff.Unsafe
6171049
618−### Values
1050+
6191051
6201052#### `unsafeInterleaveEff`
6211053
622− unsafeInterleaveEff :: forall eff1 eff2 a. Eff eff1 a -> Eff eff2 a
1054+``` purescript
1055+unsafeInterleaveEff :: forall eff1 eff2 a. Eff eff1 a -> Eff eff2 a
1056+```
1057+
6231058
6241059
6251060## Module Debug.Trace
6261061
627−### Types
1062+
6281063
6291064#### `Trace`
6301065
631− data Trace :: !
1066+``` purescript
1067+data Trace :: !
1068+```
6321069
6331070
634−### Values
1071+#### `trace`
6351072
636−#### `print`
1073+``` purescript
1074+trace :: forall r. String -> Eff (trace :: Trace | r) Unit
1075+```
6371076
638− print :: forall a r. (Show a) => a -> Eff (trace :: Trace | r) Unit
6391077
640−#### `trace`
1078+#### `print`
1079+
1080+``` purescript
1081+print :: forall a r. (Show a) => a -> Eff (trace :: Trace | r) Unit
1082+```
6411083
642− trace :: forall r. String -> Eff (trace :: Trace | r) Unit
6431084
6441085
6451086## Module Control.Monad.ST
6461087
647−### Types
1088+
6481089
6491090#### `ST`
6501091
651− data ST :: * -> !
1092+``` purescript
1093+data ST :: * -> !
1094+```
1095+
6521096
6531097#### `STRef`
6541098
655− data STRef :: * -> * -> *
1099+``` purescript
1100+data STRef :: * -> * -> *
1101+```
6561102
6571103
658−### Values
1104+#### `newSTRef`
6591105
660−#### `modifySTRef`
1106+``` purescript
1107+newSTRef :: forall a h r. a -> Eff (st :: ST h | r) (STRef h a)
1108+```
6611109
662− modifySTRef :: forall a h r. STRef h a -> (a -> a) -> Eff (st :: ST h | r) a
6631110
664−#### `newSTRef`
1111+#### `readSTRef`
6651112
666− newSTRef :: forall a h r. a -> Eff (st :: ST h | r) (STRef h a)
1113+``` purescript
1114+readSTRef :: forall a h r. STRef h a -> Eff (st :: ST h | r) a
1115+```
6671116
668−#### `pureST`
6691117
670− pureST :: forall a. (forall h r. Eff (st :: ST h | r) a) -> a
1118+#### `modifySTRef`
6711119
672−#### `readSTRef`
1120+``` purescript
1121+modifySTRef :: forall a h r. STRef h a -> (a -> a) -> Eff (st :: ST h | r) a
1122+```
1123+
1124+
1125+#### `writeSTRef`
1126+
1127+``` purescript
1128+writeSTRef :: forall a h r. STRef h a -> a -> Eff (st :: ST h | r) a
1129+```
6731130
674− readSTRef :: forall a h r. STRef h a -> Eff (st :: ST h | r) a
6751131
6761132#### `runST`
6771133
678− runST :: forall a r. (forall h. Eff (st :: ST h | r) a) -> Eff r a
1134+``` purescript
1135+runST :: forall a r. (forall h. Eff (st :: ST h | r) a) -> Eff r a
1136+```
6791137
680−#### `writeSTRef`
6811138
682− writeSTRef :: forall a h r. STRef h a -> a -> Eff (st :: ST h | r) a
1139+#### `pureST`
1140+
1141+``` purescript
1142+pureST :: forall a. (forall h r. Eff (st :: ST h | r) a) -> a
1143+```
1144+
6831145
6841146
6851147