The for Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

The for Reference Manual

This is the for Reference Manual, version 1.0.0, generated automatically by Declt version 2.3 "Robert April" on Tue Feb 20 08:39:41 2018 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

1 Introduction

About For

For is a library for an extensible iteration macro. It allows you to write concise looping constructs similar to loop and iterate. Unlike loop however it is extensible and sensible, and unlike iterate it does not require code-walking and is easier to extend.

How To

Load For using ASDF or Quicklisp.

(ql:quickload :for)

Now we can use the for macro to do iteration. Most of the constructs you know from loop are available with the same name in For.

(for:for ((li in (list 1 2 3 4))
          (vi across #(a b c d)))
  (format T "~&~a ~a" li vi))

In loop this might look as follows:

(loop for li in (list 1 2 3 4)
      for vi across #(a b c d)
      do (format T "~&~a ~a" li vi))

Unlike loop and iterate, for makes a distinction between "bindings" and body forms. Body forms can also contain clauses:

(for:for ((li in (list 1 2 3 4)))
  (thereis (evenp li)))

In loop this might look as follows:

(loop for li in (list 1 2 3 4)
      thereis (evenp li))

Naturally, there's also accumulation bindings:

(for:for ((randoms collecting (random 10)))
  (until (= 10 (length randoms))))

In loop this might look as follows:

(loop collect (random 10) into randoms
      until (= 10 (length randoms)))

You might realise that the above is a rather inefficient way of writing the loop. Instead we can also use the repeat binding:

(for:for ((i repeat 10)
          (randoms collecting (random 10))))

In loop this might look as follows:

(loop repeat 10
      collect (random 10))

If we have multiple bindings or clauses that might have useful values to return, all of them are returned:

(for:for ((a over *random-state* :limit 10)
          (b collect a))
  (thereis (evenp a)))

In loop this might look as follows:

(loop with iterator = (for-iterator:make-iterator *random-state* :limit 10)
      while (for-iterator:has-more iterator)
      for a = (for-iterator:next iterator)
      collect a into b
      when (evenp a)
      return (values T b))

In order for short-circuiting clauses to have highest priority on values, clause-values are always returned first followed by binding values. Otherwise the order follows the declaration order of the respective clauses/bindings. Note that clauses must appear as a "top-level" form within the for body and cannot appear as the result of a macroexpansion.

For also features a generic iterator construct that allows you to iterate over a multitude of different data types without having to do a case-distinction by yourself. We already saw this with the over *random-state* binding from the previous example.

(for:for ((a over '(1 2 3))
          (b over #(a b c))
          (c over (for:for ((table as (make-hash-table))) 
                    (setf (gethash (random 10) table) (random 10)) (repeat 3)))
          (d over *package*)
          (e over *random-state*)
          (f over (directory (merge-pathnames "*.*" (user-homedir-pathname))))
          (g over (make-string-input-stream "Hi!")))
  (print (list a b c d e f g)))

Note that the over iterator construct can be drastically slower than a tailored iteration construct.

Some iterators also support updating the current element. If you require doing so, you can use the updating binding.

(for:for ((list as (list 1 2 3 4 5))
          (item updating list))
  (setf item (expt item item)))

In loop this might look as follows:

(loop with list = (list 1 2 3 4 5)
      with iterator = (for-iterator:make-iterator list)
      while (for-iterator:has-more iterator)
      do (for-iterator:next iterator)
         (symbol-macrolet ((item (for-iterator:current iterator)))
           (setf item (expt item item)))
      finally (return list))

Some of the bindings also support destructuring the current item by a destructuring-lambda-list.

(for:for (((type &key object limit) in '((counter :limit 5)
                                         (package :object *package*))))
  (format T "~&Type: ~a~@[ Object: ~a~]~@[ Limit: ~a~]" type object limit))

In loop this might look as follows:

(loop for list in '((counter :limit 5)
                    (package :object *package*))
      do (destructuring-bind (type &key object limit) list
           (format T "~&Type: ~a~@[ Object: ~a~]~@[ Limit: ~a~]" type object limit)))

You can check a binding's or clause's documentation with (documentation 'in 'for:binding) which will tell you whether it supports destructuring through update.

Sometimes you may want to iterate over multiple things in sequence rather than in parallel. For this you can use the being binding, which allows you to pass a list of sub-bindings to sequentially use.

(for:for (((k v) being
           (in '((駅 station) (出口 exit) (特急 express-train)))
           (across #((勉強 studying) (宿題 home-work) (授業 lesson) (試験 exam)))))
  (format T "~&~a: ~a" k v))

In loop this might look as follows:

(progn (loop for (k v) in '((駅 station) (出口 exit) (特急 express-train))
             do (format T "~&~a: ~a" k v))
       (loop for (k v) across #((勉強 studying) (宿題 home-work) (授業 lesson) (試験 exam))
             do (format T "~&~a: ~a" k v)))

If a binding should only be updated based on a condition, there's the when and unless bindings that defer based on a test.

(for:for ((random = (random 10))
          (list when (evenp random) collect random))
  (until (= 10 (length list))))

In loop this might look as follows:

(loop with list = ()
      for random = (random 10)
      when (evenp random)
      do (push random list)
      until (= 10 (length list))
      finally (return (nreverse list)))

The following bindings are included in the for-minimal package:

The following clauses are included in the for-minimal package:

Iterator classes for the following types is included in the for-iterator package:

Extending FOR

Both bindings and clauses are defined in terms of functions that return three values:

  1. A surrounding form
    Surrounding forms will be wrapped around the rest of the expanded for by appending the rest to it. This happens through with-interleaving.
  2. A loop body form
    The body form is put inside the loop where it will be evaluated once per iteration.
  3. A return value form
    The return value form is evaluated on loop end. The position within the returned values is dependent on the clauses and bindings present during expansion. If not provided, no return value is generated. Note that this is distinct from having NIL as a third value.

Passed to the functions are the literal arguments used in the binding or clause expression. In that way, a clause/binding function must work just like a macro would.

Bindings

The most primitive way to define bindings is through the define-direct-binding macro. This defines a verbatim binding function as described above. Note that the loop body forms of bindings will always be evaluated before the proper for body.

In most cases you will want the arguments that are passed to the binding to be evaluated only once, before the loop starts properly. The define-value-binding macro will help you with that. Each argument you specify will be bound to a gensym within the definition body, and is automatically expanded to a variable with the value that is used in the binding. &aux arguments receive special treatment as they are expanded like regular variables and thus allow you to easily define helper variables necessary during iteration.

Let's look at an example binding definition:

(define-value-binding across (var vector &aux (i -1) (length (length vector)))
  `(if (= ,length (incf ,i))
       (end-for)
       (update ,var (aref ,vector ,i))))

Expanding a simple call (for ((a across vec))) results in this expansion (after cleaning it up a little):

(LET* ((#:VECTOR VEC)
       (#:I -1)
       (#:LENGTH (LENGTH #:VECTOR))
       (A NIL))
  (WITH-FOR-BODY
    (IF (= #:LENGTH (INCF #:I))
        (END-FOR)
        (UPDATE A (AREF #:VECTOR #:I))))

As you can see, our only argument, vector got expanded into a gensym-ed variable that is bound to the result of the vector argument. Our auxiliary variables received similar treatment. Note that references to other arguments automatically get translated to their proper gensyms.

In some cases however you'd like to re-evaluate an argument each iteration. To get this behaviour, you can use define-form-binding. Here's a simple example:

 (define-form-binding = (var form)
   `(update ,var ,form))

Expanding a simple call (for ((a = (* 2 2)))) presents us with:

 (LET* ((A NIL))
   (WITH-FOR-BODY
     (UPDATE A (* 2 2)))

Usually you will want form bindings if you want to accumulate the results of it over time in some manner. In that case you usually also want to return the result of the accumulation once you're done. define-accumulation-binding does exactly that. One note about form bindings is that the auxiliary variables still act the same as in the value bindings-- they automatically get expanded to bindings in the resulting loop construct.

Let's look at an example that shows both:

(define-accumulation-binding collecting (var form &aux (head (cons NIL NIL)) (tail head))
  `(setf ,tail (setf (cdr ,tail) (cons ,form NIL))
         ,var (cdr ,head)))

Expanding (for ((a collecting 2))) results in:

(LET* ((#:HEAD (CONS NIL NIL)) (#:TAIL #:HEAD) (A NIL))
  (WITH-FOR-BODY
   (SETF #:TAIL (SETF (CDR #:TAIL) (CONS 2 NIL))
         A (CDR #:HEAD))
   (RETURN-FOR A))

As before, the auxiliary arguments got expanded to variable bindings with their respective default values.

Finally we have two variants of form and value bindings, define-form-symbol-macro-binding and define-value-symbol-macro-binding. The difference to the previous definition forms here is that the var is not bound as a variable, but instead as a symbol macro. Its default value is the symbol-macro expansion. This is useful if you want to provide an updateable place as the iteration var, as is the case with the updating binding.

Clauses

Clauses work the exact same as bindings in terms of the base function, which you can define with define-direct-clause. Unlike bindings however, clauses simply get the body of their call as arguments, without an iteration var.

In order to ease things a bit there is also define-simple-clause which provides the same handling for arguments as define-form-binding does.

One thing to note is that the surrounding forms of clauses always appear deeper than those of bindings and that the result value forms of clauses always appear before those of bindings. The loop body form of a clause appears at the exact position in the body where the clause expression previously appeared.

Iterators

In order to provide the generic over iteration construct, For includes a protocol to define iterators. In order for an iterator to work, it has to subclass iterator and provide three methods: make-iterator, has-more, and next. The first is merely there so that we can dispatch on the type of object we'd like to iterate over and construct an appropriate iterator for it. The second should return a generalised boolean that tells us whether we can safely call next. Finally, next itself advances the iterator and returns a new element. If sensible and possible, a method on (setf current) can also be provided to allow updating the current element to a new value.

Let's look at the list iterator as an example:

(defclass list-iterator (iterator)
  ())

(defmethod initialize-instance :after ((iterator list-iterator) &key object)
  (setf (object iterator) (cons NIL object)))

(defmethod has-more ((iterator list-iterator))
  (cdr (object iterator)))

(defmethod next ((iterator list-iterator))
  (setf (object iterator) (cdr (object iterator)))
  (car (object iterator)))

(defmethod (setf current) (value (iterator list-iterator))
  (setf (car (object iterator)) value))

(defmethod make-iterator ((list list) &key)
  (make-instance 'list-iterator :object list))

First we subclass iterator. Next we define an initialize method in order to prepend a cons to the list. We do this so that we know the next element will always be in the cadr of the object and we can still set the car of the current cons cell to update it. The has-more test is implemented accordingly. On next we then simply pop off the first cons and return our new current element. The (setf current) can then just update the car of the object. Finally we


Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

The main system appears first, followed by any subsystem dependency.


Previous: , Up: Systems   [Contents][Index]

2.1 for

Maintainer

Nicolas Hafner <shinmera@tymoon.eu>

Author

Nicolas Hafner <shinmera@tymoon.eu>

Home Page

https://github.com/Shinmera/for

License

Artistic

Description

An extensible iteration macro library.

Version

1.0.0

Dependencies
Source

for.asd (file)

Components

Next: , Previous: , Up: Top   [Contents][Index]

3 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Previous: , Up: Files   [Contents][Index]

3.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.1 for.asd

Location

for.asd

Systems

for (system)


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.2 for/package.lisp

Parent

for (system)

Location

package.lisp

Packages

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.3 for/toolkit.lisp

Dependency

package.lisp (file)

Parent

for (system)

Location

toolkit.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.4 for/binding.lisp

Dependency

toolkit.lisp (file)

Parent

for (system)

Location

binding.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.5 for/clause.lisp

Dependency

binding.lisp (file)

Parent

for (system)

Location

clause.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.6 for/for.lisp

Dependency

clause.lisp (file)

Parent

for (system)

Location

for.lisp

Exported Definitions

for (macro)

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.7 for/iterator.lisp

Dependency

for.lisp (file)

Parent

for (system)

Location

iterator.lisp

Exported Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.8 for/standard.lisp

Dependency

iterator.lisp (file)

Parent

for (system)

Location

standard.lisp

Internal Definitions

Previous: , Up: Lisp files   [Contents][Index]

3.1.9 for/documentation.lisp

Dependency

standard.lisp (file)

Parent

for (system)

Location

documentation.lisp


Next: , Previous: , Up: Top   [Contents][Index]

4 Packages

Packages are listed by definition order.


Next: , Previous: , Up: Packages   [Contents][Index]

4.1 for

Source

package.lisp (file)

Nickname

org.shirakumo.for

Use List
Exported Definitions
Internal Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

4.2 for-minimal

Source

package.lisp (file)

Nickname

org.shirakumo.for.minimal

Use List

common-lisp

Used By List

for

Exported Definitions

Previous: , Up: Packages   [Contents][Index]

4.3 for-iterator

Source

package.lisp (file)

Nickname

org.shirakumo.for.iterator

Use List

common-lisp

Used By List

for

Exported Definitions

Next: , Previous: , Up: Top   [Contents][Index]

5 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Next: , Previous: , Up: Definitions   [Contents][Index]

5.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.1 Macros

Macro: define-accumulation-binding NAME (VAR &rest ARGS) &body BODY

Defines a binding for an accumulator.

This is identical to DEFINE-FORM-BINDING with the exception that the secondary value is set to a (RETURN-FOR var) for you, meaning the variable’s contents are returned from the FOR upon normal termination.

See DEFINE-FORM-BINDING

Package

for

Source

binding.lisp (file)

Macro: define-alias-binding NAME REFERENCED-BINDING-NAME

Defines an alias for a binding.

See BINDING

Package

for

Source

binding.lisp (file)

Macro: define-direct-binding NAME ARGS &body BODY

Defines a binding function.

Binding functions can return three values:

1. A single "surrounding form" that will go around the resulting loop. If you require multiple surrounding forms, you can use WITH-INTERLEAVING.
2. A form to run during each iteration. They will be run before any body forms. 3. A form whose value is returned by the FOR.

The arguments that the function receives are directly translated from the respective binding expression. One argument will always be passed in the very least: the variable specified for the binding.

Note that a binding function receives its arguments as literals and thus must process them like a macro would (destructive operations are bad juju).

Also note that unlike normal functions, the &environment lambda-list argument is available and its value will be passed on from the calling FOR macro.

See BINDING
See REMOVE-BINDING

Package

for

Source

binding.lisp (file)

Macro: define-form-binding NAME (VAR &rest ARGS) &body BODY

Defines a binding that receives its arguments as literals.

&AUX variables in the ARGS lambda-list receive special treatment: they are bound to gensyms within the definition body. Their value is only evaluated and set within the expanded binding. This means that &AUX variables give you a convenient way to introduce necessary helper variables to the expanded binding. References to other AUX variables or the VAR are automatically rewritten to the appropriate gensym.

VAR can also accept a default value, which receives the same semantic treatment as &AUX variables do, with the exception that it is always the last binding to be evaluated in the resulting expansion, meaning every other &AUX variable can be referenced.

The primary value returned must be the form to be evaluated on each iteration. A secondary value may be returned, which is a form to be evaluated when the loop ends normally.

See DEFINE-DIRECT-BINDING
See DEFINE-VALUE-BINDING

Package

for

Source

binding.lisp (file)

Macro: define-form-symbol-macro-binding NAME (VAR &rest ARGS) &body BODY

Defines a binding that receives its arguments as literals and treats the VAR as a symbol-macro.

This is the exact same as DEFINE-FORM-BINDING with the exception that the
VAR is translated into a symbol-macro binding. Its value is still translated
accordingly to make sure references to AUX variables stay intact.

See DEFINE-FORM-BINDING

Package

for

Source

binding.lisp (file)

Macro: define-value-binding NAME (VAR &rest ARGS) &body BODY

Defines a binding that receives its arguments as values.

The treatment of all arguments in the ARGS lambda-list is as follows: Within the definition body, they are bound to gensyms. Upon expansion of the binding, each variable is expanded to a variable binding with the respective value that was passed to the binding definition. Special exception is made for the present-p optional variables that can be specified for optional or key arguments, which are bound as usual in the definition body such that expansion may be aware of which parameters were passed. In essence, you can interpret all arguments as if treated by ONCE-ONLY.

&AUX variables in the args lambda-list receive special treatment: they are bound to gensyms within the definition body. Their value is only evaluated and set within the expanded binding. This means that AUX variables give you a convenient way to introduce necessary helper variables to the expanded binding. References to other arguments or the VAR are automatically rewritten to
the appropriate gensym.

VAR can also accept a default value, which receives the same semantic treatment as &AUX variables do, with the exception that it is always the last binding to be evaluated in the resulting expansion, meaning every other argument can be referenced.

The primary value returned must be the form to be evaluated on each iteration. A secondary value may be returned, which is a form to be evaluated when the loop ends normally.

See DEFINE-FORM-BINDING
See DEFINE-DIRECT-BINDING

Package

for

Source

binding.lisp (file)

Macro: define-value-symbol-macro-binding NAME (VAR &rest ARGS) &body BODY

Defines a binding that receives its arguments as values and treats the VAR as a symbol-macro.

This is the exact same as DEFINE-VALUE-BINDING with the exception that the
VAR is translated into a symbol-macro binding. Its value is still translated
accordingly to make sure references to arguments stay intact.

See DEFINE-VALUE-BINDING

Package

for

Source

binding.lisp (file)

Macro: for BINDINGS &body BODY

Loops the body with the given bindings established.

Each binding should have the form (var binding-type args*)

Sometimes a var can be either a single symbol denoting a variable, or a lambda-list to which the result is destructured and bound via UPDATE.
The support thereof depends on the binding construct.

Within the body, special iteration clauses may be present. A clause must appear at the "top-level" of the body and cannot appear as a macro-expansion.

If the loop is terminated normally by END-FOR then multiple values may be returned depending on how many bindings or clauses are present that want to return values. The order of the values is as follows: the clause values are returned in the order that the clauses appear in the body, followed by the binding values in the order of the binding expressions.

The loop may also be terminated abnormally by a direct call to RETURN-FOR or RETURN.

See UPDATE
See BINDING
See CLAUSE
See END-FOR
See SKIP-FOR
See RETURN-FOR
See WITH-FOR-TAGBODY
See WITH-FOR-BLOCK
See CONVERT-BINDINGS
See CONVERT-CLAUSES

Package

for-minimal

Source

for.lisp (file)

Macro: update PLACE VALUE-FORM

Allows updating the PLACE with a new value.

Unlike just (setf place value), PLACE can also be a lambda-list where each variable is then properly updated with the respective element from value list.

Package

for-minimal

Source

toolkit.lisp (file)

Macro: with-interleaving &body BODY

Interleave the body forms.

Essentially this means that the last form is appended to the form before it and this is then appended to the form before that, and so on.

Package

for

Source

toolkit.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.2 Functions

Function: binding NAME

Accessor to the function that compiles the given binding.

If there is no binding named by the given symbol directly, another search is performed using the symbol with the same symbol-name from the FOR package.

See REMOVE-BINDING

Package

for

Source

binding.lisp (file)

Writer

(setf binding) (function)

Function: (setf binding) FUNC NAME
Package

for

Source

binding.lisp (file)

Reader

binding (function)

Function: clause NAME

Accessor to the function that compiles the given clause.

If there is no clause named by the given symbol directly, another search is performed using the symbol with the same symbol-name from the FOR package.

See REMOVE-CLAUSE

Package

for

Source

clause.lisp (file)

Writer

(setf clause) (function)

Function: (setf clause) FUNC NAME
Package

for

Source

clause.lisp (file)

Reader

clause (function)

Function: hash-table-iterator TABLE

Returns a function to iterate over a hash-table.

See CL:WITH-HASH-TABLE-ITERATOR

Package

for-iterator

Source

toolkit.lisp (file)

Function: package-iterator PACKAGE STATUSES

Returns a function to iterate over a package’s symbols.

See CL:WITH-PACKAGE-ITERATOR

Package

for-iterator

Source

toolkit.lisp (file)

Function: remove-binding NAME

Removes the given binding function.

See BINDING

Package

for

Source

binding.lisp (file)

Function: remove-clause NAME

Removes the given clause function.

See CLAUSE

Package

for

Source

clause.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.3 Generic functions

Generic Function: buffer OBJECT

Accessor to the stream-iterator’s buffer.

See STREAM-ITERATOR

Package

for-iterator

Writer

(setf buffer) (generic function)

Methods
Method: buffer (STREAM-LINE-ITERATOR stream-line-iterator)

automatically generated reader method

Source

iterator.lisp (file)

Method: buffer (STREAM-ITERATOR stream-iterator)

automatically generated reader method

Source

iterator.lisp (file)

Generic Function: (setf buffer) NEW-VALUE OBJECT
Package

for-iterator

Reader

buffer (generic function)

Methods
Method: (setf buffer) NEW-VALUE (STREAM-LINE-ITERATOR stream-line-iterator)

automatically generated writer method

Source

iterator.lisp (file)

Method: (setf buffer) NEW-VALUE (STREAM-ITERATOR stream-iterator)

automatically generated writer method

Source

iterator.lisp (file)

Generic Function: close-stream OBJECT

Accessor to whether the stream should be closed on END call or not.

See STREAM-ITERATOR
See STREAM-LINE-ITERATOR

Package

for-iterator

Writer

(setf close-stream) (generic function)

Methods
Method: close-stream (STREAM-LINE-ITERATOR stream-line-iterator)

automatically generated reader method

Source

iterator.lisp (file)

Method: close-stream (STREAM-ITERATOR stream-iterator)

automatically generated reader method

Source

iterator.lisp (file)

Generic Function: (setf close-stream) NEW-VALUE OBJECT
Package

for-iterator

Reader

close-stream (generic function)

Methods
Method: (setf close-stream) NEW-VALUE (STREAM-LINE-ITERATOR stream-line-iterator)

automatically generated writer method

Source

iterator.lisp (file)

Method: (setf close-stream) NEW-VALUE (STREAM-ITERATOR stream-iterator)

automatically generated writer method

Source

iterator.lisp (file)

Generic Function: current ITERATOR

Accessor to the current item of the iterator.

The behaviour is undefined if CURRENT is used before NEXT has been called for a first time. Some (but not all) iterators may support setting the current element to a new value.

See NEXT

Package

for-iterator

Source

iterator.lisp (file)

Writer

(setf current) (generic function)

Methods
Method: current (ITERATOR iterator)

automatically generated reader method

Generic Function: (setf current) VALUE ITERATOR
Package

for-iterator

Source

iterator.lisp (file)

Reader

current (generic function)

Methods
Method: (setf current) NEW-VALUE (ITERATOR iterator)

automatically generated writer method

Method: (setf current) VALUE (ITERATOR hash-table-iterator)
Method: (setf current) (VALUE sequence) (ITERATOR stream-iterator)
Method: (setf current) (VALUE character) (ITERATOR stream-iterator)
Method: (setf current) (VALUE integer) (ITERATOR stream-iterator)
Method: (setf current) VALUE (ITERATOR array-iterator)
Method: (setf current) VALUE (ITERATOR vector-iterator)
Method: (setf current) VALUE (ITERATOR list-iterator)
Generic Function: end ITERATOR

Ends the iterator and performs potential cleanup.

You should always call this function with your iterator object once you are done to ensure proper termination.

Package

for-iterator

Source

iterator.lisp (file)

Methods
Method: end (ITERATOR stream-line-iterator)
Method: end (ITERATOR stream-iterator)
Method: end (ITERATOR iterator)
Generic Function: has-more ITERATOR

Returns a generalised boolean indicating whether the iterator has more items or not.

Package

for-iterator

Source

iterator.lisp (file)

Methods
Method: has-more (ITERATOR hash-table-iterator)
Method: has-more (ITERATOR package-iterator)
Method: has-more (ITERATOR random-iterator)
Method: has-more (ITERATOR stream-line-iterator)
Method: has-more (ITERATOR stream-iterator)
Method: has-more (ITERATOR array-iterator)
Method: has-more (ITERATOR vector-iterator)
Method: has-more (ITERATOR list-iterator)
Generic Function: index OBJECT

Accessor to the current index within the buffer.

See STREAM-ITERATOR

Package

for-iterator

Writer

(setf index) (generic function)

Methods
Method: index (STREAM-ITERATOR stream-iterator)

automatically generated reader method

Source

iterator.lisp (file)

Generic Function: (setf index) NEW-VALUE OBJECT
Package

for-iterator

Reader

index (generic function)

Methods
Method: (setf index) NEW-VALUE (STREAM-ITERATOR stream-iterator)

automatically generated writer method

Source

iterator.lisp (file)

Generic Function: limit OBJECT

Accessor to the amount of data that is currently filled in the buffer.

See STREAM-ITERATOR

Package

for-iterator

Writer

(setf limit) (generic function)

Methods
Method: limit (RANDOM-ITERATOR random-iterator)

automatically generated reader method

Source

iterator.lisp (file)

Method: limit (STREAM-ITERATOR stream-iterator)

automatically generated reader method

Source

iterator.lisp (file)

Generic Function: (setf limit) NEW-VALUE OBJECT
Package

for-iterator

Reader

limit (generic function)

Methods
Method: (setf limit) NEW-VALUE (STREAM-ITERATOR stream-iterator)

automatically generated writer method

Source

iterator.lisp (file)

Generic Function: make-iterator OBJECT &key LIMIT BUFFER-SIZE ELEMENT-TYPE CLOSE-STREAM START &allow-other-keys

Create an iterator object for the given type of object.

Package

for-iterator

Source

iterator.lisp (file)

Methods
Method: make-iterator (HASH-TABLE hash-table) &key
Method: make-iterator (PACKAGE package) &key
Method: make-iterator (RANDOM-STATE random-state) &key LIMIT
Method: make-iterator (PATHNAME pathname) &key BUFFER-SIZE ELEMENT-TYPE
Method: make-iterator (STREAM stream) &key BUFFER-SIZE CLOSE-STREAM
Method: make-iterator (ARRAY array) &key START
Method: make-iterator (VECTOR vector) &key START
Method: make-iterator (LIST list) &key
Generic Function: next ITERATOR

Advances the iterator by one item and returns the new item.

The behaviour is undefined if the iterator does not have more items.

See HAS-MORE

Package

for-iterator

Source

iterator.lisp (file)

Methods
Method: next (ITERATOR hash-table-iterator)
Method: next (ITERATOR package-iterator)
Method: next (ITERATOR random-iterator)
Method: next (ITERATOR stream-line-iterator)
Method: next (ITERATOR stream-iterator)
Method: next (ITERATOR array-iterator)
Method: next (ITERATOR vector-iterator)
Method: next (ITERATOR list-iterator)
Method: next (ITERATOR iterator) around
Generic Function: object OBJECT

Accessor to the data structure the iterator is iterating over.

Note that this is not necessarily the same object as what was passed into the constructor of the iterator. The iterator is free to modify this slot as it sees fit.

See ITERATOR

Package

for-iterator

Writer

(setf object) (generic function)

Methods
Method: object (ITERATOR iterator)

automatically generated reader method

Source

iterator.lisp (file)

Generic Function: (setf object) NEW-VALUE OBJECT
Package

for-iterator

Reader

object (generic function)

Methods
Method: (setf object) NEW-VALUE (ITERATOR iterator)

automatically generated writer method

Source

iterator.lisp (file)

Generic Function: prefetch OBJECT

Cache for the next value

Since the iterator constructs provided by CL do not allow merely testing whether a next element is available without losing it if there is one, we must cache the value on a HAS-MORE call and then use that on NEXT instead of calling the iterator function twice.

See PACKAGE-ITERATOR
See HASH-TABLE-ITERATOR

Package

for-iterator

Writer

(setf prefetch) (generic function)

Methods
Method: prefetch (HASH-TABLE-ITERATOR hash-table-iterator)

automatically generated reader method

Source

iterator.lisp (file)

Method: prefetch (PACKAGE-ITERATOR package-iterator)

automatically generated reader method

Source

iterator.lisp (file)

Generic Function: (setf prefetch) NEW-VALUE OBJECT
Package

for-iterator

Reader

prefetch (generic function)

Methods
Method: (setf prefetch) NEW-VALUE (HASH-TABLE-ITERATOR hash-table-iterator)

automatically generated writer method

Source

iterator.lisp (file)

Method: (setf prefetch) NEW-VALUE (PACKAGE-ITERATOR package-iterator)

automatically generated writer method

Source

iterator.lisp (file)

Generic Function: start OBJECT

Accessor to the index that points to the next element of the vector-iterator.

Package

for-iterator

Writer

(setf start) (generic function)

Methods
Method: start (VECTOR-ITERATOR vector-iterator)

automatically generated reader method

Source

iterator.lisp (file)

Generic Function: (setf start) NEW-VALUE OBJECT
Package

for-iterator

Reader

start (generic function)

Methods
Method: (setf start) NEW-VALUE (VECTOR-ITERATOR vector-iterator)

automatically generated writer method

Source

iterator.lisp (file)

Generic Function: total-length OBJECT

Slot holding the array-total-size.

See ARRAY-ITERATOR

Package

for-iterator

Writer

(setf total-length) (generic function)

Methods
Method: total-length (ARRAY-ITERATOR array-iterator)

automatically generated reader method

Source

iterator.lisp (file)

Generic Function: (setf total-length) NEW-VALUE OBJECT
Package

for-iterator

Reader

total-length (generic function)

Methods
Method: (setf total-length) NEW-VALUE (ARRAY-ITERATOR array-iterator)

automatically generated writer method

Source

iterator.lisp (file)


Previous: , Up: Exported definitions   [Contents][Index]

5.1.4 Classes

Class: array-iterator ()

Iterator for general arrays.

Iteration is in row-major order.

Supports setting the current element.

See VECTOR-ITERATOR
See TOTAL-LENGTH

Package

for-iterator

Source

iterator.lisp (file)

Direct superclasses

vector-iterator (class)

Direct methods
Direct slots
Slot: total-length
Readers

total-length (generic function)

Writers

(setf total-length) (generic function)

Class: directory-iterator ()

Iterator for a DIRECTORY listing.

On construction, this performs a simple DIRECTORY call on the given object and then iterates over the result list of pathnames. Thus, the pathname must be wild.

See LIST-ITERATOR

Package

for-iterator

Source

iterator.lisp (file)

Direct superclasses

list-iterator (class)

Direct methods

initialize-instance (method)

Class: hash-table-iterator ()

Iterator for the key/value pairs in a package.

Each value returned by this iterator’s CURRENT/NEXT is always a list of two values, the respective key and its value.

Supports setting the current element.

See PREFETCH
See ITERATOR

Package

for-iterator

Source

iterator.lisp (file)

Direct superclasses

iterator (class)

Direct methods
Direct slots
Slot: prefetch
Readers

prefetch (generic function)

Writers

(setf prefetch) (generic function)

Class: iterator ()

An iterator is responsible for iterating over a given data structure.

See HAS-MORE
See NEXT
See CURRENT
See MAKE-ITERATOR
See OBJECT

Package

for-iterator

Source

iterator.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Direct slots
Slot: object
Initargs

:object

Readers

object (generic function)

Writers

(setf object) (generic function)

Slot: current
Readers

current (generic function)

Writers

(setf current) (generic function)

Class: list-iterator ()

Iterator for proper lists.

Supports setting the current element.

See ITERATOR

Package

for-iterator

Source

iterator.lisp (file)

Direct superclasses

iterator (class)

Direct subclasses

directory-iterator (class)

Direct methods
Class: package-iterator ()

Iterator for the symbols in a package.

The type of symbols that are iterated can be set through the :STATUS initarg, which must be a list containing any of the following keywords: :INTERNAL :EXTERNAL :INHERITED

See PREFETCH
See ITERATOR

Package

for-iterator

Source

iterator.lisp (file)

Direct superclasses

iterator (class)

Direct methods
Direct slots
Slot: prefetch
Readers

prefetch (generic function)

Writers

(setf prefetch) (generic function)

Direct Default Initargs
InitargValue
:status(quote (:internal :external :inherited))
Class: random-iterator ()

Iterator for random numbers.

This iterator can be constructed through a RANDOM-STATE object. The argument for RANDOM that determines its limit can be passed through the :LIMIT initarg.

See ITERATOR

Package

for-iterator

Source

iterator.lisp (file)

Direct superclasses

iterator (class)

Direct methods
Direct slots
Slot: limit
Initargs

:limit

Readers

limit (generic function)

Direct Default Initargs
InitargValue
:limit1.0
Class: stream-iterator ()

Iterator for input streams.

The stream is read through a buffer, the size of which can be set via the :BUFFER-SIZE initarg. If :CLOSE-STREAM is set to non-NIL, CLOSE is performed on the stream upon END.

Supports setting the "current" element if the stream supports writing to it of course.

See BUFFER
See INDEX
See LIMIT
See ITERATOR

Package

for-iterator

Source

iterator.lisp (file)

Direct superclasses

iterator (class)

Direct methods
Direct slots
Slot: buffer
Readers

buffer (generic function)

Writers

(setf buffer) (generic function)

Slot: index
Initform

1

Readers

index (generic function)

Writers

(setf index) (generic function)

Slot: limit
Initform

1

Readers

limit (generic function)

Writers

(setf limit) (generic function)

Slot: close-stream
Initargs

:close-stream

Readers

close-stream (generic function)

Writers

(setf close-stream) (generic function)

Class: stream-line-iterator ()

Iterator for line based input streams.

If :CLOSE-STREAM is set to non-NIL, CLOSE is performed on the stream upon END.

See BUFFER
See CLOSE-STREAM
See ITERATOR

Package

for-iterator

Source

iterator.lisp (file)

Direct superclasses

iterator (class)

Direct methods
Direct slots
Slot: buffer
Readers

buffer (generic function)

Writers

(setf buffer) (generic function)

Slot: close-stream
Initargs

:close-stream

Readers

close-stream (generic function)

Writers

(setf close-stream) (generic function)

Class: vector-iterator ()

Iterator for vectors.

Supports setting the current element.

See START
See ITERATOR

Package

for-iterator

Source

iterator.lisp (file)

Direct superclasses

iterator (class)

Direct subclasses

array-iterator (class)

Direct methods
Direct slots
Slot: start
Initargs

:start

Readers

start (generic function)

Writers

(setf start) (generic function)

Direct Default Initargs
InitargValue
:start0

Previous: , Up: Definitions   [Contents][Index]

5.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.1 Special variables

Special Variable: *bindings*
Package

for

Source

binding.lisp (file)

Special Variable: *clauses*
Package

for

Source

clause.lisp (file)

Special Variable: *environment*

This variable will be bound to the environment object during the expansion of the FOR macro.

Package

for

Source

for.lisp (file)

Special Variable: *unbound*
Package

for

Source

standard.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.2 Macros

Macro: define-direct-clause NAME ARGS &body BODY

Defines a clause function.

Clause functions can return three values:

1. A single "surrounding form" that will go around the resulting loop. If you require multiple surrounding forms, you can use WITH-INTERLEAVING.
2. A form to run during each iteration.
3. A form whose value is returned by the FOR.

The arguments that the function receives are directly translated from the respective clause expression.

Note that a clause function receives its arguments as literals and thus must process them like a macro would (destructive operations are bad juju).

Also note that unlike normal functions, the &environment lambda-list argument is available and its value will be passed on from the calling FOR macro.

See CLAUSE
See REMOVE-CLAUSE

Package

for

Source

clause.lisp (file)

Macro: define-simple-clause NAME ARGS &body BODY

Defines a simple clause.

&AUX variables in the args lambda-list receive special treatment: they are bound to gensyms within the definition body. Their value is only evaluated and set within the expanded clause. This means that AUX variables give you a convenient way to introduce necessary helper variables to the expanded clause. References to other &AUX are automatically rewritten to the appropriate gensym.

The primary value returned must be the form to be evaluated on each iteration. A secondary value may be returned, which is a form to be evaluated when the loop ends normally.

See DEFINE-DIRECT-CLAUSE

Package

for

Source

clause.lisp (file)

Macro: unwind-protect* CLEANUP &body BODY
Package

for

Source

toolkit.lisp (file)

Macro: values* &rest VALUES

The same idea as LIST* except for values.

Package

for

Source

toolkit.lisp (file)

Macro: with-for-block () &body BODY

Wraps the body in a looping block.

This establishes a NIL block.

See RETURN-FOR

Package

for

Source

for.lisp (file)

Macro: with-for-tagbody BODY &body EXIT

Wraps the body in a looping tagbody, running the EXIT forms when the loop ends.

See END-FOR
See SKIP-FOR

Package

for

Source

for.lisp (file)


Previous: , Up: Internal definitions   [Contents][Index]

5.2.3 Functions

Function: bindings-for-gens AUX GENS
Package

for

Source

binding.lisp (file)

Function: collect-for-values EXPRESSIONS FUNCTION
Package

for

Source

toolkit.lisp (file)

Function: compute-binding-parts VAR VARS ARGS
Package

for

Source

binding.lisp (file)

Function: compute-declaration-parts BODY INNER-LET
Package

for

Source

binding.lisp (file)

Function: convert-bindings BINDINGS

Translates the given binding expressions into their respective parts.

Each binding must be a list of the following structure:

BINDING ::= (PLACE binding-type argument*)
PLACE ::= variable | lambda-list
variable — A symbol naming a variable to bind the result of the binding to. lambda-list — If the binding result is a list, destructure it by this lambda- list, binding the respective symbols.
binding-type — The type of binding determines how the PLACE is initialised and how it changes each iteration.
argument — An argument to the binding. Depending on the binding it may be evaluated once or in every iteration.

If an unknown binding is referenced, an error is signalled.

Returns three values:
1. A list of all surrounding forms
2. A list of all body forms
3. A list of all value forms

See BINDING

Package

for

Source

binding.lisp (file)

Function: convert-clauses FORMS

Translates the given body forms into their respective parts.

If a body form is noticed that matches a clause –by virtue of being a list and the first item thereof being a symbol that translates to a clause name– then it is replaced by the form computed by the clause function.

Returns three values:
1. A list of all surrounding forms
2. A list of all body forms
3. A list of all value forms

See CLAUSE

Package

for

Source

clause.lisp (file)

Function: copy-list* LIST

Same as COPY-LIST, but also returning the last cons of the new list as a second value.

Package

for

Source

toolkit.lisp (file)

Function: delist A &optional KEY

If A is a list, return the element that KEY retrieves.

Package

for

Source

toolkit.lisp (file)

Function: emit-binding-definition NAME VAR ARGS BODY &key EXTRA-VARS SYMBOL-MACRO-P
Package

for

Source

binding.lisp (file)

Function: enlist A &rest ELS

If A is not a list, turn it into one with the given ELS as further items.

Package

for

Source

toolkit.lisp (file)

Function: normalize-declaration-inner INNER
Package

for

Source

binding.lisp (file)

Function: normalize-declarations BODY
Package

for

Source

binding.lisp (file)

Function: remove-bindings BINDINGS FORM
Package

for

Source

standard.lisp (file)

Function: replace-lambda-vars LAMBDA-LIST VARS NEW-VARS

Replaces all VARS in LAMBDA-LIST with the NEW-VAR at the same position.

Package

for

Source

toolkit.lisp (file)

Function: translate-form-vars FORM FROM TO
Package

for

Source

binding.lisp (file)


Previous: , Up: Top   [Contents][Index]

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts

Jump to:   F   L  
Index Entry  Section

F
File, Lisp, for.asd: The for<dot>asd file
File, Lisp, for/binding.lisp: The for/binding<dot>lisp file
File, Lisp, for/clause.lisp: The for/clause<dot>lisp file
File, Lisp, for/documentation.lisp: The for/documentation<dot>lisp file
File, Lisp, for/for.lisp: The for/for<dot>lisp file
File, Lisp, for/iterator.lisp: The for/iterator<dot>lisp file
File, Lisp, for/package.lisp: The for/package<dot>lisp file
File, Lisp, for/standard.lisp: The for/standard<dot>lisp file
File, Lisp, for/toolkit.lisp: The for/toolkit<dot>lisp file
for.asd: The for<dot>asd file
for/binding.lisp: The for/binding<dot>lisp file
for/clause.lisp: The for/clause<dot>lisp file
for/documentation.lisp: The for/documentation<dot>lisp file
for/for.lisp: The for/for<dot>lisp file
for/iterator.lisp: The for/iterator<dot>lisp file
for/package.lisp: The for/package<dot>lisp file
for/standard.lisp: The for/standard<dot>lisp file
for/toolkit.lisp: The for/toolkit<dot>lisp file

L
Lisp File, for.asd: The for<dot>asd file
Lisp File, for/binding.lisp: The for/binding<dot>lisp file
Lisp File, for/clause.lisp: The for/clause<dot>lisp file
Lisp File, for/documentation.lisp: The for/documentation<dot>lisp file
Lisp File, for/for.lisp: The for/for<dot>lisp file
Lisp File, for/iterator.lisp: The for/iterator<dot>lisp file
Lisp File, for/package.lisp: The for/package<dot>lisp file
Lisp File, for/standard.lisp: The for/standard<dot>lisp file
Lisp File, for/toolkit.lisp: The for/toolkit<dot>lisp file

Jump to:   F   L  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   (  
B   C   D   E   F   G   H   I   L   M   N   O   P   R   S   T   U   V   W  
Index Entry  Section

(
(setf binding): Exported functions
(setf buffer): Exported generic functions
(setf buffer): Exported generic functions
(setf buffer): Exported generic functions
(setf clause): Exported functions
(setf close-stream): Exported generic functions
(setf close-stream): Exported generic functions
(setf close-stream): Exported generic functions
(setf current): Exported generic functions
(setf current): Exported generic functions
(setf current): Exported generic functions
(setf current): Exported generic functions
(setf current): Exported generic functions
(setf current): Exported generic functions
(setf current): Exported generic functions
(setf current): Exported generic functions
(setf current): Exported generic functions
(setf index): Exported generic functions
(setf index): Exported generic functions
(setf limit): Exported generic functions
(setf limit): Exported generic functions
(setf object): Exported generic functions
(setf object): Exported generic functions
(setf prefetch): Exported generic functions
(setf prefetch): Exported generic functions
(setf prefetch): Exported generic functions
(setf start): Exported generic functions
(setf start): Exported generic functions
(setf total-length): Exported generic functions
(setf total-length): Exported generic functions

B
binding: Exported functions
bindings-for-gens: Internal functions
buffer: Exported generic functions
buffer: Exported generic functions
buffer: Exported generic functions

C
clause: Exported functions
close-stream: Exported generic functions
close-stream: Exported generic functions
close-stream: Exported generic functions
collect-for-values: Internal functions
compute-binding-parts: Internal functions
compute-declaration-parts: Internal functions
convert-bindings: Internal functions
convert-clauses: Internal functions
copy-list*: Internal functions
current: Exported generic functions
current: Exported generic functions

D
define-accumulation-binding: Exported macros
define-alias-binding: Exported macros
define-direct-binding: Exported macros
define-direct-clause: Internal macros
define-form-binding: Exported macros
define-form-symbol-macro-binding: Exported macros
define-simple-clause: Internal macros
define-value-binding: Exported macros
define-value-symbol-macro-binding: Exported macros
delist: Internal functions

E
emit-binding-definition: Internal functions
end: Exported generic functions
end: Exported generic functions
end: Exported generic functions
end: Exported generic functions
enlist: Internal functions

F
for: Exported macros
Function, (setf binding): Exported functions
Function, (setf clause): Exported functions
Function, binding: Exported functions
Function, bindings-for-gens: Internal functions
Function, clause: Exported functions
Function, collect-for-values: Internal functions
Function, compute-binding-parts: Internal functions
Function, compute-declaration-parts: Internal functions
Function, convert-bindings: Internal functions
Function, convert-clauses: Internal functions
Function, copy-list*: Internal functions
Function, delist: Internal functions
Function, emit-binding-definition: Internal functions
Function, enlist: Internal functions
Function, hash-table-iterator: Exported functions
Function, normalize-declaration-inner: Internal functions
Function, normalize-declarations: Internal functions
Function, package-iterator: Exported functions
Function, remove-binding: Exported functions
Function, remove-bindings: Internal functions
Function, remove-clause: Exported functions
Function, replace-lambda-vars: Internal functions
Function, translate-form-vars: Internal functions

G
Generic Function, (setf buffer): Exported generic functions
Generic Function, (setf close-stream): Exported generic functions
Generic Function, (setf current): Exported generic functions
Generic Function, (setf index): Exported generic functions
Generic Function, (setf limit): Exported generic functions
Generic Function, (setf object): Exported generic functions
Generic Function, (setf prefetch): Exported generic functions
Generic Function, (setf start): Exported generic functions
Generic Function, (setf total-length): Exported generic functions
Generic Function, buffer: Exported generic functions
Generic Function, close-stream: Exported generic functions
Generic Function, current: Exported generic functions
Generic Function, end: Exported generic functions
Generic Function, has-more: Exported generic functions
Generic Function, index: Exported generic functions
Generic Function, limit: Exported generic functions
Generic Function, make-iterator: Exported generic functions
Generic Function, next: Exported generic functions
Generic Function, object: Exported generic functions
Generic Function, prefetch: Exported generic functions
Generic Function, start: Exported generic functions
Generic Function, total-length: Exported generic functions

H
has-more: Exported generic functions
has-more: Exported generic functions
has-more: Exported generic functions
has-more: Exported generic functions
has-more: Exported generic functions
has-more: Exported generic functions
has-more: Exported generic functions
has-more: Exported generic functions
has-more: Exported generic functions
hash-table-iterator: Exported functions

I
index: Exported generic functions
index: Exported generic functions

L
limit: Exported generic functions
limit: Exported generic functions
limit: Exported generic functions

M
Macro, define-accumulation-binding: Exported macros
Macro, define-alias-binding: Exported macros
Macro, define-direct-binding: Exported macros
Macro, define-direct-clause: Internal macros
Macro, define-form-binding: Exported macros
Macro, define-form-symbol-macro-binding: Exported macros
Macro, define-simple-clause: Internal macros
Macro, define-value-binding: Exported macros
Macro, define-value-symbol-macro-binding: Exported macros
Macro, for: Exported macros
Macro, unwind-protect*: Internal macros
Macro, update: Exported macros
Macro, values*: Internal macros
Macro, with-for-block: Internal macros
Macro, with-for-tagbody: Internal macros
Macro, with-interleaving: Exported macros
make-iterator: Exported generic functions
make-iterator: Exported generic functions
make-iterator: Exported generic functions
make-iterator: Exported generic functions
make-iterator: Exported generic functions
make-iterator: Exported generic functions
make-iterator: Exported generic functions
make-iterator: Exported generic functions
make-iterator: Exported generic functions
Method, (setf buffer): Exported generic functions
Method, (setf buffer): Exported generic functions
Method, (setf close-stream): Exported generic functions
Method, (setf close-stream): Exported generic functions
Method, (setf current): Exported generic functions
Method, (setf current): Exported generic functions
Method, (setf current): Exported generic functions
Method, (setf current): Exported generic functions
Method, (setf current): Exported generic functions
Method, (setf current): Exported generic functions
Method, (setf current): Exported generic functions
Method, (setf current): Exported generic functions
Method, (setf index): Exported generic functions
Method, (setf limit): Exported generic functions
Method, (setf object): Exported generic functions
Method, (setf prefetch): Exported generic functions
Method, (setf prefetch): Exported generic functions
Method, (setf start): Exported generic functions
Method, (setf total-length): Exported generic functions
Method, buffer: Exported generic functions
Method, buffer: Exported generic functions
Method, close-stream: Exported generic functions
Method, close-stream: Exported generic functions
Method, current: Exported generic functions
Method, end: Exported generic functions
Method, end: Exported generic functions
Method, end: Exported generic functions
Method, has-more: Exported generic functions
Method, has-more: Exported generic functions
Method, has-more: Exported generic functions
Method, has-more: Exported generic functions
Method, has-more: Exported generic functions
Method, has-more: Exported generic functions
Method, has-more: Exported generic functions
Method, has-more: Exported generic functions
Method, index: Exported generic functions
Method, limit: Exported generic functions
Method, limit: Exported generic functions
Method, make-iterator: Exported generic functions
Method, make-iterator: Exported generic functions
Method, make-iterator: Exported generic functions
Method, make-iterator: Exported generic functions
Method, make-iterator: Exported generic functions
Method, make-iterator: Exported generic functions
Method, make-iterator: Exported generic functions
Method, make-iterator: Exported generic functions
Method, next: Exported generic functions
Method, next: Exported generic functions
Method, next: Exported generic functions
Method, next: Exported generic functions
Method, next: Exported generic functions
Method, next: Exported generic functions
Method, next: Exported generic functions
Method, next: Exported generic functions
Method, next: Exported generic functions
Method, object: Exported generic functions
Method, prefetch: Exported generic functions
Method, prefetch: Exported generic functions
Method, start: Exported generic functions
Method, total-length: Exported generic functions

N
next: Exported generic functions
next: Exported generic functions
next: Exported generic functions
next: Exported generic functions
next: Exported generic functions
next: Exported generic functions
next: Exported generic functions
next: Exported generic functions
next: Exported generic functions
next: Exported generic functions
normalize-declaration-inner: Internal functions
normalize-declarations: Internal functions

O
object: Exported generic functions
object: Exported generic functions

P
package-iterator: Exported functions
prefetch: Exported generic functions
prefetch: Exported generic functions
prefetch: Exported generic functions

R
remove-binding: Exported functions
remove-bindings: Internal functions
remove-clause: Exported functions
replace-lambda-vars: Internal functions

S
start: Exported generic functions
start: Exported generic functions

T
total-length: Exported generic functions
total-length: Exported generic functions
translate-form-vars: Internal functions

U
unwind-protect*: Internal macros
update: Exported macros

V
values*: Internal macros

W
with-for-block: Internal macros
with-for-tagbody: Internal macros
with-interleaving: Exported macros

Jump to:   (  
B   C   D   E   F   G   H   I   L   M   N   O   P   R   S   T   U   V   W  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   *  
B   C   I   L   O   P   S   T  
Index Entry  Section

*
*bindings*: Internal special variables
*clauses*: Internal special variables
*environment*: Internal special variables
*unbound*: Internal special variables

B
buffer: Exported classes
buffer: Exported classes

C
close-stream: Exported classes
close-stream: Exported classes
current: Exported classes

I
index: Exported classes

L
limit: Exported classes
limit: Exported classes

O
object: Exported classes

P
prefetch: Exported classes
prefetch: Exported classes

S
Slot, buffer: Exported classes
Slot, buffer: Exported classes
Slot, close-stream: Exported classes
Slot, close-stream: Exported classes
Slot, current: Exported classes
Slot, index: Exported classes
Slot, limit: Exported classes
Slot, limit: Exported classes
Slot, object: Exported classes
Slot, prefetch: Exported classes
Slot, prefetch: Exported classes
Slot, start: Exported classes
Slot, total-length: Exported classes
Special Variable, *bindings*: Internal special variables
Special Variable, *clauses*: Internal special variables
Special Variable, *environment*: Internal special variables
Special Variable, *unbound*: Internal special variables
start: Exported classes

T
total-length: Exported classes

Jump to:   *  
B   C   I   L   O   P   S   T  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   A   C   D   F   H   I   L   P   R   S   V  
Index Entry  Section

A
array-iterator: Exported classes

C
Class, array-iterator: Exported classes
Class, directory-iterator: Exported classes
Class, hash-table-iterator: Exported classes
Class, iterator: Exported classes
Class, list-iterator: Exported classes
Class, package-iterator: Exported classes
Class, random-iterator: Exported classes
Class, stream-iterator: Exported classes
Class, stream-line-iterator: Exported classes
Class, vector-iterator: Exported classes

D
directory-iterator: Exported classes

F
for: The for system
for: The for package
for-iterator: The for-iterator package
for-minimal: The for-minimal package

H
hash-table-iterator: Exported classes

I
iterator: Exported classes

L
list-iterator: Exported classes

P
Package, for: The for package
Package, for-iterator: The for-iterator package
Package, for-minimal: The for-minimal package
package-iterator: Exported classes

R
random-iterator: Exported classes

S
stream-iterator: Exported classes
stream-line-iterator: Exported classes
System, for: The for system

V
vector-iterator: Exported classes

Jump to:   A   C   D   F   H   I   L   P   R   S   V