suzanne.soy/racket
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove some legacy bindings.

Browse Source
This commit is contained in:
Vincent St-Amour 2011-01-20 14:32:14 -05:00
parent 22391be437
commit d65438c9ea
10 changed files with 267 additions and 275 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
collects/tests/typed-scheme/unit-tests/typecheck-tests.rkt
View File

@ -40,7 +40,7 @@
(define N -Number) (define N -Number)
(define B -Boolean) (define B -Boolean)
(define Sym -Symbol) (define Sym -Symbol)
(define -Pos -ExactPositiveInteger) (define -Pos -PosInt)
(define R -Real) (define R -Real)
(define (g) (run typecheck-tests)) (define (g) (run typecheck-tests))
@ -159,8 +159,8 @@
(tc-e/t -268435456 -NegFixnum) (tc-e/t -268435456 -NegFixnum)
(tc-e/t 268435456 -PosFixnum) (tc-e/t 268435456 -PosFixnum)
(tc-e/t -268435457 -NegFixnum) (tc-e/t -268435457 -NegFixnum)
(tc-e/t 1073741823 -PositiveFixnum) (tc-e/t 1073741823 -PosFixnum)
(tc-e/t -1073741824 -NegativeFixnum) (tc-e/t -1073741824 -NegFixnum)
(tc-e/t 1073741824 -PosInt) (tc-e/t 1073741824 -PosInt)
(tc-e/t -1073741825 -NegInt) (tc-e/t -1073741825 -NegInt)
(tc-e/t "foo" -String) (tc-e/t "foo" -String)
@ -861,7 +861,7 @@
(test-suite (test-suite
"tc-literal tests" "tc-literal tests"
(tc-l 5 -PosByte) (tc-l 5 -PosByte)
(tc-l -5 -NegativeFixnum) (tc-l -5 -NegFixnum)
(tc-l 0 -Zero) (tc-l 0 -Zero)
(tc-l 0.0 -FlonumPosZero) (tc-l 0.0 -FlonumPosZero)
(tc-l -0.0 -FlonumNegZero) (tc-l -0.0 -FlonumNegZero)

2
collects/typed-scheme/optimizer/fixnum.rkt
View File

@ -55,7 +55,7 @@
(define-syntax-class nonzero-fixnum-expr (define-syntax-class nonzero-fixnum-expr
#:commit #:commit
(pattern e:expr (pattern e:expr
#:when (or (subtypeof? #'e -PositiveFixnum) (subtypeof? #'e -NegativeFixnum)) #:when (or (subtypeof? #'e -PosFixnum) (subtypeof? #'e -NegFixnum))
#:with opt ((optimize) #'e))) #:with opt ((optimize) #'e)))
(define-syntax-class fixnum-opt-expr (define-syntax-class fixnum-opt-expr

434
collects/typed-scheme/private/base-env-numeric.rkt
View File

@ -3,20 +3,20 @@
(begin (begin
(require (require
(for-template racket/flonum racket/fixnum racket/math racket/unsafe/ops racket/base) (for-template racket/flonum racket/fixnum racket/math racket/unsafe/ops racket/base)
(only-in (types abbrev numeric-tower) [-Number N] [-Boolean B] [-Symbol Sym] [-Real R] [-ExactPositiveInteger -Pos])) (only-in (types abbrev numeric-tower) [-Number N] [-Boolean B] [-Symbol Sym] [-Real R] [-PosInt -Pos]))
(define all-num-types (list -Pos -Nat -Integer -ExactRational -Flonum -InexactReal -Real N)) (define all-num-types (list -Pos -Nat -Int -Rat -Flonum -InexactReal -Real N))
(define binop (define binop
(lambda (t [r t]) (lambda (t [r t])
(t t . -> . r))) (t t . -> . r)))
(define rounder (define rounder
(cl->* (-> -PositiveFixnum -PositiveFixnum) (cl->* (-> -PosFixnum -PosFixnum)
(-> -NonnegativeFixnum -NonnegativeFixnum) (-> -NonNegFixnum -NonNegFixnum)
(-> -Fixnum -Fixnum) (-> -Fixnum -Fixnum)
(-> -Pos -Pos) (-> -Pos -Pos)
(-> -Nat -Nat) (-> -Nat -Nat)
(-> -ExactRational -Integer) (-> -Rat -Int)
(-> -NonNegFlonum -NonNegFlonum) (-> -NonNegFlonum -NonNegFlonum)
(-> -NonPosFlonum -NonPosFlonum) (-> -NonPosFlonum -NonPosFlonum)
(-> -Flonum -Flonum) (-> -Flonum -Flonum)
@ -29,115 +29,115 @@
(define fl-op (binop -Flonum)) (define fl-op (binop -Flonum))
(define fl-unop (unop -Flonum)) (define fl-unop (unop -Flonum))
(define fl-rounder (define fl-rounder
(cl->* (-> -NonnegativeFlonum -NonnegativeFlonum) (cl->* (-> -NonNegFlonum -NonNegFlonum)
(-> -Flonum -Flonum))) (-> -Flonum -Flonum)))
(define int-op (binop -Integer)) (define int-op (binop -Int))
(define nat-op (binop -Nat)) (define nat-op (binop -Nat))
(define fx-comp (binop -Integer B)) (define fx-comp (binop -Int B))
(define fx-op (cl->* (-Pos -Pos . -> . -PositiveFixnum) (define fx-op (cl->* (-Pos -Pos . -> . -PosFixnum)
(-Nat -Nat . -> . -NonnegativeFixnum) (-Nat -Nat . -> . -NonNegFixnum)
(-Integer -Integer . -> . -Fixnum))) (-Int -Int . -> . -Fixnum)))
(define fx-natop (cl->* (-Nat -Nat . -> . -NonnegativeFixnum) (define fx-natop (cl->* (-Nat -Nat . -> . -NonNegFixnum)
(-Integer -Integer . -> . -Fixnum))) (-Int -Int . -> . -Fixnum)))
(define fx-unop (-Integer . -> . -Fixnum)) (define fx-unop (-Int . -> . -Fixnum))
(define real-comp (->* (list R R) R B)) (define real-comp (->* (list R R) R B))
;; types for specific operations, to avoid repetition between safe and unsafe versions ;; types for specific operations, to avoid repetition between safe and unsafe versions
(define fx+-type (define fx+-type
(cl->* (-Pos -Nat . -> . -PositiveFixnum) (cl->* (-Pos -Nat . -> . -PosFixnum)
(-Nat -Pos . -> . -PositiveFixnum) (-Nat -Pos . -> . -PosFixnum)
(-Nat -Nat . -> . -NonnegativeFixnum) (-Nat -Nat . -> . -NonNegFixnum)
(-Integer -Integer . -> . -Fixnum))) (-Int -Int . -> . -Fixnum)))
(define fx--type (define fx--type
(-Integer -Integer . -> . -Fixnum)) (-Int -Int . -> . -Fixnum))
(define fx=-type (define fx=-type
(cl->* (cl->*
(-> -Integer (-val 0) B : (-FS (-filter (-val 0) 0) -top)) (-> -Int (-val 0) B : (-FS (-filter (-val 0) 0) -top))
(-> (-val 0) -Integer B : (-FS (-filter (-val 0) 1) -top)) (-> (-val 0) -Int B : (-FS (-filter (-val 0) 1) -top))
(-> -Integer -Pos B : (-FS (-filter -PositiveFixnum 0) -top)) (-> -Int -Pos B : (-FS (-filter -PosFixnum 0) -top))
(-> -Pos -Integer B : (-FS (-filter -PositiveFixnum 1) -top)) (-> -Pos -Int B : (-FS (-filter -PosFixnum 1) -top))
(-> -Integer -Nat B : (-FS (-filter -NonnegativeFixnum 0) -top)) (-> -Int -Nat B : (-FS (-filter -NonNegFixnum 0) -top))
(-> -Nat -Integer B : (-FS (-filter -NonnegativeFixnum 1) -top)) (-> -Nat -Int B : (-FS (-filter -NonNegFixnum 1) -top))
(-> -Integer -NegativeFixnum B : (-FS (-filter -NegativeFixnum 0) -top)) (-> -Int -NegFixnum B : (-FS (-filter -NegFixnum 0) -top))
(-> -NegativeFixnum -Integer B : (-FS (-filter -NegativeFixnum 1) -top)) (-> -NegFixnum -Int B : (-FS (-filter -NegFixnum 1) -top))
fx-comp)) fx-comp))
(define fx<-type (define fx<-type
(cl->* (cl->*
(-> -Integer (-val 0) B : (-FS (-filter -NegativeFixnum 0) (-filter -NonnegativeFixnum 0))) (-> -Int (-val 0) B : (-FS (-filter -NegFixnum 0) (-filter -NonNegFixnum 0)))
(-> -Integer -NegativeFixnum B : (-FS (-filter -NegativeFixnum 0) -top)) (-> -Int -NegFixnum B : (-FS (-filter -NegFixnum 0) -top))
(-> -Nat -Integer B : (-FS (-filter -PositiveFixnum 1) -top)) (-> -Nat -Int B : (-FS (-filter -PosFixnum 1) -top))
fx-comp)) fx-comp))
(define fx>-type (define fx>-type
(cl->* (cl->*
(-> -Integer (-val 0) B : (-FS (-filter -PositiveFixnum 0) -top)) (-> -Int (-val 0) B : (-FS (-filter -PosFixnum 0) -top))
(-> -NegativeFixnum -Integer B : (-FS (-filter -NegativeFixnum 1) -top)) (-> -NegFixnum -Int B : (-FS (-filter -NegFixnum 1) -top))
(-> -Integer -Nat B : (-FS (-filter -PositiveFixnum 0) -top)) (-> -Int -Nat B : (-FS (-filter -PosFixnum 0) -top))
fx-comp)) fx-comp))
(define fx<=-type (define fx<=-type
(cl->* (cl->*
(-> -Integer (-val 0) B : (-FS -top (-filter -PositiveFixnum 0))) (-> -Int (-val 0) B : (-FS -top (-filter -PosFixnum 0)))
(-> -Integer -NegativeFixnum B : (-FS (-filter -NegativeFixnum 0) -top)) (-> -Int -NegFixnum B : (-FS (-filter -NegFixnum 0) -top))
(-> -Pos -Integer B : (-FS (-filter -Pos 1) -top)) (-> -Pos -Int B : (-FS (-filter -Pos 1) -top))
(-> -Nat -Integer B : (-FS (-filter -Nat 1) -top)) (-> -Nat -Int B : (-FS (-filter -Nat 1) -top))
fx-comp)) fx-comp))
(define fx>=-type (define fx>=-type
(cl->* (cl->*
(-> -Integer (-val 0) B : (-FS (-filter -NonnegativeFixnum 0) -top)) (-> -Int (-val 0) B : (-FS (-filter -NonNegFixnum 0) -top))
(-> -NegativeFixnum -Integer B : (-FS (-filter -NegativeFixnum 1) -top)) (-> -NegFixnum -Int B : (-FS (-filter -NegFixnum 1) -top))
(-> -Integer -Pos B : (-FS (-filter -Pos 0) -top)) (-> -Int -Pos B : (-FS (-filter -Pos 0) -top))
(-> -Integer -Nat B : (-FS (-filter -Nat 0) -top)) (-> -Int -Nat B : (-FS (-filter -Nat 0) -top))
fx-comp)) fx-comp))
(define fxmin-type (define fxmin-type
(cl->* (cl->*
(-> -NegativeFixnum -Integer -NegativeFixnum) (-> -NegFixnum -Int -NegFixnum)
(-> -Integer -NegativeFixnum -NegativeFixnum) (-> -Int -NegFixnum -NegFixnum)
(-> -Pos -Pos -PositiveFixnum) (-> -Pos -Pos -PosFixnum)
(-> -Nat -Nat -NonnegativeFixnum) (-> -Nat -Nat -NonNegFixnum)
(-> -Integer -Integer -Fixnum))) (-> -Int -Int -Fixnum)))
(define fxmax-type (define fxmax-type
(cl->* (cl->*
(-> -NegativeFixnum -NegativeFixnum -NegativeFixnum) (-> -NegFixnum -NegFixnum -NegFixnum)
(-> -Pos -Integer -PositiveFixnum) (-> -Pos -Int -PosFixnum)
(-> -Integer -Pos -PositiveFixnum) (-> -Int -Pos -PosFixnum)
(-> -Nat -Integer -NonnegativeFixnum) (-> -Nat -Int -NonNegFixnum)
(-> -Integer -Nat -NonnegativeFixnum) (-> -Int -Nat -NonNegFixnum)
(-> -Integer -Integer -Fixnum))) (-> -Int -Int -Fixnum)))
(define fl+*-type (define fl+*-type
(cl->* (-NonnegativeFlonum -NonnegativeFlonum . -> . -NonnegativeFlonum) (cl->* (-NonNegFlonum -NonNegFlonum . -> . -NonNegFlonum)
(-Flonum -Flonum . -> . -Flonum))) (-Flonum -Flonum . -> . -Flonum)))
(define fl=-type (define fl=-type
(cl->* (cl->*
(-> -Flonum -NonnegativeFlonum B : (-FS (-filter -NonnegativeFlonum 0) -top)) (-> -Flonum -NonNegFlonum B : (-FS (-filter -NonNegFlonum 0) -top))
(-> -NonnegativeFlonum -Flonum B : (-FS (-filter -NonnegativeFlonum 1) -top)) (-> -NonNegFlonum -Flonum B : (-FS (-filter -NonNegFlonum 1) -top))
fl-comp)) fl-comp))
(define fl<-type (define fl<-type
(cl->* (cl->*
(-> -NonnegativeFlonum -Flonum B : (-FS (-filter -NonnegativeFlonum 1) -top)) (-> -NonNegFlonum -Flonum B : (-FS (-filter -NonNegFlonum 1) -top))
fl-comp)) fl-comp))
(define fl>-type (define fl>-type
(cl->* (cl->*
(-> -Flonum -NonnegativeFlonum B : (-FS (-filter -NonnegativeFlonum 0) -top)) (-> -Flonum -NonNegFlonum B : (-FS (-filter -NonNegFlonum 0) -top))
fl-comp)) fl-comp))
(define flmin-type (define flmin-type
(cl->* (-> -NonnegativeFlonum -NonnegativeFlonum -NonnegativeFlonum) (cl->* (-> -NonNegFlonum -NonNegFlonum -NonNegFlonum)
(-> -Flonum -Flonum -Flonum))) (-> -Flonum -Flonum -Flonum)))
(define flmax-type (define flmax-type
(cl->* (-> -NonnegativeFlonum -Flonum -NonnegativeFlonum) (cl->* (-> -NonNegFlonum -Flonum -NonNegFlonum)
(-> -Flonum -NonnegativeFlonum -NonnegativeFlonum) (-> -Flonum -NonNegFlonum -NonNegFlonum)
(-> -Flonum -Flonum -Flonum))) (-> -Flonum -Flonum -Flonum)))
) )
;; numeric predicates ;; numeric predicates
[zero? (asym-pred N B (-FS (-filter (Un -NonnegativeFlonum -Zero) 0) [zero? (asym-pred N B (-FS (-filter (Un -NonNegFlonum -Zero) 0)
(-not-filter -Zero 0)))] (-not-filter -Zero 0)))]
[number? (make-pred-ty N)] [number? (make-pred-ty N)]
[integer? (asym-pred Univ B (-FS (-filter (Un -Integer -Flonum) 0) [integer? (asym-pred Univ B (-FS (-filter (Un -Int -Flonum) 0)
(-not-filter -Integer 0)))] (-not-filter -Int 0)))]
[exact-integer? (make-pred-ty -Integer)] [exact-integer? (make-pred-ty -Int)]
[real? (make-pred-ty -Real)] [real? (make-pred-ty -Real)]
[flonum? (make-pred-ty -Flonum)] [flonum? (make-pred-ty -Flonum)]
[single-flonum? (make-pred-ty -SingleFlonum)] [single-flonum? (make-pred-ty -SingleFlonum)]
@ -145,93 +145,93 @@
[inexact-real? (make-pred-ty -InexactReal)] [inexact-real? (make-pred-ty -InexactReal)]
[complex? (make-pred-ty N)] [complex? (make-pred-ty N)]
[rational? (make-pred-ty -Real)] [rational? (make-pred-ty -Real)]
[exact? (asym-pred N B (-FS -top (-not-filter -ExactRational 0)))] [exact? (asym-pred N B (-FS -top (-not-filter -Rat 0)))]
[inexact? (asym-pred N B (-FS -top (-not-filter (Un -InexactReal -FloatComplex) 0)))] [inexact? (asym-pred N B (-FS -top (-not-filter (Un -InexactReal -FloatComplex) 0)))]
[fixnum? (make-pred-ty -Fixnum)] [fixnum? (make-pred-ty -Fixnum)]
[positive? (cl->* (-> -Fixnum B : (-FS (-filter -PositiveFixnum 0) -top)) [positive? (cl->* (-> -Fixnum B : (-FS (-filter -PosFixnum 0) -top))
(-> -Integer B : (-FS (-filter -ExactPositiveInteger 0) -top)) (-> -Int B : (-FS (-filter -PosInt 0) -top))
(-> -Flonum B : (-FS (-filter -NonnegativeFlonum 0) -top)) (-> -Flonum B : (-FS (-filter -NonNegFlonum 0) -top))
(-> -Real B))] (-> -Real B))]
[negative? (cl->* (-> -Fixnum B : (-FS (-filter -NegativeFixnum 0) (-filter -NonnegativeFixnum 0))) [negative? (cl->* (-> -Fixnum B : (-FS (-filter -NegFixnum 0) (-filter -NonNegFixnum 0)))
(-> -Integer B : (-FS -top (-filter -Nat 0))) (-> -Int B : (-FS -top (-filter -Nat 0)))
(-> -Flonum B : (-FS -top (-filter -NonnegativeFlonum 0))) (-> -Flonum B : (-FS -top (-filter -NonNegFlonum 0)))
(-> -Real B))] (-> -Real B))]
[exact-positive-integer? (make-pred-ty -Pos)] [exact-positive-integer? (make-pred-ty -Pos)]
[exact-nonnegative-integer? (make-pred-ty -Nat)] [exact-nonnegative-integer? (make-pred-ty -Nat)]
[odd? (-> -Integer B : (-FS -top (-filter (-val 0) 0)))] [odd? (-> -Int B : (-FS -top (-filter (-val 0) 0)))]
[even? (-> -Integer B)] [even? (-> -Int B)]
[modulo (cl->* (-Nat -NonnegativeFixnum . -> . -NonnegativeFixnum) [modulo (cl->* (-Nat -NonNegFixnum . -> . -NonNegFixnum)
(-Integer -Fixnum . -> . -Fixnum) (-Int -Fixnum . -> . -Fixnum)
(-Nat -Nat . -> . -Nat) (-Nat -Nat . -> . -Nat)
(-Integer -Integer . -> . -Integer))] (-Int -Int . -> . -Int))]
[= (cl->* [= (cl->*
(-> -Integer (-val 0) B : (-FS (-filter (-val 0) 0) -top)) (-> -Int (-val 0) B : (-FS (-filter (-val 0) 0) -top))
(-> (-val 0) -Integer B : (-FS (-filter (-val 0) 1) -top)) (-> (-val 0) -Int B : (-FS (-filter (-val 0) 1) -top))
(-> -Integer -PositiveFixnum B : (-FS (-filter -PositiveFixnum 0) -top)) (-> -Int -PosFixnum B : (-FS (-filter -PosFixnum 0) -top))
(-> -PositiveFixnum -Integer B : (-FS (-filter -PositiveFixnum 1) -top)) (-> -PosFixnum -Int B : (-FS (-filter -PosFixnum 1) -top))
(-> -Integer -NonnegativeFixnum B : (-FS (-filter -NonnegativeFixnum 0) -top)) (-> -Int -NonNegFixnum B : (-FS (-filter -NonNegFixnum 0) -top))
(-> -NonnegativeFixnum -Integer B : (-FS (-filter -NonnegativeFixnum 1) -top)) (-> -NonNegFixnum -Int B : (-FS (-filter -NonNegFixnum 1) -top))
(-> -Integer -NegativeFixnum B : (-FS (-filter -NegativeFixnum 0) -top)) (-> -Int -NegFixnum B : (-FS (-filter -NegFixnum 0) -top))
(-> -NegativeFixnum -Integer B : (-FS (-filter -NegativeFixnum 1) -top)) (-> -NegFixnum -Int B : (-FS (-filter -NegFixnum 1) -top))
(-> -Integer -Pos B : (-FS (-filter -Pos 0) -top)) (-> -Int -Pos B : (-FS (-filter -Pos 0) -top))
(-> -Pos -Integer B : (-FS (-filter -Pos 1) -top)) (-> -Pos -Int B : (-FS (-filter -Pos 1) -top))
(-> -Integer -Nat B : (-FS (-filter -Nat 0) -top)) (-> -Int -Nat B : (-FS (-filter -Nat 0) -top))
(-> -Nat -Integer B : (-FS (-filter -Nat 1) -top)) (-> -Nat -Int B : (-FS (-filter -Nat 1) -top))
(->* (list N N) N B))] (->* (list N N) N B))]
[> (cl->* [> (cl->*
(-> -Fixnum (-val 0) B : (-FS (-filter -PositiveFixnum 0) -top)) (-> -Fixnum (-val 0) B : (-FS (-filter -PosFixnum 0) -top))
(-> -Integer (-val 0) B : (-FS (-filter -Pos 0) -top)) (-> -Int (-val 0) B : (-FS (-filter -Pos 0) -top))
(-> -NegativeFixnum -Fixnum B : (-FS (-filter -NegativeFixnum 1) -top)) (-> -NegFixnum -Fixnum B : (-FS (-filter -NegFixnum 1) -top))
(-> -Fixnum -NonnegativeFixnum B : (-FS (-filter -PositiveFixnum 1) -top)) (-> -Fixnum -NonNegFixnum B : (-FS (-filter -PosFixnum 1) -top))
(-> -Fixnum -Nat B : (-FS (-filter -Fixnum 1) -top)) (-> -Fixnum -Nat B : (-FS (-filter -Fixnum 1) -top))
(-> -Integer -Nat B : (-FS (-filter -ExactPositiveInteger 0) -top)) (-> -Int -Nat B : (-FS (-filter -PosInt 0) -top))
(-> -Flonum -NonnegativeFlonum B : (-FS (-filter -NonnegativeFlonum 0) -top)) (-> -Flonum -NonNegFlonum B : (-FS (-filter -NonNegFlonum 0) -top))
(-> -NonnegativeFlonum -Flonum B : (-FS -top (-filter -NonnegativeFlonum 1))) (-> -NonNegFlonum -Flonum B : (-FS -top (-filter -NonNegFlonum 1)))
real-comp)] real-comp)]
[>= (cl->* [>= (cl->*
(-> -Fixnum (-val 0) B : (-FS (-filter -NonnegativeFixnum 0) (-filter -NegativeFixnum 0))) (-> -Fixnum (-val 0) B : (-FS (-filter -NonNegFixnum 0) (-filter -NegFixnum 0)))
(-> -Integer (-val 0) B : (-FS (-filter -ExactNonnegativeInteger 0) -top)) (-> -Int (-val 0) B : (-FS (-filter -Nat 0) -top))
(-> -Fixnum -PositiveFixnum B : (-FS (-filter -PositiveFixnum 0) -top)) (-> -Fixnum -PosFixnum B : (-FS (-filter -PosFixnum 0) -top))
(-> -Fixnum -NonnegativeFixnum B : (-FS (-filter -NonnegativeFixnum 0) -top)) (-> -Fixnum -NonNegFixnum B : (-FS (-filter -NonNegFixnum 0) -top))
(-> -Fixnum -Pos B : (-FS (-filter -PositiveFixnum 1) -top)) (-> -Fixnum -Pos B : (-FS (-filter -PosFixnum 1) -top))
(-> -Fixnum -Nat B : (-FS (-filter -NonnegativeFixnum 1) -top)) (-> -Fixnum -Nat B : (-FS (-filter -NonNegFixnum 1) -top))
(-> -Integer -Pos B : (-FS (-filter -Pos 0) -top)) (-> -Int -Pos B : (-FS (-filter -Pos 0) -top))
(-> -Integer -Nat B : (-FS (-filter -Nat 0) -top)) (-> -Int -Nat B : (-FS (-filter -Nat 0) -top))
(-> -Flonum -NonnegativeFlonum B : (-FS (-filter -NonnegativeFlonum 0) -top)) (-> -Flonum -NonNegFlonum B : (-FS (-filter -NonNegFlonum 0) -top))
(-> -NonnegativeFlonum -Flonum B : (-FS -top (-filter -NonnegativeFlonum 1))) (-> -NonNegFlonum -Flonum B : (-FS -top (-filter -NonNegFlonum 1)))
real-comp)] real-comp)]
[< (cl->* [< (cl->*
(-> -Fixnum (-val 0) B : (-FS (-filter -NegativeFixnum 0) (-filter -NonnegativeFixnum 0))) (-> -Fixnum (-val 0) B : (-FS (-filter -NegFixnum 0) (-filter -NonNegFixnum 0)))
(-> -Integer (-val 0) B : (-FS -top (-filter -ExactNonnegativeInteger 0))) (-> -Int (-val 0) B : (-FS -top (-filter -Nat 0)))
(-> -NonnegativeFixnum -Fixnum B : (-FS (-filter -PositiveFixnum 1) -top)) (-> -NonNegFixnum -Fixnum B : (-FS (-filter -PosFixnum 1) -top))
(-> -Fixnum -NegativeFixnum B : (-FS (-filter -NegativeFixnum 0) -top)) (-> -Fixnum -NegFixnum B : (-FS (-filter -NegFixnum 0) -top))
(-> -Nat -Fixnum B : (-FS (-filter -NonnegativeFixnum 0) -top)) (-> -Nat -Fixnum B : (-FS (-filter -NonNegFixnum 0) -top))
(-> -Nat -Integer B : (-FS (-filter -Pos 1) -top)) (-> -Nat -Int B : (-FS (-filter -Pos 1) -top))
(-> -Integer -Nat B : (-FS -top (-filter -Nat 0))) (-> -Int -Nat B : (-FS -top (-filter -Nat 0)))
(-> -NonnegativeFlonum -Flonum B : (-FS (-filter -NonnegativeFlonum 1) -top)) (-> -NonNegFlonum -Flonum B : (-FS (-filter -NonNegFlonum 1) -top))
(-> -Flonum -NonnegativeFlonum B : (-FS -top (-filter -NonnegativeFlonum 0))) (-> -Flonum -NonNegFlonum B : (-FS -top (-filter -NonNegFlonum 0)))
real-comp)] real-comp)]
[<= (cl->* [<= (cl->*
(-> -Fixnum (-val 0) B : (-FS -top (-filter -PositiveFixnum 0))) (-> -Fixnum (-val 0) B : (-FS -top (-filter -PosFixnum 0)))
(-> -Integer (-val 0) B : (-FS -top (-filter -ExactPositiveInteger 0))) (-> -Int (-val 0) B : (-FS -top (-filter -PosInt 0)))
(-> -PositiveFixnum -Fixnum B : (-FS (-filter -PositiveFixnum 1) -top)) (-> -PosFixnum -Fixnum B : (-FS (-filter -PosFixnum 1) -top))
(-> -NonnegativeFixnum -Fixnum B : (-FS (-filter -NonnegativeFixnum 1) -top)) (-> -NonNegFixnum -Fixnum B : (-FS (-filter -NonNegFixnum 1) -top))
(-> -Pos -Fixnum B : (-FS (-filter -PositiveFixnum 0) -top)) (-> -Pos -Fixnum B : (-FS (-filter -PosFixnum 0) -top))
(-> -Nat -Fixnum B : (-FS (-filter -NonnegativeFixnum 0) -top)) (-> -Nat -Fixnum B : (-FS (-filter -NonNegFixnum 0) -top))
(-> -Pos -Integer B : (-FS (-filter -Pos 1) -top)) (-> -Pos -Int B : (-FS (-filter -Pos 1) -top))
(-> -Nat -Integer B : (-FS (-filter -Nat 1) -top)) (-> -Nat -Int B : (-FS (-filter -Nat 1) -top))
(-> -NonnegativeFlonum -Flonum B : (-FS (-filter -NonnegativeFlonum 1) -top)) (-> -NonNegFlonum -Flonum B : (-FS (-filter -NonNegFlonum 1) -top))
(-> -Flonum -NonnegativeFlonum B : (-FS -top (-filter -NonnegativeFlonum 0))) (-> -Flonum -NonNegFlonum B : (-FS -top (-filter -NonNegFlonum 0)))
real-comp)] real-comp)]
[* (apply cl->* [* (apply cl->*
(append (for/list ([t (list -Pos -Nat -Integer -ExactRational -NonnegativeFlonum -Flonum)]) (->* (list) t t)) (append (for/list ([t (list -Pos -Nat -Int -Rat -NonNegFlonum -Flonum)]) (->* (list) t t))
(list (->* (list) (Un -Pos -NonnegativeFlonum) -NonnegativeFlonum)) (list (->* (list) (Un -Pos -NonNegFlonum) -NonNegFlonum))
(list (->* (list) (Un -Pos -Flonum) -Flonum)) (list (->* (list) (Un -Pos -Flonum) -Flonum))
(list (->* (list -Flonum) (Un -InexactReal -Flonum) -Flonum)) (list (->* (list -Flonum) (Un -InexactReal -Flonum) -Flonum))
(list (->* (list -InexactReal -Flonum) (Un -InexactReal -Flonum) -Flonum)) (list (->* (list -InexactReal -Flonum) (Un -InexactReal -Flonum) -Flonum))
@ -244,10 +244,10 @@
(list (-> -Byte -Byte -Index)) (list (-> -Byte -Byte -Index))
(list (->* (list -Pos) -Nat -Pos)) (list (->* (list -Pos) -Nat -Pos))
(list (->* (list -Nat -Pos) -Nat -Pos)) (list (->* (list -Nat -Pos) -Nat -Pos))
(for/list ([t (list -Nat -Integer -ExactRational -NonnegativeFlonum -Flonum)]) (->* (list) t t)) (for/list ([t (list -Nat -Int -Rat -NonNegFlonum -Flonum)]) (->* (list) t t))
;; special cases for promotion to inexact, not exhaustive ;; special cases for promotion to inexact, not exhaustive
;; valid for + and -, but not for * and /, since (* <float> 0) is exact 0 (i.e. not a float) ;; valid for + and -, but not for * and /, since (* <float> 0) is exact 0 (i.e. not a float)
(list (->* (list) (Un -Nat -NonnegativeFlonum) -NonnegativeFlonum)) (list (->* (list) (Un -Nat -NonNegFlonum) -NonNegFlonum))
(list (->* (list -Flonum) -Real -Flonum)) (list (->* (list -Flonum) -Real -Flonum))
(list (->* (list -Real -Flonum) -Real -Flonum)) (list (->* (list -Real -Flonum) -Real -Flonum))
(list (->* (list) -InexactReal -InexactReal)) (list (->* (list) -InexactReal -InexactReal))
@ -258,7 +258,7 @@
(list (->* (list) N N))))] (list (->* (list) N N))))]
[- (apply cl->* [- (apply cl->*
(append (for/list ([t (list -Integer -ExactRational -Flonum)]) (append (for/list ([t (list -Int -Rat -Flonum)])
(->* (list t) t t)) (->* (list t) t t))
(list (->* (list -Flonum) -Real -Flonum)) (list (->* (list -Flonum) -Real -Flonum))
(list (->* (list -Real -Flonum) -Real -Flonum)) (list (->* (list -Real -Flonum) -Real -Flonum))
@ -269,8 +269,8 @@
(list (->* (list N -FloatComplex) N -FloatComplex)) (list (->* (list N -FloatComplex) N -FloatComplex))
(list (->* (list N) N N))))] (list (->* (list N) N N))))]
[/ (apply cl->* [/ (apply cl->*
(append (list (->* (list -Integer) -Integer -ExactRational)) (append (list (->* (list -Int) -Int -Rat))
(for/list ([t (list -ExactRational -Flonum)]) (for/list ([t (list -Rat -Flonum)])
(->* (list t) t t)) (->* (list t) t t))
;; only exact 0 as first argument can cause the result of a division involving inexacts to be exact ;; only exact 0 as first argument can cause the result of a division involving inexacts to be exact
(list (->* (list -Flonum) -Real -Flonum)) (list (->* (list -Flonum) -Real -Flonum))
@ -281,28 +281,28 @@
(list (->* (list -FloatComplex) -FloatComplex -FloatComplex)) (list (->* (list -FloatComplex) -FloatComplex -FloatComplex))
(list (->* (list N) N N))))] (list (->* (list N) N N))))]
[max (cl->* (->* (list -PositiveFixnum) -Fixnum -PositiveFixnum) [max (cl->* (->* (list -PosFixnum) -Fixnum -PosFixnum)
(->* (list -NonnegativeFixnum) -Fixnum -NonnegativeFixnum) (->* (list -NonNegFixnum) -Fixnum -NonNegFixnum)
(->* (list -NegativeFixnum) -NegativeFixnum -NegativeFixnum) (->* (list -NegFixnum) -NegFixnum -NegFixnum)
(->* (list -Fixnum) -Fixnum -Fixnum) (->* (list -Fixnum) -Fixnum -Fixnum)
(->* (list -Pos) -Integer -Pos) (->* (list -Pos) -Int -Pos)
(->* (list -Nat) -Integer -Nat) (->* (list -Nat) -Int -Nat)
(->* (list -Integer) -Integer -Integer) (->* (list -Int) -Int -Int)
(->* (list -ExactRational) -ExactRational -ExactRational) (->* (list -Rat) -Rat -Rat)
(->* (list -NonnegativeFlonum) -Flonum -NonnegativeFlonum) (->* (list -NonNegFlonum) -Flonum -NonNegFlonum)
(->* (list -Flonum) -Flonum -Flonum) (->* (list -Flonum) -Flonum -Flonum)
(->* (list -InexactReal) -InexactReal -InexactReal) (->* (list -InexactReal) -InexactReal -InexactReal)
(->* (list -Real) -Real -Real))] (->* (list -Real) -Real -Real))]
[min (cl->* (->* (list -PositiveFixnum) -PositiveFixnum -PositiveFixnum) [min (cl->* (->* (list -PosFixnum) -PosFixnum -PosFixnum)
(->* (list -NonnegativeFixnum) -NonnegativeFixnum -NonnegativeFixnum) (->* (list -NonNegFixnum) -NonNegFixnum -NonNegFixnum)
(->* (list -NegativeFixnum) -Fixnum -NegativeFixnum) (->* (list -NegFixnum) -Fixnum -NegFixnum)
(->* (list -Fixnum) -NegativeFixnum -NegativeFixnum) (->* (list -Fixnum) -NegFixnum -NegFixnum)
(->* (list -Fixnum) -Fixnum -Fixnum) (->* (list -Fixnum) -Fixnum -Fixnum)
(->* (list -Pos) -Pos -Pos) (->* (list -Pos) -Pos -Pos)
(->* (list -Nat) -Nat -Nat) (->* (list -Nat) -Nat -Nat)
(->* (list -Integer) -Integer -Integer) (->* (list -Int) -Int -Int)
(->* (list -ExactRational) -ExactRational -ExactRational) (->* (list -Rat) -Rat -Rat)
(->* (list -NonnegativeFlonum) -NonnegativeFlonum -NonnegativeFlonum) (->* (list -NonNegFlonum) -NonNegFlonum -NonNegFlonum)
(->* (list -Flonum) -Flonum -Flonum) (->* (list -Flonum) -Flonum -Flonum)
(->* (list -InexactReal) -InexactReal -InexactReal) (->* (list -InexactReal) -InexactReal -InexactReal)
(->* (list -Real) -Real -Real))] (->* (list -Real) -Real -Real))]
@ -310,9 +310,9 @@
[add1 (cl->* (-> -Pos -Pos) [add1 (cl->* (-> -Pos -Pos)
(-> -Nat -Pos) (-> -Nat -Pos)
(-> -Integer -Integer) (-> -Int -Int)
(-> -ExactRational -ExactRational) (-> -Rat -Rat)
(-> -NonnegativeFlonum -NonnegativeFlonum) (-> -NonNegFlonum -NonNegFlonum)
(-> -Flonum -Flonum) (-> -Flonum -Flonum)
(-> -InexactReal -InexactReal) (-> -InexactReal -InexactReal)
(-> -Real -Real) (-> -Real -Real)
@ -320,61 +320,61 @@
(-> N N))] (-> N N))]
[sub1 (cl->* (-> -Pos -Nat) [sub1 (cl->* (-> -Pos -Nat)
(-> -Integer -Integer) (-> -Int -Int)
(-> -ExactRational -ExactRational) (-> -Rat -Rat)
(-> -Flonum -Flonum) (-> -Flonum -Flonum)
(-> -InexactReal -InexactReal) (-> -InexactReal -InexactReal)
(-> -Real -Real) (-> -Real -Real)
(-> -FloatComplex -FloatComplex) (-> -FloatComplex -FloatComplex)
(-> N N))] (-> N N))]
[quotient (cl->* (-NonnegativeFixnum -NonnegativeFixnum . -> . -NonnegativeFixnum) [quotient (cl->* (-NonNegFixnum -NonNegFixnum . -> . -NonNegFixnum)
(-Fixnum -Fixnum . -> . -Fixnum) (-Fixnum -Fixnum . -> . -Fixnum)
(-Nat -Nat . -> . -Nat) (-Nat -Nat . -> . -Nat)
(-Integer -Integer . -> . -Integer))] (-Int -Int . -> . -Int))]
[remainder (cl->* (-Nat -NonnegativeFixnum . -> . -NonnegativeFixnum) [remainder (cl->* (-Nat -NonNegFixnum . -> . -NonNegFixnum)
(-Integer -Fixnum . -> . -Fixnum) (-Int -Fixnum . -> . -Fixnum)
(-Nat -Nat . -> . -Nat) (-Nat -Nat . -> . -Nat)
(-Integer -Integer . -> . -Integer))] (-Int -Int . -> . -Int))]
[quotient/remainder (cl->* (-NonnegativeFixnum -NonnegativeFixnum . -> . (-values (list -NonnegativeFixnum -NonnegativeFixnum))) [quotient/remainder (cl->* (-NonNegFixnum -NonNegFixnum . -> . (-values (list -NonNegFixnum -NonNegFixnum)))
(-Nat -NonnegativeFixnum . -> . (-values (list -Nat -NonnegativeFixnum))) (-Nat -NonNegFixnum . -> . (-values (list -Nat -NonNegFixnum)))
(-Fixnum -Fixnum . -> . (-values (list -Fixnum -Fixnum))) (-Fixnum -Fixnum . -> . (-values (list -Fixnum -Fixnum)))
(-Integer -Fixnum . -> . (-values (list -Integer -Fixnum))) (-Int -Fixnum . -> . (-values (list -Int -Fixnum)))
(-Nat -Nat . -> . (-values (list -Nat -Nat))) (-Nat -Nat . -> . (-values (list -Nat -Nat)))
(-Integer -Integer . -> . (-values (list -Integer -Integer))))] (-Int -Int . -> . (-values (list -Int -Int))))]
[arithmetic-shift (cl->* ((-val 0) (Un -NegativeFixnum (-val 0)) . -> . (-val 0)) [arithmetic-shift (cl->* ((-val 0) (Un -NegFixnum (-val 0)) . -> . (-val 0))
(-NonnegativeFixnum (Un -NegativeFixnum (-val 0)) . -> . -NonnegativeFixnum) (-NonNegFixnum (Un -NegFixnum (-val 0)) . -> . -NonNegFixnum)
(-Fixnum (Un -NegativeFixnum (-val 0)) . -> . -Fixnum) (-Fixnum (Un -NegFixnum (-val 0)) . -> . -Fixnum)
(-Nat -Integer . -> . -Nat) (-Nat -Int . -> . -Nat)
(-Integer -Integer . -> . -Integer))] (-Int -Int . -> . -Int))]
[bitwise-and (cl->* (null -NonnegativeFixnum . ->* . -NonnegativeFixnum) [bitwise-and (cl->* (null -NonNegFixnum . ->* . -NonNegFixnum)
((list -Integer) -NonnegativeFixnum . ->* . -NonnegativeFixnum) ((list -Int) -NonNegFixnum . ->* . -NonNegFixnum)
(null -Fixnum . ->* . -Fixnum) (null -Fixnum . ->* . -Fixnum)
((list -Integer) -Fixnum . ->* . -Fixnum) ((list -Int) -Fixnum . ->* . -Fixnum)
(null -Nat . ->* . -Nat) (null -Nat . ->* . -Nat)
(null -Integer . ->* . -Integer))] (null -Int . ->* . -Int))]
[bitwise-ior (cl->* (null -NonnegativeFixnum . ->* . -NonnegativeFixnum) [bitwise-ior (cl->* (null -NonNegFixnum . ->* . -NonNegFixnum)
(null -Fixnum . ->* . -Fixnum) (null -Fixnum . ->* . -Fixnum)
(null -Nat . ->* . -Nat) (null -Nat . ->* . -Nat)
(null -Integer . ->* . -Integer))] (null -Int . ->* . -Int))]
[bitwise-not (cl->* (null -Fixnum . ->* . -Fixnum) [bitwise-not (cl->* (null -Fixnum . ->* . -Fixnum)
(null -Integer . ->* . -Integer))] (null -Int . ->* . -Int))]
[bitwise-xor (cl->* (null -NonnegativeFixnum . ->* . -NonnegativeFixnum) [bitwise-xor (cl->* (null -NonNegFixnum . ->* . -NonNegFixnum)
(null -Fixnum . ->* . -Fixnum) (null -Fixnum . ->* . -Fixnum)
(null -Nat . ->* . -Nat) (null -Nat . ->* . -Nat)
(null -Integer . ->* . -Integer))] (null -Int . ->* . -Int))]
[bitwise-bit-set? (-> -Integer -Integer B)] [bitwise-bit-set? (-> -Int -Int B)]
[bitwise-bit-field (-> -Integer -Integer -Integer -Integer)] [bitwise-bit-field (-> -Int -Int -Int -Int)]
[integer-length (-> -Integer -NonnegativeFixnum)] [integer-length (-> -Int -NonNegFixnum)]
[abs (cl->* (-PositiveFixnum . -> . -PositiveFixnum) [abs (cl->* (-PosFixnum . -> . -PosFixnum)
(-Fixnum . -> . -NonnegativeFixnum) (-Fixnum . -> . -NonNegFixnum)
(-Pos . -> . -Pos) (-Pos . -> . -Pos)
(-Integer . -> . -Nat) (-Int . -> . -Nat)
(-ExactRational . -> . -ExactRational) (-Rat . -> . -Rat)
(-Flonum . -> . -NonnegativeFlonum) (-Flonum . -> . -NonNegFlonum)
(-InexactReal . -> . -InexactReal) (-InexactReal . -> . -InexactReal)
(-Real . -> . -Real))] (-Real . -> . -Real))]
@ -385,11 +385,11 @@
(-Real . -> . -Flonum) (-Real . -> . -Flonum)
(N . -> . -FloatComplex))] (N . -> . -FloatComplex))]
[inexact->exact (cl->* [inexact->exact (cl->*
(-Real . -> . -ExactRational) (-Real . -> . -Rat)
(N . -> . N))] (N . -> . N))]
[fl->exact-integer (cl->* [fl->exact-integer (cl->*
(-NonnegativeFlonum . -> . -Nat) (-NonNegFlonum . -> . -Nat)
(-Flonum . -> . -Integer))] (-Flonum . -> . -Int))]
[real->single-flonum (cl->* (-PosReal . -> . -PosSingleFlonum) [real->single-flonum (cl->* (-PosReal . -> . -PosSingleFlonum)
(-NegReal . -> . -NegSingleFlonum) (-NegReal . -> . -NegSingleFlonum)
(-RealZero . -> . -SingleFlonumZero) (-RealZero . -> . -SingleFlonumZero)
@ -419,30 +419,30 @@
(N . -> . -Real))] (N . -> . -Real))]
[angle (cl->* (-FloatComplex . -> . -Flonum) [angle (cl->* (-FloatComplex . -> . -Flonum)
(N . -> . -Real))] (N . -> . -Real))]
[numerator (cl->* (-ExactRational . -> . -Integer) [numerator (cl->* (-Rat . -> . -Int)
(-Real . -> . -Real))] (-Real . -> . -Real))]
[denominator (cl->* (-ExactRational . -> . -Integer) [denominator (cl->* (-Rat . -> . -Int)
(-Real . -> . -Real))] (-Real . -> . -Real))]
[rationalize (cl->* (-ExactRational -ExactRational . -> . -ExactRational) [rationalize (cl->* (-Rat -Rat . -> . -Rat)
(-Flonum -Flonum . -> . -Flonum) (-Flonum -Flonum . -> . -Flonum)
(-InexactReal -InexactReal . -> . -InexactReal) (-InexactReal -InexactReal . -> . -InexactReal)
(-Real -Real . -> . -Real))] (-Real -Real . -> . -Real))]
[expt (cl->* (-Nat -Nat . -> . -Nat) [expt (cl->* (-Nat -Nat . -> . -Nat)
(-Integer -Nat . -> . -Integer) (-Int -Nat . -> . -Int)
(-Integer -Integer . -> . -ExactRational) (-Int -Int . -> . -Rat)
(-Real -Integer . -> . -Real) (-Real -Int . -> . -Real)
(-FloatComplex -FloatComplex . -> . -FloatComplex) (-FloatComplex -FloatComplex . -> . -FloatComplex)
(N N . -> . N))] (N N . -> . N))]
[sqrt (cl->* [sqrt (cl->*
(-Nat . -> . -Real) (-Nat . -> . -Real)
(-NonnegativeFlonum . -> . -NonnegativeFlonum) (-NonNegFlonum . -> . -NonNegFlonum)
(-FloatComplex . -> . -FloatComplex) (-FloatComplex . -> . -FloatComplex)
(N . -> . N))] (N . -> . N))]
[integer-sqrt (cl->* [integer-sqrt (cl->*
(-Zero . -> . -Zero) (-Zero . -> . -Zero)
(-NonnegativeFixnum . -> . -NonnegativeFixnum) (-NonNegFixnum . -> . -NonNegFixnum)
(-Nat . -> . -Nat) (-Nat . -> . -Nat)
(-NonnegativeFlonum . -> . -NonnegativeFlonum) (-NonNegFlonum . -> . -NonNegFlonum)
(-Real . -> . N))] (-Real . -> . N))]
[log (cl->* [log (cl->*
(-Pos . -> . -Real) (-Pos . -> . -Real)
@ -459,24 +459,24 @@
[acos (cl->* (-Flonum . -> . -Flonum) (-InexactReal . -> . -InexactReal) (-Real . -> . -Real) (-FloatComplex . -> . -FloatComplex) (N . -> . N))] [acos (cl->* (-Flonum . -> . -Flonum) (-InexactReal . -> . -InexactReal) (-Real . -> . -Real) (-FloatComplex . -> . -FloatComplex) (N . -> . N))]
[asin (cl->* (-Flonum . -> . -Flonum) (-InexactReal . -> . -InexactReal) (-Real . -> . -Real) (-FloatComplex . -> . -FloatComplex) (N . -> . N))] [asin (cl->* (-Flonum . -> . -Flonum) (-InexactReal . -> . -InexactReal) (-Real . -> . -Real) (-FloatComplex . -> . -FloatComplex) (N . -> . N))]
[atan (cl->* (-Flonum . -> . -Flonum) (-InexactReal . -> . -InexactReal) (-Real . -> . -Real) (-FloatComplex . -> . -FloatComplex) (N . -> . N) (-Real -Real . -> . N))] [atan (cl->* (-Flonum . -> . -Flonum) (-InexactReal . -> . -InexactReal) (-Real . -> . -Real) (-FloatComplex . -> . -FloatComplex) (N . -> . N) (-Real -Real . -> . N))]
[gcd (cl->* (null -Fixnum . ->* . -Fixnum) (null -Integer . ->* . -Integer))] [gcd (cl->* (null -Fixnum . ->* . -Fixnum) (null -Int . ->* . -Int))]
[lcm (null -Integer . ->* . -Integer)] [lcm (null -Int . ->* . -Int)]
;; scheme/math ;; scheme/math
[sgn (cl->* (-Zero . -> . -Zero) [sgn (cl->* (-Zero . -> . -Zero)
(-ExactPositiveInteger . -> . -PositiveFixnum) (-PosInt . -> . -PosFixnum)
(-ExactNonnegativeInteger . -> . -NonnegativeFixnum) (-Nat . -> . -NonNegFixnum)
(-ExactRational . -> . -Fixnum) (-Rat . -> . -Fixnum)
(-Flonum . -> . -Flonum) (-Flonum . -> . -Flonum)
(-InexactReal . -> . -InexactReal) (-InexactReal . -> . -InexactReal)
(-Real . -> . -Real))] (-Real . -> . -Real))]
[pi -NonnegativeFlonum] [pi -NonNegFlonum]
[sqr (cl->* (-> -Pos -Pos) [sqr (cl->* (-> -Pos -Pos)
(-> -Integer -Nat) (-> -Int -Nat)
(-> -ExactRational -ExactRational) (-> -Rat -Rat)
(-> -Flonum -NonnegativeFlonum) (-> -Flonum -NonNegFlonum)
(-> -InexactReal -InexactReal) (-> -InexactReal -InexactReal)
(-> -Real -Real) (-> -Real -Real)
(-> -FloatComplex -FloatComplex) (-> -FloatComplex -FloatComplex)
@ -491,7 +491,7 @@
(N . -> . N))] (N . -> . N))]
;; unsafe numeric ops ;; unsafe numeric ops
[unsafe-flabs (-> -Flonum -NonnegativeFlonum)] [unsafe-flabs (-> -Flonum -NonNegFlonum)]
[unsafe-fl+ fl+*-type] [unsafe-fl+ fl+*-type]
[unsafe-fl- fl-op] [unsafe-fl- fl-op]
[unsafe-fl* fl+*-type] [unsafe-fl* fl+*-type]
@ -516,7 +516,7 @@
[unsafe-fllog fl-unop] [unsafe-fllog fl-unop]
[unsafe-flexp fl-rounder] [unsafe-flexp fl-rounder]
[unsafe-flsqrt fl-rounder] [unsafe-flsqrt fl-rounder]
[unsafe-fx->fl (cl->* (-Nat . -> . -NonnegativeFlonum) (-Integer . -> . -Flonum))] [unsafe-fx->fl (cl->* (-Nat . -> . -NonNegFlonum) (-Int . -> . -Flonum))]
[unsafe-make-flrectangular (-Flonum -Flonum . -> . -FloatComplex)] [unsafe-make-flrectangular (-Flonum -Flonum . -> . -FloatComplex)]
[unsafe-flreal-part (-FloatComplex . -> . -Flonum)] [unsafe-flreal-part (-FloatComplex . -> . -Flonum)]
[unsafe-flimag-part (-FloatComplex . -> . -Flonum)] [unsafe-flimag-part (-FloatComplex . -> . -Flonum)]
@ -527,7 +527,7 @@
[unsafe-fxquotient fx-natop] [unsafe-fxquotient fx-natop]
[unsafe-fxremainder fx-natop] [unsafe-fxremainder fx-natop]
[unsafe-fxmodulo fx-natop] [unsafe-fxmodulo fx-natop]
[unsafe-fxabs (-Integer . -> . (Un -PositiveFixnum (-val 0)))] [unsafe-fxabs (-Int . -> . (Un -PosFixnum (-val 0)))]
[unsafe-fxand fx-op] [unsafe-fxand fx-op]
[unsafe-fxior fx-op] [unsafe-fxior fx-op]
@ -552,7 +552,7 @@
[fxquotient fx-natop] [fxquotient fx-natop]
[fxremainder fx-natop] [fxremainder fx-natop]
[fxmodulo fx-natop] [fxmodulo fx-natop]
[fxabs (-Integer . -> . (Un -PositiveFixnum (-val 0)))] [fxabs (-Int . -> . (Un -PosFixnum (-val 0)))]
[fxand fx-op] [fxand fx-op]
[fxior fx-op] [fxior fx-op]
@ -571,7 +571,7 @@
;; safe flonum ops ;; safe flonum ops
[flabs (-> -Flonum -NonnegativeFlonum)] [flabs (-> -Flonum -NonNegFlonum)]
[fl+ fl+*-type] [fl+ fl+*-type]
[fl- fl-op] [fl- fl-op]
[fl* fl+*-type] [fl* fl+*-type]
@ -596,7 +596,7 @@
[fllog fl-unop] [fllog fl-unop]
[flexp fl-unop] [flexp fl-unop]
[flsqrt fl-unop] [flsqrt fl-unop]
[->fl (-Integer . -> . -Flonum)] [->fl (-Int . -> . -Flonum)]
[make-flrectangular (-Flonum -Flonum . -> . -FloatComplex)] [make-flrectangular (-Flonum -Flonum . -> . -FloatComplex)]
[flreal-part (-FloatComplex . -> . -Flonum)] [flreal-part (-FloatComplex . -> . -Flonum)]
[flimag-part (-FloatComplex . -> . -Flonum)] [flimag-part (-FloatComplex . -> . -Flonum)]
@ -605,14 +605,14 @@
[flvector? (make-pred-ty -FlVector)] [flvector? (make-pred-ty -FlVector)]
[flvector (->* (list) -Flonum -FlVector)] [flvector (->* (list) -Flonum -FlVector)]
[make-flvector (cl->* (-> -Integer -FlVector) [make-flvector (cl->* (-> -Int -FlVector)
(-> -Integer -Flonum -FlVector))] (-> -Int -Flonum -FlVector))]
[flvector-length (-> -FlVector -NonnegativeFixnum)] [flvector-length (-> -FlVector -NonNegFixnum)]
[flvector-ref (-> -FlVector -Integer -Flonum)] [flvector-ref (-> -FlVector -Int -Flonum)]
[flvector-set! (-> -FlVector -Integer -Flonum -Void)] [flvector-set! (-> -FlVector -Int -Flonum -Void)]
;; unsafe flvector ops ;; unsafe flvector ops
[unsafe-flvector-length (-> -FlVector -NonnegativeFixnum)] [unsafe-flvector-length (-> -FlVector -NonNegFixnum)]
[unsafe-flvector-ref (-> -FlVector -Integer -Flonum)] [unsafe-flvector-ref (-> -FlVector -Int -Flonum)]
[unsafe-flvector-set! (-> -FlVector -Integer -Flonum -Void)] [unsafe-flvector-set! (-> -FlVector -Int -Flonum -Void)]

40
collects/typed-scheme/private/base-env.rkt
View File

@ -234,8 +234,8 @@
[string? (make-pred-ty -String)] [string? (make-pred-ty -String)]
[string (->* '() -Char -String)] [string (->* '() -Char -String)]
[string-length (-String . -> . -NonnegativeFixnum)] [string-length (-String . -> . -NonNegFixnum)]
[unsafe-string-length (-String . -> . -NonnegativeFixnum)] [unsafe-string-length (-String . -> . -NonNegFixnum)]
[symbol? (make-pred-ty Sym)] [symbol? (make-pred-ty Sym)]
[keyword? (make-pred-ty -Keyword)] [keyword? (make-pred-ty -Keyword)]
@ -322,7 +322,7 @@
[reverse (-poly (a) (-> (-lst a) (-lst a)))] [reverse (-poly (a) (-> (-lst a) (-lst a)))]
[append (-poly (a) (->* (list) (-lst a) (-lst a)))] [append (-poly (a) (->* (list) (-lst a) (-lst a)))]
[length (-poly (a) (-> (-lst a) -NonnegativeFixnum))] [length (-poly (a) (-> (-lst a) -NonNegFixnum))]
[memq (-poly (a) (-> a (-lst a) (-opt (-lst a))))] [memq (-poly (a) (-> a (-lst a) (-opt (-lst a))))]
[memv (-poly (a) (-> a (-lst a) (-opt (-lst a))))] [memv (-poly (a) (-> a (-lst a) (-opt (-lst a))))]
[memf (-poly (a) ((a . -> . B) (-lst a) . -> . (-opt (-lst a))))] [memf (-poly (a) ((a . -> . B) (-lst a) . -> . (-opt (-lst a))))]
@ -359,7 +359,7 @@
[char-general-category (-> -Char (apply Un (map -val [char-general-category (-> -Char (apply Un (map -val
'(lu ll lt lm lo mn mc me nd nl no ps pe pi pf pd '(lu ll lt lm lo mn mc me nd nl no ps pe pi pf pd
pc po sc sm sk so zs zp zl cc cf cs co cn))))] pc po sc sm sk so zs zp zl cc cf cs co cn))))]
[make-known-char-range-list (-> (-lst (-Tuple (list -ExactPositiveInteger -ExactPositiveInteger B))))] [make-known-char-range-list (-> (-lst (-Tuple (list -PosInt -PosInt B))))]
[string-ci<? (->* (list -String -String) -String B)] [string-ci<? (->* (list -String -String) -String B)]
[string-ci>? (->* (list -String -String) -String B)] [string-ci>? (->* (list -String -String) -String B)]
@ -375,7 +375,7 @@
[char-downcase (-> -Char -Char)] [char-downcase (-> -Char -Char)]
[char-titlecase (-> -Char -Char)] [char-titlecase (-> -Char -Char)]
[char-foldcase (-> -Char -Char)] [char-foldcase (-> -Char -Char)]
[char->integer (-> -Char -NonnegativeFixnum)] [char->integer (-> -Char -NonNegFixnum)]
[integer->char (-> -Integer -Char)] [integer->char (-> -Integer -Char)]
[char-utf-8-length (-> -Char (apply Un (map -val '(1 2 3 4 5 6))))] [char-utf-8-length (-> -Char (apply Un (map -val '(1 2 3 4 5 6))))]
@ -501,16 +501,16 @@
[vector->list (-poly (a) (-> (-vec a) (-lst a)))] [vector->list (-poly (a) (-> (-vec a) (-lst a)))]
[list->vector (-poly (a) (-> (-lst a) (-vec a)))] [list->vector (-poly (a) (-> (-lst a) (-vec a)))]
[vector-length ((make-VectorTop) . -> . -NonnegativeFixnum)] [vector-length ((make-VectorTop) . -> . -NonNegFixnum)]
[vector (-poly (a) (->* (list) a (-vec a)))] [vector (-poly (a) (->* (list) a (-vec a)))]
[vector-immutable (-poly (a) (->* (list) a (-vec a)))] [vector-immutable (-poly (a) (->* (list) a (-vec a)))]
[vector->immutable-vector (-poly (a) (-> (-vec a) (-vec a)))] [vector->immutable-vector (-poly (a) (-> (-vec a) (-vec a)))]
[vector-fill! (-poly (a) (-> (-vec a) a -Void))] [vector-fill! (-poly (a) (-> (-vec a) a -Void))]
[vector-argmax (-poly (a) (-> (-> a -Real) (-vec a) a))] [vector-argmax (-poly (a) (-> (-> a -Real) (-vec a) a))]
[vector-argmin (-poly (a) (-> (-> a -Real) (-vec a) a))] [vector-argmin (-poly (a) (-> (-> a -Real) (-vec a) a))]
[vector-memq (-poly (a) (-> a (-vec a) (-opt -NonnegativeFixnum)))] [vector-memq (-poly (a) (-> a (-vec a) (-opt -NonNegFixnum)))]
[vector-memv (-poly (a) (-> a (-vec a) (-opt -NonnegativeFixnum)))] [vector-memv (-poly (a) (-> a (-vec a) (-opt -NonNegFixnum)))]
[vector-member (-poly (a) (a (-vec a) . -> . (-opt -NonnegativeFixnum)))] [vector-member (-poly (a) (a (-vec a) . -> . (-opt -NonNegFixnum)))]
;; [vector->values no good type here] ;; [vector->values no good type here]
@ -579,7 +579,7 @@
[hash-remove! (-poly (a b) ((-HT a b) a . -> . -Void))] [hash-remove! (-poly (a b) ((-HT a b) a . -> . -Void))]
[hash-map (-poly (a b c) ((-HT a b) (a b . -> . c) . -> . (-lst c)))] [hash-map (-poly (a b c) ((-HT a b) (a b . -> . c) . -> . (-lst c)))]
[hash-for-each (-poly (a b c) (-> (-HT a b) (-> a b c) -Void))] [hash-for-each (-poly (a b c) (-> (-HT a b) (-> a b c) -Void))]
[hash-count (-poly (a b) (-> (-HT a b) -NonnegativeFixnum))] [hash-count (-poly (a b) (-> (-HT a b) -NonNegFixnum))]
[hash-keys (-poly (a b) ((-HT a b) . -> . (-lst a)))] [hash-keys (-poly (a b) ((-HT a b) . -> . (-lst a)))]
[hash-values (-poly (a b) ((-HT a b) . -> . (-lst b)))] [hash-values (-poly (a b) ((-HT a b) . -> . (-lst b)))]
[hash->list (-poly (a b) ((-HT a b) . -> . (-lst (-pair a b))))] [hash->list (-poly (a b) ((-HT a b) . -> . (-lst (-pair a b))))]
@ -603,12 +603,12 @@
[make-bytes (cl-> [(-Integer -Integer) -Bytes] [make-bytes (cl-> [(-Integer -Integer) -Bytes]
[(-Integer) -Bytes])] [(-Integer) -Bytes])]
[bytes->immutable-bytes (-> -Bytes -Bytes)] [bytes->immutable-bytes (-> -Bytes -Bytes)]
[byte? (make-pred-ty -NonnegativeFixnum)] [byte? (make-pred-ty -NonNegFixnum)]
[bytes-append (->* (list) -Bytes -Bytes)] [bytes-append (->* (list) -Bytes -Bytes)]
[bytes-length (-> -Bytes -NonnegativeFixnum)] [bytes-length (-> -Bytes -NonNegFixnum)]
[unsafe-bytes-length (-> -Bytes -NonnegativeFixnum)] [unsafe-bytes-length (-> -Bytes -NonNegFixnum)]
[bytes-copy (-> -Bytes -Bytes)] [bytes-copy (-> -Bytes -Bytes)]
[bytes->list (-> -Bytes (-lst -NonnegativeFixnum))] [bytes->list (-> -Bytes (-lst -NonNegFixnum))]
[list->bytes (-> (-lst -Integer) -Bytes)] [list->bytes (-> (-lst -Integer) -Bytes)]
[bytes<? (->* (list -Bytes) -Bytes B)] [bytes<? (->* (list -Bytes) -Bytes B)]
[bytes>? (->* (list -Bytes) -Bytes B)] [bytes>? (->* (list -Bytes) -Bytes B)]
@ -752,7 +752,7 @@
(-lst a)) (-lst a))
((-lst b) b) ((-lst b) b)
. ->... . . ->... .
-NonnegativeFixnum))] -NonNegFixnum))]
[filter-map (-polydots (c a b) [filter-map (-polydots (c a b)
((list ((list
((list a) (b b) . ->... . (-opt c)) ((list a) (b b) . ->... . (-opt c))
@ -785,7 +785,7 @@
[tcp-accept-ready? (-TCP-Listener . -> . B )] [tcp-accept-ready? (-TCP-Listener . -> . B )]
[tcp-addresses (cl->* [tcp-addresses (cl->*
(-Port [(-val #f)] . ->opt . (-values (list -String -String))) (-Port [(-val #f)] . ->opt . (-values (list -String -String)))
(-Port (-val #t) . -> . (-values (list -String -NonnegativeFixnum -String -NonnegativeFixnum))))] (-Port (-val #t) . -> . (-values (list -String -NonNegFixnum -String -NonNegFixnum))))]
[tcp-close (-TCP-Listener . -> . -Void )] [tcp-close (-TCP-Listener . -> . -Void )]
[tcp-connect (-String -Integer . -> . (-values (list -Input-Port -Output-Port)))] [tcp-connect (-String -Integer . -> . (-values (list -Input-Port -Output-Port)))]
[tcp-connect/enable-break (-String -Integer . -> . (-values (list -Input-Port -Output-Port)))] [tcp-connect/enable-break (-String -Integer . -> . (-values (list -Input-Port -Output-Port)))]
@ -849,8 +849,8 @@
;; unsafe ;; unsafe
[unsafe-vector-length ((make-VectorTop) . -> . -NonnegativeFixnum)] [unsafe-vector-length ((make-VectorTop) . -> . -NonNegFixnum)]
[unsafe-vector*-length ((make-VectorTop) . -> . -NonnegativeFixnum)] [unsafe-vector*-length ((make-VectorTop) . -> . -NonNegFixnum)]
[unsafe-car (-poly (a b) [unsafe-car (-poly (a b)
(cl->* (cl->*
(->acc (list (-pair a b)) a (list -car)) (->acc (list (-pair a b)) a (list -car))
@ -868,7 +868,7 @@
(-vec a)) (-vec a))
((-vec b) b) ((-vec b) b)
. ->... . . ->... .
-NonnegativeFixnum))] -NonNegFixnum))]
[vector-filter (-poly (a b) (cl->* [vector-filter (-poly (a b) (cl->*
((make-pred-ty (list a) Univ b) ((make-pred-ty (list a) Univ b)
(-vec a) (-vec a)
@ -957,7 +957,7 @@
(-> (-mlst a) (-mlst a) -Void)))] (-> (-mlst a) (-mlst a) -Void)))]
[mpair? (make-pred-ty (make-MPairTop))] [mpair? (make-pred-ty (make-MPairTop))]
[mlist (-poly (a) (->* (list) a (-mlst a)))] [mlist (-poly (a) (->* (list) a (-mlst a)))]
[mlength (-poly (a) (-> (-mlst a) -NonnegativeFixnum))] [mlength (-poly (a) (-> (-mlst a) -NonNegFixnum))]
[mreverse! (-poly (a) (-> (-mlst a) (-mlst a)))] [mreverse! (-poly (a) (-> (-mlst a) (-mlst a)))]
[mappend (-poly (a) (->* (list) (-mlst a) (-mlst a)))] [mappend (-poly (a) (->* (list) (-mlst a) (-mlst a)))]

22
collects/typed-scheme/private/base-special-env.rkt
View File

@ -69,18 +69,18 @@
[(syntax-parse (local-expand #'(in-range 1) 'expression #f) [(syntax-parse (local-expand #'(in-range 1) 'expression #f)
[(i-n _ ...) [(i-n _ ...)
#'i-n]) #'i-n])
(cl->* (-PositiveFixnum -Fixnum [-Nat] . ->opt . (-seq -PositiveFixnum)) (cl->* (-PosFixnum -Fixnum [-Nat] . ->opt . (-seq -PosFixnum))
(-NonnegativeFixnum [-Fixnum -Nat] . ->opt . (-seq -NonnegativeFixnum)) (-NonNegFixnum [-Fixnum -Nat] . ->opt . (-seq -NonNegFixnum))
(-Fixnum [-Fixnum -Integer] . ->opt . (-seq -Fixnum)) (-Fixnum [-Fixnum -Int] . ->opt . (-seq -Fixnum))
(-ExactPositiveInteger -Integer [-Nat] . ->opt . (-seq -ExactPositiveInteger)) (-PosInt -Int [-Nat] . ->opt . (-seq -PosInt))
(-Nat [-Integer -Nat] . ->opt . (-seq -Nat)) (-Nat [-Int -Nat] . ->opt . (-seq -Nat))
(-Integer [-Integer -Integer] . ->opt . (-seq -Integer)))] (-Int [-Int -Int] . ->opt . (-seq -Int)))]
;; in-naturals ;; in-naturals
[(syntax-parse (local-expand #'(in-naturals) 'expression #f) [(syntax-parse (local-expand #'(in-naturals) 'expression #f)
[(i-n _ ...) [(i-n _ ...)
#'i-n]) #'i-n])
(cl->* (-> -ExactPositiveInteger (-seq -ExactPositiveInteger)) (cl->* (-> -PosInt (-seq -PosInt))
(-> -Integer (-seq -Nat)))] (-> -Int (-seq -Nat)))]
;; in-list ;; in-list
[(syntax-parse (local-expand #'(in-list '(1 2 3)) 'expression #f) [(syntax-parse (local-expand #'(in-list '(1 2 3)) 'expression #f)
[(i-n _ ...) [(i-n _ ...)
@ -90,17 +90,17 @@
[(syntax-parse (local-expand #'(in-vector (vector 1 2 3)) 'expression #f) [(syntax-parse (local-expand #'(in-vector (vector 1 2 3)) 'expression #f)
[(i-n _ ...) [(i-n _ ...)
#'i-n]) #'i-n])
(-poly (a) (->opt (-vec a) [-Integer (-opt -Integer) -Integer] (-seq a)))] (-poly (a) (->opt (-vec a) [-Int (-opt -Int) -Int] (-seq a)))]
;; in-string ;; in-string
[(syntax-parse (local-expand #'(in-string "abc") 'expression #f) [(syntax-parse (local-expand #'(in-string "abc") 'expression #f)
[(i-n _ ...) [(i-n _ ...)
#'i-n]) #'i-n])
(->opt -String [-Integer (-opt -Integer) -Integer] (-seq -Char))] (->opt -String [-Int (-opt -Int) -Int] (-seq -Char))]
;; in-bytes ;; in-bytes
[(syntax-parse (local-expand #'(in-bytes #"abc") 'expression #f) [(syntax-parse (local-expand #'(in-bytes #"abc") 'expression #f)
[(i-n _ ...) [(i-n _ ...)
#'i-n]) #'i-n])
(->opt -Bytes [-Integer (-opt -Integer) -Integer] (-seq -Byte))] (->opt -Bytes [-Int (-opt -Int) -Int] (-seq -Byte))]
;; in-port ;; in-port
[(syntax-parse (local-expand #'(in-port) 'expression #f) [(syntax-parse (local-expand #'(in-port) 'expression #f)
[(i-n _ ...) [(i-n _ ...)

2
collects/typed-scheme/private/base-types.rkt
View File

@ -49,7 +49,7 @@
[Negative-Exact-Rational -NegRat] [Negative-Exact-Rational -NegRat]
[Nonnegative-Exact-Rational -NonNegRat] [Nonnegative-Exact-Rational -NonNegRat]
[Positive-Exact-Rational -PosRat] [Positive-Exact-Rational -PosRat]
[Integer -Integer] [Integer -Int]
[Nonpositive-Integer -NonPosInt] [Nonpositive-Integer -NonPosInt]
[Negative-Integer -NegInt] [Negative-Integer -NegInt]
[Exact-Nonnegative-Integer -Nat] ; both of these are valid [Exact-Nonnegative-Integer -Nat] ; both of these are valid

2
collects/typed-scheme/private/type-contract.rkt
View File

@ -138,7 +138,7 @@
[(== t:-Nat type-equal?) #'(flat-named-contract 'Natural (and/c exact-integer? (lambda (x) (>= x 0))))] [(== t:-Nat type-equal?) #'(flat-named-contract 'Natural (and/c exact-integer? (lambda (x) (>= x 0))))]
[(== t:-NegInt type-equal?) #'(flat-named-contract 'Negative-Integer (and/c exact-integer? negative?))] [(== t:-NegInt type-equal?) #'(flat-named-contract 'Negative-Integer (and/c exact-integer? negative?))]
[(== t:-NonPosInt type-equal?) #'(flat-named-contract 'Nonpositive-Integer (and/c exact-integer? (lambda (x) (<= x 0))))] [(== t:-NonPosInt type-equal?) #'(flat-named-contract 'Nonpositive-Integer (and/c exact-integer? (lambda (x) (<= x 0))))]
[(== t:-Integer type-equal?) #'(flat-named-contract 'Integer exact-integer?)] [(== t:-Int type-equal?) #'(flat-named-contract 'Integer exact-integer?)]
[(== t:-PosRat type-equal?) #'(flat-named-contract 'Positive-Rational (and/c exact-rational? positive?))] [(== t:-PosRat type-equal?) #'(flat-named-contract 'Positive-Rational (and/c exact-rational? positive?))]
[(== t:-NonNegRat type-equal?) #'(flat-named-contract 'Nonnegative-Rational (and/c exact-rational? (lambda (x) (>= x 0))))] [(== t:-NonNegRat type-equal?) #'(flat-named-contract 'Nonnegative-Rational (and/c exact-rational? (lambda (x) (>= x 0))))]
[(== t:-NegRat type-equal?) #'(flat-named-contract 'Negative-Rational (and/c exact-rational? negative?))] [(== t:-NegRat type-equal?) #'(flat-named-contract 'Negative-Rational (and/c exact-rational? negative?))]

18
collects/typed-scheme/typecheck/tc-app.rkt
View File

@ -471,33 +471,33 @@
(match expected (match expected
[(tc-result1: (Vector: t)) [(tc-result1: (Vector: t))
(tc-expr/check #'n (ret -Integer)) (tc-expr/check #'n (ret -Integer))
(tc-expr/check #'proc (ret (-NonnegativeFixnum . -> . t))) (tc-expr/check #'proc (ret (-NonNegFixnum . -> . t)))
expected] expected]
[(or #f (tc-result1: _)) [(or #f (tc-result1: _))
(tc/funapp #'op #'(n elt) (single-value #'op) (tc/funapp #'op #'(n elt) (single-value #'op)
(list (single-value #'n) (list (single-value #'n)
(match (tc/funapp #'proc #'(1) ; valid nonnegative-fixnum (match (tc/funapp #'proc #'(1) ; valid nonnegative-fixnum
(single-value #'proc) (single-value #'proc)
(list (ret -NonnegativeFixnum)) (list (ret -NonNegFixnum))
#f) #f)
[(tc-result1: t) (ret (-> -NonnegativeFixnum (generalize t)))])) [(tc-result1: t) (ret (-> -NonNegFixnum (generalize t)))]))
expected)] expected)]
[_ (int-err "bad expected: ~a" expected)])] [_ (int-err "bad expected: ~a" expected)])]
;; special case for `-' used like `sub1' ;; special case for `-' used like `sub1'
[(#%plain-app (~and op (~literal -)) v (~and arg2 ((~literal quote) 1))) [(#%plain-app (~and op (~literal -)) v (~and arg2 ((~literal quote) 1)))
(add-typeof-expr #'arg2 (ret -PositiveFixnum)) (add-typeof-expr #'arg2 (ret -PosFixnum))
(match-let ([(tc-result1: t) (single-value #'v)]) (match-let ([(tc-result1: t) (single-value #'v)])
(cond (cond
[(subtype t -PositiveFixnum) (ret -NonnegativeFixnum)] [(subtype t -PosFixnum) (ret -NonNegFixnum)]
[(subtype t -NonnegativeFixnum) (ret -Fixnum)] [(subtype t -NonNegFixnum) (ret -Fixnum)]
[(subtype t -ExactPositiveInteger) (ret -Nat)] [(subtype t -PosInt) (ret -Nat)]
[else (tc/funapp #'op #'(v arg2) (single-value #'op) (list (ret t) (single-value #'arg2)) expected)]))] [else (tc/funapp #'op #'(v arg2) (single-value #'op) (list (ret t) (single-value #'arg2)) expected)]))]
;; idem for fx- ;; idem for fx-
[(#%plain-app (~and op (~or (~literal fx-) (~literal unsafe-fx-))) v (~and arg2 ((~literal quote) 1))) [(#%plain-app (~and op (~or (~literal fx-) (~literal unsafe-fx-))) v (~and arg2 ((~literal quote) 1)))
(add-typeof-expr #'arg2 (ret -PositiveFixnum)) (add-typeof-expr #'arg2 (ret -PosFixnum))
(match-let ([(tc-result1: t) (single-value #'v)]) (match-let ([(tc-result1: t) (single-value #'v)])
(cond (cond
[(subtype t -ExactPositiveInteger) (ret -NonnegativeFixnum)] [(subtype t -PosInt) (ret -NonNegFixnum)]
[else (tc/funapp #'op #'(v arg2) (single-value #'op) (list (ret t) (single-value #'arg2)) expected)]))] [else (tc/funapp #'op #'(v arg2) (single-value #'op) (list (ret t) (single-value #'arg2)) expected)]))]
;; call-with-values ;; call-with-values
[(#%plain-app call-with-values prod con) [(#%plain-app call-with-values prod con)

4
collects/typed-scheme/types/convenience.rkt
View File

@ -30,9 +30,9 @@
(let loop ([t* t]) (let loop ([t* t])
(match t* (match t*
[(Value: '()) (-lst Univ)] [(Value: '()) (-lst Univ)]
[(Value: 0) -Integer] [(Value: 0) -Int]
[(List: ts) (-lst (apply Un ts))] [(List: ts) (-lst (apply Un ts))]
[(? (lambda (t) (subtype t -Integer))) -Integer] [(? (lambda (t) (subtype t -Int))) -Int]
[(? (lambda (t) (subtype t -Rat))) -Rat] [(? (lambda (t) (subtype t -Rat))) -Rat]
[(? (lambda (t) (subtype t -Flonum))) -Flonum] [(? (lambda (t) (subtype t -Flonum))) -Flonum]
[(? (lambda (t) (subtype t -SingleFlonum))) -SingleFlonum] [(? (lambda (t) (subtype t -SingleFlonum))) -SingleFlonum]

10
collects/typed-scheme/types/numeric-tower.rkt
View File

@ -17,15 +17,7 @@
-InexactRealPosZero -InexactRealNegZero -InexactRealZero -PosInexactReal -NonNegInexactReal -NegInexactReal -NonPosInexactReal -InexactReal -InexactRealPosZero -InexactRealNegZero -InexactRealZero -PosInexactReal -NonNegInexactReal -NegInexactReal -NonPosInexactReal -InexactReal
-RealZero -PosReal -NonNegReal -NegReal -NonPosReal -Real -RealZero -PosReal -NonNegReal -NegReal -NonPosReal -Real
-FloatComplex -SingleFlonumComplex -InexactComplex -Number -FloatComplex -SingleFlonumComplex -InexactComplex -Number
;; for backward compatibility (rename-out (-Int -Integer)))
(rename-out [-NonNegFlonum -NonnegativeFlonum]
[-Rat -ExactRational]
[-Int -Integer]
[-PosInt -ExactPositiveInteger]
[-PosFixnum -PositiveFixnum]
[-NegFixnum -NegativeFixnum]
[-NonNegFixnum -NonnegativeFixnum]
[-Nat -ExactNonnegativeInteger]))
;; Numeric hierarchy ;; Numeric hierarchy