My thanks to Jacek Generowicz, David Golden, and Eric Smith, whose questions provided a starting point for this FAQ file. Q: Is this fundamentally different? How is this fundamentally different from the list functionality provided by standard Common Lisp? If I use dolist, loop, the various kinds of map, etc., instead of your list comprehensions, am I missing something fundamental without understanding what I'm missing? Is there some kind of powerful idea in this, or is it more of a convenience for those who detest loop? A: Any iteration that can be expressed using the package can be expressed using other Lisp constructs. However, in many cases the package allows interations to be expressed in a more compact and readable form.I experimented with generalised list comprehensions because I wanted to find more powerful constructs for iteration etc. After all, if we don't care about expressiveness why do we bother with Lisp? Q: Why the extra parentheses? Taking the first example in your docs: (collect (list) ((* x x)) (in (x) '(1 2 3 4 5 6 7 8))) Is there a good reason for preferring this over (collect list (* x x) (in (x) '(1 2 3 4 5 6 7 8))) ? In other words, do the parentheses in ::= (nil) | (t) | (list) | (vector) and those in , serve any good purpose? A: If we are only interested in working with lists and (one-dimensional) arrays, the syntax you suggest is sufficient. However, if we want to collect the result in an array or a hash table, we want to say how the values associated with a particular key are to be collected. For example: * (collect (array (vector) (2)) ((mod x 2) x) (in (x) '(1 2 3 4 5 6))) gives the result #(#(2 4 6) #(1 3 5)) The collect expression generates a sequence of key-value pairs (the key given by (mod x 2)) and all values with the same key are collected in a vector. Q: Series stuff. Does this relate to the old SERIES stuff or is it something else? A (short): No. A (long): Richard Waters's series package defines a data type which is similar to a list or a vector in Common Lisp. A program using series resembles a conventional Lisp program operating on lists but can sometimes be much more efficient. In other words, the series package improves efficiency but does not affect expressiveness. My package has the opposite goal: I felt that the usual looping constructs were awkward, and that there should an easier way to do iteration. It might be a good idea to use the series package (or similar techniques) in the underlying implementation, though.