The clazy Reference Manual

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

The clazy Reference Manual

This is the clazy Reference Manual, generated automatically by Declt version 4.0 beta 2 "William Riker" on Mon Aug 15 04:12:05 2022 GMT+0.

Table of Contents


1 Introduction

CLAZY
=====

This is the CLAZY package, a library that introduces lazy calling in
Common Lisp.

In order to load in your environment you can use either the .asd or
the .system file that come with the distribution.

Documentation in HTML is in the 'docs/html' subfolder.

The library is relased under the terms contained in the COPYING file.

A NOTE ON FORKING
-----------------

Of course you are free to fork the project subject to the current
licensing scheme.  However, before you do so, I ask you to consider
plain old "cooperation" by asking me to become a developer.
It helps keeping the entropy level at an acceptable level.


Enjoy

Marco Antoniotti, Milan, Italy, (c) 2008-2022



2 Systems

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


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

2.1 clazy

The CLAZY System.

Author

Marco Antoniotti

Long Description

The CLAZY System.

The CLAZY system (as in ’I must be CLAZY!’) contains a set of definitions useful for introducing lazy evaluation via lazy calls in Common Lisp; i.e., CLAZY turns parts of Common Lisp into a non-strict functional language.

Source

clazy.asd.

Child Components

Next: , Previous: , Up: The clazy Reference Manual   [Contents][Index]

3 Modules

Modules are listed depth-first from the system components tree.


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

3.1 clazy/impl-dependent

Dependency

clazy-package.lisp (file).

Source

clazy.asd.

Parent Component

clazy (system).

Child Component

sbcl.lisp (file).


4 Files

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


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

4.1 Lisp


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

4.1.1 clazy/clazy.asd

Source

clazy.asd.

Parent Component

clazy (system).

ASDF Systems

clazy.


4.1.2 clazy/clazy-package.lisp

Source

clazy.asd.

Parent Component

clazy (system).

Packages

it.unimib.disco.lazy.


4.1.3 clazy/lambda-list-parsing.lisp

Dependency

clazy-package.lisp (file).

Source

clazy.asd.

Parent Component

clazy (system).

Internals

parse-ordinary-lambda-list (function).


4.1.4 clazy/clazy.lisp

Dependencies
Source

clazy.asd.

Parent Component

clazy (system).

Public Interface
Internals

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

4.1.5 clazy/impl-dependent/sbcl.lisp

Source

clazy.asd.

Parent Component

impl-dependent (module).

Internals

arglist (function).


4.1.6 clazy/library.lisp

Dependency

clazy.lisp (file).

Source

clazy.asd.

Parent Component

clazy (system).

Public Interface
Internals

4.1.7 clazy/seq-funs-package.lisp

Dependencies
Source

clazy.asd.

Parent Component

clazy (system).

Packages

it.unimib.disco.ma.cl.ext.sequences.lazy.


4.1.8 clazy/seq-funs.lisp

Dependency

seq-funs-package.lisp (file).

Source

clazy.asd.

Parent Component

clazy (system).

Public Interface
Internals

5 Packages

Packages are listed by definition order.


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

5.1 it.unimib.disco.ma.cl.ext.sequences.lazy

Source

seq-funs-package.lisp.

Nicknames
  • lazy-seq-utils
  • lazy-seqs
  • lazy-sequences
  • cl.ext.sequences.lazy
  • cl.extensions.sequences.lazy
Use List
Public Interface
Internals

5.2 it.unimib.disco.lazy

The Common Lisp Extensions Lazy Evaluation Package.

Source

clazy-package.lisp.

Nicknames
  • clazy
  • cl.ext.dacf.lazy
  • cl.extensions.data-and-control-flow.lazy
  • lazy
Use List

common-lisp.

Used By List

it.unimib.disco.ma.cl.ext.sequences.lazy.

Public Interface
Internals

6 Definitions

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


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

6.1 Public Interface


6.1.1 Macros

Macro: call (f &rest args)

The LAZY:CALL macro generalizes FUNCALL in order to handle lazy functions.

The LAZY:CALL macro introduces lazy evaluation in Common Lisp. The LAZY:CALL form ensures that, if possible, a lazy version of the function F is called, in which case all the arguments are automatically ‘thunked’. If no lazy version of F can be retrieved then F is FUNCALLed in the normal, strict, way with no ‘thunking’ of the arguments.

Package

it.unimib.disco.lazy.

Source

clazy.lisp.

Macro: cons-stream (head tail)

Constructs a LAZY-STREAM, DELAYing the TAIL argument.

Package

it.unimib.disco.lazy.

Source

library.lisp.

Macro: def-lazy-function (name args &body body)

Defines a lazy function.

The function assumes that each argument is passed as a ‘thunk’, which gets FORCEd as needed.

Package

it.unimib.disco.lazy.

Source

clazy.lisp.

Macro: deflazy (name args &body body)

Defines a function while ensuring that a lazy version exists as well.

Package

it.unimib.disco.lazy.

Source

clazy.lisp.

Macro: delay (expression)

Delays an EXPRESSION by wrapping it in a ‘thunk’ (i.e. a closure).

Package

it.unimib.disco.lazy.

Source

clazy.lisp.

Macro: lazily (&body body)

Ensures that lazy functions are called lazily with LAZY:CALL.

The macro code-walks BODY and whenever it finds an application that has a lazily defined operator, then it rewrites such application with LAZY:CALL.

Package

it.unimib.disco.lazy.

Source

library.lisp.

Macro: lazy (function-spec &optional errorp)

Transforms a function into a lazy equivalent.

The LAZY macro is akin to the FUNCTION special operator.
The function specified in FUNCTION-SPEC can be a symbol, a lambda expression or a FUNCTION special form. The macro operates at the syntactic level. The result is a function which may evaluate its arguments in a lazy way. This is achieved by ensuring that each argument is automatically interpreted as a ’thunk’.

If FUNCTION-SPEC is a symbol which names a lazy function (cfr. LAZY-FUNCTION-NAME-P) then this is the result; if FUNCTION-SPEC is a lambda expression then it is ‘lazyfied’. The same happens if FUNCTION-SPEC is of the form (FUNCTION (LAMBDA ...)). If FUNCTION-SPEC is of the form (FUNCTION <symbol>), then LAZY falls back to the first case. In every other case, LAZY may yield a ‘regular’ function.

If ERRORP is non-NIL, an error of type INVALID-LAZY-ARGUMENT is generated if there is no way to associate FUNCTION-SPEC to a function; otherwise NIL is returned.

Package

it.unimib.disco.lazy.

Source

clazy.lisp.

Macro: let/lazy (bindings &body body)

The macro operates like LET, but is delays the evaluation of the bindings.

Package

it.unimib.disco.lazy.

Source

clazy.lisp.

Macro: make-thunk (expr)

Expands into code that creates a thunk wrapping around EXPR.

Package

it.unimib.disco.lazy.

Source

clazy.lisp.

Macro: slacking (&body body)
Package

it.unimib.disco.lazy.

Source

library.lisp.


6.1.2 Ordinary functions

Function: copy-lazy-stream (instance)
Package

it.unimib.disco.lazy.

Source

library.lisp.

Function: distinct (seq &rest keys &key test key distincts-table &allow-other-keys)

Returns a generalized sequence of distinct elements.

If SEQ is a SEQUENCE then REMOVE-DUPLICATES is called. If it is a LAZY-STREAM then a new LAZY-STREAM is returned, with repeated elements removed. Key arguments are only TEST and KEY.

Arguments and Values:

SEQ : a (OR NULL SEQUENCE LAZY-STREAM)
TEST : a (FUNCTION (T T) <generalized boolean>)
KEY : a (FUNCTION (T) T)
DISTINCTS-TABLE : a HASH-TABLE
KEYS : a LIST (actually a p-list of the keywords arguments)
result : a (OR NULL SEQUENCE LAZY-STREAM)

Package

it.unimib.disco.ma.cl.ext.sequences.lazy.

Source

seq-funs.lisp.

Function: diverge ()

A function that never returns.

It is equivalent to (LOOP). It should not be called striclty: called striclty: it will never terminate.

Package

it.unimib.disco.lazy.

Source

library.lisp.

Function: drop (n seq)

Drops the first N elements of the sequence SEQ.

The result is a fresh sequence of the last (- (length SEQ) N) elements. SEQ can be a SEQUENCE or a LAZY-STREAM. The type of the result is the same as the type of SEQ if this is a SEQUENCE, otherwise it is a LAZY-STREAM or NIL (if dropping more items than the - finite - length of the LAZY-STREAM).

Package

it.unimib.disco.ma.cl.ext.sequences.lazy.

Source

seq-funs.lisp.

Function: drop-while (p seq)

Drops the first elements of the sequence SEQ that satisfy the predicate P.

Package

it.unimib.disco.ma.cl.ext.sequences.lazy.

Source

seq-funs.lisp.

Function: force (thunk)

Forces the evaluation of a THUNK.

If THUNK is a regular value it is returned as is.

Package

it.unimib.disco.lazy.

Source

clazy.lisp.

Function: head (s)

Returns the first element of a SEQUENCE or a LAZY-STREAM.

Package

it.unimib.disco.lazy.

Source

library.lisp.

Function: lazy-cons-p (object)
Package

it.unimib.disco.lazy.

Source

library.lisp.

Reader: lazy-lambda-arglist (instance)
Package

it.unimib.disco.lazy.

Source

clazy.lisp.

Target Slot

arglist.

Reader: lazy-lambda-code (instance)
Package

it.unimib.disco.lazy.

Source

clazy.lisp.

Target Slot

code.

Function: lazy-lambda-p (object)
Package

it.unimib.disco.lazy.

Source

clazy.lisp.

Function: lazy-stream-p (object)
Package

it.unimib.disco.lazy.

Source

library.lisp.

Function: repeatedly (fn &rest args)

Returns a lazy list containing repeated applications of FN to ARGS.

Package

it.unimib.disco.lazy.

Source

library.lisp.

Function: separate (p seq)
Package

it.unimib.disco.ma.cl.ext.sequences.lazy.

Source

seq-funs.lisp.

Function: span (p seq)
Package

it.unimib.disco.ma.cl.ext.sequences.lazy.

Source

seq-funs.lisp.

Function: split-at (n seq)

Returns two subsequences of SEQ split at the N-th element.

Package

it.unimib.disco.ma.cl.ext.sequences.lazy.

Source

seq-funs.lisp.

Function: tail (s)

Returns the rest of a LIST or LAZY-STREAM.

Package

it.unimib.disco.lazy.

Source

library.lisp.

Function: tails (seq)
Package

it.unimib.disco.ma.cl.ext.sequences.lazy.

Source

seq-funs.lisp.

Function: take (n seq)

Takes the first N elements of the sequence SEQ.

The result is a fresh sequence of the first N elements. SEQ can be a SEQUENCE or a LAZY-STREAM. The type of the result is the same as the type of SEQ if this is a SEQUENCE, otherwise it is a LIST.

Package

it.unimib.disco.ma.cl.ext.sequences.lazy.

Source

seq-funs.lisp.

Function: take-while (p seq)

Takes the first elements of the sequence SEQ that satisfy the predicate P.

SEQ can be a SEQUENCE or a LAZY-STREAM. The type of the result is the same as the type of SEQ if this is a SEQUENCE, otherwise it is a
LIST.

Package

it.unimib.disco.ma.cl.ext.sequences.lazy.

Source

seq-funs.lisp.

Reader: thunk-code (instance)
Package

it.unimib.disco.lazy.

Source

clazy.lisp.

Target Slot

code.

Function: thunk-p (object)
Package

it.unimib.disco.lazy.

Source

clazy.lisp.


6.1.3 Standalone methods

Method: initialize-instance :after ((ulf undefined-lazy-function) &key name &allow-other-keys)
Source

clazy.lisp.

Method: print-object ((ls lazy-stream) s)
Source

library.lisp.

Method: print-object ((ll lazy-lambda) s)

Special method for printing Lazy Lambda objects.

The printing uses the ’TAU-LAMBDA’ as a prefix, since in Greek ’lazy’ is ’tempelis’; hence the ’tau’ prefix.

Source

clazy.lisp.

Method: print-object ((ls lazy-cons) s)
Source

library.lisp.

Method: print-object ((th thunk) s)
Source

clazy.lisp.


6.1.4 Conditions

Condition: invalid-lazy-argument

The Invalid Lazy Argument Condition.

This condition is signalled by LAZY operator when it cannot get hold of a lazy version of the argument.

Package

it.unimib.disco.lazy.

Source

clazy.lisp.

Direct superclasses

type-error.

Condition: undefined-lazy-function

The Undefined Lazy Function Condition.

A simple subclass of the UNDEFINED-FUNCTION condition. This is signalled by the LAZY operator and the LAZY:CALL macro when trying to access an undefined lazy function. This may happen also when a function has a strict definition but no lazy counterpart.

Package

it.unimib.disco.lazy.

Source

clazy.lisp.

Direct superclasses

undefined-function.

Direct subclasses

undefined-lazy-lambda.

Direct methods
Direct slots
Slot: lazy-version-name
Readers

undefined-lazy-function-name.

Writers

This slot is read-only.


Next: , Previous: , Up: Public Interface   [Contents][Index]

6.1.5 Structures

Structure: lazy-cons

The Lazy Cons Structure.

The LAZY-CONS structure has both head and tail lazy. It includes LAZY-STREAM.

Package

it.unimib.disco.lazy.

Source

library.lisp.

Direct superclasses

lazy-stream.

Direct methods

print-object.

Structure: lazy-lambda

The Lazy Lambda Structure.

This structure is a wrapper around a LAMBDA representing the actual lazy code. Its main use is as a ‘type’ used in discrimination. The slot CODE contains the actual lazy code, while the slot ARGLIST containes the LAMBDA argilist.

The slots are read only. No ‘copier’ is defined. The instances are ‘immutable’.

The constuctor is defined as MAKE-LAZY-LAMBDA (&optional CODE ARGLIST) with appropriate defaults. The other usual functions automatically generated by DEFSTRUCT work as expected.

Package

it.unimib.disco.lazy.

Source

clazy.lisp.

Direct superclasses

structure-object.

Direct methods

print-object.

Direct slots
Slot: code
Type

function

Initform

(lambda (&rest it.unimib.disco.lazy::args) (declare (ignore it.unimib.disco.lazy::args)) (error (quote it.unimib.disco.lazy::undefined-lazy-lambda)))

Readers

lazy-lambda-code.

Writers

This slot is read-only.

Slot: arglist
Type

list

Initform

(quote (&rest it.unimib.disco.lazy::args))

Readers

lazy-lambda-arglist.

Writers

This slot is read-only.

Structure: lazy-stream

The Lazy Stream Structure.

The traditional implementation of SICP-like streams. The LAZY-STREAM structure has a strict head and a lazy tail.

Package

it.unimib.disco.lazy.

Source

library.lisp.

Direct superclasses

structure-object.

Direct subclasses

lazy-cons.

Direct methods

print-object.

Direct slots
Slot: head
Readers

lazy-stream-head.

Writers

This slot is read-only.

Slot: tail
Readers

lazy-stream-tail.

Writers

This slot is read-only.

Structure: thunk

The Thunk Structure.

A wrapper for code fragments that will be evaluated after a delay. Thunks can be created either directly by the macro MAKE-THUNK or by the macro DELAY.

Package

it.unimib.disco.lazy.

Source

clazy.lisp.

Direct superclasses

structure-object.

Direct methods

print-object.

Direct slots
Slot: code
Type

function

Initform

(constantly nil)

Readers

thunk-code.

Writers

This slot is read-only.

Slot: form
Readers

thunk-form.

Writers

This slot is read-only.

Slot: type
Package

common-lisp.

Initform

t

Readers

thunk-type.

Writers

This slot is read-only.


Previous: , Up: Public Interface   [Contents][Index]

6.1.6 Types

Type: list-index ()

The type of the indices inside a list.

Although not necessarily right for lists, the upper bound is set to MOST-POSITIVE-FIXNUM.

Package

it.unimib.disco.ma.cl.ext.sequences.lazy.

Source

seq-funs.lisp.

Type: seq-index ()

The type of the indices inside a sequence.

Although not necessarily right for lists, the upper bound is set to ARRAY-DIMENSION-LIMIT.

Package

it.unimib.disco.ma.cl.ext.sequences.lazy.

Source

seq-funs.lisp.


6.2 Internals


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

6.2.1 Special variables

Special Variable: *break-if-non-lazy-call-p*

If non-NIL the LAZY:CALL macro breaks when it resolves in a strict call.

Package

it.unimib.disco.lazy.

Source

clazy.lisp.

Special Variable: *warn-if-non-lazy-call-p*

If non-NIL the LAZY:CALL macro generates a warning when it resolves in a strict call.

Package

it.unimib.disco.lazy.

Source

clazy.lisp.


6.2.2 Macros

Macro: tau-lambda (arglist &body body)

Creates a LAZY-LAMBDA.

This macro is the syntactic equivalent of the LAMBDA macro for LAZY-LAMBDAs. The name comes from the Greek ’tempelis’, which means ’lazy’; hence the ’tau’ prefix.

Package

it.unimib.disco.lazy.

Source

clazy.lisp.


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

6.2.3 Ordinary functions

Function: %cons-lazy-cons (head &optional tail)
Package

it.unimib.disco.lazy.

Source

library.lisp.

Function: %cons-lazy-stream (head &optional tail)
Package

it.unimib.disco.lazy.

Source

library.lisp.

Function: %make-thunk% (form code)
Package

it.unimib.disco.lazy.

Source

clazy.lisp.

Function: arglist (function-designator)
Package

it.unimib.disco.lazy.

Source

sbcl.lisp.

Function: copy-lazy-cons (instance)
Package

it.unimib.disco.lazy.

Source

library.lisp.

Function: create-thunk-call-expansion (arg-name arg-thunk-name)
Package

it.unimib.disco.lazy.

Source

clazy.lisp.

Function: create-var-thunk-call-expansion (var-name-thunk)
Package

it.unimib.disco.lazy.

Source

clazy.lisp.

Function: get-lazy-version (f &optional errorp)

Retrieves the lazy version of a function named F.

If the lazy version does not exist and ERRORP is non-NIL an error of type UNDEFINED-LAZY-FUNCTION is signalled.

Package

it.unimib.disco.lazy.

Source

clazy.lisp.

Function: (setf get-lazy-version) (name)
Package

it.unimib.disco.lazy.

Source

clazy.lisp.

Function: lambda-expression-p (f)
Package

it.unimib.disco.lazy.

Source

clazy.lisp.

Function: lazy-cons-head (instance)
Package

it.unimib.disco.lazy.

Source

library.lisp.

Function: lazy-cons-tail (instance)
Package

it.unimib.disco.lazy.

Source

library.lisp.

Function: lazy-function-name-p (s)

Checks if the symbol S names a lazy function.

Package

it.unimib.disco.lazy.

Source

clazy.lisp.

Function: lazy-name (s)

Creates a symbol suitable for naming a lazy function.

Package

it.unimib.disco.lazy.

Source

clazy.lisp.

Reader: lazy-stream-head (instance)
Package

it.unimib.disco.lazy.

Source

library.lisp.

Target Slot

head.

Reader: lazy-stream-tail (instance)
Package

it.unimib.disco.lazy.

Source

library.lisp.

Target Slot

tail.

Function: make-lazy-lambda (&optional code arglist)
Package

it.unimib.disco.lazy.

Source

clazy.lisp.

Function: make-thunk-setup-code (arg &optional thunks-env)

Creates the actual code that sets up a thunk.

The thunk is actually a closure wrapping around two variables maintaining the thunk memoization state.

Package

it.unimib.disco.lazy.

Source

clazy.lisp.

Function: parse-ordinary-lambda-list (lambda-list)

Parses a lambda list and returns each group of arguments as a separate value.

Package

it.unimib.disco.lazy.

Source

lambda-list-parsing.lisp.

Function: rename-lambda-vars (arglist)

Traverses a (ordinary) lambda-list, making each argument ready for lazy evaluation.

The function returns a (ordinary) lambda list with each argument
appropriately renamed and ready to be thunked. It also returns a list
of argument names and an a-list of argument name versus renamed
argument.

Default parameters are treated correctly and thunked in the process;
keyword arguments are treated similarly, both in regular and in ‘extra
keyword’ form. &rest arguments are left untouched.

Package

it.unimib.disco.lazy.

Source

clazy.lisp.

Function: take-nth (n seq)
Package

it.unimib.disco.ma.cl.ext.sequences.lazy.

Source

seq-funs.lisp.

Reader: thunk-form (instance)
Package

it.unimib.disco.lazy.

Source

clazy.lisp.

Target Slot

form.

Reader: thunk-type (instance)
Package

it.unimib.disco.lazy.

Source

clazy.lisp.

Target Slot

type.

Function: zip (cons-fun seq1 seq2 &rest seqs)
Package

it.unimib.disco.ma.cl.ext.sequences.lazy.

Source

seq-funs.lisp.


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

6.2.4 Generic functions

Generic Reader: undefined-lazy-function-name (condition)
Package

it.unimib.disco.lazy.

Methods
Reader Method: undefined-lazy-function-name ((condition undefined-lazy-function))
Source

clazy.lisp.

Target Slot

lazy-version-name.


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

6.2.5 Conditions

Condition: undefined-lazy-lambda
Package

it.unimib.disco.lazy.

Source

clazy.lisp.

Direct superclasses

undefined-lazy-function.


Appendix A Indexes


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

A.1 Concepts


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

A.2 Functions

Jump to:   %   (  
A   C   D   F   G   H   I   L   M   P   R   S   T   U   Z  
Index Entry  Section

%
%cons-lazy-cons: Private ordinary functions
%cons-lazy-stream: Private ordinary functions
%make-thunk%: Private ordinary functions

(
(setf get-lazy-version): Private ordinary functions

A
arglist: Private ordinary functions

C
call: Public macros
cons-stream: Public macros
copy-lazy-cons: Private ordinary functions
copy-lazy-stream: Public ordinary functions
create-thunk-call-expansion: Private ordinary functions
create-var-thunk-call-expansion: Private ordinary functions

D
def-lazy-function: Public macros
deflazy: Public macros
delay: Public macros
distinct: Public ordinary functions
diverge: Public ordinary functions
drop: Public ordinary functions
drop-while: Public ordinary functions

F
force: Public ordinary functions
Function, %cons-lazy-cons: Private ordinary functions
Function, %cons-lazy-stream: Private ordinary functions
Function, %make-thunk%: Private ordinary functions
Function, (setf get-lazy-version): Private ordinary functions
Function, arglist: Private ordinary functions
Function, copy-lazy-cons: Private ordinary functions
Function, copy-lazy-stream: Public ordinary functions
Function, create-thunk-call-expansion: Private ordinary functions
Function, create-var-thunk-call-expansion: Private ordinary functions
Function, distinct: Public ordinary functions
Function, diverge: Public ordinary functions
Function, drop: Public ordinary functions
Function, drop-while: Public ordinary functions
Function, force: Public ordinary functions
Function, get-lazy-version: Private ordinary functions
Function, head: Public ordinary functions
Function, lambda-expression-p: Private ordinary functions
Function, lazy-cons-head: Private ordinary functions
Function, lazy-cons-p: Public ordinary functions
Function, lazy-cons-tail: Private ordinary functions
Function, lazy-function-name-p: Private ordinary functions
Function, lazy-lambda-arglist: Public ordinary functions
Function, lazy-lambda-code: Public ordinary functions
Function, lazy-lambda-p: Public ordinary functions
Function, lazy-name: Private ordinary functions
Function, lazy-stream-head: Private ordinary functions
Function, lazy-stream-p: Public ordinary functions
Function, lazy-stream-tail: Private ordinary functions
Function, make-lazy-lambda: Private ordinary functions
Function, make-thunk-setup-code: Private ordinary functions
Function, parse-ordinary-lambda-list: Private ordinary functions
Function, rename-lambda-vars: Private ordinary functions
Function, repeatedly: Public ordinary functions
Function, separate: Public ordinary functions
Function, span: Public ordinary functions
Function, split-at: Public ordinary functions
Function, tail: Public ordinary functions
Function, tails: Public ordinary functions
Function, take: Public ordinary functions
Function, take-nth: Private ordinary functions
Function, take-while: Public ordinary functions
Function, thunk-code: Public ordinary functions
Function, thunk-form: Private ordinary functions
Function, thunk-p: Public ordinary functions
Function, thunk-type: Private ordinary functions
Function, zip: Private ordinary functions

G
Generic Function, undefined-lazy-function-name: Private generic functions
get-lazy-version: Private ordinary functions

H
head: Public ordinary functions

I
initialize-instance: Public standalone methods

L
lambda-expression-p: Private ordinary functions
lazily: Public macros
lazy: Public macros
lazy-cons-head: Private ordinary functions
lazy-cons-p: Public ordinary functions
lazy-cons-tail: Private ordinary functions
lazy-function-name-p: Private ordinary functions
lazy-lambda-arglist: Public ordinary functions
lazy-lambda-code: Public ordinary functions
lazy-lambda-p: Public ordinary functions
lazy-name: Private ordinary functions
lazy-stream-head: Private ordinary functions
lazy-stream-p: Public ordinary functions
lazy-stream-tail: Private ordinary functions
let/lazy: Public macros

M
Macro, call: Public macros
Macro, cons-stream: Public macros
Macro, def-lazy-function: Public macros
Macro, deflazy: Public macros
Macro, delay: Public macros
Macro, lazily: Public macros
Macro, lazy: Public macros
Macro, let/lazy: Public macros
Macro, make-thunk: Public macros
Macro, slacking: Public macros
Macro, tau-lambda: Private macros
make-lazy-lambda: Private ordinary functions
make-thunk: Public macros
make-thunk-setup-code: Private ordinary functions
Method, initialize-instance: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, undefined-lazy-function-name: Private generic functions

P
parse-ordinary-lambda-list: Private ordinary functions
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods

R
rename-lambda-vars: Private ordinary functions
repeatedly: Public ordinary functions

S
separate: Public ordinary functions
slacking: Public macros
span: Public ordinary functions
split-at: Public ordinary functions

T
tail: Public ordinary functions
tails: Public ordinary functions
take: Public ordinary functions
take-nth: Private ordinary functions
take-while: Public ordinary functions
tau-lambda: Private macros
thunk-code: Public ordinary functions
thunk-form: Private ordinary functions
thunk-p: Public ordinary functions
thunk-type: Private ordinary functions

U
undefined-lazy-function-name: Private generic functions
undefined-lazy-function-name: Private generic functions

Z
zip: Private ordinary functions

Jump to:   %   (  
A   C   D   F   G   H   I   L   M   P   R   S   T   U   Z  

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

A.4 Data types

Jump to:   C   F   I   L   M   P   S   T   U  
Index Entry  Section

C
clazy: The clazy system
clazy-package.lisp: The clazy/clazy-package․lisp file
clazy.asd: The clazy/clazy․asd file
clazy.lisp: The clazy/clazy․lisp file
Condition, invalid-lazy-argument: Public conditions
Condition, undefined-lazy-function: Public conditions
Condition, undefined-lazy-lambda: Private conditions

F
File, clazy-package.lisp: The clazy/clazy-package․lisp file
File, clazy.asd: The clazy/clazy․asd file
File, clazy.lisp: The clazy/clazy․lisp file
File, lambda-list-parsing.lisp: The clazy/lambda-list-parsing․lisp file
File, library.lisp: The clazy/library․lisp file
File, sbcl.lisp: The clazy/impl-dependent/sbcl․lisp file
File, seq-funs-package.lisp: The clazy/seq-funs-package․lisp file
File, seq-funs.lisp: The clazy/seq-funs․lisp file

I
impl-dependent: The clazy/impl-dependent module
invalid-lazy-argument: Public conditions
it.unimib.disco.lazy: The it․unimib․disco․lazy package
it.unimib.disco.ma.cl.ext.sequences.lazy: The it․unimib․disco․ma․cl․ext․sequences․lazy package

L
lambda-list-parsing.lisp: The clazy/lambda-list-parsing․lisp file
lazy-cons: Public structures
lazy-lambda: Public structures
lazy-stream: Public structures
library.lisp: The clazy/library․lisp file
list-index: Public types

M
Module, impl-dependent: The clazy/impl-dependent module

P
Package, it.unimib.disco.lazy: The it․unimib․disco․lazy package
Package, it.unimib.disco.ma.cl.ext.sequences.lazy: The it․unimib․disco․ma․cl․ext․sequences․lazy package

S
sbcl.lisp: The clazy/impl-dependent/sbcl․lisp file
seq-funs-package.lisp: The clazy/seq-funs-package․lisp file
seq-funs.lisp: The clazy/seq-funs․lisp file
seq-index: Public types
Structure, lazy-cons: Public structures
Structure, lazy-lambda: Public structures
Structure, lazy-stream: Public structures
Structure, thunk: Public structures
System, clazy: The clazy system

T
thunk: Public structures
Type, list-index: Public types
Type, seq-index: Public types

U
undefined-lazy-function: Public conditions
undefined-lazy-lambda: Private conditions

Jump to:   C   F   I   L   M   P   S   T   U