The Dylan Quick Reference

1. Notation

This is a brief summary of useful things you might want to know about Dylan. The more complicated things are explained in handouts, this is just a quick reference.

Notation used in this handout:

• Things in fixed font are things that are typed in.
• Things in italics are parameters.
• "expr ..." means zero or more expressions.
• "expr₁ expr₂ ..." means one or more expressions.
• "[...]" means an optional syntax.

2. Identifiers

You can use letters, numbers and "=", "-", ">", "<", "/", "*" and "+" in identifiers (names). Numbers may not appear as the first character in an identifier.

3. Types

By convention, all types begin with a "<" and end with a ">". There is a hierarchy of types, with various mechanisms for user defined classes. Dylan provides many built in types, to handle numbers, strings, collections of objects, and more:

• <object>
  • <boolean>
  • <character>
  • <collection>
    • <list>
      • <empty-list>
      • <pair>
    • <string>
    • <vector>
  • <keyword>
  • <error>
    • <simple-error>
    • <type-error>
  • <function>
    • <generic-function>
    • <macro>
    • <method>
  • <number>
    • <float>
    • <integer>
  • <symbol>
  • <type>
    • <class>
    • <singleton>

4. Numbers

There are two built-in number classes, <float> and <integer>. <integer> provides integer values in the range -2⁶³...2⁶³-1.

5. Variables

Variable names can either be specified by an identifier or an (identifier type) pair. The latter is used to force the variable referenced by identifier to be of type type, and is the preferable form to use in Dylan. Specifying no type is the same as the using (identifier <object>).

6. Booleans

• #t means true
• #f means false

In addition, any object other than #f means true as well. It is good programming style however to use #t when you explicitly mean true.

7. Lists

• A <pair> is anything that can be taken apart with the head and tail functions (see below).
• The constant "()" is the empty list constant.
• A <list> is either a <pair> or the empty list ().

8. Special Forms

Special forms are expressions that do not follow standard evaluation rules:

• (quote object) or 'object
  Both of these expressions return object (unevaluated). For instance, '(1 2 3) returns the list (1 2 3).
• (method (var ...) body ...)
  this expression returns a procedure that takes some values (with the types if specified - remember that var can be either an identifier or an identifier/type pair [5]) as arguments, and when called, evaluates the body expression/s.
  For example, (method (x) (* x x)) has the value of a one-argument method. To use the method, put it in the first position of a combination ((method (x) (* x x)) 5) will evaluate to 25.
• (if test consequent alternate)
  Evaluates test, and if it evaluates to true, then it evaluates consequent, otherwise, it evaluates alternate. Keep in mind that anything that is not #f is true, so (if 0 1 2) evaluates to 1.
• (when test body)
  Evaluates test, and, if true, evaluates body, else returns #f.
• (cond (test₁ body₁)
        (test₂ body₂)
         ...
        [(else: body_else)] )
  Evaluates test₁, test₂, ... until one evaluates to true, then evaluate its corresponding body_n. If all of the clauses are false, the value of the cond is #f.
  You may also use the "else:" optional keyword to specify that the value of the cond is body_else if all the tests are false.
• (and expr ...)
  Checks the exprs from left to right until one evaluates to false, in which case it returns #f. If they all return true, and returns the value of the last expr.
• (or expr ...)
  Checks the exprs from left to right until one evaluates to true, in which case it returns that value. If they all return false, or returns #f.
• (not expr)
  If expr evaluates to #f, not returns #t. Otherwise, not returns #f. Note that not is not actually a special form, but specified here next to its relatives.
• (define var expr)
  Bind the variable name var to the value of expr. define can only be used in the global environment. var can specify a type [5]. It is considered extremely bad style to define something more than once.
• (bind ((var₁ expr₁)
         (var₂ expr₂)
          ...)
     body)
  Evaluates expr_n in an environment that has var₁ to var_n-1 set and binds this value to var_n, then evaluates body in an environment with all the vars set. vars can specify types [5].
• (bind-methods ((name₁ (var ...) body₁...)
                 (name₂ (var ...) body₂...)
                 ...)
     body)
  Binds the methods specified in such a way that they can be mutually recursive, then evaluates the body in the new envrionment created.
• (set! var expr)
  Changes the value of var to that of expr. CS212 students may not use this form until covered in class.
• (begin expr₁ expr₂ ... expr_n)
  Evaluates the exprs from left to right and returns the the value of expr_n. Useful for putting a sequence of expressions where only one is expected.
• (define-class <class> (<superclass>₁ ... <superclass>_n)
    (slot-name₁ <slot-type₁> [init-val₁])
     ...
    (slot-name_m <slot-type_m> [init-val_m]))
  Defines a new class <class>, with the given n superclasses and m slots. Also, automatically defines accessor functions with the same names as the given slot-names. The specifications of initial values for slots is optional.

  An alternate (more explicit), optional syntax for define-class is:
  (define-class <class> (<superclass>₁ ... <superclass>_n)
    (slot-name₁ <type₁> <keyword₁> [init-val₁])
     ...
    (slot-name_m <type_m> <keyword_m> [init-val_m]))
  

• (get-slot slot-name: x) Accesses the slot named slot-name: in the data structure x.
• (make <class> slot-name₁: value₁ ... slot-name_m: value_m)
  Creates an instance of class <class>, with initialized slot values as given.
• (define-generic-function name (var ...))
  Defines a generic function with then given name and vars.
• (add-method name proc)
  Adds the function proc to the generic function name.

9. Equality Testing

• (id? x y): True if x and y reference the same object.
• (= x y): True if x and y are "congruent"; which roughly means if they print the same.

10. List Structure Operators

• (null? x): Returns #t if x is the the empty list () and #f for all other objects.
• (pair x y): Returns a <pair> whose head is x and whose tail is y.
• (head l): Returns the first element of the list l.
• (tail l): Returns the tail of the list l.
• (head-setter obj pair): set!s the head of pair. Don't use until presented in class.
• (tail-setter obj pair): set!s the tail of pair. Don't use until presented in class.
• (list x₁ ...): Evalutes x₁, ... and puts them into a list.
• (length l): Returns the length of the list l.
• (append list₁ ...): Appends the lists together.
• (reverse l): Turns the list l around.
• (member? obj l): Searches the list l for something = to obj, returning #t if found, else #f.

11. Type Checking Operations

• (instance? obj class): Is obj an instance of class class?
• (object-class obj): Returns the class of obj.
• (super-class? c₁ c₂): Is c₁ a superclass of c₂?

12. Arithmetic and Numeric Operators

• (= x y), (< x y), (> x y), (<= x y), (>= x y): Various forms of numerical comparison.
• (max x₁ ...), (min x₁ ...): Return the maximum (minimum) of all x's.
• (+ x₁ x₂): Addition.
• (* x₁ x₂): Multiplication.
• (- x₁ x₂): Subtraction.
• (/ x₁ x₂): Division - result type depends on the input argument types.
• (^ x₁ x₂): Power operator. Raises x₁ to the x₂ power.
• (- x): Negation -x.
• (/ x): Reciprocal 1/x.
• (remainder n₁ n₂): Remainder after integer division.
• (modulo n₁ n₂): Clock arithmetic, n₁ mod n₂.
• (zero? x), (positive? x), (negative? x): Checks whether x=0, x>0 or x<0.
• (even? x), (odd? x): Checks whether x is even or odd
• (inc x), (dec x): Shorthand for (+ x 1) and (- x 1)
• (abs x): Absolute value of x.
• (truncate x): Integer closest to x whose absolute value <= |x|.
• (sqrt x): Square root.
• (sin x), (cos x), (tan x): Trigonometric functions.

13. Vector Operators

• (n-vector n): Creates a new vector of n elements (the initial values of the elements is undefined), indexed from 0 to n-1.
• (vector x₁ ...): Evalutes x₁, ... and puts them into a vector.
• (length vec): Returns the length of the vector vec, which is the number of elements it can store, (using constant time).
• (index vec i): Get i'th element of vec (in constant time).
• (index-setter! i vec val): Store val at element i of vec (in constant time).

14. Higher Order Functions

• (apply proc arg-list): Call proc with arguments as arg-list.
• (map func list₁ ...): Applies func to the elements of list₁, ... (that is, the first of each, the second of each, etc.) and collects the results in a list. The order it does it is not specified and probably not the one you want, but the order they appear in the result list is the right one.
• (filter pred l): Returns the list of elements from l which satisfy pred (it returns true when applied to them.