The clazy Reference Manual

Table of Contents

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

The clazy Reference Manual

This is the clazy Reference Manual, generated automatically by Declt version 2.4 "Will Decker" on Wed Jun 20 11:29:33 2018 GMT+0.


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

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-2018


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 clazy

Author

Marco Antoniotti

Description

The CLAZY System.

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 (file)

Components

Next: , Previous: , Up: Top   [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)

Parent

clazy (system)

Location

impl-dependent/

Component

sbcl.lisp (file)


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

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 files   [Contents][Index]

4.1.1 clazy.asd

Location

clazy.asd

Systems

clazy (system)


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

4.1.2 clazy/clazy-package.lisp

Parent

clazy (system)

Location

clazy-package.lisp

Packages

it.unimib.disco.lazy


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

4.1.3 clazy/lambda-list-parsing.lisp

Dependency

clazy-package.lisp (file)

Parent

clazy (system)

Location

lambda-list-parsing.lisp

Internal Definitions

parse-ordinary-lambda-list (function)


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

4.1.4 clazy/clazy.lisp

Dependencies
Parent

clazy (system)

Location

clazy.lisp

Exported Definitions
Internal Definitions

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

4.1.5 clazy/impl-dependent/sbcl.lisp

Parent

impl-dependent (module)

Location

impl-dependent/sbcl.lisp

Internal Definitions

arglist (function)


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

4.1.6 clazy/library.lisp

Dependency

clazy.lisp (file)

Parent

clazy (system)

Location

library.lisp

Exported Definitions
Internal Definitions

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

4.1.7 clazy/seq-funs-package.lisp

Dependencies
Parent

clazy (system)

Location

seq-funs-package.lisp

Packages

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


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

4.1.8 clazy/seq-funs.lisp

Dependency

seq-funs-package.lisp (file)

Parent

clazy (system)

Location

seq-funs.lisp

Exported Definitions
Internal Definitions

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

5 Packages

Packages are listed by definition order.


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

5.1 it.unimib.disco.lazy

The Common Lisp Extensions Lazy Evaluation Package.

Source

clazy-package.lisp (file)

Nicknames
Use List

common-lisp

Used By List

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

Exported Definitions
Internal Definitions

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

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

Source

seq-funs-package.lisp (file)

Nicknames
Use List
Exported Definitions
Internal Definitions

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

6 Definitions

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


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

6.1 Exported definitions


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

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 (file)

Macro: cons-stream HEAD TAIL

Constructs a LAZY-STREAM, DELAYing the TAIL argument.

Package

it.unimib.disco.lazy

Source

library.lisp (file)

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 (file)

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 (file)

Macro: delay EXPRESSION

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

Package

it.unimib.disco.lazy

Source

clazy.lisp (file)

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 (file)

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 (file)

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 (file)

Macro: make-thunk EXPR

Expands into code that creates a thunk wrapping around EXPR.

Package

it.unimib.disco.lazy

Source

clazy.lisp (file)

Macro: slacking &body BODY
Package

it.unimib.disco.lazy

Source

library.lisp (file)


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

6.1.2 Functions

Function: copy-lazy-stream INSTANCE
Package

it.unimib.disco.lazy

Source

library.lisp (file)

Function: distinct SEQ &rest KEYS &key TEST KEY (DISTINCTS-TABLE DST) &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 (file)

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 (file)

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 (file)

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 (file)

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 (file)

Function: head S

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

Package

it.unimib.disco.lazy

Source

library.lisp (file)

Function: lazy-cons-p OBJECT
Package

it.unimib.disco.lazy

Source

library.lisp (file)

Function: lazy-lambda-arglist INSTANCE
Package

it.unimib.disco.lazy

Source

clazy.lisp (file)

Function: lazy-lambda-code INSTANCE
Package

it.unimib.disco.lazy

Source

clazy.lisp (file)

Function: lazy-lambda-p OBJECT
Package

it.unimib.disco.lazy

Source

clazy.lisp (file)

Function: lazy-stream-p OBJECT
Package

it.unimib.disco.lazy

Source

library.lisp (file)

Function: repeatedly FN &rest ARGS

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

Package

it.unimib.disco.lazy

Source

library.lisp (file)

Function: separate P SEQ
Package

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

Source

seq-funs.lisp (file)

Function: span P SEQ
Package

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

Source

seq-funs.lisp (file)

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 (file)

Function: tail S

Returns the rest of a LIST or LAZY-STREAM.

Package

it.unimib.disco.lazy

Source

library.lisp (file)

Function: tails SEQ
Package

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

Source

seq-funs.lisp (file)

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 (file)

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 (file)

Function: thunk-code INSTANCE
Package

it.unimib.disco.lazy

Source

clazy.lisp (file)

Function: thunk-p OBJECT
Package

it.unimib.disco.lazy

Source

clazy.lisp (file)


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

6.1.3 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 (file)

Direct superclasses

type-error (condition)

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 (file)

Direct superclasses

undefined-function (condition)

Direct subclasses

undefined-lazy-lambda (condition)

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

undefined-lazy-function-name (generic function)


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

6.1.4 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 (file)

Direct superclasses

lazy-stream (structure)

Direct methods

print-object (method)

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 (file)

Direct superclasses

structure-object (structure)

Direct methods

print-object (method)

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 (function)

Writers

(setf lazy-lambda-code) (function)

Slot: arglist
Type

list

Initform

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

Readers

lazy-lambda-arglist (function)

Writers

(setf lazy-lambda-arglist) (function)

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 (file)

Direct superclasses

structure-object (structure)

Direct subclasses

lazy-cons (structure)

Direct methods

print-object (method)

Direct slots
Slot: head
Readers

lazy-stream-head (function)

Writers

(setf lazy-stream-head) (function)

Slot: tail
Readers

lazy-stream-tail (function)

Writers

(setf lazy-stream-tail) (function)

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 (file)

Direct superclasses

structure-object (structure)

Direct methods

print-object (method)

Direct slots
Slot: code
Type

function

Initform

(constantly nil)

Readers

thunk-code (function)

Writers

(setf thunk-code) (function)

Slot: form
Readers

thunk-form (function)

Writers

(setf thunk-form) (function)

Slot: type
Initform

t

Readers

thunk-type (function)

Writers

(setf thunk-type) (function)


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

6.1.5 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 (file)

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 (file)


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

6.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [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 (file)

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 (file)


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

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 (file)


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

6.2.3 Functions

Function: %cons-lazy-cons HEAD &optional TAIL
Package

it.unimib.disco.lazy

Source

library.lisp (file)

Function: %cons-lazy-stream HEAD &optional TAIL
Package

it.unimib.disco.lazy

Source

library.lisp (file)

Function: %make-thunk% FORM CODE
Package

it.unimib.disco.lazy

Source

clazy.lisp (file)

Function: arglist FUNCTION-DESIGNATOR
Package

it.unimib.disco.lazy

Source

sbcl.lisp (file)

Function: copy-lazy-cons INSTANCE
Package

it.unimib.disco.lazy

Source

library.lisp (file)

Function: create-thunk-call-expansion ARG-NAME ARG-THUNK-NAME
Package

it.unimib.disco.lazy

Source

clazy.lisp (file)

Function: create-var-thunk-call-expansion VAR-NAME-THUNK
Package

it.unimib.disco.lazy

Source

clazy.lisp (file)

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 (file)

Writer

(setf get-lazy-version) (function)

Function: (setf get-lazy-version) LF NAME
Package

it.unimib.disco.lazy

Source

clazy.lisp (file)

Reader

get-lazy-version (function)

Function: lambda-expression-p F
Package

it.unimib.disco.lazy

Source

clazy.lisp (file)

Function: lazy-cons-head INSTANCE
Package

it.unimib.disco.lazy

Source

library.lisp (file)

Function: lazy-cons-tail INSTANCE
Package

it.unimib.disco.lazy

Source

library.lisp (file)

Function: lazy-function-name-p S

Checks if the symbol S names a lazy function.

Package

it.unimib.disco.lazy

Source

clazy.lisp (file)

Function: lazy-name S

Creates a symbol suitable for naming a lazy function.

Package

it.unimib.disco.lazy

Source

clazy.lisp (file)

Function: lazy-stream-head INSTANCE
Package

it.unimib.disco.lazy

Source

library.lisp (file)

Function: lazy-stream-tail INSTANCE
Package

it.unimib.disco.lazy

Source

library.lisp (file)

Function: make-lazy-lambda &optional CODE ARGLIST
Package

it.unimib.disco.lazy

Source

clazy.lisp (file)

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 (file)

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 (file)

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 (file)

Function: take-nth N SEQ
Package

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

Source

seq-funs.lisp (file)

Function: thunk-form INSTANCE
Package

it.unimib.disco.lazy

Source

clazy.lisp (file)

Function: thunk-type INSTANCE
Package

it.unimib.disco.lazy

Source

clazy.lisp (file)

Function: zip CONS-FUN SEQ1 SEQ2 &rest SEQS
Package

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

Source

seq-funs.lisp (file)


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

6.2.4 Generic functions

Generic Function: undefined-lazy-function-name CONDITION
Package

it.unimib.disco.lazy

Methods
Method: undefined-lazy-function-name (CONDITION undefined-lazy-function)
Source

clazy.lisp (file)


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

6.2.5 Conditions

Condition: undefined-lazy-lambda ()
Package

it.unimib.disco.lazy

Source

clazy.lisp (file)

Direct superclasses

undefined-lazy-function (condition)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   C   F   L   M  
Index Entry  Section

C
clazy.asd: The clazy<dot>asd file
clazy/clazy-package.lisp: The clazy/clazy-package<dot>lisp file
clazy/clazy.lisp: The clazy/clazy<dot>lisp file
clazy/impl-dependent: The clazy/impl-dependent module
clazy/impl-dependent/sbcl.lisp: The clazy/impl-dependent/sbcl<dot>lisp file
clazy/lambda-list-parsing.lisp: The clazy/lambda-list-parsing<dot>lisp file
clazy/library.lisp: The clazy/library<dot>lisp file
clazy/seq-funs-package.lisp: The clazy/seq-funs-package<dot>lisp file
clazy/seq-funs.lisp: The clazy/seq-funs<dot>lisp file

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

L
Lisp File, clazy.asd: The clazy<dot>asd file
Lisp File, clazy/clazy-package.lisp: The clazy/clazy-package<dot>lisp file
Lisp File, clazy/clazy.lisp: The clazy/clazy<dot>lisp file
Lisp File, clazy/impl-dependent/sbcl.lisp: The clazy/impl-dependent/sbcl<dot>lisp file
Lisp File, clazy/lambda-list-parsing.lisp: The clazy/lambda-list-parsing<dot>lisp file
Lisp File, clazy/library.lisp: The clazy/library<dot>lisp file
Lisp File, clazy/seq-funs-package.lisp: The clazy/seq-funs-package<dot>lisp file
Lisp File, clazy/seq-funs.lisp: The clazy/seq-funs<dot>lisp file

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

Jump to:   C   F   L   M  

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

A.2 Functions

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

%
%cons-lazy-cons: Internal functions
%cons-lazy-stream: Internal functions
%make-thunk%: Internal functions

(
(setf get-lazy-version): Internal functions

A
arglist: Internal functions

C
call: Exported macros
cons-stream: Exported macros
copy-lazy-cons: Internal functions
copy-lazy-stream: Exported functions
create-thunk-call-expansion: Internal functions
create-var-thunk-call-expansion: Internal functions

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

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

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

H
head: Exported functions

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

M
Macro, call: Exported macros
Macro, cons-stream: Exported macros
Macro, def-lazy-function: Exported macros
Macro, deflazy: Exported macros
Macro, delay: Exported macros
Macro, lazily: Exported macros
Macro, lazy: Exported macros
Macro, let/lazy: Exported macros
Macro, make-thunk: Exported macros
Macro, slacking: Exported macros
Macro, tau-lambda: Internal macros
make-lazy-lambda: Internal functions
make-thunk: Exported macros
make-thunk-setup-code: Internal functions
Method, undefined-lazy-function-name: Internal generic functions

P
parse-ordinary-lambda-list: Internal functions

R
rename-lambda-vars: Internal functions
repeatedly: Exported functions

S
separate: Exported functions
slacking: Exported macros
span: Exported functions
split-at: Exported functions

T
tail: Exported functions
tails: Exported functions
take: Exported functions
take-nth: Internal functions
take-while: Exported functions
tau-lambda: Internal macros
thunk-code: Exported functions
thunk-form: Internal functions
thunk-p: Exported functions
thunk-type: Internal functions

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

Z
zip: Internal functions

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

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

A.3 Variables

Jump to:   *  
A   C   F   H   L   S   T  
Index Entry  Section

*
*break-if-non-lazy-call-p*: Internal special variables
*warn-if-non-lazy-call-p*: Internal special variables

A
arglist: Exported structures

C
code: Exported structures
code: Exported structures

F
form: Exported structures

H
head: Exported structures

L
lazy-version-name: Exported conditions

S
Slot, arglist: Exported structures
Slot, code: Exported structures
Slot, code: Exported structures
Slot, form: Exported structures
Slot, head: Exported structures
Slot, lazy-version-name: Exported conditions
Slot, tail: Exported structures
Slot, type: Exported structures
Special Variable, *break-if-non-lazy-call-p*: Internal special variables
Special Variable, *warn-if-non-lazy-call-p*: Internal special variables

T
tail: Exported structures
type: Exported structures

Jump to:   *  
A   C   F   H   L   S   T  

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

A.4 Data types

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

C
clazy: The clazy system
Condition, invalid-lazy-argument: Exported conditions
Condition, undefined-lazy-function: Exported conditions
Condition, undefined-lazy-lambda: Internal conditions

I
invalid-lazy-argument: Exported conditions
it.unimib.disco.lazy: The it<dot>unimib<dot>disco<dot>lazy package
it.unimib.disco.ma.cl.ext.sequences.lazy: The it<dot>unimib<dot>disco<dot>ma<dot>cl<dot>ext<dot>sequences<dot>lazy package

L
lazy-cons: Exported structures
lazy-lambda: Exported structures
lazy-stream: Exported structures
list-index: Exported types

P
Package, it.unimib.disco.lazy: The it<dot>unimib<dot>disco<dot>lazy package
Package, it.unimib.disco.ma.cl.ext.sequences.lazy: The it<dot>unimib<dot>disco<dot>ma<dot>cl<dot>ext<dot>sequences<dot>lazy package

S
seq-index: Exported types
Structure, lazy-cons: Exported structures
Structure, lazy-lambda: Exported structures
Structure, lazy-stream: Exported structures
Structure, thunk: Exported structures
System, clazy: The clazy system

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

U
undefined-lazy-function: Exported conditions
undefined-lazy-lambda: Internal conditions

Jump to:   C   I   L   P   S   T   U