On this page:
Version: 5.2.1

4 Utilities

Typed Racket provides some additional utility functions to facilitate typed programming.

(assert v)  A
  v : (U #f A)
(assert v p?)  B
  v : A
  p? : (A -> Any : B)
Verifies that the argument satisfies the constraint. If no predicate is provided, simply checks that the value is not #f.


> (define: x : (U #f String) (number->string 7))
> x

- : (U String False)


> (assert x)

- : String


> (define: y : (U String Symbol) "hello")
> y

- : (U Symbol String)


> (assert y string?)

- : String


> (assert y boolean?)

Assertion failed

(with-asserts ([id maybe-pred] ...) body ...+)
maybe-pred = 
  | predicate
Guard the body with assertions. If any of the assertions fail, the program errors. These assertions behave like assert.

(defined? v)  boolean?
  v : any/c
A predicate for determining if v is not #<undefined>.

(index? v)  boolean?
  v : any/c
A predicate for the Index type.

(typecheck-fail orig-stx maybe-msg maybe-id)
maybe-msg = 
  | msg-string
maybe-id = 
  | #:covered-id id
Explicitly produce a type error, with the source location or orig-stx. If msg-string is present, it must be a literal string, it is used as the error message, otherwise the error message "Incomplete case coverage" is used. If id is present and has type T, then the message "missing coverage of T" is added to the error message.


> (define-syntax (cond* stx)
    (syntax-case stx ()
      [(_ x clause ...)
       #`(cond clause ... [else (typecheck-fail #,stx "incomplete coverage"
                                                #:covered-id x)])]))
> (define: (f [x  : (U String Integer)]) : Boolean
    (cond* x
           [(string? x) #t]
           [(exact-nonnegative-integer? x) #f]))

Type Checker: incomplete coverage; missing coverage of

Negative-Integer in: #%top-interaction