Marlais Init.Dylan exported names

Note that some of the exported names properly belong elsewhere, e.g. to the Common-Dylan specification libraries. So, this document also points out good places to attack the common-dylan spec.

Exported Classes

<abort> = {the class <abort> (39)}
<array> = {the class <array> (24)}
* <big-integer> = {> (9)}
<boolean> = {the class <boolean> (2)}
<byte-string> = {the class <byte-string> (30)}
<character> = {(46)}
<class> = {the class <class> (55)}
* <class-slots-class> = {the class <class-slots-class> (59)}
<collection> = {(14)}
<complex> = {the class <complex> (4)}
<condition> = {(33)}
<deque> = {the class <deque> (23)}
* <deque-entry> = {the class <deque-entry> (58)}
<double-float> = {the class <double-float> (13)}
<empty-list> = {(26)}
<error> = {the class <error> (40)}
* <exit-function> = {the class <exit-function> (51)}
<explicit-key-collection> = {the class <explicit-key-collection> (15)}
(missing <extended-float>)
<float> = {the class <float> (11)}
* <foreign-pointer> = {the class <foreign-pointer> (61)}
<function> = {(47)}
<generic-function> = {the class <generic-function> (49)}
<integer> = {the class <integer> (7)}
* <integer-state> = {false-or( <small-integer>) (8)}
<list> = {the class <list> (25)}
<method> = {the class <method> (50)}
<mutable-collection> = {the class <mutable-collection> (17)}
<mutable-explicit-key-collection> = {(19)}
<mutable-sequence> = {the class <mutable-sequence> (20)}
<number> = {the class <number> (3)}
* <object-handle> = {the class <object-handle> (60)}
<object-table> = {the class <object-table> (22)}
<object> = {the class <object> (1)}
<pair> = {the class <pair> (27)}
* <primitive> = {(48)}
<range> = {the class <range> (62)}
* <ratio> = {the class <ratio> (10)}
<rational> = {> (6)}
<real> = {the class <real> (5)}
<restart> = {the class <restart> (37)}
<sealed-object-error> = {> (43)}
<sequence> = {> (18)}
<serious-condition> = {the class <serious-condition> (34)}
<simple-error> = {the class <simple-error> (41)}
<simple-object-vector> = {> (32)}
<simple-restart> = {the class <simple-restart> (38)}
<simple-warning> = {the class <simple-warning> (36)}
<single-float> = {the class <single-float> (12)}
<singleton> = {> (54)}
* <small-integer> = {the class <small-integer> (8)}
<stretchy-collection> = {> (16)}
<stretchy-vector>
  -- but it's currently very, very broken.
<string> = {the class <string> (28)}
<symbol> = {the class <symbol> (45)}
* <table-entry> = {the class <table-entry> (57)}
<table> = (21)
<type-error> = {> (42)}
<type> = {the class <type> (53)}
<unicode-string> = {the class <unicode-string> (31)}
* <unwind-protect-function> = {the class <unwind-protect-function> (52)}
* <variable-name> = {the class <variable-name> (44)} -- this class should probably be hidden from the Marlais user.
<vector> = {the class <vector> (29)}
<warning> = {the class <warning> (35)}

* = name exported from Marlais, but not from DRM's Dylan module

Exported Functions

* = {the generic function * (n1 :: <number>, n2 :: <number>)}
+ = {the generic function + (n1 :: <number>, n2 :: <number>)}
- = {the generic function - (n1 :: <number>, n2 :: <number>)}
/ = {the generic function / (n1 :: <number>, n2 :: <number>)}
< = {the generic function < (o1, o2, #rest x)}
<= = {an anonymous method (o1, o2)#(~, #(<, o2, o1))}
= = {the generic function = (o1, o2, #rest x)}
== = {anonymous method ==}
~== = {anonymous method ~==}
> = {an anonymous method (o1, o2)#(<, o2, o1)}
>= = {an anonymous method (o1, o2)#(~, #(<, o1, o2))}
^ = {the generic function ^ (n :: <number>, i :: <integer>)}
~ = {an anonymous method ~}
~= = {an anonymous method (o1, o2)#(~, #(=, o1, o2))}
* above = {the generic function above (x, #rest x)}
* above-setter = {the generic function above-setter (x, x, #rest x)}
(missing abort)
abs = {the generic function abs (n :: <number>)}
add = {the generic function add (s :: <sequence>, new-element)}
add! = {the generic function add! (sequence1 :: <sequence>, new-element)}
add-method = {the generic function add-method (gf, meth, #rest x)}
add-new = {the generic function add-new (sequence :: <sequence>, new-element, #key #(#"test", test, #f))}
add-new! = {the generic function add-new! (sequence1 :: <sequence>, new-element, #key #(#"test", test, #f))}
all-superclasses = {an anonymous method (c :: <class>)#(%all-superclasses, c)}
always = {the generic function always (obj, #rest x)}
any? = {the generic function any? (procedure :: <function>, collection :: <collection>, #rest more-collections)}
applicable-method? = {the generic function applicable-method? (m, #rest x)}
apply = {the generic function apply (f, #rest x)}
aref = {the generic function aref (a :: <array>, #rest indices)}
aref-setter = {the generic function aref-setter (new-val, a :: <array>, #rest indices)}
as = {the generic function as (c, obj, #rest x)}
as-lowercase = {the generic function as-lowercase (s, #rest x)}
as-lowercase! = {the generic function as-lowercase! (s, #rest x)}
as-uppercase = {the generic function as-uppercase (s, #rest x)}
as-uppercase! = {the generic function as-uppercase! (s, #rest x)}
ash = {the generic function ash (i, count, #rest x)}
backward-iteration-protocol = {the generic function backward-iteration-protocol (c, #rest x)}
(missing break)
* below = {the generic function below (x, #rest x)}
* below-setter = {the generic function below-setter (x, x, #rest x)}
* by = {the generic function by (x, #rest x)}
* by-setter = {the generic function by-setter (x, x, #rest x)}
ceiling = {the generic function ceiling (r :: <real>)}
ceiling/ = {the generic function ceiling/ (r1 :: <real>, r2 :: <real>)}
cerror = {the generic function cerror (#rest x)}
choose = {the generic function choose (predicate :: <function>, sequence :: <sequence>)}
choose-by = {the generic function choose-by (predicate :: <function>, test-sequence :: <sequence>, value-sequence :: <sequence>)}
complement = {the generic function complement (func, #rest x)}
compose = {the generic function compose (function, #rest x)}
concatenate = {the generic function concatenate (sequence1 :: <sequence>, #rest sequences)}
concatenate-as = {the generic function concatenate-as (class :: <class>, sequence1 :: <sequence>, #rest more-sequences)}
(missing condition-format-arguments)
(missing condition-format-string)
conjoin = {the generic function conjoin (predicate, #rest x)}
copy-sequence = {the generic function copy-sequence (source :: <sequence>, #key #(#"start", start, #f))}
* copy-state = {the generic function copy-state (c, state, #rest x)}
* current-element = {the generic function current-element (c, state, #rest x)}
* current-element-setter = {the generic function current-element-setter (obj, c, state, #rest x)}
* current-key = {the generic function current-key (c, state, #rest x)}
* current-module = {primitive function current-module}
curry = {the generic function curry (f, #rest x)}
* debug-name = {the generic function debug-name (c, #rest x)}
* debug-name-setter = {the generic function debug-name-setter (s, m, #rest x)}
(missing default-handler)
dimension = {the generic function dimension (a :: <array>, axis :: <integer>)}
dimensions = {the generic function dimensions (v, #rest x)}
direct-subclasses = {an anonymous method (c :: <class>)#(%direct-subclasses, c)}
direct-superclasses = {an anonymous method (c :: <class>)#(%direct-superclasses, c)}
disjoin = {the generic function disjoin (predicate, #rest x)}
do = {the generic function do (procedure :: <function>, collection :: <collection>, #rest more-collections)}
(missing do-handlers)
element = {the generic function element (c :: <collection>, key, #rest rest)}
element-setter = {the generic function element-setter (val, l, i, #rest x)}
empty? = {the generic function empty? (collection :: <collection>)}
* eof-object? = {the generic function eof-object? (obj, #rest x)}
error = {the generic function error (msg, #rest x)}
* eval = {the generic function eval (obj, #rest x)}
even? = {the generic function even? (i, #rest x)}
every? = {the generic function every? (procedure :: <function>, collection :: <collection>, #rest more-collections)}
fill! = {the generic function fill! (mutable-collection :: <mutable-collection>, value, #key #(#"start", start, #f))}
* final-state = {the generic function final-state (v, #rest x)}
find-key = {the generic function find-key (collection :: <collection>, procedure :: <function>, #key #(#"skip", skip, #f) #(#"failure", failure, #f))}
find-method = {the generic function find-method (gf, #rest x)}
* finished-state? = {the generic function finished-state? (c, state, limit, #rest x)}
first = {the generic function first (sequence :: <sequence>)}
first-setter = {the generic function first-setter (new-value, sequence :: <sequence>)}
floor = {the generic function floor (r :: <real>)}
floor/ = {the generic function floor/ (r1 :: <real>, r2 :: <real>)}
forward-iteration-protocol = {the generic function forward-iteration-protocol (c, #rest x)}
* from = {the generic function from (x, #rest x)}
* from-setter = {the generic function from-setter (x, x, #rest x)}
function-arguments = {the generic function function-arguments (f, #rest x)}
function-specializers = {the generic function function-specializers (func, #rest x)}
function-return-values = {the generic function function-return-values (func, #rest x)}
gcd = {the generic function gcd (int1, int2, #rest x)}
generic-function-mandatory-keywords = {the generic function generic-function-mandatory-keywords (gf, #rest x)}
generic-function-methods = {the generic function generic-function-methods (gf, #rest x)}
head = {the generic function head (lst, #rest x)}
head-setter = {the generic function head-setter (obj, p, #rest x)}
identity = {an anonymous method (x)x}
* initial-state = {the generic function initial-state (l, #rest x)}
initialize = {the generic function initialize (instance, #rest x)}
instance? = {an anonymous method (obj, typ :: <type>)#(%instance?, obj, typ)}
integral? = {the generic function integral? (n, #rest x)}
intersection = {the generic function intersection (sequence1 :: <sequence>, sequence2 :: <sequence>, #key #(#"test", test, #f))}
key-sequence = {the generic function key-sequence (s, #rest x)}
key-test = {the generic function key-test (c :: <collection>)}
last = {the generic function last (sequence :: <sequence>)}
last-setter = {the generic function last-setter (new-value, s, #rest x)}
lcm = {the generic function lcm (int1, int2, #rest x)}
limited = {the generic function limited (int, #rest x, #key #(#"min", min, #f) #(#"max", max, #f))}
list = {the generic function list (#rest x)}
* load = {primitive function load}
logand = {the generic function logand (#rest x)}
logior = {the generic function logior (#rest x)}
(missing logbit?)
make = {the generic function make (c, #rest x)}
map = {the generic function map (procedure :: <function>, collection :: <collection>, #rest more-collections)}
map-as = {the generic function map-as (class :: <class>, procedure :: <function>, collection :: <collection>, #rest more-collections)}
map-into = {the generic function map-into (mutable-collection :: <mutable-collection>, procedure :: <function>, collection :: <collection>, #rest more-cols)}
max = {the generic function max (n1, #rest x)}
member? = {the generic function member? (value, collection :: <collection>, #key #(#"test", test, #f))}
min = {the generic function min (n1, #rest x)}
modulo = {the generic function modulo (r1 :: <real>, r2 :: <real>)}
negative = {the generic function negative (n :: <number>)}
negative? = {the generic function negative? (r :: <real>)}
* next-state = {the generic function next-state (c, state, #rest x)}
object-class = {an anonymous method (o)#(%object-class, o)}
(missing object-hash)
odd? = {the generic function odd? (i, #rest x)}
pair = {the generic function pair (car, cdr, #rest x)}
pop = {the generic function pop (d, #rest x)}
pop-last = {the generic function pop-last (d, #rest x)}
positive? = {the generic function positive? (r :: <real>)}
* previous-state = {the generic function previous-state (v, state, #rest x)}
push = {the generic function push (d, new, #rest x)}
push-last = {the generic function push-last (d, new, #rest x)}
range = {the generic function range (#rest x)}
rank = {the generic function rank (a :: <array>)}
rcurry = {the generic function rcurry (f, #rest x)}
reduce = {the generic function reduce (procedure :: <function>, initial-value, collection :: <collection>)}
reduce1 = {the generic function reduce1 (procedure :: <function>, collection :: <collection>)}
remainder = {the generic function remainder (r1 :: <real>, r2 :: <real>)}
remove = {the generic function remove (sequence :: <sequence>, value, #key #(#"test", test, #f) #(#"count", count, #f))}
remove! = {the generic function remove! (sequence1 :: <sequence>, value, #key #(#"test", test, #f) #(#"count", count, #f))}
remove-duplicates = {the generic function remove-duplicates (sequence :: <sequence>, #key #(#"test", test, #f))}
remove-duplicates! = {the generic function remove-duplicates! (sequence1 :: <sequence>, #key #(#"test", test, #f))}
(missing remove-key!)
remove-method = {the generic function remove-method (gf, meth, #rest x)}
replace-elements! = {the generic function replace-elements! (mutable-collection :: <mutable-collection>, predicate :: <function>, new-value-fn :: <function>, #key #(#"count", count, #f))}
replace-subsequence! = {the generic function replace-subsequence! (mutable-sequence :: <sequence>, insert-sequence :: <sequence>, #key #(#"start", start, #f))}
(missing restart-query)
(missing return-allowed?)
(missing return-description)
(missing return-query)
reverse = {the generic function reverse (sequence :: <sequence>)}
reverse! = {the generic function reverse! (sequence1 :: <sequence>)}
round = {the generic function round (r :: <real>)}
round/ = {the generic function round/ (r1 :: <real>, r2 :: <real>)}
row-major-index = {the generic function row-major-index (a :: <array>, #rest subscripts)}
* seal = {the generic function seal (c, #rest x)}
second = {the generic function second (sequence :: <sequence>)}
second-setter = {the generic function second-setter (new-value, sequence :: <sequence>)}
* set-module = {primitive function set-module}
shallow-copy = {the generic function shallow-copy (o, #rest x)}
signal = {the generic function signal (#rest x)}
singleton = {an anonymous method (o)#(%singleton, o)}
size = {the generic function size (collection :: <collection>)}
size-setter = {the generic function size-setter (x, x, #rest x)}
slot-initialized? = {an anonymous method (obj, slot)#(~, #(id?, #(slot, obj), %uninitialized-slot-value))}
sort = {the generic function sort (sequence :: <sequence>, #key #(#"test", test, #f) #(#"stable", stable, #f))}
sort! = {the generic function sort! (sequence1 :: <sequence>, #key #(#"test", test, #f) #(#"stable", stable, #f))}
sorted-applicable-methods = {the generic function sorted-applicable-methods (gf, #rest x)}
subsequence-position = {the generic function subsequence-position (big :: <sequence>, pattern :: <sequence>, #key #(#"test", test, #f) #(#"count", count, #f))}
subtype? = {an anonymous method (t1 :: <type>, t2 :: <type>)#(%subtype?, t1, t2)}
* system = {primitive function system}
(missing table-protocol)
tail = {the generic function tail (lst, #rest x)}
tail-setter = {the generic function tail-setter (obj, p, #rest x)}
third = {the generic function third (sequence :: <sequence>)}
third-setter = {the generic function third-setter (new-value, sequence :: <sequence>)}
* to = {the generic function to (x, #rest x)}
* to-setter = {the generic function to-setter (x, x, #rest x)}
truncate = {the generic function truncate (r :: <real>)}
truncate/ = {the generic function truncate/ (r1 :: <real>, r2 :: <real>)}
(missing type-error-expected-type)
(missing type-error-value)
type-for-copy = {the generic function type-for-copy (o, #rest x)}
type-union = {the generic function type-union (#rest x)}
union = {the generic function union (o1, o2, #rest args)}
values = {primitive function values}
vector = {the generic function vector (#rest x)}
* warning = {the generic function warning (msg, #rest x)}
zero? = {the generic function zero? (n :: <number>)}

Bindings that really shouldn't be visible to Marlais users

Bindings that should be eliminated from Marlais

Exported Constants

(missing $permanent-hash-state)

Exported Defining Macros

class-definer
constant-definer
(missing domain-definer) -- true?
generic-definer
library-definer -- true?
method-definer
module-definer
variable-definer
(missing function-definer) -- added to the Dylan language specification after the DRM was published.

Exported Statement Macros

begin
block
case
for -- but not fully implemented?
if
method
select
unless
until
while
* when -- true?

Exported Function Macros

:=
|
&

Bindings that are targets for the Common-Dylan spec

IO Library

Classes

Functions

The next two functions must be restructured to conform to the common-dylan spec.

open-input-file = {the generic function open-input-file (s, #rest x)}
open-output-file = {the generic function open-output-file (s, #rest x)}

Variables

Transcendentals Library

Functions

Date Library

Functions