Warning:This is the manual of the legacy Guile2.0series. You may want to read the manual of the current stable series instead.

Next: SRFI-1 Deleting, Previous: SRFI-1 Filtering and Partitioning, Up: SRFI-1 [Contents][Index]

The procedures for searching elements in lists either accept a predicate or a comparison object for determining which elements are to be searched.

- Scheme Procedure:
**find***pred lst* Return the first element of

`lst`which satisfies the predicate`pred`and`#f`

if no such element is found.

- Scheme Procedure:
**find-tail***pred lst* Return the first pair of

`lst`whose CAR satisfies the predicate`pred`and`#f`

if no such element is found.

- Scheme Procedure:
**take-while***pred lst* - Scheme Procedure:
**take-while!***pred lst* Return the longest initial prefix of

`lst`whose elements all satisfy the predicate`pred`.`take-while!`

is allowed, but not required to modify the input list while producing the result.

- Scheme Procedure:
**drop-while***pred lst* Drop the longest initial prefix of

`lst`whose elements all satisfy the predicate`pred`.

- Scheme Procedure:
**span***pred lst* - Scheme Procedure:
**span!***pred lst* - Scheme Procedure:
**break***pred lst* - Scheme Procedure:
**break!***pred lst* `span`

splits the list`lst`into the longest initial prefix whose elements all satisfy the predicate`pred`, and the remaining tail.`break`

inverts the sense of the predicate.`span!`

and`break!`

are allowed, but not required to modify the structure of the input list`lst`in order to produce the result.Note that the name

`break`

conflicts with the`break`

binding established by`while`

(see while do). Applications wanting to use`break`

from within a`while`

loop will need to make a new define under a different name.

- Scheme Procedure:
**any***pred lst1 lst2 …* Test whether any set of elements from

`lst1``lst2`… satisfies`pred`. If so, the return value is the return value from the successful`pred`call, or if not, the return value is`#f`

.If there are n list arguments, then

`pred`must be a predicate taking n arguments. Each`pred`call is`(`

taking an element from each`pred``elem1``elem2`… )`lst`. The calls are made successively for the first, second, etc. elements of the lists, stopping when`pred`returns non-`#f`

, or when the end of the shortest list is reached.The

`pred`call on the last set of elements (i.e., when the end of the shortest list has been reached), if that point is reached, is a tail call.

- Scheme Procedure:
**every***pred lst1 lst2 …* Test whether every set of elements from

`lst1``lst2`… satisfies`pred`. If so, the return value is the return from the final`pred`call, or if not, the return value is`#f`

.If there are n list arguments, then

`pred`must be a predicate taking n arguments. Each`pred`call is`(`

taking an element from each`pred``elem1``elem2 …`)`lst`. The calls are made successively for the first, second, etc. elements of the lists, stopping if`pred`returns`#f`

, or when the end of any of the lists is reached.The

`pred`call on the last set of elements (i.e., when the end of the shortest list has been reached) is a tail call.If one of

`lst1``lst2`…is empty then no calls to`pred`are made, and the return value is`#t`

.

- Scheme Procedure:
**list-index***pred lst1 lst2 …* Return the index of the first set of elements, one from each of

`lst1``lst2`…, which satisfies`pred`.`pred`is called as`(`

. Searching stops when the end of the shortest`elem1``elem2 …`)`lst`is reached. The return index starts from 0 for the first set of elements. If no set of elements pass, then the return value is`#f`

.(list-index odd? '(2 4 6 9)) ⇒ 3 (list-index = '(1 2 3) '(3 1 2)) ⇒ #f

- Scheme Procedure:
**member***x lst [=]* Return the first sublist of

`lst`whose CAR is equal to`x`. If`x`does not appear in`lst`, return`#f`

.Equality is determined by

`equal?`

, or by the equality predicate`=`if given.`=`is called`(=`

, ie. with the given`x`elem)`x`first, so for example to find the first element greater than 5,(member 5 '(3 5 1 7 2 9) <) ⇒ (7 2 9)

This version of

`member`

extends the core`member`

(see List Searching) by accepting an equality predicate.

Next: SRFI-1 Deleting, Previous: SRFI-1 Filtering and Partitioning, Up: SRFI-1 [Contents][Index]