Prelude

Modules

Adaptor	Functions for converting between Flix and Java values and collections.
Array	Type of mutable fixed-length arrays, and its functions.
BigDecimal	Type of arbitrary-precision signed decimal numbers, and its functions.
BigInt	Type of arbitrary-precision signed integers, and its functions.
Bool	Type of boolean values, and its functions.
Channel	Functions for message passing over channels.
Char	Type of 16-bit Unicode characters, and its functions.
CodePoint	Functions for working with Unicode code points.
Concurrent	Modules for concurrent programming.
Fixpoint3	Functions for solving Datalog programs.
Float32	Type of 32-bit floating-point numbers, and its functions.
Float64	Type of 64-bit floating-point numbers, and its functions.
Fs	Modules for interacting with the file system.
Graph	A library of functions that operates on graphs, represented as foldable collections of either pairs or triples, for unweighted and weighted graphs respectively. These pairs, or triples, represent directed edges while nodes(vertices) are given implicitly.
Int16	Type of 16-bit signed integers, and its functions.
Int32	Type of 32-bit signed integers, and its functions.
Int64	Type of 64-bit signed integers, and its functions.
Int8	Type of 8-bit signed integers, and its functions.
Math	Modules for mathematical utilities.
Net	Modules for networking.
Object	Functions for working with Java objects and `null` values.
Reflect	Functions for reflecting on the runtime representation of values and types.
Regex	Type of compiled regular expressions, and its functions.
String	Type of immutable strings, and its functions.
Sys	Modules for interacting with the operating system.
Time	Modules for working with time.
Util	Modules for general-purpose utilities.
Vector	Type of immutable arrays, and its functions.

Traits

Add	Trait for types that support addition.
Applicative	Trait for types that support embedding values and applying embedded functions.
Box	A trait for primitive types that can be boxed and unboxed.
Coerce	Trait for types that can be coerced.
Collectable	Trait for types that can be collected from an iterator.
CommutativeGroup	Trait for types that form a commutative group.
CommutativeMonoid	Trait for types that form a commutative monoid.
CommutativeSemiGroup	Trait for types that form a commutative semigroup.
Discrete	Trait for types that form a discrete sequence.
Div	Trait for types that support division.
Eq	Trait for types that support equality and inequality.
Filterable	Trait for types that support filtering.
Foldable	Trait for types that can be folded.
ForEach	Trait for types that support iterating over their elements with `forEach`.
Formattable	Trait for types that can be formatted as a `RichString`.
FromString	Trait for types that can be constructed from strings.
Functor	Trait for types that can be mapped over.
Group	Trait for types that form a group.
Hash	Trait for types that can be hashed.
Indexable	Trait for types that map indices to elements.
IndexableMut	Trait for types that map indices to elements and can be modified.
Iterable	Trait for types that can be iterated.
JoinLattice	Trait for types that form a join semi-lattice.
LowerBound	Trait for types that are partially ordered and have a lower bound.
MeetLattice	Trait for types that form a meet semi-lattice.
Monad	Trait for types that support monadic bind (`flatMap`).
MonadZero	Trait for types that are monads with a zero element.
MonadZip	Trait for types that are monads that support zipping.
Monoid	Trait for types that form a monoid.
Mul	Trait for types that support multiplication.
Neg	Trait for types that support negation.
Order	Trait for types that have a total order.
PartialOrder	Trait for types that have a partial order.
Peekable	Trait for types that can be read from with lookahead.
Readable	Trait for types that can be read from.
Reducible	Trait for types that can be reduced to a summary value.
SemiGroup	Trait for types that form a semigroup.
Sub	Trait for types that support subtraction.
ToFlix	Trait for types that can be marshaled to Flix values.
ToJava	Trait for types that can be marshaled to Java objects.
ToString	Trait for types that can be converted to strings.
Traversable	Trait for types that can be traversed from left to right with an applicative functor.
UnorderedFoldable	Trait for types that can be folded without regard to order.
UpperBound	Trait for types that are partially ordered and have an upper bound.
Witherable	Trait for types that can be traversed from left to right with an applicative functor while filtering elements.
Writable	Trait for types that can be written to.

Effects

Abort	Effect for aborting a computation with an error message.
Assert	Effect for performing assertions during program execution.
Chan	Effect for operations on channels in the global region.
Debug	An effect used for print debugging.
IO	Effect for actions not described by any other effect.
KeyNotFound	Effect for signaling that a key was not found.
Logger	Effect for logging messages.
NonDet	Effect for non-deterministic actions.
OutOfBounds	Effect for signaling that an index is out of bounds.

Enums

Chain	Type of immutable sequences with efficient append.
CharacterSet	Type of character sets for encoding and decoding text.
Comparison	Type of comparison results.
DelayList	Type of lazy lists.
DelayMap	Type of immutable maps with lazily evaluated values.
Down	Type of values with reversed ordering.
EncodingWriter	Type of writers that encode chars into bytes.
Identity	Type of values in the identity functor and monad.
IoError	Type of errors that can occur when performing I/O operations involving the file system.
Iterator	Type of lazy iterators scoped to a region.
List	Type of immutable singly-linked lists.
Map	Type of immutable maps.
MultiMap	Type of immutable maps that allow multiple values per key.
Nec	Type of non-empty chains.
Nel	Type of non-empty immutable lists.
Option	Type of optional values.
Proxy	Type of proxies that carry type information where a witness is not available.
ProxyBool	Type of proxies that carry type-level Boolean information where a witness is not available.
ProxyEff	Type of proxies that carry effect information where a witness is not available.
Purity	Type of unary functions tagged as either pure or impure.
Purity2	Type of curried binary functions tagged as either pure or impure.
Purity3	Type of curried ternary functions tagged as either pure or impure.
Range	Type of half-open ranges of discrete values.
RedBlackTree	Type of immutable red-black trees.
Result	Type of results that are either a successful value or an error value.
RichString	Type of rich strings composed of styled text spans.
Set	Type of immutable ordered sets.
StringBuilder	Type of mutable string builders.
Validation	Type of validation results that are either a successful value or a non-empty collection of errors.

Structs

BPlusTree	Type of mutable concurrent B+ trees.
BufReader	Type of buffered readers.
DecodingReader	Type of readers that decode bytes into chars.
MutDeque	Type of mutable double-ended queues.
MutDisjointSets	Type of mutable disjoint sets (union-find).
MutHashMap	Type of mutable hash maps that preserve insertion order.
MutHashSet	Type of mutable hash sets that preserve insertion order.
MutList	Type of mutable lists backed by resizable arrays.
MutMap	Type of mutable maps.
MutPriorityQueue	Type of mutable priority queues.
MutSet	Type of mutable sets.
Ref	Represents a mutable reference to a value of type `a` in region `r`.

Type Aliases

type alias Heap[h: Eff] = h§ Source

A type alias used while we transition to a proper Heap effect.

type alias Static = IO§ Source

Static denotes the region of global lifetime.

Definitions

def !>(x: a, f: a -> Unit \ ef): a \ ef§ Source

Pipes the given value x into the function f.

Given a value x and a function f returns x.

def ++(x: a, y: a): a with SemiGroup[a]§ Source

Alias for SemiGroup.combine.

def >>(f: a -> b \ ef1, g: b -> c \ ef2): a -> c \ ef1 + ef2§ Source

Forwards function composition. Applies the function on the left first.

Given the functions f: a -> b and g: b -> c returns a function a -> c

def bug!(m: String): a§ Source

Crashes the current process with the given message m.

def coerce(x: t): Out[t] \ Aef[t] with Coerce[t]§ Source

Coerces the given value x.

def constant(x: a): b -> a \ ef§ Source

The constant function.

def eidentity(x: a): a \ ef§ Source

The identity function, automatically casting to the required effect.

def flip(f: a -> (b -> c \ ef)): b -> (a -> c \ ef)§ Source

Returns the function f with input arguments swapped. That is, given the function f: (a, b) -> c, returns a function (b, a) -> c

def fst(p: (a, b)): a§ Source

Returns the first component of t.

def identity(x: a): a§ Source

The pure identity function.

def indexOutOfBounds!(m: String): a§ Source

Throws an IndexOutOfBoundsException with the given message m.

def on(f: b -> (b -> c \ ef1), g: a -> b \ ef2, x: a, y: a): c \ ef1 + ef2§ Source

Partially applying this function in the form f `on` g lifts the binary function f to work on inputs transformed by g.

def println(x: a): Unit \ IO with ToString[a]§ Source

Converts x to a string and prints it to standard out followed by a new line.

def purityOf(f: a -> b \ ef): Purity[a, b, ef]§ Source

Returns Purity.Pure(g) if f has no effects. Returns Purity.Impure(g) otherwise. The function g can then be used in a context that requires it to be pure.

def purityOf2(f: a -> (b -> c \ ef)): Purity2[a, b, c, ef]§ Source

Returns Purity2.Pure(g) if f has no effects. Returns Purity2.Impure(g) otherwise. The function g can then be used in a context that requires it to be pure.

def purityOf3(f: a -> (b -> (c -> d \ ef))): Purity3[a, b, c, d, ef]§ Source

Returns Purity3.Pure(g) if f has no effects. Returns Purity3.Impure(g) otherwise. The function g can then be used in a context that requires it to be pure.

def snd(p: (a, b)): b§ Source

Returns the second component of t.

def swap(p: (a, b)): (b, a)§ Source

Returns the pair p with the components swapped. That is, returns (y, x) if p = (x, y).

def touch(_: Region[r]): Unit \ r§ Source

Touches the given region capability rc.

def unreachable!(): a§ Source

Asserts that this expression is unreachable. Crashes if not.

def |+|(x: a, y: a): a with CommutativeSemiGroup[a]§ Source

Alias for CommutativeSemiGroup.combine.

def |>(x: a, f: a -> b \ ef): b \ ef§ Source

Pipes the given value x into the function f.

Given a value x and a function f returns f(x).

def ||>(x: (a, b), f: a -> (b -> c \ ef)): c \ ef§ Source

Pipes the given pair x into the function f.

Given a pair x and a function f returns f(x).