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 3 4) -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 #t) (-lst* -PosByte -PosByte (-val #t))]
[tc-e/t #(2 3 #t) (make-HeterogenousVector (list -Integer -Integer -Boolean))]
[tc-e (vector 2 "3" #t) (make-HeterogenousVector (list -Integer -String -Boolean))]
[tc-e (vector-immutable 2 "3" #t) (make-HeterogenousVector (list -Integer -String -Boolean))]
[tc-e/t #(2 3 #t) (make-HeterogeneousVector (list -Integer -Integer -Boolean))]
[tc-e (vector 2 "3" #t) (make-HeterogeneousVector (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 (build-vector 4 (lambda (x) 1)) (-vec -Integer)]
[tc-e (range 4) (-lst -Byte)]
@ -1371,7 +1371,7 @@
;Random Numbers
(tc-e (make-pseudo-random-generator) -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
(tc-e (make-struct-type-property 'prop) (list -Struct-Type-Property (t:-> Univ B) (t:-> Univ Univ)))

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

@ -36,7 +36,7 @@
make-ThreadCellTop
make-Ephemeron
make-CustodianBox
make-HeterogenousVector
make-HeterogeneousVector
make-ListDots))
;Section 9.2
@ -1190,12 +1190,12 @@
(-opt -Integer)
(-opt -Integer)
(-opt -Integer)))]
[srcvec (make-HeterogenousVector (list
Univ
(-opt -Integer)
(-opt -Integer)
(-opt -Integer)
(-opt -Integer)))]
[srcvec (make-HeterogeneousVector (list
Univ
(-opt -Integer)
(-opt -Integer)
(-opt -Integer)
(-opt -Integer)))]
[srcloc (Un S (-val #f) srclist srcvec)]
[prop (-opt S)]
[cert (-opt S)])
@ -1903,7 +1903,7 @@
(-val null)))))))))]
[module-compiled-language-info
(-> -Compiled-Module-Expression
(-opt (make-HeterogenousVector (list -Module-Path -Symbol Univ))))]
(-opt (make-HeterogeneousVector (list -Module-Path -Symbol Univ))))]
;Section 13.4.3
[dynamic-require
@ -1924,7 +1924,7 @@
[module->language-info
(->opt (Un -Module-Path -Path -Resolved-Module-Path)
[Univ]
(-opt (make-HeterogenousVector (list -Module-Path -Symbol Univ))))]
(-opt (make-HeterogeneousVector (list -Module-Path -Symbol Univ))))]
[module->imports (-> -Compiled-Module-Expression
@ -2087,11 +2087,11 @@
[pseudo-random-generator? (make-pred-ty -Pseudo-Random-Generator)]
[current-pseudo-random-generator (-Param -Pseudo-Random-Generator -Pseudo-Random-Generator)]
[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
(-> (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!
(-> -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)]

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

@ -449,12 +449,12 @@
[((List: ts) (Sequence: (list t*)))
(cset-meet* (for/list ([t (in-list ts)])
(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))]
[((HeterogenousVector: ts) (Vector: s))
[((HeterogeneousVector: ts) (Vector: s))
(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))]
[((HeterogenousVector: ts) (Sequence: (list t*)))
[((HeterogeneousVector: ts) (Sequence: (list t*)))
(cset-meet* (for/list ([t (in-list ts)])
(cg t t*)))]
[((Vector: t) (Sequence: (list t*)))

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

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

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

@ -26,7 +26,7 @@
#:commit
(pattern e:expr
#:when (match (type-of #'e)
[(tc-result1: (HeterogenousVector: _)) #t]
[(tc-result1: (HeterogeneousVector: _)) #t]
[_ #f])
#:with opt ((optimize) #'e)))
@ -43,7 +43,7 @@
this-syntax)
(add-disappeared-use #'op)
(match (type-of #'v)
[(tc-result1: (HeterogenousVector: es))
[(tc-result1: (HeterogeneousVector: es))
#`(begin v.opt #,(length es))]))) ; v may have side effects
;; we can optimize vector-length on all vectors.
;; 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)
(pattern (#%plain-app op:vector-op v:known-length-vector-expr i:expr new:expr ...)
#:when (let ((len (match (type-of #'v)
[(tc-result1: (HeterogenousVector: es)) (length es)]
[(tc-result1: (HeterogeneousVector: es)) (length es)]
[_ 0]))
(ival (or (syntax-parse #'i [((~literal quote) i:number) (syntax-e #'i)] [_ #f])
(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))]
[((~and kw t:Vector) ts ...)
(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)
(add-disappeared-use #'kw)
(-pair (parse-type #'fst) (parse-type #'rst))]

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

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

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

@ -101,10 +101,10 @@
[#:key 'vector])
;; 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))))]
[#:key 'vector]
[#:fold-rhs (*HeterogenousVector (map type-rec-id elems))])
[#:fold-rhs (*HeterogeneousVector (map type-rec-id elems))])
;; elem is a Type
(def-type Box ([elem Type/c])

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

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

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

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

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

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

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

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