Social Contracts

8.2

top ← prev up next →

Social Contracts

Siddhartha Kasivajhula

Collectively-defined contracts for commonly encountered types.

procedure
(function/c) → contract?
(function/c source/c target/c) → contract?
source/c : contract?
target/c : contract?

A contract to recognize a simple function that maps values of type source/c to values of type target/c (i.e. a unary function). If target/c is expecting a value of the same type as source/c, prefer using self-map/c instead. If left unspecified, source/c and target/c assume any/c.

Examples:

> (define/contract (list-length lst)
    (function/c list? natural-number/c)
    (if (empty? lst)
      0
      (add1 (list-length (rest lst)))))
> (list-length '(h e l l o))
5
> (list-length "hello")
list-length: contract violation
  expected: list?
  given: "hello"
  in: the 1st argument of
      (-> (listof any/c) natural-number/c)
  contract from: (function list-length)
  blaming: program
   (assuming the contract is correct)
  at: eval:1:0

procedure
(self-map/c type/c) → contract?
type/c : contract?

A contract to recognize a self-map, i.e. a function that maps a value of type type/c to a value of the same type.

Examples:

> (define/contract (double n)
    (self-map/c natural-number/c)
    (* n 2))
> (double 5)
10
> (double "hello")
double: contract violation
  expected: natural-number/c
  given: "hello"
  in: the 1st argument of
      (-> natural-number/c natural-number/c)
  contract from: (function double)
  blaming: program
   (assuming the contract is correct)
  at: eval:4:0

procedure
(thunk/c [target/c]) → contract?
target/c : contract? = any/c

A contract to recognize a "thunk", i.e. a function taking no arguments, which returns a value of type target/c.

Examples:

> (define/contract (hello-button)
    (thunk/c string?)
    "hello!")
> (hello-button)
"hello!"
> (hello-button "friend")
hello-button: arity mismatch;
the expected number of arguments does not match the given
number
  expected: 0
  given: 1
  arguments...:
   "friend"
> (define/contract (hello-button)
    (thunk/c number?)
    "hello!")
> (hello-button)
hello-button: broke its own contract
  promised: number?
  produced: "hello!"
  in: the range of
      (-> number?)
  contract from: (function hello-button)
  blaming: (function hello-button)
   (assuming the contract is correct)
  at: eval:10:0

procedure
(binary-function/c [a/c b/c target/c]) → contract?
  a/c : contract? = any/c
  b/c : contract? = #f
  target/c : contract? = #f

A contract to recognize a binary function, that is, a function taking two arguments. The arguments are expected to be of type a/c and b/c, respectively, and the return value is expected to be of type target/c.

procedure
(variadic-function/c [source/c target/c]) → contract?
source/c : contract? = any/c
target/c : contract? = #f

A contract to recognize a variadic function, that is, a function taking an arbitrary number of arguments. The arguments are expected to all be of type source/c, and the return value is expected to be of type target/c. If no contract is specified for the return value, it defaults to the input type.

procedure
(binary-variadic-function/c [ a/c
b/c
target/c
#:tail? tail?]) → contract?
  a/c : contract? = any/c
  b/c : contract? = #f
  target/c : contract? = #f
  tail? : boolean? = #f

Similar to variadic-function/c but allows specification of two input types. If tail? is false, then the contract expects the first argument to be of type a/c and all subsequent arguments to be of type b/c. If tail? is true, then the contract expects the leading arguments to all be of type a/c and the last argument to be of type b/c. The return value is expected to be of type target/c.

procedure
(predicate/c [on-type/c]) → contract?
  on-type/c : contract? = any/c
procedure
(binary-predicate/c [a/c b/c]) → contract?
  a/c : contract? = any/c
  b/c : contract? = #f
procedure
(variadic-predicate/c [on-type/c]) → contract?
  on-type/c : contract? = any/c
procedure
(binary-variadic-predicate/c [ a/c
b/c
#:tail? tail?]) → contract?
  a/c : contract? = any/c
  b/c : contract? = #f
  tail? : boolean? = #f

Similar to function/c, binary-function/c, variadic-function/c and binary-variadic-function/c, but these contracts recognize predicates, meaning that the output is expected to be of type boolean?.

procedure
(encoder/c as-type/c) → contract?
as-type/c : contract?

procedure
(decoder/c from-type/c) → contract?
from-type/c : contract?

procedure
(hash-function/c) → contract?

procedure
(maybe/c contract [default/c]) → contract?
contract : contract?
default/c : contract? = #f

procedure
(binary-composition/c type/c) → contract?
type/c : contract?

procedure
(variadic-composition/c type/c) → contract?
type/c : contract?

procedure
(binary-variadic-composition/c type/c) → contract?
type/c : contract?

procedure
(reducer/c [type/c target/c]) → contract?
type/c : contract? = any/c
target/c : contract? = #f

procedure
(functional/c [procedure/c]) → contract?
procedure/c : contract? = procedure?

procedure
(classifier/c [by-type/c]) → contract?
by-type/c : contract? = any/c

procedure
(map/c [source/c target/c]) → contract?
source/c : contract? = any/c
target/c : contract? = #f

procedure
(filter/c [of-type/c]) → contract?
of-type/c : contract? = any/c

procedure
(binary-constructor/c primitive/c
composite/c
[ #:order order]) → contract?
  primitive/c : contract?
  composite/c : contract?
  order : (one-of/c 'abb 'bab) = 'abb

procedure
(variadic-constructor/c primitive/c
composite/c
[ #:order order]) → contract?
  primitive/c : contract?
  composite/c : contract?
  order : (one-of/c 'abb 'bab) = 'abb

top ← prev up next →