Glossary


Glossary

abstract class

A class that cannot have direct instances. The opposite of an abstract class is a concrete class.

accepts a variable number of arguments

The shape of the parameter list of a function that accepts a rest argument but does not accept keyword arguments.

accepts all keyword arguments

The shape of the parameter list of a function that specifies #all-keys in addition to #key.

accepts keyword arguments

The shape of the parameter list of a function that accepts keyword arguments (specifies #key). It may or may not specify #rest.

access

1. (a slot) To retrieve (get) or replace (set) the value of the slot. 2. (a collection element) To retrieve or replace the collection element.

accessor

A slot accessor (a getter or setter).

accessible

(from a module) A binding that is either owned by the module or imported into the module from another module.

alignment

See collection alignment.

ambiguous methods

(for a particular function call) Two methods that are both applicable for the function call, but neither of which is more specific than the other.

anonymous

1. (~ method) Created by a method statement, as opposed to having been created and named by a define method or local definition, or having been implicitly defined. Compare with bare method. 2. (~ class) Created by calling the make function on the class <class>, as opposed to having been created and named by a define class definition. 3. (~ generic function) Created by calling the make function on the class <generic-function>, as opposed to having been created and named by a define generic definition.

applicable

1. (~ method, during a generic function call) Having a parameter list that matches the supplied arguments. 2. (~ handler, when a condition is signaled) Matching the signaled condition by type and by an optional test function associated with the handler.

apply

1. (a function to arguments) To call the function with the arguments. 2. The function apply (see page 350).

argument

An object that is supplied to a function in a function call. In other languages, this is sometimes called an "actual argument" or "actual parameter."

array

An instance of <array>.

assign

1. (a variable) To change the value of the variable. 2. (a slot) To set the value of the slot. 3. (a collection element) To change the value of a collection element.

bare method

1. A method that is not part of a generic function. 2. A method that is invoked directly rather than through a generic function.

base type

(of a type): Every type has a base type. The base type for a class is the class itself. The base type of a singleton is the singleton itself. The base type of a union is the union of the base types of its component types. The base type of a limited type limited(C,) is C.

bind

(a variable) To establish a binding.

binding

An association between a name and a value.

body

A grammatical element of a Dylan program, consisting of zero or more constituents. If any of the constituents are expressions, the body returns the values of the last expression.

bound

(~ name) Having a binding that associates the name with a value.

call

(a function) To invoke a function on a set of arguments. If the function is a generic function, it will dispatch to an appropriate method. If the function is a method, its body will be executed within an environment in which its parameters are bound to the arguments of the function call.

circular list

A list that has no last element, because the tail of every pair in the list is another pair in the list. Compare with improper list, dotted list.

class

1. A type that specifies the structure of instance and categorizes objects. Each Dylan object is a direct instance of exactly one class. 2. (of an object) The class of which the object is a direct instance.

class hierarchy

A directed acyclic graph (DAG) that describes the subclass/superclass relationships among classes. Each node represents a class, the children of a node represent the direct subclasses of a class, and the parents of a node represent the direct superclasses of a class.

class precedence list

(of a class) A total ordering on the class and its superclasses that is consistent with the local precedence orders for the class and each of its superclasses. The class precedence list is used in determining method specificity. See "Computing the Class Precedence List" on page 54.

cleanup clause

A clause in a block statement that is guaranteed to be executed, even if the execution of the block statement is terminated by a nonlocal exit.

closed over

(~ binding) A local binding which is referenced by a closure.

closure

A function which references local variables created by a local declaration surrounding the function definition.

code body

That portion of a source code file in Dylan interchange format which follows the file header and consists of program constituents.

coerce

(an object to a type) To produce a new object of the specified type, without modifying the original object. The intent is to produce an object that preserves the meaning of the original object, but is an instance of the specified type.

collection

An aggregate data structure such as a list, a table, or an array. A collection is an instance of <collection>.

collection alignment

A technique of preparing two or more collections for an iteration over those collections, ensuring that elements are paired in a consistent way.

collection key

(of a collection) An object that can be passed to random-access operations (such as element or element-setter) to access an element of the collection.

concrete class

A class that can have direct instances. The opposite of a concrete class is an abstract class.

condition

An object that is signaled in an exceptional situation, and used to determine which handlers are applicable in the situation. Conditions are instances of <condition>.

congruent

(two or more ~ parameter lists) Having compatible parameters. The parameter lists of a generic function and its methods must be congruent. See "Parameter List Congruency" on page 93.

constant

1. A constant binding. 2. A literal constant. 3. (~ binding) Read-only. 4. (~ slot) Not assignable. Constant slots do not have setter functions.

constant binding

A binding that cannot be assigned a new value.

constituent

A portion of a Dylan program; either a definition, a local declaration, or an expression.

contents

1. (of a collection) The elements of the collection. 2. (of an object) The values stored in the object's slots.

copy

1. (of an object) A new object that has similar structure and contents as the original object. A copy may be an instance of the same class as the original object, or it may be an instance of the type-for-copy of the object. A copy may or may not share structure with the original object. Compare fresh copy, shallow copy. 2. (an object) To create a copy of the object.

default method

(of a generic function) The method with the most general parameter specializers for the generic function, intended for use when no more specific method is defined.

defaulted initialization arguments

The sequence of keyword/value pairs used to initialize the slots of an object. This sequence consists of the supplied initialization arguments augmented by any additional initialization arguments for which default values are defined by the class or any of its superclasses. See also "Instance Creation and Initialization" on page 64.

definition

A syntax form that denotes a declarative part of a program. Definitions are restricted to be top level expressions, and do not return values.

destructive

(~ function) Capable of modifying its arguments.

destructive modification

1. A change to the contents of a collection, as described on page 119. 2. Any visible change made to an object.

direct instance

(of a class C) An object whose class is C itself, rather than some subclass of C.

direct subclass

(of a class C1) A class C2 such that C1 is a direct superclass of C2.

direct superclass

(of a class C1) A class C2 that is listed as a superclass of C1 in the definition of C1, or that was passed as one of the superclass: arguments to make when C1 was created.

disjoint

(of types): Informally, two types are disjoint if there can be no object that is an instance of both types. A formal definition is given in "Type Disjointness" on page 51.

dotted list

A list that has something other than the empty list as the tail of its last pair. Compare proper list, improper list.

Dylan interchange format

A standard file format for Dylan source code, as described on page 21.

element

(of a collection) An object that is stored in the collection. It can be identified by a collection key.

element reference syntax

The shorthand syntax for accessing an element of an array or of any other collection. x[y], x[y, z].

element type

(of a collection) A specification of the types of objects which may be stored in the collection, as described in "Element Types" on page 124.

empty list

The list that contains no elements. It is the unique instance of the class <empty-list>.

environment

1. A set of bindings. 2. The set of bindings that are available to a particular part of a program.

equivalence class

(for an equivalence predicate) A set of objects, or potential objects, that are all the same under the specified equivalence predicate and different under that predicate from all objects not in the equivalence class. See also "Tables" on page 122.

equivalence predicate

A boolean function of two arguments that returns true if and only if the arguments are "the same" according to some specified criteria. For a function to be used as an equivalence predicate, it must be reflexive, commutative, and transitive. See also "Tables" on page 122 and hash function.

equivalent types

Two types, each of which is a subtype of the other.

error

1. A condition that represents an error situation. 2. An error situation.

error situation

A situation in which there is something invalid about the program.

exceptional situation

A situation that is not conceptually part of the normal execution of the program, but must be handled some other way. Exceptional situations are represented by conditions.

execute

The action of running an expression to produce its values.

exit

A transfer of control to an exit point, bypassing normal flow of control.

exit procedure

A function that can be called explicitly, during the execution of a block statement, to terminate the execution of the block statement, transfer control to its associated exit point, and return zero or more values.

exit point

A point through which control may be transferred. An exit point established by a block statement may have an associated exit procedure.

explicit definition

A definition created by define constant, define variable, define generic, define macro and the class name in define class. See also implicit definition.

explicit key collection

A collection that is not constrained to using integers as keys. The objects that may be used as keys are defined by the collection class. Contrast sequence.

explicitly defined

(of a class or generic function) defined by an explicit definition.

explicitly known

1. (of a class in a library) A class defined by define class in the library or in one of the libraries it uses. 2. (of a generic function in a library) A generic function explicitly defined by define generic in the library or in one of the libraries it uses, or a generic function implicitly defined by the definition of a method explicitly known in the library or by a slot specification for a class explicitly known in the library. 3. (of a method in a library) A method defined by define method in the library or in one of the libraries it uses, or defined by a slot specification for a class explicitly known in the library.

export

1. (~ a binding from a module) To make a binding available for import into other modules. 2. (~ a module from a library) To make a module available for import into other libraries.

expression

A construct that is executed for the values it returns and/or the side-effects that it performs.

false

The unique false object, #f.

file header

The portion of a source code file in Dylan interchange format that specifies the library, module, and possibly other characteristics of the remaining source code in the file.

first-class object

An object. The adjective "first-class" is used to emphasize that the object may be stored in a variable or data structure, may be passed as an argument to a function, and may be returned as the value of a function.

format arguments

A series of objects that are used to construct a message from a format string, as described in "Condition Messages" on page 112.

format directives

Two-character sequences in a format string which are replaced with representations of the format arguments to construct the format message, as described in "Condition Messages" on page 112.

format string

A string template into which values can be inserted to construct a message. Format strings are used by the condition system, as described in "Condition Messages" on page 112.

free class

A class that may be used freely in multiple inheritance. The opposite of a free class is a primary class.

fresh

A collection C is fresh if modification of any pre-existing collection's contents can never modify the contents of C and if modifications to C can never modify the contents of any pre-existing collection. Immutable collections cannot be modified, so a fresh immutable collection can share structure with other immutable collections.

fresh copy

A copy that does not share structure. Compare with shallow copy.

freshly allocated

See fresh.

function

An object used for performing actions and returning values. Functions have a parameter list and an optional return value declaration, which together define the function's signature. There are two kinds of functions: methods and generic functions. A method has a body of code that is executed to compute the method's values when the method is called. A generic function consists of a set of methods, and computes its values by selecting and calling an appropriate method based on the types of the arguments.

general instance

(of a type) An object that is either a direct instance or indirect instance of the type.

general subclass

(of a class) A class that is either a direct subclass or indirect subclass of the class.

general superclass

(of a class) A class that is either a direct superclass or indirect superclass of the class.

generic function

A function consisting of a set of methods with a common calling protocol. A generic function computes its value by selecting and calling an appropriate method based on the types of the arguments. See also method dispatch.

generic function dispatch

See method dispatch.

get

(the value of a slot) To retrieve the value of the slot.

getter

A function that is applied to an object and returns the value of one of the object's slots.

getter method

A method that returns the value of a slot.

handler

A function that is used to respond to a signaled condition.

hash code

A conceptual object consisting of a hash id and its associated hash state.

hash function

A function, associated with a table, that computes hash code. All hash functions have one argument, a key, and return two values, a hash id and a hash state, which together represent the hash code. See also equivalence predicate.

hash id

An integer encoding of an object.

hash state

An object of implementation-dependent type that is associated with a particular hash id and can be used by the implementation to determine whether the hash id has been invalidated.

hash table

A table.

hygiene

The property that each named value reference in a macro expansion means the same thing as it meant at the place in the original source code from which it was copied into the macro expansion. See "Hygiene" on page 161.

identical

(of two objects) Computationally equivalent. That is, there is no way for any portable Dylan program to distinguish them; they are the same under the equivalence predicate ==.

immutable

Not capable of being modified after it is created. It is an error to attempt to modify an immutable object, though Dylan implementations are not required to detect this error. The opposite of immutable is mutable.

implicit body

A series of one or more constituents separated by semicolons. When an implicit body is executed, the expressions in the implicit body are executed in order (left to right). The values of the implicit body are the values of the last expression, or #f if the implicit body contains no expressions.

implicit definition

A definition created by define method or by the slot specifications of define class.

implicitly defined

1. (of a generic function) Created by an implicit definition rather than by define generic. 2. (of a method) Created by a slot specification in a define class definition, rather than by define method.

import

1. (~ a binding into a module M) To make a binding exported by another module accessible in the module M. 2. (~ a module into a library L) To make a module exported by another library accessible in the library L.

improper list

A list that does not have the empty list as the tail of its last pair. An improper list is either a dotted list or a circular list.

indirect instance

(of a type) A direct instance of one of the proper subclasses of the type.

indirect subclass

(of a class) A class that is a general subclass of one of the class's direct subclasses.

indirect superclass

(of a class) A class that is a general superclass of one of the class's direct superclasses.

infix operator

A function or function macro that is normally called using infix notation.

init expression

An init specification that specifies an expression to be executed to generate a value used to initialize a slot. Each time the slot needs to be initialized, the expression is executed and its value is used. This allows slots to be initialized to fresh values, or to values computed from the current program state. See also init function and init value.

init function

An init specification that specifies a function to be called to generate a value used to initialize a slot. Each time the slot needs to be initialized, the function is called and its value is used. This allows slots to be initialized to fresh values, or to values computed from the current program state. See also init value and init expression.

init keyword

A keyword specified in a class definition, used to initialize a slot. An init keyword may be required or optional.

init specification

An init specification provides an initial value for the slot or a default value for an init-keyword. There are three kinds of init specifications. See page 59 for a complete description.

init value

An init specification that specifies a particular value used to initialize a slot. Each time the slot needs to be initialized, the identical value is used. See also init function and init expression.

initialization argument

A keyword argument supplied to make, used to initialize a keyword initializable slot.

initialization protocol

The protocol by which newly allocated instances are made ready for use, as described in "Instance Creation and Initialization" on page 64.

initialize

1. (an object) To prepare an object for use, by initializing its slots and calling the initialize function on the object. All Dylan objects are automatically initialized immediately after they are allocated. 2. (a slot) To give the slot its initial value. A program can test to see whether a slot has been initialized by calling the function slot-initialized? There is no mechanism for resetting a slot to the uninitialized state. 3. (a variable) To bind the variable to its initial value.

instance

(of a type) A general instance of the type.

instantiable class

A class that can be used as the first argument to make. The opposite of an instantiable class is an uninstantiable class. Note that an abstract class may be instantiable.

iteration protocol

A protocol that is common to collections, consisting of the functions forward-iteration-protocol and backward-iteration-protocol. All collections must implement forward-iteration-protocol. Collections that are stable under iteration may also implement backward-iteration-protocol.

iteration stability

The property of being stable under iteration.

iteration binding

A binding associated with a clause in a for statement. Each iteration binding is associated with only one clause.

key

An object used to indicate a particular element of a collection.

key test

The test used to determine whether a given object matches a key in a collection. See "Collection Keys" on page 118.

keyword

A symbol literal, represented in source code as a name followed by a colon. Keywords are used as program constants, and for naming keyword arguments in function calls.

keyword argument list

A sequence containing an even number of elements that are alternating keywords and values (i.e., a sequence of keyword/value pairs). When there is more than one keyword/value pair with the same keyword, the first such pair determines the value associated with that keyword in the keyword argument list.

keyword initializable

(of a slot) A slot that may be given an initial value by a keyword argument in a call to make. See also initialization arguments.

keyword parameter

(of a function) A parameter that corresponds to an optional keyword/value pair. Keyword parameters are specified by name rather than position.

keyword/value pair

Two successive arguments (a keyword and a value, respectively) supplied in a function call.

library

A set of modules and code, which is available for use by Dylan programs. Libraries are the unit of compilation, sealing, and optimization.

limited

(~ type) A type used to indicate objects that are instances of another type and have additional constraints. There are several kinds of limited types. (~ collection) A limited collection type. (~ integer) A limited integer type. See "Limited Types" on page 73 for a complete description of limited types.

literal constant

An object that is specified explicitly in program text. Literal constants are immutable.

local scope

A scope that includes a limited section of program text.

local binding

A binding created by a local declaration. Local bindings are visible within the remainder of the smallest enclosing body containing the declaration that creates the bindings.

local precedence order

The ordering of a class and its direct superclasses specified by the class definition. See also "Computing the Class Precedence List" on page 54 and class precedence list.

macro

An extension to the core language that can be defined by the user, by the implementation, or as part of the Dylan language specification. Much of the grammatical structure of Dylan is built with macros.

mandatory keyword

(of a generic function) A keyword that must be recognized by all of the methods of that generic function. Mandatory keywords are specified in the generic function's parameter list, after #key or as the key: initialization argument to make of <generic-function>.

method

A basic callable unit of code. It includes a parameter list, a return value declaration and a body.

method dispatch

The process of determining which method to call when a generic function is applied to arguments.

module

A namespace of bindings.

module binding

A binding that can be referenced from all code associated a particular module.

most specific method

The method whose specializers most closely match the arguments of a function call. A method specialized on a subclass is more specific than a method specialized on superclasses.

multimethod

A method that has more than one specialized parameter.

multiple inheritance

Inheritance from more than one direct superclass. See also single inheritance.

multiple values

Zero or more values returned by an expression. This term makes explicit the fact that Dylan expressions are not required to return exactly one value. They may also return zero or more than one value.

mutable

Capable of being modified after it is created. The opposite of mutable is immutable.

named value reference

An expression that is a reference to a binding.

natural order

The order in which elements of a collection are traversed by the iteration protocol for a particular iteration. If a collection is stable under iteration, every iteration over the collection has the same natural order.

next method

(during a generic function call) The method that is next most specific, after the method that is currently executing, in the sequence of applicable methods for that generic function call.

next-method parameter

A parameter, usually called next-method. The value of the next-method parameter is automatically supplied by the generic function dispatch mechanism. It is either #f (if there is no next method) or a function that calls the next method after defaulting any unsupplied arguments. There is no way for a program to specify the value of the next method parameter explicitly.

nonlocal exit

A transfer of control, through an exit point, out of a local region of code. The nonlocal exit terminates the normal execution of the code.

normal exit

Completing execution and returning without taking a nonlocal exit.

object

A unit of data in a Dylan program. Objects are instances of classes, may be stored in variables, slots, and collections, may be passed as arguments to functions, and may be returned as values of functions.

open class

A class that may have subclasses that are not explicitly defined in the same library. The opposite of an open class is a sealed class.

open generic function

A generic function that may have methods that are not explicitly defined in the same library. The opposite of an open generic function is a sealed generic function.

owned

(of a binding, by a module) Created by a create clause in the module's define module definition, or by a definition associated with the module.

pair

An instance of <pair>.

parameter

(of a function) A variable that is declared in the parameter list of a function and specifies part of the function's calling protocol. Parameters are lexically bound within the function body, and are bound to their initial values when the function is called. Dylan supports required parameters, rest parameters, keyword parameters, and next-method parameters.

parameter list

The part of a function definition that specifies the function's arguments and return values. See also signature.

predicate function

A function that returns a true or false value. By convention, the names of predicate functions end in a question mark.

primary class

A class that may be used only as the primary superclass in multiple inheritance. A class may not have two primary superclasses unless one is a subclass of the other. The opposite of a primary class is a free class.

proper list

A list that has the empty list as the tail of its last pair.

proper subclass

(of a class) A class that is a subclass of the class, but is not identical to the class.

proper subtype

(of a type) A type that is a subtype of the type, but is not equivalent to the type. See also equivalent types.

protocol

1. (of a class) The methods that all subclasses of the class either implement or inherit. 2. (of a function, esp. a generic function) The signature of the function.

pseudosubtype

A relation between types. The type T1 is a pseudosubtype of the type T2 if T1 is a subtype of the base type of T2 and T1 and T2 are not disjoint.

required parameter

(of a function) A parameter that corresponds to an argument that must be supplied when the function is called. Required parameters are specified in a fixed order before other parameters, and their corresponding arguments must be supplied in the same order. Required parameters may be specialized or unspecialized. Compare rest parameter, keyword parameter, and next-method parameter.

requires a fixed number of arguments

The shape of the parameter list of a function that accepts neither keyword arguments nor a rest argument.

rest parameter

(of a function) A parameter that allows a function to accept a variable number of arguments following those that correspond to the required parameters. The additional arguments are stored in a sequence.

return value declaration

An optional part of a function definition that specifies the number and types of the values returned by the function. See also signature.

sealed class

A class that cannot have direct subclasses other than those explicitly defined in the same library. The opposite of a sealed class is an open class.

sealed domain

A portion of a generic function and a portion of the class hierarchy which are declared to be invariant. See "Define Sealed Domain" on page 135 for a complete description of sealed domains.

sealed generic function

A generic function that cannot have methods that are not explicitly defined in the same library. The opposite of a sealed generic function is an open generic function.

sealing directive

A definition or adjective within a definition that specifies a sealing-related characteristic of the object being defined. See "Sealing" on page 133.

sequence

An instance of <sequence>, a type of collection which uses successive nonnegative integers as keys.

set

(the value of a slot) To replace the value of the slot with a new value.

setter

A function used to set the value of a slot. By convention, the name of a setter is the name of the getter concatenated with the suffix -setter.

setter method

A method that sets the value of a slot.

shadow

(a binding) To hide the binding within a portion of program text, by creating a new local binding with the same name.

shallow copy

(of an object) A new object that has the same contents as the object. The contents are not copied, but are the same objects contained in the original object.

signature

(of a function) The parameter list of the function, including its return value declaration.

single inheritance

Inheritance from only one direct superclass. See also multiple inheritance.

singleton

A type used to indicate an individual object. A singleton has only one instance.

slot

A unit of local storage available within an instance or a class, which is used to store state in the instance or class.

slot accessor

A getter or setter.

slot reference syntax

The shorthand syntax for invoking a function of one argument. window.position is equivalent to position(window).

source record

An implementation-defined unit of source program text.

specialize

1. (a variable) To restrict the variable to values that are general instances of a particular type. 2. (a generic function) To define a method for the generic function that is applicable only to instances of a particular type or types. 3. (a method) To specify the types of the parameters of the method.

specializer

A type, especially when it is used to specialize a parameter, variable, or slot.

stable under iteration

(of a collection) The property of a collection that any two iterations over the collection are guaranteed to produce the same values in the same order (unless, of course, the collection has been modified). See also natural order and sequence.

statement

A call to a statement macro. See page 15 for a description of statement macros.

stretchy collection

A collection that may grow or shrink to accommodate adding or removing elements.

supplied initialization arguments

The keyword arguments values supplied in a call to make. See also "Instance Creation and Initialization" on page 64 and defaulted initialization arguments.

table

An object, also known as a hash table, that maps arbitrary keys to objects. Each table has an associated equivalence predicate that is used to compare keys. The table maps keys that are equivalent under the predicate to the same table element.

true

1. The canonical true value, #t. 2. Any object other than the unique false value, #f.

type

A Dylan object that categorizes objects. See page 49.

type equivalent

See equivalent types.

type-for-copy

(of an object) An instantiable type suitable for making copies of an object. Instances of the type-for-copy must be mutable.

unbounded sequence

A sequence that is infinite or circular.

uninstantiable class

A class that cannot be used as the first argument to make. The opposite of an uninstantiable class is an instantiable class.

union type

A type used to indicate objects that are instances of one of a set of specified types. See page 72 for a complete description of union types.

unique string

A symbol literal represented in source code as a sharp sign "#" followed immediately by a string literal. These are semantically identical to keywords; the distinct syntax is provided for program readability.

value declaration

See return value declaration.

value type

The type of a return value of a function, as defined in the function's parameter list.

variable

A variable binding.

variable binding

A binding that can be assigned a new value.

visible modification

(with respect to an equivalence predicate) A modification that changes the equivalence class of the object. The modifications that are visible to an equivalence predicate are determined by the definition of the predicate. See also "Tables" on page 122.

whitespace

Any number of contiguous space, tab, newline, and newpage characters. Except within string literals, the amount of contiguous whitespace is not significant in program code.