diff --git a/collects/drscheme/acks.ss b/collects/drscheme/acks.ss index 20fdc9e163..601afb6739 100644 --- a/collects/drscheme/acks.ss +++ b/collects/drscheme/acks.ss @@ -1,4 +1,4 @@ -#lang scheme/base +#lang racket/base (provide get-general-acks get-translating-acks diff --git a/collects/drscheme/arrow.ss b/collects/drscheme/arrow.ss index 3c27480bce..6cc8852bc0 100644 --- a/collects/drscheme/arrow.ss +++ b/collects/drscheme/arrow.ss @@ -1,4 +1,4 @@ -#lang scheme/base +#lang racket/base (require scheme/class scheme/math diff --git a/collects/drscheme/default-code-style.ss b/collects/drscheme/default-code-style.ss index b4ea007e2d..971c64d4bc 100644 --- a/collects/drscheme/default-code-style.ss +++ b/collects/drscheme/default-code-style.ss @@ -1,4 +1,4 @@ -(module default-code-style mzscheme +#lang racket/base (provide color-default-code-styles bw-default-code-styles code-style-color @@ -24,4 +24,4 @@ (list 'unbound-variable (make-code-style "red" #f #f #f)) (list 'bound-variable (make-code-style "navy" #f #f #f)) (list 'primitive (make-code-style "navy" #f #f #f)) - (list 'constant (make-code-style '(51 135 39) #f #f #f))))) + (list 'constant (make-code-style '(51 135 39) #f #f #f)))) diff --git a/collects/drscheme/drscheme.ss b/collects/drscheme/drscheme.ss index e5c5207b8f..fab93a1b2e 100644 --- a/collects/drscheme/drscheme.ss +++ b/collects/drscheme/drscheme.ss @@ -1,4 +1,4 @@ -#lang scheme/base +#lang racket/base (require scheme/gui/base "private/key.ss") (define debugging? (getenv "PLTDRDEBUG")) diff --git a/collects/drscheme/installer.ss b/collects/drscheme/installer.ss index 79c6c2883f..c6259165ac 100644 --- a/collects/drscheme/installer.ss +++ b/collects/drscheme/installer.ss @@ -1,4 +1,4 @@ -(module installer mzscheme +#lang racket/base (require mzlib/file mzlib/etc launcher) @@ -18,4 +18,4 @@ (mred-program-launcher-path "DrScheme") (cons `(exe-name . "DrScheme") - (build-aux-from-path (build-path (collection-path "drscheme") "drscheme"))))))) + (build-aux-from-path (build-path (collection-path "drscheme") "drscheme")))))) diff --git a/collects/drscheme/main.ss b/collects/drscheme/main.ss index f5202c93ea..1c1d394370 100644 --- a/collects/drscheme/main.ss +++ b/collects/drscheme/main.ss @@ -1,2 +1,2 @@ -(module main scheme/base - (require "drscheme.ss")) +#lang racket/base +(require "drscheme.ss") diff --git a/collects/drscheme/private/app.ss b/collects/drscheme/private/app.ss index 71c67d4822..47dff1bcbc 100644 --- a/collects/drscheme/private/app.ss +++ b/collects/drscheme/private/app.ss @@ -1,10 +1,8 @@ #lang scheme/unit -(require mzlib/class - mzlib/list - scheme/file +(require racket/class string-constants - mred + racket/gui/base framework browser/external setup/getinfo diff --git a/collects/drscheme/private/bindings-browser.ss b/collects/drscheme/private/bindings-browser.ss index 9a2b5181ef..74bae33bd5 100644 --- a/collects/drscheme/private/bindings-browser.ss +++ b/collects/drscheme/private/bindings-browser.ss @@ -1,4 +1,4 @@ -#lang mzscheme +#lang racket/base #| CODE COPIED (with permission ...) from syntax-browser.ss @@ -9,13 +9,10 @@ Marshalling (and hence the 'read' method of the snipclass omitted for fast proto |# - (require mzlib/pretty - mzlib/list - mzlib/class - mred - mzlib/match - mzlib/string - mzlib/contract) + (require racket/pretty + racket/class + racket/gui/base + racket/contract) (provide render-bindings/snip) @@ -64,7 +61,7 @@ Marshalling (and hence the 'read' method of the snipclass omitted for fast proto ; how to enrich the notion of an output-port to get 'bold'ing to ; work otherwise... (let* ([before (send output-text last-position)]) - (pretty-print (syntax-object->datum stx)) + (pretty-print (syntax->datum stx)) (let* ([post-newline (send output-text last-position)]) (send output-text delete post-newline) ; delete the trailing \n. yuck! (send output-text insert " ") @@ -164,7 +161,7 @@ Marshalling (and hence the 'read' method of the snipclass omitted for fast proto (define black-style-delta (make-object style-delta% 'change-normal-color)) (define green-style-delta (make-object style-delta%)) - (send green-style-delta set-delta-foreground "forest green") + (void (send green-style-delta set-delta-foreground "forest green")) (define turn-snip% (class snip% diff --git a/collects/drscheme/private/bitmap-message.ss b/collects/drscheme/private/bitmap-message.ss index 80c440b0f7..afa90a2c9a 100644 --- a/collects/drscheme/private/bitmap-message.ss +++ b/collects/drscheme/private/bitmap-message.ss @@ -1,6 +1,6 @@ -#lang scheme +#lang racket/base -(require mred/mred) +(require racket/gui/base racket/class) (provide bitmap-message%) (define bitmap-message% diff --git a/collects/drscheme/private/debug.ss b/collects/drscheme/private/debug.ss index a60d0c792b..10214d7789 100644 --- a/collects/drscheme/private/debug.ss +++ b/collects/drscheme/private/debug.ss @@ -1,4 +1,4 @@ -#lang scheme/base +#lang racket/base #| @@ -10,11 +10,11 @@ profile todo: (require errortrace/errortrace-key scheme/unit - scheme/contract + racket/contract errortrace/stacktrace - scheme/class - scheme/path - scheme/gui/base + racket/class + racket/path + racket/gui/base string-constants framework framework/private/bday @@ -23,9 +23,9 @@ profile todo: "bindings-browser.ss" net/sendurl net/url - scheme/match + racket/match mrlib/include-bitmap - (for-syntax scheme/base)) + (for-syntax racket/base)) (define orig (current-output-port)) diff --git a/collects/drscheme/private/drscheme-normal.ss b/collects/drscheme/private/drscheme-normal.ss index 428f013005..1450eeae21 100644 --- a/collects/drscheme/private/drscheme-normal.ss +++ b/collects/drscheme/private/drscheme-normal.ss @@ -1,12 +1,12 @@ -#lang scheme/base +#lang racket/base (require mred - scheme/class - scheme/cmdline - scheme/list + racket/class + racket/cmdline + racket/list framework/private/bday framework/splash - scheme/file + racket/file "eb.ss") (define files-to-open (command-line #:args filenames filenames)) diff --git a/collects/drscheme/private/drsig.ss b/collects/drscheme/private/drsig.ss index 414fe8d8bc..a41a6860b6 100644 --- a/collects/drscheme/private/drsig.ss +++ b/collects/drscheme/private/drsig.ss @@ -1,4 +1,4 @@ -#lang scheme/base +#lang racket/base (require scheme/unit) (provide drscheme:eval^ diff --git a/collects/drscheme/private/eb.ss b/collects/drscheme/private/eb.ss index 6b74f5561f..09e3c99a93 100644 --- a/collects/drscheme/private/eb.ss +++ b/collects/drscheme/private/eb.ss @@ -1,7 +1,7 @@ -#lang scheme/base -(require scheme/class +#lang racket/base +(require racket/class framework/splash - scheme/gui/base) + racket/gui/base) (provide install-eb) (define (install-eb) diff --git a/collects/drscheme/private/embedded-snip-utils.ss b/collects/drscheme/private/embedded-snip-utils.ss index 9e96e233be..3c3dcf55a5 100644 --- a/collects/drscheme/private/embedded-snip-utils.ss +++ b/collects/drscheme/private/embedded-snip-utils.ss @@ -1,6 +1,6 @@ -#lang scheme/base -(require scheme/class - scheme/gui/base) +#lang racket/base +(require racket/class + racket/gui/base) (provide get-enclosing-editor-frame) diff --git a/collects/drscheme/private/eval.ss b/collects/drscheme/private/eval.ss index 8c55abdbb3..4cc00542d0 100644 --- a/collects/drscheme/private/eval.ss +++ b/collects/drscheme/private/eval.ss @@ -1,9 +1,9 @@ -#lang mzscheme +#lang racket/base (require mred - mzlib/unit - mzlib/port - mzlib/class + scheme/unit + racket/port + racket/class syntax/toplevel framework "drsig.ss") @@ -11,7 +11,7 @@ ;; to ensure this guy is loaded (and the snipclass installed) in the drscheme namespace & eventspace ;; these things are for effect only! (require mrlib/cache-image-snip - (prefix image-core: mrlib/image-core)) + (prefix-in image-core: mrlib/image-core)) (define op (current-output-port)) (define (oprintf . args) (apply fprintf op args)) @@ -173,7 +173,7 @@ (error-print-width 250) (current-ps-setup (make-object ps-setup%)) - (current-namespace (make-namespace 'empty)) + (current-namespace (make-empty-namespace)) (for-each (λ (x) (namespace-attach-module drscheme:init:system-namespace x)) to-be-copied-module-names)) diff --git a/collects/drscheme/private/font.ss b/collects/drscheme/private/font.ss index aa2dc23a8d..0428a5b698 100644 --- a/collects/drscheme/private/font.ss +++ b/collects/drscheme/private/font.ss @@ -1,8 +1,8 @@ -#lang mzscheme - (require mzlib/unit - mzlib/class +#lang racket/base + (require scheme/unit + racket/class + racket/gui/base "drsig.ss" - mred framework string-constants) diff --git a/collects/drscheme/private/frame.ss b/collects/drscheme/private/frame.ss index 30f5f6c471..c55512116f 100644 --- a/collects/drscheme/private/frame.ss +++ b/collects/drscheme/private/frame.ss @@ -1,9 +1,8 @@ #lang scheme/unit (require string-constants - mzlib/match - mzlib/class - mzlib/string - mzlib/list + racket/match + racket/class + racket/string "drsig.ss" mred framework @@ -11,7 +10,7 @@ net/head setup/plt-installer help/bug-report - scheme/file) + racket/file) (import [prefix drscheme:unit: drscheme:unit^] [prefix drscheme:app: drscheme:app^] diff --git a/collects/drscheme/private/get-extend.ss b/collects/drscheme/private/get-extend.ss index d0d492fac7..67e877d9f6 100644 --- a/collects/drscheme/private/get-extend.ss +++ b/collects/drscheme/private/get-extend.ss @@ -1,6 +1,6 @@ #lang scheme/unit -(require scheme/class +(require racket/class "drsig.ss") (import [prefix drscheme:unit: drscheme:unit^] diff --git a/collects/drscheme/private/help-desk.ss b/collects/drscheme/private/help-desk.ss index af8be7a308..cc1f6c5c1b 100644 --- a/collects/drscheme/private/help-desk.ss +++ b/collects/drscheme/private/help-desk.ss @@ -1,9 +1,9 @@ #lang scheme/unit -(require scheme/gui/base +(require racket/gui/base browser/external framework - scheme/class + racket/class net/url setup/dirs help/search diff --git a/collects/drscheme/private/honu-logo.ss b/collects/drscheme/private/honu-logo.ss index a60e3afa7c..6c36990c16 100644 --- a/collects/drscheme/private/honu-logo.ss +++ b/collects/drscheme/private/honu-logo.ss @@ -1,8 +1,8 @@ -#lang scheme/base +#lang racket/base (provide draw-honu) -(require scheme/class - scheme/gui/base +(require racket/class + racket/gui/base "palaka.ss") (define pi (atan 0 -1)) diff --git a/collects/drscheme/private/init.ss b/collects/drscheme/private/init.ss index 5c69bf7ca6..d3fc01bdc2 100644 --- a/collects/drscheme/private/init.ss +++ b/collects/drscheme/private/init.ss @@ -1,8 +1,7 @@ #lang scheme/unit (require string-constants "drsig.ss" - mzlib/list - mred) + racket/gui/base) (import) diff --git a/collects/drscheme/private/insert-large-letters.ss b/collects/drscheme/private/insert-large-letters.ss index 609d7ffa85..5184e03d5d 100644 --- a/collects/drscheme/private/insert-large-letters.ss +++ b/collects/drscheme/private/insert-large-letters.ss @@ -2,7 +2,7 @@ (require typed/mred/mred typed/framework/framework - scheme/class + racket/class string-constants/string-constant) diff --git a/collects/drscheme/private/key.ss b/collects/drscheme/private/key.ss index ccd52cc2d3..0df77cdffc 100644 --- a/collects/drscheme/private/key.ss +++ b/collects/drscheme/private/key.ss @@ -1,4 +1,4 @@ -#lang mzscheme +#lang racket/base (provide break-threads) (define super-cust (current-custodian)) (define first-child (make-custodian)) diff --git a/collects/drscheme/private/label-frame-mred.ss b/collects/drscheme/private/label-frame-mred.ss index 1ca3158cc0..842153fcb7 100644 --- a/collects/drscheme/private/label-frame-mred.ss +++ b/collects/drscheme/private/label-frame-mred.ss @@ -1,28 +1,28 @@ -#lang mzscheme - (require mred - mzlib/class) - (provide (all-from-except mred frame%) - (rename registering-frame% frame%) +#lang racket/base + (require racket/gui/base + racket/class) + (provide (except-out (all-from-out racket/gui/base) frame%) + (rename-out [registering-frame% frame%]) lookup-frame-name) (define (lookup-frame-name frame) (semaphore-wait label-sema) (begin0 - (hash-table-get label-ht frame (λ () #f)) + (hash-ref label-ht frame (λ () #f)) (semaphore-post label-sema))) (define label-sema (make-semaphore 1)) - (define label-ht (make-hash-table 'weak)) + (define label-ht (make-weak-hasheq)) (define registering-frame% (class frame% (define/override (set-label x) (semaphore-wait label-sema) - (hash-table-put! label-ht this x) + (hash-set! label-ht this x) (semaphore-post label-sema) (super set-label x)) (inherit get-label) (super-instantiate ()) (semaphore-wait label-sema) - (hash-table-put! label-ht this (get-label)) + (hash-set! label-ht this (get-label)) (semaphore-post label-sema))) diff --git a/collects/drscheme/private/language-configuration.ss b/collects/drscheme/private/language-configuration.ss index 1b9e223a7f..20efcb9c11 100644 --- a/collects/drscheme/private/language-configuration.ss +++ b/collects/drscheme/private/language-configuration.ss @@ -1,13 +1,13 @@ -#lang scheme/base +#lang racket/base (require scheme/unit mrlib/hierlist - scheme/class - scheme/contract - scheme/string - scheme/list + racket/class + racket/contract + racket/string + racket/list + racket/gui/base "drsig.ss" string-constants - mred framework setup/getinfo syntax/toplevel @@ -1252,7 +1252,12 @@ (message-box (string-constant drscheme) (format - "The drscheme-language-position, drscheme-language-modules, drscheme-language-numbers, and drscheme-language-readers specifications aren't correct. Expected (listof (cons string (listof string))), (listof (listof string)), (listof (listof number)), (listof string), (listof string), and (listof module-spec) respectively, where the lengths of the outer lists are the same. Got ~e, ~e, ~e, ~e, ~e, and ~e" + (string-append + "The drscheme-language-position, drscheme-language-modules, drscheme-language-numbers," + " and drscheme-language-readers specifications aren't correct. Expected" + " (listof (cons string (listof string))), (listof (listof string)), (listof (listof number)), (listof string)," + " (listof string), and (listof module-spec) respectively, where the lengths of the outer lists are the same." + " Got ~e, ~e, ~e, ~e, ~e, and ~e") lang-positions lang-modules numberss @@ -1431,7 +1436,7 @@ (let ([words #f]) (λ () (unless words - (set! words (text:get-completions/manuals '(scheme/base scheme/contract)))) + (set! words (text:get-completions/manuals '(racket/base racket/contract)))) words))) (define get-all-manual-keywords diff --git a/collects/drscheme/private/language-object-contract.ss b/collects/drscheme/private/language-object-contract.ss index dbb6eba60c..a9836f12d4 100644 --- a/collects/drscheme/private/language-object-contract.ss +++ b/collects/drscheme/private/language-object-contract.ss @@ -1,14 +1,14 @@ #reader scribble/reader -#lang scheme/base -(require (for-syntax scheme/base) +#lang racket/base +(require (for-syntax racket/base) scribble/srcdoc - scheme/class - scheme/gui/base - scheme/contract + racket/class + racket/gui/base + racket/contract "recon.ss") -(require/doc scheme/base scribble/manual) +(require/doc racket/base scribble/manual) -(require (for-meta 2 scheme/base)) +(require (for-meta 2 racket/base)) (provide language-object-abstraction) diff --git a/collects/drscheme/private/language.ss b/collects/drscheme/private/language.ss index 7387ce3377..d9f61db1c4 100644 --- a/collects/drscheme/private/language.ss +++ b/collects/drscheme/private/language.ss @@ -9,17 +9,17 @@ ;; NOTE: this module instantiates stacktrace itself, so we have ;; to be careful to not mix that instantiation with the one - ;; drscheme/private/debug.ss does. errortrace-lib's is for the + ;; drracket/private/debug.ss does. errortrace-lib's is for the ;; compilation handling, DrScheme's is for profiling and test coverage ;; (which do not do compilation) (prefix-in el: errortrace/errortrace-lib) mzlib/pconvert - scheme/pretty + racket/pretty mzlib/struct - scheme/class - scheme/file - scheme/list + racket/class + racket/file + racket/list compiler/embed launcher mred diff --git a/collects/drscheme/private/launcher-bootstrap.ss b/collects/drscheme/private/launcher-bootstrap.ss index 13e63f0313..36074c81e3 100644 --- a/collects/drscheme/private/launcher-bootstrap.ss +++ b/collects/drscheme/private/launcher-bootstrap.ss @@ -1,8 +1,8 @@ -#lang scheme/base +#lang racket/base (provide startup) -(require scheme/file) +(require racket/file) (define (read-from-string s) (read (open-input-string s))) diff --git a/collects/drscheme/private/launcher-mred-bootstrap.ss b/collects/drscheme/private/launcher-mred-bootstrap.ss index 20820223ab..ac676bb763 100644 --- a/collects/drscheme/private/launcher-mred-bootstrap.ss +++ b/collects/drscheme/private/launcher-mred-bootstrap.ss @@ -1,9 +1,9 @@ -#lang scheme/base +#lang racket/base -(require scheme/gui/base "launcher-bootstrap.ss") +(require racket/gui/base "launcher-bootstrap.ss") (current-namespace (make-gui-empty-namespace)) -(namespace-require 'scheme/gui/base) -(namespace-require 'scheme/class) +(namespace-require 'racket/gui/base) +(namespace-require 'racket/class) (startup) diff --git a/collects/drscheme/private/launcher-mz-bootstrap.ss b/collects/drscheme/private/launcher-mz-bootstrap.ss index f591a62c7a..e2054aebca 100644 --- a/collects/drscheme/private/launcher-mz-bootstrap.ss +++ b/collects/drscheme/private/launcher-mz-bootstrap.ss @@ -1,8 +1,8 @@ -#lang scheme/base +#lang racket/base (require "launcher-bootstrap.ss") (current-namespace (make-base-empty-namespace)) -(namespace-require 'scheme/base) +(namespace-require 'racket/base) (startup) diff --git a/collects/drscheme/private/link.ss b/collects/drscheme/private/link.ss index e2fabeceb9..e1ded533aa 100644 --- a/collects/drscheme/private/link.ss +++ b/collects/drscheme/private/link.ss @@ -1,4 +1,4 @@ -#lang scheme/base +#lang racket/base (require scheme/unit "modes.ss" "font.ss" diff --git a/collects/drscheme/private/main.ss b/collects/drscheme/private/main.ss index 998285168a..d54f1fd7dc 100644 --- a/collects/drscheme/private/main.ss +++ b/collects/drscheme/private/main.ss @@ -7,7 +7,7 @@ framework mzlib/class mzlib/list - scheme/path + racket/path browser/external setup/plt-installer) diff --git a/collects/drscheme/private/modes.ss b/collects/drscheme/private/modes.ss index 973d6275d2..f9a717578e 100644 --- a/collects/drscheme/private/modes.ss +++ b/collects/drscheme/private/modes.ss @@ -1,7 +1,7 @@ #lang scheme/unit (require string-constants - mzlib/class - mzlib/list + racket/class + racket/list framework "drsig.ss") @@ -23,7 +23,7 @@ (define (not-a-language-language? l) (and (not (null? l)) - (equal? (car (last-pair l)) + (equal? (last l) (string-constant no-language-chosen)))) (define (add-initial-modes) diff --git a/collects/drscheme/private/module-browser.ss b/collects/drscheme/private/module-browser.ss index d58fd4da64..281cfba0fc 100644 --- a/collects/drscheme/private/module-browser.ss +++ b/collects/drscheme/private/module-browser.ss @@ -1,7 +1,7 @@ -#lang scheme/base +#lang racket/base (require mred - scheme/class + racket/class syntax/moddep syntax/toplevel framework/framework @@ -9,7 +9,7 @@ mrlib/graph "drsig.ss" scheme/unit - scheme/async-channel + racket/async-channel setup/private/lib-roots) (define-struct req (filename key)) diff --git a/collects/drscheme/private/module-language-tools.ss b/collects/drscheme/private/module-language-tools.ss index 73bc52053d..deead1f19e 100644 --- a/collects/drscheme/private/module-language-tools.ss +++ b/collects/drscheme/private/module-language-tools.ss @@ -1,12 +1,12 @@ -#lang scheme/base +#lang racket/base (provide module-language-tools@) (require mrlib/switchable-button mrlib/bitmap-label - scheme/contract + racket/contract framework scheme/unit - scheme/class - scheme/gui/base + racket/class + racket/gui/base "drsig.ss") (define op (current-output-port)) diff --git a/collects/drscheme/private/module-language.ss b/collects/drscheme/private/module-language.ss index 7c09d02989..6ffa79b563 100644 --- a/collects/drscheme/private/module-language.ss +++ b/collects/drscheme/private/module-language.ss @@ -1,11 +1,11 @@ -#lang scheme/base +#lang racket/base (provide module-language@) (require scheme/unit - scheme/class - scheme/list - scheme/path - scheme/contract + racket/class + racket/list + racket/path + racket/contract mred compiler/embed compiler/cm @@ -382,7 +382,7 @@ #:literal-expression (begin (parameterize ([current-namespace (make-base-empty-namespace)]) - (namespace-require 'scheme/base) + (namespace-require 'racket/base) (compile `(namespace-require '',(string->symbol (path->string short-program-name)))))) #:cmdline '("-U" "--"))))) @@ -672,7 +672,7 @@ (raise-hopeless-syntax-error "bad syntax in name position of module" stx name)) (when filename (check-filename-matches filename name* stx)) - (let* (;; rewrite the module to use the scheme/base version of `module' + (let* (;; rewrite the module to use the racket/base version of `module' [mod (datum->syntax #'here 'module mod)] [expr (datum->syntax stx `(,mod ,name ,lang . ,body) stx stx)]) (values name lang expr))) diff --git a/collects/drscheme/private/multi-file-search.ss b/collects/drscheme/private/multi-file-search.ss index f185e45972..aa1647cd05 100644 --- a/collects/drscheme/private/multi-file-search.ss +++ b/collects/drscheme/private/multi-file-search.ss @@ -2,8 +2,8 @@ (require framework mzlib/class mred - scheme/file - scheme/path + racket/file + racket/path mzlib/thread mzlib/async-channel string-constants diff --git a/collects/drscheme/private/number-snip.ss b/collects/drscheme/private/number-snip.ss index 5426620d15..c224e5ab3a 100644 --- a/collects/drscheme/private/number-snip.ss +++ b/collects/drscheme/private/number-snip.ss @@ -1,6 +1,6 @@ -#lang mzscheme +#lang racket/base (require mred - mzlib/class + racket/class framework) (provide snip-class) diff --git a/collects/drscheme/private/palaka.ss b/collects/drscheme/private/palaka.ss index 70ba631293..f10c0e9f9f 100755 --- a/collects/drscheme/private/palaka.ss +++ b/collects/drscheme/private/palaka.ss @@ -1,5 +1,5 @@ -#lang scheme/base -(require scheme/class scheme/gui/base) +#lang racket/base +(require racket/class racket/gui/base) (provide draw-palaka palaka-pattern-size) (define scale 1) diff --git a/collects/drscheme/private/prefs-contract.ss b/collects/drscheme/private/prefs-contract.ss index dd62fb14d3..d850ca725e 100644 --- a/collects/drscheme/private/prefs-contract.ss +++ b/collects/drscheme/private/prefs-contract.ss @@ -1,6 +1,6 @@ -#lang scheme/base +#lang racket/base -(require (for-syntax scheme/base) +(require (for-syntax racket/base) framework/framework) (provide (rename-out [-preferences:get preferences:get]) diff --git a/collects/drscheme/private/profile-drs.ss b/collects/drscheme/private/profile-drs.ss index 78e0131d1f..819e83ae71 100644 --- a/collects/drscheme/private/profile-drs.ss +++ b/collects/drscheme/private/profile-drs.ss @@ -1,6 +1,6 @@ -#lang scheme/base -(require scheme/gui/base - scheme/class +#lang racket/base +(require racket/gui/base + racket/class profile/sampler profile/render-text profile/analyzer diff --git a/collects/drscheme/private/recon.ss b/collects/drscheme/private/recon.ss index 6c9a7f1822..3d7c37ce91 100644 --- a/collects/drscheme/private/recon.ss +++ b/collects/drscheme/private/recon.ss @@ -1,5 +1,5 @@ -#lang scheme/base -(require (for-syntax scheme/base)) +#lang racket/base +(require (for-syntax racket/base)) (provide reconstitute) (begin-for-syntax diff --git a/collects/drscheme/private/rep.ss b/collects/drscheme/private/rep.ss index 35aa44c1f5..7a8d95f40b 100644 --- a/collects/drscheme/private/rep.ss +++ b/collects/drscheme/private/rep.ss @@ -1,4 +1,4 @@ -#lang scheme/base +#lang racket/base #| @@ -20,15 +20,15 @@ TODO ;; user's io ports, to aid any debugging printouts. ;; (esp. useful when debugging the users's io) -(require scheme/class - scheme/path - scheme/pretty +(require racket/class + racket/path + racket/pretty scheme/unit - scheme/list + racket/list string-constants setup/xref - scheme/gui/base + racket/gui/base framework browser/external "drsig.ss" diff --git a/collects/drscheme/private/stick-figures.ss b/collects/drscheme/private/stick-figures.ss index 49a404ed67..dbe81bc423 100644 --- a/collects/drscheme/private/stick-figures.ss +++ b/collects/drscheme/private/stick-figures.ss @@ -1,7 +1,7 @@ -#lang mzscheme - (require mzlib/class - mzlib/pretty - mred) +#lang racket/base + (require racket/class + racket/pretty + racket/gui/base) (define head-size 40) (define small-bitmap-factor 1/2) diff --git a/collects/drscheme/private/tools.ss b/collects/drscheme/private/tools.ss index 5198030441..d66d10a192 100644 --- a/collects/drscheme/private/tools.ss +++ b/collects/drscheme/private/tools.ss @@ -1,9 +1,9 @@ #lang scheme/unit -(require scheme/class - scheme/list - scheme/runtime-path - scheme/contract +(require racket/class + racket/list + racket/runtime-path + racket/contract setup/getinfo mred framework @@ -13,7 +13,7 @@ mrlib/switchable-button string-constants) -(require (for-syntax scheme/base scheme/match)) +(require (for-syntax racket/base racket/match)) (import [prefix drscheme:frame: drscheme:frame^] [prefix drscheme:unit: drscheme:unit^] diff --git a/collects/drscheme/private/tracing.ss b/collects/drscheme/private/tracing.ss index 599b359d11..f30b0568cb 100644 --- a/collects/drscheme/private/tracing.ss +++ b/collects/drscheme/private/tracing.ss @@ -1,12 +1,12 @@ -#lang scheme/base +#lang racket/base -(require scheme/contract +(require racket/contract scheme/unit - scheme/class - scheme/path - scheme/port - scheme/list - scheme/gui/base + racket/class + racket/path + racket/port + racket/list + racket/gui/base string-constants framework (prefix-in tr: trace/stacktrace) diff --git a/collects/drscheme/private/ts.ss b/collects/drscheme/private/ts.ss index e1d6de5dc8..eb706554ef 100644 --- a/collects/drscheme/private/ts.ss +++ b/collects/drscheme/private/ts.ss @@ -1,5 +1,4 @@ -#reader scribble/reader -#lang scheme/base +#lang at-exp racket/base (require scribble/decode scribble/manual) diff --git a/collects/drscheme/private/unit.ss b/collects/drscheme/private/unit.ss index 67c1f52236..47b5df12c0 100644 --- a/collects/drscheme/private/unit.ss +++ b/collects/drscheme/private/unit.ss @@ -1,4 +1,4 @@ -#lang scheme/base +#lang racket/base #| closing: @@ -11,12 +11,12 @@ module browser threading seems wrong. |# - (require scheme/contract + (require racket/contract scheme/unit - scheme/class - scheme/path - scheme/port - scheme/list + racket/class + racket/path + racket/port + racket/list string-constants framework mrlib/name-message diff --git a/collects/drscheme/sprof.ss b/collects/drscheme/sprof.ss index 099dc03230..5f66b0c1ea 100644 --- a/collects/drscheme/sprof.ss +++ b/collects/drscheme/sprof.ss @@ -1,4 +1,4 @@ -#lang scheme/base +#lang racket/base (require scheme/gui/base framework scheme/class) diff --git a/collects/drscheme/syncheck-drscheme-button.ss b/collects/drscheme/syncheck-drscheme-button.ss index 25e5279643..a4d7f28d30 100644 --- a/collects/drscheme/syncheck-drscheme-button.ss +++ b/collects/drscheme/syncheck-drscheme-button.ss @@ -1,4 +1,4 @@ -#lang scheme/base +#lang racket/base (require scheme/class scheme/gui/base string-constants/string-constant) diff --git a/collects/drscheme/syncheck.ss b/collects/drscheme/syncheck.ss index 09c7ad29db..128cfa3496 100644 --- a/collects/drscheme/syncheck.ss +++ b/collects/drscheme/syncheck.ss @@ -1,4 +1,4 @@ -#lang scheme/base +#lang racket/base #| Check Syntax separates two classes of identifiers, diff --git a/collects/drscheme/tool-lib.ss b/collects/drscheme/tool-lib.ss index cbfa92f77b..8f8464faac 100644 --- a/collects/drscheme/tool-lib.ss +++ b/collects/drscheme/tool-lib.ss @@ -1,4 +1,4 @@ -#lang at-exp scheme/base +#lang at-exp racket/base #| @@ -9,7 +9,7 @@ all of the names in the tools library, for use defining keybindings |# (require scheme/class scheme/gui/base - scheme/unit + (except-in scheme/unit struct) scheme/contract scheme/class diff --git a/collects/drscheme/tool.ss b/collects/drscheme/tool.ss index 7fd1b8188c..ff4a7fbf66 100644 --- a/collects/drscheme/tool.ss +++ b/collects/drscheme/tool.ss @@ -1,4 +1,5 @@ -(module tool mzscheme - (require "private/drsig.ss") - (provide drscheme:tool^ - drscheme:tool-exports^)) +#lang racket/base +(require "private/drsig.ss") +(provide drscheme:tool^ + drscheme:tool-exports^) + diff --git a/collects/racket/set.rkt b/collects/racket/set.rkt index 2676037d7f..3dc363eb81 100644 --- a/collects/racket/set.rkt +++ b/collects/racket/set.rkt @@ -6,6 +6,7 @@ set-empty? set-count set-member? set-add set-remove set-union set-intersect set-subtract + set-subset? set-map set-for-each (rename-out [*in-set in-set]) for/set for/seteq for/seteqv @@ -163,6 +164,18 @@ (for/fold ([set set]) ([set2 (in-list sets)]) (set-subtract set set2))])) +(define (set-subset? set1 set2) + (unless (set? set1) (raise-type-error 'set-subset? "set" 0 set1 set2)) + (unless (set? set2) (raise-type-error 'set-subset? "set" 1 set1 set2)) + (let ([ht1 (set-ht set1)] + [ht2 (set-ht set2)]) + (unless (and (eq? (hash-eq? ht1) (hash-eq? ht2)) + (eq? (hash-eqv? ht1) (hash-eqv? ht2))) + (raise-mismatch-error 'set-subset? "second set's equivalence predicate is not the same as the first set: " + set2)) + (for/and ([v (in-hash-keys ht2)]) + (hash-ref ht1 v #f)))) + (define (set-map set proc) (unless (set? set) (raise-type-error 'set-map "set" 0 set proc)) (unless (and (procedure? proc) diff --git a/collects/scribble/racket.ss b/collects/scribble/racket.ss index 57144a7a99..ab3a05ca64 100644 --- a/collects/scribble/racket.ss +++ b/collects/scribble/racket.ss @@ -519,7 +519,7 @@ (set! src-col (+ src-col (- (syntax-span c) 2))) (set! src-col (+ src-col (- (syntax-column (vector-ref vec 0)) (syntax-column c) - 1))))))) + 1)))))) (when (struct? (syntax-e c)) (out "#s" p-color) (set! src-col (+ src-col 2))) @@ -532,7 +532,7 @@ (hash-set! next-col-map src-col dest-col) (let lloop ([l (cond [(vector? (syntax-e c)) - (vector->short-list (syntax-e c) syntax-e)] + (vector->short-list (syntax-e c) syntax-e)] [(struct? (syntax-e c)) (let ([l (vector->list (struct->vector (syntax-e c)))]) ;; Need to build key datum, syntax-ize it internally, and @@ -599,7 +599,7 @@ p-color) (set! src-col (+ src-col 1)) #; - (hash-set! next-col-map src-col dest-col))] + (hash-set! next-col-map src-col dest-col)))] [(box? (syntax-e c)) (advance c init-line!) (let ([quote-depth (to-quoted "`" qq? quote-depth out color? inc-src-col)]) @@ -700,7 +700,8 @@ (hash? s) (graph-defn? s) (graph-reference? s) - (struct-proxy? s)) + (struct-proxy? s) + (and qq? (identifier? c))) (gen-typeset c multi-line? prefix1 prefix suffix color? qq?) (typeset-atom c (letrec ([mk diff --git a/collects/scribblings/reference/chars.scrbl b/collects/scribblings/reference/chars.scrbl index 0c163335dd..3a328a8b17 100644 --- a/collects/scribblings/reference/chars.scrbl +++ b/collects/scribblings/reference/chars.scrbl @@ -217,8 +217,8 @@ category, which is @indexed-scheme['lu], @indexed-scheme['ll], @indexed-scheme['cn].} @defproc[(make-known-char-range-list) - (listof (list/c nonnegative-integer? - nonnegative-integer? + (listof (list/c exact-nonnegative-integer? + exact-nonnegative-integer? boolean?))]{ Produces a list of three-element lists, where each three-element list diff --git a/collects/scribblings/reference/data.scrbl b/collects/scribblings/reference/data.scrbl index 25dd6272c2..188dd30191 100644 --- a/collects/scribblings/reference/data.scrbl +++ b/collects/scribblings/reference/data.scrbl @@ -108,7 +108,7 @@ used as an ephemeron key (see @secref["ephemerons"]). @scheme[(string->symbol str)], but the resulting symbol is a new @tech{unreadable symbol}. Calling @scheme[string->unreadable-symbol] twice with equivalent @scheme[str]s returns the same symbol, but - @scheme[read] never produces the symbol.} + @scheme[read] never produces the symbol. @examples[(string->unreadable-symbol "Apple") (eq? 'a (string->unreadable-symbol "a")) diff --git a/collects/scribblings/reference/mz.ss b/collects/scribblings/reference/mz.ss index f4055713fb..f3114f5d3c 100644 --- a/collects/scribblings/reference/mz.ss +++ b/collects/scribblings/reference/mz.ss @@ -90,7 +90,7 @@ (provide exnraise Exn) (provide margin-note/ref - refalso moreref Guide guideintro guidesecref + refalso moreref Guide guideintro guidealso guidesecref HonuManual) (define (margin-note/ref . s) @@ -117,6 +117,10 @@ (decode-content (append (list finger (guidesecref tag) " in " Guide " introduces ") s (list "."))))) + + (define (guidealso tag) + (apply margin-note + (decode-content (append (list finger "See also " (guidesecref tag) " in " Guide "."))))) (define Guide (other-manual '(lib "scribblings/guide/guide.scrbl"))) diff --git a/collects/scribblings/reference/numbers.scrbl b/collects/scribblings/reference/numbers.scrbl index 0498d27caa..438ad742cd 100644 --- a/collects/scribblings/reference/numbers.scrbl +++ b/collects/scribblings/reference/numbers.scrbl @@ -453,7 +453,7 @@ used. @defproc[(log [z number?]) number?]{ Returns the natural logarithm of @scheme[z]. The result is normally inexact, but it is @scheme[0] when @scheme[z] is an exact @scheme[1]. When @scheme[z] - is exact @scheme[0], @exnraise[exn:fail:contract:divide-by-zero].} + is exact @scheme[0], @exnraise[exn:fail:contract:divide-by-zero]. @mz-examples[(log (exp 1)) (log 2+3i) (log 1)]} @@ -883,7 +883,7 @@ numbers}, which are also known as @deftech{flonums}. Flonum-specific operations provide can better performance when used consistently, and they are as safe as generic operations like @scheme[+]. -@margin-note{See @guidesecref["fixnums+flonums"].} +@guidealso["fixnums+flonums"] @subsection{Flonum Arithmetic} @@ -1080,7 +1080,7 @@ Safe versions of @scheme[unsafe-fx=], @scheme[unsafe-fx<], @note-lib[racket/math] -@defthing[pi real]{ +@defthing[pi real?]{ An approximation to the ratio of a circle's circumference to its diameter: @number->string[pi].} diff --git a/collects/scribblings/reference/pairs.scrbl b/collects/scribblings/reference/pairs.scrbl index e89b37938d..b6234dd27f 100644 --- a/collects/scribblings/reference/pairs.scrbl +++ b/collects/scribblings/reference/pairs.scrbl @@ -26,7 +26,7 @@ @(define-syntax (defc_r stx) (syntax-case stx () - [(_ x ... example) + [(_ x ... example-arg) (let ([xs (map syntax-e (syntax->list #'(x ...)))]) (let ([name (string->symbol (string-append @@ -58,10 +58,25 @@ span))) (datum->syntax #'here c (list (syntax-source stx) 1 pos (add1 pos) 1))))] - [example (datum->syntax #'here (syntax->datum #'example))] + [example (let ([ex #'example-arg]) + (datum->syntax #f + (list + (datum->syntax #f + name + (vector (syntax-source ex) + (syntax-line ex) + (- (syntax-column ex) 2) + (- (syntax-position ex) 2) + 1)) + ex) + (vector (syntax-source ex) + (syntax-line ex) + (- (syntax-column ex) 3) + (- (syntax-position ex) 3) + (+ (syntax-span ex) 4))))] [equiv equiv]) #'(defproc (name [v contract]) any/c - "Returns " (to-element 'equiv) (mz-examples (name example))))))])) + "Returns " (to-element 'equiv) (mz-examples example)))))])) @title[#:tag "pairs"]{Pairs and Lists} diff --git a/collects/scribblings/reference/regexps.scrbl b/collects/scribblings/reference/regexps.scrbl index 531149ef53..53d418025b 100644 --- a/collects/scribblings/reference/regexps.scrbl +++ b/collects/scribblings/reference/regexps.scrbl @@ -22,13 +22,13 @@ matching character streams; if a byte regexp is used with a character string, it matches bytes in the UTF-8 encoding of the string. Regular expressions can be compiled into a @deftech{regexp value} for -repeated matches. The @scheme[regexp] and @scheme[byte-regexp] +repeated matches. The @racket[regexp] and @racket[byte-regexp] procedures convert a string or byte string (respectively) into a regexp value using one syntax of regular expressions that is most -compatible to @exec{egrep}. The @scheme[pregexp] and -@scheme[byte-pregexp] procedures produce a regexp value using a +compatible to @exec{egrep}. The @racket[pregexp] and +@racket[byte-pregexp] procedures produce a regexp value using a slightly different syntax of regular expressions that is more -compatible with Perl. In addition, Scheme constants written with +compatible with Perl. In addition, Racket constants written with @litchar{#rx} or @litchar{#px} (see @secref["reader"]) produce compiled regexp values. @@ -43,22 +43,22 @@ The following syntax specifications describe the content of a string that represents a regular expression. The syntax of the corresponding string may involve extra escape characters. For example, the regular expression @litchar{(.*)\1} can be represented with the string -@scheme["(.*)\\1"] or the regexp constant @scheme[#rx"(.*)\\1"]; the +@racket["(.*)\\1"] or the regexp constant @racket[#rx"(.*)\\1"]; the @litchar{\} in the regular expression must be escaped to include it in a string or regexp constant. -The @scheme[regexp] and @scheme[pregexp] syntaxes share a common core: +The @racket[regexp] and @racket[pregexp] syntaxes share a common core: @common-table -The following completes the grammar for @scheme[regexp], which treats +The following completes the grammar for @racket[regexp], which treats @litchar["{"] and @litchar["}"] as literals, @litchar{\} as a literal within ranges, and @litchar{\} as a literal producer outside of ranges. @rx-table -The following completes the grammar for @scheme[pregexp], which uses +The following completes the grammar for @racket[pregexp], which uses @litchar["{"] and @litchar["}"] bounded repetition and uses @litchar{\} for meta-characters both inside and outside of ranges. @@ -101,26 +101,26 @@ arbitrarily large sequence). @defproc[(regexp? [v any/c]) boolean?]{ -Returns @scheme[#t] if @scheme[v] is a @tech{regexp value} created by -@scheme[regexp] or @scheme[pregexp], @scheme[#f] otherwise.} +Returns @racket[#t] if @racket[v] is a @tech{regexp value} created by +@racket[regexp] or @racket[pregexp], @racket[#f] otherwise.} @defproc[(pregexp? [v any/c]) boolean?]{ -Returns @scheme[#t] if @scheme[v] is a @tech{regexp value} created by -@scheme[pregexp] (not @scheme[regexp]), @scheme[#f] otherwise.} +Returns @racket[#t] if @racket[v] is a @tech{regexp value} created by +@racket[pregexp] (not @racket[regexp]), @racket[#f] otherwise.} @defproc[(byte-regexp? [v any/c]) boolean?]{ -Returns @scheme[#t] if @scheme[v] is a @tech{regexp value} created by -@scheme[byte-regexp] or @scheme[byte-pregexp], @scheme[#f] otherwise.} +Returns @racket[#t] if @racket[v] is a @tech{regexp value} created by +@racket[byte-regexp] or @racket[byte-pregexp], @racket[#f] otherwise.} @defproc[(byte-pregexp? [v any/c]) boolean?]{ -Returns @scheme[#t] if @scheme[v] is a @tech{regexp value} created by -@scheme[byte-pregexp] (not @scheme[byte-regexp]), @scheme[#f] +Returns @racket[#t] if @racket[v] is a @tech{regexp value} created by +@racket[byte-pregexp] (not @racket[byte-regexp]), @racket[#f] otherwise.} @@ -134,7 +134,7 @@ is used multiple times, it is faster to compile the string once to a @tech{regexp value} and use it for repeated matches instead of using the string each time. -The @scheme[object-name] procedure returns +The @racket[object-name] procedure returns the source string for a @tech{regexp value}. @examples[ @@ -144,10 +144,10 @@ the source string for a @tech{regexp value}. @defproc[(pregexp [string string?]) pregexp?]{ -Like @scheme[regexp], except that it uses a slightly different syntax +Like @racket[regexp], except that it uses a slightly different syntax (see @secref["regexp-syntax"]). The result can be used with -@scheme[regexp-match], etc., just like the result from -@scheme[regexp]. +@racket[regexp-match], etc., just like the result from +@racket[regexp]. @examples[ (pregexp "ap*le") @@ -160,7 +160,7 @@ Takes a byte-string representation of a regular expression (using the syntax in @secref["regexp-syntax"]) and compiles it into a byte-@tech{regexp value}. -The @scheme[object-name] procedure +The @racket[object-name] procedure returns the source byte string for a @tech{regexp value}. @examples[ @@ -171,10 +171,10 @@ returns the source byte string for a @tech{regexp value}. @defproc[(byte-pregexp [bstr bytes?]) byte-pregexp?]{ -Like @scheme[byte-regexp], except that it uses a slightly different +Like @racket[byte-regexp], except that it uses a slightly different syntax (see @secref["regexp-syntax"]). The result can be used with -@scheme[regexp-match], etc., just like the result from -@scheme[byte-regexp]. +@racket[regexp-match], etc., just like the result from +@racket[byte-regexp]. @examples[ (byte-pregexp #"ap*le") @@ -183,11 +183,11 @@ syntax (see @secref["regexp-syntax"]). The result can be used with @defproc*[([(regexp-quote [str string?] [case-sensitive? any/c #t]) string?] [(regexp-quote [bstr bytes?] [case-sensitive? any/c #t]) bytes?])]{ -Produces a string or byte string suitable for use with @scheme[regexp] -to match the literal sequence of characters in @scheme[str] or -sequence of bytes in @scheme[bstr]. If @scheme[case-sensitive?] is -true, the resulting regexp matches letters in @scheme[str] or -@scheme[bytes] case-insensitively, otherwise it matches +Produces a string or byte string suitable for use with @racket[regexp] +to match the literal sequence of characters in @racket[str] or +sequence of bytes in @racket[bstr]. If @racket[case-sensitive?] is +true, the resulting regexp matches letters in @racket[str] or +@racket[bytes] case-insensitively, otherwise it matches case-sensitively. @examples[ @@ -198,7 +198,7 @@ case-sensitively. @defproc[(regexp-max-lookbehind [pattern (or/c regexp? byte-regexp?)]) exact-nonnegative-integer?]{ -Returns the maximum number of bytes that @scheme[pattern] may consult +Returns the maximum number of bytes that @racket[pattern] may consult before the starting position of a match to determine the match. For example, the pattern @litchar{(?<=abc)d} consults three bytes preceding a matching @litchar{d}, while @litchar{e(?<=a..)d} consults @@ -220,93 +220,93 @@ the start of the input or of a line.} (or/c #f (cons/c string? (listof (or/c string? #f)))) (or/c #f (cons/c bytes? (listof (or/c bytes? #f)))))]{ -Attempts to match @scheme[pattern] (a string, byte string, @tech{regexp -value}, or byte-@tech{regexp value}) once to a portion of @scheme[input]. The -matcher finds a portion of @scheme[input] that matches and is closest -to the start of the input (after @scheme[start-pos]). +Attempts to match @racket[pattern] (a string, byte string, @tech{regexp +value}, or byte-@tech{regexp value}) once to a portion of @racket[input]. The +matcher finds a portion of @racket[input] that matches and is closest +to the start of the input (after @racket[start-pos]). -The optional @scheme[start-pos] and @scheme[end-pos] arguments select -a portion of @scheme[input] for matching; the default is the entire -string or the stream up to an end-of-file. When @scheme[input] is a -string, @scheme[start-pos] is a character position; when -@scheme[input] is a byte string, then @scheme[start-pos] is a byte -position; and when @scheme[input] is an input port, @scheme[start-pos] +The optional @racket[start-pos] and @racket[end-pos] arguments select +a portion of @racket[input] for matching; the default is the entire +string or the stream up to an end-of-file. When @racket[input] is a +string, @racket[start-pos] is a character position; when +@racket[input] is a byte string, then @racket[start-pos] is a byte +position; and when @racket[input] is an input port, @racket[start-pos] is the number of bytes to skip before starting to match. The -@scheme[end-pos] argument can be @scheme[#f], which corresponds to the +@racket[end-pos] argument can be @racket[#f], which corresponds to the end of the string or the end-of-file in the stream; otherwise, it is a -character or byte position, like @scheme[start-pos]. If @scheme[input] +character or byte position, like @racket[start-pos]. If @racket[input] is an input port, and if the end-of-file is reached before -@scheme[start-pos] bytes are skipped, then the match fails. +@racket[start-pos] bytes are skipped, then the match fails. -In @scheme[pattern], a start-of-string @litchar{^} refers to the first -position of @scheme[input] after @scheme[start-pos], assuming that -@scheme[input-prefix] is @scheme[#""]. The end-of-input @litchar{$} -refers to the @scheme[end-pos]th position or (in the case of an input +In @racket[pattern], a start-of-string @litchar{^} refers to the first +position of @racket[input] after @racket[start-pos], assuming that +@racket[input-prefix] is @racket[#""]. The end-of-input @litchar{$} +refers to the @racket[end-pos]th position or (in the case of an input port) the end of file, whichever comes first, assuming that -@scheme[output-prefix] is @scheme[#f]. +@racket[output-prefix] is @racket[#f]. -The @scheme[input-prefix] specifies bytes that effectively precede -@scheme[input] for the purposes of @litchar{^} and other look-behind -matching. For example, a @scheme[#""] prefix means that @litchar{^} -matches at the beginning of the stream, while a @scheme[#"\n"] -@scheme[input-prefix] means that a start-of-line @litchar{^} can match +The @racket[input-prefix] specifies bytes that effectively precede +@racket[input] for the purposes of @litchar{^} and other look-behind +matching. For example, a @racket[#""] prefix means that @litchar{^} +matches at the beginning of the stream, while a @racket[#"\n"] +@racket[input-prefix] means that a start-of-line @litchar{^} can match the beginning of the input, while a start-of-file @litchar{^} cannot. -If the match fails, @scheme[#f] is returned. If the match succeeds, a -list containing strings or byte string, and possibly @scheme[#f], is -returned. The list contains strings only if @scheme[input] is a string -and @scheme[pattern] is not a byte regexp. Otherwise, the list +If the match fails, @racket[#f] is returned. If the match succeeds, a +list containing strings or byte string, and possibly @racket[#f], is +returned. The list contains strings only if @racket[input] is a string +and @racket[pattern] is not a byte regexp. Otherwise, the list contains byte strings (substrings of the UTF-8 encoding of -@scheme[input], if @scheme[input] is a string). +@racket[input], if @racket[input] is a string). The first [byte] string in a result list is the portion of -@scheme[input] that matched @scheme[pattern]. If two portions of -@scheme[input] can match @scheme[pattern], then the match that starts +@racket[input] that matched @racket[pattern]. If two portions of +@racket[input] can match @racket[pattern], then the match that starts earliest is found. -Additional [byte] strings are returned in the list if @scheme[pattern] +Additional [byte] strings are returned in the list if @racket[pattern] contains parenthesized sub-expressions (but not when the open parenthesis is followed by @litchar{?:}). Matches for the sub-expressions are provided in the order of the opening parentheses -in @scheme[pattern]. When sub-expressions occur in branches of an +in @racket[pattern]. When sub-expressions occur in branches of an @litchar{|} ``or'' pattern, in a @litchar{*} ``zero or more'' pattern, or other places where the overall pattern can succeed without -a match for the sub-expression, then a @scheme[#f] is returned for the +a match for the sub-expression, then a @racket[#f] is returned for the sub-expression if it did not contribute to the final match. When a single sub-expression occurs within a @litchar{*} ``zero or more'' pattern or other multiple-match positions, then the rightmost match associated with the sub-expression is returned in the list. -If the optional @scheme[output-port] is provided as an output port, -the part of @scheme[input] from its beginning (not @scheme[start-pos]) -that precedes the match is written to the port. All of @scheme[input] -up to @scheme[end-pos] is written to the port if no match is -found. This functionality is most useful when @scheme[input] is an +If the optional @racket[output-port] is provided as an output port, +the part of @racket[input] from its beginning (not @racket[start-pos]) +that precedes the match is written to the port. All of @racket[input] +up to @racket[end-pos] is written to the port if no match is +found. This functionality is most useful when @racket[input] is an input port. When matching an input port, a match failure reads up to -@scheme[end-pos] bytes (or end-of-file), even if @scheme[pattern] +@racket[end-pos] bytes (or end-of-file), even if @racket[pattern] begins with a start-of-string @litchar{^}; see also -@scheme[regexp-try-match]. On success, all bytes up to and including +@racket[regexp-try-match]. On success, all bytes up to and including the match are eventually read from the port, but matching proceeds by -first peeking bytes from the port (using @scheme[peek-bytes-avail!]), +first peeking bytes from the port (using @racket[peek-bytes-avail!]), and then (re-)reading matching bytes to discard them after the match result is determined. Non-matching bytes may be read and discarded before the match is determined. The matcher peeks in blocking mode only as far as necessary to determine a match, but it may peek extra bytes to fill an internal buffer if immediately available (i.e., -without blocking). Greedy repeat operators in @scheme[pattern], such +without blocking). Greedy repeat operators in @racket[pattern], such as @litchar{*} or @litchar{+}, tend to force reading the entire -content of the port (up to @scheme[end-pos]) to determine a match. +content of the port (up to @racket[end-pos]) to determine a match. If the input port is read simultaneously by another thread, or if the port is a custom port with inconsistent reading and peeking procedures (see @secref["customport"]), then the bytes that are peeked and used for matching may be different than the bytes read and discarded after the match completes; the matcher inspects only the peeked -bytes. To avoid such interleaving, use @scheme[regexp-match-peek] -(with a @scheme[progress-evt] argument) followed by -@scheme[port-commit-peeked]. +bytes. To avoid such interleaving, use @racket[regexp-match-peek] +(with a @racket[progress-evt] argument) followed by +@racket[port-commit-peeked]. @examples[ (regexp-match #rx"x." "12x4x6") @@ -329,27 +329,27 @@ bytes. To avoid such interleaving, use @scheme[regexp-match-peek] (listof string?) (listof bytes?))]{ -Like @scheme[regexp-match], but the result is a list of strings or +Like @racket[regexp-match], but the result is a list of strings or byte strings corresponding to a sequence of matches of -@scheme[pattern] in @scheme[input]. (Unlike @scheme[regexp-match], -results for parenthesized sub-patterns in @scheme[pattern] are not +@racket[pattern] in @racket[input]. (Unlike @racket[regexp-match], +results for parenthesized sub-patterns in @racket[pattern] are not returned.) -The @scheme[pattern] is used in order to find matches, where each +The @racket[pattern] is used in order to find matches, where each match attempt starts at the end of the last match, and @litchar{^} is -allowed to match the beginning of the input (if @scheme[input-prefix] -is @scheme[#""]) only for the first match. Empty matches are handled +allowed to match the beginning of the input (if @racket[input-prefix] +is @racket[#""]) only for the first match. Empty matches are handled like other matches, returning a zero-length string or byte sequence -(they are more useful in the complementing @scheme[regexp-split] -function), but @scheme[pattern] is restricted from matching an empty +(they are more useful in the complementing @racket[regexp-split] +function), but @racket[pattern] is restricted from matching an empty sequence immediately after an empty match. -If @scheme[input] contains no matches (in the range @scheme[start-pos] -to @scheme[end-pos]), @scheme[null] is returned. Otherwise, each item +If @racket[input] contains no matches (in the range @racket[start-pos] +to @racket[end-pos]), @racket[null] is returned. Otherwise, each item in the resulting list is a distinct substring or byte sequence from -@scheme[input] that matches @scheme[pattern]. The @scheme[end-pos] -argument can be @scheme[#f] to match to the end of @scheme[input] -(which corresponds to an end-of-file if @scheme[input] is an input +@racket[input] that matches @racket[pattern]. The @racket[end-pos] +argument can be @racket[#f] to match to the end of @racket[input] +(which corresponds to an end-of-file if @racket[input] is an input port). @examples[ @@ -369,12 +369,12 @@ port). (or/c #f (cons/c string? (listof (or/c string? #f)))) (or/c #f (cons/c bytes? (listof (or/c bytes? #f)))))]{ -Like @scheme[regexp-match] on input ports, except that if the match -fails, no characters are read and discarded from @scheme[in]. +Like @racket[regexp-match] on input ports, except that if the match +fails, no characters are read and discarded from @racket[in]. -This procedure is especially useful with a @scheme[pattern] that -begins with a start-of-string @litchar{^} or with a non-@scheme[#f] -@scheme[end-pos], since each limits the amount of peeking into the +This procedure is especially useful with a @racket[pattern] that +begins with a start-of-string @litchar{^} or with a non-@racket[#f] +@racket[end-pos], since each limits the amount of peeking into the port. Otherwise, beware that a large portion of the stream may be peeked (and therefore pulled into memory) before the match succeeds or fails.} @@ -393,19 +393,19 @@ fails.} #f))) #f)]{ -Like @scheme[regexp-match], but returns a list of number pairs (and -@scheme[#f]) instead of a list of strings. Each pair of numbers refers -to a range of characters or bytes in @scheme[input]. If the result for -the same arguments with @scheme[regexp-match] would be a list of byte +Like @racket[regexp-match], but returns a list of number pairs (and +@racket[#f]) instead of a list of strings. Each pair of numbers refers +to a range of characters or bytes in @racket[input]. If the result for +the same arguments with @racket[regexp-match] would be a list of byte strings, the resulting ranges correspond to byte ranges; in that case, -if @scheme[input] is a character string, the byte ranges correspond to +if @racket[input] is a character string, the byte ranges correspond to bytes in the UTF-8 encoding of the string. -Range results are returned in a @scheme[substring]- and -@scheme[subbytes]-compatible manner, independent of -@scheme[start-pos]. In the case of an input port, the returned +Range results are returned in a @racket[substring]- and +@racket[subbytes]-compatible manner, independent of +@racket[start-pos]. In the case of an input port, the returned positions indicate the number of bytes that were read, including -@scheme[start-pos], before the first matching byte. +@racket[start-pos], before the first matching byte. @examples[ (regexp-match-positions #rx"x." "12x4x6") @@ -421,8 +421,8 @@ positions indicate the number of bytes that were read, including (listof (cons/c exact-nonnegative-integer? exact-nonnegative-integer?))]{ -Like @scheme[regexp-match-positions], but returns multiple matches -like @scheme[regexp-match*]. +Like @racket[regexp-match-positions], but returns multiple matches +like @racket[regexp-match*]. @examples[ (regexp-match-positions #rx"x." "12x4x6") @@ -437,8 +437,8 @@ like @scheme[regexp-match*]. [input-prefix bytes? #""]) boolean?]{ -Like @scheme[regexp-match], but returns merely @scheme[#t] when the -match succeeds, @scheme[#f] otherwise. +Like @racket[regexp-match], but returns merely @racket[#t] when the +match succeeds, @racket[#f] otherwise. @examples[ (regexp-match? #rx"x." "12x4x6") @@ -450,8 +450,8 @@ match succeeds, @scheme[#f] otherwise. [input (or/c string? bytes? input-port?)]) boolean?]{ -Like @scheme[regexp-match?], but @scheme[#t] is only returned when the -entire content of @scheme[input] matches @scheme[pattern]. +Like @racket[regexp-match?], but @racket[#t] is only returned when the +entire content of @racket[input] matches @racket[pattern]. @examples[ (regexp-match-exact? #rx"x." "12x4x6") @@ -468,15 +468,15 @@ entire content of @scheme[input] matches @scheme[pattern]. (or/c (cons/c bytes? (listof (or/c bytes? #f))) #f)]{ -Like @scheme[regexp-match] on input ports, but only peeks bytes from -@scheme[input] instead of reading them. Furthermore, instead of +Like @racket[regexp-match] on input ports, but only peeks bytes from +@racket[input] instead of reading them. Furthermore, instead of an output port, the last optional argument is a progress event for -@scheme[input] (see @scheme[port-progress-evt]). If @scheme[progress] -becomes ready, then the match stops peeking from @scheme[input] -and returns @scheme[#f]. The @scheme[progress] argument can be -@scheme[#f], in which case the peek may continue with inconsistent +@racket[input] (see @racket[port-progress-evt]). If @racket[progress] +becomes ready, then the match stops peeking from @racket[input] +and returns @racket[#f]. The @racket[progress] argument can be +@racket[#f], in which case the peek may continue with inconsistent information if another process meanwhile reads from -@scheme[input]. +@racket[input]. @examples[ (define p (open-input-string "a abcd")) @@ -502,9 +502,9 @@ information if another process meanwhile reads from #f))) #f)]{ -Like @scheme[regexp-match-positions] on input ports, but only peeks -bytes from @scheme[input] instead of reading them, and with a -@scheme[progress] argument like @scheme[regexp-match-peek].} +Like @racket[regexp-match-positions] on input ports, but only peeks +bytes from @racket[input] instead of reading them, and with a +@racket[progress] argument like @racket[regexp-match-peek].} @defproc[(regexp-match-peek-immediate [pattern (or/c string? bytes? regexp? byte-regexp?)] @@ -516,10 +516,10 @@ bytes from @scheme[input] instead of reading them, and with a (or/c (cons/c bytes? (listof (or/c bytes? #f))) #f)]{ -Like @scheme[regexp-match-peek], but it attempts to match only bytes -that are available from @scheme[input] without blocking. The +Like @racket[regexp-match-peek], but it attempts to match only bytes +that are available from @racket[input] without blocking. The match fails if not-yet-available characters might be used to match -@scheme[pattern].} +@racket[pattern].} @defproc[(regexp-match-peek-positions-immediate [pattern (or/c string? bytes? regexp? byte-regexp?)] @@ -535,10 +535,10 @@ match fails if not-yet-available characters might be used to match #f))) #f)]{ -Like @scheme[regexp-match-peek-positions], but it attempts to match -only bytes that are available from @scheme[input] without +Like @racket[regexp-match-peek-positions], but it attempts to match +only bytes that are available from @racket[input] without blocking. The match fails if not-yet-available characters might be -used to match @scheme[pattern].} +used to match @racket[pattern].} @defproc[(regexp-match-peek-positions* [pattern (or/c string? bytes? regexp? byte-regexp?)] @@ -549,8 +549,8 @@ used to match @scheme[pattern].} (listof (cons/c exact-nonnegative-integer? exact-nonnegative-integer?))]{ -Like @scheme[regexp-match-peek-positions], but returns multiple matches like -@scheme[regexp-match*].} +Like @racket[regexp-match-peek-positions], but returns multiple matches like +@racket[regexp-match*].} @defproc[(regexp-match/end [pattern (or/c string? bytes? regexp? byte-regexp?)] [input (or/c string? bytes? input-port?)] @@ -566,15 +566,15 @@ Like @scheme[regexp-match-peek-positions], but returns multiple matches like (or/c #f (cons/c bytes? (listof (or/c bytes? #f))))) (or/c #f bytes?))]{ -Like @scheme[regexp-match], but with a second result: a byte -string of up to @scheme[count] bytes that correspond to the input -(possibly including the @scheme[input-prefix]) leading to the end of -the match; the second result is @scheme[#f] if no match is found. +Like @racket[regexp-match], but with a second result: a byte +string of up to @racket[count] bytes that correspond to the input +(possibly including the @racket[input-prefix]) leading to the end of +the match; the second result is @racket[#f] if no match is found. -The second result can be useful as an @scheme[input-prefix] for -attempting a second match on @scheme[input] starting from the end of -the first match. In that case, use @scheme[regexp-max-lookbehind] -to determine an appropriate value for @scheme[count].} +The second result can be useful as an @racket[input-prefix] for +attempting a second match on @racket[input] starting from the end of +the first match. In that case, use @racket[regexp-max-lookbehind] +to determine an appropriate value for @racket[count].} @deftogether[( @defproc[(regexp-match-positions/end [pattern (or/c string? bytes? regexp? byte-regexp?)] @@ -618,8 +618,8 @@ to determine an appropriate value for @scheme[count].} (or/c #f bytes?))] )]{ -Like @scheme[regexp-match-positions], etc., but with a second result -like @scheme[regexp-match/end].} +Like @racket[regexp-match-positions], etc., but with a second result +like @racket[regexp-match/end].} @;------------------------------------------------------------------------ @section{Regexp Splitting} @@ -634,24 +634,24 @@ like @scheme[regexp-match/end].} (cons/c string? (listof string?)) (cons/c bytes? (listof bytes?)))]{ -The complement of @scheme[regexp-match*]: the result is a list of -strings (if @scheme[pattern] is a string or character regexp and -@scheme[input] is a string) or byte strings (otherwise) from in -@scheme[input] that are separated by matches to -@scheme[pattern]. Adjacent matches are separated with @scheme[""] or -@scheme[#""]. Zero-length matches are treated the same as for -@scheme[regexp-match*]. +The complement of @racket[regexp-match*]: the result is a list of +strings (if @racket[pattern] is a string or character regexp and +@racket[input] is a string) or byte strings (otherwise) from in +@racket[input] that are separated by matches to +@racket[pattern]. Adjacent matches are separated with @racket[""] or +@racket[#""]. Zero-length matches are treated the same as for +@racket[regexp-match*]. -If @scheme[input] contains no matches (in the range @scheme[start-pos] -to @scheme[end-pos]), the result is a list containing @scheme[input]'s -content (from @scheme[start-pos] to @scheme[end-pos]) as a single -element. If a match occurs at the beginning of @scheme[input] (at -@scheme[start-pos]), the resulting list will start with an empty +If @racket[input] contains no matches (in the range @racket[start-pos] +to @racket[end-pos]), the result is a list containing @racket[input]'s +content (from @racket[start-pos] to @racket[end-pos]) as a single +element. If a match occurs at the beginning of @racket[input] (at +@racket[start-pos]), the resulting list will start with an empty string or byte string, and if a match occurs at the end (at -@scheme[end-pos]), the list will end with an empty string or byte -string. The @scheme[end-pos] argument can be @scheme[#f], in which -case splitting goes to the end of @scheme[input] (which corresponds to -an end-of-file if @scheme[input] is an input port). +@racket[end-pos]), the list will end with an empty string or byte +string. The @racket[end-pos] argument can be @racket[#f], in which +case splitting goes to the end of @racket[input] (which corresponds to +an end-of-file if @racket[input] is an input port). @examples[ (regexp-split #rx" +" "12 34") @@ -675,52 +675,52 @@ an end-of-file if @scheme[input] is an input port). string? bytes?)]{ -Performs a match using @scheme[pattern] on @scheme[input], and then +Performs a match using @racket[pattern] on @racket[input], and then returns a string or byte string in which the matching portion of -@scheme[input] is replaced with @scheme[insert]. If @scheme[pattern] -matches no part of @scheme[input], then @scheme[iput] is returned +@racket[input] is replaced with @racket[insert]. If @racket[pattern] +matches no part of @racket[input], then @racket[iput] is returned unmodified. -The @scheme[insert] argument can be either a (byte) string, or a +The @racket[insert] argument can be either a (byte) string, or a function that returns a (byte) string. In the latter case, the -function is applied on the list of values that @scheme[regexp-match] +function is applied on the list of values that @racket[regexp-match] would return (i.e., the first argument is the complete match, and then one argument for each parenthesized sub-expression) to obtain a replacement (byte) string. -If @scheme[pattern] is a string or character regexp and @scheme[input] -is a string, then @scheme[insert] must be a string or a procedure that -accept strings, and the result is a string. If @scheme[pattern] is a -byte string or byte regexp, or if @scheme[input] is a byte string, -then @scheme[insert] as a string is converted to a byte string, -@scheme[insert] as a procedure is called with a byte string, and the +If @racket[pattern] is a string or character regexp and @racket[input] +is a string, then @racket[insert] must be a string or a procedure that +accept strings, and the result is a string. If @racket[pattern] is a +byte string or byte regexp, or if @racket[input] is a byte string, +then @racket[insert] as a string is converted to a byte string, +@racket[insert] as a procedure is called with a byte string, and the result is a byte string. -If @scheme[insert] contains @litchar{&}, then @litchar{&} -is replaced with the matching portion of @scheme[input] before it is -substituted into the match's place. If @scheme[insert] contains +If @racket[insert] contains @litchar{&}, then @litchar{&} +is replaced with the matching portion of @racket[input] before it is +substituted into the match's place. If @racket[insert] contains @litchar{\}@nonterm{n} for some integer @nonterm{n}, then it is replaced with the @nonterm{n}th matching sub-expression from -@scheme[input]. A @litchar{&} and @litchar{\0} are synonymous. If +@racket[input]. A @litchar{&} and @litchar{\0} are synonymous. If the @nonterm{n}th sub-expression was not used in the match, or if @nonterm{n} is greater than the number of sub-expressions in -@scheme[pattern], then @litchar{\}@nonterm{n} is replaced with the +@racket[pattern], then @litchar{\}@nonterm{n} is replaced with the empty string. To substitute a literal @litchar{&} or @litchar{\}, use @litchar{\&} and @litchar{\\}, respectively, in -@scheme[insert]. A @litchar{\$} in @scheme[insert] is +@racket[insert]. A @litchar{\$} in @racket[insert] is equivalent to an empty sequence; this can be used to terminate a number @nonterm{n} following @litchar{\}. If a @litchar{\} in -@scheme[insert] is followed by anything other than a digit, +@racket[insert] is followed by anything other than a digit, @litchar{&}, @litchar{\}, or @litchar{$}, then the @litchar{\} by itself is treated as @litchar{\0}. Note that the @litchar{\} described in the previous paragraphs is a -character or byte of @scheme[input]. To write such an @scheme[input] -as a Scheme string literal, an escaping @litchar{\} is needed -before the @litchar{\}. For example, the Scheme constant -@scheme["\\1"] is @litchar{\1}. +character or byte of @racket[input]. To write such an @racket[input] +as a Racket string literal, an escaping @litchar{\} is needed +before the @litchar{\}. For example, the Racket constant +@racket["\\1"] is @litchar{\1}. @examples[ (regexp-replace "mi" "mi casa" "su") @@ -740,13 +740,13 @@ before the @litchar{\}. For example, the Scheme constant [input-prefix bytes? #""]) (or/c string? bytes?)]{ -Like @scheme[regexp-replace], except that every instance of -@scheme[pattern] in @scheme[input] is replaced with @scheme[insert], +Like @racket[regexp-replace], except that every instance of +@racket[pattern] in @racket[input] is replaced with @racket[insert], instead of just the first match. Only non-overlapping instances of -@scheme[pattern] in @scheme[input] are replaced, so instances of -@scheme[pattern] within inserted strings are @italic{not} replaced +@racket[pattern] in @racket[input] are replaced, so instances of +@racket[pattern] within inserted strings are @italic{not} replaced recursively. Zero-length matches are treated the same as in -@scheme[regexp-match*]. +@racket[regexp-match*]. @examples[ (regexp-replace* "([Mm])i ([a-zA-Z]*)" "mi cerveza Mi Mi Mi" @@ -762,10 +762,10 @@ recursively. Zero-length matches are treated the same as in [(regexp-replace-quote [bstr bytes?]) bytes?])]{ Produces a string suitable for use as the third argument to -@scheme[regexp-replace] to insert the literal sequence of characters -in @scheme[str] or bytes in @scheme[bstr] as a replacement. -Concretely, every @litchar{\} and @litchar{&} in @scheme[str] or -@scheme[bstr] is protected by a quoting @litchar{\}. +@racket[regexp-replace] to insert the literal sequence of characters +in @racket[str] or bytes in @racket[bstr] as a replacement. +Concretely, every @litchar{\} and @litchar{&} in @racket[str] or +@racket[bstr] is protected by a quoting @litchar{\}. @examples[ (regexp-replace "UT" "Go UT!" "A&M") diff --git a/collects/scribblings/reference/sequences.scrbl b/collects/scribblings/reference/sequences.scrbl index 5a97e8fb84..67f2711f5e 100644 --- a/collects/scribblings/reference/sequences.scrbl +++ b/collects/scribblings/reference/sequences.scrbl @@ -331,8 +331,9 @@ the generator runs out of values to yield, the last value it computed will be returned for future invocations of the generator. Generators can be safely nested. -Note: the first form must be @scheme[()], and in the future this will -hold argument names that are used in the initial generator call. +Note: The first form must be @scheme[()]. In the future, the +@scheme[()] position will hold argument names that are used for the +initial generator call. @examples[#:eval (generator-eval) (define g (generator () diff --git a/collects/scribblings/reference/sets.scrbl b/collects/scribblings/reference/sets.scrbl index 32bcf72223..a61ff00c9f 100644 --- a/collects/scribblings/reference/sets.scrbl +++ b/collects/scribblings/reference/sets.scrbl @@ -52,11 +52,13 @@ to a later element takes precedence over the later element.} Returns @scheme[#t] if @scheme[set] has no members, @scheme[#f] otherwise.} + @defproc[(set-member? [set set?] [v any/c]) boolean?]{ Returns @scheme[#t] if @scheme[v] is in @scheme[set], @scheme[#f] otherwise.} + @defproc[(set-add [set set?] [v any/c]) set?]{ @margin-note{Like operations on immutable hash tables, ``constant @@ -101,6 +103,15 @@ runs in time proportional to the total size of all given @scheme[set]s except the first one.} +@defproc[(set-subset? [set set?] [set2 set?]) boolean?]{ + +Returns @scheme[#t] if every member of @scheme[set2] is in +@scheme[set], @scheme[#f] otherwise. The @scheme[set] and +@scheme[set2] must use the same equivalence predicate +(@scheme[equal?], @scheme[eq?], or @scheme[eqv?]). This operation +runs in time proportional to the size of @scheme[set2].} + + @defproc[(set-map [set set?] [proc (any/c . -> . any/c)]) (listof any/c)]{ diff --git a/collects/tests/mzscheme/set.ss b/collects/tests/mzscheme/set.ss index 345ca82960..9632b1fb3f 100644 --- a/collects/tests/mzscheme/set.ss +++ b/collects/tests/mzscheme/set.ss @@ -50,6 +50,11 @@ (test #t set-member? (set-remove s 5) 3) (test #f set-member? (set-remove s 3) 3) + (test #t set-subset? s (set 1 3)) + (test #t set-subset? s (set 1 2 3)) + (test #f set-subset? s (set 1 4)) + (test #t set-subset? s (set)) + (test 3 set-count (set-union s)) (test 6 set-count (set-union s (set 3 4 5 6))) (test 6 set-count (set-union (set 3 4 5 6) s))