The documentation for a layered funcion is now stored with the caller function, not the definer function.

Ignore-this: 7003c025de6bf3b135524db4f119161b

darcs-hash:de43a9aad9530173b25b4ab2867c0e871bead677

Ignore-this: 8562c17c6a8cc5e34d542426d3f31b17

darcs-hash:0d1655a5d920bd2f3fb3f861aba369220830180f

Ignore-this: c649a8c5246a8d79221281e70dde41a9

darcs-hash:9edb559d7cb565632dd7a455e76fd317faaea52d

Ignore-this: ba6afbd48fe9eb50ae0daaf03c78429e

darcs-hash:8537414a78eacc9f8c720932f83fae5db0fabf62

Ignore-this: 102bc2ae6f5104111782b8d41bdf61b5

darcs-hash:452f830dca156293564f057dc0eda0ac1a595c00

Fixed and simplified conditionalization for Clozure Common Lisp (to fix clashes with MCL, and to remove mentions of OpenMCL).

Ignore-this: 426f149224ad727d57db847ae7bcc50e

darcs-hash:319e6083ba6e67524227c340717dca85671e52ea

Ignore-this: e194502be15d6dc9bb692a6f647ebaab

darcs-hash:225e9c7c65e65e9c86ae35c61c6291dc9b2c07a9

darcs-hash:9c46508407b208370692fa7b72fe4262d8bfa9d7

ensure-layered-method now accepts function designators instead of function names (due to Drew Crampsie).

darcs-hash:b99619dc4003a356c0af761c655ddcb748701be7

darcs-hash:e519579766c4bddbb88ba327d872f28e9fa45dae

Simplified mapping of layer-related names to internal names, which should also make things easier to read when debugging ContextL programs.

darcs-hash:1ef605b1748d8e95be7d9e33a12b10534ba82ed4

A specializer for a method may not be a class, so print the specializer metaobject instead of the class name.

darcs-hash:f66010be4134e7a8ad3b74714005463f18099017

darcs-hash:8edd57f0bc55028220ea4fff3452936b444a88e1

This version of ContextL (0.4) incorporates several minor and major changes as a preparation towards a 1.0 release. Here is a list of the changes:

--- Changes in the visible API ---

+ The functions activate-layer and activate-layer-using-class have been renamed to adjoin-layer and adjoin-layer-using-class, and deactivate-layer and deactivate-layer-using-class have been renamed to remove-layer and remove-layer-using-class. The new names reflect better what these functions actually do.

+ Removed the functions funcall-with-layers and apply-with-layers. Use the functions funcall-with-layer-context and apply-with-layer-context instead.

+ The deflayer macro doesn't take a :layer-class option anymore, but instead a :metaclass option. (I have tried to abstract from the internal representation as CLOS classes, but that turns out to be useless for the time being.)

--- Additions to the visible API ---

+ Added the functions funcall-with-layer-context and apply-with-layer-context.

+ Added the function current-layer-context. This captures the set of currently active layers, which can later be reinstalled with funcall-with-layer-context and apply-with-layer-context.

+ Added the metaclasses layered-function and layered-method. However, they should better not be used directly. For programmatically creating layered functions and methods, better use the functions ensure-layered-function and ensure-layered-method.

+ Added the readers layered-function-definer, layered-function-argument-precedence-order, layered-function-lambda-list.

+ Added the readers layered-method-lambda-list, layered-method-specializers, layered-method-layer.

+ Added the readers partial-class-defining-classes, partial-class-defining-metaclass and the class partial-object, which is the default superclass for partial classes.

+ Added the readers slot-definition-layered-readers and slot-definition-layered-writers.

+ You can now specify an :in-layer option in slot specifiers. This means that a slot within a define-layered-class form can be declared to be in a different layer than the respective class itself. This allows, for example, to group slots of different layers in the same define-layered-class form.

+ Layers and layered functions can now also have uninterned symbols as names. This enables a form of anonymous layers and anonymous layered functions when gensym is used to create names for them.

+ Added the function ensure-layer for programmatically creating layers.

--- Internal changes, which are not necessarily visible ---

+ If someone tries to define default initargs for singleton classes or layers, ContextL emits a warning. The error handling is improved for the case when the :allocation for a singleton or layer-specific slot is set to something else than :class.

+ Some of the :in-layer keyword parameters to internal functions have previously taken lists of layers for technical reasons. This is not the case anymore.

+ Changed the handling of the :defining-metaclass option for partial classes.

+ Layered direct slot definition metaobjects don't take :layered-reader, :layered-writer and :layered-accessor initargs anymore, but rather :layered-readers and :layered-writers, which is closer to how the CLOS MOP works as well.

+ Added methods for print-object for the major classes and metaclasses, such that, for example, debug output now prints more nicely.

darcs-hash:592a90c3f26522c79fcebd6c89449ae62c44dd41

darcs-hash:9307a74f3b41a2177e52ea2a32e13da463982d93

See related patch for Closer to MOP. The current version of ensure-method for SBCL doesn't understand the :method-class parameter (like most other CL implementations, btw).

darcs-hash:868f47d966e5fa821250130610e51ac14dd02d8c

darcs-hash:022ad895f7e702dddc5e3ffb1f122abae99b3f96

darcs-hash:67f578dda7facd0294b68c6b34b3d1160b8e0496

Added activate-layer-using-class and deactivate-layer-using-class for metacircular layer activation/deactivation.

darcs-hash:a8f2ff872a966c3ab926dff7e6c22c04ac495f96

darcs-hash:9d38c93fb54f993efee4f7b14d9041206f9873b6

Added a function call-next-layered-method as a more convenient way to perform a call-next-method with changed arguments.

darcs-hash:38caf6b80e7d60c68d97b352aa3b247f202b7d15

darcs-hash:a0536379f270f1b5ada600af01624f201fb4e67c

Removed function-name-p in cx-util and changed the function name test in cx-layered-function accordingly.

darcs-hash:2952e759930e29207dbdcb2db553acdd2eccb1ed

Layers and layer classes were somewhat mixed up until recently. (See also comments about singleton classes.) They are now more cleanly separated.

Note that previous uses of find-layer have to be replaced by calls to find-layer-class. The function find-layer has now a slightly different meaning - it returns the prototye instance for a layer, not its class anymore.

darcs-hash:f862d26e676edd3e41c48c4ac4179576fcbb449a

darcs-hash:4ae6bf6d5080b8cb955c11be2c565d9d527378ef

darcs-hash:ed72e1d97288da9ab697479af4beee97a1ca2b2a

darcs-hash:5a23dbc8fff86551cf265dd5ac656c17f205fa0d

Since the implementation of ensure-method in CMUCL's and SBCL's Closer to MOP implementation has changed, ContextL's ensure-layered-method cannot accept the :method-class option anymore. This restriction can hopefully be removed again in the future.

darcs-hash:fdbed68781214a79ef96b20287c8b9782b428e45

Before this change, layers were simply classes with the same name as given in the deflayer form. This potentially leads to name conflicts between classes and layers. Since Common Lisp favors multiple namespaces, I have changed this, so now layers reside in their own namespace. (They are still internally implemented as classes.)

darcs-hash:8d44351700472fed4f93f563cf8ebc48107a8d2c

The :method option in define-layered-function is now parsed correctly, similar to how define-layered-method is parsed and processed. Furthermore, one can now give a name to the otherwise gensymmed layer parameter for a layered method. This is useful when one wants to call call-next-method with changed parameters. In that case, the layer parameter must be passed explicitly. (That's not optimal, but the best workaround I can think of.)

Example:

(define-layered-method some-function :in-layer (layer some-layer) (&rest some-parameters)
  (apply #'call-next-method layer ... changed parameters ... some-parameters))

darcs-hash:fbf06d1eafa51057111a18e891026b4fba2160c3

darcs-hash:4cc8d597a6f4648ef2474770569de7d7a1814d40

Until now, methods for layered functions had to be defined like this:

(defmethod -function-name- ((layer some-layer) args ...)
  ...)

People found this confusing and inconsistent with the other defining macros, i.e. define-layered-class and define-layered-function. Furthermore, they didn't like the naming convention that layered functions are named like function-name, and their methods are named like -function-name- (i.e. with preceding and succeeding dashes). So this has been replaced, and now the methods for layered functions are defined like that:

(define-layered-method :in-layer some-layer (args ...)
  ...)

Note that the :in-layer declaration has to come before the qualifiers, if any.

Thanks to Bjoern Lindberg and Thomas F. Burdick for the concrete suggestions. Among other things, the new approach also has the advantage that the implementation of layered functions doesn't shine through.

darcs-hash:9b6cd3a532c1358572da6342ebd4f8391aeb4768

darcs-hash:ff9f06424ff8aa76528f8c3c9f67c9b9f5db3b37