7 Exploring Types

▼ |  | The Typed Racket Reference

1 | Type Reference
2 | Special Form Reference
3 | Libraries Provided With Typed Racket
4 | Typed Classes
5 | Typed Units
6 | Utilities
7 | Exploring Types
8 | Deep, Shallow, and Optional Semantics
9 | Typed Racket Syntax Without Type Checking
10 | Typed Regions
11 | Optimization in Typed Racket
12 | Unsafe Typed Racket operations
13 | Legacy Forms
14 | Compatibility Languages
15 | Experimental Features
| Bibliography
| Index

On this page:

: type
: print-type
: query-type/ args
: query-type/ result
: kind

8.15
top contents ← prev up next →

### 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 ← prev up next →