v1.4.3

The most important change for v1.4.3 is that I have added a bunch of inline declarations which (koff koff) I should have added years ago. They improve performance on one update-heavy micro-benchmark by some 20% (on SBCL).

Another useful improvement is that I have added methods to the Slime Swank inspector for the FSet types (most of them, at least). I made one unusual design choice here, which is that if a collection is larger than a threshold size, it shows you a block of elements in the middle, with buttons to go either backward or forward. (Specifically, the buttons restrict the viewable range to the subrange above or below the displayed block, with, again, only a block in the middle of that viewable range actually displayed.) This lets you use binary search to reach an arbitrary element in a logarithmic number of clicks. I think this is greatly superior to always starting at the beginning and only showing you one more block per click, but others may find it a little odd at first. Let me know what you think.

If you use a different inspector and you want methods for that too, feel free to contribute them 😸 (Back in 2014, Camille Troillard contributed methods for the LispWorks inspector, but I haven't tried them myself.)

There's a new GMap result type map-to-sets, inspired by collate in this blog post. It can now be written functionally as:

(defun collate (items &key (key #'identity))
  (gmap (:result map-to-sets)
        (fn (item) (values (funcall key item) item))
        (:arg list items)))

Finally, I've added methods to support functional update on small lists. For instance:

> (defparameter *x* '(42 17 73))
> (defparameter *y* *x*)
> (incf (@ *x* 'second))
(42 18 73)
> *y*
(42 17 73)

These are methods on lookup and with, e.g.:

(defmethod lookup ((ls list) (key (eql 'first))) ...)
(defmethod with ((ls list) (key (eql 'first)) val) ...)