The transparent-wrap Reference Manual

Table of Contents

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

The transparent-wrap Reference Manual

This is the transparent-wrap Reference Manual, generated automatically by Declt version 2.3 "Robert April" on Tue Feb 20 09:26:04 2018 GMT+0.


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

1 Introduction

transparent-wrap

Build Status

This is a small utility for generating wrapper functions that have the same signature as the functions they wrap so that you can still interactively see the same function signature in the SLIME minibuffer. (It also offers the same feature for macros, which is not quite as difficult but is included for completeness' sake.)

Table of Contents

Example

When using lispbuilder-sdl on SBCL, you may encounter all kinds of floating point errors, but you don't want to disable those errors globally - you want to do your own math before calling out to foreign functions. In that case you can do something like this:

(defpackage :sdl-wrap
  (:use :cl)
  #.`(:export
      ,@(loop for symbol being the external-symbols of :sdl
           when (and (fboundp symbol)
                     (eql (symbol-package symbol) (find-package :sdl)))
           collect symbol)))

#.`(progn
     ,@(loop for symbol being the external-symbols of :sdl
          when (and (fboundp symbol)
                    (eql (symbol-package symbol) (find-package :sdl)))
          collect
            (transparent-wrap:create-transparent-defun
             symbol
             (lambda (real-function-call)
               `(sb-int:with-float-traps-masked (:invalid :overflow :divide-by-zero)
                  ,real-function-call))
             :sdl-wrap)))

and fix it without having to massively edit the package's source code or your client code. Just import the wrapper package instead. Now you can get the functionality you need and see that sdl-wrap:draw-string-solid-* has the signature (string x y &key (justify :left) (surface lispbuilder-sdl:*default-surface*) (font lispbuilder-sdl:*default-font*) (color lispbuilder-sdl:*default-color*)) without manually searching for it!

Basic Usage

;; function
(create-transparent-defun 'package:function
                          (lambda (code)
                            `(wrap ,code))
                          :wrapping-package)
(defmacro wrapper (code)
  `(wrap ,code))

;; macro
(transparent-defun package:function wrapper :wrapping-package)
;; function
(create-transparent-defmacro package:macro
                             (lambda (code)
                               ``(wrap ,,code))
                             :wrapping-package)
(defmacro wrapper (code)
  `(wrap ,code))

;; macro
(transparent-defmacro package:macro wrapper :wrapping-package)

Performance

For some argument lists, the wrapping layer imposes a considerable overhead, since we have to manually ensure that we only pass exactly the same optional and keyword arguments that appeared in the outer call in case the wrapped function explicitly checks whether any of those arguments were supplied. There are two ways to mitigate this overhead:

  1. Set the keyword argument :force-rest to t in create-transparent-defun. This adds a &rest parameter when wrapping a function that has &key arguments but no &rest argument. This way, the keyword arguments can be passed through with apply without checking which ones are present, with minimal clutter added to the function signature.

  2. When turning a development build into a production build, you can swap out create-transparent-defun for create-opaque-defun to include the same wrapping logic but strip out all the infrastructure for imitating the function signature.

Limitations

This library uses trivial-arguments to retrieve function and macro signatures. On some implementations, this will not retrieve default arguments for some parameters. When no signature can be found, transparent-defun falls back to basic opaque-defun functionality and creates a wrapper with a &rest parameter only.

Init-forms can have side effects, and they are normally evaluated in left-to-right order. This library will only hoist init-forms into wrappers until it reaches the first parameter, either optional or keyword, that has a supplied-p check. If you're confident that the ordering of your init-forms won't matter, you can set the keyword argument :allow-reordered-init-forms to t and see later parameters' init-forms in the wrapper function signature. You will still not see init-forms for any parameters that have supplied-p checks, since this can still affect the behavior of the wrapped function.

Wrappers for generic functions with &rest and/or &key parameters will have those parameters subsumed by a single &rest parameter to allow for variations in congruent method lambda lists.


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 transparent-wrap

Author

Kyle Littler

Home Page

https://github.com/DalekBaldwin/transparent-wrap

License

LLGPL

Description

A signature-preserving wrapper generator for functions and macros.

Long Description

transparent-wrap
================

[![Build Status](https://travis-ci.org/DalekBaldwin/transparent-wrap.svg?branch=master)](https://travis-ci.org/DalekBaldwin/transparent-wrap)

This is a small utility for generating wrapper functions that have the same signature as the functions they wrap so that you can still interactively see the same function signature in the SLIME minibuffer. (It also offers the same feature for macros, which is not quite as difficult but is included for completeness’ sake.)

## Table of Contents
* [Example](#example)
* [Basic Usage](#basic-usage)
* [Performance](#performance)
* [Limitations](#limitations)

Example
——-

When using ‘lispbuilder-sdl‘ on SBCL, you may encounter all kinds of floating point errors, but you don’t want to disable those errors globally - you want to do your own math before calling out to foreign functions. In that case you can do something like this:

“‘lisp
(defpackage :sdl-wrap
(:use :cl)
#.‘(:export
,@(loop for symbol being the external-symbols of :sdl
when (and (fboundp symbol)
(eql (symbol-package symbol) (find-package :sdl)))
collect symbol)))

#.‘(progn
,@(loop for symbol being the external-symbols of :sdl
when (and (fboundp symbol)
(eql (symbol-package symbol) (find-package :sdl)))
collect
(transparent-wrap:create-transparent-defun
symbol
(lambda (real-function-call)
‘(sb-int:with-float-traps-masked (:invalid :overflow :divide-by-zero)
,real-function-call))
:sdl-wrap)))
“‘

and fix it without having to massively edit the package’s source code or your client code. Just import the wrapper package instead. Now you can get the functionality you need and see that ‘sdl-wrap:draw-string-solid-*‘ has the signature ‘(string x y &key (justify :left) (surface lispbuilder-sdl:*default-surface*) (font lispbuilder-sdl:*default-font*) (color lispbuilder-sdl:*default-color*))‘ without manually searching for it!

Basic Usage
———–

“‘lisp
;; function
(create-transparent-defun ’package:function
(lambda (code)
‘(wrap ,code))
:wrapping-package)
“‘

“‘lisp
(defmacro wrapper (code)
‘(wrap ,code))

;; macro
(transparent-defun package:function wrapper :wrapping-package)
“‘

“‘lisp
;; function
(create-transparent-defmacro package:macro
(lambda (code)
“(wrap ,,code))
:wrapping-package)
“‘

“‘lisp
(defmacro wrapper (code)
‘(wrap ,code))

;; macro
(transparent-defmacro package:macro wrapper :wrapping-package)
“‘

Performance
———–

For some argument lists, the wrapping layer imposes a considerable overhead, since we have to manually ensure that we only pass exactly the same optional and keyword arguments that appeared in the outer call in case the wrapped function explicitly checks whether any of those arguments were supplied. There are two ways to mitigate this overhead:

1. Set the keyword argument ‘:force-rest‘ to ‘t‘ in ‘create-transparent-defun‘. This adds a ‘&rest‘ parameter when wrapping a function that has ‘&key‘ arguments but no ‘&rest‘ argument. This way, the keyword arguments can be passed through with ‘apply‘ without checking which ones are present, with minimal clutter added to the function signature.

2. When turning a development build into a production build, you can swap out ‘create-transparent-defun‘ for ‘create-opaque-defun‘ to include the same wrapping logic but strip out all the infrastructure for imitating the function signature.

Limitations
———–

This library uses ‘trivial-arguments‘ to retrieve function and macro signatures. On some implementations, this will not retrieve default arguments for some parameters. When no signature can be found, ‘transparent-defun‘ falls back to basic ‘opaque-defun‘ functionality and creates a wrapper with a ‘&rest‘ parameter only.

Init-forms can have side effects, and they are normally evaluated in left-to-right order. This library will only hoist init-forms into wrappers until it reaches the first parameter, either optional or keyword, that has a supplied-p check. If you’re confident that the ordering of your init-forms won’t matter, you can set the keyword argument ‘:allow-reordered-init-forms‘ to ‘t‘ and see later parameters’ init-forms in the wrapper function signature. You will still not see init-forms for any parameters that have supplied-p checks, since this can still affect the behavior of the wrapped function.

Wrappers for generic functions with ‘&rest‘ and/or ‘&key‘ parameters will have those parameters subsumed by a single ‘&rest‘ parameter to allow for variations in congruent method lambda lists.

Dependencies
Source

transparent-wrap.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 transparent-wrap/src

Dependency

transparent-wrap.asd (file)

Parent

transparent-wrap (system)

Location

src/

Components

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

4 Files

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


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

4.1 Lisp


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

4.1.1 transparent-wrap.asd

Location

transparent-wrap.asd

Systems

transparent-wrap (system)

Packages

transparent-wrap-system


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

4.1.2 transparent-wrap/src/package.lisp

Parent

src (module)

Location

src/package.lisp

Packages

transparent-wrap


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

4.1.3 transparent-wrap/src/match.lisp

Dependency

package.lisp (file)

Parent

src (module)

Location

src/match.lisp

Internal Definitions

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

4.1.4 transparent-wrap/src/transparent-wrap.lisp

Dependency

match.lisp (file)

Parent

src (module)

Location

src/transparent-wrap.lisp

Exported Definitions
Internal Definitions

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

4.2 Other


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

4.2.1 transparent-wrap/transparent-wrap.asd

Parent

transparent-wrap (system)

Location

transparent-wrap.asd


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

5 Packages

Packages are listed by definition order.


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

5.1 transparent-wrap-system

Source

transparent-wrap.asd

Use List

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

5.2 transparent-wrap

Source

package.lisp (file)

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: opaque-defmacro MACRO WRAPPER WRAPPING-PACKAGE
Package

transparent-wrap

Source

transparent-wrap.lisp (file)

Macro: opaque-defun FUNCTION WRAPPER WRAPPING-PACKAGE &key ALT-NAME
Package

transparent-wrap

Source

transparent-wrap.lisp (file)

Macro: transparent-defmacro MACRO WRAPPER WRAPPING-PACKAGE
Package

transparent-wrap

Source

transparent-wrap.lisp (file)

Macro: transparent-defun FUNCTION WRAPPER WRAPPING-PACKAGE &key (FORCE-REST *FORCE-REST*) (ALLOW-REORDERED-INIT-FORMS *ALLOW-REORDERED-INIT-FORMS*) ALT-NAME
Package

transparent-wrap

Source

transparent-wrap.lisp (file)


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

6.1.2 Functions

Function: create-opaque-defmacro MACRO WRAPPER WRAPPING-PACKAGE
Package

transparent-wrap

Source

transparent-wrap.lisp (file)

Function: create-opaque-defun FUNCTION WRAPPER WRAPPING-PACKAGE &key ALT-NAME
Package

transparent-wrap

Source

transparent-wrap.lisp (file)

Function: create-transparent-defmacro MACRO WRAPPER WRAPPING-PACKAGE
Package

transparent-wrap

Source

transparent-wrap.lisp (file)

Function: create-transparent-defun FUNCTION WRAPPER WRAPPING-PACKAGE &key (FORCE-REST *FORCE-REST*) (ALLOW-REORDERED-INIT-FORMS *ALLOW-REORDERED-INIT-FORMS*) ALT-NAME
Package

transparent-wrap

Source

transparent-wrap.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: *allow-reordered-init-forms*
Package

transparent-wrap

Source

transparent-wrap.lisp (file)

Special Variable: *force-rest*
Package

transparent-wrap

Source

transparent-wrap.lisp (file)


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

6.2.2 Functions

Function: aux-param-init-form INSTANCE
Function: (setf aux-param-init-form) VALUE INSTANCE
Package

transparent-wrap

Source

match.lisp (file)

Function: aux-param-name INSTANCE
Function: (setf aux-param-name) VALUE INSTANCE
Package

transparent-wrap

Source

match.lisp (file)

Function: aux-param-p OBJECT
Package

transparent-wrap

Source

match.lisp (file)

Function: aux-param-whole INSTANCE
Function: (setf aux-param-whole) VALUE INSTANCE
Package

transparent-wrap

Source

match.lisp (file)

Function: copy-aux-param INSTANCE
Package

transparent-wrap

Source

match.lisp (file)

Function: copy-key-param INSTANCE
Package

transparent-wrap

Source

match.lisp (file)

Function: copy-optional-param INSTANCE
Package

transparent-wrap

Source

match.lisp (file)

Function: copy-required-param INSTANCE
Package

transparent-wrap

Source

match.lisp (file)

Function: copy-rest-param INSTANCE
Package

transparent-wrap

Source

match.lisp (file)

Function: copy-specialized-param INSTANCE
Package

transparent-wrap

Source

match.lisp (file)

Function: count-until-false LIST
Package

transparent-wrap

Source

transparent-wrap.lisp (file)

Function: create-body FUNCTION REQUIRED OPTIONAL REST KEY INIT-FORMS-OKAY-SEQ
Package

transparent-wrap

Source

transparent-wrap.lisp (file)

Function: create-optional-params OPTIONAL
Package

transparent-wrap

Source

transparent-wrap.lisp (file)

Function: create-transparent-defun% FUNCTION WRAPPER WRAPPING-PACKAGE &key ALT-NAME BODY-MAKER
Package

transparent-wrap

Source

transparent-wrap.lisp (file)

Function: key-param-init-form INSTANCE
Function: (setf key-param-init-form) VALUE INSTANCE
Package

transparent-wrap

Source

match.lisp (file)

Function: key-param-keyword-name INSTANCE
Function: (setf key-param-keyword-name) VALUE INSTANCE
Package

transparent-wrap

Source

match.lisp (file)

Function: key-param-name INSTANCE
Function: (setf key-param-name) VALUE INSTANCE
Package

transparent-wrap

Source

match.lisp (file)

Function: key-param-p OBJECT
Package

transparent-wrap

Source

match.lisp (file)

Function: key-param-supplied-p-parameter INSTANCE
Function: (setf key-param-supplied-p-parameter) VALUE INSTANCE
Package

transparent-wrap

Source

match.lisp (file)

Function: key-param-whole INSTANCE
Function: (setf key-param-whole) VALUE INSTANCE
Package

transparent-wrap

Source

match.lisp (file)

Function: make-aux-param &key (WHOLE WHOLE) (NAME NAME) (INIT-FORM INIT-FORM)
Package

transparent-wrap

Source

match.lisp (file)

Function: make-key-param &key (WHOLE WHOLE) (NAME NAME) (KEYWORD-NAME KEYWORD-NAME) (INIT-FORM INIT-FORM) (SUPPLIED-P-PARAMETER SUPPLIED-P-PARAMETER)
Package

transparent-wrap

Source

match.lisp (file)

Function: make-optional-param &key (WHOLE WHOLE) (NAME NAME) (INIT-FORM INIT-FORM) (SUPPLIED-P-PARAMETER SUPPLIED-P-PARAMETER)
Package

transparent-wrap

Source

match.lisp (file)

Function: make-required-param &key (NAME NAME)
Package

transparent-wrap

Source

match.lisp (file)

Function: make-rest-param &key (NAME NAME)
Package

transparent-wrap

Source

match.lisp (file)

Function: make-specialized-param &key (NAME NAME) (WHOLE WHOLE) (SPECIALIZER SPECIALIZER)
Package

transparent-wrap

Source

match.lisp (file)

Function: match-aux PARAM
Package

transparent-wrap

Source

match.lisp (file)

Function: match-auxes PARAMS
Package

transparent-wrap

Source

match.lisp (file)

Function: match-key PARAM
Package

transparent-wrap

Source

match.lisp (file)

Function: match-keys PARAMS
Package

transparent-wrap

Source

match.lisp (file)

Function: match-lambda-list PARAMS
Package

transparent-wrap

Source

match.lisp (file)

Function: match-optional PARAM
Package

transparent-wrap

Source

match.lisp (file)

Function: match-optionals PARAMS
Package

transparent-wrap

Source

match.lisp (file)

Function: match-post-keys PARAMS
Package

transparent-wrap

Source

match.lisp (file)

Function: match-post-rest PARAMS
Package

transparent-wrap

Source

match.lisp (file)

Function: match-requireds PARAMS
Package

transparent-wrap

Source

match.lisp (file)

Function: match-specialized PARAM
Package

transparent-wrap

Source

match.lisp (file)

Function: match-specialized-lambda-list PARAMS
Package

transparent-wrap

Source

match.lisp (file)

Function: match-specialized-requireds PARAMS
Package

transparent-wrap

Source

match.lisp (file)

Function: optional-param-init-form INSTANCE
Function: (setf optional-param-init-form) VALUE INSTANCE
Package

transparent-wrap

Source

match.lisp (file)

Function: optional-param-name INSTANCE
Function: (setf optional-param-name) VALUE INSTANCE
Package

transparent-wrap

Source

match.lisp (file)

Function: optional-param-p OBJECT
Package

transparent-wrap

Source

match.lisp (file)

Function: optional-param-supplied-p-parameter INSTANCE
Function: (setf optional-param-supplied-p-parameter) VALUE INSTANCE
Package

transparent-wrap

Source

match.lisp (file)

Function: optional-param-whole INSTANCE
Function: (setf optional-param-whole) VALUE INSTANCE
Package

transparent-wrap

Source

match.lisp (file)

Function: organize-arguments ARGLIST
Package

transparent-wrap

Source

transparent-wrap.lisp (file)

Function: real-keyword KEY-PARAM
Package

transparent-wrap

Source

transparent-wrap.lisp (file)

Function: required-param-name INSTANCE
Function: (setf required-param-name) VALUE INSTANCE
Package

transparent-wrap

Source

match.lisp (file)

Function: required-param-p OBJECT
Package

transparent-wrap

Source

match.lisp (file)

Function: rest-param-name INSTANCE
Function: (setf rest-param-name) VALUE INSTANCE
Package

transparent-wrap

Source

match.lisp (file)

Function: rest-param-p OBJECT
Package

transparent-wrap

Source

match.lisp (file)

Function: specialized-param-name INSTANCE
Function: (setf specialized-param-name) VALUE INSTANCE
Package

transparent-wrap

Source

match.lisp (file)

Function: specialized-param-p OBJECT
Package

transparent-wrap

Source

match.lisp (file)

Function: specialized-param-specializer INSTANCE
Function: (setf specialized-param-specializer) VALUE INSTANCE
Package

transparent-wrap

Source

match.lisp (file)

Function: specialized-param-whole INSTANCE
Function: (setf specialized-param-whole) VALUE INSTANCE
Package

transparent-wrap

Source

match.lisp (file)


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

6.2.3 Structures

Structure: aux-param ()
Package

transparent-wrap

Source

match.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: whole
Readers

aux-param-whole (function)

Writers

(setf aux-param-whole) (function)

Slot: name
Readers

aux-param-name (function)

Writers

(setf aux-param-name) (function)

Slot: init-form
Readers

aux-param-init-form (function)

Writers

(setf aux-param-init-form) (function)

Structure: key-param ()
Package

transparent-wrap

Source

match.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: whole
Readers

key-param-whole (function)

Writers

(setf key-param-whole) (function)

Slot: name
Readers

key-param-name (function)

Writers

(setf key-param-name) (function)

Slot: keyword-name
Readers

key-param-keyword-name (function)

Writers

(setf key-param-keyword-name) (function)

Slot: init-form
Readers

key-param-init-form (function)

Writers

(setf key-param-init-form) (function)

Slot: supplied-p-parameter
Readers

key-param-supplied-p-parameter (function)

Writers

(setf key-param-supplied-p-parameter) (function)

Structure: optional-param ()
Package

transparent-wrap

Source

match.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: whole
Readers

optional-param-whole (function)

Writers

(setf optional-param-whole) (function)

Slot: name
Readers

optional-param-name (function)

Writers

(setf optional-param-name) (function)

Slot: init-form
Readers

optional-param-init-form (function)

Writers

(setf optional-param-init-form) (function)

Slot: supplied-p-parameter
Readers

optional-param-supplied-p-parameter (function)

Writers

(setf optional-param-supplied-p-parameter) (function)

Structure: required-param ()
Package

transparent-wrap

Source

match.lisp (file)

Direct superclasses

structure-object (structure)

Direct subclasses

specialized-param (structure)

Direct slots
Slot: name
Readers

required-param-name (function)

Writers

(setf required-param-name) (function)

Structure: rest-param ()
Package

transparent-wrap

Source

match.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: name
Readers

rest-param-name (function)

Writers

(setf rest-param-name) (function)

Structure: specialized-param ()
Package

transparent-wrap

Source

match.lisp (file)

Direct superclasses

required-param (structure)

Direct slots
Slot: whole
Readers

specialized-param-whole (function)

Writers

(setf specialized-param-whole) (function)

Slot: specializer
Readers

specialized-param-specializer (function)

Writers

(setf specialized-param-specializer) (function)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   F   L   M   O   T  
Index Entry  Section

F
File, Lisp, transparent-wrap.asd: The transparent-wrap<dot>asd file
File, Lisp, transparent-wrap/src/match.lisp: The transparent-wrap/src/match<dot>lisp file
File, Lisp, transparent-wrap/src/package.lisp: The transparent-wrap/src/package<dot>lisp file
File, Lisp, transparent-wrap/src/transparent-wrap.lisp: The transparent-wrap/src/transparent-wrap<dot>lisp file
File, other, transparent-wrap/transparent-wrap.asd: The transparent-wrap/transparent-wrap<dot>asd file

L
Lisp File, transparent-wrap.asd: The transparent-wrap<dot>asd file
Lisp File, transparent-wrap/src/match.lisp: The transparent-wrap/src/match<dot>lisp file
Lisp File, transparent-wrap/src/package.lisp: The transparent-wrap/src/package<dot>lisp file
Lisp File, transparent-wrap/src/transparent-wrap.lisp: The transparent-wrap/src/transparent-wrap<dot>lisp file

M
Module, transparent-wrap/src: The transparent-wrap/src module

O
Other File, transparent-wrap/transparent-wrap.asd: The transparent-wrap/transparent-wrap<dot>asd file

T
transparent-wrap.asd: The transparent-wrap<dot>asd file
transparent-wrap/src: The transparent-wrap/src module
transparent-wrap/src/match.lisp: The transparent-wrap/src/match<dot>lisp file
transparent-wrap/src/package.lisp: The transparent-wrap/src/package<dot>lisp file
transparent-wrap/src/transparent-wrap.lisp: The transparent-wrap/src/transparent-wrap<dot>lisp file
transparent-wrap/transparent-wrap.asd: The transparent-wrap/transparent-wrap<dot>asd file

Jump to:   F   L   M   O   T  

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

A.2 Functions

Jump to:   (  
A   C   F   K   M   O   R   S   T  
Index Entry  Section

(
(setf aux-param-init-form): Internal functions
(setf aux-param-name): Internal functions
(setf aux-param-whole): Internal functions
(setf key-param-init-form): Internal functions
(setf key-param-keyword-name): Internal functions
(setf key-param-name): Internal functions
(setf key-param-supplied-p-parameter): Internal functions
(setf key-param-whole): Internal functions
(setf optional-param-init-form): Internal functions
(setf optional-param-name): Internal functions
(setf optional-param-supplied-p-parameter): Internal functions
(setf optional-param-whole): Internal functions
(setf required-param-name): Internal functions
(setf rest-param-name): Internal functions
(setf specialized-param-name): Internal functions
(setf specialized-param-specializer): Internal functions
(setf specialized-param-whole): Internal functions

A
aux-param-init-form: Internal functions
aux-param-name: Internal functions
aux-param-p: Internal functions
aux-param-whole: Internal functions

C
copy-aux-param: Internal functions
copy-key-param: Internal functions
copy-optional-param: Internal functions
copy-required-param: Internal functions
copy-rest-param: Internal functions
copy-specialized-param: Internal functions
count-until-false: Internal functions
create-body: Internal functions
create-opaque-defmacro: Exported functions
create-opaque-defun: Exported functions
create-optional-params: Internal functions
create-transparent-defmacro: Exported functions
create-transparent-defun: Exported functions
create-transparent-defun%: Internal functions

F
Function, (setf aux-param-init-form): Internal functions
Function, (setf aux-param-name): Internal functions
Function, (setf aux-param-whole): Internal functions
Function, (setf key-param-init-form): Internal functions
Function, (setf key-param-keyword-name): Internal functions
Function, (setf key-param-name): Internal functions
Function, (setf key-param-supplied-p-parameter): Internal functions
Function, (setf key-param-whole): Internal functions
Function, (setf optional-param-init-form): Internal functions
Function, (setf optional-param-name): Internal functions
Function, (setf optional-param-supplied-p-parameter): Internal functions
Function, (setf optional-param-whole): Internal functions
Function, (setf required-param-name): Internal functions
Function, (setf rest-param-name): Internal functions
Function, (setf specialized-param-name): Internal functions
Function, (setf specialized-param-specializer): Internal functions
Function, (setf specialized-param-whole): Internal functions
Function, aux-param-init-form: Internal functions
Function, aux-param-name: Internal functions
Function, aux-param-p: Internal functions
Function, aux-param-whole: Internal functions
Function, copy-aux-param: Internal functions
Function, copy-key-param: Internal functions
Function, copy-optional-param: Internal functions
Function, copy-required-param: Internal functions
Function, copy-rest-param: Internal functions
Function, copy-specialized-param: Internal functions
Function, count-until-false: Internal functions
Function, create-body: Internal functions
Function, create-opaque-defmacro: Exported functions
Function, create-opaque-defun: Exported functions
Function, create-optional-params: Internal functions
Function, create-transparent-defmacro: Exported functions
Function, create-transparent-defun: Exported functions
Function, create-transparent-defun%: Internal functions
Function, key-param-init-form: Internal functions
Function, key-param-keyword-name: Internal functions
Function, key-param-name: Internal functions
Function, key-param-p: Internal functions
Function, key-param-supplied-p-parameter: Internal functions
Function, key-param-whole: Internal functions
Function, make-aux-param: Internal functions
Function, make-key-param: Internal functions
Function, make-optional-param: Internal functions
Function, make-required-param: Internal functions
Function, make-rest-param: Internal functions
Function, make-specialized-param: Internal functions
Function, match-aux: Internal functions
Function, match-auxes: Internal functions
Function, match-key: Internal functions
Function, match-keys: Internal functions
Function, match-lambda-list: Internal functions
Function, match-optional: Internal functions
Function, match-optionals: Internal functions
Function, match-post-keys: Internal functions
Function, match-post-rest: Internal functions
Function, match-requireds: Internal functions
Function, match-specialized: Internal functions
Function, match-specialized-lambda-list: Internal functions
Function, match-specialized-requireds: Internal functions
Function, optional-param-init-form: Internal functions
Function, optional-param-name: Internal functions
Function, optional-param-p: Internal functions
Function, optional-param-supplied-p-parameter: Internal functions
Function, optional-param-whole: Internal functions
Function, organize-arguments: Internal functions
Function, real-keyword: Internal functions
Function, required-param-name: Internal functions
Function, required-param-p: Internal functions
Function, rest-param-name: Internal functions
Function, rest-param-p: Internal functions
Function, specialized-param-name: Internal functions
Function, specialized-param-p: Internal functions
Function, specialized-param-specializer: Internal functions
Function, specialized-param-whole: Internal functions

K
key-param-init-form: Internal functions
key-param-keyword-name: Internal functions
key-param-name: Internal functions
key-param-p: Internal functions
key-param-supplied-p-parameter: Internal functions
key-param-whole: Internal functions

M
Macro, opaque-defmacro: Exported macros
Macro, opaque-defun: Exported macros
Macro, transparent-defmacro: Exported macros
Macro, transparent-defun: Exported macros
make-aux-param: Internal functions
make-key-param: Internal functions
make-optional-param: Internal functions
make-required-param: Internal functions
make-rest-param: Internal functions
make-specialized-param: Internal functions
match-aux: Internal functions
match-auxes: Internal functions
match-key: Internal functions
match-keys: Internal functions
match-lambda-list: Internal functions
match-optional: Internal functions
match-optionals: Internal functions
match-post-keys: Internal functions
match-post-rest: Internal functions
match-requireds: Internal functions
match-specialized: Internal functions
match-specialized-lambda-list: Internal functions
match-specialized-requireds: Internal functions

O
opaque-defmacro: Exported macros
opaque-defun: Exported macros
optional-param-init-form: Internal functions
optional-param-name: Internal functions
optional-param-p: Internal functions
optional-param-supplied-p-parameter: Internal functions
optional-param-whole: Internal functions
organize-arguments: Internal functions

R
real-keyword: Internal functions
required-param-name: Internal functions
required-param-p: Internal functions
rest-param-name: Internal functions
rest-param-p: Internal functions

S
specialized-param-name: Internal functions
specialized-param-p: Internal functions
specialized-param-specializer: Internal functions
specialized-param-whole: Internal functions

T
transparent-defmacro: Exported macros
transparent-defun: Exported macros

Jump to:   (  
A   C   F   K   M   O   R   S   T  

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

A.3 Variables

Jump to:   *  
I   K   N   S   W  
Index Entry  Section

*
*allow-reordered-init-forms*: Internal special variables
*force-rest*: Internal special variables

I
init-form: Internal structures
init-form: Internal structures
init-form: Internal structures

K
keyword-name: Internal structures

N
name: Internal structures
name: Internal structures
name: Internal structures
name: Internal structures
name: Internal structures

S
Slot, init-form: Internal structures
Slot, init-form: Internal structures
Slot, init-form: Internal structures
Slot, keyword-name: Internal structures
Slot, name: Internal structures
Slot, name: Internal structures
Slot, name: Internal structures
Slot, name: Internal structures
Slot, name: Internal structures
Slot, specializer: Internal structures
Slot, supplied-p-parameter: Internal structures
Slot, supplied-p-parameter: Internal structures
Slot, whole: Internal structures
Slot, whole: Internal structures
Slot, whole: Internal structures
Slot, whole: Internal structures
Special Variable, *allow-reordered-init-forms*: Internal special variables
Special Variable, *force-rest*: Internal special variables
specializer: Internal structures
supplied-p-parameter: Internal structures
supplied-p-parameter: Internal structures

W
whole: Internal structures
whole: Internal structures
whole: Internal structures
whole: Internal structures

Jump to:   *  
I   K   N   S   W  

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

A.4 Data types

Jump to:   A   K   O   P   R   S   T  
Index Entry  Section

A
aux-param: Internal structures

K
key-param: Internal structures

O
optional-param: Internal structures

P
Package, transparent-wrap: The transparent-wrap package
Package, transparent-wrap-system: The transparent-wrap-system package

R
required-param: Internal structures
rest-param: Internal structures

S
specialized-param: Internal structures
Structure, aux-param: Internal structures
Structure, key-param: Internal structures
Structure, optional-param: Internal structures
Structure, required-param: Internal structures
Structure, rest-param: Internal structures
Structure, specialized-param: Internal structures
System, transparent-wrap: The transparent-wrap system

T
transparent-wrap: The transparent-wrap system
transparent-wrap: The transparent-wrap package
transparent-wrap-system: The transparent-wrap-system package

Jump to:   A   K   O   P   R   S   T