These functions perform operations on lists that represent sets of
elements. All these functions (unless otherwise specified) default to
using `eql`

as the test function, but that can be modified by the
`:test`

parameter.

- 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`

.`item``list`:test 'equal)

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`.