r bignum? &bignum)
(define-simple-predicate-inferrer bitvector? &bitvector)
(define-simple-predicate-inferrer bytevector? &bytevector)
(define-simple-predicate-inferrer char? &char)
(define-simple-predicate-inferrer compnum? &complex)
(define-simple-predicate-inferrer flonum? &flonum)
(define-simple-predicate-inferrer fixnum? &fixnum)
(define-simple-predicate-inferrer fluid? &fluid)
(define-simple-predicate-inferrer fracnum? &fraction)
(define-simple-predicate-inferrer immutable-vector? &immutable-vector)
(define-simple-predicate-inferrer keyword? &keyword)
(define-simple-predicate-inferrer mutable-vector? &mutable-vector)
(define-simple-predicate-inferrer pair? &pair)
(define-simple-predicate-inferrer pointer? &pointer)
(define-simple-predicate-inferrer program? &procedure)
(define-simple-predicate-inferrer string? &string)
(define-simple-predicate-inferrer struct? &struct)
(define-simple-predicate-inferrer symbol? &symbol)
(define-simple-predicate-inferrer syntax? &syntax)
(define-simple-predicate-inferrer variable? &box)

(define-simple-predicate-inferrer number? &number)
(define-type-inferrer-aliases number? rational? complex?)
(define-simple-predicate-inferrer heap-number? &heap-number)
(define-simple-predicate-inferrer real? &real)
(let ((&maybe-integer (logior &exact-integer &flonum &complex)))
  (define-simple-predicate-inferrer integer? &maybe-integer))
(define-simple-predicate-inferrer exact-integer? &exact-integer)
(define-simple-predicate-inferrer exact? &exact-number)
(let ((&inexact-number (logior &flonum &complex)))
  (define-simple-predicate-inferrer inexact? &inexact-number))

(define-type-inferrer-aliases eq? heap-numbers-equal?)

(define-predicate-inferrer (procedure? val true?)
  ;; Besides proper procedures, structs and smobs can also be applicable
  ;; in the guile-vm target.
  (define applicable-types (logior &procedure &struct &other-heap-object))
  (when true?
    (restrict! val (logand (&type val) applicable-types)
               (&min val) (&max val))))

(define-predicate-inferrer (vector? val true?)
  (define &not-vector (logand &all-types (lognot &vector)))
  (restrict! val (if true? &vector &not-vector) -inf.0 +inf.0))

(define-predicate-inferrer (eq? a b true?)
  ;; We can only propagate information down the true leg.
  (when true?
    (let ((type (logand (&type a) (&type b)))
          (min (max (&min a) (&min b)))
          (max (min (&max a) (&max b))))
      (restrict! a type min max)
      (restrict! b type min max))))
(define-type-inferrer-aliases eq? heap-numbers-equal?)