Package `COALTON`

Hint to the compiler that predicate is likely True.

`(NOINLINE APPLICATION)` ^{_{[FUNCTION] · src}}

∀ :A. (:A → :A)

Prevent application from being inlined. It will prevent inlining when the argument is syntactically a function application.

`(SOME X)` ^{_{[FUNCTION] · src}}

∀ :A. (:A → (OPTIONAL :A))

A constructor for the type, Optional. This constructor can be used like any other algebraic data type constructor, including for pattern matching, as in the following example.

(match x
  ((Some value)
    value)
  (_ (error "Oh, no!")))

`(UNLIKELY PREDICATE)` ^{_{[FUNCTION] · src}}

Hint to the compiler that predicate is likely False.

`FALSE` ^{_{[VALUE] · src}}

BOOLEAN

`NIL` ^{_{[VALUE] · src}}

∀ :A. (LIST :A)

`NONE` ^{_{[VALUE] · src}}

∀ :A. (OPTIONAL :A)

A constructor for the type, Optional. This constructor can be used like any other algebraic data type constructor, including for pattern matching, as in the following example.

(match x
  ((None)
   "Fantastic!")
  (_ (error "Oh, no!")))

`TRUE` ^{_{[VALUE] · src}}

BOOLEAN

`UNIT` ^{_{[VALUE] · src}}

UNIT

Macros

Right associative compose operator. Creates a new functions that will run the functions right to left when applied. This is the same as the nest macro without supplying the value. The composition is thus the same order as compose.

(.< f g h) creates the function (fn (x) (f (g (h x)))).

`.> (&REST ITEMS)` ^_[MACRO]

Left associative compose operator. Creates a new functions that will run the functions left to right when applied. This is the same as the pipe macro without supplying the value. The composition is thus the reverse order of compose.

(.> f g h) creates the function (fn (x) (h (g (f x)))).

`AS (TYPE &OPTIONAL (EXPR NIL EXPR-SUPPLIED-P))` ^_[MACRO]

A syntactic convenience for type casting.

(as <type> <expr>)

is equivalent to

(the <type> (into <expr>))

and

(as <type>)

is equivalent to

(fn (expr) (the <type> (into expr))).

Note that this may copy the object or allocate memory.

`ASSERT (DATUM &OPTIONAL (FORMAT-STRING "") &REST FORMAT-DATA)` ^_[MACRO]

Signal an error unless datum is True.

If the assertion fails, the signaled error will apply the format-data to the format-string via cl:format to produce an error message.

`MAKE-LIST (&REST FORMS)` ^_[MACRO]

Create a heterogeneous Coalton List of objects. This macro is deprecated; use coalton-library/list:make.

`NEST (&REST ITEMS)` ^_[MACRO]

A syntactic convenience for function application. Transform

(nest f g h x)

(f (g (h x))).

`PIPE (&REST ITEMS)` ^_[MACRO]

A syntactic convenience for function application, sometimes called a “threading macro”. Transform

(pipe x h g f)

(f (g (h x))).

`TRY-AS (TYPE &OPTIONAL (EXPR NIL EXPR-SUPPLIED-P))` ^_[MACRO]

A syntactic convenience for type casting.

(try-as <type> <expr>)

is equivalent to

(the (Result :_ <type>) (tryInto <expr>))

and

(try-as <type>)

is equivalent to

(fn (expr) (the (Result :_ <type>) (tryInto expr))).

Note that this may copy the object or allocate memory.

`UNWRAP-AS (TYPE &OPTIONAL (EXPR NIL EXPR-SUPPLIED-P))` ^_[MACRO]

A syntactic convenience for type casting.

(unwrap-as <type> <expr>)

is equivalent to

(the <type> (uwrap (tryInto <expr>)))

and

(unwrap-as <type>)

is equivalent to

(fn (expr) (the <type> (unwrap (tryInto expr)))).

Note that this may copy the object or allocate memory.

Package `COALTON-LIBRARY/ALGORITHMS/FFT`

A coalton package for performing FFTs.

Classes

`FFTCYCLICGROUP` ^{_{[CLASS] · src}}

FFTCYCLICGROUP :A

A class of types, each of which is a mathematical cyclic group.

These are types which are valid elements for a collection which may undergo a discrete Fourier transform. Examples include complex floating-point numbers and finite (modular) integers.

Methods:

CYCLIC-ADD-IDENTITY :: :A
CYCLIC-ADD :: (:A → :A → :A)
CYCLIC-ADD-INVERSE :: (:A → :A)
CYCLIC-NTH-GENERATOR :: (UFIX → :A)
A function which returns a primitive nth root of unity.

Instances

FFTCYCLICGROUP (COMPLEX F64)
FFTCYCLICGROUP (COMPLEX F32)

`FFTFIELD` ^{_{[CLASS] · src}}

FFTRING :A ⇒ FFTFIELD :A

A class of types, each of which is a mathematical field.

These are types which are valid elements for a collection which may undergo a discrete Fourier transform. Examples include complex floating-point numbers and finite (modular) integers.

Methods:

MULTIPLY-INVERSE :: (:A → :A)

Instances

FFTFIELD (COMPLEX F64)
FFTFIELD (COMPLEX F32)

`FFTGROUP` ^{_{[CLASS] · src}}

FFTGROUP :A

A class of types, each of which is a mathematical group.

These are types which are valid elements for a collection which may undergo a discrete Fourier transform. Examples include complex floating-point numbers and finite (modular) integers.

Methods:

ADD-IDENTITY :: :A
ADD :: (:A → :A → :A)
ADD-INVERSE :: (:A → :A)

Instances

FFTGROUP (COMPLEX F64)
FFTGROUP (COMPLEX F32)

`FFTRING` ^{_{[CLASS] · src}}

FFTGROUP :A ⇒ FFTRING :A

A class of types, each of which is a mathematical ring.

These are types which are valid elements for a collection which may undergo a discrete Fourier transform. Examples include complex floating-point numbers and finite (modular) integers.

Methods:

MULTIPLY-IDENTITY :: :A
MULTIPLY :: (:A → :A → :A)

Instances

FFTRING (COMPLEX F64)
FFTRING (COMPLEX F32)

Values

`(DIF-FFT-RAW DST SRC)` ^{_{[FUNCTION] · src}}

∀ :A :B :C. (RANDOMACCESS :B :A) (RANDOMACCESS :C :A) (FFTRING :A) (FFTCYCLICGROUP :A) ⇒ (:B → :C → UNIT)

A decimation-in-frequency fast fourier transform, reading from src and writing to dst.

Input: natural order Output: bit-reversed order Normalization: none

`(DIF-IFFT-RAW DST SRC)` ^{_{[FUNCTION] · src}}

∀ :A :B :C. (RANDOMACCESS :B :A) (RANDOMACCESS :C :A) (FFTRING :A) (FFTCYCLICGROUP :A) ⇒ (:B → :C → UNIT)

A decimation-in-frequency inverse fast fourier transform, reading from src and writing to dst.

Input: natural order Output: bit-reversed order Normalization: none

`(DIT-FFT-RAW DST SRC)` ^{_{[FUNCTION] · src}}

∀ :A :B :C. (RANDOMACCESS :B :A) (RANDOMACCESS :C :A) (FFTRING :A) (FFTCYCLICGROUP :A) ⇒ (:B → :C → UNIT)

A decimation-in-time fast fourier transform, reading from src and writing to dst.

Input: bit-reversed order Output: natural order Normalization: none

`(DIT-IFFT-RAW DST SRC)` ^{_{[FUNCTION] · src}}

∀ :A :B :C. (RANDOMACCESS :B :A) (RANDOMACCESS :C :A) (FFTRING :A) (FFTCYCLICGROUP :A) ⇒ (:B → :C → UNIT)

A decimation-in-time inverse fast fourier transform, reading from src and writing to dst.

Input: bit-reversed order Output: natural order Normalization: none

`(DIVIDE X Y)` ^{_{[FUNCTION] · src}}

∀ :A. FFTFIELD :A ⇒ (:A → :A → :A)

`(FFT STORAGE)` ^{_{[FUNCTION] · src}}

∀ :A :B :C. (RANDOMACCESS :B :A) (RANDOMACCESS :C :A) (FFTRING :A) (FFTCYCLICGROUP :A) ⇒ (:B → :C)

Perform a fast Fourier transform on the data in storage.

`(FFT! STORAGE)` ^{_{[FUNCTION] · src}}

∀ :A :B. (RANDOMACCESS :B :A) (FFTRING :A) (FFTCYCLICGROUP :A) ⇒ (:B → :B)

Perform an in-place fast Fourier transform on storage.

`(FFT-INTO! DST SRC)` ^{_{[FUNCTION] · src}}

∀ :A :B :C. (RANDOMACCESS :C :A) (RANDOMACCESS :B :A) (FFTRING :A) (FFTCYCLICGROUP :A) ⇒ (:B → :C → :B)

Perform a fast Fourier transform of src, writing the result to dst. If dst is longer than src, then remaining elements of dst are left unmutated.

`(IFFT STORAGE)` ^{_{[FUNCTION] · src}}

∀ :A :B :C. (RANDOMACCESS :B :A) (RANDOMACCESS :C :A) (FFTFIELD :A) (FFTCYCLICGROUP :A) (NUM :A) ⇒ (:B → :C)

Perform an inverse fast Fourier transform on the data in storage.

`(IFFT! STORAGE)` ^{_{[FUNCTION] · src}}

∀ :A :B. (RANDOMACCESS :B :A) (FFTFIELD :A) (FFTCYCLICGROUP :A) (NUM :A) ⇒ (:B → :B)

Perform an in-place inverse fast Fourier transform on storage.

`(IFFT-INTO! DST SRC)` ^{_{[FUNCTION] · src}}

∀ :A :B :C. (RANDOMACCESS :C :A) (RANDOMACCESS :B :A) (FFTFIELD :A) (FFTCYCLICGROUP :A) (NUM :A) ⇒ (:B → :C → :B)

Perform an inverse fast Fourier transform of src, writing the result to dst. If dst is longer than src, then remaining elements of dst are left unmutated.

`(SUBTRACT X Y)` ^{_{[FUNCTION] · src}}

∀ :A. FFTGROUP :A ⇒ (:A → :A → :A)

Package `COALTON-LIBRARY/BIG-FLOAT`

Types

`BIG-FLOAT` ^{_{[TYPE] · src}}

An arbitrary (but fixed) precision floating point number.

Instances

COMPLEXCOMPONENT BIG-FLOAT
DIVIDABLE INTEGER BIG-FLOAT
ELEMENTARY BIG-FLOAT
EQ BIG-FLOAT
EXPONENTIABLE BIG-FLOAT
INTO F32 BIG-FLOAT
INTO F64 BIG-FLOAT
INTO FRACTION BIG-FLOAT
INTO INTEGER BIG-FLOAT
NUM BIG-FLOAT
ORD BIG-FLOAT
POLAR BIG-FLOAT
QUANTIZABLE BIG-FLOAT
RADICAL BIG-FLOAT
RATIONAL BIG-FLOAT
REAL BIG-FLOAT
RECIPROCABLE BIG-FLOAT
RUNTIMEREPR BIG-FLOAT
TRANSFINITE BIG-FLOAT
TRIGONOMETRIC BIG-FLOAT

`ROUNDINGMODE` ^{_{[TYPE] · src}}

Instances

RUNTIMEREPR ROUNDINGMODE

Values

`(BF-EE _)` ^{_{[FUNCTION] · src}}

∀ :A. (:A → BIG-FLOAT)

Return the value of ee = exp(1) to the currently set precision.

`(BF-PI _)` ^{_{[FUNCTION] · src}}

∀ :A. (:A → BIG-FLOAT)

Return the value of pi to the currently set precision.

`(GET-PRECISION _)` ^{_{[FUNCTION] · src}}

(UNIT → UFIX)

Get the current precision of Big-Float arithmetic.

`(GET-ROUNDING-MODE _)` ^{_{[FUNCTION] · src}}

(UNIT → ROUNDINGMODE)

Get the current rounding-mode of Big-Float arithmetic.

`(SET-PRECISION! PREC-BITS)` ^{_{[FUNCTION] · src}}

(UFIX → UNIT)

Set the precision of Big-Float arithmetic to PREC-BITS bits.

`(SET-ROUNDING-MODE! R)` ^{_{[FUNCTION] · src}}

(ROUNDINGMODE → UNIT)

Set the global rounding mode for Big-Float operations.

`(WITH-PRECISION PREC-BITS F)` ^{_{[FUNCTION] · src}}

∀ :A. (UFIX → (UNIT → :A) → :A)

Call F with a temporary Big-Float precision PREC-BITS.

`(WITH-PRECISION-ROUNDING PREC-BITS RND F)` ^{_{[FUNCTION] · src}}

∀ :A. (UFIX → ROUNDINGMODE → (UNIT → :A) → :A)

Call F with a temporary Big-Float PREC-BITS precision and RND rounding-mode.

`(WITH-ROUNDING RND F)` ^{_{[FUNCTION] · src}}

∀ :A. (ROUNDINGMODE → (UNIT → :A) → :A)

Call F with a temporary Big-Float rounding-mode RND.

`RNDA` ^{_{[VALUE] · src}}

RouND Away from zero.

`RNDD` ^{_{[VALUE] · src}}

RouND Down, toward negative infinity.

`RNDF` ^{_{[VALUE] · src}}

Faithful rounding (experimental).

`RNDN` ^{_{[VALUE] · src}}

RouND to Nearest, with the even rounding rule.

`RNDNA` ^{_{[VALUE] · src}}

RouND to Nearest Away.

`RNDU` ^{_{[VALUE] · src}}

RouND Up, toward positive infinity.

`RNDZ` ^{_{[VALUE] · src}}

RouND toward Zero.

Package `COALTON-LIBRARY/BITS`

Classes

`BITS` ^{_{[CLASS] · src}}

NUM :A ⇒ BITS :A

Operations on the bits of twos-complement integers

Methods:

AND :: (:A → :A → :A)
The bitwise logical and of two integers
OR :: (:A → :A → :A)
The bitwise logical or of two integers
XOR :: (:A → :A → :A)
The bitwise logical exclusive or of two integers
NOT :: (:A → :A)
The bitwise logical not of two integers
SHIFT :: (INTEGER → :A → :A)
The arithmetic left-shift of an integer by an integer number of bits

Instances

BITS UFIX
BITS U64
BITS U32
BITS U16
BITS U8
BITS BIT
BITS IFIX
BITS I64
BITS I32
BITS I16
BITS I8
BITS INTEGER

`REVERSEBITS` ^{_{[CLASS] · src}}

REVERSEBITS :A

A type class for number types that support bit reversal.

Methods:

REVERSE-BITS :: (:A → :A)
Reverse the bits of x.
REVERSE-N-BITS :: (UFIX → :A → :A)
Reverse the first n bits of x and set the rest to 0.

Instances

REVERSEBITS U64
REVERSEBITS UFIX
REVERSEBITS U32
REVERSEBITS U16
REVERSEBITS U8

Values

`(DPB NEWBYTE SIZE POSITION BITSTRING)` ^{_{[FUNCTION] · src}}

∀ :A. BITS :A ⇒ (:A → UFIX → UFIX → :A → :A)

Deposits a byte newbyte of size size into a bitstring bitstring at a position position.

`(LDB SIZE POSITION BITSTRING)` ^{_{[FUNCTION] · src}}

∀ :A. BITS :A ⇒ (UFIX → UFIX → :A → :A)

Deposits a byte of size size into a bitstring at a position position.

Package `COALTON-LIBRARY/BUILTIN`

Values

`(BOOLEAN-AND X Y)` ^{_{[FUNCTION] · src}}

Are both x and y true? Note that this is a function which means both x and y will be evaluated. Use the and macro for short-circuiting behavior.

`(BOOLEAN-NOT X)` ^{_{[FUNCTION] · src}}

The logical negation of x. Is x false?

`(BOOLEAN-OR X Y)` ^{_{[FUNCTION] · src}}

Is either x or y true? Note that this is a function which means both x and y will be evaluated. Use the or macro for short-circuiting behavior.

`(BOOLEAN-XOR X Y)` ^{_{[FUNCTION] · src}}

Are x or y true, but not both?

`(NOT X)` ^{_{[FUNCTION] · src}}

Synonym for boolean-not.

`(UNDEFINED _)` ^{_{[FUNCTION] · src}}

∀ :A :B. (:A → :B)

A function which can be used in place of any value, throwing an error at runtime.

`(XOR X Y)` ^{_{[FUNCTION] · src}}

Synonym for boolean-xor.

Macros

`UNREACHABLE (&OPTIONAL (DATUM "Unreachable") &REST ARGUMENTS)` ^_[MACRO]

Signal an error with CL format string DATUM and optional format arguments ARGUMENTS.

Package `COALTON-LIBRARY/CELL`

Types

`CELL` ^{_{[TYPE] · src}}

Internally mutable cell

Instances

APPLICATIVE CELL
DEFAULT :A ⇒ DEFAULT (CELL :A)
EQ :A ⇒ EQ (CELL :A)
FUNCTOR CELL
INTO (CELL :A) :A
INTO :A (CELL :A)
INTO :A STRING ⇒ INTO (CELL :A) STRING
NUM :A ⇒ NUM (CELL :A)
ORD :A ⇒ ORD (CELL :A)
RUNTIMEREPR (CELL :A)
SEMIGROUP :A ⇒ SEMIGROUP (CELL :A)

Values

`(DECREMENT! CEL)` ^{_{[FUNCTION] · src}}

∀ :A. NUM :A ⇒ ((CELL :A) → :A)

Subtract one from the contents of cel, storing and returning the new value.

`(INCREMENT! CEL)` ^{_{[FUNCTION] · src}}

∀ :A. NUM :A ⇒ ((CELL :A) → :A)

Add one to the contents of cel, storing and returning the new value.

`(NEW DATA)` ^{_{[FUNCTION] · src}}

∀ :A. (:A → (CELL :A))

Create a new mutable cell containing data.

`(POP! CEL)` ^{_{[FUNCTION] · src}}

∀ :A. ((CELL (LIST :A)) → (OPTIONAL :A))

Remove and return the first element of the list in cel.

`(PUSH! CEL NEW-ELT)` ^{_{[FUNCTION] · src}}

∀ :A. ((CELL (LIST :A)) → :A → (LIST :A))

Push new-elt onto the start of the list in cel.

`(READ CEL)` ^{_{[FUNCTION] · src}}

∀ :A. ((CELL :A) → :A)

Read the value of a mutable cell cel.

`(SWAP! CEL DATA)` ^{_{[FUNCTION] · src}}

∀ :A. ((CELL :A) → :A → :A)

Replace the value of a mutable cell cel with a new value data, then return the old value.

`(UPDATE! F CEL)` ^{_{[FUNCTION] · src}}

∀ :A. ((:A → :A) → (CELL :A) → :A)

Apply f to the contents of cel, storing and returning the result.

`(UPDATE-SWAP! F CEL)` ^{_{[FUNCTION] · src}}

∀ :A. ((:A → :A) → (CELL :A) → :A)

Apply f to the contents of cel, swapping the result for the old value.

`(WRITE! CEL DATA)` ^{_{[FUNCTION] · src}}

∀ :A. ((CELL :A) → :A → :A)

Set the value of a mutable cell cel to data, returning the new value.

Package `COALTON-LIBRARY/CHAR`

Values

`(ALPHA? C)` ^{_{[FUNCTION] · src}}

Is c an alphabetic character?

`(ASCII-ALPHA? C)` ^{_{[FUNCTION] · src}}

Is c an ASCII alphabetic character?

`(ASCII-ALPHANUMERIC? C)` ^{_{[FUNCTION] · src}}

Is c an ASCII alphanumeric character?

`(ASCII-DIGIT? C)` ^{_{[FUNCTION] · src}}

Is c an ASCII digit character?

`(ASCII-LOWERCASE? C)` ^{_{[FUNCTION] · src}}

Is c an ASCII lowercase character?

`(ASCII-UPPERCASE? C)` ^{_{[FUNCTION] · src}}

Is c an ASCII uppercase character?

`(CHAR-CODE CHAR)` ^{_{[FUNCTION] · src}}

(CHAR → UFIX)

Convert a character to its ASCII representation.

`(CODE-CHAR CODE)` ^{_{[FUNCTION] · src}}

(UFIX → (OPTIONAL CHAR))

Convert a number to its ASCII character, returning None on failure.

`(DIGIT? C)` ^{_{[FUNCTION] · src}}

Is c a digit character?

`(DOWNCASE C)` ^{_{[FUNCTION] · src}}

(CHAR → CHAR)

Returns the downcased version of c, returning c when there is none.

`(LOWERCASE? C)` ^{_{[FUNCTION] · src}}

Is c a lowercase character?

`(RANGE START END)` ^{_{[FUNCTION] · src}}

(CHAR → CHAR → (ITERATOR CHAR))

An inclusive range of characters from start to end by char-code.

`(UPCASE C)` ^{_{[FUNCTION] · src}}

(CHAR → CHAR)

Returns the upcased version of c, returning c when there is none.

`(UPPERCASE? C)` ^{_{[FUNCTION] · src}}

Is c an uppercase character?

Package `COALTON-LIBRARY/CLASSES`

Types

`HASH` ^{_{[TYPE] · src}}

Implementation dependent hash code.

Instances

DEFAULT HASH
EQ HASH
HASH HASH
MONOID HASH
ORD HASH
RUNTIMEREPR HASH
SEMIGROUP HASH

`ORD` ^{_{[TYPE] · src}}

LT
- Less than
GT
- Greater than
EQ
- Equal to

The result of an ordered comparison.

Instances

EQ ORD
ORD ORD
RUNTIMEREPR ORD

`RESULT` ^{_{[TYPE] · src}}

(ERR :A)
(OK :B)

Represents something that may have failed.

Instances

(EQ :A) (EQ :B) ⇒ EQ (RESULT :A :B)
(ORD :A) (ORD :B) ⇒ ORD (RESULT :A :B)
APPLICATIVE (RESULT :A)
BIFUNCTOR RESULT
FROMITERATOR :A :B ⇒ FROMITERATOR (RESULT :C :A) (RESULT :C :B)
FUNCTOR (RESULT :A)
INTO (OPTIONAL :A) (RESULT UNIT :A)
INTO (RESULT :A :B) (OPTIONAL :B)
INTOITERATOR (RESULT :A :B) :B
ISO (RESULT UNIT :A) (OPTIONAL :A)
MONAD (RESULT :A)
MONOID :A ⇒ MONOID (RESULT :B :A)
RUNTIMEREPR (RESULT :A :B)
SEMIGROUP :A ⇒ SEMIGROUP (RESULT :B :A)
TRAVERSABLE (RESULT :A)
UNWRAPPABLE (RESULT :A)

Structs

`TUPLE :A :B` ^{_{[STRUCT] · src}}

A heterogeneous collection of items.

Instances

(DEFAULT :A) (DEFAULT :B) ⇒ DEFAULT (TUPLE :A :B)
(EQ :A) (EQ :B) ⇒ EQ (TUPLE :A :B)
(HASH :A) (HASH :B) ⇒ HASH (TUPLE :A :B)
(ORD :A) (ORD :B) ⇒ ORD (TUPLE :A :B)
BIFUNCTOR TUPLE
HASH :A ⇒ FROMITERATOR (HASHMAP :A :B) (TUPLE :A :B)
HASH :A ⇒ FROMITERATOR (HASHTABLE :A :B) (TUPLE :A :B)
INTO (MAPPAIR :A :B) (TUPLE :A :B)
INTO (TUPLE :A :B) (TUPLE :B :A)
INTOITERATOR (HASHMAP :A :B) (TUPLE :A :B)
INTOITERATOR (HASHTABLE :A :B) (TUPLE :A :B)
INTOITERATOR (ORDMAP :A :B) (TUPLE :A :B)
ISO (TUPLE :A :B) (TUPLE :B :A)
ORD :A ⇒ FROMITERATOR (ORDMAP :A :B) (TUPLE :A :B)
RUNTIMEREPR (TUPLE :A :B)

Classes

`ALTERNATIVE` ^{_{[CLASS] · src}}

APPLICATIVE :A ⇒ ALTERNATIVE :A

Types which are monoids on applicative functors.

Methods:

ALT :: ((:A :B) → (:A :B) → (:A :B))
EMPTY :: (:A :C)

Instances

MONAD :A ⇒ ALTERNATIVE (OPTIONALT :A)
ALTERNATIVE LIST
ALTERNATIVE OPTIONAL

`APPLICATIVE` ^{_{[CLASS] · src}}

FUNCTOR :A ⇒ APPLICATIVE :A

Types which are a functor which can embed pure expressions and sequence operations.

Methods:

PURE :: (:B → (:A :B))
LIFTA2 :: ((:C → :D → :E) → (:A :C) → (:A :D) → (:A :E))

Instances

(FUNCTOR :A) (MONAD :B) ⇒ APPLICATIVE ((FREET :A) :B)
FUNCTOR :A ⇒ APPLICATIVE (FREE :A)
MONAD :A ⇒ APPLICATIVE (OPTIONALT :A)
MONAD :A ⇒ APPLICATIVE ((RESULTT :B) :A)
APPLICATIVE :A ⇒ APPLICATIVE ((ENVT :B) :A)
APPLICATIVE (ENV :A)
APPLICATIVE :A ⇒ APPLICATIVE ((STATET :B) :A)
APPLICATIVE (ST :A)
APPLICATIVE IDENTITY
APPLICATIVE LIST
APPLICATIVE (RESULT :A)
APPLICATIVE OPTIONAL
APPLICATIVE CELL
APPLICATIVE (ARROW :A)

`BIFUNCTOR` ^{_{[CLASS] · src}}

BIFUNCTOR :A

Types which take two type arguments and are functors on both.

Methods:

BIMAP :: ((:B → :C) → (:D → :E) → ((:A :B) :D) → ((:A :C) :E))

Instances

FUNCTOR :A ⇒ BIFUNCTOR (FREEF :A)
BIFUNCTOR RESULT
BIFUNCTOR TUPLE

`DEFAULT` ^{_{[CLASS] · src}}

DEFAULT :A

Types which have default values.

Methods:

DEFAULT :: (UNIT → :A)

Instances

RUNTIMEREPR :A ⇒ DEFAULT (SEQ :A)
DEFAULT (QUEUE :A)
HASH :A ⇒ DEFAULT (HASHTABLE :A :B)
DEFAULT STRING
DEFAULT (VECTOR :A)
DEFAULT (LIST :A)
DEFAULT (OPTIONAL :A)
(DEFAULT :A) (DEFAULT :B) (DEFAULT :C) (DEFAULT :D) (DEFAULT :E) ⇒ DEFAULT (TUPLE5 :A :B :C :D :E)
(DEFAULT :A) (DEFAULT :B) (DEFAULT :C) (DEFAULT :D) ⇒ DEFAULT (TUPLE4 :A :B :C :D)
(DEFAULT :A) (DEFAULT :B) (DEFAULT :C) ⇒ DEFAULT (TUPLE3 :A :B :C)
(DEFAULT :A) (DEFAULT :B) ⇒ DEFAULT (TUPLE :A :B)
DEFAULT :A ⇒ DEFAULT (CELL :A)
DEFAULT F64
DEFAULT F32
DEFAULT INTEGER
DEFAULT UFIX
DEFAULT IFIX
DEFAULT U64
DEFAULT U32
DEFAULT U16
DEFAULT I64
DEFAULT I32
DEFAULT I16
DEFAULT U8
DEFAULT I8
DEFAULT BIT
DEFAULT SYMBOL
DEFAULT BOOLEAN
DEFAULT HASH

`EQ` ^{_{[CLASS] · src}}

EQ :A

Types which have equality defined.

Methods:

== :: (:A → :A → BOOLEAN)

Instances

EQ CREAL
EQ BIG-FLOAT
EQ PATHNAME
EQ :A ⇒ EQ (SEQ :A)
(EQ :A) (EQ :B) ⇒ EQ (ORDMAP :A :B)
EQ :A ⇒ EQ (MAPPAIR :A :B)
EQ COLOR
EQ :A ⇒ EQ (TREE :A)
EQ :A ⇒ EQ (QUEUE :A)
(EQ :A) (EQ :B) ⇒ EQ (HASHMAP :A :B)
(HASH :A) (EQ :B) ⇒ EQ (HASHTABLE :A :B)
EQ :A ⇒ EQ (SLICE :A)
EQ STRING
EQ CHAR
EQ :A ⇒ EQ (VECTOR :A)
EQ :A ⇒ EQ (LIST :A)
EQ :A ⇒ EQ (LISPARRAY :A)
(EQ :A) (EQ :B) ⇒ EQ (RESULT :A :B)
EQ :A ⇒ EQ (OPTIONAL :A)
(EQ :A) (EQ :B) (EQ :C) (EQ :D) (EQ :E) ⇒ EQ (TUPLE5 :A :B :C :D :E)
(EQ :A) (EQ :B) (EQ :C) (EQ :D) ⇒ EQ (TUPLE4 :A :B :C :D)
(EQ :A) (EQ :B) (EQ :C) ⇒ EQ (TUPLE3 :A :B :C)
(EQ :A) (EQ :B) ⇒ EQ (TUPLE :A :B)
EQ :A ⇒ EQ (CELL :A)
EQ :A ⇒ EQ (HYPERDUAL :A)
EQ :A ⇒ EQ (DUAL :A)
Note: Eq only compares the primal component.
EQ DYADIC
COMPLEXCOMPONENT :A ⇒ EQ (COMPLEX :A)
EQ FRACTION
EQ F64
EQ F32
EQ U64
EQ I64
EQ U32
EQ I32
EQ U16
EQ I16
EQ U8
EQ I8
EQ BIT
EQ UFIX
EQ IFIX
EQ INTEGER
EQ SYMBOL
EQ BOOLEAN
EQ HASH
EQ ORD
EQ UNIT
EQ LISPTYPE

`FOLDABLE` ^{_{[CLASS] · src}}

FOLDABLE :A

Types which can be folded into a single element.

Methods:

FOLD :: ((:B → :C → :B) → :B → (:A :C) → :B)
A left tail-recursive fold.
FOLDR :: ((:D → :E → :E) → :E → (:A :D) → :E)
A right non-tail-recursive fold.

Instances

FOLDABLE TREE
FOLDABLE :A ⇒ FOLDABLE (FREE :A)
FOLDABLE QUEUE
FOLDABLE SLICE
FOLDABLE VECTOR
FOLDABLE LIST
FOLDABLE LISPARRAY

`FUNCTOR` ^{_{[CLASS] · src}}

FUNCTOR :A

Types which can map an inner type where the mapping adheres to the identity and composition laws.

Methods:

MAP :: ((:B → :C) → (:A :B) → (:A :C))

Instances

FUNCTOR SEQ
FUNCTOR (ORDMAP :A)
(FUNCTOR :A) (FUNCTOR :B) ⇒ FUNCTOR ((FREET :A) :B)
FUNCTOR :A ⇒ FUNCTOR ((FREEF :A) :B)
FUNCTOR :A ⇒ FUNCTOR (FREE :A)
FUNCTOR :A ⇒ FUNCTOR (OPTIONALT :A)
FUNCTOR :A ⇒ FUNCTOR ((RESULTT :B) :A)
FUNCTOR :A ⇒ FUNCTOR ((ENVT :B) :A)
FUNCTOR (ENV :A)
FUNCTOR :A ⇒ FUNCTOR ((STATET :B) :A)
FUNCTOR (ST :A)
FUNCTOR IDENTITY
FUNCTOR QUEUE
FUNCTOR VECTOR
FUNCTOR LIST
FUNCTOR (RESULT :A)
FUNCTOR OPTIONAL
FUNCTOR ITERATOR
FUNCTOR CELL
FUNCTOR (ARROW :A)

`HASH` ^{_{[CLASS] · src}}

EQ :A ⇒ HASH :A

Types which can be hashed for storage in hash tables.

The hash function must satisfy the invariant that (== left right) implies (== (hash left) (hash right)).

Methods:

HASH :: (:A → HASH)

Instances

(HASH :A) (HASH :B) ⇒ HASH (ORDMAP :A :B)
HASH :A ⇒ HASH (TREE :A)
(HASH :A) (HASH :B) ⇒ HASH (HASHMAP :A :B)
(HASH :A) (HASH :B) ⇒ HASH (HASHTABLE :A :B)
HASH STRING
HASH CHAR
HASH :A ⇒ HASH (LIST :A)
(HASH :A) (HASH :B) (HASH :C) (HASH :D) (HASH :E) ⇒ HASH (TUPLE5 :A :B :C :D :E)
(HASH :A) (HASH :B) (HASH :C) (HASH :D) ⇒ HASH (TUPLE4 :A :B :C :D)
(HASH :A) (HASH :B) (HASH :C) ⇒ HASH (TUPLE3 :A :B :C)
(HASH :A) (HASH :B) ⇒ HASH (TUPLE :A :B)
HASH :A ⇒ HASH (HYPERDUAL :A)
HASH :A ⇒ HASH (DUAL :A)
Note: Hash only considers the primal component in order to be consistent with Eq.
HASH F64
HASH F32
HASH UFIX
HASH IFIX
HASH U64
HASH U32
HASH U16
HASH U8
HASH BIT
HASH I64
HASH I32
HASH I16
HASH I8
HASH INTEGER
HASH BOOLEAN
HASH HASH

`INTO` ^{_{[CLASS] · src}}

INTO :A :B

INTO imples every element of :a can be represented by an element of :b. This conversion might not be bijective (i.e., there may be elements in :b that don’t correspond to any in :a).

Methods:

INTO :: (:A → :B)

Instances

INTO I8 CREAL
INTO U8 CREAL
INTO I16 CREAL
INTO U16 CREAL
INTO I32 CREAL
INTO U32 CREAL
INTO I64 CREAL
INTO U64 CREAL
INTO IFIX CREAL
INTO UFIX CREAL
INTO INTEGER CREAL
INTO FRACTION CREAL
INTO F64 CREAL
INTO F32 CREAL
(COMPLEXCOMPONENT :A) (INTO :A CREAL) ⇒ INTO (COMPLEX :A) (COMPLEX CREAL)
INTO F64 BIG-FLOAT
INTO F32 BIG-FLOAT
INTO FRACTION BIG-FLOAT
INTO INTEGER BIG-FLOAT
INTO PATHNAME STRING
INTO STRING PATHNAME
INTO (SEQ :A) (VECTOR :A)
INTO (SEQ :A) (LIST :A)
(FOLDABLE :A) (RUNTIMEREPR :B) ⇒ INTO (:A :B) (SEQ :B)
INTO (MAPPAIR :A :B) (TUPLE :A :B)
INTO (VECTOR :A) (SLICE :A)
INTO (SLICE :A) (VECTOR :A)
INTO F64 STRING
INTO F32 STRING
INTO FRACTION STRING
INTO U64 STRING
INTO I64 STRING
INTO U32 STRING
INTO I32 STRING
INTO U16 STRING
INTO I16 STRING
INTO U8 STRING
INTO I8 STRING
INTO UFIX STRING
INTO IFIX STRING
INTO INTEGER STRING
INTO (VECTOR CHAR) STRING
INTO (LIST CHAR) STRING
INTO CHAR STRING
INTO STRING (VECTOR CHAR)
INTO STRING (LIST CHAR)
INTO (VECTOR :A) (LIST :A)
INTO (LIST :A) (VECTOR :A)
INTO (OPTIONAL :A) (LIST :A)
INTO (LISPARRAY :A) (LIST :A)
RUNTIMEREPR :A ⇒ INTO (LIST :A) (LISPARRAY :A)
INTO (OPTIONAL :A) (RESULT UNIT :A)
INTO (RESULT :A :B) (OPTIONAL :B)
INTO (TUPLE :A :B) (TUPLE :B :A)
INTO :A STRING ⇒ INTO (CELL :A) STRING
INTO (CELL :A) :A
INTO :A (CELL :A)
(COMPLEXCOMPONENT :A) (INTO :A (HYPERDUAL :A)) ⇒ INTO (COMPLEX :A) (COMPLEX (HYPERDUAL :A))
NUM :A ⇒ INTO :A (HYPERDUAL :A)
INTO INTEGER DYADIC
INTO DYADIC FRACTION
COMPLEXCOMPONENT :A ⇒ INTO :A (COMPLEX :A)
INTO UFIX FRACTION
INTO U64 FRACTION
INTO U32 FRACTION
INTO U16 FRACTION
INTO U8 FRACTION
INTO BIT FRACTION
INTO IFIX FRACTION
INTO I64 FRACTION
INTO I32 FRACTION
INTO I16 FRACTION
INTO I8 FRACTION
INTO INTEGER FRACTION
INTO I32 F64
INTO U32 F64
INTO I16 F64
INTO U16 F64
INTO I8 F64
INTO U8 F64
INTO BIT F64
INTO I16 F32
INTO U16 F32
INTO I8 F32
INTO U8 F32
INTO BIT F32
INTO IFIX INTEGER
INTO IFIX I64
INTO UFIX INTEGER
INTO UFIX IFIX
INTO UFIX I64
INTO UFIX U64
INTO I64 INTEGER
INTO U64 INTEGER
INTO I32 INTEGER
INTO I32 IFIX
INTO I32 I64
INTO U32 INTEGER
INTO U32 IFIX
INTO U32 UFIX
INTO U32 I64
INTO U32 U64
INTO I16 INTEGER
INTO I16 IFIX
INTO I16 I64
INTO I16 I32
INTO U16 INTEGER
INTO U16 IFIX
INTO U16 UFIX
INTO U16 I64
INTO U16 U64
INTO U16 I32
INTO U16 U32
INTO I8 INTEGER
INTO I8 IFIX
INTO I8 I64
INTO I8 I32
INTO I8 I16
INTO U8 INTEGER
INTO U8 IFIX
INTO U8 UFIX
INTO U8 I64
INTO U8 U64
INTO U8 I32
INTO U8 U32
INTO U8 I16
INTO U8 U16
INTO BIT INTEGER
INTO BIT IFIX
INTO BIT UFIX
INTO BIT I64
INTO BIT U64
INTO BIT I32
INTO BIT U32
INTO BIT I16
INTO BIT U16
INTO BIT I8
INTO BIT U8
INTO :A :A

`ISO` ^{_{[CLASS] · src}}

(INTO :A :B) (INTO :B :A) ⇒ ISO :A :B

Opting into this marker typeclass imples that the instances for (Into :a :b) and (Into :b :a) form a bijection.

Methods:

Instances

ISO (SLICE :A) (VECTOR :A)
ISO (LIST CHAR) STRING
ISO (VECTOR :A) (LIST :A)
RUNTIMEREPR :A ⇒ ISO (LISPARRAY :A) (LIST :A)
ISO (RESULT UNIT :A) (OPTIONAL :A)
ISO (TUPLE :A :B) (TUPLE :B :A)
ISO :A :A

`MONAD` ^{_{[CLASS] · src}}

APPLICATIVE :A ⇒ MONAD :A

Types which are monads as defined in Haskell. See https://wiki.haskell.org/Monad for more information.

Methods:

>>= :: ((:A :B) → (:B → (:A :C)) → (:A :C))

Instances

(FUNCTOR :A) (MONAD :B) ⇒ MONAD ((FREET :A) :B)
FUNCTOR :A ⇒ MONAD (FREE :A)
MONAD :A ⇒ MONAD (OPTIONALT :A)
MONAD :A ⇒ MONAD ((RESULTT :B) :A)
MONAD :A ⇒ MONAD ((ENVT :B) :A)
MONAD (ENV :A)
MONAD :A ⇒ MONAD ((STATET :B) :A)
MONAD (ST :A)
MONAD IDENTITY
MONAD LIST
MONAD (RESULT :A)
MONAD OPTIONAL
MONAD (ARROW :A)

`MONADFAIL` ^{_{[CLASS] · src}}

MONAD :A ⇒ MONADFAIL :A

Methods:

FAIL :: (STRING → (:A :B))

Instances

MONADFAIL OPTIONAL

`MONADTRANSFORMER` ^{_{[CLASS] · src}}

MONADTRANSFORMER :A

Types which are monads that wrap another monad, allowing you to use - for example - State and Result together.

Methods:

LIFT :: MONAD :B ⇒ ((:B :C) → ((:A :B) :C))

Instances

FUNCTOR :A ⇒ MONADTRANSFORMER (FREET :A)
MONADTRANSFORMER OPTIONALT
MONADTRANSFORMER (RESULTT :A)
MONADTRANSFORMER (ENVT :A)
MONADTRANSFORMER (STATET :A)

`MONOID` ^{_{[CLASS] · src}}

SEMIGROUP :A ⇒ MONOID :A

Types with an associative binary operation and identity defined.

Methods:

MEMPTY :: :A

Instances

MONOID PATHNAME
RUNTIMEREPR :A ⇒ MONOID (SEQ :A)
ORD :A ⇒ MONOID (TREE :A)
MONOID STRING
MONOID (VECTOR :A)
MONOID (LIST :A)
MONOID :A ⇒ MONOID (RESULT :B :A)
MONOID :A ⇒ MONOID (OPTIONAL :A)
MONOID HASH

`NUM` ^{_{[CLASS] · src}}

EQ :A ⇒ NUM :A

Types which have numeric operations defined.

Methods:

+ :: (:A → :A → :A)
- :: (:A → :A → :A)
* :: (:A → :A → :A)
FROMINT :: (INTEGER → :A)

Instances

NUM CREAL
NUM BIG-FLOAT
NUM :A ⇒ NUM (CELL :A)
NUM :A ⇒ NUM (HYPERDUAL :A)
NUM :A ⇒ NUM (DUAL :A)
NUM DYADIC
COMPLEXCOMPONENT :A ⇒ NUM (COMPLEX :A)
NUM FRACTION
NUM F64
NUM F32
NUM UFIX
NUM BIT
NUM U64
NUM U32
NUM U16
NUM U8
NUM IFIX
NUM I64
NUM I32
NUM I16
NUM I8
NUM INTEGER

`ORD` ^{_{[CLASS] · src}}

EQ :A ⇒ ORD :A

Types whose values can be ordered. Requires Eq.

Methods:

<=> :: (:A → :A → ORD)
Given two objects, return their comparison (as an Ord object).

Instances

ORD CREAL
ORD BIG-FLOAT
ORD PATHNAME
ORD :A ⇒ ORD (MAPPAIR :A :B)
ORD STRING
ORD CHAR
ORD :A ⇒ ORD (LIST :A)
(ORD :A) (ORD :B) ⇒ ORD (RESULT :A :B)
ORD :A ⇒ ORD (OPTIONAL :A)
(ORD :A) (ORD :B) ⇒ ORD (TUPLE :A :B)
ORD :A ⇒ ORD (CELL :A)
ORD :A ⇒ ORD (HYPERDUAL :A)
ORD :A ⇒ ORD (DUAL :A)
Note: Ord only compares the primal component.
ORD DYADIC
ORD FRACTION
ORD F64
ORD F32
ORD U64
ORD I64
ORD U32
ORD I32
ORD U16
ORD I16
ORD U8
ORD I8
ORD BIT
ORD UFIX
ORD IFIX
ORD INTEGER
ORD BOOLEAN
ORD HASH
ORD ORD

`SEMIGROUP` ^{_{[CLASS] · src}}

SEMIGROUP :A

Types with an associative binary operation defined.

Methods:

<> :: (:A → :A → :A)

Instances

SEMIGROUP PATHNAME
RUNTIMEREPR :A ⇒ SEMIGROUP (SEQ :A)
ORD :A ⇒ SEMIGROUP (ORDMAP :A :B)
ORD :A ⇒ SEMIGROUP (TREE :A)
SEMIGROUP (QUEUE :A)
SEMIGROUP STRING
SEMIGROUP (VECTOR :A)
SEMIGROUP (LIST :A)
SEMIGROUP :A ⇒ SEMIGROUP (RESULT :B :A)
SEMIGROUP :A ⇒ SEMIGROUP (OPTIONAL :A)
SEMIGROUP :A ⇒ SEMIGROUP (CELL :A)
SEMIGROUP HASH

`SIGNALABLE` ^{_{[CLASS] · src}}

SIGNALABLE :A

Signals errors or warnings by calling their respective lisp conditions.

Methods:

ERROR :: (:A → :B)
Signal an error with a type-specific error string.

Instances

SIGNALABLE FILEERROR
SIGNALABLE LISPCONDITION
SIGNALABLE STRING

`TRAVERSABLE` ^{_{[CLASS] · src}}

TRAVERSABLE :A

Methods:

TRAVERSE :: APPLICATIVE :B ⇒ ((:C → (:B :D)) → (:A :C) → (:B (:A :D)))

Instances

(MONAD :A) (TRAVERSABLE :A) (TRAVERSABLE :B) ⇒ TRAVERSABLE ((FREET :B) :A)
TRAVERSABLE :A ⇒ TRAVERSABLE ((FREEF :A) :B)
TRAVERSABLE :A ⇒ TRAVERSABLE (FREE :A)
TRAVERSABLE LIST
TRAVERSABLE (RESULT :A)
TRAVERSABLE OPTIONAL

`TRYINTO` ^{_{[CLASS] · src}}

TRYINTO :A :B :C

TRY-INTO implies some elements of :a can be represented exactly by an element of :b, but sometimes not. If not, an error of type :c is returned.

Methods:

TRYINTO :: (:A → (RESULT :C :B))

Instances

TRYINTO STRING INTEGER STRING
TRYINTO UFIX F64 STRING
TRYINTO IFIX F64 STRING
TRYINTO U64 F64 STRING
TRYINTO I64 F64 STRING
TRYINTO I32 F32 STRING
TRYINTO U32 F32 STRING
TRYINTO UFIX F32 STRING
TRYINTO IFIX F32 STRING
TRYINTO U64 F32 STRING
TRYINTO I64 F32 STRING
TRYINTO INTEGER F64 STRING
TRYINTO INTEGER F32 STRING
TRYINTO INTEGER IFIX STRING
TRYINTO INTEGER UFIX STRING
TRYINTO INTEGER I64 STRING
TRYINTO INTEGER U64 STRING
TRYINTO INTEGER I32 STRING
TRYINTO INTEGER U32 STRING
TRYINTO INTEGER I16 STRING
TRYINTO INTEGER U16 STRING
TRYINTO INTEGER I8 STRING
TRYINTO INTEGER U8 STRING
TRYINTO INTEGER BIT STRING
TRYINTO IFIX UFIX STRING
TRYINTO IFIX U64 STRING
TRYINTO IFIX I32 STRING
TRYINTO IFIX U32 STRING
TRYINTO IFIX I16 STRING
TRYINTO IFIX U16 STRING
TRYINTO IFIX I8 STRING
TRYINTO IFIX U8 STRING
TRYINTO IFIX BIT STRING
TRYINTO UFIX I32 STRING
TRYINTO UFIX U32 STRING
TRYINTO UFIX I16 STRING
TRYINTO UFIX U16 STRING
TRYINTO UFIX I8 STRING
TRYINTO UFIX U8 STRING
TRYINTO UFIX BIT STRING
TRYINTO I64 IFIX STRING
TRYINTO I64 UFIX STRING
TRYINTO I64 U64 STRING
TRYINTO I64 I32 STRING
TRYINTO I64 U32 STRING
TRYINTO I64 I16 STRING
TRYINTO I64 U16 STRING
TRYINTO I64 I8 STRING
TRYINTO I64 U8 STRING
TRYINTO I64 BIT STRING
TRYINTO U64 IFIX STRING
TRYINTO U64 UFIX STRING
TRYINTO U64 I64 STRING
TRYINTO U64 I32 STRING
TRYINTO U64 U32 STRING
TRYINTO U64 I16 STRING
TRYINTO U64 U16 STRING
TRYINTO U64 I8 STRING
TRYINTO U64 U8 STRING
TRYINTO U64 BIT STRING
TRYINTO I32 UFIX STRING
TRYINTO I32 U64 STRING
TRYINTO I32 U32 STRING
TRYINTO I32 I16 STRING
TRYINTO I32 U16 STRING
TRYINTO I32 I8 STRING
TRYINTO I32 U8 STRING
TRYINTO I32 BIT STRING
TRYINTO U32 I32 STRING
TRYINTO U32 I16 STRING
TRYINTO U32 U16 STRING
TRYINTO U32 I8 STRING
TRYINTO U32 U8 STRING
TRYINTO U32 BIT STRING
TRYINTO I16 UFIX STRING
TRYINTO I16 U64 STRING
TRYINTO I16 U32 STRING
TRYINTO I16 U16 STRING
TRYINTO I16 I8 STRING
TRYINTO I16 U8 STRING
TRYINTO I16 BIT STRING
TRYINTO U16 I16 STRING
TRYINTO U16 I8 STRING
TRYINTO U16 U8 STRING
TRYINTO U16 BIT STRING
TRYINTO I8 UFIX STRING
TRYINTO I8 U64 STRING
TRYINTO I8 U32 STRING
TRYINTO I8 U16 STRING
TRYINTO I8 U8 STRING
TRYINTO I8 BIT STRING
TRYINTO U8 I8 STRING
TRYINTO U8 BIT STRING
TRYINTO F64 FRACTION STRING
TRYINTO F32 FRACTION STRING

`UNWRAPPABLE` ^{_{[CLASS] · src}}

UNWRAPPABLE :A

Containers which can be unwrapped to get access to their contents.

(unwrap-or-else succeed fail container) should invoke the succeed continuation on the unwrapped contents of container when successful, or invoke the fail continuation with no arguments (i.e., with Unit as an argument) when unable to unwrap a value.

The succeed continuation will often, but not always, be the identity function. as-optional passes Some to construct an Optional.

Typical fail continuations are:

Return a default value, or
Signal an error.

Methods:

UNWRAP-OR-ELSE :: ((:B → :C) → (UNIT → :C) → (:A :B) → :C)

Instances

UNWRAPPABLE OPTIONAL
UNWRAPPABLE (RESULT :A)

Values

`(< X Y)` ^{_{[FUNCTION] · src}}

∀ :A. ORD :A ⇒ (:A → :A → BOOLEAN)

Is x less than y?

`(<= X Y)` ^{_{[FUNCTION] · src}}

∀ :A. ORD :A ⇒ (:A → :A → BOOLEAN)

Is x less than or equal to y?

`(> X Y)` ^{_{[FUNCTION] · src}}

∀ :A. ORD :A ⇒ (:A → :A → BOOLEAN)

Is x greater than y?

`(>= X Y)` ^{_{[FUNCTION] · src}}

∀ :A. ORD :A ⇒ (:A → :A → BOOLEAN)

Is x greater than or equal to y?

`(>> A B)` ^{_{[FUNCTION] · src}}

∀ :A :B :C. MONAD :A ⇒ ((:A :B) → (:A :C) → (:A :C))

Equivalent to (>>= a (fn (_) b)).

`(AS-OPTIONAL CONTAINER)` ^{_{[FUNCTION] · src}}

∀ :A :B. UNWRAPPABLE :A ⇒ ((:A :B) → (OPTIONAL :B))

Convert any Unwrappable container into an Optional, constructing Some on a successful unwrap and None on a failed unwrap.

`(DEFAULT? X)` ^{_{[FUNCTION] · src}}

∀ :A. (DEFAULT :A) (EQ :A) ⇒ (:A → BOOLEAN)

Is x the default item of its type?

`(DEFAULTING-UNWRAP CONTAINER)` ^{_{[FUNCTION] · src}}

∀ :A :B. (UNWRAPPABLE :A) (DEFAULT :B) ⇒ ((:A :B) → :B)

Unwrap an unwrappable, returning (default) of the wrapped type on failure.

`(EXPECT REASON CONTAINER)` ^{_{[FUNCTION] · src}}

∀ :A :B. UNWRAPPABLE :A ⇒ (STRING → (:A :B) → :B)

Unwrap container, signaling an error with the description reason on failure.

`(JOIN M)` ^{_{[FUNCTION] · src}}

∀ :A :B. MONAD :A ⇒ ((:A (:A :B)) → (:A :B))

Equivalent to (>>= m id).

`(MAP-FST F B)` ^{_{[FUNCTION] · src}}

∀ :A :B :C :D. BIFUNCTOR :C ⇒ ((:A → :B) → (:C :A :D) → (:C :B :D))

Map over the first argument of a Bifunctor.

`(MAP-SND F B)` ^{_{[FUNCTION] · src}}

∀ :A :B :C :D. BIFUNCTOR :C ⇒ ((:A → :B) → (:C :D :A) → (:C :D :B))

Map over the second argument of a Bifunctor.

`(MAX X Y)` ^{_{[FUNCTION] · src}}

∀ :A. ORD :A ⇒ (:A → :A → :A)

Returns the greater element of x and y.

`(MCOMMUTE? A B)` ^{_{[FUNCTION] · src}}

∀ :A. (EQ :A) (SEMIGROUP :A) ⇒ (:A → :A → BOOLEAN)

Does a <> b equal b <> a?

`(MCONCAT A)` ^{_{[FUNCTION] · src}}

∀ :A :B. (FOLDABLE :A) (MONOID :B) ⇒ ((:A :B) → :B)

Fold a container of monoids into a single element.

`(MCONCATMAP F A)` ^{_{[FUNCTION] · src}}

∀ :A :B :C. (FOLDABLE :C) (MONOID :B) ⇒ ((:A → :B) → (:C :A) → :B)

Map a container to a container of monoids, and then fold that container into a single element.

`(MEMPTY? A)` ^{_{[FUNCTION] · src}}

∀ :A. (EQ :A) (MONOID :A) ⇒ (:A → BOOLEAN)

Does a equal (the Type mempty)?

`(MIN X Y)` ^{_{[FUNCTION] · src}}

∀ :A. ORD :A ⇒ (:A → :A → :A)

Returns the lesser element of x and y.

`(SEQUENCE)` ^{_{[FUNCTION] · src}}

∀ :A :B :C. (TRAVERSABLE :A) (APPLICATIVE :B) ⇒ ((:A (:B :C)) → (:B (:A :C)))

`(UNWRAP CONTAINER)` ^{_{[FUNCTION] · src}}

∀ :A :B. UNWRAPPABLE :A ⇒ ((:A :B) → :B)

Unwrap container, signaling an error on failure.

`(UNWRAP-INTO X)` ^{_{[FUNCTION] · src}}

∀ :A :B :C. TRYINTO :B :C :A ⇒ (:B → :C)

Same as tryInto followed by unwrap.

`(WITH-DEFAULT DEFAULT CONTAINER)` ^{_{[FUNCTION] · src}}

∀ :A :B. UNWRAPPABLE :B ⇒ (:A → (:B :A) → :A)

Unwrap container, returning default on failure.

Package `COALTON-LIBRARY/COMPUTABLE-REALS`

Types

`CREAL` ^{_{[TYPE] · src}}

Instances

COMPLEXCOMPONENT CREAL
DIVIDABLE INTEGER CREAL
ELEMENTARY CREAL
EQ CREAL
EXPONENTIABLE CREAL
INTO F32 CREAL
INTO F64 CREAL
INTO FRACTION CREAL
INTO I16 CREAL
INTO I32 CREAL
INTO I64 CREAL
INTO I8 CREAL
INTO IFIX CREAL
INTO INTEGER CREAL
INTO U16 CREAL
INTO U32 CREAL
INTO U64 CREAL
INTO U8 CREAL
INTO UFIX CREAL
NUM CREAL
ORD CREAL
POLAR CREAL
QUANTIZABLE CREAL
RADICAL CREAL
REAL CREAL
RECIPROCABLE CREAL
RUNTIMEREPR CREAL
TRIGONOMETRIC CREAL

Values

`(APPROX X K)` ^{_{[FUNCTION] · src}}

(CREAL → UFIX → INTEGER)

Computes an approximation of the bits of a given CReal. Specifically, given an object of type CReal x and a non-negative integer k, return an integer $a$ with

$$ \vert a\cdot 2^{-\mathtt{k}} - \mathtt{x}\vert \leq 2^{-\mathtt{k}}. $$

See rational or rationalize to produce a rational approximation of CReal.

`(COMPARISON-THRESHOLD _)` ^{_{[FUNCTION] · src}}

∀ :A. (:A → UFIX)

Returns the current CReal comparison threshold measured as a number of bits after the ‘decimal’ point.

This threshold is used to ensure Eq and Ord instances terminate. (In general, computable real arithmetic is undecidable.) Note that if the production of a CReal depends on comparison, there is no guarantee that the CReal will be accurate to any precision.

`(CR-PRINT X K)` ^{_{[FUNCTION] · src}}

(CREAL → UFIX → BOOLEAN)

Prints a real x up to k bits of precision.

`(RATIONAL-APPROX X K)` ^{_{[FUNCTION] · src}}

(CREAL → UFIX → FRACTION)

Produce a rational approximation of x called $r$ such that

$$ \vert r - \mathtt{x} \vert < 2^{-\mathtt{k}}. $$

`(RATIONALIZE X K)` ^{_{[FUNCTION] · src}}

(CREAL → UFIX → FRACTION)

Produce a rational approximation of x called $r$ such that

$$ \vert r - \mathtt{x} \vert < 2^{-\mathtt{k}}, $$

taking into account the maximum precision specified by k to return the simplest possible such approximation.

`(SET-COMPARISON-THRESHOLD! K)` ^{_{[FUNCTION] · src}}

∀ :A. (:A → UNIT)

Sets the global CReal comparison threshold to k bits after the ‘decimal’ point.

See comparison-threshold for more details.

Package `COALTON-LIBRARY/EXPERIMENTAL/LOOPS`

A Coalton package of loop macros.

Note: (return), (break), and (continue) do not work inside any of these loop macros.

Macros

`ARGBESTTIMES ((VARIABLE COUNT BETTER?) &BODY BODY)` ^_[MACRO]

The UFix in [0, count) which, when variable is bound to it, results in the evaluation of body which is better than the same for the rest of the UFixs in [0, count).

`BESTTIMES ((VARIABLE COUNT BETTER?) &BODY BODY)` ^_[MACRO]

The result of evaluating body with variable bound to a UFix in [0, count) that is better? than the result of evaluating body with variable bound to the rest of the UFixs in [0, count)..

`COLLECTTIMES ((VARIABLE COUNT) &BODY BODY)` ^_[MACRO]

Collect the results of evaluating body for variable bound to every UFix in [0, count) as a List.

`DOLIST ((VARIABLE LIS) &BODY BODY)` ^_[MACRO]

Perform body with variable bound to every element of lis.

`DOLIST-ENUMERATED ((INDEX-VARIABLE ELEMENT-VARIABLE LIS) &BODY BODY)` ^_[MACRO]

Perform body with element-variable bound to the elements of lis and index-variable bound to their indices.

`DOLISTS (VARIABLES-AND-LISTS &BODY BODY)` ^_[MACRO]

Perform body with the variables bound to the elements of the lists. See the example below.

Example:

> (coalton (dolists ((x (make-list 1 2 3))
                     (y (make-list 10 20 30))
                     (z (make-list 100 200 300 400)))
             (print (+ x (+ y z))))
111
222
333
COALTON::UNIT/UNIT

`DORANGE ((VARIABLE START-OR-STOP &OPTIONAL STOP STEP) &BODY BODY)` ^_[MACRO]

Perform body with variable bound to elements of a discrete range.

If only start-or-stop is supplied, then the range is from 0 (inclusive) to start-or-stop (exclusive) by increments or decrements of 1.

> (coalton (dorange (x 3) (print x)))
0
1
2
COALTON::UNIT/UNIT
> (coalton (dorange (x -3) (print x)))
0
-1
-2
COALTON::UNIT/UNIT

If only start-or-stop and stop are supplied, then the range is from start-or-stop (inclusive) to stop (exclusive) by increments or decrements of 1.

> (coalton (dorange (x -2 2) (print x)))
-2 
-1
0
1
COALTON::UNIT/UNIT
> (coalton (dorange (x 0.5 -2) (print x)))
0.5
-0.5
-1.5
COALTON::UNIT/UNIT

Otherwise, the range is from start-or-stop (inclusive) to stop (exclusive) by step. step must be the correct sign, or dorange does nothing.

> (coalton (dorange -2 2 2) (print x))
-2 
0
COALTON::UNIT/UNIT
> (coalton (dorange -2 2 -1) (print x))
COALTON::UNIT/UNIT

`DOTIMES ((VARIABLE COUNT) &BODY BODY)` ^_[MACRO]

Perform body with variable bound to every UFix in [0, count) sequentially.

`EVERYTIMES ((VARIABLE COUNT) &BODY BODY)` ^_[MACRO]

Does body evaluate to True for variable bound to every UFix in [0, count). Returns True if (zero? count).

`PRODTIMES ((VARIABLE COUNT) &BODY BODY)` ^_[MACRO]

The product of body for variable bount to every UFix in [0, count).

`REPEAT ((COUNT) &BODY BODY)` ^_[MACRO]

Perform body count times.

`SOMETIMES ((VARIABLE COUNT) &BODY BODY)` ^_[MACRO]

Does body evaluate to True for variable bound to some UFix in [0, count). Returns False if (zero? count).

`SUMTIMES ((VARIABLE COUNT) &BODY BODY)` ^_[MACRO]

The sum of body for variable bount to every UFix in [0, count).

Package `COALTON-LIBRARY/FILE`

This is Coalton’s library for directory utilities and file IO.

Most functions return outputs of type (Result FileError :a), ensuring that errors can be assessed and handled.

File IO is handled using stream options, for instance:

(with-open-file (Bidirectional file EError)
  (fn (stream)
    (write-string stream "Hello World!")
    (read-file-to-vector stream)

Common Lisp makes a distinction between file and directory paths. Directory paths are always terminated with a trailing slash, file paths must never have a trailing slash.

Types

`FILEERROR` ^{_{[TYPE] · src}}

(PATHERROR STRING PATHNAME)
(LISPERROR LISPCONDITION)
(FILEERROR STRING)
EOF

Errors for file functions.

Instances

RUNTIMEREPR FILEERROR
SIGNALABLE FILEERROR

`FILESTREAM` ^{_{[TYPE] · src}}

Represents a file stream, using cl:file-stream.

Instances

RUNTIMEREPR (FILESTREAM :A)

`IFEXISTS` ^{_{[TYPE] · src}}

SUPERSEDE
OVERWRITE
EERROR
APPEND

Possible options for opening a stream when the file exists.

Instances

RUNTIMEREPR IFEXISTS

`PATHNAME` ^{_{[TYPE] · src}}

Pathname object. Equivalent to cl:pathname

Instances

EQ PATHNAME
INTO PATHNAME STRING
INTO STRING PATHNAME
MONOID PATHNAME
ORD PATHNAME
RUNTIMEREPR PATHNAME
SEMIGROUP PATHNAME

`STREAMOPTIONS` ^{_{[TYPE] · src}}

(BIDIRECTIONAL PATHNAME IFEXISTS)
- Constructor for opening a bidirectional stream.
(OUTPUT PATHNAME IFEXISTS)
- Constructor for opening an output stream.
(INPUT PATHNAME)
- Constructor for opening an input stream

A type for providing parameters for opening streams. StreamOptions take strings for pathnames, but they will error if they are not proper and appropriate pathnames.

Instances

RUNTIMEREPR STREAMOPTIONS

Classes

`FILE` ^{_{[CLASS] · src}}

FILE :A

A class of types which are able to be written to or read from a file.

Methods:

OPEN :: (STREAMOPTIONS → (RESULT FILEERROR (FILESTREAM :A)))
READ :: ((FILESTREAM :A) → (RESULT FILEERROR :A))
WRITE :: ((FILESTREAM :A) → :A → (RESULT FILEERROR UNIT))

Instances

FILE U64
FILE I64
FILE U32
FILE I32
FILE U16
FILE I16
FILE U8
FILE I8
FILE UFIX
FILE IFIX
FILE CHAR

Values

`(ABORT STREAM)` ^{_{[FUNCTION] · src}}

∀ :A :B. ((FILESTREAM :A) → (RESULT FILEERROR :B))

Closes a FileStream and aborts all operations..

`(APPEND-TO-FILE! PATH DATA)` ^{_{[FUNCTION] · src}}

∀ :A :B. (RUNTIMEREPR :B) (INTO :A PATHNAME) (FILE :B) ⇒ (:A → (VECTOR :B) → (RESULT FILEERROR UNIT))

Opens and appends a file with data of type :a.

`(CLOSE STREAM)` ^{_{[FUNCTION] · src}}

∀ :A :B. ((FILESTREAM :A) → (RESULT FILEERROR :B))

Closes a FileStream.

`(COPY! INPUT OUTPUT)` ^{_{[FUNCTION] · src}}

∀ :A :B. (INTO :A PATHNAME) (INTO :B PATHNAME) ⇒ (:A → :B → (RESULT FILEERROR UNIT))

Copies a file to a new location.

`(CREATE-DIRECTORY! PATH)` ^{_{[FUNCTION] · src}}

∀ :A. INTO :A PATHNAME ⇒ (:A → (RESULT FILEERROR PATHNAME))

This is equivalent to mkdir -p. Creates a directory and its parents. The pathname must be a valid directory pathname.

`(CREATE-TEMP-DIRECTORY! _)` ^{_{[FUNCTION] · src}}

(UNIT → (RESULT FILEERROR PATHNAME))

This configures a default temporary directory for use.

`(CREATE-TEMP-FILE! FILE-EXT)` ^{_{[FUNCTION] · src}}

(STRING → (RESULT FILEERROR PATHNAME))

This configures a default temporary file for use.

`(DELETE-FILE! PATH)` ^{_{[FUNCTION] · src}}

∀ :A. INTO :A PATHNAME ⇒ (:A → (RESULT FILEERROR UNIT))

Deletes a given file if the file exists.

`(DIRECTORY-EXISTS? PATH)` ^{_{[FUNCTION] · src}}

∀ :A. INTO :A PATHNAME ⇒ (:A → (RESULT FILEERROR BOOLEAN))

Returns True if a pathname names a directory that exists.

`(DIRECTORY-FILES PATH)` ^{_{[FUNCTION] · src}}

∀ :A. INTO :A PATHNAME ⇒ (:A → (RESULT FILEERROR (LIST PATHNAME)))

Returns all files within the directory. Returns an error if the pathname is not a directory pathname.

`(DIRECTORY-PATHNAME? PATH)` ^{_{[FUNCTION] · src}}

∀ :A. INTO :A PATHNAME ⇒ (:A → BOOLEAN)

Returns True if a pathname has no file component.

`(EMPTY? PATH)` ^{_{[FUNCTION] · src}}

∀ :A. INTO :A PATHNAME ⇒ (:A → (RESULT FILEERROR BOOLEAN))

Checks whether a directory is empty.

`(EXISTS? PATH)` ^{_{[FUNCTION] · src}}

∀ :A. INTO :A PATHNAME ⇒ (:A → (RESULT FILEERROR BOOLEAN))

Returns whether a file or directory exists.

`(FILE-EXISTS? PATH)` ^{_{[FUNCTION] · src}}

∀ :A. INTO :A PATHNAME ⇒ (:A → (RESULT FILEERROR BOOLEAN))

Returns True if a pathname names a file that exists.

`(FILE-PATHNAME? PATH)` ^{_{[FUNCTION] · src}}

∀ :A. INTO :A PATHNAME ⇒ (:A → BOOLEAN)

Returns True if a pathname has a file component.

`(FILE-POSITION STREAM)` ^{_{[FUNCTION] · src}}

∀ :A. ((FILESTREAM :A) → (RESULT FILEERROR UFIX))

Finds the file-position of a file stream.

`(FLUSH STREAM)` ^{_{[FUNCTION] · src}}

∀ :A :B. ((FILESTREAM :A) → (RESULT FILEERROR :B))

Blocks until stream has been flushed. Calls cl:finish-output.

`(MERGE PATH1 PATH2)` ^{_{[FUNCTION] · src}}

∀ :A :B. (INTO :A PATHNAME) (INTO :B PATHNAME) ⇒ (:A → :B → PATHNAME)

Merges two pathnames together. The directory pathname should be the first argument.

`(READ-CHAR STREAM)` ^{_{[FUNCTION] · src}}

((FILESTREAM CHAR) → (RESULT FILEERROR CHAR))

Reads a character from an FileStream.

`(READ-FILE-LINES PATH)` ^{_{[FUNCTION] · src}}

∀ :A. INTO :A PATHNAME ⇒ (:A → (RESULT FILEERROR (LIST STRING)))

Reads a file into lines, given a pathname or string.

`(READ-FILE-TO-STRING PATH)` ^{_{[FUNCTION] · src}}

∀ :A. INTO :A PATHNAME ⇒ (:A → (RESULT FILEERROR STRING))

Reads a file into a string, given a pathname string.

`(READ-FILE-TO-VECTOR STREAM)` ^{_{[FUNCTION] · src}}

∀ :A. FILE :A ⇒ ((FILESTREAM :A) → (RESULT FILEERROR (VECTOR :A)))

Reads a file into a vector of type :a.

`(READ-VECTOR STREAM CHUNK-SIZE)` ^{_{[FUNCTION] · src}}

∀ :A. FILE :A ⇒ ((FILESTREAM :A) → UFIX → (RESULT FILEERROR (VECTOR :A)))

Reads a chunk of a file into a vector of type :a.

`(REMOVE-DIRECTORY! PATH)` ^{_{[FUNCTION] · src}}

∀ :A. INTO :A PATHNAME ⇒ (:A → (RESULT FILEERROR :A))

Deletes an empty directory.

`(REMOVE-DIRECTORY-RECURSIVE! PATH)` ^{_{[FUNCTION] · src}}

∀ :A. INTO :A PATHNAME ⇒ (:A → (RESULT FILEERROR UNIT))

Deletes a target directory recursively. Equivalent to rm -r. Errors if the path is not a directory.

`(SET-FILE-POSITION STREAM I)` ^{_{[FUNCTION] · src}}

∀ :A. ((FILESTREAM :A) → UFIX → (RESULT FILEERROR UNIT))

Sets the file position of a file stream.

`(SUBDIRECTORIES PATH)` ^{_{[FUNCTION] · src}}

∀ :A. INTO :A PATHNAME ⇒ (:A → (RESULT FILEERROR (LIST PATHNAME)))

Returns all subdirectories within the directory. Returns an error if the pathname is not a directory pathname.

`(SYSTEM-RELATIVE-PATHNAME SYSTEM-NAME NAME)` ^{_{[FUNCTION] · src}}

∀ :A. INTO :A STRING ⇒ (:A → STRING → (RESULT FILEERROR PATHNAME))

Generates a system-relative-pathname for a given filename or path. This is a wrapper for asdf:system-relative-pathname. Name will likely be an empty string unless a subdirectory or filename is specified.

`(WITH-OPEN-FILE STREAM-OPTIONS THUNK)` ^{_{[FUNCTION] · src}}

∀ :A :B. FILE :A ⇒ (STREAMOPTIONS → ((FILESTREAM :A) → (RESULT FILEERROR :B)) → (RESULT FILEERROR :B))

Opens a file stream, performs thunk on it, then closes the stream.

`(WITH-TEMP-DIRECTORY THUNK)` ^{_{[FUNCTION] · src}}

∀ :A. ((PATHNAME → (RESULT FILEERROR :A)) → (RESULT FILEERROR :A))

Performs an operation thunk inside a temporary directory.

`(WITH-TEMP-FILE FILE-TYPE THUNK)` ^{_{[FUNCTION] · src}}

∀ :A :B. FILE :A ⇒ (STRING → ((FILESTREAM :A) → (RESULT FILEERROR :B)) → (RESULT FILEERROR :B))

Performs an operation thunk on a temporary file. File type extensions need to include ., like “.txt”.

`(WRITE-CHAR STREAM DATA)` ^{_{[FUNCTION] · src}}

((FILESTREAM CHAR) → CHAR → (RESULT FILEERROR UNIT))

Writes a Char to the stream.

`(WRITE-LINE STREAM S)` ^{_{[FUNCTION] · src}}

((FILESTREAM CHAR) → STRING → (RESULT FILEERROR UNIT))

Writes a string with an appended newline to a filestream of type Char.

`(WRITE-STRING FS S)` ^{_{[FUNCTION] · src}}

((FILESTREAM CHAR) → STRING → (RESULT FILEERROR UNIT))

Writes a string to a FileStream of type Char.

`(WRITE-TO-FILE! PATH DATA)` ^{_{[FUNCTION] · src}}

∀ :A :B. (RUNTIMEREPR :B) (INTO :A PATHNAME) (FILE :B) ⇒ (:A → (VECTOR :B) → (RESULT FILEERROR UNIT))

Opens and writes to a file with data of type :a. Supersedes existing data on the file.

`(WRITE-VECTOR STREAM V)` ^{_{[FUNCTION] · src}}

∀ :A. (RUNTIMEREPR :A) (FILE :A) ⇒ ((FILESTREAM :A) → (VECTOR :A) → (RESULT FILEERROR UNIT))

Writes elements of an vector of type :a to a stream of type :a.

Package `COALTON-LIBRARY/FUNCTIONS`

Values

`(/= A B)` ^{_{[FUNCTION] · src}}

∀ :A. EQ :A ⇒ (:A → :A → BOOLEAN)

Is a not equal to b?

`(ASUM XS)` ^{_{[FUNCTION] · src}}

∀ :A :B :C. (ALTERNATIVE :B) (FOLDABLE :A) ⇒ ((:A (:B :C)) → (:B :C))

Fold over a list using alt.

`(BRACKET INIT EXIT BODY)` ^{_{[FUNCTION] · src}}

∀ :A :B :C :D. MONAD :A ⇒ ((:A :B) → (:B → (:A :C)) → (:B → (:A :D)) → (:A :D))

Bracket takes an initial state, performs a body of operations, and then forces a safe exit.

This wraps cl:unwind-protect.

Modeled after Haskell: https://wiki.haskell.org/Bracket_pattern

`(COMPLEMENT F X)` ^{_{[FUNCTION] · src}}

∀ :A. ((:A → BOOLEAN) → :A → BOOLEAN)

Compute the complement of a unary Boolean function.

`(COMPOSE F G X)` ^{_{[FUNCTION] · src}}

∀ :A :B :C. ((:A → :B) → (:C → :A) → :C → :B)

Equivalent to (f (g x)).

`(CONJOIN F G X)` ^{_{[FUNCTION] · src}}

∀ :A. ((:A → BOOLEAN) → (:A → BOOLEAN) → :A → BOOLEAN)

Compute the conjunction of two unary Boolean functions.

`(CONST A _B)` ^{_{[FUNCTION] · src}}

∀ :A :B. (:A → :B → :A)

A function that always returns its first argument.

`(CURRY FUNC LEFT RIGHT)` ^{_{[FUNCTION] · src}}

∀ :A :B :C. (((TUPLE :A :B) → :C) → :A → :B → :C)

Take a function whose input is a tuple and enable curried application of the left and right parameters, equivalent to (func (Tuple left right)).

`(DISJOIN F G X)` ^{_{[FUNCTION] · src}}

∀ :A. ((:A → BOOLEAN) → (:A → BOOLEAN) → :A → BOOLEAN)

Compute the disjunction of two unary Boolean functions.

`(FIX F N)` ^{_{[FUNCTION] · src}}

∀ :A :B. (((:A → :B) → :A → :B) → :A → :B)

Compute the fixed point of a unary function. This is equivalent to the Y-combinator of the lambda calculus. This combinator allows recursion without specific assignment of names. For example, the factorial function can be written

(define fact
  (fix
    (fn (f n)
      (if (== n 0)
        1
        (* n (f (- n 1)))))))

`(FLIP F X Y)` ^{_{[FUNCTION] · src}}

∀ :A :B :C. ((:A → :B → :C) → :B → :A → :C)

Returns a function that takes its arguments in reverse order.

`(ID X)` ^{_{[FUNCTION] · src}}

∀ :A. (:A → :A)

A function that always returns its argument.

`(MSUM XS)` ^{_{[FUNCTION] · src}}

∀ :A :B. (MONOID :B) (FOLDABLE :A) ⇒ ((:A :B) → :B)

Fold over a list using <>.

`(PAIR-WITH FUNC LEFT)` ^{_{[FUNCTION] · src}}

∀ :A :B. ((:A → :B) → :A → (TUPLE :A :B))

Create a Tuple of the form (Tuple left (func left)).

`(PRINT ITEM)` ^{_{[FUNCTION] · src}}

∀ :A. INTO :A STRING ⇒ (:A → UNIT)

Print the String representation of item to cl:*standard-output*.

`(REDUCE F Y XS)` ^{_{[FUNCTION] · src}}

∀ :A :B :C. FOLDABLE :C ⇒ ((:A → :B → :B) → :B → (:C :A) → :B)

The same as fold but with the argument order swapped to match cl:reduce

`(TRACE STR)` ^{_{[FUNCTION] · src}}

(STRING → UNIT)

Print a line to cl:*standard-output*.

`(TRACEOBJECT STR ITEM)` ^{_{[FUNCTION] · src}}

∀ :A. (STRING → :A → UNIT)

Print a line to cl:*standard-output* in the form “{STR}: {ITEM}”.

`(UNCURRY FUNC TPL)` ^{_{[FUNCTION] · src}}

∀ :A :B :C. ((:A → :B → :C) → (TUPLE :A :B) → :C)

Take a function with two currying parameters and enable their input as a single Tuple.

`(UNSAFE-POINTER-EQ? A B)` ^{_{[FUNCTION] · src}}

∀ :A. (:A → :A → BOOLEAN)

Macros

`CONJOIN* (&REST PREDICATES)` ^_[MACRO]

Compute the conjuction of predicates.

For example, the following expressions are equivalent.

(conjoin* f g h)

(fn (x) (and (f x) (g x) (h x)))

`DISJOIN* (&REST PREDICATES)` ^_[MACRO]

Compute the disjunction of predicates.

For example, the following expressions are equivalent.

(disjoin* f g h)

(fn (x) (or (f x) (g x) (h x)))

Package `COALTON-LIBRARY/HASH`

Values

`(COMBINE-HASHES LHS RHS)` ^{_{[FUNCTION] · src}}

(HASH → HASH → HASH)

`(COMBINE-HASHES-ORDER-INDEPENDENT LHS RHS)` ^{_{[FUNCTION] · src}}

(HASH → HASH → HASH)

Package `COALTON-LIBRARY/HASHMAP`

Types

`HASHMAP` ^{_{[TYPE] · src}}

(HASHMAP (HMNODE :A :B))

Immutable map (also known as a dictionary or dict) using hashes. Implemented as a hash array mapped trie data structure.

Instances

(EQ :A) (EQ :B) ⇒ EQ (HASHMAP :A :B)
(HASH :A) (HASH :B) ⇒ HASH (HASHMAP :A :B)
HASH :A ⇒ FROMITERATOR (HASHMAP :A :B) (TUPLE :A :B)
INTOITERATOR (HASHMAP :A :B) (TUPLE :A :B)
RUNTIMEREPR (HASHMAP :A :B)

Values

`(COUNT HM)` ^{_{[FUNCTION] · src}}

∀ :A :B. ((HASHMAP :A :B) → INTEGER)

Returns the number of entries in HM.

`(EMPTY? HM)` ^{_{[FUNCTION] · src}}

∀ :A :B. ((HASHMAP :A :B) → BOOLEAN)

Returns True if a hashmap HM is empty, False if not.

`(INSERT HM KEY VAL)` ^{_{[FUNCTION] · src}}

∀ :A :B. HASH :A ⇒ ((HASHMAP :A :B) → :A → :B → (HASHMAP :A :B))

Returns a hashmap that has a new entry of (KEY, VAL) added to HM. If HM containes an entry with KEY, the new hashmap replaces it for the new entry.

`(KEYS HM)` ^{_{[FUNCTION] · src}}

∀ :A :B. HASH :A ⇒ ((HASHMAP :A :B) → (ITERATOR :A))

Returns an interator to iterate over all the keys in a hashmap hm.

`(LOOKUP HM KEY)` ^{_{[FUNCTION] · src}}

∀ :A :B. HASH :A ⇒ ((HASHMAP :A :B) → :A → (OPTIONAL :B))

Returns a value associated with KEY in the hashmap HM.

`(REMOVE HM KEY)` ^{_{[FUNCTION] · src}}

∀ :A :B. HASH :A ⇒ ((HASHMAP :A :B) → :A → (HASHMAP :A :B))

Returns a hashmap that is identical to HM except the entry with KEY is removed. If HM does not contain an entry with KEY, HM is returned as is.

`(VALUES HM)` ^{_{[FUNCTION] · src}}

∀ :A :B. HASH :A ⇒ ((HASHMAP :A :B) → (ITERATOR :B))

Returns an interator to iterate over all the values in a hashmap hm.

`EMPTY` ^{_{[VALUE] · src}}

∀ :A :B. (HASHMAP :A :B)

An empty HashMap

Package `COALTON-LIBRARY/HASHTABLE`

Types

`HASHTABLE` ^{_{[TYPE] · src}}

A mutable hash table.

Instances

(HASH :A) (EQ :B) ⇒ EQ (HASHTABLE :A :B)
(HASH :A) (HASH :B) ⇒ HASH (HASHTABLE :A :B)
HASH :A ⇒ DEFAULT (HASHTABLE :A :B)
HASH :A ⇒ FROMITERATOR (HASHTABLE :A :B) (TUPLE :A :B)
INTOITERATOR (HASHTABLE :A :B) (TUPLE :A :B)
RUNTIMEREPR (HASHTABLE :A :B)

Values

`(COUNT TABLE)` ^{_{[FUNCTION] · src}}

∀ :A :B. ((HASHTABLE :A :B) → INTEGER)

Returns the number of entries in TABLE

`(ENTRIES TABLE)` ^{_{[FUNCTION] · src}}

∀ :A :B. ((HASHTABLE :A :B) → (ITERATOR (TUPLE :A :B)))

Returns the key-values pairs as a list.

`(EXTEND! TABLE ITER)` ^{_{[FUNCTION] · src}}

∀ :A :B :C. (HASH :A) (INTOITERATOR :C (TUPLE :A :B)) ⇒ ((HASHTABLE :A :B) → :C → UNIT)

Insert all of the key value pairs from ITER into TABLE, overwriting duplicate keys.

`(GET TABLE KEY)` ^{_{[FUNCTION] · src}}

∀ :A :B. HASH :A ⇒ ((HASHTABLE :A :B) → :A → (OPTIONAL :B))

Lookup KEY in TABLE

`(KEYS TABLE)` ^{_{[FUNCTION] · src}}

∀ :A :B. ((HASHTABLE :A :B) → (ITERATOR :A))

Returns the keys in TABLE as a list

`(NEW _)` ^{_{[FUNCTION] · src}}

∀ :A :B. HASH :A ⇒ (UNIT → (HASHTABLE :A :B))

Create a new empty hashtable

`(REMOVE! TABLE KEY)` ^{_{[FUNCTION] · src}}

∀ :A :B. HASH :A ⇒ ((HASHTABLE :A :B) → :A → UNIT)

Remove the entry at KEY from TABLE

`(SET! TABLE KEY VALUE)` ^{_{[FUNCTION] · src}}

∀ :A :B. HASH :A ⇒ ((HASHTABLE :A :B) → :A → :B → UNIT)

Set KEY to VALUE in TABLE

`(VALUES TABLE)` ^{_{[FUNCTION] · src}}

∀ :A :B. ((HASHTABLE :A :B) → (ITERATOR :B))

Returns the values in TABLE as a list

`(WITH-CAPACITY CAPACITY)` ^{_{[FUNCTION] · src}}

∀ :A :B. HASH :A ⇒ (INTEGER → (HASHTABLE :A :B))

Create a new empty hashtable with a given capacity

Package `COALTON-LIBRARY/ITERATOR`

Types

`ITERATOR` ^{_{[TYPE] · src}}

A forward-moving pointer into an ordered sequence of :ELTs

Instances

FUNCTOR ITERATOR
INTOITERATOR (ITERATOR :A) :A
RUNTIMEREPR (ITERATOR :A)

Classes

`FROMITERATOR` ^{_{[CLASS] · src}}

FROMITERATOR :A :B

Methods:

COLLECT! :: ((ITERATOR :B) → :A)

Instances

RUNTIMEREPR :A ⇒ FROMITERATOR (SEQ :A) :A
ORD :A ⇒ FROMITERATOR (ORDMAP :A :B) (TUPLE :A :B)
ORD :A ⇒ FROMITERATOR (TREE :A) :A
FROMITERATOR (QUEUE :A) :A
HASH :A ⇒ FROMITERATOR (HASHMAP :A :B) (TUPLE :A :B)
HASH :A ⇒ FROMITERATOR (HASHTABLE :A :B) (TUPLE :A :B)
FROMITERATOR (SLICE :A) :A
FROMITERATOR STRING CHAR
FROMITERATOR (VECTOR :A) :A
FROMITERATOR (LIST :A) :A
FROMITERATOR :A :B ⇒ FROMITERATOR (RESULT :C :A) (RESULT :C :B)
FROMITERATOR :A :B ⇒ FROMITERATOR (OPTIONAL :A) (OPTIONAL :B)

`INTOITERATOR` ^{_{[CLASS] · src}}

INTOITERATOR :A :B

Containers which can be converted into iterators.

INTO-ITER must not mutate its argument, only produce a “view” into it.

Methods:

INTO-ITER :: (:A → (ITERATOR :B))

Instances

INTOITERATOR (SEQ :A) :A
INTOITERATOR (ORDMAP :A :B) (TUPLE :A :B)
INTOITERATOR (TREE :A) :A
INTOITERATOR (QUEUE :A) :A
INTOITERATOR (HASHMAP :A :B) (TUPLE :A :B)
INTOITERATOR (HASHTABLE :A :B) (TUPLE :A :B)
INTOITERATOR (SLICE :A) :A
INTOITERATOR STRING CHAR
INTOITERATOR (VECTOR :A) :A
INTOITERATOR (LIST :A) :A
INTOITERATOR (RESULT :A :B) :B
INTOITERATOR (OPTIONAL :A) :A
INTOITERATOR (ITERATOR :A) :A

Values

`(AND! ITER)` ^{_{[FUNCTION] · src}}

((ITERATOR BOOLEAN) → BOOLEAN)

Returns True if all iterator elements are True. May not consume the entire iterator. Returns True on an empty iterator.

`(ANY! GOOD? ITER)` ^{_{[FUNCTION] · src}}

∀ :A. ((:A → BOOLEAN) → (ITERATOR :A) → BOOLEAN)

Return True as soon as any element of ITER is GOOD?, or False if none of them are.

Returns False if ITER is empty.

`(CHAIN! ITER1 ITER2)` ^{_{[FUNCTION] · src}}

∀ :A. ((ITERATOR :A) → (ITERATOR :A) → (ITERATOR :A))

Yield all the elements of ITER1 followed by all the elements from ITER2.

`(COUNT! ITER)` ^{_{[FUNCTION] · src}}

∀ :A. ((ITERATOR :A) → UFIX)

Return the number of elements in ITER. This operation could be called length!, but count! emphasizes the fact that it consumes ITER, and afterwards, ITER will be exhausted.

`(COUNT-FOREVER _)` ^{_{[FUNCTION] · src}}

∀ :A. (NUM :A) (ORD :A) ⇒ (UNIT → (ITERATOR :A))

An infinite iterator which starts at 0 and counts upwards by 1.

`(DOWN-FROM LIMIT)` ^{_{[FUNCTION] · src}}

∀ :A. (NUM :A) (ORD :A) ⇒ (:A → (ITERATOR :A))

An iterator which begins below the provided limit and counts down through and including zero.

`(ELEMENTWISE-HASH! ITER)` ^{_{[FUNCTION] · src}}

∀ :A. HASH :A ⇒ ((ITERATOR :A) → HASH)

Hash an iterator by combining the hashes of all its elements.

The empty iterator will hash as 0.

`(ELEMENTWISE-MATCH! SAME? LEFT RIGHT)` ^{_{[FUNCTION] · src}}

∀ :A. ((:A → :A → BOOLEAN) → (ITERATOR :A) → (ITERATOR :A) → BOOLEAN)

Are LEFT and RIGHT elementwise-identical under SAME?

True if, for every pair of elements (A B) in (LEFT RIGHT), (same? A B) is True, and LEFT and RIGHT have the same length.

`(ELEMENTWISE==!)` ^{_{[FUNCTION] · src}}

∀ :A. EQ :A ⇒ ((ITERATOR :A) → (ITERATOR :A) → BOOLEAN)

Is every element of the first iterator `==’ to the corresponding element of the second?

True if two iterators have the same length, and for every N, the Nth element of the first iterator is `==’ to the Nth element of the second iterator.

`(ENUMERATE! ITER)` ^{_{[FUNCTION] · src}}

∀ :A. ((ITERATOR :A) → (ITERATOR (TUPLE UFIX :A)))

Pair successive zero-based incides with elements from ITER

`(EVERY! GOOD? ITER)` ^{_{[FUNCTION] · src}}

∀ :A. ((:A → BOOLEAN) → (ITERATOR :A) → BOOLEAN)

Return True if every element of ITER is GOOD?, or False as soon as any element is not GOOD?.

Returns True if ITER is empty.

`(FILTER! KEEP? ITER)` ^{_{[FUNCTION] · src}}

∀ :A. ((:A → BOOLEAN) → (ITERATOR :A) → (ITERATOR :A))

Return an iterator over the elements from ITER for which KEEP?returns true.

`(FILTER-MAP! F ITER)` ^{_{[FUNCTION] · src}}

∀ :A :B. ((:A → (OPTIONAL :B)) → (ITERATOR :A) → (ITERATOR :B))

Map an iterator, retaining only the elements where F returns SOME.

`(FIND! THIS? ITER)` ^{_{[FUNCTION] · src}}

∀ :A. ((:A → BOOLEAN) → (ITERATOR :A) → (OPTIONAL :A))

Return the first element of ITER for which THIS? returns True, or None if no element matches.

`(FIND-MAP! F)` ^{_{[FUNCTION] · src}}

∀ :A :B. ((:A → (OPTIONAL :B)) → (ITERATOR :A) → (OPTIONAL :B))

Return the first element of (map F ITER) for which F returns Some.

`(FLAT-MAP! FUNC ITER)` ^{_{[FUNCTION] · src}}

∀ :A :B. ((:A → (ITERATOR :B)) → (ITERATOR :A) → (ITERATOR :B))

Flatten! wrapped around map.

`(FLATTEN! ITERS)` ^{_{[FUNCTION] · src}}

∀ :A. ((ITERATOR (ITERATOR :A)) → (ITERATOR :A))

Yield all the elements from each of the ITERS in order.

`(FOLD! FUNC INIT ITER)` ^{_{[FUNCTION] · src}}

∀ :A :B. ((:A → :B → :A) → :A → (ITERATOR :B) → :A)

Tail recursive in-order fold. Common Lisp calls this operation reduce.

If ITER is empty, returns INIT. Otherwise, calls (FUNC STATE ITEM) for each ITEM of ITER to produce a new STATE, using INIT as the first STATE.

`(FOR-EACH! THUNK ITER)` ^{_{[FUNCTION] · src}}

∀ :A. ((:A → UNIT) → (ITERATOR :A) → UNIT)

Call THUNK on each element of ITER in order for side effects. Discard values returned by THUNK.

`(INDEX-OF! THIS? ITER)` ^{_{[FUNCTION] · src}}

∀ :A. ((:A → BOOLEAN) → (ITERATOR :A) → (OPTIONAL UFIX))

Return the zero-based index of the first element of ITER for which THIS? is True, or None if no element matches.

`(INTERLEAVE! LEFT RIGHT)` ^{_{[FUNCTION] · src}}

∀ :A. ((ITERATOR :A) → (ITERATOR :A) → (ITERATOR :A))

Return an interator of interleaved elements from LEFT and RIGHT which terminates as soon as both LEFT and RIGHT do.

If one iterator terminates before the other, elements from the longer iterator will be yielded without interleaving. (interleave empty ITER) is equivalent to (id ITER).

`(LAST! ITER)` ^{_{[FUNCTION] · src}}

∀ :A. ((ITERATOR :A) → (OPTIONAL :A))

Yields the last element of ITER, completely consuming it.

`(MAP-WHILE! F ITER)` ^{_{[FUNCTION] · src}}

∀ :A :B. ((:A → (OPTIONAL :B)) → (ITERATOR :A) → (ITERATOR :B))

Map an iterator, stopping early if F returns NONE.

`(MAX! ITER)` ^{_{[FUNCTION] · src}}

∀ :A. ORD :A ⇒ ((ITERATOR :A) → (OPTIONAL :A))

Return the most-positive element of ITER, or None if ITER is empty.

`(MAXIMIZE-BY! F ITER)` ^{_{[FUNCTION] · src}}

∀ :A :B. ORD :B ⇒ ((:A → :B) → (ITERATOR :A) → (OPTIONAL :A))

For a function F, which maps the iterator, return the element of ITER where (F ELT) is the most-positive.

Return `None’ if ITER is empty.

`(MCONCAT! ITER)` ^{_{[FUNCTION] · src}}

∀ :A. MONOID :A ⇒ ((ITERATOR :A) → :A)

Fold an iterator of monoids into a single element.

`(MCONCATMAP! FUNC ITER)` ^{_{[FUNCTION] · src}}

∀ :A :B. MONOID :B ⇒ ((:A → :B) → (ITERATOR :A) → :B)

Map an iterator to an iterator of monoids, and then fold that iterator into a single element.

`(MIN! ITER)` ^{_{[FUNCTION] · src}}

∀ :A. ORD :A ⇒ ((ITERATOR :A) → (OPTIONAL :A))

Return the most-negative element of ITER, or None if ITER is empty.

`(MINIMIZE-BY! F ITER)` ^{_{[FUNCTION] · src}}

∀ :A :B. ORD :B ⇒ ((:A → :B) → (ITERATOR :A) → (OPTIONAL :A))

For a function F, which maps the iterator, return the element of ITER where (F ELT) is the most-negative.

Return `None’ if ITER is empty.

`(NEW F)` ^{_{[FUNCTION] · src}}

∀ :A. ((UNIT → (OPTIONAL :A)) → (ITERATOR :A))

Create a new iterator from a function that yields elements.

`(NEXT! ITER)` ^{_{[FUNCTION] · src}}

∀ :A. ((ITERATOR :A) → (OPTIONAL :A))

Advance ITER, returning its next yielded value, or None if the iterator is exhausted. Behavior is undefined if two threads concurrently call next! on the same iterator without a lock. Note that most of the operators defined on iterators call next! internally, or create new iterators which will call next! on their inputs.

`(ONCE ITEM)` ^{_{[FUNCTION] · src}}

∀ :A. (:A → (ITERATOR :A))

Yield item once.

`(OPTIMIZE! BETTER? ITER)` ^{_{[FUNCTION] · src}}

∀ :A. ((:A → :A → BOOLEAN) → (ITERATOR :A) → (OPTIONAL :A))

For an order BETTER? which returns True if its first argument is better than its second argument, return the best element of ITER.

Return None if ITER is empty.

`(OPTIMIZE-BY! BETTER? F ITER)` ^{_{[FUNCTION] · src}}

∀ :A :B. ((:A → :A → BOOLEAN) → (:B → :A) → (ITERATOR :B) → (OPTIONAL :B))

For an order BETTER? which returns True if its first argument is better than its second argument, return the element of ITER where (F ELT) is the best.

Return None if ITER is empty.

`(OR! ITER)` ^{_{[FUNCTION] · src}}

((ITERATOR BOOLEAN) → BOOLEAN)

Returns True if any iterator elements are True. May not consume the entire iterator. Returns False on an empty iterator.

`(PAIR-WITH! FUNC KEYS)` ^{_{[FUNCTION] · src}}

∀ :A :B. ((:A → :B) → (ITERATOR :A) → (ITERATOR (TUPLE :A :B)))

Returns an iterator over tuples whose FSTs are elements from KEYS, and whose SNDs are the results of applying FUNC to those KEYS.

`(RANGE-DECREASING STEP START END)` ^{_{[FUNCTION] · src}}

∀ :A. (NUM :A) (ORD :A) ⇒ (:A → :A → :A → (ITERATOR :A))

A range which begins below START and counts down through and including END by STEP.

Equivalent to reversing range-increasing

`(RANGE-INCREASING STEP START END)` ^{_{[FUNCTION] · src}}

∀ :A. (NUM :A) (ORD :A) ⇒ (:A → :A → :A → (ITERATOR :A))

An iterator which begins at START and yields successive elements spaced by STEP, stopping before END.

`(RECURSIVE-ITER SUCC DONE? START)` ^{_{[FUNCTION] · src}}

∀ :A. ((:A → :A) → (:A → BOOLEAN) → :A → (ITERATOR :A))

An iterator which yields first START, then (SUCC START), then (SUCC (SUCC START)), and so on, stopping as soon as such a value is done?.

Beware off-by-one errors: the first value which is done? is not yielded. If `(done? start)’ is true, the iterator is empty.

`(REMOVE-DUPLICATES! ITER)` ^{_{[FUNCTION] · src}}

∀ :A. HASH :A ⇒ ((ITERATOR :A) → (ITERATOR :A))

Yield unique elements from ITER in order of first appearance.

`(REPEAT ITEM)` ^{_{[FUNCTION] · src}}

∀ :A. (:A → (ITERATOR :A))

Yield ITEM over and over, infinitely.

`(REPEAT-FOR ITEM COUNT)` ^{_{[FUNCTION] · src}}

∀ :A. (:A → UFIX → (ITERATOR :A))

Yield ITEM COUNT times, then stop.

`(SIZE-HINT ITER)` ^{_{[FUNCTION] · src}}

∀ :A. ((ITERATOR :A) → (OPTIONAL UFIX))

`(SUM! ITER)` ^{_{[FUNCTION] · src}}

∀ :A. NUM :A ⇒ ((ITERATOR :A) → :A)

Add together all the elements of ITER.

`(TAKE! COUNT ITER)` ^{_{[FUNCTION] · src}}

∀ :A. (UFIX → (ITERATOR :A) → (ITERATOR :A))

An Iterator which yields at most COUNT elements from ITER.

`(UNWRAPPED! ITER)` ^{_{[FUNCTION] · src}}

∀ :A :B. UNWRAPPABLE :A ⇒ ((ITERATOR (:A :B)) → (ITERATOR :B))

`(UP-THROUGH LIMIT)` ^{_{[FUNCTION] · src}}

∀ :A. (NUM :A) (ORD :A) ⇒ (:A → (ITERATOR :A))

An iterator which begins at zero and counts up through and including LIMIT.

`(UP-TO LIMIT)` ^{_{[FUNCTION] · src}}

∀ :A. (NUM :A) (ORD :A) ⇒ (:A → (ITERATOR :A))

An iterator which begins at zero and counts up to, but not including, LIMIT.

`(WITH-SIZE F SIZE)` ^{_{[FUNCTION] · src}}

∀ :A. ((UNIT → (OPTIONAL :A)) → UFIX → (ITERATOR :A))

`(ZIP!)` ^{_{[FUNCTION] · src}}

∀ :A :B. ((ITERATOR :A) → (ITERATOR :B) → (ITERATOR (TUPLE :A :B)))

Return an iterator of tuples contining elements from two iterators.

`(ZIP-WITH! F LEFT RIGHT)` ^{_{[FUNCTION] · src}}

∀ :A :B :C. ((:A → :B → :C) → (ITERATOR :A) → (ITERATOR :B) → (ITERATOR :C))

Return an iterator of elements from LEFT and RIGHT which terminates as soon as either LEFT or RIGHT does.

`EMPTY` ^{_{[VALUE] · src}}

∀ :A. (ITERATOR :A)

Yields nothing; stops immediately

Package `COALTON-LIBRARY/LISPARRAY`

Types

`LISPARRAY` ^{_{[TYPE] · src}}

A one-dimensional, non-resizable array of elements.

These arrays are represented as possibly specialized (cl:simple-array <type> (cl:*)) and are meant to be used as a tool either to interface with Lisp code or to implement efficient data structures. One should consult Vector or Seq for more general sequential data structure needs.

Whether or not the arrays are specialized depends on the underlying Lisp implementation. Consult cl:upgraded-array-element-type to determine whether LispArray may get specialized.

Instances

EQ :A ⇒ EQ (LISPARRAY :A)
FOLDABLE LISPARRAY
INTO (LISPARRAY :A) (LIST :A)
RUNTIMEREPR :A ⇒ INTO (LIST :A) (LISPARRAY :A)
RUNTIMEREPR :A ⇒ ISO (LISPARRAY :A) (LIST :A)
RUNTIMEREPR :A ⇒ RANDOMACCESS (LISPARRAY :A) :A
RUNTIMEREPR :A ⇒ RUNTIMEREPR (LISPARRAY :A)

Values

`(AREF V I)` ^{_{[FUNCTION] · src}}

∀ :A. ((LISPARRAY :A) → UFIX → :A)

Read the ith value of the LispArray v.

`(COPY V)` ^{_{[FUNCTION] · src}}

∀ :A. ((LISPARRAY :A) → (LISPARRAY :A))

Make a deep copy of the LispArray v.

`(LENGTH V)` ^{_{[FUNCTION] · src}}

∀ :A. ((LISPARRAY :A) → UFIX)

Return the length of the LispArray v.

`(MAKE N X)` ^{_{[FUNCTION] · src}}

∀ :A. RUNTIMEREPR :A ⇒ (UFIX → :A → (LISPARRAY :A))

Make a new LispArray of length n initialized to x.

If the type of x represents a specialized array

`(MAKE-UNINITIALIZED N)` ^{_{[FUNCTION] · src}}

∀ :A. RUNTIMEREPR :A ⇒ (UFIX → (LISPARRAY :A))

Make a new LispArray of length n that can store elements of type :t.

WARNING: The consequences are undefined if an uninitialized element is read before being set.

`(SET! V I X)` ^{_{[FUNCTION] · src}}

∀ :A. ((LISPARRAY :A) → UFIX → :A → UNIT)

Set the ith value of the LispArray v to x.

Package `COALTON-LIBRARY/LIST`

Values

`(ALL F? XS)` ^{_{[FUNCTION] · src}}

∀ :A. ((:A → BOOLEAN) → (LIST :A) → BOOLEAN)

Returns True if every element in xs matches f?.

`(ANY F? L)` ^{_{[FUNCTION] · src}}

∀ :A. ((:A → BOOLEAN) → (LIST :A) → BOOLEAN)

Returns True if at least one element in xs matches f?.

`(APPEND XS YS)` ^{_{[FUNCTION] · src}}

∀ :A. ((LIST :A) → (LIST :A) → (LIST :A))

Appends two lists together and returns a new list.

`(CAR X)` ^{_{[FUNCTION] · src}}

∀ :A. ((LIST :A) → :A)

Return the traditional car of a list. This function is partial

`(CDR XS)` ^{_{[FUNCTION] · src}}

∀ :A. ((LIST :A) → (LIST :A))

Return the traditional cdr of a list.

`(COMBS L)` ^{_{[FUNCTION] · src}}

∀ :A. ((LIST :A) → (LIST (LIST :A)))

Compute a list of all combinations of elements of l. This function is sometimes goes by the name “power set” or “subsets”.

The ordering of elements of l is preserved in the ordering of elements in each list produced by this function.

`(COMBSOF N L)` ^{_{[FUNCTION] · src}}

∀ :A. (UFIX → (LIST :A) → (LIST (LIST :A)))

Produce a list of size-N subsets of l.

The ordering of elements of l is preserved in the ordering of elements in each list produced by (combsOf n l).

This function is equivalent to all size-n elements of (combs l).

`(CONCAT XS)` ^{_{[FUNCTION] · src}}

∀ :A. ((LIST (LIST :A)) → (LIST :A))

Appends a list of lists together into a single new list.

`(CONCATMAP F XS)` ^{_{[FUNCTION] · src}}

∀ :A :B. ((:A → (LIST :B)) → (LIST :A) → (LIST :B))

Apply F to each element in XS and concatenate the results.

`(CONS? XS)` ^{_{[FUNCTION] · src}}

∀ :A. ((LIST :A) → BOOLEAN)

Returns TRUE if XS is a non-empty list.

`(COUNTBY F THINGS)` ^{_{[FUNCTION] · src}}

∀ :A. ((:A → BOOLEAN) → (LIST :A) → UFIX)

Count the number of items in THINGS that satisfy the predicate F.

`(DIFFERENCE XS YS)` ^{_{[FUNCTION] · src}}

∀ :A. EQ :A ⇒ ((LIST :A) → (LIST :A) → (LIST :A))

Returns a new list with the first occurence of each element in ys removed from xs.

`(DROP N XS)` ^{_{[FUNCTION] · src}}

∀ :A. (UFIX → (LIST :A) → (LIST :A))

Returns a list with the first N elements removed.

`(ELEMINDEX X XS)` ^{_{[FUNCTION] · src}}

∀ :A. EQ :A ⇒ (:A → (LIST :A) → (OPTIONAL UFIX))

`(EQUIVALENCE-CLASSES)` ^{_{[FUNCTION] · src}}

∀ :A. EQ :A ⇒ ((LIST :A) → (LIST (LIST :A)))

`(EQUIVALENCE-CLASSES-BY F L)` ^{_{[FUNCTION] · src}}

∀ :A. ((:A → :A → BOOLEAN) → (LIST :A) → (LIST (LIST :A)))

Break a list into a list of equivalence classes according to an equivalence relation.

`(FILTER F XS)` ^{_{[FUNCTION] · src}}

∀ :A. ((:A → BOOLEAN) → (LIST :A) → (LIST :A))

Returns a new list containing every element of XS that matches the predicate function F in the same order.

`(FIND F XS)` ^{_{[FUNCTION] · src}}

∀ :A. ((:A → BOOLEAN) → (LIST :A) → (OPTIONAL :A))

Returns the first element in a list matching the predicate function F.

`(FINDINDEX F XS)` ^{_{[FUNCTION] · src}}

∀ :A. ((:A → BOOLEAN) → (LIST :A) → (OPTIONAL UFIX))

Returns the index of the first element matching the predicate function F.

`(HEAD L)` ^{_{[FUNCTION] · src}}

∀ :A. ((LIST :A) → (OPTIONAL :A))

Returns the first element of a list.

`(INDEX I XS)` ^{_{[FUNCTION] · src}}

∀ :A. (UFIX → (LIST :A) → (OPTIONAL :A))

Returns the Ith element of a list.

`(INIT L)` ^{_{[FUNCTION] · src}}

∀ :A. ((LIST :A) → (LIST :A))

Returns every element except the last in a list.

`(INSERT E LS)` ^{_{[FUNCTION] · src}}

∀ :A. ORD :A ⇒ (:A → (LIST :A) → (LIST :A))

Inserts an element into a list at the first place it is less than or equal to the next element.

`(INSERTBY CMP X YS)` ^{_{[FUNCTION] · src}}

∀ :A. ((:A → :A → ORD) → :A → (LIST :A) → (LIST :A))

Generic version of insert

`(INSERTIONS A L)` ^{_{[FUNCTION] · src}}

∀ :A. (:A → (LIST :A) → (LIST (LIST :A)))

Produce a list of copies of l, each with A inserted at a possible position.

(insertions 0 (make-list 1 2))
;; => ((0 1 2) (1 0 2) (1 2 0))

`(INTERCALATE XS XSS)` ^{_{[FUNCTION] · src}}

∀ :A. ((LIST :A) → (LIST (LIST :A)) → (LIST :A))

Intersperse xs into xss and then concatenate the result.

`(INTERSECTION XS YS)` ^{_{[FUNCTION] · src}}

∀ :A. EQ :A ⇒ ((LIST :A) → (LIST :A) → (LIST :A))

Returns elements which occur in both lists. Does not return duplicates and does not guarantee order.

`(INTERSPERSE E XS)` ^{_{[FUNCTION] · src}}

∀ :A. (:A → (LIST :A) → (LIST :A))

Returns a new list by inserting e between every element of xs.

`(LAST L)` ^{_{[FUNCTION] · src}}

∀ :A. ((LIST :A) → (OPTIONAL :A))

Returns the last element of a list.

`(LENGTH L)` ^{_{[FUNCTION] · src}}

∀ :A. ((LIST :A) → UFIX)

Returns the length of a list.

`(LOOKUP E XS)` ^{_{[FUNCTION] · src}}

∀ :A :B. EQ :A ⇒ (:A → (LIST (TUPLE :A :B)) → (OPTIONAL :B))

Returns the value of the first (key, value) tuple in XS where the key matches E.

`(MAXIMUM L)` ^{_{[FUNCTION] · src}}

∀ :A. ORD :A ⇒ ((LIST :A) → (OPTIONAL :A))

Returns a greatest element of a list, or None.

`(MEMBER E XS)` ^{_{[FUNCTION] · src}}

∀ :A. EQ :A ⇒ (:A → (LIST :A) → BOOLEAN)

Returns true if any element of XS is equal to E.

`(MINIMUM L)` ^{_{[FUNCTION] · src}}

∀ :A. ORD :A ⇒ ((LIST :A) → (OPTIONAL :A))

Returns a least element of a list, or None.

`(NTH N L)` ^{_{[FUNCTION] · src}}

∀ :A. (UFIX → (LIST :A) → :A)

Like INDEX, but errors if the index is not found.

`(NTH-CDR N L)` ^{_{[FUNCTION] · src}}

∀ :A. (UFIX → (LIST :A) → (LIST :A))

Returns the nth-cdr of a list.

`(NULL? XS)` ^{_{[FUNCTION] · src}}

∀ :A. ((LIST :A) → BOOLEAN)

Returns TRUE if XS is an empty list.

`(OPTIMUMBY F XS)` ^{_{[FUNCTION] · src}}

∀ :A. ((:A → :A → BOOLEAN) → (LIST :A) → (OPTIONAL :A))

Returns an optimum according to a total order.

`(PARTITION F XS)` ^{_{[FUNCTION] · src}}

∀ :A. ((:A → BOOLEAN) → (LIST :A) → (TUPLE (LIST :A) (LIST :A)))

Splits a list into two new lists. The first list contains elements matching predicate F.

`(PERMS L)` ^{_{[FUNCTION] · src}}

∀ :A. ((LIST :A) → (LIST (LIST :A)))

Produce all permutations of the list L.

`(PRODUCT XS)` ^{_{[FUNCTION] · src}}

∀ :A. NUM :A ⇒ ((LIST :A) → :A)

Returns the product of xs.

`(RANGE START END)` ^{_{[FUNCTION] · src}}

∀ :A. (NUM :A) (ORD :A) ⇒ (:A → :A → (LIST :A))

Returns a list containing the numbers from START to END inclusive, counting by 1.

COALTON-USER> (coalton (range 1 5))
(1 2 3 4 5)

COALTON-USER> (coalton (range 5 2))
(5 4 3 2)

`(REMOVE X YS)` ^{_{[FUNCTION] · src}}

∀ :A. EQ :A ⇒ (:A → (LIST :A) → (LIST :A))

Return a new list with the first element equal to x removed.

`(REMOVE-DUPLICATES XS)` ^{_{[FUNCTION] · src}}

∀ :A. EQ :A ⇒ ((LIST :A) → (LIST :A))

Returns a new list without duplicate elements.

`(REMOVE-IF PRED XS)` ^{_{[FUNCTION] · src}}

∀ :A. ((:A → BOOLEAN) → (LIST :A) → (LIST :A))

Return a new list with the first element for which PRED is True is removed.

`(REPEAT N X)` ^{_{[FUNCTION] · src}}

∀ :A. (UFIX → :A → (LIST :A))

Returns a list with the same value repeated multiple times.

`(REVERSE XS)` ^{_{[FUNCTION] · src}}

∀ :A. ((LIST :A) → (LIST :A))

Returns a new list containing the same elements in reverse order.

`(SINGLETON X)` ^{_{[FUNCTION] · src}}

∀ :A. (:A → (LIST :A))

Returns a list containing one element.

`(SINGLETON? XS)` ^{_{[FUNCTION] · src}}

∀ :A. ((LIST :A) → BOOLEAN)

Is xs a list containing exactly one element?

`(SORT XS)` ^{_{[FUNCTION] · src}}

∀ :A. ORD :A ⇒ ((LIST :A) → (LIST :A))

Sort xs.

`(SORTBY CMP XS)` ^{_{[FUNCTION] · src}}

∀ :A. ((:A → :A → ORD) → (LIST :A) → (LIST :A))

Sort xs by a custom comparison function cmp.

`(SPLIT C STR)` ^{_{[FUNCTION] · src}}

(CHAR → STRING → (LIST STRING))

Split a string str into a list of substrings by the character c.

`(SUM XS)` ^{_{[FUNCTION] · src}}

∀ :A. NUM :A ⇒ ((LIST :A) → :A)

Returns the sum of xs.

`(TAIL L)` ^{_{[FUNCTION] · src}}

∀ :A. ((LIST :A) → (OPTIONAL (LIST :A)))

Returns every element except the first in a list.

`(TAKE N XS)` ^{_{[FUNCTION] · src}}

∀ :A. (UFIX → (LIST :A) → (LIST :A))

Returns the first N elements of a list.

`(TRANSPOSE XS)` ^{_{[FUNCTION] · src}}

∀ :A. ((LIST (LIST :A)) → (LIST (LIST :A)))

Transposes a matrix represented by a list of lists.

`(UNION XS YS)` ^{_{[FUNCTION] · src}}

∀ :A. EQ :A ⇒ ((LIST :A) → (LIST :A) → (LIST :A))

Returns a new list with the elements from both XS and YS and without duplicates.

`(ZIP XS YS)` ^{_{[FUNCTION] · src}}

∀ :A :B. ((LIST :A) → (LIST :B) → (LIST (TUPLE :A :B)))

Builds a list of tuples with the elements of XS and YS.

`(ZIPWITH F XS YS)` ^{_{[FUNCTION] · src}}

∀ :A :B :C. ((:A → :B → :C) → (LIST :A) → (LIST :B) → (LIST :C))

Builds a new list by calling f with elements of xs and ys.

`(ZIPWITH3 F XS YS ZS)` ^{_{[FUNCTION] · src}}

∀ :A :B :C :D. ((:A → :B → :C → :D) → (LIST :A) → (LIST :B) → (LIST :C) → (LIST :D))

Build a new list by calling F with elements of XS, YS and ZS

`(ZIPWITH4 F AS BS CS DS)` ^{_{[FUNCTION] · src}}

∀ :A :B :C :D :E. ((:A → :B → :C → :D → :E) → (LIST :A) → (LIST :B) → (LIST :C) → (LIST :D) → (LIST :E))

Build a new list by calling F with elements of AS, BS, CS and DS

`(ZIPWITH5 F AS BS CS DS ES)` ^{_{[FUNCTION] · src}}

∀ :A :B :C :D :E :F. ((:A → :B → :C → :D → :E → :F) → (LIST :A) → (LIST :B) → (LIST :C) → (LIST :D) → (LIST :E) → (LIST :F))

Build a new list by calling F with elements of AS, BS, CS, DS and ES

Macros

`MAKE (&REST ELEMENTS)` ^_[MACRO]

Make a homogeneous list of elements. Synonym for coalton:make-list.

Package `COALTON-LIBRARY/MATH/ARITH`

Classes

`DIVIDABLE` ^{_{[CLASS] · src}}

DIVIDABLE :A :B

The representation of a type such that division within that type possibly results in another type. For instance,

(Dividable Integer Fraction)

establishes that division of two Integers can result in a Fraction, whereas

(Dividable F32 F32)

establishes that division of two F32s can result in a F32.

Note that Dividable does not establish a default result type; you must constrain the result type yourself.

The function general/ is partial, and will error produce a run-time error if the divisor is zero.

Methods:

GENERAL/ :: (:A → :A → :B)

Instances

DIVIDABLE INTEGER CREAL
DIVIDABLE INTEGER BIG-FLOAT
DIVIDABLE INTEGER FRACTION
DIVIDABLE INTEGER F64
DIVIDABLE INTEGER F32
RECIPROCABLE :A ⇒ DIVIDABLE :A :A

`RECIPROCABLE` ^{_{[CLASS] · src}}

NUM :A ⇒ RECIPROCABLE :A

Any number with a multiplicative inverse (reciprocal) where:

1 = (* (reciprocal x) x) = (* x (reciprocal x))
(/ x y) = (* x (reciprocal y))

If no reciprocal exists for an element, produce a run-time error (e.g., zero).

Methods:

/ :: (:A → :A → :A)
RECIPROCAL :: (:A → :A)

Instances

RECIPROCABLE CREAL
RECIPROCABLE BIG-FLOAT
RECIPROCABLE :A ⇒ RECIPROCABLE (HYPERDUAL :A)
RECIPROCABLE :A ⇒ RECIPROCABLE (DUAL :A)
(COMPLEXCOMPONENT :A) (RECIPROCABLE :A) ⇒ RECIPROCABLE (COMPLEX :A)
RECIPROCABLE FRACTION
RECIPROCABLE F64
RECIPROCABLE F32

`TRANSFINITE` ^{_{[CLASS] · src}}

TRANSFINITE :A

Numeric type with a value for (positive) infinity and/or NaN.

Methods:

INFINITY :: :A
INFINITE? :: (:A → BOOLEAN)
NAN :: :A
NAN? :: (:A → BOOLEAN)

Instances

TRANSFINITE BIG-FLOAT
TRANSFINITE F64
TRANSFINITE F32

Values

`(1+ NUM)` ^{_{[FUNCTION] · src}}

∀ :A. NUM :A ⇒ (:A → :A)

Increment num.

`(1- NUM)` ^{_{[FUNCTION] · src}}

∀ :A. NUM :A ⇒ (:A → :A)

Decrement num.

`(ABS X)` ^{_{[FUNCTION] · src}}

∀ :A. (ORD :A) (NUM :A) ⇒ (:A → :A)

Absolute value of x.

`(ASH X N)` ^{_{[FUNCTION] · src}}

Compute the “arithmetic shift” of x by n.

`(FINITE? X)` ^{_{[FUNCTION] · src}}

∀ :A. TRANSFINITE :A ⇒ (:A → BOOLEAN)

Neither infinite or NaN.

`(NEGATE X)` ^{_{[FUNCTION] · src}}

∀ :A. NUM :A ⇒ (:A → :A)

The negation, or additive inverse, of x.

`(NEGATIVE? X)` ^{_{[FUNCTION] · src}}

∀ :A. (NUM :A) (ORD :A) ⇒ (:A → BOOLEAN)

Is x negative?

`(NONNEGATIVE? X)` ^{_{[FUNCTION] · src}}

∀ :A. (NUM :A) (ORD :A) ⇒ (:A → BOOLEAN)

Is x not negative?

`(NONPOSITIVE? X)` ^{_{[FUNCTION] · src}}

∀ :A. (NUM :A) (ORD :A) ⇒ (:A → BOOLEAN)

Is x not positive?

`(NONZERO? X)` ^{_{[FUNCTION] · src}}

∀ :A. NUM :A ⇒ (:A → BOOLEAN)

Is x not zero?

`(POSITIVE? X)` ^{_{[FUNCTION] · src}}

∀ :A. (NUM :A) (ORD :A) ⇒ (:A → BOOLEAN)

Is x positive?

`(SIGN X)` ^{_{[FUNCTION] · src}}

∀ :A :B. (ORD :A) (NUM :A) (NUM :B) ⇒ (:A → :B)

The sign of x, where (sign 0) = 1.

`(ZERO? X)` ^{_{[FUNCTION] · src}}

∀ :A. NUM :A ⇒ (:A → BOOLEAN)

Is x zero?

`NEGATIVE-INFINITY` ^{_{[VALUE] · src}}

∀ :A. (TRANSFINITE :A) (NUM :A) ⇒ :A

Package `COALTON-LIBRARY/MATH/BOUNDED`

Classes

`BOUNDED` ^{_{[CLASS] · src}}

BOUNDED :A

Types which have a maximum and minumum bound.

Methods:

MINBOUND :: :A
MAXBOUND :: :A

Instances

BOUNDED UFIX
BOUNDED IFIX
BOUNDED I64
BOUNDED U64
BOUNDED I32
BOUNDED U32
BOUNDED I16
BOUNDED U16
BOUNDED I8
BOUNDED U8
BOUNDED BIT

Package `COALTON-LIBRARY/MATH/COMPLEX`

Types

`COMPLEX` ^{_{[TYPE] · src}}

A complex number with a real and imaginary component.

This object does not have any public constructors. Instead, use the function complex of the ComplexComponent type class.

A Complex object may either have a native or constructed representation. See the ComplexComponent type class for allowed component types.

Instances

(COMPLEXCOMPONENT :A) (INTO :A (HYPERDUAL :A)) ⇒ INTO (COMPLEX :A) (COMPLEX (HYPERDUAL :A))
(COMPLEXCOMPONENT :A) (INTO :A CREAL) ⇒ INTO (COMPLEX :A) (COMPLEX CREAL)
(COMPLEXCOMPONENT :A) (RECIPROCABLE :A) ⇒ RECIPROCABLE (COMPLEX :A)
COMPLEXCOMPONENT :A ⇒ EQ (COMPLEX :A)
COMPLEXCOMPONENT :A ⇒ INTO :A (COMPLEX :A)
COMPLEXCOMPONENT :A ⇒ NUM (COMPLEX :A)
ELEMENTARY :A ⇒ EXPONENTIABLE (COMPLEX :A)
ELEMENTARY :A ⇒ RADICAL (COMPLEX :A)
ELEMENTARY :A ⇒ TRIGONOMETRIC (COMPLEX :A)
FFTCYCLICGROUP (COMPLEX F64)
FFTCYCLICGROUP (COMPLEX F32)
FFTFIELD (COMPLEX F64)
FFTFIELD (COMPLEX F32)
FFTGROUP (COMPLEX F64)
FFTGROUP (COMPLEX F32)
FFTRING (COMPLEX F64)
FFTRING (COMPLEX F32)
RUNTIMEREPR :A ⇒ RUNTIMEREPR (COMPLEX :A)

Classes

`COMPLEXCOMPONENT` ^{_{[CLASS] · src}}

NUM :A ⇒ COMPLEXCOMPONENT :A

A type class for describing complex component types. This type class also encodes the construction and projection of Complex data types.

Methods:

COMPLEX :: (:A → :A → (COMPLEX :A))
REAL-PART :: ((COMPLEX :A) → :A)
IMAG-PART :: ((COMPLEX :A) → :A)

Instances

COMPLEXCOMPONENT CREAL
COMPLEXCOMPONENT BIG-FLOAT
COMPLEXCOMPONENT :A ⇒ COMPLEXCOMPONENT (HYPERDUAL :A)
COMPLEXCOMPONENT INTEGER
COMPLEXCOMPONENT FRACTION
COMPLEXCOMPONENT F64
COMPLEXCOMPONENT F32

Values

`(CONJUGATE Z)` ^{_{[FUNCTION] · src}}

∀ :A. COMPLEXCOMPONENT :A ⇒ ((COMPLEX :A) → (COMPLEX :A))

The complex conjugate. If $z=a+bi$ then the conjugate $\bar z=a-bi$.

`(SQUARE-MAGNITUDE Z)` ^{_{[FUNCTION] · src}}

∀ :A. COMPLEXCOMPONENT :A ⇒ ((COMPLEX :A) → :A)

The squared length of a complex number: $$\vert z\vert^2=(\operatorname{Re} z)^2+(\operatorname{Im} z)^2.$$

`II` ^{_{[VALUE] · src}}

∀ :A. COMPLEXCOMPONENT :A ⇒ (COMPLEX :A)

The complex unit $i=\sqrt{-1}$. (The double ii represents a blackboard-bold 𝕚.)

Package `COALTON-LIBRARY/MATH/DUAL`

Dual numbers are a hypercomplex number system [1]. A dual number has the form $a + b\varepsilon$ where $a$ and $b$ are real numbers and $\varepsilon$ is a symbol that satisfies $\varepsilon^2=0$ and $\varepsilon\neq 0$. The value $a$ is often called the primal part and the value $b$ is often called the dual part. One application of dual numbers is automatic differentiation; an example taken from [2] is as follows.

Consider the function $f(x) = 3x+2$ and you want to calculate $f(4)$ and $f^{\prime}(4)$. By the usual rules of differentiation, we know $f^{\prime}(x) = 3$ and thus $(f(4), f^{\prime}(4)) = (14, 3)$. We seek to recover this with dual numbers.

With dual numbers, we can calculate

$$f(a) + f^{\prime}(a)\varepsilon$$

by taking a real-valued function $f$ and evaluating as if it were a dual-valued function at the point $a + \varepsilon$. Thus, for the defined $f$, we have:

$$ \begin{aligned} f(4 + \varepsilon) &= 3(4 + \varepsilon) + 2 \\ &= 3\cdot 4 + 3\varepsilon + 2 \\ &= 14 + 3\varepsilon. \end{aligned} $$

In this result, the primal $14$ is the value of $f(4)$ and the dual is the value of of $f^{\prime}(4)$.

Haskell has an automatic differentiation library and you can find it here [3].

Limitations:

We have decided to implement Ord, Eq, and Hash to look at only the primal part of numbers. This is so the Dual type can be used primarily for the purpose of automatic differentiation of existing code, and not for general abstract mathematics. If you need these type classes acting in the usual way (i.e., on both primal and dual parts), then we recommend making your own data type which wraps a dual number.

References:

Structs

`DUAL :A` ^{_{[STRUCT] · src}}

Representation of a dual number in the form $a + b\varepsilon$ where $a$ and $b$ are real numbers and $\varepsilon$ satisfies $\varepsilon^2 = 0$ and $\varepsilon \neq 0$.

Note: Eq, and Ord and Hash only make use of the primal component.

Instances

(NUM :A) (EXPONENTIABLE :A) (RECIPROCABLE :A) ⇒ EXPONENTIABLE (DUAL :A)
(NUM :A) (RADICAL :A) (RECIPROCABLE :A) (EXPONENTIABLE :A) ⇒ RADICAL (DUAL :A)
(NUM :A) (TRIGONOMETRIC :A) (RECIPROCABLE :A) (RADICAL :A) ⇒ TRIGONOMETRIC (DUAL :A)
EQ :A ⇒ EQ (DUAL :A)
Note: Eq only compares the primal component.
HASH :A ⇒ HASH (DUAL :A)
Note: Hash only considers the primal component in order to be consistent with Eq.
NUM :A ⇒ NUM (DUAL :A)
ORD :A ⇒ ORD (DUAL :A)
Note: Ord only compares the primal component.
RECIPROCABLE :A ⇒ RECIPROCABLE (DUAL :A)
RUNTIMEREPR (DUAL :A)

Values

`(DUAL-PART (DUAL _ D))` ^{_{[FUNCTION] · src}}

∀ :A. ((DUAL :A) → :A)

The dual (i.e., derivative) part of a dual number.

`(PRIMAL-PART (DUAL P _))` ^{_{[FUNCTION] · src}}

∀ :A. ((DUAL :A) → :A)

The primal (i.e., real) part of a dual number.

Package `COALTON-LIBRARY/MATH/DYADIC`

Types

`DYADIC` ^{_{[TYPE] · src}}

(DYADIC INTEGER INTEGER)

(Dyadic n k) represents the rational $\mathtt{n}\cdot 2^{\mathtt{k}}$.

Instances

EQ DYADIC
INTO DYADIC FRACTION
INTO INTEGER DYADIC
NUM DYADIC
ORD DYADIC
QUANTIZABLE DYADIC
RATIONAL DYADIC
REAL DYADIC
RUNTIMEREPR DYADIC

Values

`(SCALE X J)` ^{_{[FUNCTION] · src}}

(DYADIC → INTEGER → DYADIC)

Scales a dyadic x by $2^{\mathtt{k}}$.

`(SHIFT K A)` ^{_{[FUNCTION] · src}}

(UFIX → DYADIC → DYADIC)

Shift dyadic a to its floor with $\mathtt{k}+1$ bits of precision.

`(SIMPLIFY D)` ^{_{[FUNCTION] · src}}

(DYADIC → DYADIC)

Simplifies a dyadic by maximizing the absolute value of the exponent.

`(SIMPLIFY-INTEGER N)` ^{_{[FUNCTION] · src}}

(INTEGER → DYADIC)

Finds the simplest dyadic given an integer.

Package `COALTON-LIBRARY/MATH/ELEMENTARY`

Classes

`ELEMENTARY` ^{_{[CLASS] · src}}

(RECIPROCABLE :A) (POLAR :A) (TRIGONOMETRIC :A) (EXPONENTIABLE :A) (RADICAL :A) ⇒ ELEMENTARY :A

Elementary is a marker class, providing Reciprocable, Polar, Trigonometric, Exponentiable, and Radical.

Methods:

Instances

ELEMENTARY CREAL
ELEMENTARY BIG-FLOAT
ELEMENTARY F64
ELEMENTARY F32

`EXPONENTIABLE` ^{_{[CLASS] · src}}

EXPONENTIABLE :A

Exponential maps obeying:

(* (exp x) (exp y)) = (exp (+ x y))
(exp (ln x)) = x = (ln (exp x))
(log b x) = (/ (ln x) (ln b))
(pow x y) = (exp (* y (ln x)))

Methods:

EXP :: (:A → :A)
POW :: (:A → :A → :A)
LN :: (:A → :A)
LOG :: (:A → :A → :A)
EE :: :A

Instances

EXPONENTIABLE CREAL
EXPONENTIABLE BIG-FLOAT
(EXPONENTIABLE :A) (RECIPROCABLE :A) ⇒ EXPONENTIABLE (HYPERDUAL :A)
(NUM :A) (EXPONENTIABLE :A) (RECIPROCABLE :A) ⇒ EXPONENTIABLE (DUAL :A)
ELEMENTARY :A ⇒ EXPONENTIABLE (COMPLEX :A)
EXPONENTIABLE F64
EXPONENTIABLE F32

`POLAR` ^{_{[CLASS] · src}}

(COMPLEXCOMPONENT :A) (NUM :A) ⇒ POLAR :A

This type class includes ComplexComponent types that admit a magnitude and phase.

For a complex number z = (complex x y), the following identities hold:

z = (* (magnitude z) (exp (* ii (phase z))))
(polar z) = (Tuple (magnitude z) (phase z))
(phase z) = (atan2 y x)

Methods:

PHASE :: ((COMPLEX :A) → :A)
POLAR :: ((COMPLEX :A) → (TUPLE :A :A))

Instances

POLAR CREAL
POLAR BIG-FLOAT
POLAR F64
POLAR F32

`RADICAL` ^{_{[CLASS] · src}}

RADICAL :A

Obeys:

(^ (sqrt x) 2) = x = (^^ (nth-root n x) n)

Methods:

NTH-ROOT :: (INTEGER → :A → :A)
SQRT :: (:A → :A)

Instances

RADICAL CREAL
RADICAL BIG-FLOAT
(RADICAL :A) (RECIPROCABLE :A) (EXPONENTIABLE :A) ⇒ RADICAL (HYPERDUAL :A)
(NUM :A) (RADICAL :A) (RECIPROCABLE :A) (EXPONENTIABLE :A) ⇒ RADICAL (DUAL :A)
ELEMENTARY :A ⇒ RADICAL (COMPLEX :A)
RADICAL F64
RADICAL F32

`TRIGONOMETRIC` ^{_{[CLASS] · src}}

TRIGONOMETRIC :A

Standard circular functions and their inverses.

Methods:

SIN :: (:A → :A)
COS :: (:A → :A)
TAN :: (:A → :A)
ASIN :: (:A → :A)
ACOS :: (:A → :A)
ATAN :: (:A → :A)
PI :: :A

Instances

TRIGONOMETRIC CREAL
TRIGONOMETRIC BIG-FLOAT
(TRIGONOMETRIC :A) (RECIPROCABLE :A) (RADICAL :A) ⇒ TRIGONOMETRIC (HYPERDUAL :A)
(NUM :A) (TRIGONOMETRIC :A) (RECIPROCABLE :A) (RADICAL :A) ⇒ TRIGONOMETRIC (DUAL :A)
ELEMENTARY :A ⇒ TRIGONOMETRIC (COMPLEX :A)
TRIGONOMETRIC F64
TRIGONOMETRIC F32

Values

`(ACOSH X)` ^{_{[FUNCTION] · src}}

∀ :A. ELEMENTARY :A ⇒ (:A → :A)

`(ASINH X)` ^{_{[FUNCTION] · src}}

∀ :A. ELEMENTARY :A ⇒ (:A → :A)

`(ATAN2 Y X)` ^{_{[FUNCTION] · src}}

∀ :A. (ORD :A) (TRIGONOMETRIC :A) (RECIPROCABLE :A) ⇒ (:A → :A → :A)

Computes the two-argument arctangent of y and x, which is roughly the same as (atan (/ y x)) when defined and accounting for the quadrant of the point $(\mathtt{x},\mathtt{y})$.

`(ATANH X)` ^{_{[FUNCTION] · src}}

∀ :A. ELEMENTARY :A ⇒ (:A → :A)

`(CIS Z)` ^{_{[FUNCTION] · src}}

∀ :A. (TRIGONOMETRIC :A) (COMPLEXCOMPONENT :A) ⇒ (:A → (COMPLEX :A))

A point on the complex unit circle:

(cis z) := (exp (complex 0 z))
         = (complex (cos z) (sin z))

`(COSH X)` ^{_{[FUNCTION] · src}}

∀ :A. ELEMENTARY :A ⇒ (:A → :A)

`(MAGNITUDE Z)` ^{_{[FUNCTION] · src}}

∀ :A. (RADICAL :A) (COMPLEXCOMPONENT :A) ⇒ ((COMPLEX :A) → :A)

The magnitude of a complex number. For z = x + yi,

(magnitude z) = (sqrt (+ (^ x 2) (^ y 2)))

`(SINCOS X)` ^{_{[FUNCTION] · src}}

∀ :A. TRIGONOMETRIC :A ⇒ (:A → (TUPLE :A :A))

Computes the sine and cosine of X.

`(SINH X)` ^{_{[FUNCTION] · src}}

∀ :A. ELEMENTARY :A ⇒ (:A → :A)

`(TANH X)` ^{_{[FUNCTION] · src}}

∀ :A. ELEMENTARY :A ⇒ (:A → :A)

Package `COALTON-LIBRARY/MATH/FRACTION`

Values

`(DENOMINATOR Q)` ^{_{[FUNCTION] · src}}

(FRACTION → INTEGER)

The denominator of a fraction.

`(MKFRACTION A B)` ^{_{[FUNCTION] · src}}

(INTEGER → INTEGER → FRACTION)

`(NUMERATOR Q)` ^{_{[FUNCTION] · src}}

(FRACTION → INTEGER)

The numerator of a fraction.

Package `COALTON-LIBRARY/MATH/HYPERDUAL`

An implementation of hyperdual numbers for second-order and multivariate automatic differentiation.

——————————————————————————————————————————————–

For univariate differentiation of a function f at a point x, apply f to (Hyperdual x 1 1 0). The result will be (Hyperdual f(x) df/dx(x) df/dx(x) d²f/dx²(x)).

You may also use the convenience functions d-x and d-xx to compute the first and second derivatives as (d-x f x) and (d-xx f x).

——————————————————————————————————————————————–

For multivariate differentiation of a function f at a point (x, y), an application of f to (Hyperdual x 1 0 0) and (Hyperdual y 0 1 0) will result in
(Hyperdual f(x, y) ∂f/∂x(x, y) ∂f/∂y(x, y) ∂²f/∂x∂y(x, y)).

Second derivatives of a single argument xi of f are computed in the same manner as the univariate case, except the values (Hyperdual xj 0 0 0) are passed for the remaining arguments, j ≠ i.

You may also use the convenience functions partial-x, partial-y, gradient, partial-xx, partial-xy, partial-yy, hessian, and laplacian, to compute partials of bivariate functions.

——————————————————————————————————————————————–

The following list of identities describe the theory of hyperdual numbers.

:: given (∀i∀j((i ≠ j) → (εᵢεⱼ ≠ 0)) ∧ ∀i(εᵢ² = 0))

——————————————————————————————————————————————–

:: univariate identities

(1) f(a + bε₁ + cε₂ + dε₁ε₂) = f(a) + (bε₁+cε₂+dε₁ε₂)f’(a) + bcε₁ε₂f’’(a) = f(a) + bf’(a)ε₁ + cf’(a)ε₂ + [df’(a) + bcf’’(a)]ε₁ε₂

(2) f(x + ε₁ + ε₂) = f(x) + f’(x)ε₁ + f’(x)ε₂ + f’’(x)ε₁ε₂

:: multivariate identities

(3) f(a₁ + b₁ε₁ + c₁ε₂ + d₁ε₁ε₂, a₂ + b₂ε₁ + c₂ε₂ + d₂ε₁ε₂) = f(a₁, a₂) + (b₁ε₁ + c₁ε₂ + d₁ε₁ε₂)∂f/∂x(a₁, a₂) + b₁c₁ε₁ε₂∂²f/∂x²(a₁, a₂) + (b₂ε₁ + c₂ε₂ + d₂ε₁ε₂)∂f/∂y(a₁, a₂) + b₂c₂ε₁ε₂∂²f/∂y² + (b₁c₂ + b₂c₁)ε₁ε₂∂²f/∂x∂y(a₁, a₂) = f(a₁, a₂) + (b₁∂f/∂x(a₁, a₂) + b₂∂f/∂y(a₁, a₂))ε₁ + (c₁∂f/∂x(a₁, a₂) + c₂∂f/∂y(a₁, a₂))ε₂ + (d₁∂f/∂x(a₁, a₂) + d₂∂f/∂y(a₁, a₂) + b₁c₁∂²f/∂x²(a₁, a₂) + b₂c₂∂²f/∂x²(a₁, a₂) + (b₁c₂ + b₂c₁)∂²f/∂x∂y(a₁, a₂))ε₁ε₂

(4) f(x + ε₁ + ε₂, y) = f(x, y) + ∂f/∂x(x, y)ε₁ + ∂f/∂x(x, y)ε₂ + ∂²f/∂x²(x, y)ε₁ε₂

(5) f(x + ε₁, y + ε₂) = f(x, y) + ∂f/∂x(x, y)ε₁ + ∂f/∂y(x, y)ε₂ + ∂²f/∂x∂y(x, y)ε₁ε₂

(6) f(x, y + ε₁ + ε₂) = f(x, y) + ∂f/∂y(x, y)ε₁ + ∂f/∂y(x, y)ε₂ + ∂²f/∂y²(x, y)ε₁ε₂

:: equivalently

(1) (f (Hyperdual a b c d)) = (Hyperdual (f a) (* b (f’ a)) (* c (f’ a)) (+ (* d (f’ a)) (* (* b c) (f’’ a))))

(2) (f (Hyperdual x 1 1 0)) = (Hyperdual (f x) (f’ x) (f’ x) (f’’ x))

(3) (f (Hyperdual a1 b1 c1 d1) (Hyperdual a2 b2 c2 d2)) = (Hyperdual (f a1 a2) (+ (* b1 (∂f/∂x a1 a2)) (* b2 (∂f/∂y a1 a2))) (+ (* c1 (∂f/∂x a1 a2)) (* c2 (∂f/∂y a1 a2))) (+ (+ (* d1 (∂f/∂x a1 a2)) (* d2 (∂f/∂y a1 a2))) (+ (* (* b1 c1) (∂²f/∂x² a1 a2)) (* (* b2 c2) (∂²f/∂y² a1 a2))) (* (+ (* b1 c2) (* b2 c1)) (∂²f/∂x∂y a1 a2)))

(4) (f (Hyperdual x 1 1 0) (Hyperdual y 0 0 0)) = (Hyperdual (f x y) (∂f/∂x x y) (∂f/∂x x y) (∂²f/∂x² x y))

(5) (f (Hyperdual x 1 0 0) (Hyperdual y 0 1 0)) = (Hyperdual (f x y) (∂f/∂x x y) (∂f/∂y x y) (∂²f/∂x∂y x y))

(6) (f (Hyperdual x 0 0 0) (Hyperdual y 1 1 0)) = (Hyperdual (f x y) (∂f/∂x x y) (∂f/∂x x y) (∂²f/∂x² x y))

Structs

`HYPERDUAL :A` ^{_{[STRUCT] · src}}

Representation of a hyperdual number in the form a + bε₁ + cε₂ + dε₁ε₂ where a, b, c, and d are real numbers and ε₁ and ε₂ satisfy εᵢ² = 0 and ε₁ε₂ != 0.

Note: Eq, and Ord and Hash only make use of the primal component.

Instances

(EXPONENTIABLE :A) (RECIPROCABLE :A) ⇒ EXPONENTIABLE (HYPERDUAL :A)
(RADICAL :A) (RECIPROCABLE :A) (EXPONENTIABLE :A) ⇒ RADICAL (HYPERDUAL :A)
(TRIGONOMETRIC :A) (RECIPROCABLE :A) (RADICAL :A) ⇒ TRIGONOMETRIC (HYPERDUAL :A)
COMPLEXCOMPONENT :A ⇒ COMPLEXCOMPONENT (HYPERDUAL :A)
EQ :A ⇒ EQ (HYPERDUAL :A)
HASH :A ⇒ HASH (HYPERDUAL :A)
NUM :A ⇒ INTO :A (HYPERDUAL :A)
NUM :A ⇒ NUM (HYPERDUAL :A)
ORD :A ⇒ ORD (HYPERDUAL :A)
RECIPROCABLE :A ⇒ RECIPROCABLE (HYPERDUAL :A)
RUNTIMEREPR (HYPERDUAL :A)

Values

`(D-X F X)` ^{_{[FUNCTION] · src}}

∀ :A. NUM :A ⇒ (((HYPERDUAL :A) → (HYPERDUAL :A)) → :A → :A)

Compute f’(x).

`(D-XX F X)` ^{_{[FUNCTION] · src}}

∀ :A. NUM :A ⇒ (((HYPERDUAL :A) → (HYPERDUAL :A)) → :A → :A)

Compute f’’(x).

`(GRADIENT F X Y)` ^{_{[FUNCTION] · src}}

∀ :A. NUM :A ⇒ (((HYPERDUAL :A) → (HYPERDUAL :A) → (HYPERDUAL :A)) → :A → :A → (LIST :A))

Compute the gradient (∂f/∂x, ∂f/∂y) at the point (x, y).

`(HESSIAN F X Y)` ^{_{[FUNCTION] · src}}

∀ :A. NUM :A ⇒ (((HYPERDUAL :A) → (HYPERDUAL :A) → (HYPERDUAL :A)) → :A → :A → (LIST :A))

Compute the flat Hessian (∂²f/∂x², ∂²f/∂x∂y, ∂²f/∂y∂x, ∂²f/∂y²) at the point (x, y).

`(LAPLACIAN F X Y)` ^{_{[FUNCTION] · src}}

∀ :A. NUM :A ⇒ (((HYPERDUAL :A) → (HYPERDUAL :A) → (HYPERDUAL :A)) → :A → :A → :A)

Compute the Laplacian ∂²f/∂x² + ∂²f/∂y² at the point (x, y).

`(PARTIAL-X F X Y)` ^{_{[FUNCTION] · src}}

∀ :A. NUM :A ⇒ (((HYPERDUAL :A) → (HYPERDUAL :A) → (HYPERDUAL :A)) → :A → :A → :A)

Compute ∂f/∂x(x, y).

`(PARTIAL-XX F X Y)` ^{_{[FUNCTION] · src}}

∀ :A. NUM :A ⇒ (((HYPERDUAL :A) → (HYPERDUAL :A) → (HYPERDUAL :A)) → :A → :A → :A)

Compute ∂²f/∂x²(x, y).

`(PARTIAL-XY F X Y)` ^{_{[FUNCTION] · src}}

∀ :A. NUM :A ⇒ (((HYPERDUAL :A) → (HYPERDUAL :A) → (HYPERDUAL :A)) → :A → :A → :A)

Compute ∂²f/∂x∂y(x, y).

`(PARTIAL-Y F X Y)` ^{_{[FUNCTION] · src}}

∀ :A. NUM :A ⇒ (((HYPERDUAL :A) → (HYPERDUAL :A) → (HYPERDUAL :A)) → :A → :A → :A)

Compute ∂f/∂y(x, y).

`(PARTIAL-YY F X Y)` ^{_{[FUNCTION] · src}}

∀ :A. NUM :A ⇒ (((HYPERDUAL :A) → (HYPERDUAL :A) → (HYPERDUAL :A)) → :A → :A → :A)

Compute ∂²f/∂y²(x, y).

Package `COALTON-LIBRARY/MATH/INTEGRAL`

Classes

`INTEGRAL` ^{_{[CLASS] · src}}

(REMAINDER :A) (ORD :A) ⇒ INTEGRAL :A

Integral is a number that is either even or odd where div and quot are floored and truncated division, respectively.

Methods:

TOINTEGER :: (:A → INTEGER)

Instances

INTEGRAL UFIX
INTEGRAL U64
INTEGRAL U32
INTEGRAL U16
INTEGRAL U8
INTEGRAL BIT
INTEGRAL IFIX
INTEGRAL I64
INTEGRAL I32
INTEGRAL I16
INTEGRAL I8
INTEGRAL INTEGER

`REMAINDER` ^{_{[CLASS] · src}}

NUM :A ⇒ REMAINDER :A

Remainder is typically an integral domain satisfying:

a = (+ (* b (quot a b)) (rem a b))
a = (+ (* b (div a b)) (mod a b))

Methods:

QUOT :: (:A → :A → :A)
REM :: (:A → :A → :A)
QUOTREM :: (:A → :A → (TUPLE :A :A))
DIV :: (:A → :A → :A)
MOD :: (:A → :A → :A)
DIVMOD :: (:A → :A → (TUPLE :A :A))

Instances

REMAINDER F64
REMAINDER F32
REMAINDER FRACTION
REMAINDER UFIX
REMAINDER U64
REMAINDER U32
REMAINDER U16
REMAINDER U8
REMAINDER BIT
REMAINDER IFIX
REMAINDER I64
REMAINDER I32
REMAINDER I16
REMAINDER I8
REMAINDER INTEGER

Values

`(EVEN? N)` ^{_{[FUNCTION] · src}}

∀ :A. INTEGRAL :A ⇒ (:A → BOOLEAN)

Is N even?

`(GCD A B)` ^{_{[FUNCTION] · src}}

∀ :A. (REMAINDER :A) (ORD :A) ⇒ (:A → :A → :A)

The greatest common divisor of A and B.

`(ILOG B X)` ^{_{[FUNCTION] · src}}

∀ :A. INTEGRAL :A ⇒ (:A → :A → :A)

The floor of the logarithm with base B > 1 of X >= 1.

`(INTEGRAL->NUM N)` ^{_{[FUNCTION] · src}}

∀ :A :B. (INTEGRAL :A) (NUM :B) ⇒ (:A → :B)

Converts any Integral N into any Num.

`(ISQRT X)` ^{_{[FUNCTION] · src}}

∀ :A. INTEGRAL :A ⇒ (:A → :A)

The floor of the square root of N > 0.

`(LCM A B)` ^{_{[FUNCTION] · src}}

∀ :A. (REMAINDER :A) (ORD :A) ⇒ (:A → :A → :A)

The least common multiple of A and B.

`(LSH X N)` ^{_{[FUNCTION] · src}}

∀ :A :B. (INTEGRAL :B) (BITS :A) ⇒ (:A → :B → :A)

Left shift X by N

`(ODD? N)` ^{_{[FUNCTION] · src}}

∀ :A. INTEGRAL :A ⇒ (:A → BOOLEAN)

Is N odd?

`(RSH X N)` ^{_{[FUNCTION] · src}}

∀ :A :B. (INTEGRAL :B) (BITS :A) ⇒ (:A → :B → :A)

Right shift X by N

`(^ BASE POWER)` ^{_{[FUNCTION] · src}}

∀ :A :B. (NUM :A) (INTEGRAL :B) ⇒ (:A → :B → :A)

Exponentiate BASE to a non-negative POWER.

`(^^ BASE POWER)` ^{_{[FUNCTION] · src}}

∀ :A :B. (RECIPROCABLE :A) (INTEGRAL :B) ⇒ (:A → :B → :A)

Exponentiate BASE to a signed POWER.

Package `COALTON-LIBRARY/MATH/REAL`

Structs

`QUANTIZATION :A` ^{_{[STRUCT] · src}}

Represents an integer quantization of :a.

Instances

RUNTIMEREPR (QUANTIZATION :A)

Classes

`QUANTIZABLE` ^{_{[CLASS] · src}}

QUANTIZABLE :A

The representation of a type that allows for rounding operations

max x such that (floor x) <= x
min x such that (ceiling x) <= x

And

(proper x) = (Tuple (truncate x) (- x (truncate x)))

where

(truncate x) = (* (sign x) (floor (abs x))

Methods:

PROPER :: (:A → (TUPLE INTEGER :A))
FLOOR :: (:A → INTEGER)
CEILING :: (:A → INTEGER)

Instances

QUANTIZABLE CREAL
QUANTIZABLE BIG-FLOAT
QUANTIZABLE DYADIC
QUANTIZABLE F64
QUANTIZABLE F32
QUANTIZABLE FRACTION
QUANTIZABLE INTEGER
QUANTIZABLE IFIX
QUANTIZABLE I64
QUANTIZABLE I32
QUANTIZABLE I8
QUANTIZABLE UFIX
QUANTIZABLE U64
QUANTIZABLE U32
QUANTIZABLE U8
QUANTIZABLE BIT

`RATIONAL` ^{_{[CLASS] · src}}

(REAL :A) (ORD :A) ⇒ RATIONAL :A

Any number that can be exactly represented by a fraction, or is not finite.

If a rational can be converted from a fraction it must satisfy:

(into (to-fraction x)) = x
(into (best-approx x)) = x

Furthermore, best-approx returns the simplest fraction, and both functions may be partial.

Methods:

TO-FRACTION :: (:A → FRACTION)
BEST-APPROX :: (:A → FRACTION)

Instances

RATIONAL BIG-FLOAT
RATIONAL DYADIC
RATIONAL F64
RATIONAL F32
RATIONAL FRACTION
RATIONAL INTEGER
RATIONAL IFIX
RATIONAL I64
RATIONAL I32
RATIONAL I8
RATIONAL UFIX
RATIONAL U64
RATIONAL U32
RATIONAL U8
RATIONAL BIT

`REAL` ^{_{[CLASS] · src}}

(QUANTIZABLE :A) (NUM :A) ⇒ REAL :A

A real number that can be approximated with abs(real-approx x - x) < 2^-n.

Methods:

REAL-APPROX :: (UFIX → :A → FRACTION)

Instances

REAL CREAL
REAL BIG-FLOAT
REAL DYADIC
REAL F64
REAL F32
REAL FRACTION
REAL INTEGER
REAL IFIX
REAL I64
REAL I32
REAL I8
REAL UFIX
REAL U64
REAL U32
REAL U8
REAL BIT

Values

`(CEILING/ A B)` ^{_{[FUNCTION] · src}}

Divide two integers and compute the ceiling of the quotient.

`(EXACT/ A B)` ^{_{[FUNCTION] · src}}

(INTEGER → INTEGER → FRACTION)

Exactly divide two integers and produce a fraction.

`(FLOOR/ A B)` ^{_{[FUNCTION] · src}}

Divide two integers and compute the floor of the quotient.

`(FROMFRAC Q)` ^{_{[FUNCTION] · src}}

∀ :A. DIVIDABLE INTEGER :A ⇒ (FRACTION → :A)

Converts a fraction to a target type.

Specifically, target types must have an instance of Dividable Integer :a.

This conversion may result in loss of fidelity.

`(INEXACT/ A B)` ^{_{[FUNCTION] · src}}

(INTEGER → INTEGER → F64)

Compute the quotient of integers as a double-precision float.

Note: This does not divide double-float arguments.

`(QUANTIZE X)` ^{_{[FUNCTION] · src}}

∀ :A. REAL :A ⇒ (:A → (QUANTIZATION :A))

Given X, (QUANTIZE X) will return the least integer greater or equal to X, and the greatest integer less than or equal to X, along with their respective remainders expressed as values of type of X.

`(ROUND X)` ^{_{[FUNCTION] · src}}

∀ :A. (QUANTIZABLE :A) (NUM :A) ⇒ (:A → INTEGER)

Return the nearest integer to X, with ties breaking towards even numbers.

`(ROUND-HALF-DOWN X)` ^{_{[FUNCTION] · src}}

∀ :A. (QUANTIZABLE :A) (NUM :A) ⇒ (:A → INTEGER)

Return the nearest integer to X, with ties breaking toward positive infinity.

`(ROUND-HALF-UP X)` ^{_{[FUNCTION] · src}}

∀ :A. (QUANTIZABLE :A) (NUM :A) ⇒ (:A → INTEGER)

Return the nearest integer to X, with ties breaking toward positive infinity.

`(ROUND/ A B)` ^{_{[FUNCTION] · src}}

Divide two integers and round the quotient.

`(SAFE/ X Y)` ^{_{[FUNCTION] · src}}

∀ :A :B. (NUM :A) (DIVIDABLE :A :B) ⇒ (:A → :A → (OPTIONAL :B))

Safely divide X by Y, returning None if Y is zero.

`(TRUNCATE X)` ^{_{[FUNCTION] · src}}

∀ :A. QUANTIZABLE :A ⇒ (:A → INTEGER)

Returns the integer closest/equal to x that is within 0 and x.

Package `COALTON-LIBRARY/MONAD/CLASSES`

Classes

`MONADENVIRONMENT` ^{_{[CLASS] · src}}

MONAD :A ⇒ MONADENVIRONMENT :B :A

A monad capable of a function in a computation environment.

Methods:

ASK :: (:A :B)
Retrieves the computation environment.
LOCAL :: ((:B → :B) → (:A :C) → (:A :C))
Run a computation in a modified environment.
ASKS :: ((:B → :D) → (:A :D))
Retrieve an aspect of the computation environment.

Instances

MONADENVIRONMENT :A :B ⇒ MONADENVIRONMENT :A (OPTIONALT :B)
MONADENVIRONMENT :A :B ⇒ MONADENVIRONMENT :A ((RESULTT :C) :B)
MONAD :A ⇒ MONADENVIRONMENT :B ((ENVT :B) :A)
MONADENVIRONMENT :A (ENV :A)
MONADENVIRONMENT :A :B ⇒ MONADENVIRONMENT :A ((STATET :C) :B)

`MONADSTATE` ^{_{[CLASS] · src}}

MONAD :A ⇒ MONADSTATE :B :A

A monad capable of tracking state in a computation.

Methods:

GET :: (:A :B)
Retrieve the computation state.
PUT :: (:B → (:A UNIT))
Set the state to a given value.
MODIFY :: ((:B → :B) → (:A UNIT))
Modify the computation state, discarding the old state.

Instances

MONADSTATE :A :B ⇒ MONADSTATE :A (OPTIONALT :B)
MONADSTATE :A :B ⇒ MONADSTATE :A ((RESULTT :C) :B)
MONADSTATE :A :B ⇒ MONADSTATE :A ((ENVT :C) :B)
MONAD :A ⇒ MONADSTATE :B ((STATET :B) :A)

Package `COALTON-LIBRARY/MONAD/ENVIRONMENT`

Types

`ENV` ^{_{[TYPE] · src}}

(ENV (:A → :B))

A computation that runs inside an :env environment.

Instances

APPLICATIVE (ENV :A)
FUNCTOR (ENV :A)
MONAD (ENV :A)
MONADENVIRONMENT :A (ENV :A)
RUNTIMEREPR (ENV :A :B)

`ENVT` ^{_{[TYPE] · src}}

(ENVT (:A → (:B :C)))

A monadic computation that runs inside an :env environment. Equivalent to Haskell’s ReaderT monad https://hackage.haskell.org/package/transformers-0.6.1.2/docs/Control-Monad-Trans-Reader.html

Instances

APPLICATIVE :A ⇒ APPLICATIVE ((ENVT :B) :A)
FUNCTOR :A ⇒ FUNCTOR ((ENVT :B) :A)
MONAD :A ⇒ MONAD ((ENVT :B) :A)
MONAD :A ⇒ MONADENVIRONMENT :B ((ENVT :B) :A)
MONADSTATE :A :B ⇒ MONADSTATE :A ((ENVT :C) :B)
MONADTRANSFORMER (ENVT :A)
RUNTIMEREPR (((ENVT :A) :B) :C)

Values

`(ASKS-ENV FENV->A)` ^{_{[FUNCTION] · src}}

∀ :A :B. ((:A → :B) → (ENV :A :B))

Retrieve an aspect of the computation environment.

`(ASKS-ENVT FENV->A)` ^{_{[FUNCTION] · src}}

∀ :A :B :C. APPLICATIVE :C ⇒ ((:A → :B) → (((ENVT :A) :C) :B))

Retrieve an aspect of the computation environment.

`(LIFT-ENVT M)` ^{_{[FUNCTION] · src}}

∀ :A :B :C. ((:A :B) → (((ENVT :C) :A) :B))

`(LOCAL-ENV FENV MENV)` ^{_{[FUNCTION] · src}}

∀ :A :B. ((:A → :A) → (ENV :A :B) → (ENV :A :B))

`(LOCAL-ENVT FENV (ENVT FENV->A))` ^{_{[FUNCTION] · src}}

∀ :A :B :C. ((:A → :A) → (((ENVT :A) :B) :C) → (((ENVT :A) :B) :C))

Run a computation in a modified environment.

`(MAP-ENVT FMA->NB (ENVT FENV->MA))` ^{_{[FUNCTION] · src}}

∀ :A :B :C :D :E. (((:A :B) → (:C :D)) → (((ENVT :E) :A) :B) → (((ENVT :E) :C) :D))

`(RUN-ENV (ENV ENV-COMPUTATION) ENV)` ^{_{[FUNCTION] · src}}

∀ :A :B. ((ENV :A :B) → :A → :B)

Run a Env inside an environment.

`(RUN-ENVT (ENVT FENV->VAL) ENV)` ^{_{[FUNCTION] · src}}

∀ :A :B :C. ((((ENVT :A) :B) :C) → :A → (:B :C))

Run a EnvT inside an environment.

`ASK-ENV` ^{_{[VALUE] · src}}

∀ :A. (ENV :A :A)

Retrieve the computation environment.

`ASK-ENVT` ^{_{[VALUE] · src}}

∀ :A :B. MONAD :B ⇒ (((ENVT :A) :B) :A)

Retrieve the computation environment.

Package `COALTON-LIBRARY/MONAD/FREE`

Types

`FREE` ^{_{[TYPE] · src}}

(FREE (:A ((FREE :A) :B)))
(VAL :C)

Free :f gives you a Monad instance for any Functor :f.

References: here and here

Instances

FOLDABLE :A ⇒ FOLDABLE (FREE :A)
FUNCTOR :A ⇒ APPLICATIVE (FREE :A)
FUNCTOR :A ⇒ FUNCTOR (FREE :A)
FUNCTOR :A ⇒ MONAD (FREE :A)
FUNCTOR :A ⇒ MONADFREE :A (FREE :A)
RUNTIMEREPR ((FREE :A) :B)
TRAVERSABLE :A ⇒ TRAVERSABLE (FREE :A)

Classes

`MONADFREE` ^{_{[CLASS] · src}}

MONAD :A ⇒ MONADFREE :B :A

A free monad is a monad, :m, which is capable of ‘wrapping’ around functors, and then ‘unwrapping’ them later using >>=.

Methods:

WRAP :: ((:B (:A :C)) → (:A :C))

Instances

(FUNCTOR :A) (MONAD :B) ⇒ MONADFREE :A ((FREET :A) :B)
FUNCTOR :A ⇒ MONADFREE :A (FREE :A)

Values

`(FOLDFREE NAT FR)` ^{_{[FUNCTION] · src}}

∀ :A :B :C. MONAD :C ⇒ (((:A ((FREE :A) :B)) → (:C ((FREE :A) :B))) → ((FREE :A) :B) → (:C :B))

Given a natural transformation, induce a Monad homomorphism from a free monad to a target monad.

`(LIFTF F)` ^{_{[FUNCTION] · src}}

∀ :A :B :C. (FUNCTOR :A) (MONADFREE :A :C) ⇒ ((:A :B) → (:C :B))

Lift a Functor into the Free Monad.

Package `COALTON-LIBRARY/MONAD/FREET`

Types

`FREEF` ^{_{[TYPE] · src}}

(FREEF (:A :B))
(VAL :C)

Instances

FUNCTOR :A ⇒ BIFUNCTOR (FREEF :A)
FUNCTOR :A ⇒ FUNCTOR ((FREEF :A) :B)
RUNTIMEREPR (((FREEF :A) :B) :C)
TRAVERSABLE :A ⇒ TRAVERSABLE ((FREEF :A) :B)

`FREET` ^{_{[TYPE] · src}}

(FREET (:A (((FREEF :B) :C) (((FREET :B) :A) :C))))

Free :f :m :a gives you a Monad Transformer instance for any Functor :f and Monad :m.

Instances

(FUNCTOR :A) (FUNCTOR :B) ⇒ FUNCTOR ((FREET :A) :B)
(FUNCTOR :A) (MONAD :B) ⇒ APPLICATIVE ((FREET :A) :B)
(FUNCTOR :A) (MONAD :B) ⇒ MONAD ((FREET :A) :B)
(FUNCTOR :A) (MONAD :B) ⇒ MONADFREE :A ((FREET :A) :B)
(MONAD :A) (TRAVERSABLE :A) (TRAVERSABLE :B) ⇒ TRAVERSABLE ((FREET :B) :A)
FUNCTOR :A ⇒ MONADTRANSFORMER (FREET :A)
RUNTIMEREPR (((FREET :A) :B) :C)

Values

`(FOLD-FREET F (FREET M))` ^{_{[FUNCTION] · src}}

∀ :A :B :C :D. (MONADTRANSFORMER :D) (MONAD (:D :B)) (MONAD :B) ⇒ (((:A (((FREET :A) :B) :C)) → ((:D :B) (((FREET :A) :B) :C))) → (((FREET :A) :B) :C) → ((:D :B) :C))

`(RUN-FREET (FREET M))` ^{_{[FUNCTION] · src}}

∀ :A :B :C. ((((FREET :A) :B) :C) → (:B (((FREEF :A) :C) (((FREET :A) :B) :C))))

Package `COALTON-LIBRARY/MONAD/IDENTITY`

Types

`IDENTITY` ^{_{[TYPE] · src}}

(IDENTITY :A)

A bare computation. Not useful on its own, but is useful for running Monad transformers in a bare context.

Instances

APPLICATIVE IDENTITY
FUNCTOR IDENTITY
MONAD IDENTITY
RUNTIMEREPR (IDENTITY :A)

Values

`(RUN-IDENTITY (IDENTITY A))` ^{_{[FUNCTION] · src}}

∀ :A. ((IDENTITY :A) → :A)

Package `COALTON-LIBRARY/MONAD/OPTIONALT`

Types

`OPTIONALT` ^{_{[TYPE] · src}}

(OPTIONALT (:A (OPTIONAL :B)))

A monadic computation that returns an Optional.

Instances

FUNCTOR :A ⇒ FUNCTOR (OPTIONALT :A)
MONAD :A ⇒ ALTERNATIVE (OPTIONALT :A)
MONAD :A ⇒ APPLICATIVE (OPTIONALT :A)
MONAD :A ⇒ MONAD (OPTIONALT :A)
MONADENVIRONMENT :A :B ⇒ MONADENVIRONMENT :A (OPTIONALT :B)
MONADSTATE :A :B ⇒ MONADSTATE :A (OPTIONALT :B)
MONADTRANSFORMER OPTIONALT
RUNTIMEREPR ((OPTIONALT :A) :B)

Values

`(MAP-OPTIONALT F (OPTIONALT M))` ^{_{[FUNCTION] · src}}

∀ :A :B :C :D. (((:A (OPTIONAL :B)) → (:C (OPTIONAL :D))) → ((OPTIONALT :A) :B) → ((OPTIONALT :C) :D))

`(RUN-OPTIONALT (OPTIONALT M))` ^{_{[FUNCTION] · src}}

∀ :A :B. (((OPTIONALT :A) :B) → (:A (OPTIONAL :B)))

Package `COALTON-LIBRARY/MONAD/RESULTT`

Types

`RESULTT` ^{_{[TYPE] · src}}

(RESULTT (:A (RESULT :B :C)))

A monadic computation that returns a Result.

Instances

FUNCTOR :A ⇒ FUNCTOR ((RESULTT :B) :A)
MONAD :A ⇒ APPLICATIVE ((RESULTT :B) :A)
MONAD :A ⇒ MONAD ((RESULTT :B) :A)
MONADENVIRONMENT :A :B ⇒ MONADENVIRONMENT :A ((RESULTT :C) :B)
MONADSTATE :A :B ⇒ MONADSTATE :A ((RESULTT :C) :B)
MONADTRANSFORMER (RESULTT :A)
RUNTIMEREPR (((RESULTT :A) :B) :C)

Values

`(ERR-IFT PASSED FAILURE)` ^{_{[FUNCTION] · src}}

∀ :A :B. MONAD :B ⇒ (BOOLEAN → :A → (((RESULTT :A) :B) UNIT))

`(MAP-ERRT FERR)` ^{_{[FUNCTION] · src}}

∀ :A :B :C :D. FUNCTOR :C ⇒ ((:A → :B) → (((RESULTT :A) :C) :D) → (((RESULTT :B) :C) :D))

`(MAP-RESULTT F (RESULTT M))` ^{_{[FUNCTION] · src}}

∀ :A :B :C :D :E :F. (((:A (RESULT :B :C)) → (:D (RESULT :E :F))) → (((RESULTT :B) :A) :C) → (((RESULTT :E) :D) :F))

`(RUN-RESULTT (RESULTT M))` ^{_{[FUNCTION] · src}}

∀ :A :B :C. ((((RESULTT :A) :B) :C) → (:B (RESULT :A :C)))

Package `COALTON-LIBRARY/MONAD/STATE`

Types

`ST` ^{_{[TYPE] · src}}

(ST (:A → (TUPLE :A :B)))

A computation of a value which may affect the state. Represented as a closure from initial state to updated state and value.

Instances

APPLICATIVE (ST :A)
FUNCTOR (ST :A)
MONAD (ST :A)
RUNTIMEREPR (ST :A :B)

Values

`(MODIFY FS->S)` ^{_{[FUNCTION] · src}}

∀ :A. ((:A → :A) → (ST :A UNIT))

Modify the state in a StatefulComputation, discarding the old state.

`(MODIFY-GET FS->S)` ^{_{[FUNCTION] · src}}

∀ :A. ((:A → :A) → (ST :A :A))

Modify the state in a StatefulComputation, discarding the old state. Return the new state.

`(MODIFY-SWAP FS->S)` ^{_{[FUNCTION] · src}}

∀ :A. ((:A → :A) → (ST :A :A))

Modify the state in a StatefulComputation, returning the old state.

`(PUT STATE)` ^{_{[FUNCTION] · src}}

∀ :A. (:A → (ST :A UNIT))

A StatefulComputation with state set to be the given state. The returned value is Unit.

`(RUN SC)` ^{_{[FUNCTION] · src}}

∀ :A :B. ((ST :A :B) → :A → (TUPLE :A :B))

Runs a StatefulComputation to produce a final updated state and value given an initial state

`(SWAP STATE)` ^{_{[FUNCTION] · src}}

∀ :A. (:A → (ST :A :A))

A StatefulComputation with state set to be the given state. The old state is returned.

`GET` ^{_{[VALUE] · src}}

∀ :A. (ST :A :A)

A StatefulComputation which returns the current state as the value.

Package `COALTON-LIBRARY/MONAD/STATET`

Types

`STATET` ^{_{[TYPE] · src}}

(STATET (:A → (:B (TUPLE :A :C))))

A monadic computation that tracks state of type :s.

Instances

APPLICATIVE :A ⇒ APPLICATIVE ((STATET :B) :A)
FUNCTOR :A ⇒ FUNCTOR ((STATET :B) :A)
MONAD :A ⇒ MONAD ((STATET :B) :A)
MONAD :A ⇒ MONADSTATE :B ((STATET :B) :A)
MONADENVIRONMENT :A :B ⇒ MONADENVIRONMENT :A ((STATET :C) :B)
MONADTRANSFORMER (STATET :A)
RUNTIMEREPR (((STATET :A) :B) :C)

Values

`(LIFT-STATET M)` ^{_{[FUNCTION] · src}}

∀ :A :B :C. FUNCTOR :A ⇒ ((:A :B) → (((STATET :C) :A) :B))

Lift a stateless computation into a stateful context.

`(MAP-STATET FMA->NB (STATET FS->MSA))` ^{_{[FUNCTION] · src}}

∀ :A :B :C :D :E. (((:A (TUPLE :B :C)) → (:D (TUPLE :B :E))) → (((STATET :B) :A) :C) → (((STATET :B) :D) :E))

Map the return value, the final state, and the execution context.

`(MODIFY-STATET FS->S)` ^{_{[FUNCTION] · src}}

∀ :A :B. APPLICATIVE :B ⇒ ((:A → :A) → (((STATET :A) :B) UNIT))

Modify the computation state, discarding the old state.

`(PUT-STATET STATE)` ^{_{[FUNCTION] · src}}

∀ :A :B. APPLICATIVE :B ⇒ (:A → (((STATET :A) :B) UNIT))

A stateful computation with state set to the given state. The returned value is Unit.

`(RUN-STATET (STATET FS->MSA) S)` ^{_{[FUNCTION] · src}}

∀ :A :B :C. APPLICATIVE :B ⇒ ((((STATET :A) :B) :C) → :A → (:B (TUPLE :A :C)))

`GET-STATET` ^{_{[VALUE] · src}}

∀ :A :B. APPLICATIVE :B ⇒ (((STATET :A) :B) :A)

A stateful computation which returns the current state as the value.

Package `COALTON-LIBRARY/OPTIONAL`

Values

`(FROM-SOME STR OPT)` ^{_{[FUNCTION] · src}}

∀ :A. (STRING → (OPTIONAL :A) → :A)

Get the value of OPT, erroring with the provided string if it is None.

`(NONE? X)` ^{_{[FUNCTION] · src}}

∀ :A. ((OPTIONAL :A) → BOOLEAN)

Is X None?

`(SOME? X)` ^{_{[FUNCTION] · src}}

∀ :A. ((OPTIONAL :A) → BOOLEAN)

Is X Some?

Package `COALTON-LIBRARY/ORDMAP`

Types

`ORDMAP` ^{_{[TYPE] · src}}

A red-black binary tree which associates each :KEY with a :VALUE, sorted by <=>' on the keys and unique by ==’ on the keys.

Instances

(EQ :A) (EQ :B) ⇒ EQ (ORDMAP :A :B)
(HASH :A) (HASH :B) ⇒ HASH (ORDMAP :A :B)
FUNCTOR (ORDMAP :A)
INTOITERATOR (ORDMAP :A :B) (TUPLE :A :B)
ORD :A ⇒ FROMITERATOR (ORDMAP :A :B) (TUPLE :A :B)
ORD :A ⇒ SEMIGROUP (ORDMAP :A :B)
RUNTIMEREPR (ORDMAP :A :B)

Values

`(COLLECT COLL)` ^{_{[FUNCTION] · src}}

∀ :A :B :C. (ORD :B) (FOLDABLE :A) ⇒ ((:A (TUPLE :B :C)) → (ORDMAP :B :C))

Construct a OrdMap containing all the (key value) pairs in coll.

If coll contains duplicate keys, later values will overwrite earlier values.

`(COLLECT! ITER)` ^{_{[FUNCTION] · src}}

∀ :A :B. ORD :A ⇒ ((ITERATOR (TUPLE :A :B)) → (ORDMAP :A :B))

Construct a OrdMap containing all the (key value) pairs in iter.

If iter contains duplicate keys, later values will overwrite earlier values.

`(ENTRIES MP)` ^{_{[FUNCTION] · src}}

∀ :A :B. ((ORDMAP :A :B) → (ITERATOR (TUPLE :A :B)))

Iterate over the (key value) pairs in MP, sorted by the keys in least-to-greatest order.

`(INSERT MP K V)` ^{_{[FUNCTION] · src}}

∀ :A :B. ORD :A ⇒ ((ORDMAP :A :B) → :A → :B → (OPTIONAL (ORDMAP :A :B)))

Associate K with V in MP. If MP already contains a mapping for K, return None.

`(INSERT-OR-REPLACE MP K V)` ^{_{[FUNCTION] · src}}

∀ :A :B. ORD :A ⇒ ((ORDMAP :A :B) → :A → :B → (ORDMAP :A :B))

Update MP to associate K with V.

If MP already contains a mapping for K, replace it and discard the old value.

Like `replace-or-insert’, but prioritizing insertion as a use case.

`(KEYS MP)` ^{_{[FUNCTION] · src}}

∀ :A :B. ((ORDMAP :A :B) → (ITERATOR :A))

Iterate over the keys in MP, sorted least-to-greatest.

`(LOOKUP MP K)` ^{_{[FUNCTION] · src}}

∀ :A :B. ORD :A ⇒ ((ORDMAP :A :B) → :A → (OPTIONAL :B))

Retrieve the value associated with K in MP, or None if MP does not contain K.

`(MERGE A B)` ^{_{[FUNCTION] · src}}

∀ :A :B. ORD :A ⇒ ((ORDMAP :A :B) → (ORDMAP :A :B) → (ORDMAP :A :B))

Construct a Tree containing all the mappings of both A and B.

If A and B contain mappings X -> A’ and X -> B’, it is undefined whether the result maps X to A’ or B’.

Because of the possibility that A and B will map the same X to different A’ and B’, this is not an associative operation, and therefore OrdMap cannot implement Monoid.

`(REMOVE MP K)` ^{_{[FUNCTION] · src}}

∀ :A :B. ORD :A ⇒ ((ORDMAP :A :B) → :A → (OPTIONAL (ORDMAP :A :B)))

Remove the mapping associated with K in MP. If K does not have a value in MP, return None.

`(REPLACE MP K V)` ^{_{[FUNCTION] · src}}

∀ :A :B. ORD :A ⇒ ((ORDMAP :A :B) → :A → :B → (OPTIONAL (TUPLE (ORDMAP :A :B) :B)))

Change the association of K to V in MP. If MP did not already contain a mapping for K, return None.

`(REPLACE-OR-INSERT MP K V)` ^{_{[FUNCTION] · src}}

∀ :A :B. ORD :A ⇒ ((ORDMAP :A :B) → :A → :B → (TUPLE (ORDMAP :A :B) (OPTIONAL :B)))

Update MP to associate K with V.

If MP already contains a mapping for K, replace it and return the old value.

`(UPDATE FUNC MP KEY)` ^{_{[FUNCTION] · src}}

∀ :A :B. ORD :B ⇒ ((:A → :A) → (ORDMAP :B :A) → :B → (OPTIONAL (ORDMAP :B :A)))

Apply FUNC to the value corresponding to KEY in MP, returning a new `OrdMap’ which maps KEY to the result of the function.

`(VALUES MP)` ^{_{[FUNCTION] · src}}

∀ :A :B. ((ORDMAP :A :B) → (ITERATOR :B))

Iterate over the values in MP, sorted by their corresponding keys in least-to-greatest order.

`EMPTY` ^{_{[VALUE] · src}}

∀ :A :B. (ORDMAP :A :B)

A OrdMap containing no mappings.

Package `COALTON-LIBRARY/ORDTREE`

Types

`TREE` ^{_{[TYPE] · src}}

EMPTY
- exported; an empty tree. considered black for the purpose of the invariants.

A red-black balanced binary tree, sorted by <=> and unique by ==.

Instances

EQ :A ⇒ EQ (TREE :A)
FOLDABLE TREE
HASH :A ⇒ HASH (TREE :A)
INTOITERATOR (TREE :A) :A
ORD :A ⇒ FROMITERATOR (TREE :A) :A
ORD :A ⇒ MONOID (TREE :A)
ORD :A ⇒ SEMIGROUP (TREE :A)
RUNTIMEREPR (TREE :A)

Values

`(COLLECT! ITER)` ^{_{[FUNCTION] · src}}

∀ :A. ORD :A ⇒ ((ITERATOR :A) → (TREE :A))

Construct a Tree containing all the elements of ITER.

If ITER contains duplicates, later elements will overwrite earlier elements.

`(DECREASING-ORDER)` ^{_{[FUNCTION] · src}}

∀ :A. ((TREE :A) → (ITERATOR :A))

Iterate the elements of a tree, starting with the greatest by `<=>’ and ending with the least.

`(INCREASING-ORDER)` ^{_{[FUNCTION] · src}}

∀ :A. ((TREE :A) → (ITERATOR :A))

Iterate the elements of a tree, starting with the least by `<=>’ and ending with the greatest.

`(INSERT TRE ELT)` ^{_{[FUNCTION] · src}}

∀ :A. ORD :A ⇒ ((TREE :A) → :A → (OPTIONAL (TREE :A)))

Construct a new Tree like TRE but containing ELT. If TRE already had an element == to ELT, return None.

`(INSERT-OR-REPLACE TRE ELT)` ^{_{[FUNCTION] · src}}

∀ :A. ORD :A ⇒ ((TREE :A) → :A → (TREE :A))

Construct a new Tree like TRE but containing ELT.

If TRE already had an element == to ELT, remove it, replace it with ELT, and discard the removed value.

Like replace-or-insert, but prioritizing insertion as a use case.

`(LOOKUP HAYSTACK NEEDLE)` ^{_{[FUNCTION] · src}}

∀ :A. ORD :A ⇒ ((TREE :A) → :A → (OPTIONAL :A))

If HAYSTACK contains an element == to NEEDLE, return it.

`(MERGE A B)` ^{_{[FUNCTION] · src}}

∀ :A. ORD :A ⇒ ((TREE :A) → (TREE :A) → (TREE :A))

Construct a Tree containing all the elements of both A and B.

If A and B contain elements A’ and B’ respectively where (== A’ B’), the result will contain either A’ or B’. Which one is chosen for the result is undefined.

`(REMOVE TRE ELT)` ^{_{[FUNCTION] · src}}

∀ :A. ORD :A ⇒ ((TREE :A) → :A → (OPTIONAL (TREE :A)))

Construct a new Tree like TRE but without an element ==' to ELT. Return None if TRE does not contain an element ==` to ELT.

`(REPLACE TRE ELT)` ^{_{[FUNCTION] · src}}

∀ :A. ORD :A ⇒ ((TREE :A) → :A → (OPTIONAL (TUPLE (TREE :A) :A)))

Construct a new Tree like TRE but with ELT replacing an old element == to ELT.

Return the new tree and the removed element.

If TRE did not have an element `==’ to ELT, return None.

`(REPLACE-OR-INSERT TRE ELT)` ^{_{[FUNCTION] · src}}

∀ :A. ORD :A ⇒ ((TREE :A) → :A → (TUPLE (TREE :A) (OPTIONAL :A)))

Construct a new Tree like TRE but containing ELT.

If TRE already had an element == to ELT, remove it, replace it with ELT, and return the removed value alongside the new tree.

Macros

`MAKE (&REST ELEMENTS)` ^_[MACRO]

Construct a tree containing the elements.

e.g. (tree:make 5 6 1 8 9) returns a tree containing 1, 5, 6, 8, 9.

Package `COALTON-LIBRARY/QUEUE`

Types

`QUEUE` ^{_{[TYPE] · src}}

Unbounded FIFO queue implemented with a linked list.

Instances

DEFAULT (QUEUE :A)
EQ :A ⇒ EQ (QUEUE :A)
FOLDABLE QUEUE
FROMITERATOR (QUEUE :A) :A
FUNCTOR QUEUE
INTOITERATOR (QUEUE :A) :A
RUNTIMEREPR (QUEUE :A)
SEMIGROUP (QUEUE :A)

Values

`(APPEND Q1 Q2)` ^{_{[FUNCTION] · src}}

∀ :A. ((QUEUE :A) → (QUEUE :A) → (QUEUE :A))

Create a new queue containing the elements of q1 followed by the elements of q2.

`(CLEAR! Q)` ^{_{[FUNCTION] · src}}

∀ :A. ((QUEUE :A) → UNIT)

Clear all elements from q.

`(COPY Q)` ^{_{[FUNCTION] · src}}

∀ :A. ((QUEUE :A) → (QUEUE :A))

Return a new queue containing the same elements as q.

`(EMPTY? Q)` ^{_{[FUNCTION] · src}}

∀ :A. ((QUEUE :A) → BOOLEAN)

Is q empty?

`(EXTEND! Q ITER)` ^{_{[FUNCTION] · src}}

∀ :A :B. INTOITERATOR :B :A ⇒ ((QUEUE :A) → :B → UNIT)

Push every element in iter to the end of q.

`(INDEX INDEX Q)` ^{_{[FUNCTION] · src}}

∀ :A. (UFIX → (QUEUE :A) → (OPTIONAL :A))

Return the indexth element of q.

`(INDEX-UNSAFE INDEX Q)` ^{_{[FUNCTION] · src}}

∀ :A. (UFIX → (QUEUE :A) → :A)

Return the indexth element of q without checking if the element exists.

`(ITEMS! Q)` ^{_{[FUNCTION] · src}}

∀ :A. ((QUEUE :A) → (ITERATOR :A))

Returns an interator over the items of q, removing items as they are returned.

`(LENGTH Q)` ^{_{[FUNCTION] · src}}

∀ :A. ((QUEUE :A) → UFIX)

Returns the length of q.

`(NEW _)` ^{_{[FUNCTION] · src}}

∀ :A. (UNIT → (QUEUE :A))

Create a new empty queue.

`(PEEK Q)` ^{_{[FUNCTION] · src}}

∀ :A. ((QUEUE :A) → (OPTIONAL :A))

Peek at the first item of q.

`(PEEK-UNSAFE Q)` ^{_{[FUNCTION] · src}}

∀ :A. ((QUEUE :A) → :A)

Peek at the first item of q without checking if the queue is empty.

`(POP! Q)` ^{_{[FUNCTION] · src}}

∀ :A. ((QUEUE :A) → (OPTIONAL :A))

Remove and return the first item of q.

`(POP-UNSAFE! Q)` ^{_{[FUNCTION] · src}}

∀ :A. ((QUEUE :A) → :A)

Remove and return the first item of q without checking if the queue is empty.

`(PUSH! ITEM Q)` ^{_{[FUNCTION] · src}}

∀ :A. (:A → (QUEUE :A) → UNIT)

Push item onto the end of q.

Package `COALTON-LIBRARY/RANDOMACCESS`

Classes

`RANDOMACCESS` ^{_{[CLASS] · src}}

RANDOMACCESS :A :B

Establishes that :f is a random-access store of elements of type :t. The storage type :f implies the stored type :t. The storage is expected to be sequential and O(1) in random access reads and writes.

It is permitted for any of make, unsafe-aref, or unsafe-set! to error.

Methods:

MAKE :: (UFIX → :B → :A)
MAKE-UNINITIALIZED :: (UFIX → :A)
LENGTH :: (:A → UFIX)
READABLE? :: (:A → BOOLEAN)
WRITABLE? :: (:A → BOOLEAN)
UNSAFE-AREF :: (:A → UFIX → :B)
UNSAFE-SET! :: (:A → UFIX → :B → UNIT)

Instances

RANDOMACCESS (VECTOR :A) :A
RUNTIMEREPR :A ⇒ RANDOMACCESS (LISPARRAY :A) :A

Values

`(AREF STORAGE INDEX)` ^{_{[FUNCTION] · src}}

∀ :A :B. RANDOMACCESS :A :B ⇒ (:A → UFIX → (OPTIONAL :B))

Read the element at index of the random-access storage storage. Return None if the read is out-of-bounds or not permitted.

`(ROTATE! STORAGE INDEX1 INDEX2)` ^{_{[FUNCTION] · src}}

∀ :A :B. RANDOMACCESS :B :A ⇒ (:B → UFIX → UFIX → (OPTIONAL UNIT))

Rotate the elements at indices index1 and index2 of the random-access storage storage. Return None if the indices are out-of-bounds or if reading from or writing to storage is not permitted.

`(SET! STORAGE INDEX VALUE)` ^{_{[FUNCTION] · src}}

∀ :A :B. RANDOMACCESS :A :B ⇒ (:A → UFIX → :B → (OPTIONAL UNIT))

Write the element value at index of the random-access storage storage. Return None if the write is out-of-bounds or not permitted.

`(UNSAFE-ROTATE! STORAGE INDEX1 INDEX2)` ^{_{[FUNCTION] · src}}

∀ :A :B. RANDOMACCESS :B :A ⇒ (:B → UFIX → UFIX → UNIT)

Rotate the elements at indices index1 and index2 of the random-access storage storage.

Package `COALTON-LIBRARY/RESULT`

Values

`(ERR-IF FAILED? FAILURE)` ^{_{[FUNCTION] · src}}

∀ :A. (BOOLEAN → :A → (RESULT :A UNIT))

Fail with FAILURE value if FAILED? is True.

`(ERR? X)` ^{_{[FUNCTION] · src}}

∀ :A :B. ((RESULT :A :B) → BOOLEAN)

Returns TRUE if X is ERR

`(FLATTEN X)` ^{_{[FUNCTION] · src}}

∀ :A. ((RESULT :A :A) → :A)

`(MAP-ERR F X)` ^{_{[FUNCTION] · src}}

∀ :A :B :C. ((:A → :B) → (RESULT :A :C) → (RESULT :B :C))

Map over the ERR case

`(OK-OR-ERROR RES)` ^{_{[FUNCTION] · src}}

∀ :A :B. SIGNALABLE :A ⇒ ((RESULT :A :B) → :B)

`(OK? X)` ^{_{[FUNCTION] · src}}

∀ :A :B. ((RESULT :A :B) → BOOLEAN)

Returns TRUE if X is OK

`(OPT->RESULT FAILURE OPT)` ^{_{[FUNCTION] · src}}

∀ :A :B. (:A → (OPTIONAL :B) → (RESULT :A :B))

Convert OPT to a Result, using FAILURE value if None.

Package `COALTON-LIBRARY/SEQ`

Types

`SEQ` ^{_{[TYPE] · src}}

Instances

(FOLDABLE :A) (RUNTIMEREPR :B) ⇒ INTO (:A :B) (SEQ :B)
EQ :A ⇒ EQ (SEQ :A)
FUNCTOR SEQ
INTO (SEQ :A) (LIST :A)
INTO (SEQ :A) (VECTOR :A)
INTOITERATOR (SEQ :A) :A
RUNTIMEREPR (SEQ :A)
RUNTIMEREPR :A ⇒ DEFAULT (SEQ :A)
RUNTIMEREPR :A ⇒ FROMITERATOR (SEQ :A) :A
RUNTIMEREPR :A ⇒ MONOID (SEQ :A)
RUNTIMEREPR :A ⇒ SEMIGROUP (SEQ :A)

Values

`(CONC LEFT RIGHT)` ^{_{[FUNCTION] · src}}

∀ :A. RUNTIMEREPR :A ⇒ ((SEQ :A) → (SEQ :A) → (SEQ :A))

Concatenate two Seqs

`(EMPTY? SEQ)` ^{_{[FUNCTION] · src}}

∀ :A. ((SEQ :A) → BOOLEAN)

`(GET SEQ IDX)` ^{_{[FUNCTION] · src}}

∀ :A. ((SEQ :A) → UFIX → (OPTIONAL :A))

Get the member of seq at index idx, or None if idx is larger than (size seq)

`(NEW _)` ^{_{[FUNCTION] · src}}

∀ :A. RUNTIMEREPR :A ⇒ (UNIT → (SEQ :A))

Create a new empty Seq.

`(POP SEQ)` ^{_{[FUNCTION] · src}}

∀ :A. ((SEQ :A) → (OPTIONAL (TUPLE :A (SEQ :A))))

If seq is empty, return None. Otherwise, the last member of seq and a new Seq instance.

`(PUSH SEQ A)` ^{_{[FUNCTION] · src}}

∀ :A. ((SEQ :A) → :A → (SEQ :A))

Push a onto the end of seq, returning a new Seq instance.

`(PUT SEQ IDX A)` ^{_{[FUNCTION] · src}}

∀ :A. ((SEQ :A) → UFIX → :A → (OPTIONAL (SEQ :A)))

If idx is less than (size seq), Return a new seq whose idx position contains a.

`(SIZE SEQ)` ^{_{[FUNCTION] · src}}

∀ :A. ((SEQ :A) → UFIX)

Return the number of elements in the seq.

Macros

`MAKE (&REST ELEMS)` ^_[MACRO]

Create a new Seq containing elems.

Package `COALTON-LIBRARY/SLICE`

Types

`SLICE` ^{_{[TYPE] · src}}

Instances

EQ :A ⇒ EQ (SLICE :A)
FOLDABLE SLICE
FROMITERATOR (SLICE :A) :A
INTO (SLICE :A) (VECTOR :A)
INTO (VECTOR :A) (SLICE :A)
INTOITERATOR (SLICE :A) :A
ISO (SLICE :A) (VECTOR :A)
RUNTIMEREPR (SLICE :A)
SLICEABLE (SLICE :A)

Values

`(INDEX IDX S)` ^{_{[FUNCTION] · src}}

∀ :A. (UFIX → (SLICE :A) → (OPTIONAL :A))

Lookup the element at index in s.

`(INDEX-UNSAFE IDX S)` ^{_{[FUNCTION] · src}}

∀ :A. (UFIX → (SLICE :A) → :A)

Lookup the element at index in s without bounds checking.

`(ITER-CHUNKED SIZE S)` ^{_{[FUNCTION] · src}}

∀ :A :B. SLICEABLE (:A :B) ⇒ (UFIX → (:A :B) → (ITERATOR (SLICE :B)))

Divide s into a series of slices of length size. Will return a final shorter slice if s does not divide evenly.

`(ITER-CHUNKED-EXACT SIZE S)` ^{_{[FUNCTION] · src}}

∀ :A :B. SLICEABLE (:A :B) ⇒ (UFIX → (:A :B) → (ITERATOR (SLICE :B)))

Divide s into a series of slices of length size. Will skip trailing elements if s does not divide evenly.

`(ITER-SLIDING SIZE S)` ^{_{[FUNCTION] · src}}

∀ :A :B. SLICEABLE (:A :B) ⇒ (UFIX → (:A :B) → (ITERATOR (SLICE :B)))

Returns an iterator that yeilds a series of overlapping slices of length size.

`(LENGTH S)` ^{_{[FUNCTION] · src}}

∀ :A. ((SLICE :A) → UFIX)

Returns the length of s.

`(NEW START LEN V)` ^{_{[FUNCTION] · src}}

∀ :A :B. SLICEABLE (:A :B) ⇒ (UFIX → UFIX → (:A :B) → (SLICE :B))

Create a new slice backed by v starting at index start and continuing for len elements.

`(SET! IDX ITEM S)` ^{_{[FUNCTION] · src}}

∀ :A. (UFIX → :A → (SLICE :A) → UNIT)

Set the element at index idx in s to item.

Package `COALTON-LIBRARY/STRING`

Values

`(CHARS STR)` ^{_{[FUNCTION] · src}}

(STRING → (ITERATOR CHAR))

Returns an iterator over the characters in str.

`(CONCAT STR1 STR2)` ^{_{[FUNCTION] · src}}

(STRING → STRING → STRING)

Concatenate STR1 and STR2 together, returning a new string.

`(DOWNCASE STR)` ^{_{[FUNCTION] · src}}

(STRING → STRING)

Returns a new string with lowercase characters.

`(LENGTH STR)` ^{_{[FUNCTION] · src}}

(STRING → UFIX)

The length of a string STR.

`(PARSE-INT STR)` ^{_{[FUNCTION] · src}}

(STRING → (OPTIONAL INTEGER))

Parse the integer in string str.

`(REF STR IDX)` ^{_{[FUNCTION] · src}}

(STRING → UFIX → (OPTIONAL CHAR))

Return the idxth character of str.

`(REF-UNCHECKED STR IDX)` ^{_{[FUNCTION] · src}}

(STRING → UFIX → CHAR)

Return the idxth character of str. This function is partial.

`(REVERSE S)` ^{_{[FUNCTION] · src}}

(STRING → STRING)

Reverse a string.

`(SPLIT N STR)` ^{_{[FUNCTION] · src}}

(UFIX → STRING → (TUPLE STRING STRING))

Splits a string into a head and tail at the nth index.

`(STRIP-PREFIX PREFIX STR)` ^{_{[FUNCTION] · src}}

(STRING → STRING → (OPTIONAL STRING))

Returns a string without a give prefix, or None if the string does not have that suffix.

`(STRIP-SUFFIX SUFFIX STR)` ^{_{[FUNCTION] · src}}

(STRING → STRING → (OPTIONAL STRING))

Returns a string without a give suffix, or None if the string does not have that suffix.

`(SUBSTRING STR START END)` ^{_{[FUNCTION] · src}}

(STRING → UFIX → UFIX → STRING)

Compute a substring of a string bounded by given indices.

`(SUBSTRING-INDEX SMALL BIG)` ^{_{[FUNCTION] · src}}

(STRING → STRING → (OPTIONAL UFIX))

If the first argument appears as a substring within the second argument, return the starting index into the second argument.

`(SUBSTRING? SMALL BIG)` ^{_{[FUNCTION] · src}}

(STRING → STRING → BOOLEAN)

Return true if the first argument appears as a substring within the second argument.

`(UPCASE STR)` ^{_{[FUNCTION] · src}}

(STRING → STRING)

Returns a new string with uppercase characters.

Package `COALTON-LIBRARY/SYMBOL`

An interface to Common Lisp symbols.

Types

`SYMBOL` ^{_{[TYPE] · src}}

A Common Lisp symbol.

Instances

DEFAULT SYMBOL
EQ SYMBOL
RUNTIMEREPR SYMBOL

Values

`(GENSYM _)` ^{_{[FUNCTION] · src}}

(UNIT → SYMBOL)

Make an uninterned symbol as by cl:gensym.

`(KEYWORD? S)` ^{_{[FUNCTION] · src}}

(SYMBOL → BOOLEAN)

Is the symbol s a Common Lisp keyword?

`(MAKE-KEYWORD S)` ^{_{[FUNCTION] · src}}

(STRING → SYMBOL)

Find or make a keyword named s.

WARNING: This function interns a new symbol. It will not get garbage collected. Use with caution.

`(MAKE-SYMBOL S)` ^{_{[FUNCTION] · src}}

(STRING → SYMBOL)

Make an uninterned symbol with the name s.

`(SYMBOL-NAME S)` ^{_{[FUNCTION] · src}}

(SYMBOL → STRING)

Return the name of the symbol s.

`(UNINTERNED? S)` ^{_{[FUNCTION] · src}}

(SYMBOL → BOOLEAN)

Is the symbol s uninterned?

Package `COALTON-LIBRARY/SYSTEM`

Types

`LISPCONDITION` ^{_{[TYPE] · src}}

Condition for lisp error handling. Uses cl:condition.

Instances

RUNTIMEREPR LISPCONDITION
SIGNALABLE LISPCONDITION

Structs

`METEREDRESULT :A` ^{_{[STRUCT] · src}}

Function output with space and timing metedata.

Instances

RUNTIMEREPR (METEREDRESULT :A)

Values

`(ADD-FEATURE FEAT)` ^{_{[FUNCTION] · src}}

(STRING → UNIT)

Adds a feature feat to cl:*features*.

`(ARCHITECTURE _)` ^{_{[FUNCTION] · src}}

The system’s architecture (stored at compile time).

`(ARGV0 _)` ^{_{[FUNCTION] · src}}

(UNIT → (OPTIONAL STRING))

The first command line argument (stored at compile time).

`(CMD-ARGS _)` ^{_{[FUNCTION] · src}}

(UNIT → (LIST STRING))

The current command line arguments (stored at compile time).

`(FEATURES _)` ^{_{[FUNCTION] · src}}

(UNIT → (LIST STRING))

Returns a list of active features, from cl:*features*.

`(GC _)` ^{_{[FUNCTION] · src}}

(UNIT → UNIT)

Perform a full garbage collection.

`(GET-REAL-TIME _)` ^{_{[FUNCTION] · src}}

(UNIT → INTEGER)

Gets the real-time in internal time units. The difference between two successive calls to this function represents the time that has elapsed.

`(GETENV VAR)` ^{_{[FUNCTION] · src}}

(STRING → (OPTIONAL STRING))

Gets the value of the environmental variable var, errors if var doesn’t exist.

`(HOSTNAME _)` ^{_{[FUNCTION] · src}}

Returns the system’s hostname. This is a function because the hostname can be redefined.

`(IMPLEMENTATION _)` ^{_{[FUNCTION] · src}}

The lisp implementation (stored at compile time).

`(LISP-VERSION _)` ^{_{[FUNCTION] · src}}

The lisp implementation version (stored at compile time).

`(MONOTONIC-BYTES-CONSED _)` ^{_{[FUNCTION] · src}}

(UNIT → (OPTIONAL INTEGER))

Returns the number of bytes consed since some unspecified point in time.

The difference between two successive calls to this function represents the number of bytes consed in that period of time.

`(OS _)` ^{_{[FUNCTION] · src}}