git.iko.soy/rowtype-yoga/purescript-native
on golang help sign in
Doc update
1893f8ePhil Freeman
docs/source/prelude.rst+131−134
compare with golang
unifiedsplit
@@ -9,19 +9,9 @@ Types
9
9
10::
10::
11
11
12− data Array :: * -> *
13−
14− data Boolean :: *
15−
16− data Function :: * -> * -> *
17−
18− data Number :: *
19−
20 data Ref a where
12 data Ref a where
21 Ref :: a -> Ref a
13 Ref :: a -> Ref a
22
14
23− data String :: *
24−
25Type Classes
15Type Classes
26~~~~~~~~~~~~
16~~~~~~~~~~~~
27
17
@@ -39,9 +29,9 @@ Type Classes
39 (&) :: b -> b -> b
29 (&) :: b -> b -> b
40 (|) :: b -> b -> b
30 (|) :: b -> b -> b
41 (^) :: b -> b -> b
31 (^) :: b -> b -> b
42− shl :: b -> Prelude.Number -> b
32+ shl :: b -> Prim.Number -> b
43− shr :: b -> Prelude.Number -> b
33+ shr :: b -> Prim.Number -> b
44− zshr :: b -> Prelude.Number -> b
34+ zshr :: b -> Prim.Number -> b
45 complement :: b -> b
35 complement :: b -> b
46
36
47 class BoolLike b where
37 class BoolLike b where
@@ -55,8 +45,8 @@ Type Classes
55 (>>>) :: forall d. forall c. forall b. a b c -> a c d -> a b d
45 (>>>) :: forall d. forall c. forall b. a b c -> a c d -> a b d
56
46
57 class Eq a where
47 class Eq a where
58− (==) :: a -> a -> Prelude.Boolean
48+ (==) :: a -> a -> Prim.Boolean
59− (/=) :: a -> a -> Prelude.Boolean
49+ (/=) :: a -> a -> Prim.Boolean
60
50
61 class Functor f where
51 class Functor f where
62 (<$>) :: forall b. forall a. (a -> b) -> f a -> f b
52 (<$>) :: forall b. forall a. (a -> b) -> f a -> f b
@@ -74,16 +64,16 @@ Type Classes
74 negate :: a -> a
64 negate :: a -> a
75
65
76 class Ord a where
66 class Ord a where
77− (<) :: a -> a -> Prelude.Boolean
67+ (<) :: a -> a -> Prim.Boolean
78− (>) :: a -> a -> Prelude.Boolean
68+ (>) :: a -> a -> Prim.Boolean
79− (<=) :: a -> a -> Prelude.Boolean
69+ (<=) :: a -> a -> Prim.Boolean
80− (>=) :: a -> a -> Prelude.Boolean
70+ (>=) :: a -> a -> Prim.Boolean
81
71
82 class Read a where
72 class Read a where
83− read :: Prelude.String -> a
73+ read :: Prim.String -> a
84
74
85 class Show a where
75 class Show a where
86− show :: a -> Prelude.String
76+ show :: a -> Prim.String
87
77
88Type Class Instances
78Type Class Instances
89~~~~~~~~~~~~~~~~~~~~
79~~~~~~~~~~~~~~~~~~~~
@@ -92,37 +82,37 @@ Type Class Instances
92
82
93 (Monad (m)) => instance Applicative m
83 (Monad (m)) => instance Applicative m
94
84
95− instance Bits Prelude.Number
85+ instance Bits Prim.Number
96
86
97− instance BoolLike Prelude.Boolean
87+ instance BoolLike Prim.Boolean
98
88
99− instance Category Prelude.Function
89+ instance Category Prim.Function
100
90
101 instance Eq Ref a
91 instance Eq Ref a
102
92
103− instance Eq Prelude.String
93+ instance Eq Prim.String
104
94
105− instance Eq Prelude.Number
95+ instance Eq Prim.Number
106
96
107− instance Eq Prelude.Boolean
97+ instance Eq Prim.Boolean
108
98
109 (Eq (a)) => instance Eq [a]
99 (Eq (a)) => instance Eq [a]
110
100
111 (Applicative (f)) => instance Functor f
101 (Applicative (f)) => instance Functor f
112
102
113− instance Num Prelude.Number
103+ instance Num Prim.Number
114
104
115− instance Ord Prelude.Number
105+ instance Ord Prim.Number
116
106
117− instance Prelude.Show Prelude.Number
107+ instance Prelude.Show Prim.Number
118
108
119− instance Read Prelude.String
109+ instance Read Prim.String
120
110
121− instance Read Prelude.Boolean
111+ instance Read Prim.Boolean
122
112
123− instance Show Prelude.String
113+ instance Show Prim.String
124
114
125− instance Show Prelude.Boolean
115+ instance Show Prim.Boolean
126
116
127Values
117Values
128~~~~~~
118~~~~~~
@@ -131,65 +121,65 @@ Values
131
121
132 $const :: forall b. forall a. a -> b -> a
122 $const :: forall b. forall a. a -> b -> a
133
123
134− (!!) :: forall a. [a] -> Prelude.Number -> a
124+ (!!) :: forall a. [a] -> Prim.Number -> a
135
125
136 (#) :: forall b. forall a. a -> (a -> b) -> b
126 (#) :: forall b. forall a. a -> (a -> b) -> b
137
127
138 ($) :: forall b. forall a. (a -> b) -> a -> b
128 ($) :: forall b. forall a. (a -> b) -> a -> b
139
129
140− (++) :: Prelude.String -> Prelude.String -> Prelude.String
130+ (++) :: Prim.String -> Prim.String -> Prim.String
141
131
142− boolAnd :: Prelude.Boolean -> Prelude.Boolean -> Prelude.Boolean
132+ boolAnd :: Prim.Boolean -> Prim.Boolean -> Prim.Boolean
143
133
144− boolNot :: Prelude.Boolean -> Prelude.Boolean
134+ boolNot :: Prim.Boolean -> Prim.Boolean
145
135
146− boolOr :: Prelude.Boolean -> Prelude.Boolean -> Prelude.Boolean
136+ boolOr :: Prim.Boolean -> Prim.Boolean -> Prim.Boolean
147
137
148 flip :: forall c. forall b. forall a. (a -> b -> c) -> b -> a -> c
138 flip :: forall c. forall b. forall a. (a -> b -> c) -> b -> a -> c
149
139
150− numAdd :: Prelude.Number -> Prelude.Number -> Prelude.Number
140+ numAdd :: Prim.Number -> Prim.Number -> Prim.Number
151
141
152− numAnd :: Prelude.Number -> Prelude.Number -> Prelude.Number
142+ numAnd :: Prim.Number -> Prim.Number -> Prim.Number
153
143
154− numComplement :: Prelude.Number -> Prelude.Number
144+ numComplement :: Prim.Number -> Prim.Number
155
145
156− numDiv :: Prelude.Number -> Prelude.Number -> Prelude.Number
146+ numDiv :: Prim.Number -> Prim.Number -> Prim.Number
157
147
158− numGreater :: Prelude.Number -> Prelude.Number -> Prelude.Boolean
148+ numGreater :: Prim.Number -> Prim.Number -> Prim.Boolean
159
149
160− numGreaterEq :: Prelude.Number -> Prelude.Number -> Prelude.Boolean
150+ numGreaterEq :: Prim.Number -> Prim.Number -> Prim.Boolean
161
151
162− numLess :: Prelude.Number -> Prelude.Number -> Prelude.Boolean
152+ numLess :: Prim.Number -> Prim.Number -> Prim.Boolean
163
153
164− numLessEq :: Prelude.Number -> Prelude.Number -> Prelude.Boolean
154+ numLessEq :: Prim.Number -> Prim.Number -> Prim.Boolean
165
155
166− numMod :: Prelude.Number -> Prelude.Number -> Prelude.Number
156+ numMod :: Prim.Number -> Prim.Number -> Prim.Number
167
157
168− numMul :: Prelude.Number -> Prelude.Number -> Prelude.Number
158+ numMul :: Prim.Number -> Prim.Number -> Prim.Number
169
159
170− numNegate :: Prelude.Number -> Prelude.Number
160+ numNegate :: Prim.Number -> Prim.Number
171
161
172− numOr :: Prelude.Number -> Prelude.Number -> Prelude.Number
162+ numOr :: Prim.Number -> Prim.Number -> Prim.Number
173
163
174− numShl :: Prelude.Number -> Prelude.Number -> Prelude.Number
164+ numShl :: Prim.Number -> Prim.Number -> Prim.Number
175
165
176− numShr :: Prelude.Number -> Prelude.Number -> Prelude.Number
166+ numShr :: Prim.Number -> Prim.Number -> Prim.Number
177
167
178− numSub :: Prelude.Number -> Prelude.Number -> Prelude.Number
168+ numSub :: Prim.Number -> Prim.Number -> Prim.Number
179
169
180− numXor :: Prelude.Number -> Prelude.Number -> Prelude.Number
170+ numXor :: Prim.Number -> Prim.Number -> Prim.Number
181
171
182− numZshr :: Prelude.Number -> Prelude.Number -> Prelude.Number
172+ numZshr :: Prim.Number -> Prim.Number -> Prim.Number
183
173
184− refEq :: forall a. Ref a -> Ref a -> Prelude.Boolean
174+ refEq :: forall a. Ref a -> Ref a -> Prim.Boolean
185
175
186− refIneq :: forall a. Ref a -> Ref a -> Prelude.Boolean
176+ refIneq :: forall a. Ref a -> Ref a -> Prim.Boolean
187
177
188− showNumber :: Prelude.Number -> Prelude.String
178+ showNumber :: Prim.Number -> Prim.String
189
179
190− unsafeRefEq :: forall a. a -> a -> Prelude.Boolean
180+ unsafeRefEq :: forall a. a -> a -> Prim.Boolean
191
181
192− unsafeRefIneq :: forall a. a -> a -> Prelude.Boolean
182+ unsafeRefIneq :: forall a. a -> a -> Prim.Boolean
193
183
194Module Monoid
184Module Monoid
195-------------
185-------------
@@ -211,7 +201,7 @@ Type Class Instances
211
201
212::
202::
213
203
214− instance Monoid Prelude.String
204+ instance Monoid Prim.String
215
205
216Values
206Values
217~~~~~~
207~~~~~~
@@ -247,11 +237,11 @@ Values
247
237
248 mapM :: forall b. forall a. forall m. (Monad (m)) => (a -> m b) -> [a] -> m [b]
238 mapM :: forall b. forall a. forall m. (Monad (m)) => (a -> m b) -> [a] -> m [b]
249
239
250− replicateM :: forall a. forall m. (Monad (m)) => Prelude.Number -> m a -> m [a]
240+ replicateM :: forall a. forall m. (Monad (m)) => Prim.Number -> m a -> m [a]
251
241
252 sequence :: forall a. forall m. (Monad (m)) => [m a] -> m [a]
242 sequence :: forall a. forall m. (Monad (m)) => [m a] -> m [a]
253
243
254− when :: forall m. (Monad (m)) => Prelude.Boolean -> m { } -> m { }
244+ when :: forall m. (Monad (m)) => Prim.Boolean -> m { } -> m { }
255
245
256Module Maybe
246Module Maybe
257------------
247------------
@@ -327,9 +317,9 @@ Type Class Instances
327
317
328::
318::
329
319
330− instance Prelude.Alternative Prelude.Array
320+ instance Prelude.Alternative Prim.Array
331
321
332− instance Prelude.Monad Prelude.Array
322+ instance Prelude.Monad Prim.Array
333
323
334 (Prelude.Show (a)) => instance Prelude.Show [a]
324 (Prelude.Show (a)) => instance Prelude.Show [a]
335
325
@@ -340,15 +330,15 @@ Values
340
330
341 (:) :: forall a. a -> [a] -> [a]
331 (:) :: forall a. a -> [a] -> [a]
342
332
343− all :: forall a. (a -> Prelude.Boolean) -> [a] -> Prelude.Boolean
333+ all :: forall a. (a -> Prim.Boolean) -> [a] -> Prim.Boolean
344
334
345− any :: forall a. (a -> Prelude.Boolean) -> [a] -> Prelude.Boolean
335+ any :: forall a. (a -> Prim.Boolean) -> [a] -> Prim.Boolean
346
336
347 concat :: forall a. [a] -> [a] -> [a]
337 concat :: forall a. [a] -> [a] -> [a]
348
338
349 concatMap :: forall b. forall a. [a] -> (a -> [b]) -> [b]
339 concatMap :: forall b. forall a. [a] -> (a -> [b]) -> [b]
350
340
351− filter :: forall a. (a -> Prelude.Boolean) -> [a] -> [a]
341+ filter :: forall a. (a -> Prim.Boolean) -> [a] -> [a]
352
342
353 foldl :: forall b. forall a. (a -> b -> b) -> b -> [a] -> b
343 foldl :: forall b. forall a. (a -> b -> b) -> b -> [a] -> b
354
344
@@ -358,23 +348,23 @@ Values
358
348
359 headSafe :: forall a. [a] -> Maybe a
349 headSafe :: forall a. [a] -> Maybe a
360
350
361− indexOf :: forall a. [a] -> a -> Prelude.Number
351+ indexOf :: forall a. [a] -> a -> Prim.Number
362
352
363− isEmpty :: forall a. [a] -> Prelude.Boolean
353+ isEmpty :: forall a. [a] -> Prim.Boolean
364
354
365− joinS :: [Prelude.String] -> Prelude.String
355+ joinS :: [Prim.String] -> Prim.String
366
356
367− joinWith :: [Prelude.String] -> Prelude.String -> Prelude.String
357+ joinWith :: [Prim.String] -> Prim.String -> Prim.String
368
358
369− lastIndexOf :: forall a. [a] -> a -> Prelude.Number
359+ lastIndexOf :: forall a. [a] -> a -> Prim.Number
370
360
371− length :: forall a. [a] -> Prelude.Number
361+ length :: forall a. [a] -> Prim.Number
372
362
373 map :: forall b. forall a. (a -> b) -> [a] -> [b]
363 map :: forall b. forall a. (a -> b) -> [a] -> [b]
374
364
375 push :: forall a. [a] -> a -> [a]
365 push :: forall a. [a] -> a -> [a]
376
366
377− range :: Prelude.Number -> Prelude.Number -> [Prelude.Number]
367+ range :: Prim.Number -> Prim.Number -> [Prim.Number]
378
368
379 reverse :: forall a. [a] -> [a]
369 reverse :: forall a. [a] -> [a]
380
370
@@ -382,11 +372,11 @@ Values
382
372
383 singleton :: forall a. a -> [a]
373 singleton :: forall a. a -> [a]
384
374
385− slice :: forall a. Prelude.Number -> Prelude.Number -> [a] -> [a]
375+ slice :: forall a. Prim.Number -> Prim.Number -> [a] -> [a]
386
376
387 sort :: forall a. [a] -> [a]
377 sort :: forall a. [a] -> [a]
388
378
389− splice :: forall a. Prelude.Number -> Prelude.Number -> [a] -> [a] -> [a]
379+ splice :: forall a. Prim.Number -> Prim.Number -> [a] -> [a] -> [a]
390
380
391 tail :: forall a. [a] -> [a]
381 tail :: forall a. [a] -> [a]
392
382
@@ -394,15 +384,16 @@ Values
394
384
395 zipWith :: forall c. forall b. forall a. (a -> b -> c) -> [a] -> [b] -> [c]
385 zipWith :: forall c. forall b. forall a. (a -> b -> c) -> [a] -> [b] -> [c]
396
386
397−Module Tuple
387+Module Tuples
398−------------
388+-------------
399
389
400Types
390Types
401~~~~~
391~~~~~
402
392
403::
393::
404
394
395+ data Tuple a b where
405− type Tuple a b = { snd :: b, fst :: a }
396+ Tuple :: { snd :: b, fst :: a } -> Tuple a b
406
397
407Type Classes
398Type Classes
408~~~~~~~~~~~~
399~~~~~~~~~~~~
@@ -410,6 +401,10 @@ Type Classes
410Type Class Instances
401Type Class Instances
411~~~~~~~~~~~~~~~~~~~~
402~~~~~~~~~~~~~~~~~~~~
412
403
404+::
405+
406+ (Prelude.Show (a),Prelude.Show (b)) => instance Prelude.Show Tuple a b
407+
413Values
408Values
414~~~~~~
409~~~~~~
415
410
@@ -442,31 +437,31 @@ Values
442
437
443::
438::
444
439
445− charAt :: Prelude.Number -> Prelude.String -> Prelude.String
440+ charAt :: Prim.Number -> Prim.String -> Prim.String
446
441
447− indexOfS :: Prelude.String -> Prelude.String -> Prelude.Number
442+ indexOfS :: Prim.String -> Prim.String -> Prim.Number
448
443
449− lastIndexOfS :: Prelude.String -> Prelude.String -> Prelude.Number
444+ lastIndexOfS :: Prim.String -> Prim.String -> Prim.Number
450
445
451− lengthS :: Prelude.String -> Prelude.Number
446+ lengthS :: Prim.String -> Prim.Number
452
447
453− localeCompare :: Prelude.String -> Prelude.String -> Prelude.Number
448+ localeCompare :: Prim.String -> Prim.String -> Prim.Number
454
449
455− replace :: Prelude.String -> Prelude.String -> Prelude.String -> Prelude.String
450+ replace :: Prim.String -> Prim.String -> Prim.String -> Prim.String
456
451
457− sliceS :: Prelude.Number -> Prelude.Number -> Prelude.String -> Prelude.String
452+ sliceS :: Prim.Number -> Prim.Number -> Prim.String -> Prim.String
458
453
459− split :: Prelude.String -> Prelude.String -> [Prelude.String]
454+ split :: Prim.String -> Prim.String -> [Prim.String]
460
455
461− substr :: Prelude.Number -> Prelude.Number -> Prelude.String -> Prelude.String
456+ substr :: Prim.Number -> Prim.Number -> Prim.String -> Prim.String
462
457
463− substring :: Prelude.Number -> Prelude.Number -> Prelude.String -> Prelude.String
458+ substring :: Prim.Number -> Prim.Number -> Prim.String -> Prim.String
464
459
465− toLower :: Prelude.String -> Prelude.String
460+ toLower :: Prim.String -> Prim.String
466
461
467− toUpper :: Prelude.String -> Prelude.String
462+ toUpper :: Prim.String -> Prim.String
468
463
469− trim :: Prelude.String -> Prelude.String
464+ trim :: Prim.String -> Prim.String
470
465
471Module Regex
466Module Regex
472------------
467------------
@@ -489,15 +484,15 @@ Values
489
484
490::
485::
491
486
492− match :: Regex -> Prelude.String -> [Prelude.String]
487+ match :: Regex -> Prim.String -> [Prim.String]
493
488
494− regex :: Prelude.String -> Prelude.String -> Regex
489+ regex :: Prim.String -> Prim.String -> Regex
495
490
496− replaceR :: Regex -> Prelude.String -> Prelude.String -> Prelude.String
491+ replaceR :: Regex -> Prim.String -> Prim.String -> Prim.String
497
492
498− search :: Regex -> Prelude.String -> Prelude.Number
493+ search :: Regex -> Prim.String -> Prim.Number
499
494
500− test :: Regex -> Prelude.String -> Prelude.Boolean
495+ test :: Regex -> Prim.String -> Prim.Boolean
501
496
502Module Global
497Module Global
503-------------
498-------------
@@ -516,31 +511,31 @@ Values
516
511
517::
512::
518
513
519− decodeURI :: Prelude.String -> Prelude.String
514+ decodeURI :: Prim.String -> Prim.String
520
515
521− decodeURIComponent :: Prelude.String -> Prelude.String
516+ decodeURIComponent :: Prim.String -> Prim.String
522
517
523− encodeURI :: Prelude.String -> Prelude.String
518+ encodeURI :: Prim.String -> Prim.String
524
519
525− encodeURIComponent :: Prelude.String -> Prelude.String
520+ encodeURIComponent :: Prim.String -> Prim.String
526
521
527− infinity :: Prelude.Number
522+ infinity :: Prim.Number
528
523
529− isFinite :: Prelude.Number -> Prelude.Boolean
524+ isFinite :: Prim.Number -> Prim.Boolean
530
525
531− isNaN :: Prelude.Number -> Prelude.Boolean
526+ isNaN :: Prim.Number -> Prim.Boolean
532
527
533− nan :: Prelude.Number
528+ nan :: Prim.Number
534
529
535− parseFloat :: Prelude.String -> Prelude.Number
530+ parseFloat :: Prim.String -> Prim.Number
536
531
537− parseInt :: Prelude.String -> Prelude.Number
532+ parseInt :: Prim.String -> Prim.Number
538
533
539− toExponential :: Prelude.Number -> Prelude.String
534+ toExponential :: Prim.Number -> Prim.String
540
535
541− toFixed :: Prelude.Number -> Prelude.Number -> Prelude.String
536+ toFixed :: Prim.Number -> Prim.Number -> Prim.String
542
537
543− toPrecision :: Prelude.Number -> Prelude.Number -> Prelude.String
538+ toPrecision :: Prim.Number -> Prim.Number -> Prim.String
544
539
545Module Math
540Module Math
546-----------
541-----------
@@ -559,39 +554,39 @@ Values
559
554
560::
555::
561
556
562− abs :: Prelude.Number -> Prelude.Number
557+ abs :: Prim.Number -> Prim.Number
563
558
564− aceil :: Prelude.Number -> Prelude.Number
559+ aceil :: Prim.Number -> Prim.Number
565
560
566− acos :: Prelude.Number -> Prelude.Number
561+ acos :: Prim.Number -> Prim.Number
567
562
568− asin :: Prelude.Number -> Prelude.Number
563+ asin :: Prim.Number -> Prim.Number
569
564
570− atan :: Prelude.Number -> Prelude.Number
565+ atan :: Prim.Number -> Prim.Number
571
566
572− atan2 :: Prelude.Number -> Prelude.Number -> Prelude.Number
567+ atan2 :: Prim.Number -> Prim.Number -> Prim.Number
573
568
574− cos :: Prelude.Number -> Prelude.Number
569+ cos :: Prim.Number -> Prim.Number
575
570
576− exp :: Prelude.Number -> Prelude.Number
571+ exp :: Prim.Number -> Prim.Number
577
572
578− floor :: Prelude.Number -> Prelude.Number
573+ floor :: Prim.Number -> Prim.Number
579
574
580− log :: Prelude.Number -> Prelude.Number
575+ log :: Prim.Number -> Prim.Number
581
576
582− max :: Prelude.Number -> Prelude.Number
577+ max :: Prim.Number -> Prim.Number
583
578
584− min :: Prelude.Number -> Prelude.Number
579+ min :: Prim.Number -> Prim.Number
585
580
586− pow :: Prelude.Number -> Prelude.Number
581+ pow :: Prim.Number -> Prim.Number
587
582
588− round :: Prelude.Number -> Prelude.Number
583+ round :: Prim.Number -> Prim.Number
589
584
590− sin :: Prelude.Number -> Prelude.Number
585+ sin :: Prim.Number -> Prim.Number
591
586
592− sqrt :: Prelude.Number -> Prelude.Number
587+ sqrt :: Prim.Number -> Prim.Number
593
588
594− tan :: Prelude.Number -> Prelude.Number
589+ tan :: Prim.Number -> Prim.Number
595
590
596Module Eff
591Module Eff
597----------
592----------
@@ -622,7 +617,7 @@ Values
622
617
623 bindEff :: forall b. forall a. forall e. Eff e a -> (a -> Eff e b) -> Eff e b
618 bindEff :: forall b. forall a. forall e. Eff e a -> (a -> Eff e b) -> Eff e b
624
619
625− forE :: forall e. Prelude.Number -> Prelude.Number -> (Prelude.Number -> Eff e { }) -> Eff e { }
620+ forE :: forall e. Prim.Number -> Prim.Number -> (Prim.Number -> Eff e { }) -> Eff e { }
626
621
627 foreachE :: forall a. forall e. [a] -> (a -> Eff e { }) -> Eff e { }
622 foreachE :: forall a. forall e. [a] -> (a -> Eff e { }) -> Eff e { }
628
623
@@ -630,9 +625,9 @@ Values
630
625
631 runPure :: forall a. Pure a -> a
626 runPure :: forall a. Pure a -> a
632
627
633− untilE :: forall e. Eff e Prelude.Boolean -> Eff e { }
628+ untilE :: forall e. Eff e Prim.Boolean -> Eff e { }
634
629
635− whileE :: forall e. Eff e Prelude.Boolean -> Eff e { } -> Eff e { }
630+ whileE :: forall e. Eff e Prim.Boolean -> Eff e { } -> Eff e { }
636
631
637Module Random
632Module Random
638-------------
633-------------
@@ -655,7 +650,7 @@ Values
655
650
656::
651::
657
652
658− random :: forall e. Eff random :: Random | e Prelude.Number
653+ random :: forall e. Eff random :: Random | e Prim.Number
659
654
660Module Errors
655Module Errors
661-------------
656-------------
@@ -711,6 +706,8 @@ Values
711
706
712 readIORef :: forall r. forall s. IORef s -> Eff ref :: Ref | r s
707 readIORef :: forall r. forall s. IORef s -> Eff ref :: Ref | r s
713
708
709+ unsafeRunIORef :: forall a. forall eff. Eff ref :: Ref | eff a -> Eff eff a
710+
714 writeIORef :: forall r. forall s. IORef s -> s -> Eff ref :: Ref | r { }
711 writeIORef :: forall r. forall s. IORef s -> s -> Eff ref :: Ref | r { }
715
712
716Module Trace
713Module Trace
@@ -736,7 +733,7 @@ Values
736
733
737 print :: forall r. forall a. (Prelude.Show (a)) => a -> Eff trace :: Trace | r { }
734 print :: forall r. forall a. (Prelude.Show (a)) => a -> Eff trace :: Trace | r { }
738
735
739− trace :: forall r. Prelude.String -> Eff trace :: Trace | r { }
736+ trace :: forall r. Prim.String -> Eff trace :: Trace | r { }
740
737
741Module ST
738Module ST
742---------
739---------
libraries/prelude/README.md+7−2
@@ -344,11 +344,12 @@
344 zipWith :: forall c. forall b. forall a. (a -> b -> c) -> [a] -> [b] -> [c]
344 zipWith :: forall c. forall b. forall a. (a -> b -> c) -> [a] -> [b] -> [c]
345
345
346
346
347−## Module Tuple
347+## Module Tuples
348
348
349### Types
349### Types
350
350
351+ data Tuple a b where
351− type Tuple a b = { snd :: b, fst :: a }
352+ Tuple :: { snd :: b, fst :: a } -> Tuple a b
352
353
353
354
354### Type Classes
355### Type Classes
@@ -356,6 +357,8 @@
356
357
357### Type Class Instances
358### Type Class Instances
358
359
360+ (Prelude.Show (a),Prelude.Show (b)) => instance Prelude.Show Tuple a b
361+
359
362
360### Values
363### Values
361
364
@@ -619,6 +622,8 @@
619
622
620 readIORef :: forall r. forall s. IORef s -> Eff ref :: Ref | r s
623 readIORef :: forall r. forall s. IORef s -> Eff ref :: Ref | r s
621
624
625+ unsafeRunIORef :: forall a. forall eff. Eff ref :: Ref | eff a -> Eff eff a
626+
622 writeIORef :: forall r. forall s. IORef s -> s -> Eff ref :: Ref | r { }
627 writeIORef :: forall r. forall s. IORef s -> s -> Eff ref :: Ref | r { }
623
628
624
629