moved contents of unstable/set to racket/set

collects/racket/set.rkt

@@ -8,13 +8,16 @@
          set? set-eq? set-eqv? set-equal?
          set-empty? set-count
          set-member? set-add set-remove
-         set-union set-intersect set-subtract
+         set-union set-intersect set-subtract set-symmetric-difference
-         subset?
+         subset? proper-subset?
          set-map set-for-each 
          (rename-out [*in-set in-set])
          for/set for/seteq for/seteqv
          for*/set for*/seteq for*/seteqv
-         set/c)
+         set/c
+         set=?
+         set->list
+         list->set list->seteq list->seteqv)
 
 (define-serializable-struct set (ht)
   #:omit-define-syntaxes
@@ -222,17 +225,27 @@
     (for/fold ([set set]) ([set2 (in-list sets)])
       (set-subtract set set2))]))
 
-(define (subset? set2 set1)
+(define (subset* who set2 set1 proper?)
-  (unless (set? set2) (raise-type-error 'subset? "set" 0 set2 set1))
+  (unless (set? set2) (raise-type-error who "set" 0 set2 set1))
-  (unless (set? set1) (raise-type-error 'subset? "set" 0 set2 set1))
+  (unless (set? set1) (raise-type-error who "set" 0 set2 set1))
   (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: "
+      (raise-mismatch-error who
+                            "second set's equivalence predicate is not the same as the first set: "
                             set2))
-    (for/and ([v (in-hash-keys ht2)])
+    (and (for/and ([v (in-hash-keys ht2)])
-      (hash-ref ht1 v #f))))
+           (hash-ref ht1 v #f))
+         (if proper?
+             (< (hash-count ht2) (hash-count ht1))
+             #t))))
+
+(define (subset? one two)
+  (subset* 'subset? one two #f))
+
+(define (proper-subset? one two)
+  (subset* 'proper-subset? one two #t))
 
 (define (set-map set proc)
   (unless (set? set) (raise-type-error 'set-map "set" 0 set proc))
@@ -356,3 +369,55 @@
                   blame
                   s
                   "expected a <~a>, got ~v" (get-name c))))))))))
+
+;; ----
+
+(define (set=? one two)
+  (unless (set? one) (raise-type-error 'set=? "set" 0 one two))
+  (unless (set? two) (raise-type-error 'set=? "set" 1 one two))
+  ;; Sets implement prop:equal+hash
+  (equal? one two))
+
+(define set-symmetric-difference
+  (case-lambda
+    [(set)
+     (unless (set? set) (raise-type-error 'set-symmetric-difference "set" 0 set))
+     set]
+    [(set set2)
+     (unless (set? set) (raise-type-error 'set-symmetric-difference "set" 0 set set2))
+     (unless (set? set2) (raise-type-error 'set-symmetric-difference "set" 1 set set2))
+     (let ([ht1 (set-ht set)]
+           [ht2 (set-ht set2)])
+      (unless (and (eq? (hash-eq? ht1) (hash-eq? ht2))
+                   (eq? (hash-eqv? ht1) (hash-eqv? ht2)))
+        (raise-mismatch-error 'set-symmetric-difference
+                              "set's equivalence predicate is not the same as the first set: "
+                              set2))
+      (let-values ([(big small)
+                    (if (>= (hash-count ht1) (hash-count ht2))
+                        (values ht1 ht2)
+                        (values ht2 ht1))])
+        (make-set
+         (for/fold ([ht big]) ([e (in-hash-keys small)])
+           (if (hash-ref ht e #f)
+               (hash-remove ht e)
+               (hash-set ht e #t))))))]
+    [(set . sets)
+     (for ([s (in-list (cons set sets))]
+           [i (in-naturals)])
+       (unless (set? s) (apply raise-type-error 'set-symmetric-difference "set" i (cons s sets))))
+     (for/fold ([set set]) ([set2 (in-list sets)])
+       (set-symmetric-difference set set2))]))
+
+(define (set->list set)
+  (unless (set? set) (raise-type-error 'set->list "set" 0 set))
+  (for/list ([elem (in-hash-keys (set-ht set))]) elem))
+(define (list->set elems)
+  (unless (list? elems) (raise-type-error 'list->set "list" 0 elems))
+  (apply set elems))
+(define (list->seteq elems)
+  (unless (list? elems) (raise-type-error 'list->seteq "list" 0 elems))
+  (apply seteq elems))
+(define (list->seteqv elems)
+  (unless (list? elems) (raise-type-error 'list->seteqv "list" 0 elems))
+  (apply seteqv elems))

collects/racklog/lang/compiler.rkt

@@ -62,9 +62,6 @@
 (define (clause-predicate c)
   (literal-predicate (clause-head c)))
 
-(define (set->list s)
-  (for/list ([e (in-set s)]) e))
-
 (define literal-variables
   (match-lambda
     [(literal _ _ ts)

collects/scribblings/reference/sets.scrbl

@@ -110,13 +110,64 @@ runs in time proportional to the total size of all given
 @racket[st]s except the first one.}
 
 
+@defproc[(set-symmetric-difference [st set?] ...+) set?]{
+
+Produces a set containing only those elements found in each
+@racket[st] an odd number of times. All of the given @racket[st]s must
+use the same equivalence predicate (@racket[equal?], @racket[eq?], or
+@racket[eqv?]). This operation runs in time proportional to the total
+size of all given @racket[st]s except the first one.
+
+@examples[#:eval set-eval
+(set-symmetric-difference (set 1) (set 1 2) (set 1 2 3))
+]}
+
+
+@defproc[(set=? [st set?] [st2 set?]) boolean?]{
+
+Returns @racket[#t] if @racket[st] and @racket[st2] contain the same
+members, @racket[#f] otherwise. The @racket[st] and @racket[st2] must
+use the same equivalence predicate (@racket[equal?], @racket[eq?], or
+@racket[eqv?]).  This operation runs in time proportional to the size
+of @racket[st].
+
+Equivalent to @racket[(equal? st st2)].
+
+@examples[#:eval set-eval
+(set=? (set 1) (set 1 2 3))
+(set=? (set 1 2 3) (set 1))
+(set=? (set 1 2 3) (set 1 2 3))
+]}
+
 @defproc[(subset? [st set?] [st2 set?]) boolean?]{
 
 Returns @racket[#t] if every member of @racket[st] is in
 @racket[st2], @racket[#f] otherwise. The @racket[st] and
 @racket[st2] must use the same equivalence predicate
 (@racket[equal?], @racket[eq?], or @racket[eqv?]).  This operation
-runs in time proportional to the size of @racket[st].}
+runs in time proportional to the size of @racket[st].
+
+@examples[#:eval set-eval
+(subset? (set 1) (set 1 2 3))
+(subset? (set 1 2 3) (set 1))
+(subset? (set 1 2 3) (set 1 2 3))
+]}
+
+
+@defproc[(proper-subset? [st set?] [st2 set?]) boolean?]{
+
+Returns @racket[#t] if every member of @racket[st] is in @racket[st2]
+and there is some member of @racket[st2] that is not a member of
+@racket[st], @racket[#f] otherwise. The @racket[st] and @racket[st2]
+must use the same equivalence predicate (@racket[equal?],
+@racket[eq?], or @racket[eqv?]).  This operation runs in time
+proportional to the size of @racket[st].
+
+@examples[#:eval set-eval
+(proper-subset? (set 1) (set 1 2 3))
+(proper-subset? (set 1 2 3) (set 1))
+(proper-subset? (set 1 2 3) (set 1 2 3))
+]}
 
 
 @defproc[(set-map [st set?]
@@ -182,7 +233,27 @@ other forms.}
 Analogous to @racket[for/list] and @racket[for*/list], but to
 construct a set instead of a list.}
 
+
+@deftogether[(
+@defproc[(list->set [lst list?]) set?]
+@defproc[(list->seteq [lst list?]) set?]
+@defproc[(list->seteqv [lst list?]) set?]
+)]{
+
+Produces the appropriate type of set containing the elements of the
+given list. Equivalent to @racket[(apply set lst)], @racket[(apply
+seteq lst)], and @racket[(apply seteqv lst)], respectively.
+}
+
+@defproc[(set->list [st set?]) list?]{
+
+Produces a list containing the elements of @scheme[st].}
+
+
 @close-eval[set-eval]
 
 @(define i #'set)
-@(define i2 #'set-union)
+@(define i2 #'set-union)
+
+
+

collects/tests/unstable/set.rkt

@@ -1,6 +1,6 @@
 #lang racket
 
-(require rackunit rackunit/text-ui unstable/set "helpers.rkt")
+(require rackunit rackunit/text-ui racket/set "helpers.rkt")
 
 (define (check/set a-set a-list #:= [== equal?])
   (check/sort (set->list a-set) a-list #:= ==))
@@ -32,7 +32,7 @@
        (test (check-false (proper-subset? (set 1 2 3) (set 1))))
        (test (check-false (proper-subset? (set 1 2 3) (set 1 2 3))))))
    (test-suite "Combinations"
-     (test-suite "set-exclusive-or"
+     (test-suite "set-symmetric-difference"
-       (test/set (set-exclusive-or (set 1) (set 1 2) (set 1 2 3)) (list 1 3))
+       (test/set (set-symmetric-difference (set 1) (set 1 2) (set 1 2 3)) (list 1 3))
-       (test/set (set-exclusive-or (set 1) (set 2) (set 3)) (list 1 2 3))
+       (test/set (set-symmetric-difference (set 1) (set 2) (set 3)) (list 1 2 3))
-       (test/set (set-exclusive-or (set 1 2) (set 2 3) (set 1 3)) (list))))))
+       (test/set (set-symmetric-difference (set 1 2) (set 2 3) (set 1 3)) (list))))))

collects/unstable/scribblings/set.scrbl

@@ -1,80 +0,0 @@
-#lang scribble/manual
-@(require scribble/eval "utils.rkt" (for-label racket unstable/set))
-
-@title{Sets}
-
-@defmodule[unstable/set]
-
-@unstable[@author+email["Carl Eastlund" "cce@racket-lang.org"]]
-
-This module provides tools for representing finite sets.
-
-@deftogether[(
-@defproc[(list->set [lst list?]) set?]
-@defproc[(list->seteq [lst list?]) set?]
-@defproc[(list->seteqv [lst list?]) set?]
-)]{
-
-Produces the appropriate type of set containing the elements of the given list.
-
-@defexamples[
-#:eval (eval/require 'racket/set 'unstable/set)
-(define lst
-  (list 'atom (expt 2 100) (list 'compound)
-        'atom (expt 2 100) (list 'compound)))
-(list->set lst)
-(list->seteqv lst)
-(list->seteq lst)
-]
-
-}
-
-@defproc[(set=? [a set?] [b set?]) boolean?]{
-
-Reports whether two sets contain the same elements.
-
-@defexamples[
-#:eval (eval/require 'racket/set 'unstable/set)
-(set=? (set 1) (set 1 2 3))
-(set=? (set 1 2 3) (set 1))
-(set=? (set 1 2 3) (set 1 2 3))
-]
-
-}
-
-@defproc[(proper-subset? [a set?] [b set?]) boolean?]{
-
-Reports whether @scheme[b] contains all of the elements of @scheme[a], and at
-least one element not in @scheme[a].
-
-@defexamples[
-#:eval (eval/require 'racket/set 'unstable/set)
-(proper-subset? (set 1) (set 1 2 3))
-(proper-subset? (set 1 2 3) (set 1))
-(proper-subset? (set 1 2 3) (set 1 2 3))
-]
-
-}
-
-@defproc[(set->list [s set?]) list?]{
-
-Produces a list containing the elements of @scheme[s].
-
-@defexamples[
-#:eval (eval/require 'racket/set 'unstable/set)
-(set->list (set 1 2 3))
-]
-
-}
-
-@defproc[(set-exclusive-or [s set?] ...+) set?]{
-
-Produces a set containing only those elements found in each @scheme[s] an odd
-number of times.
-
-@defexamples[
-#:eval (eval/require 'racket/set 'unstable/set)
-(set-exclusive-or (set 1) (set 1 2) (set 1 2 3))
-]
-
-}

collects/unstable/scribblings/unstable.scrbl

@@ -96,7 +96,6 @@ Keep documentation and tests up to date.
 @include-section["pretty.scrbl"]
 @include-section["require.scrbl"]
 @include-section["sequence.scrbl"]
-@include-section["set.scrbl"]
 @include-section["sexp-diff.scrbl"]
 @include-section["string.scrbl"]
 @include-section["struct.scrbl"]

collects/unstable/set.rkt

@@ -1,43 +0,0 @@
-#lang racket/base
-(require racket/set racket/contract)
-
-(define (set->list set)
-  (for/list ([elem (in-set set)]) elem))
-
-(define (list->set elems) (apply set elems))
-(define (list->seteq elems) (apply seteq elems))
-(define (list->seteqv elems) (apply seteqv elems))
-
-(define (set=? one two)
-  ;; Sets implement prop:equal+hash
-  (equal? one two))
-
-(define (proper-subset? one two)
-  (and (< (set-count one) (set-count two))
-       (subset? one two)))
-
-(define (set-exclusive-or s0 . rest)
-  (for/fold ([s s0]) ([s* (in-list rest)])
-    (define-values [ big small ]
-      (if (>= (set-count s) (set-count s*))
-        (values s s*)
-        (values s* s)))
-    (for/fold ([s big]) ([e (in-set small)])
-      (if (set-member? s e)
-        (set-remove s e)
-        (set-add s e)))))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;
-;;  Exports
-;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(provide/contract
- [list->set (-> list? set?)]
- [list->seteq (-> list? set?)]
- [list->seteqv (-> list? set?)]
- [set->list (-> set? list?)]
- [set=? (-> set? set? boolean?)]
- [proper-subset? (-> set? set? boolean?)]
- [set-exclusive-or (->* [set?] [] #:rest (listof set?) set?)])