Peter Siebel - Practical Common Lisp

(make-array 5 :fill-pointer 0 :adjustable t :element-type 'character) ""

Bit vectors—vectors whose elements are all zeros or ones—also get some special treatment. They have a special read/print syntax that looks like #*00001111and a fairly large library of functions, which I won't discuss, for performing bit-twiddling operations such as "anding" together two bit arrays. The type descriptor to pass as the :element-typeto create a bit vector is the symbol BIT .

As mentioned earlier, vectors and lists are the two concrete subtypes of the abstract type sequence . All the functions I'll discuss in the next few sections are sequence functions; in addition to being applicable to vectors—both general and specialized—they can also be used with lists.

The two most basic sequence functions are LENGTH , which returns the length of a sequence, and ELT , which allows you to access individual elements via an integer index. LENGTH takes a sequence as its only argument and returns the number of elements it contains. For vectors with a fill pointer, this will be the value of the fill pointer. ELT , short for element , takes a sequence and an integer index between zero (inclusive) and the length of the sequence (exclusive) and returns the corresponding element. ELT will signal an error if the index is out of bounds. Like LENGTH , ELT treats a vector with a fill pointer as having the length specified by the fill pointer.

(defparameter *x* (vector 1 2 3))

(length *x*) ==> 3

(elt *x* 0) ==> 1

(elt *x* 1) ==> 2

(elt *x* 2) ==> 3

(elt *x* 3) ==> error

ELT is also a SETF able place, so you can set the value of a particular element like this:

(setf (elt *x* 0) 10)

*x* ==> #(10 2 3)

While in theory all operations on sequences boil down to some combination of LENGTH , ELT , and SETF of ELT operations, Common Lisp provides a large library of sequence functions.

One group of sequence functions allows you to express certain operations on sequences such as finding or filtering specific elements without writing explicit loops. Table 11-1 summarizes them.

Table 11-1.Basic Sequence Functions

Here are some simple examples of how to use these functions:

(count 1 #(1 2 1 2 3 1 2 3 4)) ==> 3

(remove 1 #(1 2 1 2 3 1 2 3 4)) ==> #(2 2 3 2 3 4)

(remove 1 '(1 2 1 2 3 1 2 3 4)) ==> (2 2 3 2 3 4)

(remove #\a "foobarbaz") ==> "foobrbz"

(substitute 10 1 #(1 2 1 2 3 1 2 3 4)) ==> #(10 2 10 2 3 10 2 3 4)

(substitute 10 1 '(1 2 1 2 3 1 2 3 4)) ==> (10 2 10 2 3 10 2 3 4)

(substitute #\x #\b "foobarbaz") ==> "fooxarxaz"

(find 1 #(1 2 1 2 3 1 2 3 4)) ==> 1

(find 10 #(1 2 1 2 3 1 2 3 4)) ==> NIL

(position 1 #(1 2 1 2 3 1 2 3 4)) ==> 0

Note how REMOVE and SUBSTITUTE always return a sequence of the same type as their sequence argument.

You can modify the behavior of these five functions in a variety of ways using keyword arguments. For instance, these functions, by default, look for elements in the sequence that are the same object as the item argument. You can change this in two ways: First, you can use the :testkeyword to pass a function that accepts two arguments and returns a boolean. If provided, it will be used to compare item to each element instead of the default object equality test, EQL . [123] Another parameter, :test-not parameter, specifies a two-argument predicate to be used like a :test argument except with the boolean result logically reversed. This parameter is deprecated, however, in preference for using the COMPLEMENT function. COMPLEMENT takes a function argu-ment and returns a function that takes the same number of arguments as the original and returns the logical complement of the original function. Thus, you can, and should, write this: (count x sequence :test (complement #'some-test)) rather than the following: (count x sequence :test-not #'some-test) Second, with the :keykeyword you can pass a one-argument function to be called on each element of the sequence to extract a key value, which will then be compared to the item in the place of the element itself. Note, however, that functions such as FIND that return elements of the sequence continue to return the actual element, not just the extracted key.

(count "foo" #("foo" "bar" "baz") :test #'string=) ==> 1

(find 'c #((a 10) (b 20) (c 30) (d 40)) :key #'first) ==> (C 30)

To limit the effects of these functions to a particular subsequence of the sequence argument, you can provide bounding indices with :startand :endarguments. Passing NIL for :endor omitting it is the same as specifying the length of the sequence. [124] Note, however, that the effect of :start and :end on REMOVE and SUBSTITUTE is only to limit the elements they consider for removal or substitution; elements before :start and after :end will be passed through untouched.

If a non- NIL:from-endargument is provided, then the elements of the sequence will be examined in reverse order. By itself :from-endcan affect the results of only FIND and POSITION . For instance:

(find 'a #((a 10) (b 20) (a 30) (b 40)) :key #'first) ==> (A 10)

(find 'a #((a 10) (b 20) (a 30) (b 40)) :key #'first :from-end t) ==> (A 30)

However, the :from-endargument can affect REMOVE and SUBSTITUTE in conjunction with another keyword parameter, :count, that's used to specify how many elements to remove or substitute. If you specify a :countlower than the number of matching elements, then it obviously matters which end you start from:

(remove #\a "foobarbaz" :count 1) ==> "foobrbaz"

(remove #\a "foobarbaz" :count 1 :from-end t) ==> "foobarbz"