At the 2018 European Lisp Symposium, the most obviously actionable feedback for SBCL from a presentation was from Didier's remorseless deconstruction of SBCL's support for method combinations (along with the lack of explicitness about behavioural details in the ANSI CL specification and the Art of the Metaobject Protocol). I don't think that Didier meant to imply that SBCL was particularly bad at method combinations, compared with other available implementations – merely that SBCL was a convenient target. And, to be fair, there was a bug report from a discussion with Bruno Haible back in SBCL's history – May/June 2004, according to my search – which had languished largely unfixed for fourteen years.
I said that I found the Symposium energising.
And what better use to put that energy than addressing user feedback?
So, I spent a bit of time earlier this month thinking, fixing and
attempting to work out what behaviours might actually be useful. To
be clear, SBCL’s support for
define-method-combination was (probably)
standards-compliant in the usual case, but if you follow the links
from above, or listen to Didier’s talk, you will be aware that that’s
not saying all that much, in that almost nothing is specified about
behaviours under redefinition of method combinations.
So, to start with, I solved the cache invalidation (one of
hardest problems in Computer Science),
making sure that discriminating functions and effective methods are
reset and invalidated for all affected generic functions. This was
slightly complicated by the strategy that SBCL has of distinguishing
short and long
method-combinations with distinct classes (and distinct
but this just needed to be methodical and careful. Famous last words:
I think that all method-combination behaviour in SBCL is now coherent
and should meet user expectations.
More interesting, I think, was coming up with test cases for desired
behaviours. Method combinations are not, I think, widely used in
practice; whether that is because of lack of support, lack of
understanding or lack of need of what they provide, I don't know. (In
fact in conversations at ELS we discussed another possibility, which
is that everyone is more comfortable customising
compute-effective-method instead – both that and
define-method-combination provide ways for inserting arbitrary code
for the effect of a generic function call with particular arguments.
But what this means is that there isn’t, as far as I know at least, a
large corpus of interesting method combinations to play with.
One interesting one which came up:
implementation using method-combinations of finite state machines,
which I adapted to add to SBCL’s test suite. My version looks like:
(define-method-combination fsm (default-start) ((primary *)) (:arguments &key start) `(let ((state (or ,start ',default-start))) (restart-bind (,@(mapcar (lambda (m) `(,(first (method-qualifiers m)) (lambda () (setq state (call-method ,m)) (if (and (typep state '(and symbol (not null))) (find-restart state)) (invoke-restart state) state)))) primary)) (invoke-restart state))))
and there will be more on this use
restart-bind in a
later post, I hope. Staying on the topic of method combinations, how
might one use this
fsm method combination? A simple example might
be to recognize strings with an even number of
;;; first, define something to help with all string parsing (defclass info () ((string :initarg :string) (index :initform 0))) ;;; then the state machine itself (defgeneric even-as (info &key &allow-other-keys) (:method-combination fsm :yes)) (defmethod even-as :yes (info &key) (with-slots ((s string) (i index)) info (cond ((= i (length s)) t) ((char= (char s i) #\a) (incf i) :no) (t (incf i) :yes)))) (defmethod even-as :no (info &key) (with-slots ((s string) (i index)) info (cond ((= i (length s)) nil) ((char= (char s i) #\a) (incf i) :yes) (t (incf i) :no))))
(Exercise for the reader: adapt this to implement a Turing Machine)
Another example of (I think) an interesting method combination was one which I came up with in the context of generalized specializers, for an ELS a while ago: the HTTP Request method-combination to be used with HTTP Accept specializers. I'm interested in more! A github search found some examples before I ran out of patience; do you have any examples?
And I have one further question. The method combination takes
arguments at generic-function definition time (the
(:method-combination fsm :yes)). Normally, arguments to things are
evaluated at the appropriate time. At the moment, SBCL (and indeed
all other implementations I tested, but that's not strong evidence
given the shared heritage) do not evaluate the arguments to
:method-combination – treating it more like a macro call than a
function call. I’m not sure that is the most helpful behaviour, but
I’m struggling to come up with an example where the other is
definitely better. Maybe something like
(let ((lock (make-lock))) (defgeneric foo (x) (:method-combination locked lock) (:method (x) ...)))
Which would allow automatic locking around the effective method of
FOO through the method combination? I need to think some more here.
In any case: the
method-combination fixes are in the current SBCL
master branch, shortly to be released as sbcl-1.4.8. And there is
still time (though not very much!) to apply for
many jobs advertised
Goldsmiths Computing –
what better things to do on a Bank Holiday weekend?