Prelude

Modules

Adaptor
Array
BigDecimal	Represents arbitrary-precision signed decimal numbers. The representation consists of both a "value" and a "scale". Standard equality (`==` and the `Eq` trait) consider both value and scale, numerical equality (are the values the same after the scales have been normalized) is provided by the function `numericEquals`.
BigInt
Bool
Channel
Char
CodePoint	The `CodePoint` module complements the `Char` module. `Char` only represents characters in Unicode's _Basic Multilingual Plane_ (U+0000 to U+FFFF). CodePoint extends access to include _supplementary characters_ so all Unicode characters can be represented.
Concurrent
Fixpoint3
Float32
Float64
Fs	## Effect Hierarchy
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
Int32
Int64
Int8
Math	The `Math` module is a collection of mathematical utility submodules, each offering a self-contained piece of functionality:
Net	The `Net` module is a collection of networking utility submodules, each offering a self-contained piece of functionality:
Object
Reflect
Regex	Basic support for regular expression matching on Strings.
String
Sys	The `Sys` module is a collection of operating-system utility submodules, each offering a self-contained piece of functionality:
Time	The `Time` module is a collection of time-related utility submodules, each offering a self-contained piece of functionality:
Util	The `Util` module is a collection of general-purpose utility submodules, each offering a self-contained piece of functionality:
Vector

Traits

Add	A trait for addition.
Applicative	A trait for functors that support application, i.e. allow to:
Box	A trait for primitive types that can be boxed and unboxed.
Coerce	A trait for type that can be coerced.
Collectable	A trait representing collections that can be produced from an Iterator.
CommutativeGroup	A trait for types that form a commutative group (abelian group) i.e. groups where the `combine` function is commutative.
CommutativeMonoid	A trait for types that form a commutative monoid.
CommutativeSemiGroup	A trait for types that form a commutative semigroup.
Discrete	A trait for types whose values form a discrete sequence, i.e. where every value has an immediate successor and predecessor.
Div	A trait for division.
Eq	A trait for equality and inequality.
Filterable	A trait for filtering container functors.
Foldable	A trait for data structures that can be folded.
ForEach	A trait for data structures that support a forEach operation.
Formattable	A trait for types that can be formatted as a `RichString`.
FromString	A trait for types that can be constructed from strings.
Functor	A trait for types that can be mapped over.
Group	A trait for types that form a group.
Hash	A trait for types that can be hashed.
Indexable	An `Indexable` instance on a type means that it has a (partial or total) mapping from indices (`Idx`) to elements (`Elm`). The mapping can be accessed by `get`.
IndexableMut	An `IndexableMut` instance on a type means that it has a (potentially partial) mapping from indices (`Indexable.Idx`) to elements (`Indexable.Elm`). The mapping can be modified and potentially expanded. The mapping can be accessed by `Indexable.get` and modified by `put`.
Iterable	A trait for immutable data structures that can be iterated.
JoinLattice	A trait for join semi lattices.
LowerBound	A trait for partially ordered types that have a lower bound.
MeetLattice	A trait for meet semi lattices. A Meet Lattice is pair of functions (⊑, ⊓) where ⊑ is a partial order and ⊓ satisfy two properties: lower-bound and greatest-lower-bound.
Monad	A trait for applicatives that support monadic bind (`flatMap`), i.e., allow to apply a function that takes a normal value and produces a monadic value to a monadic value. That is, the bind mechanism supports extraction of monadic values, or, viewed differently, allows to combine (flatten) nested monadic values (`flapMap` can be understood as a `Functor.map` followed by a `flatten`).
MonadZero	A trait for Monads that have a zero element.
MonadZip	A trait for zipping Monads, typically container monads like `List`.
Monoid	A trait for Monoids, objects that support an associative binary operation `combine` and neutral element `empty`.
Mul	A trait for multiplication.
Neg	A trait for negation.
Order	A trait for types with a total order.
PartialOrder	A Partial Order is a function ⊑ which satisfies three properties: reflexivity, anti-symmetry, and transitivity.
Peekable	Extends `Readable` with the ability to `peek` at values that have not yet been `read`, `skip` values that don't need to be read, and perform other kinds of conditional reads.
Readable	A trait for types which are resources that can be read from.
Reducible	A trait for types that can be reduced to a summary value.
SemiGroup	A trait for types that form a semigroup.
Sub	A trait for subtraction.
ToFlix	A trait for marshaling values to Flix objects.
ToJava	A trait for marshaling values to Java objects.
ToString	A trait for types that can be converted to strings.
Traversable	A trait for data structures that can be traversed in left-to-right order with an applicative functor.
UnorderedFoldable	A trait for unordered data structures that can be folded.
UpperBound	A trait for partially ordered types that have an upper bound.
Witherable	A trait for data structures that can be traversed in left-to-right order with an applicative partial functor.
Writable	A trait for types which are resources that can be written to.

Effects

Abort	An effect used to abort computation with an error message.
Assert	An effect used to perform assertions during program execution.
Chan	The uninterpretable Chan effect.
Debug	An effect used for print debugging.
IO	The uninterpretable IO effect.
KeyNotFound	Indicates that a key was not found. Useful for instances of `Index` or `IndexMut`.
Logger	An effect used to log messages.
NonDet	The uninterpretable `NonDet` effect.
OutOfBounds	Indicates that an index was out of bounds. Useful for instances of `Index` or `IndexMut`.

Enums

Chain	The Chain type.
CharacterSet
Comparison
DelayList
DelayMap
Down	The `Down` type allows you to reverse the sort order of `a` conveniently.
EncodingWriter	Adapts a `Writable` of bytes to a `Writable` of chars.
Identity
IoError	An error that can occur when performing I/O operations involving the file system.
Iterator
List	The List type.
Map	The Map type.
MultiMap	The MultiMap type.
Nec	The NonEmpty Chain type.
Nel	The NonEmptyList type.
Option	The Option type.
Proxy	An enum that holds type information where a witness is not available.
ProxyBool	An enum that holds type-level Bool information where a witness is not available.
ProxyEff	An enum that holds effect information where a witness is not available.
Purity
Purity2
Purity3
Range	Represents a range (b, e) of discrete values from `b` (inclusive) to `e` (exclusive).
RedBlackTree	An immutable red-black tree implementation with keys of type `k` and values of type `v`.
Result	The Result type.
RichString	A rich string composed of multiple styled spans.
Set	The Set type.
StringBuilder	Represents a StringBuilder.
Validation	The Validation type.

Structs

BPlusTree	A mutable concurrent B+ Tree implementation with keys of type `k` and values of type `v`.
BufReader	A `Readable` implementation that wraps an underlying `Readable` instance and stores the items read from the underlying instance in an internal buffer.
DecodingReader	Adapts a `Readable` of bytes to a `Readable` of chars.
MutDeque	Represents a mutable deque.
MutDisjointSets	Represents a mutable disjoint set data structure using union-by-rank and path compression.
MutHashMap	Represents a mutable hash map that preserves insertion order.
MutHashSet	Represents a mutable hash set that preserves insertion order.
MutList	Represents a mutable list.
MutMap	The Mutable Map type.
MutPriorityQueue	Represents a mutable priority queue. Explanation of component types (left to right): Component 1: The region capability the queue is associated with. Component 2: A reference to the backing array. Component 3: A reference to the number of elements in the mutable priority queue.
MutSet	The Mutable Set type.
Ref

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).