git.iko.soy/rowtype-yoga/purescript-native
on golang help sign in
Remove extracted prelude modules
dc19934Gary Burgess
prelude/prelude.purs+23−896
compare with golang
unifiedsplit
@@ -146,29 +146,17 @@ module Prelude where
146 (==) :: a -> a -> Boolean
146 (==) :: a -> a -> Boolean
147 (/=) :: a -> a -> Boolean
147 (/=) :: a -> a -> Boolean
148
148
149− foreign import unsafeRefEq "function unsafeRefEq(r1) {\
150− \ return function(r2) {\
151− \ return r1 === r2;\
152− \ };\
153− \}" :: forall a. a -> a -> Boolean
154−
155− foreign import unsafeRefIneq "function unsafeRefIneq(r1) {\
156− \ return function(r2) {\
157− \ return r1 !== r2;\
158− \ };\
159− \}" :: forall a. a -> a -> Boolean
160−
161 instance eqString :: Eq String where
149 instance eqString :: Eq String where
162− (==) = unsafeRefEq
150+ (==) = Data.Eq.Unsafe.refEq
163− (/=) = unsafeRefIneq
151+ (/=) = Data.Eq.Unsafe.refIneq
164
152
165 instance eqNumber :: Eq Number where
153 instance eqNumber :: Eq Number where
166− (==) = unsafeRefEq
154+ (==) = Data.Eq.Unsafe.refEq
167− (/=) = unsafeRefIneq
155+ (/=) = Data.Eq.Unsafe.refIneq
168
156
169 instance eqBoolean :: Eq Boolean where
157 instance eqBoolean :: Eq Boolean where
170− (==) = unsafeRefEq
158+ (==) = Data.Eq.Unsafe.refEq
171− (/=) = unsafeRefIneq
159+ (/=) = Data.Eq.Unsafe.refIneq
172
160
173 instance eqArray :: (Eq a) => Eq [a] where
161 instance eqArray :: (Eq a) => Eq [a] where
174 (==) [] [] = true
162 (==) [] [] = true
@@ -331,650 +319,43 @@ module Prelude where
331 \ };\
319 \ };\
332 \}" :: String -> String -> String
320 \}" :: String -> String -> String
333
321
334−module Data.Monoid where
335−
336− import Prelude
337−
338− infixr 6 <>
339−
340− class Monoid m where
341− mempty :: m
342− (<>) :: m -> m -> m
343−
344− instance monoidString :: Monoid String where
345− mempty = ""
346− (<>) = (++)
347−
348− instance monoidArray :: Monoid [a] where
349− mempty = []
350− (<>) = Data.Array.concat
351−
352−module Control.Applicative where
353−
354− import Prelude
355−
356− infixl 4 <*
357− infixl 4 *>
358−
359− (<*) :: forall a b f. (Applicative f) => f a -> f b -> f a
360− (<*) x y = const <$> x <*> y
361−
362− (*>) :: forall a b f. (Applicative f) => f a -> f b -> f b
363− (*>) x y = const id <$> x <*> y
364−
365− lift2 :: forall a b c f. (Applicative f) => (a -> b -> c) -> f a -> f b -> f c
366− lift2 f x y = f <$> x <*> y
367−
368− lift3 :: forall a b c d f. (Applicative f) => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
369− lift3 f x y z = f <$> x <*> y <*> z
370−
371−module Control.Monad where
372−
373− import Prelude
374− import Data.Array
375− import Data.Traversable
376−
377− replicateM :: forall m a. (Monad m) => Number -> m a -> m [a]
378− replicateM 0 _ = return []
379− replicateM n m = do
380− a <- m
381− as <- replicateM (n - 1) m
382− return (a : as)
383−
384− infixr 1 >=>
385− infixr 1 <=<
386−
387− (>=>) :: forall m a b c. (Monad m) => (a -> m b) -> (b -> m c) -> a -> m c
388− (>=>) f g a = do
389− b <- f a
390− g b
391−
392− (<=<) :: forall m a b c. (Monad m) => (b -> m c) -> (a -> m b) -> a -> m c
393− (<=<) = flip (>=>)
394−
395− join :: forall m a. (Monad m) => m (m a) -> m a
396− join mm = do
397− m <- mm
398− m
399−
400− foldM :: forall m a b. (Monad m) => (a -> b -> m a) -> a -> [b] -> m a
401− foldM _ a [] = return a
402− foldM f a (b:bs) = f a b >>= \a' -> foldM f a' bs
403−
404− when :: forall m. (Monad m) => Boolean -> m {} -> m {}
405− when true m = m
406− when false _ = return {}
407−
408− zipWithA :: forall m a b c. (Applicative m) => (a -> b -> m c) -> [a] -> [b] -> m [c]
409− zipWithA f xs ys = sequence (zipWith f xs ys)
410−
411−module Data.Maybe where
412−
413− import Prelude
414−
415− data Maybe a = Nothing | Just a
416−
417− maybe :: forall a b. b -> (a -> b) -> Maybe a -> b
418− maybe b _ Nothing = b
419− maybe _ f (Just a) = f a
420−
421− fromMaybe :: forall a. a -> Maybe a -> a
422− fromMaybe a = maybe a (id :: forall a. a -> a)
423−
424− isJust :: forall a. Maybe a -> Boolean
425− isJust = maybe false (const true)
426−
427− isNothing :: forall a. Maybe a -> Boolean
428− isNothing = maybe true (const false)
429−
430− instance monadMaybe :: Monad Maybe where
431− return = Just
432− (>>=) m f = maybe Nothing f m
433−
434− instance applicativeMaybe :: Applicative Maybe where
435− pure = Just
436− (<*>) (Just fn) x = fn <$> x
437− (<*>) Nothing _ = Nothing
438−
439− instance functorMaybe :: Functor Maybe where
440− (<$>) fn (Just x) = Just (fn x)
441− (<$>) _ _ = Nothing
442−
443− instance showMaybe :: (Show a) => Show (Maybe a) where
444− show (Just x) = "Just " ++ (show x)
445− show Nothing = "Nothing"
446−
447− instance eqMaybe :: (Eq a) => Eq (Maybe a) where
448− (==) Nothing Nothing = true
449− (==) (Just a1) (Just a2) = a1 == a2
450− (==) _ _ = false
451− (/=) a b = not (a == b)
452−
453−module Data.Either where
454−
455− import Prelude
456−
457− data Either a b = Left a | Right b
458−
459− either :: forall a b c. (a -> c) -> (b -> c) -> Either a b -> c
460− either f _ (Left a) = f a
461− either _ g (Right b) = g b
462−
463− isLeft :: forall a b. Either a b -> Boolean
464− isLeft = either (const true) (const false)
465−
466− isRight :: forall a b. Either a b -> Boolean
467− isRight = either (const false) (const true)
468−
469− instance monadEither :: Monad (Either e) where
470− return = Right
471− (>>=) = either (\e _ -> Left e) (\a f -> f a)
472−
473− instance applicativeEither :: Applicative (Either e) where
474− pure = Right
475− (<*>) (Left e) _ = Left e
476− (<*>) (Right f) r = f <$> r
477−
478− instance functorEither :: Functor (Either a) where
479− (<$>) _ (Left x) = Left x
480− (<$>) f (Right y) = Right (f y)
481−
482− instance showEither :: (Show a, Show b) => Show (Either a b) where
483− show (Left x) = "Left " ++ (show x)
484− show (Right y) = "Right " ++ (show y)
485−
486− instance eqEither :: (Eq a, Eq b) => Eq (Either a b) where
487− (==) (Left a1) (Left a2) = a1 == a2
488− (==) (Right b1) (Right b2) = b1 == b2
489− (==) _ _ = false
490− (/=) a b = not (a == b)
491−
492−module Data.Array where
493−
494− import Prelude
495− import Data.Maybe
496−
497− head :: forall a. [a] -> Maybe a
498− head (x : _) = Just x
499− head _ = Nothing
500−
501− tail :: forall a. [a] -> Maybe [a]
502− tail (_ : xs) = Just xs
503− tail _ = Nothing
504−
505− map :: forall a b. (a -> b) -> [a] -> [b]
506− map _ [] = []
507− map f (x:xs) = f x : map f xs
508−
509− foreign import length "function length(xs) {\
510− \ return xs.length;\
511− \}" :: forall a. [a] -> Number
512−
513− foreign import indexOf "function indexOf(l) {\
514− \ return function (e) {\
515− \ return l.indexOf(e);\
516− \ };\
517− \}" :: forall a. [a] -> a -> Number
518−
519− foreign import lastIndexOf "function lastIndexOf(l) {\
520− \ return function (e) {\
521− \ return l.lastIndexOf(e);\
522− \ };\
523− \}" :: forall a. [a] -> a -> Number
524−
525− foreign import concat "function concat(l1) {\
526− \ return function (l2) {\
527− \ return l1.concat(l2);\
528− \ };\
529− \}" :: forall a. [a] -> [a] -> [a]
530−
531− foreign import joinS "function joinS(l) {\
532− \ return l.join();\
533− \}" :: [String] -> String
534−
535− foreign import joinWith "function joinWith(l) {\
536− \ return function (s) {\
537− \ return l.join(s);\
538− \ };\
539− \}" :: [String] -> String -> String
540−
541− foreign import push "function push(l) {\
542− \ return function (e) {\
543− \ var l1 = l.slice();\
544− \ l1.push(e); \
545− \ return l1;\
546− \ };\
547− \}" :: forall a. [a] -> a -> [a]
548−
549− foreign import reverse "function reverse(l) {\
550− \ var l1 = l.slice();\
551− \ l1.reverse(); \
552− \ return l1;\
553− \}" :: forall a. [a] -> [a]
554−
555− foreign import shift "function shift(l) {\
556− \ var l1 = l.slice();\
557− \ l1.shift();\
558− \ return l1;\
559− \}" :: forall a. [a] -> [a]
560−
561− foreign import slice "function slice(s) {\
562− \ return function(e) {\
563− \ return function (l) {\
564− \ return l.slice(s, e);\
565− \ };\
566− \ };\
567− \}" :: forall a. Number -> Number -> [a] -> [a]
568−
569− foreign import sort "function sort(l) {\
570− \ var l1 = l.slice();\
571− \ l1.sort();\
572− \ return l1;\
573− \}" :: forall a. [a] -> [a]
574−
575− foreign import insertAt
576− "function insertAt(index) {\
577− \ return function(a) {\
578− \ return function(l) {\
579− \ var l1 = l.slice();\
580− \ l1.splice(index, 0, a);\
581− \ return l1;\
582− \ }; \
583− \ };\
584− \}":: forall a. Number -> a -> [a] -> [a]
585−
586− foreign import deleteAt
587− "function deleteAt(index) {\
588− \ return function(n) {\
589− \ return function(l) {\
590− \ var l1 = l.slice();\
591− \ l1.splice(index, n);\
592− \ return l1;\
593− \ }; \
594− \ };\
595− \}":: forall a. Number -> Number -> [a] -> [a]
596−
597− foreign import updateAt
598− "function updateAt(index) {\
599− \ return function(a) {\
600− \ return function(l) {\
601− \ var l1 = l.slice();\
602− \ l1[index] = a;\
603− \ return l1;\
604− \ }; \
605− \ };\
606− \}":: forall a. Number -> a -> [a] -> [a]
607−
608− infixr 6 :
609−
610− (:) :: forall a. a -> [a] -> [a]
611− (:) a = concat [a]
612−
613− singleton :: forall a. a -> [a]
614− singleton a = [a]
615−
616− concatMap :: forall a b. (a -> [b]) -> [a] -> [b]
617− concatMap _ [] = []
618− concatMap f (a:as) = f a `concat` concatMap f as
619−
620− filter :: forall a. (a -> Boolean) -> [a] -> [a]
621− filter _ [] = []
622− filter p (x:xs) | p x = x : filter p xs
623− filter p (_:xs) = filter p xs
624−
625− isEmpty :: forall a. [a] -> Boolean
626− isEmpty [] = true
627− isEmpty _ = false
628−
629− range :: Number -> Number -> [Number]
630− range lo hi | lo > hi = []
631− range lo hi = lo : range (lo + 1) hi
632−
633− zipWith :: forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
634− zipWith f (a:as) (b:bs) = f a b : zipWith f as bs
635− zipWith _ _ _ = []
636−
637− drop :: forall a. Number -> [a] -> [a]
638− drop 0 xs = xs
639− drop _ [] = []
640− drop n (x:xs) = drop (n - 1) xs
641−
642− take :: forall a. Number -> [a] -> [a]
643− take 0 _ = []
644− take _ [] = []
645− take n (x:xs) = x : take (n - 1) xs
646−
647− nub :: forall a. (Eq a) => [a] -> [a]
648− nub = nubBy (==)
649−
650− nubBy :: forall a. (a -> a -> Boolean) -> [a] -> [a]
651− nubBy _ [] = []
652− nubBy (==) (x:xs) = x : nubBy (==) (filter (\y -> not (x == y)) xs)
653−
654− instance showArray :: (Show a) => Show [a] where
655− show xs = "[" ++ joinWith (map show xs) "," ++ "]"
656−
657− instance monadArray :: Monad [] where
658− return = singleton
659− (>>=) = flip concatMap
660−
661− instance functorArray :: Functor [] where
662− (<$>) = map
663−
664− instance alternativeArray :: Alternative [] where
665− empty = []
666− (<|>) = concat
667−
668module Data.Eq where
322module Data.Eq where
669
323
670− import Prelude
324+ import qualified Data.Eq.Unsafe as Unsafe
671
325
672− -- Referential equality
673 data Ref a = Ref a
326 data Ref a = Ref a
674
327
675 liftRef :: forall a b. (a -> a -> b) -> Ref a -> Ref a -> b
328 liftRef :: forall a b. (a -> a -> b) -> Ref a -> Ref a -> b
676 liftRef f (Ref x) (Ref y) = f x y
329 liftRef f (Ref x) (Ref y) = f x y
677
330
678 refEq :: forall a. Ref a -> Ref a -> Boolean
331 refEq :: forall a. Ref a -> Ref a -> Boolean
679− refEq = liftRef unsafeRefEq
332+ refEq = liftRef Unsafe.refEq
680
333
681 refIneq :: forall a. Ref a -> Ref a -> Boolean
334 refIneq :: forall a. Ref a -> Ref a -> Boolean
682− refIneq = liftRef unsafeRefIneq
335+ refIneq = liftRef Unsafe.refIneq
683
336
684 instance eqRef :: Eq (Ref a) where
337 instance eqRef :: Eq (Ref a) where
685 (==) = refEq
338 (==) = refEq
686 (/=) = refIneq
339 (/=) = refIneq
340+
341+module Data.Eq.Unsafe where
687
342
688−module Data.Array.Unsafe where
689−
690− head :: forall a. [a] -> a
691− head (x : _) = x
692−
693− tail :: forall a. [a] -> [a]
694− tail (_ : xs) = xs
695−
696−module Data.Tuple where
697−
698− import Prelude
699− import Data.Array
700−
701− data Tuple a b = Tuple a b
702−
703− fst :: forall a b. Tuple a b -> a
704− fst (Tuple a _) = a
705−
706− snd :: forall a b. Tuple a b -> b
707− snd (Tuple _ b) = b
708−
709− instance showTuple :: (Show a, Show b) => Show (Tuple a b) where
710− show (Tuple a b) = "Tuple(" ++ show a ++ ", " ++ show b ++ ")"
711−
712− curry :: forall a b c. (Tuple a b -> c) -> a -> b -> c
713− curry f a b = f (Tuple a b)
714−
715− uncurry :: forall a b c. (a -> b -> c) -> Tuple a b -> c
716− uncurry f (Tuple a b) = f a b
717−
718− zip :: forall a b. [a] -> [b] -> [Tuple a b]
719− zip = zipWith Tuple
720−
721− unzip :: forall a b. [Tuple a b] -> Tuple [a] [b]
722− unzip ((Tuple a b):ts) = case unzip ts of
723− Tuple as bs -> Tuple (a : as) (b : bs)
724− unzip [] = Tuple [] []
725−
726− instance eqTuple :: (Eq a, Eq b) => Eq (Tuple a b) where
727− (==) (Tuple a1 b1) (Tuple a2 b2) = a1 == a2 && b1 == b2
728− (/=) t1 t2 = not (t1 == t2)
729−
730− instance functorTuple :: Functor (Tuple a) where
731− (<$>) f (Tuple x y) = Tuple x (f y)
732−
733−module Data.String where
734−
735− foreign import lengthS "function lengthS(s) {\
736− \ return s.length;\
737− \}" :: String -> Number
738−
739− foreign import charAt "function charAt(i) {\
740− \ return function(s) {\
741− \ return s.charAt(i); \
742− \ };\
743− \}" :: Number -> String -> String
744−
745− foreign import indexOfS "function indexOfS(s1) {\
746− \ return function(s2) {\
747− \ return s1.indexOf(s2);\
748− \ }; \
749− \}" :: String -> String -> Number
750−
751− foreign import lastIndexOfS "function lastIndexOfS(s1) {\
752− \ return function(s2) {\
753− \ return s1.lastIndexOf(s2);\
754− \ };\
755− \}" :: String -> String -> Number
756−
757− foreign import localeCompare "function localeCompare(s1) {\
758− \ return function(s2) {\
759− \ return s1.localeCompare(s2);\
760− \ };\
761− \}" :: String -> String -> Number
762−
763− foreign import replace "function replace(s1) {\
764− \ return function(s2) {\
765− \ return function(s3) {\
766− \ return s3.replace(s1, s2);\
767− \ };\
768− \ };\
769− \}" :: String -> String -> String -> String
770−
771− foreign import sliceS "function sliceS(st) {\
772− \ return function(e) {\
773− \ return function(s) {\
774− \ return s.slice(st, e);\
775− \ };\
776− \ };\
777− \}" :: Number -> Number -> String -> String
778−
779− foreign import split "function split(sep) {\
780− \ return function(s) {\
781− \ return s.split(sep);\
782− \ };\
783− \}" :: String -> String -> [String]
784−
785− foreign import substr "function substr(n1) {\
786− \ return function(n2) {\
787− \ return function(s) {\
788− \ return s.substr(n1, n2);\
789− \ };\
790− \ };\
791− \}" :: Number -> Number -> String -> String
792−
793− foreign import substring "function substring(n1) {\
794− \ return function(n2) {\
795− \ return function(s) {\
796− \ return s.substring(n1, n2);\
797− \ };\
798− \ };\
799− \}" :: Number -> Number -> String -> String
800−
801− foreign import toLower "function toLower(s) {\
802− \ return s.toLowerCase();\
803− \}" :: String -> String
804−
805− foreign import toUpper "function toUpper(s) {\
806− \ return s.toUpperCase();\
807− \}" :: String -> String
808−
809− foreign import trim "function trim(s) {\
810− \ return s.trim();\
811− \}" :: String -> String
812−
813−module Data.String.Regex where
814−
815− foreign import data Regex :: *
816−
817− foreign import regex "function regex(s1) {\
818− \ return function(s2) {\
819− \ return new Regex(s1, s2);\
820− \ };\
821− \}" :: String -> String -> Regex
822−
823− foreign import test "function test(r) {\
824− \ return function (s) {\
825− \ return r.test(s);\
826− \ };\
827− \}" :: Regex -> String -> Boolean
828−
829− foreign import match "function match(r) {\
830− \ return function (s) {\
831− \ return s.match(r); \
832− \ };\
833− \}" :: Regex -> String -> [String]
834−
835− foreign import replaceR "function replaceR(r) {\
836− \ return function(s1) {\
837− \ return function(s2) {\
838− \ return s2.replace(r, s1);\
839− \ };\
840− \ };\
841− \}" :: Regex -> String -> String -> String
842−
843− foreign import search "function search(r) {\
844− \ return function (s) {\
845− \ return s.search(r);\
846− \ };\
847− \}" :: Regex -> String -> Number
848−
849−module Global where
850−
851− foreign import nan "var nan = NaN;" :: Number
852−
853− foreign import infinity "var infinity = Infinity;" :: Number
854−
855− foreign import toExponential "function toExponential(n) {\
856− \ return n.toExponential();\
857− \}" :: Number -> String
858−
859− foreign import toFixed "function toFixed(d) {\
860− \ return function(n) {\
861− \ return n.toFixed(d);\
862− \ };\
863− \}" :: Number -> Number -> String
864−
865− foreign import toPrecision "function toPrecision(d) {\
866− \ return function(n) {\
867− \ return n.toPrecision(d);\
868− \ };\
869− \}" :: Number -> Number -> String
870−
871− foreign import isFinite :: Number -> Boolean
872−
873− foreign import parseFloat :: String -> Number
874−
875− foreign import parseInt :: String -> Number
876−
877− foreign import encodeURIComponent :: String -> String
878−
879− foreign import decodeURIComponent :: String -> String
880−
881− foreign import encodeURI :: String -> String
882−
883− foreign import decodeURI :: String -> String
884−
885− foreign import isNaN :: Number -> Boolean
343+ foreign import refEq
886−
344+ "function refEq(r1) {\
887−module Math where
888−
889− foreign import abs "function abs(n){\
890− \ return Math.abs(n);\
345+ \ return function(r2) {\
891− \}" :: Number -> Number
892−
893− foreign import acos "function acos(n){\
894− \ return Math.acos(n);\
346+ \ return r1 === r2;\
895− \}" :: Number -> Number
347+ \ };\
896−
348+ \}" :: forall a. a -> a -> Boolean
897− foreign import asin "function asin(n){\
898− \ return Math.asin(n);\
899− \}" :: Number -> Number
900−
901− foreign import atan "function atan(n){\
902− \ return Math.atan(n);\
903− \}" :: Number -> Number
904−
905− foreign import atan2 "function atan2(y){\
906− \ return function (x) {\
907− \ return Math.atan2(y, x);\
908− \ };\
909− \}" :: Number -> Number -> Number
910
349
911− foreign import aceil "function aceil(n){\
350+ foreign import refIneq
912− \ return Math.aceil(n);\
351+ "function refIneq(r1) {\
913− \}" :: Number -> Number
352+ \ return function(r2) {\
914−
915− foreign import cos "function cos(n){\
916− \ return Math.cos(n);\
353+ \ return r1 !== r2;\
917− \}" :: Number -> Number
354+ \ };\
918−
355+ \}" :: forall a. a -> a -> Boolean
919− foreign import exp "function exp(n){\
920− \ return Math.exp(n);\
921− \}" :: Number -> Number
922−
923− foreign import floor "function floor(n){\
924− \ return Math.floor(n);\
925− \}" :: Number -> Number
926−
927− foreign import log "function log(n){\
928− \ return Math.log(n);\
929− \}" :: Number -> Number
930−
931− foreign import max "function max(n1){\
932− \ return function(n2) {\
933− \ return Math.max(n1, n2);\
934− \ }\
935− \}" :: Number -> Number -> Number
936−
937− foreign import min "function min(n1){\
938− \ return function(n2) {\
939− \ return Math.min(n1, n2);\
940− \ }\
941− \}" :: Number -> Number -> Number
942−
943− foreign import pow "function pow(n){\
944− \ return function(p) {\
945− \ return Math.pow(n, p);\
946− \ }\
947− \}" :: Number -> Number -> Number
948−
949− foreign import round "function round(n){\
950− \ return Math.round(n);\
951− \}" :: Number -> Number
952−
953− foreign import sin "function sin(n){\
954− \ return Math.sin(n);\
955− \}" :: Number -> Number
956−
957− foreign import sqrt "function sqrt(n){\
958− \ return Math.sqrt(n);\
959− \}" :: Number -> Number
960−
961− foreign import tan "function tan(n){\
962− \ return Math.tan(n);\
963− \}" :: Number -> Number
964−
965− foreign import e "var e = Math.E;" :: Number
966− foreign import ln2 "var ln2 = Math.LN2;" :: Number
967− foreign import ln10 "var ln10 = Math.LN10;" :: Number
968− foreign import log2e "var log2e = Math.LOG2E;" :: Number
969− foreign import log10e "var log10e = Math.LOG10E;" :: Number
970− foreign import pi "var pi = Math.PI;" :: Number
971− foreign import sqrt1_2 "var sqrt1_2 = Math.SQRT1_2;" :: Number
972− foreign import sqrt2 "var sqrt2 = Math.SQRT2;" :: Number
973
356
974module Control.Monad.Eff where
357module Control.Monad.Eff where
975
358
976− import Prelude
977−
978 foreign import data Eff :: # ! -> * -> *
359 foreign import data Eff :: # ! -> * -> *
979
360
980 foreign import retEff "function retEff(a) {\
361 foreign import retEff "function retEff(a) {\
@@ -1049,86 +430,8 @@ module Control.Monad.Eff.Unsafe where
1049 \ return f;\
430 \ return f;\
1050 \}" :: forall eff1 eff2 a. Eff eff1 a -> Eff eff2 a
431 \}" :: forall eff1 eff2 a. Eff eff1 a -> Eff eff2 a
1051
432
1052−module Random where
1053−
1054− import Control.Monad.Eff
1055−
1056− foreign import data Random :: !
1057−
1058− foreign import random "function random() {\
1059− \ return Math.random();\
1060− \}" :: forall e. Eff (random :: Random | e) Number
1061−
1062−module Control.Monad.Eff.Error where
1063−
1064− import Control.Monad.Eff
1065−
1066− foreign import data Error :: * -> !
1067−
1068− foreign import throwError "function throwError(e) {\
1069− \ return function() {\
1070− \ throw e;\
1071− \ };\
1072− \}" :: forall a e r. e -> Eff (err :: Error e | r) a
1073−
1074− foreign import catchError "function catchError(c) {\
1075− \ return function(t) {\
1076− \ return function() {\
1077− \ try {\
1078− \ return t();\
1079− \ } catch(e) {\
1080− \ return c(e)();\
1081− \ }\
1082− \ };\
1083− \ };\
1084− \}" :: forall e r a. (e -> Eff r a) -> Eff (err :: Error e | r) a -> Eff r a
1085−
1086−module Data.IORef where
1087−
1088− import Control.Monad.Eff
1089−
1090− foreign import data Ref :: !
1091−
1092− foreign import data IORef :: * -> *
1093−
1094− foreign import newIORef "function newIORef(val) {\
1095− \ return function () {\
1096− \ return { value: val };\
1097− \ };\
1098− \}" :: forall s r. s -> Eff (ref :: Ref | r) (IORef s)
1099−
1100− foreign import readIORef "function readIORef(ref) {\
1101− \ return function() {\
1102− \ return ref.value;\
1103− \ };\
1104− \}" :: forall s r. IORef s -> Eff (ref :: Ref | r) s
1105−
1106−
1107− foreign import modifyIORef "function modifyIORef(ref) {\
1108− \ return function(f) {\
1109− \ return function() {\
1110− \ ref.value = f(ref.value);\
1111− \ return {};\
1112− \ };\
1113− \ };\
1114− \}" :: forall s r. IORef s -> (s -> s) -> Eff (ref :: Ref | r) {}
1115−
1116− foreign import writeIORef "function writeIORef(ref) {\
1117− \ return function(val) {\
1118− \ return function() {\
1119− \ ref.value = val;\
1120− \ return {};\
1121− \ };\
1122− \ };\
1123− \}" :: forall s r. IORef s -> s -> Eff (ref :: Ref | r) {}
1124−
1125− foreign import unsafeRunIORef "function unsafeRunIORef(f) {\
1126− \ return f;\
1127− \}" :: forall eff a. Eff (ref :: Ref | eff) a -> Eff eff a
1128−
1129module Debug.Trace where
433module Debug.Trace where
1130
434
1131− import Prelude
1132 import Control.Monad.Eff
435 import Control.Monad.Eff
1133
436
1134 foreign import data Trace :: !
437 foreign import data Trace :: !
@@ -1218,179 +521,3 @@ module Control.Monad.ST where
1218 foreign import runSTArray "function runSTArray(f) {\
521 foreign import runSTArray "function runSTArray(f) {\
1219 \ return f;\
522 \ return f;\
1220 \}" :: forall a r. (forall h. Eff (st :: ST h | r) (STArray h a)) -> Eff r [a]
523 \}" :: forall a r. (forall h. Eff (st :: ST h | r) (STArray h a)) -> Eff r [a]
1221−
1222−module Data.Enum where
1223−
1224− import Data.Maybe
1225−
1226− class Enum a where
1227− toEnum :: Number -> Maybe a
1228− fromEnum :: a -> Number
1229−
1230−module Text.Parsing.Read where
1231−
1232− class Read a where
1233− read :: String -> a
1234−
1235− instance readString :: Read String where
1236− read s = s
1237−
1238− instance readBoolean :: Read Boolean where
1239− read "true" = true
1240− read _ = false
1241−
1242− foreign import readNumberImpl "var readNumberImpl = parseFloat;" :: String -> Number
1243−
1244− instance readNumber :: Read Number where
1245− read = readNumberImpl
1246−
1247−module Data.Foldable where
1248−
1249− import Prelude
1250− import Control.Applicative
1251− import Data.Either
1252− import Data.Eq
1253− import Data.Maybe
1254− import Data.Monoid
1255− import Data.Tuple
1256−
1257− class Foldable f where
1258− foldr :: forall a b. (a -> b -> b) -> b -> f a -> b
1259− foldl :: forall a b. (b -> a -> b) -> b -> f a -> b
1260− foldMap :: forall a m. (Monoid m) => (a -> m) -> f a -> m
1261−
1262− instance foldableArray :: Foldable [] where
1263− foldr _ z [] = z
1264− foldr f z (x:xs) = x `f` (foldr f z xs)
1265−
1266− foldl _ z [] = z
1267− foldl f z (x:xs) = foldl f (z `f` x) xs
1268−
1269− foldMap _ [] = mempty
1270− foldMap f (x:xs) = f x <> foldMap f xs
1271−
1272− instance foldableEither :: Foldable (Either a) where
1273− foldr _ z (Left _) = z
1274− foldr f z (Right x) = x `f` z
1275−
1276− foldl _ z (Left _) = z
1277− foldl f z (Right x) = z `f` x
1278−
1279− foldMap f (Left _) = mempty
1280− foldMap f (Right x) = f x
1281−
1282− instance foldableMaybe :: Foldable Maybe where
1283− foldr _ z Nothing = z
1284− foldr f z (Just x) = x `f` z
1285−
1286− foldl _ z Nothing = z
1287− foldl f z (Just x) = z `f` x
1288−
1289− foldMap f Nothing = mempty
1290− foldMap f (Just x) = f x
1291−
1292− instance foldableRef :: Foldable Ref where
1293− foldr f z (Ref x) = x `f` z
1294−
1295− foldl f z (Ref x) = z `f` x
1296−
1297− foldMap f (Ref x) = f x
1298−
1299− instance foldableTuple :: Foldable (Tuple a) where
1300− foldr f z (Tuple _ x) = x `f` z
1301−
1302− foldl f z (Tuple _ x) = z `f` x
1303−
1304− foldMap f (Tuple _ x) = f x
1305−
1306− fold :: forall f m. (Foldable f, Monoid m) => f m -> m
1307− fold = foldMap id
1308−
1309− traverse_ :: forall a b f m. (Applicative m, Foldable f) => (a -> m b) -> f a -> m {}
1310− traverse_ f = foldr ((*>) <<< f) (pure {})
1311−
1312− for_ :: forall a b f m. (Applicative m, Foldable f) => f a -> (a -> m b) -> m {}
1313− for_ = flip traverse_
1314−
1315− sequence_ :: forall a f m. (Applicative m, Foldable f) => f (m a) -> m {}
1316− sequence_ = traverse_ id
1317−
1318− mconcat :: forall f m. (Foldable f, Monoid m) => f m -> m
1319− mconcat = foldl (<>) mempty
1320−
1321− and :: forall f. (Foldable f) => f Boolean -> Boolean
1322− and = foldl (&&) true
1323−
1324− or :: forall f. (Foldable f) => f Boolean -> Boolean
1325− or = foldl (||) false
1326−
1327− any :: forall a f. (Foldable f) => (a -> Boolean) -> f a -> Boolean
1328− any p = or <<< foldMap (\x -> [p x])
1329−
1330− all :: forall a f. (Foldable f) => (a -> Boolean) -> f a -> Boolean
1331− all p = and <<< foldMap (\x -> [p x])
1332−
1333− sum :: forall f. (Foldable f) => f Number -> Number
1334− sum = foldl (+) 0
1335−
1336− product :: forall f. (Foldable f) => f Number -> Number
1337− product = foldl (*) 1
1338−
1339− elem :: forall a f. (Eq a, Foldable f) => a -> f a -> Boolean
1340− elem = any <<< (==)
1341−
1342− notElem :: forall a f. (Eq a, Foldable f) => a -> f a -> Boolean
1343− notElem x = not <<< elem x
1344−
1345− find :: forall a f. (Foldable f) => (a -> Boolean) -> f a -> Maybe a
1346− find p f = case foldMap (\x -> if p x then [x] else []) f of
1347− (x:_) -> Just x
1348− [] -> Nothing
1349−
1350−module Data.Traversable where
1351−
1352− import Prelude
1353− import Data.Array ((:))
1354− import Data.Either
1355− import Data.Eq
1356− import Data.Foldable
1357− import Data.Maybe
1358− import Data.Tuple
1359−
1360− class Traversable t where
1361− traverse :: forall a b m. (Applicative m) => (a -> m b) -> t a -> m (t b)
1362− sequence :: forall a m. (Applicative m) => t (m a) -> m (t a)
1363−
1364− instance traversableArray :: Traversable [] where
1365− traverse _ [] = pure []
1366− traverse f (x:xs) = (:) <$> (f x) <*> traverse f xs
1367−
1368− sequence [] = pure []
1369− sequence (x:xs) = (:) <$> x <*> sequence xs
1370−
1371− instance traversableEither :: Traversable (Either a) where
1372− traverse _ (Left x) = pure (Left x)
1373− traverse f (Right x) = Right <$> f x
1374−
1375− sequence (Left x) = pure (Left x)
1376− sequence (Right x) = Right <$> x
1377−
1378− instance traversableRef :: Traversable Ref where
1379− traverse f (Ref x) = Ref <$> f x
1380−
1381− sequence (Ref x) = Ref <$> x
1382−
1383− instance traversableMaybe :: Traversable Maybe where
1384− traverse _ Nothing = pure Nothing
1385− traverse f (Just x) = Just <$> f x
1386−
1387− sequence Nothing = pure Nothing
1388− sequence (Just x) = Just <$> x
1389−
1390− instance traversableTuple :: Traversable (Tuple a) where
1391− traverse f (Tuple x y) = Tuple x <$> f y
1392−
1393− sequence (Tuple x y) = Tuple x <$> y
1394−
1395− for :: forall a b m t. (Applicative m, Traversable t) => t a -> (a -> m b) -> m (t b)
1396− for x f = traverse f x