7.7
Predicates
| (require predicates) | package: predicates |
These functions allow for easy construction of predicates - functions that take an input and return a boolean - for use with contracts and filter variants. This library makes it easy to define predicates in a point-free style, meaning that you can construct new predicates in terms of old predicates without defining them as functions with arguments.
source code: https://github.com/jackfirth/predicates
1 Logic Predicate Constructors
Combines each pred into a single predicate that returns #t for its
if all the original preds return #t for the input.
Examples:
Combines each pred into a single predicate that returns #t for its
input if any of the original preds return #t for the input.
Examples:
Returns a new predicate that returns #t for its input if the original
predicate returns #f for the input.
Combines each pred into a single function that accepts any number of
arguments and returns #t if the first pred returns #t
for the first argument, and the second pred returns #t for the
second argument, and so on for each pred and each argument.
Examples:
Combines each pred into a single function in a manner similar to
and?*, except the resulting function returns #t if any of
the preds return #t for their argument.
Examples:
2 Comparison Predicate Constructors
Examples:
3 List Predicates
procedure
(nonempty-list? v) → boolean?
v : any?
Returns #t if v is a list containing at least one element, and returns
#f otherwise. Equivalent to (and? list? (not? null?)).
Examples:
> (nonempty-list? '(foo bar baz)) #t
> (nonempty-list? null) #f
> (nonempty-list? '()) #f
> (nonempty-list? 'foo) #f
procedure
(nonsingular-list? v) → boolean?
v : any?
Returns #t if v is a list containing at least two elements, and returns
#f otherwise. Equivalent to (and? list? (not? null?) (rest? (not? null?))).
Examples:
> (nonsingular-list? '(foo bar baz)) #t
> (nonsingular-list? '(foo)) #f
> (nonsingular-list? '()) #f
> (nonsingular-list? null) #f
> (nonsingular-list? 7) #f
procedure
n : exact-nonnegative-integer?
Returns a predicate that returns #t for any list with more than n
elements.
Examples:
procedure
n : exact-nonnegative-integer?
Returns a predicate that returns #t for any list with n elements.
Examples:
procedure
n : exact-nonnegative-integer?
Returns a predicate that returns #t for any list with fewer than n
elements.
Examples:
procedure
(first? pred ...+) → (-> nonempty-list? boolean?)
pred : (-> any? boolean?)
procedure
(second? pred ...+) → (-> (and? list? (length>? 1)) boolean?)
pred : (-> any? boolean?)
procedure
(third? pred ...+) → (-> (and? list? (length>? 2)) boolean?)
pred : (-> any? boolean?)
procedure
(fourth? pred ...+) → (-> (and? list? (length>? 3)) boolean?)
pred : (-> any? boolean?)
Returns a predicate that returns #t for any list whose first, second, third,
or fourth item satisfies (and? pred ...), depending on the procedure chosen.
Examples:
Examples:
Returns a predicate that returns #t for any list for which every element in
the list satisfies pred.
Examples:
Returns a predicate that returns #t for any value that is a list with one
element for each pred whose first element satisfies the first pred,
second element satisfies the second pred, and so on for each pred.
Examples:
procedure
(list-with-head? pred ...+) → (-> any? boolean?)
pred : (-> any? boolean?)
Similar to listof? but returns #t for lists with extra elements
Examples:
> (define starts-with-num-sym? (list-with-head? number? symbol?)) > (starts-with-num-sym? '(1 foo 2 3 4 5)) #t
> (starts-with-num-sym? '(1 foo)) #t
> (starts-with-num-sym? '(foo bar baz)) #f
> (starts-with-num-sym? '(1 2 3)) #f
> (starts-with-num-sym? '()) #f
> (starts-with-num-sym? 5) #f
4 Conditional Combinators
procedure
(if? pred f [g]) → (-> any? any?)
pred : (-> any? boolean?) f : (-> any? any?) g : (-> any? any?) = identity
Examples:
Examples:
Examples:
Returns a function that, for an input v, returns just v if (p v)
is false, otherwise it recursively calls itself with (f v).
Examples:
Examples:
Like while? except that f is guaranteed to be called at least once.
Similar to the relationship between while and do ... while loops in
imperative languages. Equivalent to (compose (while? p f) f).
Examples:
Examples:
5 Miscellaneous
Returns #t if v is not #f, and #f otherwise.
Useful to turn "truthy" functions into predicates that only return #t
or #f.
procedure
(without-truthiness f) → proc?
f : proc?
Returns a procedure that’s like f, but returns either #t or
#f based on whether f returns false. Essentially, this procedure
turns functions that rely on returning "truthy" values into function that only
return a boolean.
Examples:
> (define member? (without-truthiness member)) > (member? 1 '(1 2 3)) #t
> (member? 'foo '(1 2 3)) #f
Returns a predicate that determins in its input is a real number between low
and high. If exclusive? is #t, then values = to
low or high will return #f.