1
1
module Prelude where
2
- import Prelude ()
3
2
infixr 9 >>>
4
3
infixr 9 <<<
5
4
infixr 0 $
6
5
infixl 0 #
6
+ infixr 6 :
7
7
infixl 4 <$>
8
8
infixl 4 <*>
9
9
infixl 3 <|>
@@ -22,11 +22,13 @@ infixl 4 >=
22
22
infixl 10 &
23
23
infixl 10 |
24
24
infixl 10 ^
25
- infixl 8 !!
26
25
infixr 2 ||
27
26
infixr 3 &&
27
+ infixr 5 <>
28
28
infixr 5 ++
29
29
data Ordering = LT | GT | EQ
30
+ class Semigroup a where
31
+ (<>) :: a -> a -> a
30
32
class BoolLike b where
31
33
(&&) :: b -> b -> b
32
34
(||) :: b -> b -> b
@@ -39,7 +41,7 @@ class Bits b where
39
41
shr :: b -> Prim.Number -> b
40
42
zshr :: b -> Prim.Number -> b
41
43
complement :: b -> b
42
- class Ord a where
44
+ class ( Prelude.Eq a ) <= Ord a where
43
45
compare :: a -> a -> Prelude.Ordering
44
46
class Eq a where
45
47
(==) :: a -> a -> Prim.Boolean
@@ -51,27 +53,29 @@ class Num a where
51
53
(/) :: a -> a -> a
52
54
(%) :: a -> a -> a
53
55
negate :: a -> a
54
- class Monad m where
55
- return :: forall a . a -> m a
56
+ class ( Prelude.Applicative m , Prelude.Bind m ) <= Monad m where
57
+ class ( Prelude.Apply m ) <= Bind m where
56
58
(>>=) :: forall a b . m a -> (a -> m b ) -> m b
57
59
class Alternative f where
58
60
empty :: forall a . f a
59
61
(<|>) :: forall a . f a -> f a -> f a
60
- class Applicative f where
62
+ class ( Prelude.Apply f ) <= Applicative f where
61
63
pure :: forall a . a -> f a
64
+ class (Prelude.Functor f ) <= Apply f where
62
65
(<*>) :: forall a b . f (a -> b ) -> f a -> f b
63
66
class Functor f where
64
67
(<$>) :: forall a b . (a -> b ) -> f a -> f b
65
68
class Show a where
66
69
show :: a -> Prim.String
67
- class Category a where
70
+ class ( Prelude.Semigroupoid a ) <= Category a where
68
71
id :: forall t . a t t
72
+ class Semigroupoid a where
69
73
(<<<) :: forall b c d . a c d -> a b c -> a b d
70
- foreign import (++) :: Prim.String -> Prim.String -> Prim.String
74
+ foreign import (++) :: forall s . (Prelude.Semigroup s ) => s -> s -> s
75
+ foreign import concatString :: Prim.String -> Prim.String -> Prim.String
71
76
foreign import boolNot :: Prim.Boolean -> Prim.Boolean
72
77
foreign import boolOr :: Prim.Boolean -> Prim.Boolean -> Prim.Boolean
73
78
foreign import boolAnd :: Prim.Boolean -> Prim.Boolean -> Prim.Boolean
74
- foreign import (!!) :: forall a . [a ] -> Prim.Number -> a
75
79
foreign import numComplement :: Prim.Number -> Prim.Number
76
80
foreign import numXor :: Prim.Number -> Prim.Number -> Prim.Number
77
81
foreign import numOr :: Prim.Number -> Prim.Number -> Prim.Number
@@ -92,28 +96,44 @@ foreign import numDiv :: Prim.Number -> Prim.Number -> Prim.Number
92
96
foreign import numMul :: Prim.Number -> Prim.Number -> Prim.Number
93
97
foreign import numSub :: Prim.Number -> Prim.Number -> Prim.Number
94
98
foreign import numAdd :: Prim.Number -> Prim.Number -> Prim.Number
99
+ foreign import ap :: forall m a b . (Prelude.Monad m ) => m (a -> b ) -> m a -> m b
100
+ foreign import liftM1 :: forall m a b . (Prelude.Monad m ) => (a -> b ) -> m a -> m b
101
+ foreign import return :: forall m a . (Prelude.Monad m ) => a -> m a
102
+ foreign import liftA1 :: forall f a b . (Prelude.Applicative f ) => (a -> b ) -> f a -> f b
103
+ foreign import showArrayImpl :: forall a . (a -> Prim.String ) -> [a ] -> Prim.String
95
104
foreign import showNumberImpl :: Prim.Number -> Prim.String
105
+ foreign import showStringImpl :: Prim.String -> Prim.String
106
+ foreign import cons :: forall a . a -> [a ] -> [a ]
107
+ foreign import (:) :: forall a . a -> [a ] -> [a ]
96
108
foreign import (#) :: forall a b . a -> (a -> b ) -> b
97
109
foreign import ($) :: forall a b . (a -> b ) -> a -> b
98
- foreign import (>>>) :: forall a b c d . (Prelude.Category a ) => a b c -> a c d -> a b d
99
- foreign import on :: forall a b c . ( b -> b -> c ) -> ( a -> b ) -> a -> a -> c
110
+ foreign import (>>>) :: forall a b c d . (Prelude.Semigroupoid a ) => a b c -> a c d -> a b d
111
+ foreign import asTypeOf :: forall a . a -> a -> a
100
112
foreign import const :: forall a b . a -> b -> a
101
113
foreign import flip :: forall a b c . (a -> b -> c ) -> b -> a -> c
114
+ foreign import instance semigroupoidArr :: Prelude.Semigroupoid Prim.Function
102
115
foreign import instance categoryArr :: Prelude.Category Prim.Function
103
116
foreign import instance showString :: Prelude.Show Prim.String
104
117
foreign import instance showBoolean :: Prelude.Show Prim.Boolean
105
118
foreign import instance showNumber :: Prelude.Show Prim.Number
106
- foreign import instance functorFromApplicative :: (Prelude.Applicative f ) => Prelude.Functor f
107
- foreign import instance applicativeFromMonad :: (Prelude.Monad m ) => Prelude.Applicative m
119
+ foreign import instance showArray :: (Prelude.Show a ) => Prelude.Show [a ]
108
120
foreign import instance numNumber :: Prelude.Num Prim.Number
109
121
foreign import instance eqString :: Prelude.Eq Prim.String
110
122
foreign import instance eqNumber :: Prelude.Eq Prim.Number
111
123
foreign import instance eqBoolean :: Prelude.Eq Prim.Boolean
112
124
foreign import instance eqArray :: (Prelude.Eq a ) => Prelude.Eq [a ]
125
+ foreign import instance eqOrdering :: Prelude.Eq Prelude.Ordering
113
126
foreign import instance showOrdering :: Prelude.Show Prelude.Ordering
114
127
foreign import instance ordNumber :: Prelude.Ord Prim.Number
115
128
foreign import instance bitsNumber :: Prelude.Bits Prim.Number
116
129
foreign import instance boolLikeBoolean :: Prelude.BoolLike Prim.Boolean
130
+ foreign import instance semigroupString :: Prelude.Semigroup Prim.String
131
+ module Prelude.Unsafe where
132
+ import Prelude ()
133
+ foreign import unsafeIndex :: forall a . [a ] -> Prim.Number -> a
134
+ module Data.Function where
135
+ import Prelude ()
136
+ foreign import on :: forall a b c . (b -> b -> c ) -> (a -> b ) -> a -> a -> c
117
137
module Data.Eq where
118
138
import Prelude ()
119
139
data Ref a = Ref a
@@ -128,14 +148,20 @@ foreign import forE :: forall e. Prim.Number -> Prim.Number -> (Prim.Number -> C
128
148
foreign import whileE :: forall e a . Control.Monad.Eff.Eff e Prim.Boolean -> Control.Monad.Eff.Eff e a -> Control.Monad.Eff.Eff e { }
129
149
foreign import untilE :: forall e . Control.Monad.Eff.Eff e Prim.Boolean -> Control.Monad.Eff.Eff e { }
130
150
foreign import runPure :: forall a . Control.Monad.Eff.Pure a -> a
131
- foreign import bindEff :: forall e a b . Control.Monad.Eff.Eff e a -> (a -> Control.Monad.Eff.Eff e b ) -> Control.Monad.Eff.Eff e b
132
- foreign import retEff :: forall e a . a -> Control.Monad.Eff.Eff e a
151
+ foreign import bindE :: forall e a b . Control.Monad.Eff.Eff e a -> (a -> Control.Monad.Eff.Eff e b ) -> Control.Monad.Eff.Eff e b
152
+ foreign import returnE :: forall e a . a -> Control.Monad.Eff.Eff e a
153
+ foreign import instance functorEff :: Prelude.Functor (Control.Monad.Eff.Eff e )
154
+ foreign import instance applyEff :: Prelude.Apply (Control.Monad.Eff.Eff e )
155
+ foreign import instance applicativeEff :: Prelude.Applicative (Control.Monad.Eff.Eff e )
156
+ foreign import instance bindEff :: Prelude.Bind (Control.Monad.Eff.Eff e )
133
157
foreign import instance monadEff :: Prelude.Monad (Control.Monad.Eff.Eff e )
134
158
module Control.Monad.Eff.Unsafe where
135
159
import Prelude ()
160
+ import Control.Monad.Eff ()
136
161
foreign import unsafeInterleaveEff :: forall eff1 eff2 a . Control.Monad.Eff.Eff eff1 a -> Control.Monad.Eff.Eff eff2 a
137
162
module Control.Monad.ST where
138
163
import Prelude ()
164
+ import Control.Monad.Eff ()
139
165
foreign import data STArray :: * -> * -> *
140
166
foreign import data STRef :: * -> * -> *
141
167
foreign import data ST :: * -> !
@@ -150,6 +176,7 @@ foreign import readSTRef :: forall a h r. Control.Monad.ST.STRef h a -> Control.
150
176
foreign import newSTRef :: forall a h r . a -> Control.Monad.Eff.Eff (st :: Control.Monad.ST.ST h | r ) (Control.Monad.ST.STRef h a )
151
177
module Debug.Trace where
152
178
import Prelude ()
179
+ import Control.Monad.Eff ()
153
180
foreign import data Trace :: !
154
181
foreign import print :: forall a r . (Prelude.Show a ) => a -> Control.Monad.Eff.Eff (trace :: Debug.Trace.Trace | r ) { }
155
182
foreign import trace :: forall r . Prim.String -> Control.Monad.Eff.Eff (trace :: Debug.Trace.Trace | r ) { }
0 commit comments