The structure-ext Reference Manual

3.1.1 structure-ext/structure-ext.asd

Source

structure-ext.asd.

Parent Component

structure-ext (system).

ASDF Systems

structure-ext.

---

3.1.2 structure-ext.left-arrow-accessors/structure-ext.left-arrow-accessors.asd

Source

structure-ext.left-arrow-accessors.asd.

Parent Component

structure-ext.left-arrow-accessors (system).

ASDF Systems

structure-ext.left-arrow-accessors.

---

3.1.3 structure-ext.make-instance/structure-ext.make-instance.asd

Source

structure-ext.make-instance.asd.

Parent Component

structure-ext.make-instance (system).

ASDF Systems

structure-ext.make-instance.

---

3.1.4 structure-ext.as-class/structure-ext.as-class.asd

Source

structure-ext.as-class.asd.

Parent Component

structure-ext.as-class (system).

ASDF Systems

structure-ext.as-class.

---

3.1.5 structure-ext/package.lisp

Source

structure-ext.asd.

Parent Component

structure-ext (system).

Packages

structure-ext.

---

3.1.6 structure-ext.left-arrow-accessors/left-arrow-accessors.lisp

Source

structure-ext.left-arrow-accessors.asd.

Parent Component

structure-ext.left-arrow-accessors (system).

Packages

structure-ext.left-arrow-accessors.

Public Interface

• define-left-arrow-accessors (macro).
• missing-symbol (condition).

Internals

• accessors (function).
• left-arrow-names (function).
• the-defun-forms (function).
• the-setf-forms (function).

---

3.1.7 structure-ext.make-instance/make-instance.lisp

Source

structure-ext.make-instance.asd.

Parent Component

structure-ext.make-instance (system).

Packages

structure-ext.make-instance.

---

3.1.8 structure-ext.as-class/as-class.lisp

Source

structure-ext.as-class.asd.

Parent Component

structure-ext.as-class (system).

Packages

structure-ext.as-class.

Public Interface

defstruct* (macro).

Internals

• accessors (function).
• check (function).
• collect-option (function).
• conc-name (function).
• constructors (function).
• copier (function).
• enslot (function).
• may-documentation (function).
• may-generic (function).
• may-initargs (function).
• method-name (function).
• parse (function).
• predicate (function).
• print-function (function).
• slots (function).
• slots<=obj (function).
• super-classes (function).

---

5.1.1 Macros

Macro: define-left-arrow-accessors (type &rest slot*) ¶

# DEFINE-LEFT-ARROW-ACCESSORS

## Description:
Define accessor aliases.

“‘lisp
#?(defstruct foo bar bazz)
=> FOO
, :lazy
“‘

“‘lisp
#?(define-left-arrow-accessors foo bar)
=> (BAR<=FOO)
, :test
“‘

“‘lisp
#?(bar<=foo (make-foo :bar 0))
=> 0
, :around
“‘

“‘lisp
#?(bazz<=foo (make-foo :bazz 0))
:signals (or undefined-function
warning ; for ccl
)
“‘

### syntax
(DEFINE-LEFT-ARROW-ACCESSORS type &rest slot\*)
=> result

## Arguments and Values:
type := symbol which is structure name, otherwise error.

“‘lisp
#?(define-left-arrow-accessors "FOO" bazz)
:signals error
“‘

“‘lisp
#?(define-left-arrow-accessors bar bazz)
:signals error
“‘
slot* := symbol which is slot-name, otherwise error.

“‘lisp
#?(define-left-arrow-accessors foo "BAR")
:signals error
“‘

“‘lisp
#?(define-left-arrow-accessors foo hoge)
:signals error
“‘
result := list which includes defined accessor names.

## Affected By:
lisp image status.

## Side-Effects:
define new functions in current package.

## Notes:

## Exceptional-Situations:

Package

structure-ext.left-arrow-accessors.

Source

left-arrow-accessors.lisp.

Macro: defstruct* (&body body) ¶

# DEFSTRUCT\*

## Description:
Define class by defstruct syntax.

### syntax
(DEFSTRUCT\* &body body)
=> result

“‘lisp
#?(defstruct* foo bar)
=> FOO
, :lazy
“‘

“‘lisp
#?(make-foo)
:be-the foo
“‘

“‘lisp
#?(foo-bar (make-foo :bar 0))
=> 0
“‘

“‘lisp
#?(foo-p (make-foo))
:satisfies identity
“‘

“‘lisp
#?(let* ((foo (make-foo :bar 0))
(copied (copy-foo foo)))
(values (eq foo copied)
(foo-bar copied)))
:multiple-value-satisfies (lambda ($samep $copied-bar-value)
(& (null $samep)
(= 0 $copied-bar-value)))
“‘

## Arguments and Values:
see CL:DEFSTRUCT.

## Affected By:
none

## Side-Effects:
none

## Notes:

## Exceptional-Situations:
:initial-offset, :type and :named option is invalid.

“‘lisp
#?(defstruct* (bar (:type list))
hoge fuga)
:signals error
“‘

“‘lisp
#?(defstruct* (bar (:initial-offset 4))
hoge fuga)
:signals error
“‘
specify both :print-function and :print-object is invalid.

“‘lisp
#?(defstruct* (bar (:print-function bar-printer)
(:print-object (lambda (&rest args) (print args))))
hoge fuga)
:signals error
“‘

## Examples
simplest form

“‘lisp
#?(defstruct* hoge bar)
:expanded-to (progn (defclass hoge ()
((bar :initform nil :initarg :bar :accessor hoge-bar)))
(defun make-hoge (&rest args)
(apply #’make-instance ’hoge args))
(defgeneric copy-hoge (arg))
(defmethod copy-hoge ((arg hoge))
(let ((obj (make-instance (class-of arg))))
(dolist (slot (slots<=obj arg))
(if (slot-boundp arg slot)
(setf (slot-value obj slot) (slot-value arg slot)) (slot-makunbound obj slot)))
obj))
#+(or clisp sbcl)
(defun hoge-p (arg) (typep arg ’hoge))
#-(or clisp sbcl)
(defgeneric hoge-p (arg))
#-(or clisp sbcl)
(defmethod hoge-p ((arg hoge)) arg)
#-(or clisp sbcl)
(defmethod hoge-p (arg)
(declare (ignore arg))
nil)
’hoge)
“‘
with initform.

“‘lisp
#?(defstruct* hoge
(bar 0))
; <— specified.
:expanded-to
“‘
Specify type.

“‘lisp
#?(defstruct* hoge
(bar 0 :type integer))
; <— specified.
:expanded-to
“‘
Specify read-only T.

“‘lisp
#?(defstruct* hoge
(bar 0 :read-only T))
; <— specified.
:expanded-to
“‘
Conc-name option example.
Specify no prefix.

“‘lisp
#?(defstruct* (hoge (:conc-name nil)) ; <— Specify.
bar)
:expanded-to (progn (defclass hoge ()
((bar :initform nil :initarg :bar :accessor bar))) ; <— This! (defun make-hoge (&rest args)
(apply #’make-instance ’hoge args))
(defgeneric copy-hoge (arg))
(defmethod copy-hoge ((arg hoge))
(let ((obj (make-instance (class-of arg))))
(dolist (slot (slots<=obj arg))
(if (slot-boundp arg slot)
(setf (slot-value obj slot) (slot-value arg slot)) (slot-makunbound obj slot)))
obj))
#+(or clisp sbcl)
(defun hoge-p (arg) (typep arg ’hoge))
#-(or clisp sbcl)
(defgeneric hoge-p (arg))
#-(or clisp sbcl)
(defmethod hoge-p ((arg hoge)) arg)
#-(or clisp sbcl)
(defmethod hoge-p (arg)
(declare (ignore arg))
nil)
’hoge)
“‘
Same above.

“‘lisp
#?(defstruct* (hoge (:conc-name)) bar)
:expanded-to (progn (defclass hoge ()
((bar :initform nil :initarg :bar :accessor bar))) ; <— This! (defun make-hoge (&rest args)
(apply #’make-instance ’hoge args))
(defgeneric copy-hoge (arg))
(defmethod copy-hoge ((arg hoge))
(let ((obj (make-instance (class-of arg))))
(dolist (slot (slots<=obj arg))
(if (slot-boundp arg slot)
(setf (slot-value obj slot) (slot-value arg slot)) (slot-makunbound obj slot)))
obj))
#+(or clisp sbcl)
(defun hoge-p (arg) (typep arg ’hoge))
#-(or clisp sbcl)
(defgeneric hoge-p (arg))
#-(or clisp sbcl)
(defmethod hoge-p ((arg hoge)) arg)
#-(or clisp sbcl)
(defmethod hoge-p (arg)
(declare (ignore arg))
nil)
’hoge)
“‘
Specify alternative.

“‘lisp
#?(defstruct* (hoge (:conc-name hoge-)) ; <— Specify
bar)
:expanded-to (progn (defclass hoge ()
((bar :initform nil :initarg :bar :accessor hoge-bar))) ; <— This! (defun make-hoge (&rest args)
(apply #’make-instance ’hoge args))
(defgeneric copy-hoge (arg))
(defmethod copy-hoge ((arg hoge))
(let ((obj (make-instance (class-of arg))))
(dolist (slot (slots<=obj arg))
(if (slot-boundp arg slot)
(setf (slot-value obj slot) (slot-value arg slot)) (slot-makunbound obj slot)))
obj))
#+(or clisp sbcl)
(defun hoge-p (arg) (typep arg ’hoge))
#-(or clisp sbcl)
(defgeneric hoge-p (arg))
#-(or clisp sbcl)
(defmethod hoge-p ((arg hoge)) arg)
#-(or clisp sbcl)
(defmethod hoge-p (arg)
(declare (ignore arg))
nil)
’hoge)
“‘
Can use string-designator.

“‘lisp
#?(defstruct* (hoge (:conc-name "hoge-")) ; <— use string.
bar)
:expanded-to (progn (defclass hoge ()
((bar :initform nil :initarg :bar :accessor |hoge-BAR|))) ; <— This! (defun make-hoge (&rest args)
(apply #’make-instance ’hoge args))
(defgeneric copy-hoge (arg))
(defmethod copy-hoge ((arg hoge))
(let ((obj (make-instance (class-of arg))))
(dolist (slot (slots<=obj arg))
(if (slot-boundp arg slot)
(setf (slot-value obj slot) (slot-value arg slot)) (slot-makunbound obj slot)))
obj))
#+(or clisp sbcl)
(defun hoge-p (arg) (typep arg ’hoge))
#-(or clisp sbcl)
(defgeneric hoge-p (arg))
#-(or clisp sbcl)
(defmethod hoge-p ((arg hoge)) arg)
#-(or clisp sbcl)
(defmethod hoge-p (arg)
(declare (ignore arg))
nil)
’hoge)
“‘
Examples of :constructor option.

“‘lisp
#?(defstruct* (hoge (:constructor make)) ; <— Specify.
bar)
:expanded-to (progn (defclass hoge ()
((bar :initform nil :initarg :bar :accessor hoge-bar)))
(defun make ; <— This!
(&rest args)
(apply #’make-instance ’hoge args))
(defgeneric copy-hoge (arg))
(defmethod copy-hoge ((arg hoge))
(let ((obj (make-instance (class-of arg))))
(dolist (slot (slots<=obj arg))
(if (slot-boundp arg slot)
(setf (slot-value obj slot) (slot-value arg slot)) (slot-makunbound obj slot)))
obj))
#+(or clisp sbcl)
(defun hoge-p (arg) (typep arg ’hoge))
#-(or clisp sbcl)
(defgeneric hoge-p (arg))
#-(or clisp sbcl)
(defmethod hoge-p ((arg hoge)) arg)
#-(or clisp sbcl)
(defmethod hoge-p (arg)
(declare (ignore arg))
nil)
’hoge)
“‘

“‘lisp
#?(defstruct* (hoge (:constructor)) ; <— No arg means use default. bar)
:expanded-to (progn (defclass hoge ()
((bar :initform nil :initarg :bar :accessor hoge-bar)))
(defun make-hoge ; <— This!
(&rest args)
(apply #’make-instance ’hoge args))
(defgeneric copy-hoge (arg))
(defmethod copy-hoge ((arg hoge))
(let ((obj (make-instance (class-of arg))))
(dolist (slot (slots<=obj arg))
(if (slot-boundp arg slot)
(setf (slot-value obj slot) (slot-value arg slot)) (slot-makunbound obj slot)))
obj))
#+(or clisp sbcl)
(defun hoge-p (arg) (typep arg ’hoge))
#-(or clisp sbcl)
(defgeneric hoge-p (arg))
#-(or clisp sbcl)
(defmethod hoge-p ((arg hoge)) arg)
#-(or clisp sbcl)
(defmethod hoge-p (arg)
(declare (ignore arg))
nil)
’hoge)
“‘

“‘lisp
#?(defstruct* (hoge (:constructor create-hoge
(a &optional b (c ’sea) &rest d &aux e (f ’eff))))
a b c d e f)
:expanded-to (progn (defclass hoge ()
((a :initform nil :initarg :a :accessor hoge-a)
(b :initform nil :initarg :b :accessor hoge-b)
(c :initform nil :initarg :c :accessor hoge-c)
(d :initform nil :initarg :d :accessor hoge-d)
(e :initform nil :initarg :e :accessor hoge-e)
(f :initform nil :initarg :f :accessor hoge-f)))
;; This!
(defun create-hoge (a &optional b (c ’sea) &rest d &aux e (f ’eff)) (make-instance ’hoge :a a :b b :c c :d d :e e :f f))
(defgeneric copy-hoge (arg))
(defmethod copy-hoge ((arg hoge))
(let ((obj (make-instance (class-of arg))))
(dolist (slot (slots<=obj arg))
(if (slot-boundp arg slot)
(setf (slot-value obj slot) (slot-value arg slot)) (slot-makunbound obj slot)))
obj))
#+(or clisp sbcl)
(defun hoge-p (arg) (typep arg ’hoge))
#-(or clisp sbcl)
(defgeneric hoge-p (arg))
#-(or clisp sbcl)
(defmethod hoge-p ((arg hoge)) arg)
#-(or clisp sbcl)
(defmethod hoge-p (arg)
(declare (ignore arg))
nil)
’hoge)
“‘
Examples of :copier option.

“‘lisp
#?(defstruct* (hoge (:copier nil)) ; specify nil.
bar)
:expanded-to (progn (defclass hoge ()
((bar :initform nil :initarg :bar :accessor hoge-bar)))
(defun make-hoge (&rest args)
(apply #’make-instance ’hoge args))
;; No cpier!
#+(or clisp sbcl)
(defun hoge-p (arg) (typep arg ’hoge))
#-(or clisp sbcl)
(defgeneric hoge-p (arg))
#-(or clisp sbcl)
(defmethod hoge-p ((arg hoge)) arg)
#-(or clisp sbcl)
(defmethod hoge-p (arg)
(declare (ignore arg))
nil)
’hoge)
“‘

“‘lisp
#?(defstruct* (hoge (:copier hoge)) ; specify name.
bar)
:expanded-to (progn (defclass hoge ()
((bar :initform nil :initarg :bar :accessor hoge-bar)))
(defun make-hoge (&rest args)
(apply #’make-instance ’hoge args))
;; This!
(defgeneric hoge (arg))
;; Also!
(defmethod hoge ((arg hoge))
(let ((obj (make-instance (class-of arg))))
(dolist (slot (slots<=obj arg))
(if (slot-boundp arg slot)
(setf (slot-value obj slot) (slot-value arg slot)) (slot-makunbound obj slot)))
obj))
#+(or clisp sbcl)
(defun hoge-p (arg) (typep arg ’hoge))
#-(or clisp sbcl)
(defgeneric hoge-p (arg))
#-(or clisp sbcl)
(defmethod hoge-p ((arg hoge)) arg)
#-(or clisp sbcl)
(defmethod hoge-p (arg)
(declare (ignore arg))
nil)
’hoge)
“‘
Examples of :include option.

“‘lisp
#?(defstruct* (hoge (:include foo)) fuga)
:expanded-to (progn (defclass hoge (foo) ; <— This!
((fuga :initform nil :initarg :fuga :accessor hoge-fuga)))
(defun make-hoge (&rest args)
(apply #’make-instance ’hoge args))
(defgeneric copy-hoge (arg))
(defmethod copy-hoge ((arg hoge))
(let ((obj (make-instance (class-of arg))))
(dolist (slot (slots<=obj arg))
(if (slot-boundp arg slot)
(setf (slot-value obj slot) (slot-value arg slot)) (slot-makunbound obj slot)))
obj))
#+(or clisp sbcl)
(defun hoge-p (arg) (typep arg ’hoge))
#-(or clisp sbcl)
(defgeneric hoge-p (arg))
#-(or clisp sbcl)
(defmethod hoge-p ((arg hoge)) arg)
#-(or clisp sbcl)
(defmethod hoge-p (arg)
(declare (ignore arg))
nil)
;; These!
(defgeneric hoge-bar (arg))
(defmethod hoge-bar ((arg hoge))
(foo-bar arg))
(defgeneric (setf hoge-bar) (new arg))
(defmethod (setf hoge-bar) (new (arg hoge))
(setf (foo-bar arg) new))
’hoge)
“‘
Some :include options are valid.
Lets say another object bazz.

“‘lisp
#?(defstruct* bazz
(piyo 0 :read-only t))
=> BAZZ
, :lazy
“‘

“‘lisp
#?(defstruct* (hoge (:include foo)
(:include bazz)) ; <— This!
fuga)
:expanded-to (progn (defclass hoge (foo bazz) ; <— This!
((fuga :initform nil :initarg :fuga :accessor hoge-fuga)))
(defun make-hoge (&rest args)
(apply #’make-instance ’hoge args))
(defgeneric copy-hoge (arg))
(defmethod copy-hoge ((arg hoge))
(let ((obj (make-instance (class-of arg))))
(dolist (slot (slots<=obj arg))
(if (slot-boundp arg slot)
(setf (slot-value obj slot) (slot-value arg slot)) (slot-makunbound obj slot)))
obj))
#+(or clisp sbcl)
(defun hoge-p (arg) (typep arg ’hoge))
#-(or clisp sbcl)
(defgeneric hoge-p (arg))
#-(or clisp sbcl)
(defmethod hoge-p ((arg hoge)) arg)
#-(or clisp sbcl)
(defmethod hoge-p (arg)
(declare (ignore arg))
nil)
;; These!
(defgeneric hoge-bar (arg))
(defmethod hoge-bar ((arg hoge))
(foo-bar arg))
(defgeneric (setf hoge-bar) (new arg))
(defmethod (setf hoge-bar) (new (arg hoge))
(setf (foo-bar arg) new))
(defgeneric hoge-piyo (arg))
(defmethod hoge-piyo ((arg hoge))
(bazz-piyo arg))
’hoge)
“‘
Slot description example.

“‘lisp
#?(defstruct* (hoge (:include foo (bar 0)))
fuga)
:expanded-to (progn (defclass hoge (foo)
((fuga :initform nil :initarg :fuga :accessor hoge-fuga)) (:default-initargs :bar 0)) ; <— This!
(defun make-hoge (&rest args)
(apply #’make-instance ’hoge args))
(defgeneric copy-hoge (arg))
(defmethod copy-hoge ((arg hoge))
(let ((obj (make-instance (class-of arg))))
(dolist (slot (slots<=obj arg))
(if (slot-boundp arg slot)
(setf (slot-value obj slot) (slot-value arg slot)) (slot-makunbound obj slot)))
obj))
#+(or clisp sbcl)
(defun hoge-p (arg) (typep arg ’hoge))
#-(or clisp sbcl)
(defgeneric hoge-p (arg))
#-(or clisp sbcl)
(defmethod hoge-p ((arg hoge)) arg)
#-(or clisp sbcl)
(defmethod hoge-p (arg)
(declare (ignore arg))
nil)
(defgeneric hoge-bar (arg))
(defmethod hoge-bar ((arg hoge))
(foo-bar arg))
(defgeneric (setf hoge-bar) (new arg))
(defmethod (setf hoge-bar) (new (arg hoge))
(setf (foo-bar arg) new))
’hoge)
“‘
Examples of :predicate option.

“‘lisp
#?(defstruct* (hoge (:predicate nil)) ; specify nil.
bar)
:expanded-to (progn (defclass hoge ()
((bar :initform nil :initarg :bar :accessor hoge-bar)))
(defun make-hoge (&rest args)
(apply #’make-instance ’hoge args))
(defgeneric copy-hoge (arg))
(defmethod copy-hoge ((arg hoge))
(let ((obj (make-instance (class-of arg))))
(dolist (slot (slots<=obj arg))
(if (slot-boundp arg slot)
(setf (slot-value obj slot) (slot-value arg slot)) (slot-makunbound obj slot)))
obj))
;; No predicate!
’hoge)
“‘

“‘lisp
#?(defstruct* (hoge (:predicate hoge)) ; specify name.
bar)
:expanded-to (progn (defclass hoge ()
((bar :initform nil :initarg :bar :accessor hoge-bar)))
(defun make-hoge (&rest args)
(apply #’make-instance ’hoge args))
(defgeneric copy-hoge (arg))
(defmethod copy-hoge ((arg hoge))
(let ((obj (make-instance (class-of arg))))
(dolist (slot (slots<=obj arg))
(if (slot-boundp arg slot)
(setf (slot-value obj slot) (slot-value arg slot)) (slot-makunbound obj slot)))
obj))
;; This!
#+(or clisp sbcl)
(defun hoge (arg) (typep arg ’hoge))
#-(or clisp sbcl)
(defgeneric hoge (arg))
#-(or clisp sbcl)
(defmethod hoge ((arg hoge)) arg)
#-(or clisp sbcl)
(defmethod hoge (arg)
(declare (ignore arg))
nil)
’hoge)
“‘
:print-function

“‘lisp
#?(defstruct* (hoge (:print-function printer)) ; <— specify
bar)
:expanded-to (progn (defclass hoge ()
((bar :initform nil :initarg :bar :accessor hoge-bar)))
(defun make-hoge (&rest args)
(apply #’make-instance ’hoge args))
;; This!
(defmethod print-object ((obj hoge) stream)
(printer obj stream *print-level*))
(defgeneric copy-hoge (arg))
(defmethod copy-hoge ((arg hoge))
(let ((obj (make-instance (class-of arg))))
(dolist (slot (slots<=obj arg))
(if (slot-boundp arg slot)
(setf (slot-value obj slot) (slot-value arg slot)) (slot-makunbound obj slot)))
obj))
#+(or clisp sbcl)
(defun hoge-p (arg) (typep arg ’hoge))
#-(or clisp sbcl)
(defgeneric hoge-p (arg))
#-(or clisp sbcl)
(defmethod hoge-p ((arg hoge)) arg)
#-(or clisp sbcl)
(defmethod hoge-p (arg)
(declare (ignore arg))
nil)
’hoge)
“‘
:print-object

“‘lisp
#?(defstruct* (hoge (:print-object printer)) ; <— specify
bar)
:expanded-to (progn (defclass hoge ()
((bar :initform nil :initarg :bar :accessor hoge-bar)))
(defun make-hoge (&rest args)
(apply #’make-instance ’hoge args))
;; This!
(defmethod print-object ((obj hoge) stream)
(printer obj stream))
(defgeneric copy-hoge (arg))
(defmethod copy-hoge ((arg hoge))
(let ((obj (make-instance (class-of arg))))
(dolist (slot (slots<=obj arg))
(if (slot-boundp arg slot)
(setf (slot-value obj slot) (slot-value arg slot)) (slot-makunbound obj slot)))
obj))
#+(or clisp sbcl)
(defun hoge-p (arg) (typep arg ’hoge))
#-(or clisp sbcl)
(defgeneric hoge-p (arg))
#-(or clisp sbcl)
(defmethod hoge-p ((arg hoge)) arg)
#-(or clisp sbcl)
(defmethod hoge-p (arg)
(declare (ignore arg))
nil)
’hoge)
“‘

Package

structure-ext.as-class.

Source

as-class.lisp.

---

5.1.2 Conditions

Condition: missing-symbol ¶

# MISSING-SYMBOL

## Description:

## Class Precedence List: (case in SBCL)
missing-symbol simple-error simple-condition program-error error serious-condition condition slot-object t

## Effective Slots:
FORMAT-CONTROL [Type] T
[READER] simple-condition-format-control
FORMAT-ARGUMENTS [Type] T
[READER] simple-condition-format-arguments

## Notes:

Package

structure-ext.left-arrow-accessors.

Source

left-arrow-accessors.lisp.

Direct superclasses

• program-error.
• simple-error.

---

5.2.1 Ordinary functions

Function: accessors (type slots) ¶

Package

structure-ext.left-arrow-accessors.

Source

left-arrow-accessors.lisp.

Function: accessors (name options) ¶

Package

structure-ext.as-class.

Source

as-class.lisp.

Function: check (options) ¶

Package

structure-ext.as-class.

Source

as-class.lisp.

Function: collect-option (option options) ¶

Package

structure-ext.as-class.

Source

as-class.lisp.

Function: conc-name (options class-name) ¶

Package

structure-ext.as-class.

Source

as-class.lisp.

Function: constructors (name options) ¶

Package

structure-ext.as-class.

Source

as-class.lisp.

Function: copier (name options) ¶

Package

structure-ext.as-class.

Source

as-class.lisp.

Function: enslot (slot conc-name) ¶

Package

structure-ext.as-class.

Source

as-class.lisp.

Function: left-arrow-names (type slots) ¶

Package

structure-ext.left-arrow-accessors.

Source

left-arrow-accessors.lisp.

Function: may-documentation (doc) ¶

Package

structure-ext.as-class.

Source

as-class.lisp.

Function: may-generic (method &optional lambda-list) ¶

Package

structure-ext.as-class.

Source

as-class.lisp.

Function: may-initargs (options) ¶

Package

structure-ext.as-class.

Source

as-class.lisp.

Function: method-name (conc-name slot-name) ¶

Package

structure-ext.as-class.

Source

as-class.lisp.

Function: parse (body) ¶

Package

structure-ext.as-class.

Source

as-class.lisp.

Function: predicate (name options) ¶

Package

structure-ext.as-class.

Source

as-class.lisp.

Function: print-function (name options) ¶

Package

structure-ext.as-class.

Source

as-class.lisp.

Function: slots (slots options class-name) ¶

Package

structure-ext.as-class.

Source

as-class.lisp.

Function: slots<=obj (obj) ¶

Package

structure-ext.as-class.

Source

as-class.lisp.

Function: super-classes (options) ¶

Package

structure-ext.as-class.

Source

as-class.lisp.

Function: the-defun-forms (left-arrow-names accessors) ¶

Package

structure-ext.left-arrow-accessors.

Source

left-arrow-accessors.lisp.

Function: the-setf-forms (left-arrow-names accessors) ¶

Package

structure-ext.left-arrow-accessors.

Source

left-arrow-accessors.lisp.

---