▼ |  | Unstable

1 | Guidelines for developing unstable libraries
2 | Bytes
3 | Classes and Objects
4 | Contracts
5 | Definitions
6 | Dictionaries
7 | Directories
8 | Exceptions
9 | Filesystem
10 | Functions
11 | Lists
12 | Net
13 | Path
14 | PLane T Packages
15 | Ports
16 | Pretty-Printing
17 | Regular Expressions
18 | Requiring Modules
19 | Sandboxed Evaluation
20 | Scribble Documentation
21 | Sets
22 | S-Expression Diff
23 | Source Locations
24 | Strings
25 | Structs
26 | Syntax
27 | Planet Package Macros
28 | Text Representations
29 | Multiple Values
30 | XML and CSS
31 | Polymorphic Contracts
32 | Finding Mutated Variables
33 | Find
34 | Interface-Oriented Programming for Classes
35 | Sequences
36 | Hash Tables
37 | Match
38 | Generics
39 | Mark Parameters
40 | Debugging
41 | Contracts for macro subexpressions
42 | Contracts for struct type properties
43 | GUI libraries

On this page:

find
find-first

Version: 5.0.2
top ← prev up next →

### 33`` Find

Ryan Culpepper <ryanc@racket-lang.org>

( require unstable/find )

This library is unstable; compatibility will not be maintained. See Unstable for more information.

( find |  | pred |  |  |  |
|  | x |  |  |  |
| [ | #:stop-on-found? stop-on-found? |  |  |  |
|  | #:stop stop |  |  |  |
|  | #:get-children get-children]) |  | → |  | list?

pred : ( -> any/c any/c )
x : any/c
stop-on-found? : any/c = #f
stop : ( or/c #f ( -> any/c any/c )) = #f
get-children : ( or/c #f ( -> any/c ( or/c #f list? ))) = #f

Returns a list of all values satisfying pred contained in x (possibly including x itself).

If stop-on-found? is true, the children of values satisfying pred are not examined. If stop is a procedure, then the children of values for which stop returns true are not examined (but the values themselves are; stop is applied after pred). Only the current branch of the search is stopped, not the whole search.

The search recurs through pairs, vectors, boxes, and the accessible fields of structures. If get-children is a procedure, it can override the default notion of a value’s children by returning a list (if it returns false, the default notion of children is used).

No cycle detection is done, so find on a cyclic graph may diverge. To do cycle checking yourself, use stop and a mutable table.

Examples:
> ( find symbol? '((all work) and (no play)))
'(all work and no play)
> ( find list? '#((all work) and (no play)) #:stop-on-found? #t)
'((all work) (no play))

> ( find negative? 100
#:stop-on-found? #t
#:get-children ( lambda (n) ( list ( - n 12))))

'(-8)

> ( find symbol? ( shared ([x ( cons 'a x)]) x)
#:stop ( let ([table ( make-hasheq )])
( lambda (x)
( begin0 ( hash-ref table x #f)
( hash-set! table x #t)))))

'(a)

( find-first |  | pred |  |  |  |
|  | x |  |  |  |
| [ | #:stop stop |  |  |  |
|  | #:get-children get-children |  |  |  |
|  | #:default default]) |  | → |  | any/c

pred : ( -> any/c any/c )
x : any/c
stop : ( or/c #f ( -> any/c any/c )) = #f
get-children : ( or/c #f ( -> any/c ( or/c #f list? ))) = #f
default : any/c = ( lambda () ( error ....))

Like find, but only returns the first match. If no matches are found, default is applied as a thunk if it is a procedure or returned otherwise.

Examples:
> ( find-first symbol? '((all work) and (no play)))
'all
> ( find-first list? '#((all work) and (no play)))
'(all work)

> ( find-first negative? 100
#:get-children ( lambda (n) ( list ( - n 12))))

-8
> ( find-first symbol? ( shared ([x ( cons 'a x)]) x))
'a

top ← prev up next →