Next: Association Lists, Previous: Substitution of Expressions, Up: Lists [Contents][Index]

These functions perform operations on lists that represent sets of elements.

- Function:
**cl-member***item list*`&key :test :test-not :key` This function searches

`list`for an element matching`item`. If a match is found, it returns the cons cell whose CAR was the matching element. Otherwise, it returns`nil`

. Elements are compared by`eql`

by default; you can use the`:test`

,`:test-not`

, and`:key`

arguments to modify this behavior. See Sequences.The standard Emacs lisp function

`member`

uses`equal`

for comparisons; it is equivalent to`(cl-member`

. With no keyword arguments,`item``list`:test 'equal)`cl-member`

is equivalent to`memq`

.

The `cl-member-if`

and `cl-member-if-not`

functions
analogously search for elements that satisfy a given predicate.

- Function:
**cl-tailp***sublist list* This function returns

`t`

if`sublist`is a sublist of`list`, i.e., if`sublist`is`eql`

to`list`or to any of its CDRs.

- Function:
**cl-adjoin***item list*`&key :test :test-not :key` This function conses

`item`onto the front of`list`, like`(cons`

, but only if`item``list`)`item`is not already present on the list (as determined by`cl-member`

). If a`:key`

argument is specified, it is applied to`item`as well as to the elements of`list`during the search, on the reasoning that`item`is “about” to become part of the list.

- Function:
**cl-union***list1 list2*`&key :test :test-not :key` This function combines two lists that represent sets of items, returning a list that represents the union of those two sets. The resulting list contains all items that appear in

`list1`or`list2`, and no others. If an item appears in both`list1`and`list2`it is copied only once. If an item is duplicated in`list1`or`list2`, it is undefined whether or not that duplication will survive in the result list. The order of elements in the result list is also undefined.

- Function:
**cl-nunion***list1 list2*`&key :test :test-not :key` This is a destructive version of

`cl-union`

; rather than copying, it tries to reuse the storage of the argument lists if possible.

- Function:
**cl-intersection***list1 list2*`&key :test :test-not :key` This function computes the intersection of the sets represented by

`list1`and`list2`. It returns the list of items that appear in both`list1`and`list2`.

- Function:
**cl-nintersection***list1 list2*`&key :test :test-not :key` This is a destructive version of

`cl-intersection`

. It tries to reuse storage of`list1`rather than copying. It does*not*reuse the storage of`list2`.

- Function:
**cl-set-difference***list1 list2*`&key :test :test-not :key` This function computes the “set difference” of

`list1`and`list2`, i.e., the set of elements that appear in`list1`but*not*in`list2`.

- Function:
**cl-nset-difference***list1 list2*`&key :test :test-not :key` This is a destructive

`cl-set-difference`

, which will try to reuse`list1`if possible.

- Function:
**cl-set-exclusive-or***list1 list2*`&key :test :test-not :key` This function computes the “set exclusive or” of

`list1`and`list2`, i.e., the set of elements that appear in exactly one of`list1`and`list2`.

- Function:
**cl-nset-exclusive-or***list1 list2*`&key :test :test-not :key` This is a destructive

`cl-set-exclusive-or`

, which will try to reuse`list1`and`list2`if possible.

- Function:
**cl-subsetp***list1 list2*`&key :test :test-not :key` This function checks whether

`list1`represents a subset of`list2`, i.e., whether every element of`list1`also appears in`list2`.

Next: Association Lists, Previous: Substitution of Expressions, Up: Lists [Contents][Index]