git.iko.soy/rowtype-yoga/purescript-native
on golang help sign in
Basic documentation generation #164
aaa6c53Phil Freeman
docgen/Main.hsnew file+155
compare with golang
unifiedsplit
@@ -0,0 +1,155 @@
1+-----------------------------------------------------------------------------
2+--
3+-- Module : Main
4+-- Copyright : (c) Phil Freeman 2013
5+-- License : MIT
6+--
7+-- Maintainer : Phil Freeman <paf31@cantab.net>
8+-- Stability : experimental
9+-- Portability :
10+--
11+-- |
12+--
13+-----------------------------------------------------------------------------
14+
15+module Main where
16+
17+import qualified Language.PureScript as P
18+import System.Console.CmdTheLine
19+import Control.Applicative
20+import Control.Monad
21+import Control.Monad.Writer
22+import System.Exit (exitSuccess, exitFailure)
23+import qualified System.IO.UTF8 as U
24+import qualified Paths_purescript as Paths
25+import Data.Version (showVersion)
26+import Data.List
27+import Data.Function (on)
28+
29+docgen :: FilePath -> IO ()
30+docgen input = do
31+ text <- U.readFile input
32+ case P.runIndentParser input P.parseModules text of
33+ Left err -> do
34+ U.print err
35+ exitFailure
36+ Right ms -> do
37+ U.putStrLn . runDocs $ renderModules ms
38+ exitSuccess
39+
40+type Docs = Writer [String] ()
41+
42+runDocs :: Docs -> String
43+runDocs = unlines . execWriter
44+
45+spacer :: Docs
46+spacer = tell [""]
47+
48+headerLevel :: Int -> String -> Docs
49+headerLevel level hdr = tell [replicate level '#' ++ ' ' : hdr]
50+
51+atIndent :: Int -> String -> Docs
52+atIndent indent text =
53+ let ls = lines text in
54+ forM_ ls $ \l -> tell [replicate indent ' ' ++ l]
55+
56+renderModules :: [P.Module] -> Docs
57+renderModules ms = do
58+ headerLevel 1 "Module Documentation"
59+ mapM_ renderModule ms
60+
61+renderModule :: P.Module -> Docs
62+renderModule (P.Module (P.ProperName moduleName) ds) = do
63+ headerLevel 2 $ "Module " ++ moduleName
64+ spacer
65+ headerLevel 3 "Types"
66+ spacer
67+ renderTopLevel (filter isTypeDeclaration ds)
68+ spacer
69+ headerLevel 3 "Type Classes"
70+ spacer
71+ renderTopLevel (filter isTypeClassDeclaration ds)
72+ spacer
73+ headerLevel 3 "Type Class Instances"
74+ spacer
75+ renderTopLevel (filter isTypeInstanceDeclaration ds)
76+ spacer
77+ headerLevel 3 "Values"
78+ spacer
79+ renderTopLevel (filter isValueDeclaration ds)
80+ spacer
81+
82+renderTopLevel :: [P.Declaration] -> Docs
83+renderTopLevel decls = forM_ (sortBy (compare `on` getName) decls) $ \decl -> do
84+ renderDeclaration 4 decl
85+ spacer
86+
87+renderDeclaration :: Int -> P.Declaration -> Docs
88+renderDeclaration n (P.TypeDeclaration ident ty) =
89+ atIndent n $ show ident ++ " :: " ++ P.prettyPrintType ty
90+renderDeclaration n (P.ExternDeclaration _ ident _ ty) =
91+ atIndent n $ show ident ++ " :: " ++ P.prettyPrintType ty
92+renderDeclaration n (P.DataDeclaration name args ctors) = do
93+ let typeName = P.runProperName name ++ " " ++ intercalate " " args
94+ atIndent n $ "data " ++ typeName ++ " where"
95+ forM_ ctors $ \(ctor, ty) -> do
96+ atIndent (n + 2) $ P.runProperName ctor ++ " :: " ++ maybe "" ((++ " -> ") . P.prettyPrintType) ty ++ typeName
97+renderDeclaration n (P.ExternDataDeclaration name kind) =
98+ atIndent n $ "data " ++ P.runProperName name ++ " :: " ++ P.prettyPrintKind kind
99+renderDeclaration n (P.TypeSynonymDeclaration name args ty) = do
100+ let typeName = P.runProperName name ++ " " ++ intercalate " " args
101+ atIndent n $ "type " ++ typeName ++ " = " ++ P.prettyPrintType ty
102+renderDeclaration n (P.TypeClassDeclaration name arg ds) = do
103+ atIndent n $ "class " ++ P.runProperName name ++ " " ++ arg ++ " where"
104+ mapM_ (renderDeclaration (n + 2)) ds
105+renderDeclaration n (P.TypeInstanceDeclaration constraints name ty _) = do
106+ let constraintsText = case constraints of
107+ [] -> ""
108+ cs -> "(" ++ intercalate "," (map (\(pn, ty') -> show pn ++ " (" ++ P.prettyPrintType ty' ++ ")") cs) ++ ") => "
109+ atIndent n $ constraintsText ++ "instance " ++ show name ++ " " ++ P.prettyPrintType ty
110+renderDeclaration _ _ = return ()
111+
112+getName :: P.Declaration -> String
113+getName (P.TypeDeclaration ident _) = show ident
114+getName (P.ExternDeclaration _ ident _ _) = show ident
115+getName (P.DataDeclaration name _ _) = P.runProperName name
116+getName (P.ExternDataDeclaration name _) = P.runProperName name
117+getName (P.TypeSynonymDeclaration name _ _) = P.runProperName name
118+getName (P.TypeClassDeclaration name _ _) = P.runProperName name
119+getName (P.TypeInstanceDeclaration _ name _ _) = show name
120+getName _ = error "Invalid argument to getName"
121+
122+isValueDeclaration :: P.Declaration -> Bool
123+isValueDeclaration (P.TypeDeclaration _ _) = True
124+isValueDeclaration (P.ExternDeclaration _ _ _ _) = True
125+isValueDeclaration _ = False
126+
127+isTypeDeclaration :: P.Declaration -> Bool
128+isTypeDeclaration (P.DataDeclaration _ _ _) = True
129+isTypeDeclaration (P.ExternDataDeclaration _ _) = True
130+isTypeDeclaration (P.TypeSynonymDeclaration _ _ _) = True
131+isTypeDeclaration _ = False
132+
133+isTypeClassDeclaration :: P.Declaration -> Bool
134+isTypeClassDeclaration (P.TypeClassDeclaration _ _ _) = True
135+isTypeClassDeclaration _ = False
136+
137+isTypeInstanceDeclaration :: P.Declaration -> Bool
138+isTypeInstanceDeclaration (P.TypeInstanceDeclaration _ _ _ _) = True
139+isTypeInstanceDeclaration _ = False
140+
141+inputFile :: Term FilePath
142+inputFile = value $ pos 0 "input.ps" $ posInfo { posDoc = "The input .ps file" }
143+
144+term :: Term (IO ())
145+term = docgen <$> inputFile
146+
147+termInfo :: TermInfo
148+termInfo = defTI
149+ { termName = "docgen"
150+ , version = showVersion $ Paths.version
151+ , termDoc = "Generate Markdown documentation from PureScript extern files"
152+ }
153+
154+main :: IO ()
155+main = run (term, termInfo)
docs/source/prelude.rst+745−60
@@ -1,88 +1,773 @@
1−Prelude
1+Module Documentation
2−=======
2+====================
3
3
4−The Prelude is a collection of standard modules which define types for standard Javascript functions, as well as some common functions that will be familiar to users of Haskell or similar functional languages.
5−
6−Prelude Module
4+Module Prelude
7--------------
5--------------
8
6
9−=========== ============================================================ ===========================================
7+Types
10−Name Type Description
8+~~~~~
11−=========== ============================================================ ===========================================
9+
10+::
11+
12+ data Array :: * -> *
13+
14+ data Boolean :: *
15+
16+ data Function :: * -> * -> *
17+
18+ data Number :: *
19+
20+ data Ref a where
21+ Ref :: a -> Ref a
22+
23+ data String :: *
24+
25+Type Classes
26+~~~~~~~~~~~~
27+
28+::
29+
30+ class Alternative f where
31+ empty :: forall a. f a
32+ (<|>) :: forall a. f a -> f a -> f a
33+
34+ class Applicative f where
35+ pure :: forall a. a -> f a
36+ (<*>) :: forall b. forall a. f (a -> b) -> f a -> f b
37+
38+ class Bits b where
39+ (&) :: b -> b -> b
40+ (|) :: b -> b -> b
41+ (^) :: b -> b -> b
42+ shl :: b -> Prelude.Number -> b
43+ shr :: b -> Prelude.Number -> b
44+ zshr :: b -> Prelude.Number -> b
45+ complement :: b -> b
46+
47+ class BoolLike b where
48+ (&&) :: b -> b -> b
49+ (||) :: b -> b -> b
50+ not :: b -> b
51+
52+ class Category a where
12−``id`` ``forall a. a -> a`` Identity function
53+ id :: forall t. a t t
13−``flip`` ``forall a b c. (a -> b -> c) -> b -> a -> c`` Flips the order of a function's arguments
54+ (<<<) :: forall d. forall c. forall b. a c d -> a b c -> a b d
55+ (>>>) :: forall d. forall c. forall b. a b c -> a c d -> a b d
56+
57+ class Eq a where
58+ (==) :: a -> a -> Prelude.Boolean
59+ (/=) :: a -> a -> Prelude.Boolean
60+
61+ class Functor f where
62+ (<$>) :: forall b. forall a. Prelude.Function a b -> f a -> f b
63+
64+ class Monad m where
65+ ret :: forall a. a -> m a
66+ (>>=) :: forall b. forall a. m a -> Prelude.Function a (m b) -> m b
67+
68+ class Num a where
69+ (+) :: a -> a -> a
70+ (-) :: a -> a -> a
71+ (*) :: a -> a -> a
72+ (/) :: a -> a -> a
73+ (%) :: a -> a -> a
74+ negate :: a -> a
75+
76+ class Ord a where
77+ (<) :: a -> a -> Prelude.Boolean
78+ (>) :: a -> a -> Prelude.Boolean
79+ (<=) :: a -> a -> Prelude.Boolean
80+ (>=) :: a -> a -> Prelude.Boolean
81+
82+ class Read a where
83+ read :: Prelude.String -> a
84+
85+ class Show a where
86+ show :: a -> Prelude.String
87+
88+Type Class Instances
89+~~~~~~~~~~~~~~~~~~~~
90+
91+::
92+
93+ (Monad (m)) => instance Applicative m
94+
95+ instance Bits Prelude.Number
96+
97+ instance BoolLike Prelude.Boolean
98+
99+ instance Category Prelude.Function
100+
101+ instance Eq Ref a
102+
103+ instance Eq Prelude.String
104+
105+ instance Eq Prelude.Number
106+
107+ instance Eq Prelude.Boolean
108+
109+ (Eq (a)) => instance Eq Prelude.Array a
110+
111+ (Applicative (f)) => instance Functor f
112+
113+ instance Num Prelude.Number
114+
115+ instance Ord Prelude.Number
116+
117+ instance Prelude.Show Prelude.Number
118+
119+ instance Read Prelude.String
120+
121+ instance Read Prelude.Boolean
122+
123+ instance Show Prelude.String
124+
125+ instance Show Prelude.Boolean
126+
127+Values
128+~~~~~~
129+
130+::
131+
132+ (!!) :: forall a. Prelude.Array a -> Prelude.Number -> a
133+
134+ (#) :: forall b. forall a. a -> Prelude.Function a b -> b
135+
136+ ($) :: forall b. forall a. Prelude.Function a b -> a -> b
137+
138+ (++) :: Prelude.String -> Prelude.String -> Prelude.String
139+
140+ boolAnd :: Prelude.Boolean -> Prelude.Boolean -> Prelude.Boolean
141+
142+ boolNot :: Prelude.Boolean -> Prelude.Boolean
143+
144+ boolOr :: Prelude.Boolean -> Prelude.Boolean -> Prelude.Boolean
145+
146+ flip :: forall c. forall b. forall a. Prelude.Function a (b -> c) -> b -> a -> c
147+
14−``konst`` ``forall a b. a -> b -> a`` Defines a constant function
148+ konst :: forall b. forall a. a -> b -> a
15−``(<|)`` ``forall a b c. (a -> b) -> (b -> c) -> a -> c`` Function composition
149+
16−``(|>)`` ``forall a b c. (b -> c) -> (a -> b) -> a -> c`` Function composition
150+ numAdd :: Prelude.Number -> Prelude.Number -> Prelude.Number
17−``($)`` ``forall a b. (a -> b) -> a -> b`` Function application
151+
18−=========== ============================================================ ===========================================
152+ numAnd :: Prelude.Number -> Prelude.Number -> Prelude.Number
19−
153+
20−======= ===========================================
154+ numComplement :: Prelude.Number -> Prelude.Number
21−Name Description
155+
22−======= ===========================================
156+ numDiv :: Prelude.Number -> Prelude.Number -> Prelude.Number
23−Show Type class for types whose values can be
157+
24− converted to strings
158+ numGreater :: Prelude.Number -> Prelude.Number -> Prelude.Boolean
25−Monad Type class for type constructors which
159+
26− support ``do`` notation
160+ numGreaterEq :: Prelude.Number -> Prelude.Number -> Prelude.Boolean
27−======= ===========================================
161+
28−
162+ numLess :: Prelude.Number -> Prelude.Number -> Prelude.Boolean
163+
164+ numLessEq :: Prelude.Number -> Prelude.Number -> Prelude.Boolean
165+
166+ numMod :: Prelude.Number -> Prelude.Number -> Prelude.Number
167+
168+ numMul :: Prelude.Number -> Prelude.Number -> Prelude.Number
169+
170+ numNegate :: Prelude.Number -> Prelude.Number
171+
172+ numOr :: Prelude.Number -> Prelude.Number -> Prelude.Number
173+
174+ numShl :: Prelude.Number -> Prelude.Number -> Prelude.Number
175+
176+ numShr :: Prelude.Number -> Prelude.Number -> Prelude.Number
177+
178+ numSub :: Prelude.Number -> Prelude.Number -> Prelude.Number
179+
180+ numXor :: Prelude.Number -> Prelude.Number -> Prelude.Number
181+
182+ numZshr :: Prelude.Number -> Prelude.Number -> Prelude.Number
183+
184+ refEq :: forall a. Ref a -> Ref a -> Prelude.Boolean
185+
186+ refIneq :: forall a. Ref a -> Ref a -> Prelude.Boolean
187+
188+ showNumber :: Prelude.Number -> Prelude.String
189+
190+ unsafeRefEq :: forall a. a -> a -> Prelude.Boolean
191+
192+ unsafeRefIneq :: forall a. a -> a -> Prelude.Boolean
193+
29−String Module
194+Module Monoid
30-------------
195-------------
31
196
32−`TODO`
197+Types
198+~~~~~
199+
200+Type Classes
201+~~~~~~~~~~~~
202+
203+::
204+
205+ class Monoid m where
206+ mempty :: m
207+ (<>) :: m -> m -> m
208+
209+Type Class Instances
210+~~~~~~~~~~~~~~~~~~~~
33
211
212+::
213+
214+ instance Monoid Prelude.String
215+
216+Values
217+~~~~~~
218+
219+::
220+
221+ mconcat :: forall m. (Monoid (m)) => Prelude.Array m -> m
222+
34−Regex Module
223+Module Monad
35------------
224------------
36
225
37−`TODO`
226+Types
227+~~~~~
228+
229+Type Classes
230+~~~~~~~~~~~~
231+
232+Type Class Instances
233+~~~~~~~~~~~~~~~~~~~~
234+
235+Values
236+~~~~~~
237+
238+::
239+
240+ (<=<) :: forall c. forall b. forall a. forall m. (Monad (m)) => Prelude.Function b (m c) -> Prelude.Function a (m b) -> a -> m c
38
241
242+ (>=>) :: forall c. forall b. forall a. forall m. (Monad (m)) => Prelude.Function a (m b) -> Prelude.Function b (m c) -> a -> m c
243+
244+ foldM :: forall b. forall a. forall m. (Monad (m)) => Prelude.Function a (b -> m a) -> a -> Prelude.Array b -> m a
245+
246+ join :: forall a. forall m. (Monad (m)) => m (m a) -> m a
247+
248+ mapM :: forall b. forall a. forall m. (Monad (m)) => Prelude.Function a (m b) -> Prelude.Array a -> m [b]
249+
250+ replicateM :: forall a. forall m. (Monad (m)) => Prelude.Number -> m a -> m [a]
251+
252+ sequence :: forall a. forall m. (Monad (m)) => Prelude.Array (m a) -> m [a]
253+
254+ when :: forall m. (Monad (m)) => Prelude.Boolean -> m { } -> m { }
255+
39−Maybe Module
256+Module Maybe
40------------
257------------
41
258
42−`TODO`
259+Types
260+~~~~~
261+
262+::
263+
264+ data Maybe a where
265+ Nothing :: Maybe a
266+ Just :: a -> Maybe a
267+
268+Type Classes
269+~~~~~~~~~~~~
43
270
271+Type Class Instances
272+~~~~~~~~~~~~~~~~~~~~
273+
274+::
275+
276+ instance Prelude.Monad Maybe
277+
278+Values
279+~~~~~~
280+
281+::
282+
283+ fromMaybe :: forall a. a -> Maybe a -> a
284+
285+ maybe :: forall b. forall a. b -> Prelude.Function a b -> Maybe a -> b
286+
44−Either Module
287+Module Either
45-------------
288-------------
46
289
47−`TODO`
290+Types
48−
291+~~~~~
292+
293+::
294+
295+ data Either a b where
296+ Left :: a -> Either a b
297+ Right :: b -> Either a b
298+
299+Type Classes
300+~~~~~~~~~~~~
301+
302+Type Class Instances
303+~~~~~~~~~~~~~~~~~~~~
304+
305+::
306+
307+ instance Prelude.Monad Either e
308+
309+Values
310+~~~~~~
311+
312+::
313+
314+ either :: forall c. forall b. forall a. Prelude.Function a c -> Prelude.Function b c -> Either a b -> c
315+
49−Arrays Module
316+Module Arrays
50-------------
317-------------
51
318
52−`TODO`
319+Types
53−
320+~~~~~
321+
322+Type Classes
323+~~~~~~~~~~~~
324+
325+Type Class Instances
326+~~~~~~~~~~~~~~~~~~~~
327+
328+::
329+
330+ instance Prelude.Alternative Prelude.Array
331+
332+ instance Prelude.Monad Prelude.Array
333+
334+ (Prelude.Show (a)) => instance Prelude.Show Prelude.Array a
335+
336+Values
337+~~~~~~
338+
339+::
340+
341+ (:) :: forall a. a -> Prelude.Array a -> Prelude.Array a
342+
343+ all :: forall a. Prelude.Function a Prelude.Boolean -> Prelude.Array a -> Prelude.Boolean
344+
345+ any :: forall a. Prelude.Function a Prelude.Boolean -> Prelude.Array a -> Prelude.Boolean
346+
347+ concat :: forall a. Prelude.Array a -> Prelude.Array a -> Prelude.Array a
348+
349+ concatMap :: forall b. forall a. Prelude.Array a -> Prelude.Function a [b] -> Prelude.Array b
350+
351+ filter :: forall a. Prelude.Function a Prelude.Boolean -> Prelude.Array a -> Prelude.Array a
352+
353+ foldl :: forall b. forall a. Prelude.Function a (b -> b) -> b -> Prelude.Array a -> b
354+
355+ foldr :: forall b. forall a. Prelude.Function a (b -> a) -> a -> Prelude.Array b -> a
356+
357+ head :: forall a. Prelude.Array a -> a
358+
359+ headSafe :: forall a. Prelude.Array a -> Maybe a
360+
361+ indexOf :: forall a. Prelude.Array a -> a -> Prelude.Number
362+
363+ isEmpty :: forall a. Prelude.Array a -> Prelude.Boolean
364+
365+ joinS :: Prelude.Array Prelude.String -> Prelude.String
366+
367+ joinWith :: Prelude.Array Prelude.String -> Prelude.String -> Prelude.String
368+
369+ lastIndexOf :: forall a. Prelude.Array a -> a -> Prelude.Number
370+
371+ length :: forall a. Prelude.Array a -> Prelude.Number
372+
373+ map :: forall b. forall a. Prelude.Function a b -> Prelude.Array a -> Prelude.Array b
374+
375+ push :: forall a. Prelude.Array a -> a -> Prelude.Array a
376+
377+ range :: Prelude.Number -> Prelude.Number -> Prelude.Array Prelude.Number
378+
379+ reverse :: forall a. Prelude.Array a -> Prelude.Array a
380+
381+ shift :: forall a. Prelude.Array a -> Prelude.Array a
382+
383+ singleton :: forall a. a -> Prelude.Array a
384+
385+ slice :: forall a. Prelude.Number -> Prelude.Number -> Prelude.Array a -> Prelude.Array a
386+
387+ sort :: forall a. Prelude.Array a -> Prelude.Array a
388+
389+ splice :: forall a. Prelude.Number -> Prelude.Number -> Prelude.Array a -> Prelude.Array a -> Prelude.Array a
390+
391+ tail :: forall a. Prelude.Array a -> Prelude.Array a
392+
393+ tailSafe :: forall a. Prelude.Array a -> Maybe [a]
394+
395+ zipWith :: forall c. forall b. forall a. Prelude.Function a (b -> c) -> Prelude.Array a -> Prelude.Array b -> Prelude.Array c
396+
54−Tuple Module
397+Module Tuple
55------------
398------------
56
399
57−`TODO`
400+Types
58−
401+~~~~~
59−Eff Module
402+
60−----------
403+::
404+
405+ type Tuple a b = { snd :: b, fst :: a }
406+
407+Type Classes
408+~~~~~~~~~~~~
61
409
62−`TODO`
410+Type Class Instances
63−
411+~~~~~~~~~~~~~~~~~~~~
412+
413+Values
414+~~~~~~
415+
416+::
417+
418+ curry :: forall c. forall b. forall a. Prelude.Function (Tuple a b) c -> a -> b -> c
419+
420+ tuple :: forall b. forall a. a -> b -> Tuple a b
421+
422+ uncurry :: forall c. forall b. forall a. Prelude.Function a (b -> c) -> Tuple a b -> c
423+
424+ unzip :: forall b. forall a. Prelude.Array (Tuple a b) -> Tuple [a] [b]
425+
426+ zip :: forall b. forall a. Prelude.Array a -> Prelude.Array b -> Prelude.Array (Tuple a b)
427+
64−Errors Module
428+Module String
65-------------
429-------------
66
430
67−`TODO`
431+Types
68−
432+~~~~~
433+
434+Type Classes
435+~~~~~~~~~~~~
436+
437+Type Class Instances
438+~~~~~~~~~~~~~~~~~~~~
439+
440+Values
441+~~~~~~
442+
443+::
444+
445+ charAt :: Prelude.Number -> Prelude.String -> Prelude.String
446+
447+ indexOfS :: Prelude.String -> Prelude.String -> Prelude.Number
448+
449+ lastIndexOfS :: Prelude.String -> Prelude.String -> Prelude.Number
450+
451+ lengthS :: Prelude.String -> Prelude.Number
452+
453+ localeCompare :: Prelude.String -> Prelude.String -> Prelude.Number
454+
455+ replace :: Prelude.String -> Prelude.String -> Prelude.String -> Prelude.String
456+
457+ sliceS :: Prelude.Number -> Prelude.Number -> Prelude.String -> Prelude.String
458+
459+ split :: Prelude.String -> Prelude.String -> Prelude.Array Prelude.String
460+
461+ substr :: Prelude.Number -> Prelude.Number -> Prelude.String -> Prelude.String
462+
463+ substring :: Prelude.Number -> Prelude.Number -> Prelude.String -> Prelude.String
464+
465+ toLower :: Prelude.String -> Prelude.String
466+
467+ toUpper :: Prelude.String -> Prelude.String
468+
469+ trim :: Prelude.String -> Prelude.String
470+
69−IORef Module
471+Module Regex
70------------
472------------
71
473
72−`TODO`
474+Types
73−
475+~~~~~
476+
477+::
478+
479+ data Regex :: *
480+
481+Type Classes
482+~~~~~~~~~~~~
483+
484+Type Class Instances
485+~~~~~~~~~~~~~~~~~~~~
486+
487+Values
488+~~~~~~
489+
490+::
491+
492+ match :: Regex -> Prelude.String -> Prelude.Array Prelude.String
493+
494+ regex :: Prelude.String -> Prelude.String -> Regex
495+
496+ replaceR :: Regex -> Prelude.String -> Prelude.String -> Prelude.String
497+
498+ search :: Regex -> Prelude.String -> Prelude.Number
499+
500+ test :: Regex -> Prelude.String -> Prelude.Boolean
501+
74−Random Module
502+Module Global
75-------------
503-------------
76
504
77−`TODO`
505+Types
78−
506+~~~~~
507+
508+Type Classes
509+~~~~~~~~~~~~
510+
511+Type Class Instances
512+~~~~~~~~~~~~~~~~~~~~
513+
514+Values
515+~~~~~~
516+
517+::
518+
519+ decodeURI :: Prelude.String -> Prelude.String
520+
521+ decodeURIComponent :: Prelude.String -> Prelude.String
522+
523+ encodeURI :: Prelude.String -> Prelude.String
524+
525+ encodeURIComponent :: Prelude.String -> Prelude.String
526+
527+ infinity :: Prelude.Number
528+
529+ isFinite :: Prelude.Number -> Prelude.Boolean
530+
531+ isNaN :: Prelude.Number -> Prelude.Boolean
532+
533+ nan :: Prelude.Number
534+
535+ parseFloat :: Prelude.String -> Prelude.Number
536+
537+ parseInt :: Prelude.String -> Prelude.Number
538+
539+ toExponential :: Prelude.Number -> Prelude.String
540+
541+ toFixed :: Prelude.Number -> Prelude.Number -> Prelude.String
542+
543+ toPrecision :: Prelude.Number -> Prelude.Number -> Prelude.String
544+
79−ST Module
545+Module Math
80−---------
546+-----------
547+
548+Types
549+~~~~~
550+
551+Type Classes
552+~~~~~~~~~~~~
553+
554+Type Class Instances
555+~~~~~~~~~~~~~~~~~~~~
556+
557+Values
558+~~~~~~
559+
560+::
561+
562+ abs :: Prelude.Number -> Prelude.Number
563+
564+ aceil :: Prelude.Number -> Prelude.Number
565+
566+ acos :: Prelude.Number -> Prelude.Number
567+
568+ asin :: Prelude.Number -> Prelude.Number
569+
570+ atan :: Prelude.Number -> Prelude.Number
571+
572+ atan2 :: Prelude.Number -> Prelude.Number -> Prelude.Number
573+
574+ cos :: Prelude.Number -> Prelude.Number
575+
576+ exp :: Prelude.Number -> Prelude.Number
577+
578+ floor :: Prelude.Number -> Prelude.Number
579+
580+ log :: Prelude.Number -> Prelude.Number
581+
582+ max :: Prelude.Number -> Prelude.Number
583+
584+ min :: Prelude.Number -> Prelude.Number
585+
586+ pow :: Prelude.Number -> Prelude.Number
587+
588+ round :: Prelude.Number -> Prelude.Number
589+
590+ sin :: Prelude.Number -> Prelude.Number
591+
592+ sqrt :: Prelude.Number -> Prelude.Number
593+
594+ tan :: Prelude.Number -> Prelude.Number
81
595
82−`TODO`
596+Module Eff
83−
597+----------
598+
599+Types
600+~~~~~
601+
602+::
603+
604+ data Eff :: # ! -> * -> *
605+
606+ type Pure a = forall e. Eff e a
607+
608+Type Classes
609+~~~~~~~~~~~~
610+
611+Type Class Instances
612+~~~~~~~~~~~~~~~~~~~~
613+
614+::
615+
616+ instance Prelude.Monad Eff e
617+
618+Values
619+~~~~~~
620+
621+::
622+
623+ bindEff :: forall b. forall a. forall e. Eff e a -> Prelude.Function a (Eff e b) -> Eff e b
624+
625+ forE :: forall e. Prelude.Number -> Prelude.Number -> Prelude.Function Prelude.Number (Eff e { }) -> Eff e { }
626+
627+ foreachE :: forall a. forall e. Prelude.Array a -> Prelude.Function a (Eff e { }) -> Eff e { }
628+
629+ retEff :: forall a. forall e. a -> Eff e a
630+
631+ runPure :: forall a. Pure a -> a
632+
633+ untilE :: forall e. Eff e Prelude.Boolean -> Eff e { }
634+
635+ whileE :: forall e. Eff e Prelude.Boolean -> Eff e { } -> Eff e { }
636+
637+Module Random
638+-------------
639+
640+Types
641+~~~~~
642+
643+::
644+
645+ data Random :: !
646+
647+Type Classes
648+~~~~~~~~~~~~
649+
650+Type Class Instances
651+~~~~~~~~~~~~~~~~~~~~
652+
653+Values
654+~~~~~~
655+
656+::
657+
658+ random :: forall e. Eff random :: Random | e Prelude.Number
659+
660+Module Errors
661+-------------
662+
663+Types
664+~~~~~
665+
666+::
667+
668+ data Error :: * -> !
669+
670+Type Classes
671+~~~~~~~~~~~~
672+
673+Type Class Instances
674+~~~~~~~~~~~~~~~~~~~~
675+
676+Values
677+~~~~~~
678+
679+::
680+
681+ catchError :: forall a. forall r. forall e. Prelude.Function e (Eff r a) -> Eff err :: Error e | r a -> Eff r a
682+
683+ throwError :: forall r. forall e. forall a. e -> Eff err :: Error e | r a
684+
685+Module IORef
686+------------
687+
688+Types
689+~~~~~
690+
691+::
692+
693+ data IORef :: * -> *
694+
695+ data Ref :: !
696+
697+Type Classes
698+~~~~~~~~~~~~
699+
700+Type Class Instances
701+~~~~~~~~~~~~~~~~~~~~
702+
703+Values
704+~~~~~~
705+
706+::
707+
708+ modifyIORef :: forall r. forall s. IORef s -> Prelude.Function s s -> Eff ref :: Ref | r { }
709+
710+ newIORef :: forall r. forall s. s -> Eff ref :: Ref | r (IORef s)
711+
712+ readIORef :: forall r. forall s. IORef s -> Eff ref :: Ref | r s
713+
714+ writeIORef :: forall r. forall s. IORef s -> s -> Eff ref :: Ref | r { }
715+
84−Trace Module
716+Module Trace
85------------
717------------
86
718
87−`TODO`
719+Types
88−
720+~~~~~
721+
722+::
723+
724+ data Trace :: !
725+
726+Type Classes
727+~~~~~~~~~~~~
728+
729+Type Class Instances
730+~~~~~~~~~~~~~~~~~~~~
731+
732+Values
733+~~~~~~
734+
735+::
736+
737+ print :: forall r. forall a. (Prelude.Show (a)) => a -> Eff trace :: Trace | r { }
738+
739+ trace :: forall r. Prelude.String -> Eff trace :: Trace | r { }
740+
741+Module ST
742+---------
743+
744+Types
745+~~~~~
746+
747+::
748+
749+ data ST :: * -> !
750+
751+ data STRef :: * -> * -> *
752+
753+Type Classes
754+~~~~~~~~~~~~
755+
756+Type Class Instances
757+~~~~~~~~~~~~~~~~~~~~
758+
759+Values
760+~~~~~~
761+
762+::
763+
764+ modifySTRef :: forall r. forall h. forall a. STRef h a -> Prelude.Function a a -> Eff st :: ST h | r { }
765+
766+ newSTRef :: forall r. forall h. forall a. a -> Eff st :: ST h | r (STRef h a)
767+
768+ readSTRef :: forall r. forall h. forall a. STRef h a -> Eff st :: ST h | r a
769+
770+ runST :: forall r. forall a. forall h. Eff st :: ST h | r a -> Eff r a
771+
772+ writeSTRef :: forall r. forall h. forall a. STRef h a -> a -> Eff st :: ST h | r { }
773+
libraries/prelude/README.mdnew file+683
@@ -0,0 +1,683 @@
1+# Module Documentation
2+## Module Prelude
3+
4+### Types
5+
6+ data Array :: * -> *
7+
8+ data Boolean :: *
9+
10+ data Function :: * -> * -> *
11+
12+ data Number :: *
13+
14+ data Ref a where
15+ Ref :: a -> Ref a
16+
17+ data String :: *
18+
19+
20+### Type Classes
21+
22+ class Alternative f where
23+ empty :: forall a. f a
24+ (<|>) :: forall a. f a -> f a -> f a
25+
26+ class Applicative f where
27+ pure :: forall a. a -> f a
28+ (<*>) :: forall b. forall a. f (a -> b) -> f a -> f b
29+
30+ class Bits b where
31+ (&) :: b -> b -> b
32+ (|) :: b -> b -> b
33+ (^) :: b -> b -> b
34+ shl :: b -> Prelude.Number -> b
35+ shr :: b -> Prelude.Number -> b
36+ zshr :: b -> Prelude.Number -> b
37+ complement :: b -> b
38+
39+ class BoolLike b where
40+ (&&) :: b -> b -> b
41+ (||) :: b -> b -> b
42+ not :: b -> b
43+
44+ class Category a where
45+ id :: forall t. a t t
46+ (<<<) :: forall d. forall c. forall b. a c d -> a b c -> a b d
47+ (>>>) :: forall d. forall c. forall b. a b c -> a c d -> a b d
48+
49+ class Eq a where
50+ (==) :: a -> a -> Prelude.Boolean
51+ (/=) :: a -> a -> Prelude.Boolean
52+
53+ class Functor f where
54+ (<$>) :: forall b. forall a. Prelude.Function a b -> f a -> f b
55+
56+ class Monad m where
57+ ret :: forall a. a -> m a
58+ (>>=) :: forall b. forall a. m a -> Prelude.Function a (m b) -> m b
59+
60+ class Num a where
61+ (+) :: a -> a -> a
62+ (-) :: a -> a -> a
63+ (*) :: a -> a -> a
64+ (/) :: a -> a -> a
65+ (%) :: a -> a -> a
66+ negate :: a -> a
67+
68+ class Ord a where
69+ (<) :: a -> a -> Prelude.Boolean
70+ (>) :: a -> a -> Prelude.Boolean
71+ (<=) :: a -> a -> Prelude.Boolean
72+ (>=) :: a -> a -> Prelude.Boolean
73+
74+ class Read a where
75+ read :: Prelude.String -> a
76+
77+ class Show a where
78+ show :: a -> Prelude.String
79+
80+
81+### Type Class Instances
82+
83+ (Monad (m)) => instance Applicative m
84+
85+ instance Bits Prelude.Number
86+
87+ instance BoolLike Prelude.Boolean
88+
89+ instance Category Prelude.Function
90+
91+ instance Eq Ref a
92+
93+ instance Eq Prelude.String
94+
95+ instance Eq Prelude.Number
96+
97+ instance Eq Prelude.Boolean
98+
99+ (Eq (a)) => instance Eq Prelude.Array a
100+
101+ (Applicative (f)) => instance Functor f
102+
103+ instance Num Prelude.Number
104+
105+ instance Ord Prelude.Number
106+
107+ instance Prelude.Show Prelude.Number
108+
109+ instance Read Prelude.String
110+
111+ instance Read Prelude.Boolean
112+
113+ instance Show Prelude.String
114+
115+ instance Show Prelude.Boolean
116+
117+
118+### Values
119+
120+ (!!) :: forall a. Prelude.Array a -> Prelude.Number -> a
121+
122+ (#) :: forall b. forall a. a -> Prelude.Function a b -> b
123+
124+ ($) :: forall b. forall a. Prelude.Function a b -> a -> b
125+
126+ (++) :: Prelude.String -> Prelude.String -> Prelude.String
127+
128+ boolAnd :: Prelude.Boolean -> Prelude.Boolean -> Prelude.Boolean
129+
130+ boolNot :: Prelude.Boolean -> Prelude.Boolean
131+
132+ boolOr :: Prelude.Boolean -> Prelude.Boolean -> Prelude.Boolean
133+
134+ flip :: forall c. forall b. forall a. Prelude.Function a (b -> c) -> b -> a -> c
135+
136+ konst :: forall b. forall a. a -> b -> a
137+
138+ numAdd :: Prelude.Number -> Prelude.Number -> Prelude.Number
139+
140+ numAnd :: Prelude.Number -> Prelude.Number -> Prelude.Number
141+
142+ numComplement :: Prelude.Number -> Prelude.Number
143+
144+ numDiv :: Prelude.Number -> Prelude.Number -> Prelude.Number
145+
146+ numGreater :: Prelude.Number -> Prelude.Number -> Prelude.Boolean
147+
148+ numGreaterEq :: Prelude.Number -> Prelude.Number -> Prelude.Boolean
149+
150+ numLess :: Prelude.Number -> Prelude.Number -> Prelude.Boolean
151+
152+ numLessEq :: Prelude.Number -> Prelude.Number -> Prelude.Boolean
153+
154+ numMod :: Prelude.Number -> Prelude.Number -> Prelude.Number
155+
156+ numMul :: Prelude.Number -> Prelude.Number -> Prelude.Number
157+
158+ numNegate :: Prelude.Number -> Prelude.Number
159+
160+ numOr :: Prelude.Number -> Prelude.Number -> Prelude.Number
161+
162+ numShl :: Prelude.Number -> Prelude.Number -> Prelude.Number
163+
164+ numShr :: Prelude.Number -> Prelude.Number -> Prelude.Number
165+
166+ numSub :: Prelude.Number -> Prelude.Number -> Prelude.Number
167+
168+ numXor :: Prelude.Number -> Prelude.Number -> Prelude.Number
169+
170+ numZshr :: Prelude.Number -> Prelude.Number -> Prelude.Number
171+
172+ refEq :: forall a. Ref a -> Ref a -> Prelude.Boolean
173+
174+ refIneq :: forall a. Ref a -> Ref a -> Prelude.Boolean
175+
176+ showNumber :: Prelude.Number -> Prelude.String
177+
178+ unsafeRefEq :: forall a. a -> a -> Prelude.Boolean
179+
180+ unsafeRefIneq :: forall a. a -> a -> Prelude.Boolean
181+
182+
183+## Module Monoid
184+
185+### Types
186+
187+
188+### Type Classes
189+
190+ class Monoid m where
191+ mempty :: m
192+ (<>) :: m -> m -> m
193+
194+
195+### Type Class Instances
196+
197+ instance Monoid Prelude.String
198+
199+
200+### Values
201+
202+ mconcat :: forall m. (Monoid (m)) => Prelude.Array m -> m
203+
204+
205+## Module Monad
206+
207+### Types
208+
209+
210+### Type Classes
211+
212+
213+### Type Class Instances
214+
215+
216+### Values
217+
218+ (<=<) :: forall c. forall b. forall a. forall m. (Monad (m)) => Prelude.Function b (m c) -> Prelude.Function a (m b) -> a -> m c
219+
220+ (>=>) :: forall c. forall b. forall a. forall m. (Monad (m)) => Prelude.Function a (m b) -> Prelude.Function b (m c) -> a -> m c
221+
222+ foldM :: forall b. forall a. forall m. (Monad (m)) => Prelude.Function a (b -> m a) -> a -> Prelude.Array b -> m a
223+
224+ join :: forall a. forall m. (Monad (m)) => m (m a) -> m a
225+
226+ mapM :: forall b. forall a. forall m. (Monad (m)) => Prelude.Function a (m b) -> Prelude.Array a -> m [b]
227+
228+ replicateM :: forall a. forall m. (Monad (m)) => Prelude.Number -> m a -> m [a]
229+
230+ sequence :: forall a. forall m. (Monad (m)) => Prelude.Array (m a) -> m [a]
231+
232+ when :: forall m. (Monad (m)) => Prelude.Boolean -> m { } -> m { }
233+
234+
235+## Module Maybe
236+
237+### Types
238+
239+ data Maybe a where
240+ Nothing :: Maybe a
241+ Just :: a -> Maybe a
242+
243+
244+### Type Classes
245+
246+
247+### Type Class Instances
248+
249+ instance Prelude.Monad Maybe
250+
251+
252+### Values
253+
254+ fromMaybe :: forall a. a -> Maybe a -> a
255+
256+ maybe :: forall b. forall a. b -> Prelude.Function a b -> Maybe a -> b
257+
258+
259+## Module Either
260+
261+### Types
262+
263+ data Either a b where
264+ Left :: a -> Either a b
265+ Right :: b -> Either a b
266+
267+
268+### Type Classes
269+
270+
271+### Type Class Instances
272+
273+ instance Prelude.Monad Either e
274+
275+
276+### Values
277+
278+ either :: forall c. forall b. forall a. Prelude.Function a c -> Prelude.Function b c -> Either a b -> c
279+
280+
281+## Module Arrays
282+
283+### Types
284+
285+
286+### Type Classes
287+
288+
289+### Type Class Instances
290+
291+ instance Prelude.Alternative Prelude.Array
292+
293+ instance Prelude.Monad Prelude.Array
294+
295+ (Prelude.Show (a)) => instance Prelude.Show Prelude.Array a
296+
297+
298+### Values
299+
300+ (:) :: forall a. a -> Prelude.Array a -> Prelude.Array a
301+
302+ all :: forall a. Prelude.Function a Prelude.Boolean -> Prelude.Array a -> Prelude.Boolean
303+
304+ any :: forall a. Prelude.Function a Prelude.Boolean -> Prelude.Array a -> Prelude.Boolean
305+
306+ concat :: forall a. Prelude.Array a -> Prelude.Array a -> Prelude.Array a
307+
308+ concatMap :: forall b. forall a. Prelude.Array a -> Prelude.Function a [b] -> Prelude.Array b
309+
310+ filter :: forall a. Prelude.Function a Prelude.Boolean -> Prelude.Array a -> Prelude.Array a
311+
312+ foldl :: forall b. forall a. Prelude.Function a (b -> b) -> b -> Prelude.Array a -> b
313+
314+ foldr :: forall b. forall a. Prelude.Function a (b -> a) -> a -> Prelude.Array b -> a
315+
316+ head :: forall a. Prelude.Array a -> a
317+
318+ headSafe :: forall a. Prelude.Array a -> Maybe a
319+
320+ indexOf :: forall a. Prelude.Array a -> a -> Prelude.Number
321+
322+ isEmpty :: forall a. Prelude.Array a -> Prelude.Boolean
323+
324+ joinS :: Prelude.Array Prelude.String -> Prelude.String
325+
326+ joinWith :: Prelude.Array Prelude.String -> Prelude.String -> Prelude.String
327+
328+ lastIndexOf :: forall a. Prelude.Array a -> a -> Prelude.Number
329+
330+ length :: forall a. Prelude.Array a -> Prelude.Number
331+
332+ map :: forall b. forall a. Prelude.Function a b -> Prelude.Array a -> Prelude.Array b
333+
334+ push :: forall a. Prelude.Array a -> a -> Prelude.Array a
335+
336+ range :: Prelude.Number -> Prelude.Number -> Prelude.Array Prelude.Number
337+
338+ reverse :: forall a. Prelude.Array a -> Prelude.Array a
339+
340+ shift :: forall a. Prelude.Array a -> Prelude.Array a
341+
342+ singleton :: forall a. a -> Prelude.Array a
343+
344+ slice :: forall a. Prelude.Number -> Prelude.Number -> Prelude.Array a -> Prelude.Array a
345+
346+ sort :: forall a. Prelude.Array a -> Prelude.Array a
347+
348+ splice :: forall a. Prelude.Number -> Prelude.Number -> Prelude.Array a -> Prelude.Array a -> Prelude.Array a
349+
350+ tail :: forall a. Prelude.Array a -> Prelude.Array a
351+
352+ tailSafe :: forall a. Prelude.Array a -> Maybe [a]
353+
354+ zipWith :: forall c. forall b. forall a. Prelude.Function a (b -> c) -> Prelude.Array a -> Prelude.Array b -> Prelude.Array c
355+
356+
357+## Module Tuple
358+
359+### Types
360+
361+ type Tuple a b = { snd :: b, fst :: a }
362+
363+
364+### Type Classes
365+
366+
367+### Type Class Instances
368+
369+
370+### Values
371+
372+ curry :: forall c. forall b. forall a. Prelude.Function (Tuple a b) c -> a -> b -> c
373+
374+ tuple :: forall b. forall a. a -> b -> Tuple a b
375+
376+ uncurry :: forall c. forall b. forall a. Prelude.Function a (b -> c) -> Tuple a b -> c
377+
378+ unzip :: forall b. forall a. Prelude.Array (Tuple a b) -> Tuple [a] [b]
379+
380+ zip :: forall b. forall a. Prelude.Array a -> Prelude.Array b -> Prelude.Array (Tuple a b)
381+
382+
383+## Module String
384+
385+### Types
386+
387+
388+### Type Classes
389+
390+
391+### Type Class Instances
392+
393+
394+### Values
395+
396+ charAt :: Prelude.Number -> Prelude.String -> Prelude.String
397+
398+ indexOfS :: Prelude.String -> Prelude.String -> Prelude.Number
399+
400+ lastIndexOfS :: Prelude.String -> Prelude.String -> Prelude.Number
401+
402+ lengthS :: Prelude.String -> Prelude.Number
403+
404+ localeCompare :: Prelude.String -> Prelude.String -> Prelude.Number
405+
406+ replace :: Prelude.String -> Prelude.String -> Prelude.String -> Prelude.String
407+
408+ sliceS :: Prelude.Number -> Prelude.Number -> Prelude.String -> Prelude.String
409+
410+ split :: Prelude.String -> Prelude.String -> Prelude.Array Prelude.String
411+
412+ substr :: Prelude.Number -> Prelude.Number -> Prelude.String -> Prelude.String
413+
414+ substring :: Prelude.Number -> Prelude.Number -> Prelude.String -> Prelude.String
415+
416+ toLower :: Prelude.String -> Prelude.String
417+
418+ toUpper :: Prelude.String -> Prelude.String
419+
420+ trim :: Prelude.String -> Prelude.String
421+
422+
423+## Module Regex
424+
425+### Types
426+
427+ data Regex :: *
428+
429+
430+### Type Classes
431+
432+
433+### Type Class Instances
434+
435+
436+### Values
437+
438+ match :: Regex -> Prelude.String -> Prelude.Array Prelude.String
439+
440+ regex :: Prelude.String -> Prelude.String -> Regex
441+
442+ replaceR :: Regex -> Prelude.String -> Prelude.String -> Prelude.String
443+
444+ search :: Regex -> Prelude.String -> Prelude.Number
445+
446+ test :: Regex -> Prelude.String -> Prelude.Boolean
447+
448+
449+## Module Global
450+
451+### Types
452+
453+
454+### Type Classes
455+
456+
457+### Type Class Instances
458+
459+
460+### Values
461+
462+ decodeURI :: Prelude.String -> Prelude.String
463+
464+ decodeURIComponent :: Prelude.String -> Prelude.String
465+
466+ encodeURI :: Prelude.String -> Prelude.String
467+
468+ encodeURIComponent :: Prelude.String -> Prelude.String
469+
470+ infinity :: Prelude.Number
471+
472+ isFinite :: Prelude.Number -> Prelude.Boolean
473+
474+ isNaN :: Prelude.Number -> Prelude.Boolean
475+
476+ nan :: Prelude.Number
477+
478+ parseFloat :: Prelude.String -> Prelude.Number
479+
480+ parseInt :: Prelude.String -> Prelude.Number
481+
482+ toExponential :: Prelude.Number -> Prelude.String
483+
484+ toFixed :: Prelude.Number -> Prelude.Number -> Prelude.String
485+
486+ toPrecision :: Prelude.Number -> Prelude.Number -> Prelude.String
487+
488+
489+## Module Math
490+
491+### Types
492+
493+
494+### Type Classes
495+
496+
497+### Type Class Instances
498+
499+
500+### Values
501+
502+ abs :: Prelude.Number -> Prelude.Number
503+
504+ aceil :: Prelude.Number -> Prelude.Number
505+
506+ acos :: Prelude.Number -> Prelude.Number
507+
508+ asin :: Prelude.Number -> Prelude.Number
509+
510+ atan :: Prelude.Number -> Prelude.Number
511+
512+ atan2 :: Prelude.Number -> Prelude.Number -> Prelude.Number
513+
514+ cos :: Prelude.Number -> Prelude.Number
515+
516+ exp :: Prelude.Number -> Prelude.Number
517+
518+ floor :: Prelude.Number -> Prelude.Number
519+
520+ log :: Prelude.Number -> Prelude.Number
521+
522+ max :: Prelude.Number -> Prelude.Number
523+
524+ min :: Prelude.Number -> Prelude.Number
525+
526+ pow :: Prelude.Number -> Prelude.Number
527+
528+ round :: Prelude.Number -> Prelude.Number
529+
530+ sin :: Prelude.Number -> Prelude.Number
531+
532+ sqrt :: Prelude.Number -> Prelude.Number
533+
534+ tan :: Prelude.Number -> Prelude.Number
535+
536+
537+## Module Eff
538+
539+### Types
540+
541+ data Eff :: # ! -> * -> *
542+
543+ type Pure a = forall e. Eff e a
544+
545+
546+### Type Classes
547+
548+
549+### Type Class Instances
550+
551+ instance Prelude.Monad Eff e
552+
553+
554+### Values
555+
556+ bindEff :: forall b. forall a. forall e. Eff e a -> Prelude.Function a (Eff e b) -> Eff e b
557+
558+ forE :: forall e. Prelude.Number -> Prelude.Number -> Prelude.Function Prelude.Number (Eff e { }) -> Eff e { }
559+
560+ foreachE :: forall a. forall e. Prelude.Array a -> Prelude.Function a (Eff e { }) -> Eff e { }
561+
562+ retEff :: forall a. forall e. a -> Eff e a
563+
564+ runPure :: forall a. Pure a -> a
565+
566+ untilE :: forall e. Eff e Prelude.Boolean -> Eff e { }
567+
568+ whileE :: forall e. Eff e Prelude.Boolean -> Eff e { } -> Eff e { }
569+
570+
571+## Module Random
572+
573+### Types
574+
575+ data Random :: !
576+
577+
578+### Type Classes
579+
580+
581+### Type Class Instances
582+
583+
584+### Values
585+
586+ random :: forall e. Eff random :: Random | e Prelude.Number
587+
588+
589+## Module Errors
590+
591+### Types
592+
593+ data Error :: * -> !
594+
595+
596+### Type Classes
597+
598+
599+### Type Class Instances
600+
601+
602+### Values
603+
604+ catchError :: forall a. forall r. forall e. Prelude.Function e (Eff r a) -> Eff err :: Error e | r a -> Eff r a
605+
606+ throwError :: forall r. forall e. forall a. e -> Eff err :: Error e | r a
607+
608+
609+## Module IORef
610+
611+### Types
612+
613+ data IORef :: * -> *
614+
615+ data Ref :: !
616+
617+
618+### Type Classes
619+
620+
621+### Type Class Instances
622+
623+
624+### Values
625+
626+ modifyIORef :: forall r. forall s. IORef s -> Prelude.Function s s -> Eff ref :: Ref | r { }
627+
628+ newIORef :: forall r. forall s. s -> Eff ref :: Ref | r (IORef s)
629+
630+ readIORef :: forall r. forall s. IORef s -> Eff ref :: Ref | r s
631+
632+ writeIORef :: forall r. forall s. IORef s -> s -> Eff ref :: Ref | r { }
633+
634+
635+## Module Trace
636+
637+### Types
638+
639+ data Trace :: !
640+
641+
642+### Type Classes
643+
644+
645+### Type Class Instances
646+
647+
648+### Values
649+
650+ print :: forall r. forall a. (Prelude.Show (a)) => a -> Eff trace :: Trace | r { }
651+
652+ trace :: forall r. Prelude.String -> Eff trace :: Trace | r { }
653+
654+
655+## Module ST
656+
657+### Types
658+
659+ data ST :: * -> !
660+
661+ data STRef :: * -> * -> *
662+
663+
664+### Type Classes
665+
666+
667+### Type Class Instances
668+
669+
670+### Values
671+
672+ modifySTRef :: forall r. forall h. forall a. STRef h a -> Prelude.Function a a -> Eff st :: ST h | r { }
673+
674+ newSTRef :: forall r. forall h. forall a. a -> Eff st :: ST h | r (STRef h a)
675+
676+ readSTRef :: forall r. forall h. forall a. STRef h a -> Eff st :: ST h | r a
677+
678+ runST :: forall r. forall a. forall h. Eff st :: ST h | r a -> Eff r a
679+
680+ writeSTRef :: forall r. forall h. forall a. STRef h a -> a -> Eff st :: ST h | r { }
681+
682+
683+
libraries/prelude/updateDocs.shnew file+2
@@ -0,0 +1,2 @@
1+../../dist/build/docgen/docgen prelude.purs > README.md
2+pandoc -o ../../docs/source/prelude.rst README.md
purescript.cabal+9
@@ -86,6 +86,15 @@ executable psci
86 other-modules:
86 other-modules:
87 ghc-options: -Wall -O2
87 ghc-options: -Wall -O2
88
88
89+executable docgen
90+ build-depends: base >=4 && <5, cmdtheline -any, purescript -any, utf8-string -any,
91+ process -any, mtl -any
92+ main-is: Main.hs
93+ buildable: True
94+ hs-source-dirs: docgen
95+ other-modules:
96+ ghc-options: -Wall -O2
97+
89test-suite tests
98test-suite tests
90 build-depends: base >=4 && <5, containers -any, directory -any,
99 build-depends: base >=4 && <5, containers -any, directory -any,
91 filepath -any, mtl -any, parsec -any, purescript -any, syb -any,
100 filepath -any, mtl -any, parsec -any, purescript -any, syb -any,