On this page:
if/  c
failure-result/  c
maybe/  c
truth/  c
sequence/  c

4 Contracts

This library is unstable; compatibility will not be maintained. See Unstable: May Change Without Warning for more information.

 (require unstable/contract)
  package: unstable-contract-lib


(non-empty-string? x)  boolean?

  x : any/c
Returns #t if x is a string and is not empty; returns #f otherwise.

Equivalent to (between/c 1 65535).

Equivalent to (between/c 0 65535).

Equivalent to (or/c path-string? (symbols 'up 'same)).

The subsequent bindings were added by Ryan Culpepper.


(if/c predicate then-contract else-contract)  contract?

  predicate : (-> any/c any/c)
  then-contract : contract?
  else-contract : contract?
Produces a contract that, when applied to a value, first tests the value with predicate; if predicate returns true, the then-contract is applied; otherwise, the else-contract is applied. The resulting contract is a flat contract if both then-contract and else-contract are flat contracts.

For example, the following contract enforces that if a value is a procedure, it is a thunk; otherwise it can be any (non-procedure) value:
Note that the following contract is not equivalent:

(or/c (-> any) any/c) ; wrong!

The last contract is the same as any/c because or/c tries flat contracts before higher-order contracts.

A contract that describes the failure result arguments of procedures such as hash-ref.

Equivalent to (if/c procedure? (-> any) any/c).


(rename-contract contract name)  contract?

  contract : contract?
  name : any/c
Produces a contract that acts like contract but with the name name.

The resulting contract is a flat contract if contract is a flat contract.

The subsequent bindings were added by Asumu Takikawa.


(maybe/c contract)  contract?

  contract : contract?
Creates a contract that acts like contract but will also accept #f. Intended to describe situations where a failure or default value may be used.

The subsequent bindings were added by Carl Eastlund <cce@racket-lang.org>.

This contract recognizes Racket truth values, i.e., any value, but with a more informative name and description. Use it in negative positions for arguments that accept arbitrary truth values that may not be booleans.


(sequence/c [#:min-count min-count]    
  elem/c ...)  contract?
  min-count : (or/c #f exact-nonnegative-integer?) = #f
  elem/c : contract?
Wraps a sequence, obligating it to produce as many values as there are elem/c contracts, and obligating each value to satisfy the corresponding elem/c. The result is not guaranteed to be the same kind of sequence as the original value; for instance, a wrapped list is not guaranteed to satisfy list?.

If min-count is a number, the stream is required to have at least that many elements in it.


> (define/contract predicates
    (sequence/c (-> any/c boolean?))
    (in-list (list integer?
> (for ([P predicates])
    (printf "~s\n" (P "cat")))


predicates: broke its contract

  promised: boolean?

  produced: 'cat

  in: the range of

      an element of

      (sequence/c (-> any/c boolean?))

  contract from: (definition predicates)

  blaming: (definition predicates)

   (assuming the contract is correct)

  at: eval:2.0

> (define/contract numbers&strings
    (sequence/c number? string?)
    (in-dict (list (cons 1 "one")
                   (cons 2 "two")
                   (cons 3 'three))))
> (for ([(N S) numbers&strings])
    (printf "~s: ~a\n" N S))

1: one

2: two

numbers&strings: broke its contract

  promised: string?

  produced: 'three

  in: an element of

      (sequence/c number? string?)

  contract from: (definition numbers&strings)

  blaming: (definition numbers&strings)

   (assuming the contract is correct)

  at: eval:4.0

> (define/contract a-sequence
    (sequence/c #:min-count 2 char?)
> (for ([x a-sequence]
        [i (in-naturals)])
    (printf "~a is ~a\n" i x))

0 is x

a-sequence: broke its contract

  promised: a sequence that contains at least 2 values

  produced: "x"

  in: (sequence/c #:min-count 2 char?)

  contract from: (definition a-sequence)

  blaming: (definition a-sequence)

   (assuming the contract is correct)

  at: eval:6.0

The subsequent bindings were added by Neil Toronto <neil.toronto@gmail.com>.


(treeof elem-contract)  contract?

  elem-contract : contract?
Identifies values that meet the contract elem-contract, lists of such values, lists of lists, and so on.


> (define number-tree/c (treeof number?))
> (flat-contract? number-tree/c)


> (define number-tree? (flat-contract-predicate number-tree/c))
> (number-tree? 4)


> (number-tree? '(4 5))


> (number-tree? '((4 5) 6))


> (number-tree? '(4 . 5))