From 3b1d5169f9be26569e6a455f07dc1ed98ad78195 Mon Sep 17 00:00:00 2001 From: Eli Barzilay Date: Fri, 21 Mar 2008 18:46:07 +0000 Subject: [PATCH] some clarifying comments svn: r9046 --- collects/srfi/1/alist.ss | 5 +++-- collects/srfi/1/delete.ss | 4 ++-- collects/srfi/1/filter.ss | 6 +++--- collects/srfi/1/fold.ss | 4 ++-- collects/srfi/1/lset.ss | 10 +++++----- collects/srfi/1/misc.ss | 8 ++++---- collects/srfi/1/search.ss | 6 +++--- 7 files changed, 22 insertions(+), 21 deletions(-) diff --git a/collects/srfi/1/alist.ss b/collects/srfi/1/alist.ss index dcd4b9e5c2..19e86e9326 100644 --- a/collects/srfi/1/alist.ss +++ b/collects/srfi/1/alist.ss @@ -40,7 +40,8 @@ alist-cons alist-copy alist-delete - #;alist-delete!) + #; alist-delete! ; lists are immutable + ) ;; Extended from R4RS to take an optional comparison argument. (define (my-assoc x lis [= equal?]) @@ -54,7 +55,7 @@ (define (alist-delete key alist [= equal?]) (filter (lambda (elt) (not (= key (car elt)))) alist)) -#; +#; ; lists are immutable (define (alist-delete! key alist [= equal?]) (filter! (lambda (elt) (not (= key (car elt)))) alist)) diff --git a/collects/srfi/1/delete.ss b/collects/srfi/1/delete.ss index 22f3f958bf..737aed3fa1 100644 --- a/collects/srfi/1/delete.ss +++ b/collects/srfi/1/delete.ss @@ -43,7 +43,7 @@ (define (delete x lis [= equal?]) (filter (lambda (y) (not (= x y))) lis)) -#; +#; ; lists are immutable (define delete! (x lis [= equal?]) (filter! (lambda (y) (not (= x y))) lis)) @@ -65,7 +65,7 @@ (new-tail (recur (delete x tail elt=)))) (if (eq? tail new-tail) lis (cons x new-tail)))))) -#; +#; ; lists are immutable (define (delete-duplicates! lis [elt= equal?]) (check-arg procedure? elt= 'delete-duplicates!) (let recur ((lis lis)) diff --git a/collects/srfi/1/filter.ss b/collects/srfi/1/filter.ss index 49b4168ae3..6c553601a5 100644 --- a/collects/srfi/1/filter.ss +++ b/collects/srfi/1/filter.ss @@ -77,7 +77,7 @@ ;; It just zips down contiguous runs of in and out elts in LIS doing the ;; minimal number of SET-CDR!s to splice the tail of one run of ins to the ;; beginning of the next. -#; +#; ; lists are immutable (define (filter! pred lis) (check-arg procedure? pred 'filter!) (let lp ((ans lis)) @@ -130,7 +130,7 @@ ;; It just zips down contiguous runs of in and out elts in LIS doing the ;; minimal number of SET-CDR!s to splice these runs together into the result ;; lists. -#; +#; ; lists are immutable (define (partition! pred lis) (check-arg procedure? pred 'partition!) (if (null-list? lis) (values lis lis) @@ -172,7 +172,7 @@ ;; Inline us, please. (define (my-remove pred l) (filter (lambda (x) (not (pred x))) l)) -#; +#; ; lists are immutable (define (remove! pred l) (filter! (lambda (x) (not (pred x))) l)) ;;; filter.ss ends here diff --git a/collects/srfi/1/fold.ss b/collects/srfi/1/fold.ss index 617eadebb0..c98f68f715 100644 --- a/collects/srfi/1/fold.ss +++ b/collects/srfi/1/fold.ss @@ -150,7 +150,7 @@ (define (append-map f lis1 . lists) (really-append-map append-map append f lis1 lists)) -#; +#; ; lists are immutable (define (append-map! f lis1 . lists) (really-append-map append-map! append! f lis1 lists)) @@ -185,7 +185,7 @@ (lp tail)))))) ;; We stop when LIS1 runs out, not when any list runs out. -#; +#; ; lists are immutable (define (map! f lis1 . lists) (check-arg procedure? f 'map!) (if (pair? lists) diff --git a/collects/srfi/1/lset.ss b/collects/srfi/1/lset.ss index a2301032d5..4c8a482fc5 100644 --- a/collects/srfi/1/lset.ss +++ b/collects/srfi/1/lset.ss @@ -106,7 +106,7 @@ ans lis)))) '() lists)) -#; +#; ; lists are immutable (define (lset-union! = . lists) (check-arg procedure? = 'lset-union!) (reduce (lambda (lis ans) ; Splice new elts of LIS onto the front of ANS. @@ -131,7 +131,7 @@ (every (lambda (lis) (s:member x lis =)) lists)) lis1))))) -#; +#; ; lists are immutable (define (lset-intersection! = lis1 . lists) (check-arg procedure? = 'lset-intersection!) (let ((lists (delete lis1 lists eq?))) ; Throw out any LIS1 vals. @@ -151,7 +151,7 @@ lists)) lis1))))) -#; +#; ; lists are immutable (define (lset-difference! = lis1 . lists) (check-arg procedure? = 'lset-difference!) (let ((lists (filter pair? lists))) ; Throw out empty lists. @@ -182,7 +182,7 @@ b))))) '() lists)) -#; +#; ; lists are immutable (define (lset-xor! = . lists) (check-arg procedure? = 'lset-xor!) (reduce (lambda (b a) ; Compute A xor B: @@ -214,7 +214,7 @@ lists))) lis1)))) -#; +#; ; lists are immutable (define (lset-diff+intersection! = lis1 . lists) (check-arg procedure? = 'lset-diff+intersection!) (cond ((every null-list? lists) (values lis1 '())) ; Short cut diff --git a/collects/srfi/1/misc.ss b/collects/srfi/1/misc.ss index c84f3e1046..6e59b41ac3 100644 --- a/collects/srfi/1/misc.ss +++ b/collects/srfi/1/misc.ss @@ -127,7 +127,7 @@ ;; append! append-reverse append-reverse! concatenate concatenate! ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#; +#; ; lists are immutable (define (my-append! . lists) ;; First, scan through lists looking for a non-empty one. (let lp ((lists lists) (prev '())) @@ -161,7 +161,7 @@ (if (null-list? rev-head) tail (lp (cdr rev-head) (cons (car rev-head) tail))))) -#; +#; ; lists are immutable (define (append-reverse! rev-head tail) (let lp ((rev-head rev-head) (tail tail)) (if (null-list? rev-head) tail @@ -170,10 +170,10 @@ (lp next-rev rev-head))))) (define (concatenate lists) (reduce-right append '() lists)) -#; +#; ; lists are immutable (define (concatenate! lists) (reduce-right my-append! '() lists)) -#; +#; ; lists are immutable (define (my-reverse! lis) (let lp ((lis lis) (ans '())) (if (null-list? lis) ans diff --git a/collects/srfi/1/search.ss b/collects/srfi/1/search.ss index 58d8bed1a1..2de0b3d114 100644 --- a/collects/srfi/1/search.ss +++ b/collects/srfi/1/search.ss @@ -83,7 +83,7 @@ ((pred (car lis)) (lp (cdr lis))) (else lis)))) -#; +#; ; lists are immutable (define (take-while! pred lis) (check-arg procedure? pred 'take-while!) (if (or (null-list? lis) (not (pred (car lis)))) '() @@ -104,7 +104,7 @@ (values (cons x prefix) suffix)) (values '() lis)))))) -#; +#; ; lists are immutable (define (span! pred lis) (check-arg procedure? pred 'span!) (if (or (null-list? lis) (not (pred (car lis)))) (values '() lis) @@ -117,7 +117,7 @@ (values lis suffix)))) (define (break pred lis) (span (lambda (x) (not (pred x))) lis)) -#; +#; ; lists are immutable (define (break! pred lis) (span! (lambda (x) (not (pred x))) lis)) (define (any pred lis1 . lists)