Fix missing set-integer-set-contents!

Closes PR 13368

This was a MzScheme -> Racket transition issue. Also
added tests and fixed some docs as well.

collects/data/integer-set.rkt

@@ -44,7 +44,7 @@
 ;; set is the union of the ranges.  The ranges must be disjoint and
 ;; increasing.  Further, adjacent ranges must have at least
 ;; one number between them.
-(define-struct integer-set (contents))
+(define-struct integer-set (contents) #:mutable)
 
 ;; well-formed-set? : X -> bool
 (define (well-formed-set? x)

collects/data/scribblings/integer-set.scrbl

@@ -86,7 +86,8 @@ that are not in @racket[y]).}
 Returns the union of the given sets.}
 
 
-@defproc[(split [x integer-set?][y integer-set?]) integer-set?]{
+@defproc[(split [x integer-set?][y integer-set?])
+         (values integer-set? integer-set? integer-set?)]{
 
 Produces three values: the first is the intersection of @racket[x] and
 @racket[y], the second is the difference @racket[x] remove @racket[y],
@@ -95,9 +96,9 @@ and the third is the difference @racket[y] remove @racket[x].}
 
 @defproc[(complement [s integer-set?]
                      [start exact-integer?]
-                     [end exact-integer?]) any]
+                     [end exact-integer?]) integer-set?]{
 
-Returns the a set containing the elements between @racket[start] to
+Returns a set containing the elements between @racket[start] to
 @racket[end] inclusive that are not in @racket[s], where
 @racket[(start-k . <= . end-k)].}
 
@@ -114,10 +115,9 @@ Returns @racket[#t] if @racket[k] is in @racket[s], @racket[#f]
 otherwise.}
 
 
-@defproc[(get-integer [integer-set any/c]) (or/c exact-integer? false/c)]{
+@defproc[(get-integer [set integer-set?]) (or/c exact-integer? #f)]{
 
-Returns a member of @racket[integer-set], or @racket[#f] if
-@racket[integer-set] is empty.}
+Returns a member of @racket[set], or @racket[#f] if @racket[set] is empty.}
 
 
 @defproc[(foldr [proc (exact-integer? any/c . -> . any/c)]
@@ -132,7 +132,7 @@ example, @racket[(foldr cons null s)] returns a list of all the
 integers in @racket[s], sorted in increasing order.}
 
 
-@defproc[(partition [s integer-set-list?]) (listof integer-set?)]{
+@defproc[(partition [s (listof integer-set?)]) (listof integer-set?)]{
 
 Returns the coarsest refinement of the sets in @racket[s] such that
 the sets in the result list are pairwise disjoint.  For example,

collects/tests/data/integer-set.rkt

@@ -0,0 +1,54 @@
+#lang racket/base
+(require data/integer-set
+         rackunit)
+
+(test-equal? "integer-set"
+             (integer-set-contents (make-integer-set '((-1 . 2) (4 . 10))))
+             '((-1 . 2) (4 . 10)))
+
+(test-true "integer-set?"
+           (integer-set? (make-integer-set '((-1 . 2) (4 . 10)))))
+
+(test-equal? "set-integer-set-contents!"
+             (let ([s (make-integer-set '((-1 . 2) (4 . 10)))])
+               (set-integer-set-contents! s '((1 . 1) (3 . 3)))
+               (integer-set-contents s))
+             '((1 . 1) (3 . 3)))
+
+(test-true "well-formed-set? true"
+           (well-formed-set? '((-1 . 2) (4 . 10))))
+
+(test-false "well-formed-set? false"
+            (well-formed-set? '((1 . 5) (6 . 7))))
+
+(define s1 (make-integer-set '((-1 . 2) (4 . 10))))
+(define s2 (make-integer-set '((1 . 1) (3 . 3))))
+
+(check-true (member? 1 (intersect s1 s2)))
+(check-false (member? 3 (intersect s1 s2)))
+
+(check-true (member? 2 (union s1 s2)))
+(check-false (member? 15 (union s1 s2)))
+
+(check-true (member? 4 (subtract s1 s2)))
+(check-false (member? 1 (subtract s1 s2)))
+
+(check-true (member? 4 (symmetric-difference s1 s2)))
+(check-true (member? 3 (symmetric-difference s1 s2)))
+(check-false (member? 1 (symmetric-difference s1 s2)))
+
+(check-equal? (count s1) 11)
+(check-equal? (count s2) 2)
+
+(check-true (member? (get-integer s1) s1))
+(check-false (get-integer (make-integer-set '())))
+
+;; TODO: custom equal?
+#;
+(check-equal? (partition (list (make-integer-set '((1 . 2) (5 . 10)))
+                               (make-integer-set '((2 . 2) (6 . 6) (12 . 12)))))
+              (list (make-integer-set '((1 . 1) (5 . 5) (7 . 10)))
+                    (make-integer-set '((2 . 2) (6 . 6)))
+                    (make-integer-set '((12 . 12)))))
+
+(check-true (subset? (make-integer-set '((1 . 1))) s2))