The transparent-wrap Reference Manual

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

The transparent-wrap Reference Manual

This is the transparent-wrap Reference Manual, generated automatically by Declt version 4.0 beta 2 "William Riker" on Mon Aug 15 06:02:06 2022 GMT+0.

Table of Contents

Next: , Previous: , Up: The transparent-wrap Reference Manual   [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: The transparent-wrap Reference Manual   [Contents][Index]

2 Systems

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

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

2.1 transparent-wrap

A signature-preserving wrapper generator for functions and macros.

Author

Kyle Littler

Home Page

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

License

LLGPL

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
  • trivial-arguments (system).
  • named-readtables (system).
  • optima (system).
  • fare-quasiquote-extras (system).
Source

transparent-wrap.asd.

Child Component

src (module).

Next: , Previous: , Up: The transparent-wrap Reference Manual   [Contents][Index]

3 Modules

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

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

3.1 transparent-wrap/src

Source

transparent-wrap.asd.

Parent Component

transparent-wrap (system).

Child Components

Next: , Previous: , Up: The transparent-wrap Reference Manual   [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   [Contents][Index]

4.1.1 transparent-wrap/transparent-wrap.asd

Source

transparent-wrap.asd.

Parent Component

transparent-wrap (system).

ASDF Systems

transparent-wrap.

Packages

transparent-wrap-system.

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

4.1.2 transparent-wrap/src/package.lisp

Source

transparent-wrap.asd.

Parent Component

src (module).

Packages

transparent-wrap.

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

4.1.3 transparent-wrap/src/match.lisp

Dependency

package.lisp (file).

Source

transparent-wrap.asd.

Parent Component

src (module).

Internals

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

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

Dependency

match.lisp (file).

Source

transparent-wrap.asd.

Parent Component

src (module).

Public Interface
Internals

Next: , Previous: , Up: The transparent-wrap Reference Manual   [Contents][Index]

5 Packages

Packages are listed by definition order.

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

5.1 transparent-wrap

Source

package.lisp.

Use List
  • common-lisp.
  • optima.
Public Interface
Internals

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

5.2 transparent-wrap-system

Source

transparent-wrap.asd.

Use List
  • asdf/interface.
  • common-lisp.

Next: , Previous: , Up: The transparent-wrap Reference Manual   [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 Public Interface

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

6.1.1 Macros

Macro: opaque-defmacro (macro wrapper wrapping-package)
Package

transparent-wrap.

Source

transparent-wrap.lisp.

Macro: opaque-defun (function wrapper wrapping-package &key alt-name)
Package

transparent-wrap.

Source

transparent-wrap.lisp.

Macro: transparent-defmacro (macro wrapper wrapping-package)
Package

transparent-wrap.

Source

transparent-wrap.lisp.

Macro: transparent-defun (function wrapper wrapping-package &key force-rest allow-reordered-init-forms alt-name)
Package

transparent-wrap.

Source

transparent-wrap.lisp.

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

6.1.2 Ordinary functions

Function: create-opaque-defmacro (macro wrapper wrapping-package)
Package

transparent-wrap.

Source

transparent-wrap.lisp.

Function: create-opaque-defun (function wrapper wrapping-package &key alt-name)
Package

transparent-wrap.

Source

transparent-wrap.lisp.

Function: create-transparent-defmacro (macro wrapper wrapping-package)
Package

transparent-wrap.

Source

transparent-wrap.lisp.

Function: create-transparent-defun (function wrapper wrapping-package &key force-rest allow-reordered-init-forms alt-name)
Package

transparent-wrap.

Source

transparent-wrap.lisp.

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

6.2 Internals

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

6.2.1 Special variables

Special Variable: *allow-reordered-init-forms*
Package

transparent-wrap.

Source

transparent-wrap.lisp.

Special Variable: *force-rest*
Package

transparent-wrap.

Source

transparent-wrap.lisp.

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

6.2.2 Ordinary functions

Reader: aux-param-init-form (instance)
Writer: (setf aux-param-init-form) (instance)
Package

transparent-wrap.

Source

match.lisp.

Target Slot

init-form.

Reader: aux-param-name (instance)
Writer: (setf aux-param-name) (instance)
Package

transparent-wrap.

Source

match.lisp.

Target Slot

name.

Function: aux-param-p (object)
Package

transparent-wrap.

Source

match.lisp.

Reader: aux-param-whole (instance)
Writer: (setf aux-param-whole) (instance)
Package

transparent-wrap.

Source

match.lisp.

Target Slot

whole.

Function: copy-aux-param (instance)
Package

transparent-wrap.

Source

match.lisp.

Function: copy-key-param (instance)
Package

transparent-wrap.

Source

match.lisp.

Function: copy-optional-param (instance)
Package

transparent-wrap.

Source

match.lisp.

Function: copy-required-param (instance)
Package

transparent-wrap.

Source

match.lisp.

Function: copy-rest-param (instance)
Package

transparent-wrap.

Source

match.lisp.

Function: copy-specialized-param (instance)
Package

transparent-wrap.

Source

match.lisp.

Function: count-until-false (list)
Package

transparent-wrap.

Source

transparent-wrap.lisp.

Function: create-body (function required optional rest key init-forms-okay-seq)
Package

transparent-wrap.

Source

transparent-wrap.lisp.

Function: create-optional-params (optional)
Package

transparent-wrap.

Source

transparent-wrap.lisp.

Function: create-transparent-defun% (function wrapper wrapping-package &key alt-name body-maker)
Package

transparent-wrap.

Source

transparent-wrap.lisp.

Reader: key-param-init-form (instance)
Writer: (setf key-param-init-form) (instance)
Package

transparent-wrap.

Source

match.lisp.

Target Slot

init-form.

Reader: key-param-keyword-name (instance)
Writer: (setf key-param-keyword-name) (instance)
Package

transparent-wrap.

Source

match.lisp.

Target Slot

keyword-name.

Reader: key-param-name (instance)
Writer: (setf key-param-name) (instance)
Package

transparent-wrap.

Source

match.lisp.

Target Slot

name.

Function: key-param-p (object)
Package

transparent-wrap.

Source

match.lisp.

Reader: key-param-supplied-p-parameter (instance)
Writer: (setf key-param-supplied-p-parameter) (instance)
Package

transparent-wrap.

Source

match.lisp.

Target Slot

supplied-p-parameter.

Reader: key-param-whole (instance)
Writer: (setf key-param-whole) (instance)
Package

transparent-wrap.

Source

match.lisp.

Target Slot

whole.

Function: make-aux-param (&key whole name init-form)
Package

transparent-wrap.

Source

match.lisp.

Function: make-key-param (&key whole name keyword-name init-form supplied-p-parameter)
Package

transparent-wrap.

Source

match.lisp.

Function: make-optional-param (&key whole name init-form supplied-p-parameter)
Package

transparent-wrap.

Source

match.lisp.

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

transparent-wrap.

Source

match.lisp.

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

transparent-wrap.

Source

match.lisp.

Function: make-specialized-param (&key name whole specializer)
Package

transparent-wrap.

Source

match.lisp.

Function: match-aux (param)
Package

transparent-wrap.

Source

match.lisp.

Function: match-auxes (params)
Package

transparent-wrap.

Source

match.lisp.

Function: match-key (param)
Package

transparent-wrap.

Source

match.lisp.

Function: match-keys (params)
Package

transparent-wrap.

Source

match.lisp.

Function: match-lambda-list (params)
Package

transparent-wrap.

Source

match.lisp.

Function: match-optional (param)
Package

transparent-wrap.

Source

match.lisp.

Function: match-optionals (params)
Package

transparent-wrap.

Source

match.lisp.

Function: match-post-keys (params)
Package

transparent-wrap.

Source

match.lisp.

Function: match-post-rest (params)
Package

transparent-wrap.

Source

match.lisp.

Function: match-requireds (params)
Package

transparent-wrap.

Source

match.lisp.

Function: match-specialized (param)
Package

transparent-wrap.

Source

match.lisp.

Function: match-specialized-lambda-list (params)
Package

transparent-wrap.

Source

match.lisp.

Function: match-specialized-requireds (params)
Package

transparent-wrap.

Source

match.lisp.

Reader: optional-param-init-form (instance)
Writer: (setf optional-param-init-form) (instance)
Package

transparent-wrap.

Source

match.lisp.

Target Slot

init-form.

Reader: optional-param-name (instance)
Writer: (setf optional-param-name) (instance)
Package

transparent-wrap.

Source

match.lisp.

Target Slot

name.

Function: optional-param-p (object)
Package

transparent-wrap.

Source

match.lisp.

Reader: optional-param-supplied-p-parameter (instance)
Writer: (setf optional-param-supplied-p-parameter) (instance)
Package

transparent-wrap.

Source

match.lisp.

Target Slot

supplied-p-parameter.

Reader: optional-param-whole (instance)
Writer: (setf optional-param-whole) (instance)
Package

transparent-wrap.

Source

match.lisp.

Target Slot

whole.

Function: organize-arguments (arglist)
Package

transparent-wrap.

Source

transparent-wrap.lisp.

Function: real-keyword (key-param)
Package

transparent-wrap.

Source

transparent-wrap.lisp.

Reader: required-param-name (instance)
Writer: (setf required-param-name) (instance)
Package

transparent-wrap.

Source

match.lisp.

Target Slot

name.

Function: required-param-p (object)
Package

transparent-wrap.

Source

match.lisp.

Reader: rest-param-name (instance)
Writer: (setf rest-param-name) (instance)
Package

transparent-wrap.

Source

match.lisp.

Target Slot

name.

Function: rest-param-p (object)
Package

transparent-wrap.

Source

match.lisp.

Function: specialized-param-name (instance)
Package

transparent-wrap.

Source

match.lisp.

Function: (setf specialized-param-name) (instance)
Package

transparent-wrap.

Source

match.lisp.

Function: specialized-param-p (object)
Package

transparent-wrap.

Source

match.lisp.

Reader: specialized-param-specializer (instance)
Writer: (setf specialized-param-specializer) (instance)
Package

transparent-wrap.

Source

match.lisp.

Target Slot

specializer.

Reader: specialized-param-whole (instance)
Writer: (setf specialized-param-whole) (instance)
Package

transparent-wrap.

Source

match.lisp.

Target Slot

whole.

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

6.2.3 Structures

Structure: aux-param
Package

transparent-wrap.

Source

match.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: whole
Readers

aux-param-whole.

Writers

(setf aux-param-whole).

Slot: name
Readers

aux-param-name.

Writers

(setf aux-param-name).

Slot: init-form
Readers

aux-param-init-form.

Writers

(setf aux-param-init-form).

Structure: key-param
Package

transparent-wrap.

Source

match.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: whole
Readers

key-param-whole.

Writers

(setf key-param-whole).

Slot: name
Readers

key-param-name.

Writers

(setf key-param-name).

Slot: keyword-name
Readers

key-param-keyword-name.

Writers

(setf key-param-keyword-name).

Slot: init-form
Readers

key-param-init-form.

Writers

(setf key-param-init-form).

Slot: supplied-p-parameter
Readers

key-param-supplied-p-parameter.

Writers

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

Structure: optional-param
Package

transparent-wrap.

Source

match.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: whole
Readers

optional-param-whole.

Writers

(setf optional-param-whole).

Slot: name
Readers

optional-param-name.

Writers

(setf optional-param-name).

Slot: init-form
Readers

optional-param-init-form.

Writers

(setf optional-param-init-form).

Slot: supplied-p-parameter
Readers

optional-param-supplied-p-parameter.

Writers

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

Structure: required-param
Package

transparent-wrap.

Source

match.lisp.

Direct superclasses

structure-object.

Direct subclasses

specialized-param.

Direct slots
Slot: name
Readers

required-param-name.

Writers

(setf required-param-name).

Structure: rest-param
Package

transparent-wrap.

Source

match.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: name
Readers

rest-param-name.

Writers

(setf rest-param-name).

Structure: specialized-param
Package

transparent-wrap.

Source

match.lisp.

Direct superclasses

required-param.

Direct slots
Slot: whole
Readers

specialized-param-whole.

Writers

(setf specialized-param-whole).

Slot: specializer
Readers

specialized-param-specializer.

Writers

(setf specialized-param-specializer).

Previous: , Up: The transparent-wrap Reference Manual   [Contents][Index]

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   F   K   M   O   R   S   T  
Index Entry  Section
(
(setf aux-param-init-form): Private ordinary functions
(setf aux-param-name): Private ordinary functions
(setf aux-param-whole): Private ordinary functions
(setf key-param-init-form): Private ordinary functions
(setf key-param-keyword-name): Private ordinary functions
(setf key-param-name): Private ordinary functions
(setf key-param-supplied-p-parameter): Private ordinary functions
(setf key-param-whole): Private ordinary functions
(setf optional-param-init-form): Private ordinary functions
(setf optional-param-name): Private ordinary functions
(setf optional-param-supplied-p-parameter): Private ordinary functions
(setf optional-param-whole): Private ordinary functions
(setf required-param-name): Private ordinary functions
(setf rest-param-name): Private ordinary functions
(setf specialized-param-name): Private ordinary functions
(setf specialized-param-specializer): Private ordinary functions
(setf specialized-param-whole): Private ordinary functions
A
aux-param-init-form: Private ordinary functions
aux-param-name: Private ordinary functions
aux-param-p: Private ordinary functions
aux-param-whole: Private ordinary functions
C
copy-aux-param: Private ordinary functions
copy-key-param: Private ordinary functions
copy-optional-param: Private ordinary functions
copy-required-param: Private ordinary functions
copy-rest-param: Private ordinary functions
copy-specialized-param: Private ordinary functions
count-until-false: Private ordinary functions
create-body: Private ordinary functions
create-opaque-defmacro: Public ordinary functions
create-opaque-defun: Public ordinary functions
create-optional-params: Private ordinary functions
create-transparent-defmacro: Public ordinary functions
create-transparent-defun: Public ordinary functions
create-transparent-defun%: Private ordinary functions
F
Function, (setf aux-param-init-form): Private ordinary functions
Function, (setf aux-param-name): Private ordinary functions
Function, (setf aux-param-whole): Private ordinary functions
Function, (setf key-param-init-form): Private ordinary functions
Function, (setf key-param-keyword-name): Private ordinary functions
Function, (setf key-param-name): Private ordinary functions
Function, (setf key-param-supplied-p-parameter): Private ordinary functions
Function, (setf key-param-whole): Private ordinary functions
Function, (setf optional-param-init-form): Private ordinary functions
Function, (setf optional-param-name): Private ordinary functions
Function, (setf optional-param-supplied-p-parameter): Private ordinary functions
Function, (setf optional-param-whole): Private ordinary functions
Function, (setf required-param-name): Private ordinary functions
Function, (setf rest-param-name): Private ordinary functions
Function, (setf specialized-param-name): Private ordinary functions
Function, (setf specialized-param-specializer): Private ordinary functions
Function, (setf specialized-param-whole): Private ordinary functions
Function, aux-param-init-form: Private ordinary functions
Function, aux-param-name: Private ordinary functions
Function, aux-param-p: Private ordinary functions
Function, aux-param-whole: Private ordinary functions
Function, copy-aux-param: Private ordinary functions
Function, copy-key-param: Private ordinary functions
Function, copy-optional-param: Private ordinary functions
Function, copy-required-param: Private ordinary functions
Function, copy-rest-param: Private ordinary functions
Function, copy-specialized-param: Private ordinary functions
Function, count-until-false: Private ordinary functions
Function, create-body: Private ordinary functions
Function, create-opaque-defmacro: Public ordinary functions
Function, create-opaque-defun: Public ordinary functions
Function, create-optional-params: Private ordinary functions
Function, create-transparent-defmacro: Public ordinary functions
Function, create-transparent-defun: Public ordinary functions
Function, create-transparent-defun%: Private ordinary functions
Function, key-param-init-form: Private ordinary functions
Function, key-param-keyword-name: Private ordinary functions
Function, key-param-name: Private ordinary functions
Function, key-param-p: Private ordinary functions
Function, key-param-supplied-p-parameter: Private ordinary functions
Function, key-param-whole: Private ordinary functions
Function, make-aux-param: Private ordinary functions
Function, make-key-param: Private ordinary functions
Function, make-optional-param: Private ordinary functions
Function, make-required-param: Private ordinary functions
Function, make-rest-param: Private ordinary functions
Function, make-specialized-param: Private ordinary functions
Function, match-aux: Private ordinary functions
Function, match-auxes: Private ordinary functions
Function, match-key: Private ordinary functions
Function, match-keys: Private ordinary functions
Function, match-lambda-list: Private ordinary functions
Function, match-optional: Private ordinary functions
Function, match-optionals: Private ordinary functions
Function, match-post-keys: Private ordinary functions
Function, match-post-rest: Private ordinary functions
Function, match-requireds: Private ordinary functions
Function, match-specialized: Private ordinary functions
Function, match-specialized-lambda-list: Private ordinary functions
Function, match-specialized-requireds: Private ordinary functions
Function, optional-param-init-form: Private ordinary functions
Function, optional-param-name: Private ordinary functions
Function, optional-param-p: Private ordinary functions
Function, optional-param-supplied-p-parameter: Private ordinary functions
Function, optional-param-whole: Private ordinary functions
Function, organize-arguments: Private ordinary functions
Function, real-keyword: Private ordinary functions
Function, required-param-name: Private ordinary functions
Function, required-param-p: Private ordinary functions
Function, rest-param-name: Private ordinary functions
Function, rest-param-p: Private ordinary functions
Function, specialized-param-name: Private ordinary functions
Function, specialized-param-p: Private ordinary functions
Function, specialized-param-specializer: Private ordinary functions
Function, specialized-param-whole: Private ordinary functions
K
key-param-init-form: Private ordinary functions
key-param-keyword-name: Private ordinary functions
key-param-name: Private ordinary functions
key-param-p: Private ordinary functions
key-param-supplied-p-parameter: Private ordinary functions
key-param-whole: Private ordinary functions
M
Macro, opaque-defmacro: Public macros
Macro, opaque-defun: Public macros
Macro, transparent-defmacro: Public macros
Macro, transparent-defun: Public macros
make-aux-param: Private ordinary functions
make-key-param: Private ordinary functions
make-optional-param: Private ordinary functions
make-required-param: Private ordinary functions
make-rest-param: Private ordinary functions
make-specialized-param: Private ordinary functions
match-aux: Private ordinary functions
match-auxes: Private ordinary functions
match-key: Private ordinary functions
match-keys: Private ordinary functions
match-lambda-list: Private ordinary functions
match-optional: Private ordinary functions
match-optionals: Private ordinary functions
match-post-keys: Private ordinary functions
match-post-rest: Private ordinary functions
match-requireds: Private ordinary functions
match-specialized: Private ordinary functions
match-specialized-lambda-list: Private ordinary functions
match-specialized-requireds: Private ordinary functions
O
opaque-defmacro: Public macros
opaque-defun: Public macros
optional-param-init-form: Private ordinary functions
optional-param-name: Private ordinary functions
optional-param-p: Private ordinary functions
optional-param-supplied-p-parameter: Private ordinary functions
optional-param-whole: Private ordinary functions
organize-arguments: Private ordinary functions
R
real-keyword: Private ordinary functions
required-param-name: Private ordinary functions
required-param-p: Private ordinary functions
rest-param-name: Private ordinary functions
rest-param-p: Private ordinary functions
S
specialized-param-name: Private ordinary functions
specialized-param-p: Private ordinary functions
specialized-param-specializer: Private ordinary functions
specialized-param-whole: Private ordinary functions
T
transparent-defmacro: Public macros
transparent-defun: Public macros
Jump to:   (  
A   C   F   K   M   O   R   S   T  

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

A.4 Data types

Jump to:   A   F   K   M   O   P   R   S   T  
Index Entry  Section
A
aux-param: Private structures
F
File, match.lisp: The transparent-wrap/src/match․lisp file
File, package.lisp: The transparent-wrap/src/package․lisp file
File, transparent-wrap.asd: The transparent-wrap/transparent-wrap․asd file
File, transparent-wrap.lisp: The transparent-wrap/src/transparent-wrap․lisp file
K
key-param: Private structures
M
match.lisp: The transparent-wrap/src/match․lisp file
Module, src: The transparent-wrap/src module
O
optional-param: Private structures
P
Package, transparent-wrap: The transparent-wrap package
Package, transparent-wrap-system: The transparent-wrap-system package
package.lisp: The transparent-wrap/src/package․lisp file
R
required-param: Private structures
rest-param: Private structures
S
specialized-param: Private structures
src: The transparent-wrap/src module
Structure, aux-param: Private structures
Structure, key-param: Private structures
Structure, optional-param: Private structures
Structure, required-param: Private structures
Structure, rest-param: Private structures
Structure, specialized-param: Private 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
transparent-wrap.asd: The transparent-wrap/transparent-wrap․asd file
transparent-wrap.lisp: The transparent-wrap/src/transparent-wrap․lisp file
Jump to:   A   F   K   M   O   P   R   S   T