Vector accumulators

This adds with-vector-accumulators to collecting.

Fix a typo in 10.5.0

v10.5.1

Bug fix to 10.5.0 (typo)

Some enhancements to collectors

There is now collector-empty-p and pop-collector: these enable collectors to be used as queues.

let-values: allow fallback cases

Previously let-values didn't allow cases which looked like plain let: now it does. There's no point in not allowing them and they might save indentation.

Utilities: symbolify

symbolify makes symbols from concatenated string designators. It avoids the nightmare of (make-symbol (concatenate 'string (symbol-name s) "-P")) and (intern (make-symbol (concatenate 'string (symbol-name s) "-P"))) which tends to pervade complicated macros.

object-accessors: named array element access

with-named-array-references provides a way of giving names to elements of an array. This is a substrate on which you can map 'structures' onto chunks of an array, which is useful for fast but readable floating-point code.

parse-docstring-body from the utilities is also now correct, or less incorrect.

let-values is better, process-declarations has a macro

let-values now avoids rebinding in sequential forms, which can avoid unused variables in cases like

(let*-values (((a b) ...)
              ((c d) (f a b)))
  ... don't use a and b ...)

process-declarations has a new processing-declaration-specifier macro which makes things a little nicer. It is still unstable. let-values uses process-declarations for its declaration processing now.

A possibly-unstable process-declarations hack

I'm just adding this now so other things can depend on it. The interface may be OK but I'm not sure.

let-values

let-values provides four let-style macros which work with multiple values.

• let-values and let*-values are like let and let* respectively
• let-values* and let*-values* have semantics like multiple-value-call: they take all the values from a number of initforms and use them, in parallel and sequentially respectively.

As an example of let-values*

> (let-values* (((a b c) (values 1 2) 3))
    (+ a b c))
6

---

There are also improvements to valid-type-specifier-p: it now works by checking that typep can't signal an error, which I think can't be evaded the way SBCL evades things with subtypep.

Utilities: valid-type-specifier-p

There's a function, valid-type-specifier-p which attempts (and perhaps actually does) answer the question 'is something a valid type specifier?'. It is as horrible as you would expect.