Merge branch 'master' of github.com:joergen7/typed-racket

Author: joergen7

typed-racket-doc/typed-racket/scribblings/reference/special-forms.scrbl

@@ -225,9 +225,15 @@ To see how to declare a type for @racket[add-map], see the
                [for-clause [id : t seq-expr]
                            [(binding ...) seq-expr]
                            [id seq-expr]
-                           @code:line[#:when guard]]
+                           @code:line[#:when guard]
+                           @code:line[#:unless guard]
+                           @code:line[#:do [do-body ...]]
+                           break-clause
+                           @code:line[#:splice (splicing-id . form)]]
                [binding id
-                        [id : t]])]{
+                        [id : t]]
+               [break-clause @code:line[#:break guard]
+                             @code:line[#:final guard]])]{
 Like @|for-id| from @racketmodname[racket/base], but each @racket[id] has the associated type
 @racket[t]. The latter @racket[_ann-maybe] will be used first, and then the previous one.
 Since the return type is always @racket[Void],

typed-racket-doc/typed-racket/scribblings/reference/types.scrbl

@@ -352,6 +352,8 @@ corresponding to @racket[trest], where @racket[bound]
 @deftypeconstr[(MListof t)]{Returns the type of a homogeneous @rtech{mutable list} of @racket[t].}
 @deftypeconstr[(MPairof t u)]{Returns the type of a @rtech{Mutable pair} of @racket[t] and @racket[u].}
 
+@deftypeconstr[(TreeListof t)]{Returns the type of @rtech{treelist} of @racket[t]}
+
 @deftype[MPairTop]{Is the type of a @rtech{mutable pair} with unknown
   element types and is the supertype of all mutable pair types.
   This type typically appears in programs via the combination of

typed-racket-lib/typed-racket/HISTORY.txt

@@ -1,3 +1,8 @@
+8.16
+- Add `case-λ` as an alias for `case-lambda`
+- Bug fixes and type updates. 
+8.15
+- Bug fixes and type updates. 
 8.14
 - Bug fixes and type updates. 
 8.13

typed-racket-lib/typed-racket/base-env/annotate-classes.rkt

@@ -169,7 +169,7 @@
            #:with ty #'t))
 (define-splicing-syntax-class optional-standalone-annotation
   (pattern (~optional a:standalone-annotation)
-           #:attr ty (if (attribute a) #'a.ty #f)))
+           #:attr ty (and (attribute a) #'a.ty)))
 
 (define-syntax-class type-variables
   #:attributes ((vars 1))
@@ -330,10 +330,8 @@
                  (define-values (all-mand-tys all-opt-tys)
                    (cond
                      [kw-property
-                      (define-values (mand-kw-set opt-kw-set)
-                        (values
-                         (list->set (lambda-kws-mand kw-property))
-                         (list->set (lambda-kws-opt kw-property))))
+                      (define mand-kw-set (list->set (lambda-kws-mand kw-property)))
+                      (define opt-kw-set (list->set (lambda-kws-opt kw-property)))
 
                       (define-values (mand-tys^ opt-kw^)
                         (partition (part-pred opt-kw-set)

typed-racket-lib/typed-racket/base-env/base-env.rkt

@@ -8,6 +8,7 @@
   racket/unsafe/ops
   racket/unsafe/undefined
   racket/hash
+  racket/treelist
   (only-in racket/extflonum floating-point-bytes->extfl extfl->floating-point-bytes)
   ;(only-in rnrs/lists-6 fold-left)
   '#%paramz
@@ -1294,6 +1295,56 @@
 
 [unsafe-undefined -Unsafe-Undefined]
 
+;; Section 4.21 (TreeLists)
+
+[treelist (-poly (a) (->* (list) a (-treelist a)))]
+[treelist-empty? (-> (-treelist Univ) B)]
+[treelist-length (-> (-treelist Univ) -Index)]
+[treelist-member?
+ (-poly (a)
+        (cl->* ((-treelist a) a . -> . Univ)
+               ((-treelist a) a (-> a a Univ) . -> . B)))]
+[treelist-first (-poly (a) (-> (-treelist a) a :T+ #f))]
+[treelist-last (-poly (a) (-> (-treelist a) a :T+ #f))]
+[treelist-rest (-poly (a) (-> (-treelist a) (-treelist a)))]
+[treelist-add (-poly (a) (-> (-treelist a) a (-treelist a)))]
+[treelist-cons (-poly (a) (-> (-treelist a) a (-treelist a)))]
+[treelist-delete (-poly (a) (-> (-treelist a) -Index (-treelist a)))]
+[make-treelist (-poly (a) (-> -Nat a (-treelist a)))]
+[treelist-ref (-poly (a) (-> (-treelist a) -Index a :T+ #f))]
+[treelist-insert (-poly (a) (-> (-treelist a) -Index a (-treelist a)))]
+[treelist-set (-poly (a) (-> (-treelist a) -Index a (-treelist a)))]
+[treelist-take (-poly (a) (-> (-treelist a) -Index (-treelist a)))]
+[treelist-drop (-poly (a) (-> (-treelist a) -Index (-treelist a)))]
+[treelist-take-right (-poly (a) (-> (-treelist a) -Index (-treelist a)))]
+[treelist-drop-right (-poly (a) (-> (-treelist a) -Index (-treelist a)))]
+[treelist-sublist (-poly (a) (-> (-treelist a) -Index -Index (-treelist a)))]
+[treelist-reverse (-poly (a) (-> (-treelist a) (-treelist a)))]
+[treelist->list (-poly (a) (-> (-treelist a) (-lst a)))]
+[list->treelist (-poly (a) (-> (-lst a) (-treelist a)))]
+[treelist->vector (-poly (a) (-> (-treelist a) (-vec a)))]
+[vector->treelist (-poly (a) (-> (-vec a) (-treelist a)))]
+[in-treelist (-poly (a) (-> (-treelist a) (-seq a)))]
+[treelist? (unsafe-shallow:make-pred-ty (-treelist Univ))]
+[treelist-append (-poly (a) (->* (list) (-treelist a) (-treelist a)))]
+[treelist-map (-poly (a b) (-> (-treelist a) (-> a b) (-treelist b)))]
+[treelist-for-each (-poly (a b) (-> (-treelist a) (-> a b) -Void))]
+[treelist-filter (-poly (a) (-> (-> a Univ) (-treelist a) (-treelist a)))]
+[treelist-find (-poly (a) (-> (-treelist a) (-> a Univ) a :T+ #f))]
+[treelist-index-of
+ (-poly (a)
+        (cl->* ((-treelist a) a . -> . -Index)
+               ((-treelist a) a (-> a a Univ) . -> . -Index)))]
+[treelist-flatten (Univ . -> . (-treelist Univ))]
+[treelist-append* (-poly (a) (-> (-treelist (-treelist a)) (-treelist a)))]
+[treelist-sort
+(-poly
+  (a b)
+  (cl->*
+   (->key (-treelist a) (-> a a -Boolean) #:key (-opt (-> a a :T+ #f)) #f #:cache-keys? -Boolean #f (-treelist a))
+   (->key (-treelist a) (-> b b -Boolean) #:key (-> a b :T+ #f) #t #:cache-keys? -Boolean #f (-treelist a))))]
+
+
 ;; Section 5.2 (Structure Types)
 [make-struct-type
  (->opt -Symbol

typed-racket-lib/typed-racket/base-env/base-structs.rkt

@@ -11,7 +11,11 @@
 
 (require (for-template racket/base (prefix-in k: '#%kernel)))
 
-(provide initialize-structs -Date -Srcloc -Date -Arity-At-Least -Exn)
+(provide initialize-structs
+         -Date
+         -Srcloc
+         -Arity-At-Least
+         -Exn)
 
 (define-syntax define-hierarchy
   (syntax-rules (define-hierarchy)

typed-racket-lib/typed-racket/base-env/base-types.rkt

@@ -197,6 +197,7 @@
 [Async-Channelof -async-channel]
 [Ephemeronof -Ephemeron]
 [Setof -set]
+[TreeListof -treelist]
 [Evtof -evt]
 [Continuation-Mark-Set -Cont-Mark-Set]
 [False -False]

typed-racket-lib/typed-racket/base-env/for-clauses.rkt

@@ -25,8 +25,8 @@
            #:with (expand* ...) (list (quasisyntax/loc #'c
                                         ((v.ann-name ...) seq-expr.e))
                                       #'#:when #''#t))
-  (pattern (~seq (~and kw (~or #:when #:unless #:break #:final)) guard:expr)
-           #:with (expand ...) (list #'kw #'guard)
+  (pattern (~seq (~and kw (~or #:when #:unless #:break #:final #:do #:splice)) expr:expr)
+           #:with (expand ...) (list #'kw #'expr)
            #:with (expand* ...) #'(expand ...)))
 
 (define-syntax-class for-clauses

typed-racket-lib/typed-racket/base-env/prims.rkt

@@ -308,16 +308,29 @@ the typed racket language.
            (pattern (~seq (~and kw (~or #:break #:final)) guard-expr:expr)
                     #:with (expand ...) #'(kw guard-expr)))
          (define-syntax-class for-kw
+           (pattern #:when)
+           (pattern #:unless)
+           (pattern #:do)
+           (pattern #:splice))
+         (define-syntax-class for-when
            (pattern #:when
                     #:with replace-with #'when)
            (pattern #:unless
                     #:with replace-with #'unless))
          (syntax-parse clauses
-           [(head:for-clause next:for-clause ... kw:for-kw guard b:break-clause ... rest ...)
+           [(when:for-when guard) ; we end on a keyword clause
+            (quasisyntax/loc stx
+              (when.replace-with guard
+                #,@body))]
+           [(when:for-when guard rest ...)
+            (quasisyntax/loc stx
+              (when.replace-with guard
+                #,(loop #'(rest ...))))]
+           [(head:for-clause ... kw:for-kw expr b:break-clause ... rest ...)
             (add-ann
              (quasisyntax/loc stx
                (for
-                (head.expand ... next.expand ... ... kw guard b.expand ... ...)
+                (head.expand ... ... kw expr b.expand ... ...)
                 #,(loop #'(rest ...))))
              #'Void)]
            [(head:for-clause ...) ; we reached the end
@@ -326,15 +339,7 @@ the typed racket language.
                (for
                 (head.expand ... ...)
                 #,@body))
-             #'Void)]
-           [(kw:for-kw guard) ; we end on a keyword clause
-            (quasisyntax/loc stx
-              (kw.replace-with guard
-                #,@body))]
-           [(kw:for-kw guard rest ...)
-            (quasisyntax/loc stx
-              (kw.replace-with guard
-                #,(loop #'(rest ...))))])))]))
+             #'Void)])))]))
 
 (begin-for-syntax
   (define-splicing-syntax-class optional-standalone-annotation*

typed-racket-lib/typed-racket/base-env/unit-prims.rkt

@@ -133,12 +133,8 @@
 ;; in the signature, this is needed to typecheck define-values/invoke-unit forms
 (define-for-syntax (imports/members sig-id)
   (define-values (_1 imp-mem _2 _3) (signature-members sig-id sig-id))
-  #`(#,sig-id #,@(map (lambda (id)
-                        (local-expand
-                         id
-                         (syntax-local-context)
-                         (kernel-form-identifier-list)))
-                      imp-mem)))
+  #`(#,sig-id #,@(for/list ([id (in-list imp-mem)])
+                   (local-expand id (syntax-local-context) (kernel-form-identifier-list)))))
 
 ;; Given a list of signature specs
 ;; Processes each signature spec to determine the variables exported