Used by the compiler to wrap main console applications.
| std | |
| core | |
| bool | |
| char | Standard |
| console | Standard output to the console. |
| debug | Core debugging functions. |
| delayed | Delayed computations. |
| either | Standard |
| exn | Standard exception ( |
| hnd | Internal effect handler primitives. |
| int | Standard integer |
| list | Standard |
| maybe | Standard |
| order | Standard |
| show | Standard show functions. |
| sslice | Efficient views on strings. |
| string | Standard |
| tuple | Standard tuple functions. |
| types | Primitive types and functions. |
| vector | Standard vector functions. |
This module is implicitly imported and all functions and types
are always available.
Some types and operations are required to be defined for the compiler
to work correctly (i.e. types like exnstd/core/exn/exn: (E, V) -> V or liststd/core/types/list: V -> V).
The blockingstd/core/blocking: X effect signifies that a function may block.
The fsysstd/core/fsys: X effect signifies a function may access the file system.
The global-scopestd/core/global-scope: S is a special type constant to denote the global scope.
The iostd/core/io: E effect is used for functions that perform arbitrary I/O operations.
The io-noexnstd/core/io-noexn: E effect is used for functions that perform arbitrary I/O operations, but raise no exceptions.
The io-totalstd/core/io-total: E effect is used for functions that perform arbitrary I/O operations, but are terminating without raising exceptions.
The netstd/core/net: X effect signifies a function may access the network.
The named effect is the default umbrella effect for named effects.
An alias for pure effects: a pure function always returns the same result when called with the same arguments but may not terminate or raise an exception.
The scopestd/core/scope: S -> X effect is used to ensure named effects cannot escape the scope of their handler.
A streamstd/core/stream: V -> V is a co-inductive type representing an infinite list of elements.
Automatically generated. Retrieves the head constructor field of the streamstd/core/stream: V -> V type.
Automatically generated. Retrieves the tail constructor field of the streamstd/core/stream: V -> V type.
The uistd/core/ui: X effect signifies a function may access the graphics system.
Generic equality if cmp exists.
Fold over the integers between [start,end] (including end).
Fold over the integers between [start,end] (including end) or until f returns Nothingstd/core/types/Nothing: forall<a> maybe<a>.
Executes action for each integer from start to end (including end ).
If start > end the function returns without any call to action .
Executes action for each integer between start to end (including end ).
If start > end the function returns without any call to action .
If action returns Juststd/core/types/Just: forall<a> (value : a) -> maybe<a>, the iteration is stopped and the result returned.
Generic inequality.
Generic lower than.
Generic lower than or equal.
Generic greater than.
Generic greater than or equal.
Apply a function f to a specified argument x.
Return a ‘constant’ function that ignores its argument and always returns the same result.
Fold over the integers between [0,upto) (excluding upto).
Fold over the integers between [0,n) (excluding n) or until f returns Nothingstd/core/types/Nothing: forall<a> maybe<a>.
Executes action n times for each integer from 0 to malformed identifier: a dash must be preceded by a letter or digit, and followed by a letter.
If n <= 0 the function returns without any call to action .
Executes action for each integer between [0,n) (excluding n ).
If n <= 0 the function returns without any call to action .
If action returns Juststd/core/types/Just: forall<a> (value : a) -> maybe<a>, the iteration is stopped and the result returned.
Return the host environment: dotnet, browser, webworker, node, or libc.
The ignorestd/core/ignore: forall<a> (x : a) -> () function ignores its argument.
Used by the compiler to wrap main console applications.
Compose two functions f and g.
The repeat fun executes action n times.
Concise way to ensure two expressions have the same type.
Returns a unique integer (modulo 32-bits).
The whilestd/core/while: forall<e> (predicate : () -> <div|e> bool, action : () -> <div|e> ()) -> <div|e> () fun executes action as long as pred is true.
Standard
boolstd/core/types/bool: Vfunctions.