@@ -61,10 +61,37 @@ module Prelude where
6161 read "true" = true
6262 read _ = false
6363
64+ infixl 4 <$>
65+
66+ class Functor f where
67+ (<$>) :: forall a b. (a -> b) -> f a -> f b
68+
69+ infixl 4 <*>
70+
71+ class Applicative f where
72+ pure :: forall a. a -> f a
73+ (<*>) :: forall a b. f (a -> b) -> f a -> f b
74+
75+ instance (Applicative f) => Functor f where
76+ (<$>) f a = pure f <*> a
77+
78+ infixl 3 <|>
79+
80+ class Alternative f where
81+ empty :: forall a. f a
82+ (<|>) :: forall a. f a -> f a -> f a
83+
6484 class Monad m where
6585 ret :: forall a. a -> m a
6686 (>>=) :: forall a b. m a -> (a -> m b) -> m b
6787
88+ instance (Monad m) => Applicative m where
89+ pure = ret
90+ (<*>) f a = do
91+ f' <- f
92+ a' <- a
93+ ret (f' a')
94+
6895 infixl 5 *
6996 infixl 5 /
7097 infixl 5 %
@@ -326,6 +353,74 @@ module Prelude where
326353 \ };\
327354 \}" :: String -> String -> String
328355
356+module Monoid where
357+
358+ import Prelude
359+
360+ infixr 6 <>
361+
362+ class Monoid m where
363+ mempty :: m
364+ (<>) :: m -> m -> m
365+
366+ instance Monoid String where
367+ mempty = ""
368+ (<>) = (++)
369+
370+ mconcat :: forall m. (Monoid m) => [m] -> m
371+ mconcat [] = mempty
372+ mconcat (m:ms) = m <> mconcat ms
373+
374+module Monad where
375+
376+ import Prelude
377+ import Arrays
378+
379+ replicateM :: forall m a. (Monad m) => Number -> m a -> m [a]
380+ replicateM 0 _ = ret []
381+ replicateM n m = do
382+ a <- m
383+ as <- replicateM (n - 1) m
384+ ret (a : as)
385+
386+ mapM :: forall m a b. (Monad m) => (a -> m b) -> [a] -> m [b]
387+ mapM _ [] = ret []
388+ mapM f (a:as) = do
389+ b <- f a
390+ bs <- mapM f as
391+ ret (b : bs)
392+
393+ infixr 1 >=>
394+ infixr 1 <=<
395+
396+ (>=>) :: forall m a b c. (Monad m) => (a -> m b) -> (b -> m c) -> a -> m c
397+ (>=>) f g a = do
398+ b <- f a
399+ g b
400+
401+ (<=<) :: forall m a b c. (Monad m) => (b -> m c) -> (a -> m b) -> a -> m c
402+ (<=<) = flip (>=>)
403+
404+ sequence :: forall m a. (Monad m) => [m a] -> m [a]
405+ sequence [] = ret []
406+ sequence (m:ms) = do
407+ a <- m
408+ as <- sequence ms
409+ ret (a : as)
410+
411+ join :: forall m a. (Monad m) => m (m a) -> m a
412+ join mm = do
413+ m <- mm
414+ m
415+
416+ foldM :: forall m a b. (Monad m) => (a -> b -> m a) -> a -> [b] -> m a
417+ foldM _ a [] = ret a
418+ foldM f a (b:bs) = f a b >>= \a' -> foldM f a' bs
419+
420+ when :: forall m. (Monad m) => Boolean -> m {} -> m {}
421+ when true m = m
422+ when false _ = ret {}
423+
329424module Maybe where
330425
331426 import Prelude
@@ -408,9 +503,9 @@ module Arrays where
408503 \ };\
409504 \}" :: forall a. [a] -> [a] -> [a]
410505
411− foreign import join "function join(l) {\
412− \ return l.join();\
413− \}" :: [String] -> String
506+ foreign import joinS "function joinS(l) {\
507+ \ return l.join();\
508+ \}" :: [String] -> String
414509
415510 foreign import joinWith "function joinWith(l) {\
416511 \ return function (s) {\
@@ -467,6 +562,9 @@ module Arrays where
467562 (:) :: forall a. a -> [a] -> [a]
468563 (:) a = concat [a]
469564
565+ singleton :: forall a. a -> [a]
566+ singleton a = [a]
567+
470568 concatMap :: forall a b. [a] -> (a -> [b]) -> [b]
471569 concatMap [] f = []
472570 concatMap (a:as) f = f a `concat` concatMap as f
@@ -476,9 +574,9 @@ module Arrays where
476574 filter p (x:xs) | p x = x : filter p xs
477575 filter p (_:xs) = filter p xs
478576
479− empty :: forall a. [a] -> Boolean
480− empty [] = true
481− empty _ = false
577+ isEmpty :: forall a. [a] -> Boolean
578+ isEmpty [] = true
579+ isEmpty _ = false
482580
483581 range :: Number -> Number -> [Number]
484582 range lo hi = {
@@ -505,6 +603,14 @@ module Arrays where
505603 show [] = "[]"
506604 show (x:xs) = show x ++ " : " ++ show xs
507605
606+ instance Prelude.Monad [] where
607+ ret = singleton
608+ (>>=) = concatMap
609+
610+ instance Prelude.Alternative [] where
611+ empty = []
612+ (<|>) = concat
613+
508614module Tuple where
509615
510616 import Prelude
@@ -783,6 +889,46 @@ module Eff where
783889 ret = retEff
784890 (>>=) = bindEff
785891
892+ foreign import untilE "function untilE(f) {\
893+ \ return function() {\
894+ \ while (!f()) { }\
895+ \ return {};\
896+ \ };\
897+ \}" :: forall e. Eff e Boolean -> Eff e {}
898+
899+ foreign import whileE "function whileE(f) {\
900+ \ return function(a) {\
901+ \ return function() {\
902+ \ while (f()) {\
903+ \ a();\
904+ \ }\
905+ \ return {};\
906+ \ };\
907+ \ };\
908+ \}" :: forall e. Eff e Boolean -> Eff e {} -> Eff e {}
909+
910+ foreign import forE "function forE(lo) {\
911+ \ return function(hi) {\
912+ \ return function(f) {\
913+ \ return function() {\
914+ \ for (var i = lo; i < hi; i++) {\
915+ \ f(i)();\
916+ \ }\
917+ \ };\
918+ \ };\
919+ \ };\
920+ \}" :: forall e. Number -> Number -> (Number -> Eff e {}) -> Eff e {}
921+
922+
923+ foreign import foreachE "function foreachE(as) {\
924+ \ return function(f) {\
925+ \ for (var i = 0; i < as.length; i++) {\
926+ \ f(as[i])();\
927+ \ }\
928+ \ };\
929+ \}" :: forall e a. [a] -> (a -> Eff e {}) -> Eff e {}
930+
931+
786932module Random where
787933
788934 import Eff