▼The Typed Racket Reference
On this page:
:  type
:  print-type
:  query-type/  args
:  query-type/  result
:  kind
8.15.0.6
  top  contents    up   

7 Exploring Types🔗ℹ

In addition to printing a summary of the types of REPL results, Typed Racket provides interactive utilities to explore and query types. The following bindings are only available at the Typed Racket REPL.

syntax

(:type maybe-verbose t)

 
maybe-verbose = 
  | #:verbose
Prints the type t. If t is a type alias (e.g., Number), then it will be expanded to its representation when printing. Any further type aliases in the type named by t will remain unexpanded.

If #:verbose is provided, all type aliases are expanded in the printed type.

Examples:
> (:type Number)

(U Exact-Number Imaginary Inexact-Complex Real)

[can expand further: Exact-Number Inexact-Complex Imaginary Real]

> (:type Real)

(U Negative-Real Nonnegative-Real)

[can expand further: Negative-Real Nonnegative-Real]

> (:type #:verbose Number)

(U 0

   1

   Byte-Larger-Than-One

   Exact-Complex

   Exact-Imaginary

   Float-Complex

   Float-Imaginary

   Float-Nan

   Float-Negative-Zero

   Float-Positive-Zero

   Negative-Fixnum

   Negative-Float-No-NaN

   Negative-Integer-Not-Fixnum

   Negative-Rational-Not-Integer

   Negative-Single-Flonum-No-Nan

   Positive-Fixnum-Not-Index

   Positive-Float-No-NaN

   Positive-Index-Not-Byte

   Positive-Integer-Not-Fixnum

   Positive-Rational-Not-Integer

   Positive-Single-Flonum-No-Nan

   Single-Flonum-Complex

   Single-Flonum-Imaginary

   Single-Flonum-Nan

   Single-Flonum-Negative-Zero

   Single-Flonum-Positive-Zero)

syntax

(:print-type e)

Prints the type of e, which must be an expression. This prints the whole type, which can sometimes be quite large.

Examples:
> (:print-type (+ 1 2))

Positive-Index

> (:print-type map)

(All (c a b ...)

  (case->

   (-> (-> a c) (Pairof a (Listof a)) (Pairof c (Listof c)))

   (-> (-> a b ... b c) (Listof a) (Listof b) ... b (Listof c))))

syntax

(:query-type/args f t ...)

Given a function f and argument types t, shows the result type of f.

Example:
> (:query-type/args + Integer Number)

(-> Integer Number Number)

syntax

(:query-type/result f t)

Given a function f and a desired return type t, shows the arguments types f should be given to return a value of type t.

Examples:
> (:query-type/result + Integer)

(-> Integer * Integer)

> (:query-type/result + Float)

(case->

 (-> Flonum Flonum * Flonum)

 (-> Real Real Flonum Real * Flonum)

 (-> Real Flonum Real * Flonum)

 (-> Flonum Real Real * Flonum))

syntax

(:kind e)

Prints the kind of a well-kinded type-level expression e. When e is a type, it prints *. When e is a type constructor, -> following the open parenthesis in the printed result indicates e is productive and -o indicates otherwise.

Examples:
> (:kind Integer)

*

> (:kind Listof)

(-> * *)

> (:kind Pairof)

(-> * * *)

> (:kind U)

(-o * ... *)

Added in version 1.15 of package typed-racket-lib.

  top  contents    up