Package COALTON

Public interface to COALTON.

Types

Arrow ^_[TYPE]

A named constructor for function types. Arrow :a :b is equivalent to :a -> :b.

Bit ^{_{[TYPE] · src}}

A single bit, equal to 0 or 1. Uses cl:bit.

Boolean ^_[TYPE]

• False
  • Boolean False
• True
  • Boolean True

Either true or false, internally represented by cl:t and cl:nil respectively.

Char ^_[TYPE]

A character represented by a Common Lisp cl:character.

Double-Float ^{_{[TYPE] · src}}

Deprecated name for F64. This is provided for backward compatibility.

F32 ^_[TYPE]

Single-precision floating point number (32 bits in size). Represented by a Common Lisp cl:single-float.

F64 ^_[TYPE]

Double-precision floating point number (64 bits in size). Represented by a Common Lisp cl:double-float.

Fraction ^_[TYPE]

A ratio of integers always in reduced form. Represented by a Common Lisp cl:rational.

I16 ^{_{[TYPE] · src}}

Signed 16-bit integer capable of storing values in [-32768, 32767]. Uses (signed-byte 16).

I32 ^{_{[TYPE] · src}}

Signed 32-bit integer capable of storing values in [-2147483648, 2147483647]. Uses (signed-byte 32).

I64 ^{_{[TYPE] · src}}

Signed 64-bit integer capable of storing values in [-9223372036854775808, 9223372036854775807]. Uses (signed-byte 64).

I8 ^{_{[TYPE] · src}}

Signed 8-bit integer capable of storing values in [-128, 127]. Uses (signed-byte 8).

IFix ^{_{[TYPE] · src}}

Non-allocating tagged integer; range is platform-dependent. Does not error on overflow. Uses fixnum.

Integer ^_[TYPE]

Integer of unbounded size. Represented by a Common Lisp cl:integer.

List ^_[TYPE]

• Nil
  • Nil represents an empty List.
• (Cons :A (List :A))
  • Cons represents a List containing a first element (car) and a nested Cons (cdr).

Homogeneous list of objects. Represented as a typical Common Lisp chain of cl:cons (or cl:nil).

Optional ^_[TYPE]

• (Some :A)
  • Some expresses the presence of a meaningful value.
• None
  • None expresses the absence of a meaningful value.

A type that allows indicating the presence or absence of a value. The underlying representation does not allocate when a value is present (i.e., with Some).

Single-Float ^{_{[TYPE] · src}}

Deprecated name for F32. This is provided for backward compatibility.

String ^_[TYPE]

String of characters. Represented by Common Lisp cl:string.

U16 ^{_{[TYPE] · src}}

Unsigned 16-bit integer capable of storing values in [0, 65535]. Uses (unsigned-byte 16).

U32 ^{_{[TYPE] · src}}

Unsigned 32-bit integer capable of storing values in [0, 4294967295]. Uses (unsigned-byte 32).

U64 ^{_{[TYPE] · src}}

Unsigned 64-bit integer capable of storing values in [0, 18446744073709551615]. Uses (unsigned-byte 64).

U8 ^{_{[TYPE] · src}}

Unsigned 8-bit integer capable of storing values in [0, 255]. Uses (unsigned-byte 8).

UFix ^{_{[TYPE] · src}}

Non-allocating tagged non-negative integer; range is platform-dependent. Uses (and fixnum unsigned-byte).

Unit ^_[TYPE]

• Unit
  • Unit represents nullary parameters and return types.

The “unit” type whose only member is the value Unit.

Void ^{_{[TYPE] · src}}

Values

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

∀ :A. (:A → (List :A) → (List :A))

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

∀ :A. (:A → :A)

Try to inline application. It will only attempt to inline application written syntactically as a function application.

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

(Boolean → Boolean)

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}}

(Boolean → Boolean)

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

.< (&REST ITEMS) ^_[MACRO]

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)

to

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

to

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

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)

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)

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)

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.

RoundingMode ^{_{[TYPE] · src}}

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}}

RoundingMode

RouND Away from zero.

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

RoundingMode

RouND Down, toward negative infinity.

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

RoundingMode

Faithful rounding (experimental).

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

RoundingMode

RouND to Nearest, with the even rounding rule.

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

RoundingMode

RouND to Nearest Away.

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

RoundingMode

RouND Up, toward positive infinity.

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

RoundingMode

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

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.

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}}

(Boolean → Boolean → Boolean)

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}}

(Boolean → Boolean)

The logical negation of x. Is x false?

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

(Boolean → Boolean → Boolean)

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}}

(Boolean → Boolean → Boolean)

Are x or y true, but not both?

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

(Boolean → Boolean)

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}}

(Boolean → Boolean → Boolean)

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

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}}

(Char → Boolean)

Is c an alphabetic character?

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

(Char → Boolean)

Is c an ASCII alphabetic character?

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

(Char → Boolean)

Is c an ASCII alphanumeric character?

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

(Char → Boolean)

Is c an ASCII digit character?

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

(Char → Boolean)

Is c an ASCII lowercase character?

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

(Char → Boolean)

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}}

(Char → Boolean)

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}}

(Char → Boolean)

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}}

(Char → Boolean)

Is c an uppercase character?

Package COALTON-LIBRARY/CLASSES

Types

Hash ^{_{[TYPE] · src}}

Implementation dependent hash code.

Ord ^{_{[TYPE] · src}}

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

The result of an ordered comparison.

Result ^{_{[TYPE] · src}}

• (Err :A)
• (Ok :B)

Represents something that may have failed.

Structs

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

A heterogeneous collection of items.

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)

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

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

Default ^{_{[CLASS] · src}}

Default :A

Types which have default values.

Methods:

• DEFAULT :: (Unit → :A)

Eq ^{_{[CLASS] · src}}

Eq :A

Types which have equality defined.

Methods:

• == :: (:A → :A → Boolean)

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.

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

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)

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)