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

Heterogenous -> heterogenEous.

Browse Source 
Found by Ray Racine.
This commit is contained in:
Vincent St-Amour 2012-11-20 17:06:51 -05:00
parent d994ba1914
commit e2007abd7a
12 changed files with 45 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
collects/tests/typed-racket/unit-tests/typecheck-tests.rkt
View File

@ -223,12 +223,12 @@
[tc-e (void) -Void] [tc-e (void) -Void]
[tc-e (void 3 4) -Void] [tc-e (void 3 4) -Void]
[tc-e (void #t #f '(1 2 3)) -Void] [tc-e (void #t #f '(1 2 3)) -Void]
[tc-e/t #(3 4 5) (make-HeterogenousVector (list -Integer -Integer -Integer))] [tc-e/t #(3 4 5) (make-HeterogeneousVector (list -Integer -Integer -Integer))]
[tc-e/t '(2 3 4) (-lst* -PosByte -PosByte -PosByte)] [tc-e/t '(2 3 4) (-lst* -PosByte -PosByte -PosByte)]
[tc-e/t '(2 3 #t) (-lst* -PosByte -PosByte (-val #t))] [tc-e/t '(2 3 #t) (-lst* -PosByte -PosByte (-val #t))]
[tc-e/t #(2 3 #t) (make-HeterogenousVector (list -Integer -Integer -Boolean))] [tc-e/t #(2 3 #t) (make-HeterogeneousVector (list -Integer -Integer -Boolean))]
[tc-e (vector 2 "3" #t) (make-HeterogenousVector (list -Integer -String -Boolean))] [tc-e (vector 2 "3" #t) (make-HeterogeneousVector (list -Integer -String -Boolean))]
[tc-e (vector-immutable 2 "3" #t) (make-HeterogenousVector (list -Integer -String -Boolean))] [tc-e (vector-immutable 2 "3" #t) (make-HeterogeneousVector (list -Integer -String -Boolean))]
[tc-e (make-vector 4 1) (-vec -Integer)] [tc-e (make-vector 4 1) (-vec -Integer)]
[tc-e (build-vector 4 (lambda (x) 1)) (-vec -Integer)] [tc-e (build-vector 4 (lambda (x) 1)) (-vec -Integer)]
[tc-e (range 4) (-lst -Byte)] [tc-e (range 4) (-lst -Byte)]
@ -1371,7 +1371,7 @@
;Random Numbers ;Random Numbers
(tc-e (make-pseudo-random-generator) -Pseudo-Random-Generator) (tc-e (make-pseudo-random-generator) -Pseudo-Random-Generator)
(tc-e (let: ((pg : Pseudo-Random-Generator (make-pseudo-random-generator))) (tc-e (let: ((pg : Pseudo-Random-Generator (make-pseudo-random-generator)))
(pseudo-random-generator->vector pg)) (make-HeterogenousVector (list -PosInt -PosInt -PosInt -PosInt -PosInt -PosInt))) (pseudo-random-generator->vector pg)) (make-HeterogeneousVector (list -PosInt -PosInt -PosInt -PosInt -PosInt -PosInt)))
;Structure Type Properties ;Structure Type Properties
(tc-e (make-struct-type-property 'prop) (list -Struct-Type-Property (t:-> Univ B) (t:-> Univ Univ))) (tc-e (make-struct-type-property 'prop) (list -Struct-Type-Property (t:-> Univ B) (t:-> Univ Univ)))

14
collects/typed-racket/base-env/base-env.rkt
View File

@ -36,7 +36,7 @@
make-ThreadCellTop make-ThreadCellTop
make-Ephemeron make-Ephemeron
make-CustodianBox make-CustodianBox
make-HeterogenousVector make-HeterogeneousVector
make-ListDots)) make-ListDots))
;Section 9.2 ;Section 9.2
@ -1190,7 +1190,7 @@
(-opt -Integer) (-opt -Integer)
(-opt -Integer) (-opt -Integer)
(-opt -Integer)))] (-opt -Integer)))]
[srcvec (make-HeterogenousVector (list [srcvec (make-HeterogeneousVector (list
Univ Univ
(-opt -Integer) (-opt -Integer)
(-opt -Integer) (-opt -Integer)
@ -1903,7 +1903,7 @@
(-val null)))))))))] (-val null)))))))))]
[module-compiled-language-info [module-compiled-language-info
(-> -Compiled-Module-Expression (-> -Compiled-Module-Expression
(-opt (make-HeterogenousVector (list -Module-Path -Symbol Univ))))] (-opt (make-HeterogeneousVector (list -Module-Path -Symbol Univ))))]
;Section 13.4.3 ;Section 13.4.3
[dynamic-require [dynamic-require
@ -1924,7 +1924,7 @@
[module->language-info [module->language-info
(->opt (Un -Module-Path -Path -Resolved-Module-Path) (->opt (Un -Module-Path -Path -Resolved-Module-Path)
[Univ] [Univ]
(-opt (make-HeterogenousVector (list -Module-Path -Symbol Univ))))] (-opt (make-HeterogeneousVector (list -Module-Path -Symbol Univ))))]
[module->imports (-> -Compiled-Module-Expression [module->imports (-> -Compiled-Module-Expression
@ -2087,11 +2087,11 @@
[pseudo-random-generator? (make-pred-ty -Pseudo-Random-Generator)] [pseudo-random-generator? (make-pred-ty -Pseudo-Random-Generator)]
[current-pseudo-random-generator (-Param -Pseudo-Random-Generator -Pseudo-Random-Generator)] [current-pseudo-random-generator (-Param -Pseudo-Random-Generator -Pseudo-Random-Generator)]
[pseudo-random-generator->vector [pseudo-random-generator->vector
(-> -Pseudo-Random-Generator (make-HeterogenousVector (list -PosInt -PosInt -PosInt -PosInt -PosInt -PosInt)))] (-> -Pseudo-Random-Generator (make-HeterogeneousVector (list -PosInt -PosInt -PosInt -PosInt -PosInt -PosInt)))]
[vector->pseudo-random-generator [vector->pseudo-random-generator
(-> (make-HeterogenousVector (list -PosInt -PosInt -PosInt -PosInt -PosInt -PosInt)) -Pseudo-Random-Generator)] (-> (make-HeterogeneousVector (list -PosInt -PosInt -PosInt -PosInt -PosInt -PosInt)) -Pseudo-Random-Generator)]
[vector->pseudo-random-generator! [vector->pseudo-random-generator!
(-> -Pseudo-Random-Generator (make-HeterogenousVector (list -PosInt -PosInt -PosInt -PosInt -PosInt -PosInt)) -Void)] (-> -Pseudo-Random-Generator (make-HeterogeneousVector (list -PosInt -PosInt -PosInt -PosInt -PosInt -PosInt)) -Void)]
[current-evt-pseudo-random-generator (-Param -Pseudo-Random-Generator -Pseudo-Random-Generator)] [current-evt-pseudo-random-generator (-Param -Pseudo-Random-Generator -Pseudo-Random-Generator)]

6
collects/typed-racket/infer/infer-unit.rkt
View File

@ -449,12 +449,12 @@
[((List: ts) (Sequence: (list t*))) [((List: ts) (Sequence: (list t*)))
(cset-meet* (for/list ([t (in-list ts)]) (cset-meet* (for/list ([t (in-list ts)])
(cg t t*)))] (cg t t*)))]
[((HeterogenousVector: ts) (HeterogenousVector: ts*)) [((HeterogeneousVector: ts) (HeterogeneousVector: ts*))
(cset-meet (cgen/list V X Y ts ts*) (cgen/list V X Y ts* ts))] (cset-meet (cgen/list V X Y ts ts*) (cgen/list V X Y ts* ts))]
[((HeterogenousVector: ts) (Vector: s)) [((HeterogeneousVector: ts) (Vector: s))
(define ts* (map (λ _ s) ts)) ;; invariant, everything has to match (define ts* (map (λ _ s) ts)) ;; invariant, everything has to match
(cset-meet (cgen/list V X Y ts ts*) (cgen/list V X Y ts* ts))] (cset-meet (cgen/list V X Y ts ts*) (cgen/list V X Y ts* ts))]
[((HeterogenousVector: ts) (Sequence: (list t*))) [((HeterogeneousVector: ts) (Sequence: (list t*)))
(cset-meet* (for/list ([t (in-list ts)]) (cset-meet* (for/list ([t (in-list ts)])
(cg t t*)))] (cg t t*)))]
[((Vector: t) (Sequence: (list t*))) [((Vector: t) (Sequence: (list t*)))

2
collects/typed-racket/optimizer/sequence.rkt
View File

@ -27,7 +27,7 @@
(pattern e:expr (pattern e:expr
#:when (match (type-of #'e) #:when (match (type-of #'e)
[(tc-result1: (Vector: _)) #t] [(tc-result1: (Vector: _)) #t]
[(tc-result1: (HeterogenousVector: _)) #t] [(tc-result1: (HeterogeneousVector: _)) #t]
[_ #f]) [_ #f])
#:with opt ((optimize) #'e))) #:with opt ((optimize) #'e)))

6
collects/typed-racket/optimizer/vector.rkt
View File

@ -26,7 +26,7 @@
#:commit #:commit
(pattern e:expr (pattern e:expr
#:when (match (type-of #'e) #:when (match (type-of #'e)
[(tc-result1: (HeterogenousVector: _)) #t] [(tc-result1: (HeterogeneousVector: _)) #t]
[_ #f]) [_ #f])
#:with opt ((optimize) #'e))) #:with opt ((optimize) #'e)))
@ -43,7 +43,7 @@
this-syntax) this-syntax)
(add-disappeared-use #'op) (add-disappeared-use #'op)
(match (type-of #'v) (match (type-of #'v)
[(tc-result1: (HeterogenousVector: es)) [(tc-result1: (HeterogeneousVector: es))
#`(begin v.opt #,(length es))]))) ; v may have side effects #`(begin v.opt #,(length es))]))) ; v may have side effects
;; we can optimize vector-length on all vectors. ;; we can optimize vector-length on all vectors.
;; since the program typechecked, we know the arg is a vector. ;; since the program typechecked, we know the arg is a vector.
@ -63,7 +63,7 @@
;; the index is within bounds (for now, literal or singleton type) ;; the index is within bounds (for now, literal or singleton type)
(pattern (#%plain-app op:vector-op v:known-length-vector-expr i:expr new:expr ...) (pattern (#%plain-app op:vector-op v:known-length-vector-expr i:expr new:expr ...)
#:when (let ((len (match (type-of #'v) #:when (let ((len (match (type-of #'v)
[(tc-result1: (HeterogenousVector: es)) (length es)] [(tc-result1: (HeterogeneousVector: es)) (length es)]
[_ 0])) [_ 0]))
(ival (or (syntax-parse #'i [((~literal quote) i:number) (syntax-e #'i)] [_ #f]) (ival (or (syntax-parse #'i [((~literal quote) i:number) (syntax-e #'i)] [_ #f])
(match (type-of #'i) (match (type-of #'i)

2
collects/typed-racket/private/parse-type.rkt
View File

@ -184,7 +184,7 @@
(-Tuple* (map parse-type (syntax->list #'(ts ...))) (parse-type #'t))] (-Tuple* (map parse-type (syntax->list #'(ts ...))) (parse-type #'t))]
[((~and kw t:Vector) ts ...) [((~and kw t:Vector) ts ...)
(add-disappeared-use #'kw) (add-disappeared-use #'kw)
(make-HeterogenousVector (map parse-type (syntax->list #'(ts ...))))] (make-HeterogeneousVector (map parse-type (syntax->list #'(ts ...))))]
[((~and kw cons) fst rst) [((~and kw cons) fst rst)
(add-disappeared-use #'kw) (add-disappeared-use #'kw)
(-pair (parse-type #'fst) (parse-type #'rst))] (-pair (parse-type #'fst) (parse-type #'rst))]

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

@ -324,7 +324,7 @@
[(Vector: t) [(Vector: t)
(set-chaperone!) (set-chaperone!)
#`(vectorof #,(t->c t))] #`(vectorof #,(t->c t))]
[(HeterogenousVector: ts) [(HeterogeneousVector: ts)
(set-chaperone!) (set-chaperone!)
#`(vector/c #,@(map t->c ts))] #`(vector/c #,@(map t->c ts))]
[(Box: t) [(Box: t)

4
collects/typed-racket/rep/type-rep.rkt
View File

@ -101,10 +101,10 @@
[#:key 'vector]) [#:key 'vector])
;; elems are all Types ;; elems are all Types
(def-type HeterogenousVector ([elems (listof Type/c)]) (def-type HeterogeneousVector ([elems (listof Type/c)])
[#:frees (λ (f) (make-invariant (combine-frees (map f elems))))] [#:frees (λ (f) (make-invariant (combine-frees (map f elems))))]
[#:key 'vector] [#:key 'vector]
[#:fold-rhs (*HeterogenousVector (map type-rec-id elems))]) [#:fold-rhs (*HeterogeneousVector (map type-rec-id elems))])
;; elem is a Type ;; elem is a Type
(def-type Box ([elem Type/c]) (def-type Box ([elem Type/c])

10
collects/typed-racket/typecheck/tc-app/tc-app-hetero.rkt
View File

@ -91,7 +91,7 @@
;; vector-ref on het vectors ;; vector-ref on het vectors
(pattern (~and form ((~or vector-ref unsafe-vector-ref unsafe-vector*-ref) vec:expr index:expr)) (pattern (~and form ((~or vector-ref unsafe-vector-ref unsafe-vector*-ref) vec:expr index:expr))
(match (single-value #'vec) (match (single-value #'vec)
[(tc-result1: (and vec-t (app resolve (HeterogenousVector: es)))) [(tc-result1: (and vec-t (app resolve (HeterogeneousVector: es))))
(tc/hetero-ref #'index es vec-t expected "vector")] (tc/hetero-ref #'index es vec-t expected "vector")]
[v-ty (tc/app-regular #'form expected)])) [v-ty (tc/app-regular #'form expected)]))
;; unsafe struct-set! ;; unsafe struct-set!
@ -103,17 +103,17 @@
;; vector-set! on het vectors ;; vector-set! on het vectors
(pattern (~and form ((~or vector-set! unsafe-vector-set! unsafe-vector*-set!) v:expr index:expr val:expr)) (pattern (~and form ((~or vector-set! unsafe-vector-set! unsafe-vector*-set!) v:expr index:expr val:expr))
(match (single-value #'v) (match (single-value #'v)
[(tc-result1: (and vec-t (app resolve (HeterogenousVector: es)))) [(tc-result1: (and vec-t (app resolve (HeterogeneousVector: es))))
(tc/hetero-set! #'index es #'val vec-t expected "vector")] (tc/hetero-set! #'index es #'val vec-t expected "vector")]
[v-ty (tc/app-regular #'form expected)])) [v-ty (tc/app-regular #'form expected)]))
(pattern (~and form ((~or vector-immutable vector) args:expr ...)) (pattern (~and form ((~or vector-immutable vector) args:expr ...))
(match expected (match expected
[(tc-result1: (app resolve (Vector: t))) (tc/app-regular #'form expected)] [(tc-result1: (app resolve (Vector: t))) (tc/app-regular #'form expected)]
[(tc-result1: (app resolve (HeterogenousVector: ts))) [(tc-result1: (app resolve (HeterogeneousVector: ts)))
(unless (= (length ts) (length (syntax->list #'(args ...)))) (unless (= (length ts) (length (syntax->list #'(args ...))))
(tc-error/expr "expected vector with ~a elements, but got ~a" (tc-error/expr "expected vector with ~a elements, but got ~a"
(length ts) (length ts)
(make-HeterogenousVector (map tc-expr/t (syntax->list #'(args ...)))))) (make-HeterogeneousVector (map tc-expr/t (syntax->list #'(args ...))))))
(for ([e (in-list (syntax->list #'(args ...)))] (for ([e (in-list (syntax->list #'(args ...)))]
[t (in-list ts)]) [t (in-list ts)])
(tc-expr/check e (ret t))) (tc-expr/check e (ret t)))
@ -131,6 +131,6 @@
[_ (continue)])] [_ (continue)])]
;; since vectors are mutable, if there is no expected type, we want to generalize the element type ;; since vectors are mutable, if there is no expected type, we want to generalize the element type
[(or #f (tc-result1: _)) [(or #f (tc-result1: _))
(ret (make-HeterogenousVector (map (lambda (x) (generalize (tc-expr/t x))) (ret (make-HeterogeneousVector (map (lambda (x) (generalize (tc-expr/t x)))
(syntax->list #'(args ...)))))] (syntax->list #'(args ...)))))]
[_ (int-err "bad expected: ~a" expected)]))) [_ (int-err "bad expected: ~a" expected)])))

6
collects/typed-racket/typecheck/tc-expr-unit.rkt
View File

@ -101,13 +101,13 @@
t ;; so that this isn't (Un) when we get no elems t ;; so that this isn't (Un) when we get no elems
(for/list ([l (in-vector (syntax-e #'i))]) (for/list ([l (in-vector (syntax-e #'i))])
(tc-literal l t))))] (tc-literal l t))))]
[(HeterogenousVector: ts) [(HeterogeneousVector: ts)
(make-HeterogenousVector (make-HeterogeneousVector
(for/list ([l (in-vector (syntax-e #'i))] (for/list ([l (in-vector (syntax-e #'i))]
[t (in-list ts)]) [t (in-list ts)])
(tc-literal l t)))] (tc-literal l t)))]
;; errors are handled elsewhere ;; errors are handled elsewhere
[_ (make-HeterogenousVector (for/list ([l (syntax-e #'i)]) [_ (make-HeterogeneousVector (for/list ([l (syntax-e #'i)])
(generalize (tc-literal l #f))))])] (generalize (tc-literal l #f))))])]
[(~var i (3d hash?)) [(~var i (3d hash?))
(match expected (match expected

2
collects/typed-racket/types/printer.rkt
View File

@ -252,7 +252,7 @@
[(Function: arities) (fp "~a" (print-case-lambda c))] [(Function: arities) (fp "~a" (print-case-lambda c))]
[(arr: _ _ _ _ _) (fp "(arr ~a)" (format-arr c))] [(arr: _ _ _ _ _) (fp "(arr ~a)" (format-arr c))]
[(Vector: e) (fp "(Vectorof ~a)" e)] [(Vector: e) (fp "(Vectorof ~a)" e)]
[(HeterogenousVector: e) (fp "(Vector") [(HeterogeneousVector: e) (fp "(Vector")
(for ([i (in-list e)]) (for ([i (in-list e)])
(fp " ~a" i)) (fp " ~a" i))
(fp ")")] (fp ")")]

6
collects/typed-racket/types/subtype.rkt
View File

@ -287,7 +287,7 @@
(subtype* A0 t t*)] (subtype* A0 t t*)]
[((List: ts) (Sequence: (list t*))) [((List: ts) (Sequence: (list t*)))
(subtypes* A0 ts (map (λ _ t*) ts))] (subtypes* A0 ts (map (λ _ t*) ts))]
[((HeterogenousVector: ts) (Sequence: (list t*))) [((HeterogeneousVector: ts) (Sequence: (list t*)))
(subtypes* A0 ts (map (λ _ t*) ts))] (subtypes* A0 ts (map (λ _ t*) ts))]
[((Vector: t) (Sequence: (list t*))) [((Vector: t) (Sequence: (list t*)))
(subtype* A0 t t*)] (subtype* A0 t t*)]
@ -416,8 +416,8 @@
[((Set: t) (Set: t*)) (subtype* A0 t t*)] [((Set: t) (Set: t*)) (subtype* A0 t t*)]
[((Channel: _) (ChannelTop:)) A0] [((Channel: _) (ChannelTop:)) A0]
[((Vector: _) (VectorTop:)) A0] [((Vector: _) (VectorTop:)) A0]
[((HeterogenousVector: _) (VectorTop:)) A0] [((HeterogeneousVector: _) (VectorTop:)) A0]
[((HeterogenousVector: (list e ...)) (Vector: e*)) [((HeterogeneousVector: (list e ...)) (Vector: e*))
(if (andmap (lambda (e0) (type-equal? e0 e*)) e) A0 (fail! s t))] (if (andmap (lambda (e0) (type-equal? e0 e*)) e) A0 (fail! s t))]
[((MPair: _ _) (MPairTop:)) A0] [((MPair: _ _) (MPairTop:)) A0]
[((Hashtable: _ _) (HashtableTop:)) A0] [((Hashtable: _ _) (HashtableTop:)) A0]