suzanne.soy/racket
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix rotting indentation, switch to #lang

Browse Source 
svn: r8987
This commit is contained in:
Eli Barzilay 2008-03-16 15:17:50 +00:00
parent 696f8a24ba
commit 38ba4f29e8
12 changed files with 1292 additions and 1409 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
collects/srfi/1/alist.ss
View File

@ -32,8 +32,7 @@
;; hold me liable for its use. Please send bug reports to shivers@ai.mit.edu. ;; hold me liable for its use. Please send bug reports to shivers@ai.mit.edu.
;; -Olin ;; -Olin
(module alist #lang mzscheme
mzscheme
(require mzlib/etc (require mzlib/etc
srfi/optional srfi/optional
@ -47,7 +46,6 @@
alist-delete alist-delete
#;alist-delete!) #;alist-delete!)
;; Extended from R4RS to take an optional comparison argument. ;; Extended from R4RS to take an optional comparison argument.
(define my-assoc (define my-assoc
(opt-lambda (x lis (maybe-= equal?)) (opt-lambda (x lis (maybe-= equal?))
@ -71,6 +69,4 @@
(let ((= maybe-=)) (let ((= maybe-=))
(filter! (lambda (elt) (not (= key (car elt)))) alist)))) (filter! (lambda (elt) (not (= key (car elt)))) alist))))
)
;;; alist.ss ends here ;;; alist.ss ends here

25
collects/srfi/1/cons.ss
View File

@ -32,8 +32,7 @@
;; hold me liable for its use. Please send bug reports to shivers@ai.mit.edu. ;; hold me liable for its use. Please send bug reports to shivers@ai.mit.edu.
;; -Olin ;; -Olin
(module cons #lang mzscheme
mzscheme
(require mzlib/etc (require mzlib/etc
srfi/optional srfi/optional
@ -51,7 +50,6 @@
;; higher-order procedure. ;; higher-order procedure.
(define (xcons d a) (cons a d)) (define (xcons d a) (cons a d))
;; Make a list of length LEN. ;; Make a list of length LEN.
(define make-list (define make-list
@ -61,7 +59,6 @@
(ans '() (cons elt ans))) (ans '() (cons elt ans)))
((<= i 0) ans)))) ((<= i 0) ans))))
;; Make a list of length LEN. Elt i is (PROC i) for 0 <= i < LEN. ;; Make a list of length LEN. Elt i is (PROC i) for 0 <= i < LEN.
(define (list-tabulate len proc) (define (list-tabulate len proc)
@ -72,7 +69,7 @@
((< i 0) ans))) ((< i 0) ans)))
;; (cons* a1 a2 ... an) = (cons a1 (cons a2 (cons ... an))) ;; (cons* a1 a2 ... an) = (cons a1 (cons a2 (cons ... an)))
;; (cons* a1) = a1 (cons* a1 a2 ...) = (cons a1 (cons* a2 ...)) ;; (cons* a1) = a1; (cons* a1 a2 ...) = (cons a1 (cons* a2 ...))
;; ;;
;; (cons first (unfold not-pair? car cdr rest values)) ;; (cons first (unfold not-pair? car cdr rest values))
@ -82,26 +79,21 @@
(cons x (recur (car rest) (cdr rest))) (cons x (recur (car rest) (cdr rest)))
x))) x)))
(define (list-copy lis) (define (list-copy lis)
(let recur ((lis lis)) (let recur ((lis lis))
(if (pair? lis) (if (pair? lis)
(cons (car lis) (recur (cdr lis))) (cons (car lis) (recur (cdr lis)))
lis))) lis)))
(define (circular-list val1 . vals) (define (circular-list val1 . vals)
(let ([ph (make-placeholder #f)]) (let ([ph (make-placeholder #f)])
(placeholder-set! ph (placeholder-set! ph
(cons val1 (cons val1 (let loop ([vals vals])
(let loop ([vals vals])
(if (null? vals) (if (null? vals)
ph ph
(cons (car vals) (cons (car vals) (loop (cdr vals)))))))
(loop (cdr vals)))))))
(make-reader-graph ph))) (make-reader-graph ph)))
;; IOTA count [start step] (start start+step ... start+(count-1)*step) ;; IOTA count [start step] (start start+step ... start+(count-1)*step)
(define iota (define iota
@ -112,12 +104,7 @@
(unless (or (zero? count) (positive? count)) (unless (or (zero? count) (positive? count))
(error 'iota "count expected to be non-negative, got: ~a" count)) (error 'iota "count expected to be non-negative, got: ~a" count))
(let loop ([n 0]) (let loop ([n 0])
(cond (if (= n count) '()
[(= n count) '()] (cons (+ start (* n step)) (loop (add1 n)))))))
[else (cons (+ start (* n step))
(loop (add1 n)))]))))
)
;;; cons.ss ends here ;;; cons.ss ends here

6
collects/srfi/1/delete.ss
View File

@ -33,8 +33,7 @@
;; hold me liable for its use. Please send bug reports to shivers@ai.mit.edu. ;; hold me liable for its use. Please send bug reports to shivers@ai.mit.edu.
;; -Olin ;; -Olin
(module delete #lang mzscheme
mzscheme
(require mzlib/etc (require mzlib/etc
srfi/optional srfi/optional
@ -89,7 +88,4 @@
(new-tail (recur (delete! x tail elt=)))) (new-tail (recur (delete! x tail elt=))))
(if (eq? tail new-tail) lis (cons x new-tail)))))))) (if (eq? tail new-tail) lis (cons x new-tail))))))))
)
;;; delete.ss ends here ;;; delete.ss ends here

23
collects/srfi/1/filter.ss
View File

@ -32,13 +32,12 @@
;; hold me liable for its use. Please send bug reports to shivers@ai.mit.edu. ;; hold me liable for its use. Please send bug reports to shivers@ai.mit.edu.
;; -Olin ;; -Olin
(module filter #lang mzscheme
mzscheme
(require mzlib/etc (require mzlib/etc
srfi/optional srfi/optional
"predicate.ss") "predicate.ss"
(require srfi/8/receive) srfi/8/receive)
(provide filter (provide filter
partition partition
@ -47,7 +46,6 @@
(rename partition partition!) (rename partition partition!)
(rename remove remove!)) (rename remove remove!))
;; filter, remove, partition ;; filter, remove, partition
;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; FILTER, REMOVE, PARTITION and their destructive counterparts do not ;; FILTER, REMOVE, PARTITION and their destructive counterparts do not
@ -69,10 +67,6 @@
(cons head new-tail))) (cons head new-tail)))
(recur tail)))))) ; this one can be a tail call. (recur tail)))))) ; this one can be a tail call.
;; This implementation of FILTER! ;; This implementation of FILTER!
;; - doesn't cons, and uses no stack; ;; - doesn't cons, and uses no stack;
;; - is careful not to do redundant SET-CDR! writes, as writes to memory are ;; - is careful not to do redundant SET-CDR! writes, as writes to memory are
@ -87,7 +81,6 @@
(let lp ((ans lis)) (let lp ((ans lis))
(cond ((null-list? ans) ans) ; Scan looking for (cond ((null-list? ans) ans) ; Scan looking for
((not (pred (car ans))) (lp (cdr ans))) ; first cons of result. ((not (pred (car ans))) (lp (cdr ans))) ; first cons of result.
;; ANS is the eventual answer. ;; ANS is the eventual answer.
;; SCAN-IN: (CDR PREV) = LIS and (CAR PREV) satisfies PRED. ;; SCAN-IN: (CDR PREV) = LIS and (CAR PREV) satisfies PRED.
;; Scan over a contiguous segment of the list that ;; Scan over a contiguous segment of the list that
@ -114,8 +107,6 @@
(scan-in ans (cdr ans)) (scan-in ans (cdr ans))
ans))))) ans)))))
;; Answers share common tail with LIS where possible; ;; Answers share common tail with LIS where possible;
;; the technique is slightly subtle. ;; the technique is slightly subtle.
(define (partition pred lis) (define (partition pred lis)
@ -129,8 +120,6 @@
(values (if (pair? out) (cons elt in) lis) out) (values (if (pair? out) (cons elt in) lis) out)
(values in (if (pair? in) (cons elt out) lis)))))))) (values in (if (pair? in) (cons elt out) lis))))))))
;; This implementation of PARTITION! ;; This implementation of PARTITION!
;; - doesn't cons, and uses no stack; ;; - doesn't cons, and uses no stack;
;; - is careful not to do redundant SET-CDR! writes, as writes to memory are ;; - is careful not to do redundant SET-CDR! writes, as writes to memory are
@ -143,7 +132,6 @@
(define (partition! pred lis) (define (partition! pred lis)
(check-arg procedure? pred 'partition!) (check-arg procedure? pred 'partition!)
(if (null-list? lis) (values lis lis) (if (null-list? lis) (values lis lis)
;; This pair of loops zips down contiguous in & out runs of the ;; This pair of loops zips down contiguous in & out runs of the
;; list, splicing the runs together. The invariants are ;; list, splicing the runs together. The invariants are
;; SCAN-IN: (cdr in-prev) = LIS. ;; SCAN-IN: (cdr in-prev) = LIS.
@ -156,7 +144,6 @@
(begin (set-cdr! out-prev lis) (begin (set-cdr! out-prev lis)
(scan-out in-prev lis (cdr lis)))) (scan-out in-prev lis (cdr lis))))
(set-cdr! out-prev lis))))) ; Done. (set-cdr! out-prev lis))))) ; Done.
(scan-out (lambda (in-prev out-prev lis) (scan-out (lambda (in-prev out-prev lis)
(let lp ((out-prev out-prev) (lis lis)) (let lp ((out-prev out-prev) (lis lis))
(if (pair? lis) (if (pair? lis)
@ -165,7 +152,6 @@
(scan-in lis out-prev (cdr lis))) (scan-in lis out-prev (cdr lis)))
(lp lis (cdr lis))) (lp lis (cdr lis)))
(set-cdr! in-prev lis)))))) ; Done. (set-cdr! in-prev lis)))))) ; Done.
;; Crank up the scan&splice loops. ;; Crank up the scan&splice loops.
(if (pred (car lis)) (if (pred (car lis))
;; LIS begins in-list. Search for out-list's first pair. ;; LIS begins in-list. Search for out-list's first pair.
@ -174,7 +160,6 @@
((pred (car l)) (lp l (cdr l))) ((pred (car l)) (lp l (cdr l)))
(else (scan-out prev-l l (cdr l)) (else (scan-out prev-l l (cdr l))
(values lis l)))) ; Done. (values lis l)))) ; Done.
;; LIS begins out-list. Search for in-list's first pair. ;; LIS begins out-list. Search for in-list's first pair.
(let lp ((prev-l lis) (l (cdr lis))) (let lp ((prev-l lis) (l (cdr lis)))
(cond ((not (pair? l)) (values l lis)) (cond ((not (pair? l)) (values l lis))
@ -183,11 +168,9 @@
(values l lis)) ; Done. (values l lis)) ; Done.
(else (lp l (cdr l))))))))) (else (lp l (cdr l)))))))))
;; Inline us, please. ;; Inline us, please.
(define (remove pred l) (filter (lambda (x) (not (pred x))) l)) (define (remove pred l) (filter (lambda (x) (not (pred x))) l))
#; #;
(define (remove! pred l) (filter! (lambda (x) (not (pred x))) l)) (define (remove! pred l) (filter! (lambda (x) (not (pred x))) l))
)
;;; filter.ss ends here ;;; filter.ss ends here

34
collects/srfi/1/fold.ss
View File

@ -32,14 +32,13 @@
;; hold me liable for its use. Please send bug reports to shivers@ai.mit.edu. ;; hold me liable for its use. Please send bug reports to shivers@ai.mit.edu.
;; -Olin ;; -Olin
(module fold #lang mzscheme
mzscheme
(require srfi/optional (require srfi/optional
"predicate.ss" "predicate.ss"
"selector.ss" "selector.ss"
"util.ss") "util.ss"
(require srfi/8/receive) srfi/8/receive)
(provide (rename my-map map) (provide (rename my-map map)
(rename my-for-each for-each) (rename my-for-each for-each)
@ -58,7 +57,6 @@
filter-map filter-map
map-in-order) map-in-order)
;; fold/unfold ;; fold/unfold
;;;;;;;;;;;;;; ;;;;;;;;;;;;;;
@ -71,26 +69,21 @@
(lp (g seed) (lp (g seed)
(cons (f seed) ans))))) (cons (f seed) ans)))))
(define (unfold p f g seed . maybe-tail-gen) (define (unfold p f g seed . maybe-tail-gen)
(check-arg procedure? p 'unfold) (check-arg procedure? p 'unfold)
(check-arg procedure? f 'unfold) (check-arg procedure? f 'unfold)
(check-arg procedure? g 'unfold) (check-arg procedure? g 'unfold)
(if (pair? maybe-tail-gen) (if (pair? maybe-tail-gen)
(let ((tail-gen (car maybe-tail-gen))) (let ((tail-gen (car maybe-tail-gen)))
(if (pair? (cdr maybe-tail-gen)) (if (pair? (cdr maybe-tail-gen))
(apply error "Too many arguments" unfold p f g seed maybe-tail-gen) (apply error "Too many arguments" unfold p f g seed maybe-tail-gen)
(let recur ((seed seed)) (let recur ((seed seed))
(if (p seed) (tail-gen seed) (if (p seed) (tail-gen seed)
(cons (f seed) (recur (g seed))))))) (cons (f seed) (recur (g seed)))))))
(let recur ((seed seed)) (let recur ((seed seed))
(if (p seed) '() (if (p seed) '()
(cons (f seed) (recur (g seed))))))) (cons (f seed) (recur (g seed)))))))
(define (fold kons knil lis1 . lists) (define (fold kons knil lis1 . lists)
(check-arg procedure? kons 'fold) (check-arg procedure? kons 'fold)
(if (pair? lists) (if (pair? lists)
@ -98,12 +91,10 @@
(receive (cars+ans cdrs) (%cars+cdrs+ lists ans) (receive (cars+ans cdrs) (%cars+cdrs+ lists ans)
(if (null? cars+ans) ans ; Done. (if (null? cars+ans) ans ; Done.
(lp cdrs (apply kons cars+ans))))) (lp cdrs (apply kons cars+ans)))))
(let lp ((lis lis1) (ans knil)) ; Fast path (let lp ((lis lis1) (ans knil)) ; Fast path
(if (null-list? lis) ans (if (null-list? lis) ans
(lp (cdr lis) (kons (car lis) ans)))))) (lp (cdr lis) (kons (car lis) ans))))))
(define (fold-right kons knil lis1 . lists) (define (fold-right kons knil lis1 . lists)
(check-arg procedure? kons 'fold-right) (check-arg procedure? kons 'fold-right)
(if (pair? lists) (if (pair? lists)
@ -117,7 +108,6 @@
(let ((head (car lis))) (let ((head (car lis)))
(kons head (recur (cdr lis)))))))) (kons head (recur (cdr lis))))))))
(define (pair-fold-right f zero lis1 . lists) (define (pair-fold-right f zero lis1 . lists)
(check-arg procedure? f 'pair-fold-right) (check-arg procedure? f 'pair-fold-right)
(if (pair? lists) (if (pair? lists)
@ -125,7 +115,6 @@
(let ((cdrs (%cdrs lists))) (let ((cdrs (%cdrs lists)))
(if (null? cdrs) zero (if (null? cdrs) zero
(apply f (append lists (list (recur cdrs))))))) (apply f (append lists (list (recur cdrs)))))))
(let recur ((lis lis1)) ; Fast path (let recur ((lis lis1)) ; Fast path
(if (null-list? lis) zero (f lis (recur (cdr lis))))))) (if (null-list? lis) zero (f lis (recur (cdr lis)))))))
@ -136,13 +125,11 @@
(let ((tails (%cdrs lists))) (let ((tails (%cdrs lists)))
(if (null? tails) ans (if (null? tails) ans
(lp tails (apply f (append lists (list ans))))))) (lp tails (apply f (append lists (list ans)))))))
(let lp ((lis lis1) (ans zero)) (let lp ((lis lis1) (ans zero))
(if (null-list? lis) ans (if (null-list? lis) ans
(let ((tail (cdr lis))) ; Grab the cdr now, (let ((tail (cdr lis))) ; Grab the cdr now,
(lp tail (f lis ans))))))) ; in case F SET-CDR!s LIS. (lp tail (f lis ans))))))) ; in case F SET-CDR!s LIS.
;; REDUCE and REDUCE-RIGHT only use RIDENTITY in the empty-list case. ;; REDUCE and REDUCE-RIGHT only use RIDENTITY in the empty-list case.
;; These cannot meaningfully be n-ary. ;; These cannot meaningfully be n-ary.
@ -159,8 +146,6 @@
(f head (recur (car lis) (cdr lis))) (f head (recur (car lis) (cdr lis)))
head)))) head))))
;; Mappers: append-map append-map! pair-for-each map! filter-map map-in-order ;; Mappers: append-map append-map! pair-for-each map! filter-map map-in-order
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@ -180,7 +165,6 @@
(receive (cars2 cdrs2) (%cars+cdrs cdrs) (receive (cars2 cdrs2) (%cars+cdrs cdrs)
(if (null? cars2) vals (if (null? cars2) vals
(appender vals (recur cars2 cdrs2)))))))) (appender vals (recur cars2 cdrs2))))))))
;; Fast path ;; Fast path
(if (null-list? lis1) '() (if (null-list? lis1) '()
(let recur ((elt (car lis1)) (rest (cdr lis1))) (let recur ((elt (car lis1)) (rest (cdr lis1)))
@ -188,17 +172,14 @@
(if (null-list? rest) vals (if (null-list? rest) vals
(appender vals (recur (car rest) (cdr rest))))))))) (appender vals (recur (car rest) (cdr rest)))))))))
(define (pair-for-each proc lis1 . lists) (define (pair-for-each proc lis1 . lists)
(check-arg procedure? proc 'pair-for-each) (check-arg procedure? proc 'pair-for-each)
(if (pair? lists) (if (pair? lists)
(let lp ((lists (cons lis1 lists))) (let lp ((lists (cons lis1 lists)))
(let ((tails (%cdrs lists))) (let ((tails (%cdrs lists)))
(if (pair? tails) (if (pair? tails)
(begin (apply proc lists) (begin (apply proc lists)
(lp tails))))) (lp tails)))))
;; Fast path. ;; Fast path.
(let lp ((lis lis1)) (let lp ((lis lis1))
(if (not (null-list? lis)) (if (not (null-list? lis))
@ -216,12 +197,10 @@
(receive (heads tails) (%cars+cdrs/no-test lists) (receive (heads tails) (%cars+cdrs/no-test lists)
(set-car! lis1 (apply f (car lis1) heads)) (set-car! lis1 (apply f (car lis1) heads))
(lp (cdr lis1) tails)))) (lp (cdr lis1) tails))))
;; Fast path. ;; Fast path.
(pair-for-each (lambda (pair) (set-car! pair (f (car pair)))) lis1)) (pair-for-each (lambda (pair) (set-car! pair (f (car pair)))) lis1))
lis1) lis1)
;; Map F across L, and save up all the non-false results. ;; Map F across L, and save up all the non-false results.
(define (filter-map f lis1 . lists) (define (filter-map f lis1 . lists)
(check-arg procedure? f 'filter-map) (check-arg procedure? f 'filter-map)
@ -232,7 +211,6 @@
(cond ((apply f cars) => (lambda (x) (cons x (recur cdrs)))) (cond ((apply f cars) => (lambda (x) (cons x (recur cdrs))))
(else (recur cdrs))) ; Tail call in this arm. (else (recur cdrs))) ; Tail call in this arm.
'()))) '())))
;; Fast path. ;; Fast path.
(let recur ((lis lis1)) (let recur ((lis lis1))
(if (null-list? lis) lis (if (null-list? lis) lis
@ -240,7 +218,6 @@
(cond ((f (car lis)) => (lambda (x) (cons x tail))) (cond ((f (car lis)) => (lambda (x) (cons x tail)))
(else tail))))))) (else tail)))))))
;; Map F across lists, guaranteeing to go left-to-right. ;; Map F across lists, guaranteeing to go left-to-right.
;; NOTE: Some implementations of R5RS MAP are compliant with this spec; ;; NOTE: Some implementations of R5RS MAP are compliant with this spec;
;; in which case this procedure may simply be defined as a synonym for MAP. ;; in which case this procedure may simply be defined as a synonym for MAP.
@ -254,7 +231,6 @@
(let ((x (apply f cars))) ; Do head first, (let ((x (apply f cars))) ; Do head first,
(cons x (recur cdrs))) ; then tail. (cons x (recur cdrs))) ; then tail.
'()))) '())))
;; Fast path. ;; Fast path.
(let recur ((lis lis1)) (let recur ((lis lis1))
(if (null-list? lis) lis (if (null-list? lis) lis
@ -262,7 +238,6 @@
(x (f (car lis)))) ; Do head first, (x (f (car lis)))) ; Do head first,
(cons x (recur tail))))))) ; then tail. (cons x (recur tail))))))) ; then tail.
;; We extend MAP to handle arguments of unequal length. ;; We extend MAP to handle arguments of unequal length.
(define my-map map-in-order) (define my-map map-in-order)
@ -280,12 +255,11 @@
(begin (begin
(apply f cars) ; Do head first, (apply f cars) ; Do head first,
(recur cdrs))))) ; then tail. (recur cdrs))))) ; then tail.
;; Fast path. ;; Fast path.
(let recur ((lis lis1)) (let recur ((lis lis1))
(if (not (null-list? lis)) (if (not (null-list? lis))
(begin (begin
(f (car lis)) ; Do head first, (f (car lis)) ; Do head first,
(recur (cdr lis))))))) (recur (cdr lis)))))))
)
;;; fold.ss ends here ;;; fold.ss ends here

11
collects/srfi/1/list.ss
View File

@ -212,7 +212,7 @@
;; with an s: to avoid colliding with mzscheme. The wrapper 1.ss ;; with an s: to avoid colliding with mzscheme. The wrapper 1.ss
;; changes their names back to the non-prefixed form. ;; changes their names back to the non-prefixed form.
(module list mzscheme #lang mzscheme
(require srfi/optional) (require srfi/optional)
@ -231,9 +231,7 @@
(rename "alist.ss" s:assoc assoc) (rename "alist.ss" s:assoc assoc)
"lset.ss") "lset.ss")
(provide (all-from "cons.ss")
(provide
(all-from "cons.ss")
(all-from "selector.ss") (all-from "selector.ss")
(all-from "predicate.ss") (all-from "predicate.ss")
(all-from "misc.ss") (all-from "misc.ss")
@ -243,8 +241,3 @@
(all-from "delete.ss") (all-from "delete.ss")
(all-from "alist.ss") (all-from "alist.ss")
(all-from "lset.ss")) (all-from "lset.ss"))
;;end of the unit
)

24
collects/srfi/1/lset.ss
View File

@ -32,8 +32,7 @@
;; hold me liable for its use. Please send bug reports to shivers@ai.mit.edu. ;; hold me liable for its use. Please send bug reports to shivers@ai.mit.edu.
;; -Olin ;; -Olin
(module lset #lang mzscheme
mzscheme
(require srfi/optional (require srfi/optional
(all-except "search.ss" member) (all-except "search.ss" member)
@ -41,8 +40,8 @@
(rename "search.ss" s:member member) (rename "search.ss" s:member member)
"delete.ss" "delete.ss"
"predicate.ss" "predicate.ss"
"filter.ss") "filter.ss"
(require srfi/8/receive) srfi/8/receive)
(provide lset<= (provide lset<=
lset= lset=
@ -93,13 +92,11 @@
(and (%lset2<= = s1 s2) (%lset2<= = s2 s1))) ; Real test (and (%lset2<= = s1 s2) (%lset2<= = s2 s1))) ; Real test
(lp s2 rest))))))) (lp s2 rest)))))))
(define (lset-adjoin = lis . elts) (define (lset-adjoin = lis . elts)
(check-arg procedure? = 'lset-adjoin) (check-arg procedure? = 'lset-adjoin)
(fold (lambda (elt ans) (if (s:member elt ans =) ans (cons elt ans))) (fold (lambda (elt ans) (if (s:member elt ans =) ans (cons elt ans)))
lis elts)) lis elts))
(define (lset-union = . lists) (define (lset-union = . lists)
(check-arg procedure? = 'lset-union) (check-arg procedure? = 'lset-union)
(reduce (lambda (lis ans) ; Compute ANS + LIS. (reduce (lambda (lis ans) ; Compute ANS + LIS.
@ -107,7 +104,8 @@
((null? ans) lis) ; if we don't have to. ((null? ans) lis) ; if we don't have to.
((eq? lis ans) ans) ((eq? lis ans) ans)
(else (else
(fold (lambda (elt ans) (if (any (lambda (x) (= x elt)) ans) (fold (lambda (elt ans)
(if (any (lambda (x) (= x elt)) ans)
ans ans
(cons elt ans))) (cons elt ans)))
ans lis)))) ans lis))))
@ -129,7 +127,6 @@
ans lis)))) ans lis))))
'() lists)) '() lists))
(define (lset-intersection = lis1 . lists) (define (lset-intersection = lis1 . lists)
(check-arg procedure? = 'lset-intersection) (check-arg procedure? = 'lset-intersection)
(let ((lists (delete lis1 lists eq?))) ; Throw out any LIS1 vals. (let ((lists (delete lis1 lists eq?))) ; Throw out any LIS1 vals.
@ -149,7 +146,6 @@
(every (lambda (lis) (s:member x lis =)) lists)) (every (lambda (lis) (s:member x lis =)) lists))
lis1))))) lis1)))))
(define (lset-difference = lis1 . lists) (define (lset-difference = lis1 . lists)
(check-arg procedure? = 'lset-difference) (check-arg procedure? = 'lset-difference)
(let ((lists (filter pair? lists))) ; Throw out empty lists. (let ((lists (filter pair? lists))) ; Throw out empty lists.
@ -171,7 +167,6 @@
lists)) lists))
lis1))))) lis1)))))
(define (lset-xor = . lists) (define (lset-xor = . lists)
(check-arg procedure? = 'lset-xor) (check-arg procedure? = 'lset-xor)
(reduce (lambda (b a) ; Compute A xor B: (reduce (lambda (b a) ; Compute A xor B:
@ -181,7 +176,6 @@
;; cuts for the cases A = (), B = (), and A eq? B. It takes ;; cuts for the cases A = (), B = (), and A eq? B. It takes
;; a careful case analysis to see it, but it's carefully ;; a careful case analysis to see it, but it's carefully
;; built in. ;; built in.
;; Compute a-b and a^b, then compute b-(a^b) and ;; Compute a-b and a^b, then compute b-(a^b) and
;; cons it onto the front of a-b. ;; cons it onto the front of a-b.
(receive (a-b a-int-b) (lset-diff+intersection = a b) (receive (a-b a-int-b) (lset-diff+intersection = a b)
@ -203,20 +197,19 @@
;; cuts for the cases A = (), B = (), and A eq? B. It takes ;; cuts for the cases A = (), B = (), and A eq? B. It takes
;; a careful case analysis to see it, but it's carefully ;; a careful case analysis to see it, but it's carefully
;; built in. ;; built in.
;; Compute a-b and a^b, then compute b-(a^b) and ;; Compute a-b and a^b, then compute b-(a^b) and
;; cons it onto the front of a-b. ;; cons it onto the front of a-b.
(receive (a-b a-int-b) (lset-diff+intersection! = a b) (receive (a-b a-int-b) (lset-diff+intersection! = a b)
(cond ((null? a-b) (lset-difference! = b a)) (cond ((null? a-b) (lset-difference! = b a))
((null? a-int-b) (append! b a)) ((null? a-int-b) (append! b a))
(else (pair-fold (lambda (b-pair ans) (else (pair-fold
(lambda (b-pair ans)
(if (s:member (car b-pair) a-int-b =) ans (if (s:member (car b-pair) a-int-b =) ans
(begin (set-cdr! b-pair ans) b-pair))) (begin (set-cdr! b-pair ans) b-pair)))
a-b a-b
b))))) b)))))
'() lists)) '() lists))
(define (lset-diff+intersection = lis1 . lists) (define (lset-diff+intersection = lis1 . lists)
(check-arg procedure? = 'lset-diff+intersection) (check-arg procedure? = 'lset-diff+intersection)
(cond ((every null-list? lists) (values lis1 '())) ; Short cut (cond ((every null-list? lists) (values lis1 '())) ; Short cut
@ -236,7 +229,4 @@
lists))) lists)))
lis1)))) lis1))))
)
;;; lset.ss ends here ;;; lset.ss ends here

18
collects/srfi/1/misc.ss
View File

@ -32,16 +32,15 @@
;; hold me liable for its use. Please send bug reports to shivers@ai.mit.edu. ;; hold me liable for its use. Please send bug reports to shivers@ai.mit.edu.
;; -Olin ;; -Olin
(module misc #lang mzscheme
mzscheme
(require srfi/optional (require srfi/optional
"predicate.ss" "predicate.ss"
"selector.ss" "selector.ss"
"util.ss" "util.ss"
(only "fold.ss" reduce-right) (only "fold.ss" reduce-right)
(rename "fold.ss" srfi-1:map map)) (rename "fold.ss" srfi-1:map map)
(require srfi/8/receive) srfi/8/receive)
(provide length+ (provide length+
concatenate concatenate
@ -58,13 +57,11 @@
unzip5 unzip5
count) count)
;; count ;; count
;;;;;;;; ;;;;;;;;
(define (count pred list1 . lists) (define (count pred list1 . lists)
(check-arg procedure? pred 'count) (check-arg procedure? pred 'count)
(if (pair? lists) (if (pair? lists)
;; N-ary case ;; N-ary case
(let lp ((list1 list1) (lists lists) (i 0)) (let lp ((list1 list1) (lists lists) (i 0))
(if (null-list? list1) i (if (null-list? list1) i
@ -72,13 +69,11 @@
(if (null? as) i (if (null? as) i
(lp (cdr list1) ds (lp (cdr list1) ds
(if (apply pred (car list1) as) (+ i 1) i)))))) (if (apply pred (car list1) as) (+ i 1) i))))))
;; Fast path ;; Fast path
(let lp ((lis list1) (i 0)) (let lp ((lis list1) (i 0))
(if (null-list? lis) i (if (null-list? lis) i
(lp (cdr lis) (if (pred (car lis)) (+ i 1) i)))))) (lp (cdr lis) (if (pred (car lis)) (+ i 1) i))))))
(define (length+ x) ; Returns #f if X is circular. (define (length+ x) ; Returns #f if X is circular.
(let lp ((x x) (lag x) (len 0)) (let lp ((x x) (lag x) (len 0))
(if (pair? x) (if (pair? x)
@ -92,8 +87,6 @@
len)) len))
len))) len)))
(define (zip list1 . more-lists) (apply srfi-1:map list list1 more-lists)) (define (zip list1 . more-lists) (apply srfi-1:map list list1 more-lists))
;; Unzippers -- 1 through 5 ;; Unzippers -- 1 through 5
@ -139,7 +132,6 @@
(cons (cadddr elt) d) (cons (cadddr elt) d)
(cons (car (cddddr elt)) e))))))) (cons (car (cddddr elt)) e)))))))
;; append! append-reverse append-reverse! concatenate concatenate! ;; append! append-reverse append-reverse! concatenate concatenate!
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@ -151,7 +143,7 @@
(let ((first (car lists)) (let ((first (car lists))
(rest (cdr lists))) (rest (cdr lists)))
(if (not (pair? first)) (lp rest first) (if (not (pair? first)) (lp rest first)
; ;; Now, do the splicing. ;; Now, do the splicing.
(let lp2 ((tail-cons (last-pair first)) (let lp2 ((tail-cons (last-pair first))
(rest rest)) (rest rest))
(if (pair? rest) (if (pair? rest)
@ -185,7 +177,6 @@
(set-cdr! rev-head tail) (set-cdr! rev-head tail)
(lp next-rev rev-head))))) (lp next-rev rev-head)))))
(define (concatenate lists) (reduce-right append '() lists)) (define (concatenate lists) (reduce-right append '() lists))
#; #;
(define (concatenate! lists) (reduce-right my-append! '() lists)) (define (concatenate! lists) (reduce-right my-append! '() lists))
@ -198,5 +189,4 @@
(set-cdr! lis ans) (set-cdr! lis ans)
(lp tail lis))))) (lp tail lis)))))
)
;;; misc.ss ends here ;;; misc.ss ends here

7
collects/srfi/1/predicate.ss
View File

@ -33,8 +33,7 @@
;; -Olin ;; -Olin
(module predicate #lang mzscheme
mzscheme
(require srfi/optional) (require srfi/optional)
@ -63,7 +62,6 @@
(null? x))) (null? x)))
(null? x)))) (null? x))))
;; A dotted list is a finite list (possibly of length 0) terminated ;; A dotted list is a finite list (possibly of length 0) terminated
;; by a non-nil value. Any non-cons, non-nil value (e.g., "foo" or 5) ;; by a non-nil value. Any non-cons, non-nil value (e.g., "foo" or 5)
;; is a dotted list of length 0. ;; is a dotted list of length 0.
@ -101,7 +99,6 @@
((null? l) #t) ((null? l) #t)
(else (error "null-list?: argument out of domain" l)))) (else (error "null-list?: argument out of domain" l))))
(define (list= = . lists) (define (list= = . lists)
(or (null? lists) ; special case (or (null? lists) ; special case
(let lp1 ((list-a (car lists)) (others (cdr lists))) (let lp1 ((list-a (car lists)) (others (cdr lists)))
@ -118,6 +115,4 @@
(= (car la) (car lb)) (= (car la) (car lb))
(lp2 (cdr la) (cdr lb))))))))))) (lp2 (cdr la) (cdr lb)))))))))))
)
;;; predicate.ss ends here ;;; predicate.ss ends here

23
collects/srfi/1/search.ss
View File

@ -32,14 +32,13 @@
;; hold me liable for its use. Please send bug reports to shivers@ai.mit.edu. ;; hold me liable for its use. Please send bug reports to shivers@ai.mit.edu.
;; -Olin ;; -Olin
(module search #lang mzscheme
mzscheme
(require mzlib/etc (require mzlib/etc
srfi/optional srfi/optional
"predicate.ss" "predicate.ss"
"util.ss") "util.ss"
(require srfi/8/receive) srfi/8/receive)
(provide (rename my-member member) (provide (rename my-member member)
find find
@ -87,10 +86,9 @@
(define (drop-while pred lis) (define (drop-while pred lis)
(check-arg procedure? pred 'drop-while) (check-arg procedure? pred 'drop-while)
(let lp ((lis lis)) (let lp ((lis lis))
(if (null-list? lis) '() (cond ((null-list? lis) '())
(if (pred (car lis)) ((pred (car lis)) (lp (cdr lis)))
(lp (cdr lis)) (else lis))))
lis))))
#; #;
(define (take-while! pred lis) (define (take-while! pred lis)
@ -125,7 +123,6 @@
rest))))))) rest)))))))
(values lis suffix)))) (values lis suffix))))
(define (break pred lis) (span (lambda (x) (not (pred x))) lis)) (define (break pred lis) (span (lambda (x) (not (pred x))) lis))
#; #;
(define (break! pred lis) (span! (lambda (x) (not (pred x))) lis)) (define (break! pred lis) (span! (lambda (x) (not (pred x))) lis))
@ -133,7 +130,6 @@
(define (any pred lis1 . lists) (define (any pred lis1 . lists)
(check-arg procedure? pred 'any) (check-arg procedure? pred 'any)
(if (pair? lists) (if (pair? lists)
;; N-ary case ;; N-ary case
(receive (heads tails) (%cars+cdrs (cons lis1 lists)) (receive (heads tails) (%cars+cdrs (cons lis1 lists))
(and (pair? heads) (and (pair? heads)
@ -142,7 +138,6 @@
(if (pair? next-heads) (if (pair? next-heads)
(or (apply pred heads) (lp next-heads next-tails)) (or (apply pred heads) (lp next-heads next-tails))
(apply pred heads)))))) ; Last PRED app is tail call. (apply pred heads)))))) ; Last PRED app is tail call.
;; Fast path ;; Fast path
(and (not (null-list? lis1)) (and (not (null-list? lis1))
(let lp ((head (car lis1)) (tail (cdr lis1))) (let lp ((head (car lis1)) (tail (cdr lis1)))
@ -150,7 +145,6 @@
(pred head) ; Last PRED app is tail call. (pred head) ; Last PRED app is tail call.
(or (pred head) (lp (car tail) (cdr tail)))))))) (or (pred head) (lp (car tail) (cdr tail))))))))
;(define (every pred list) ; Simple definition. ;(define (every pred list) ; Simple definition.
; (let lp ((list list)) ; Doesn't return the last PRED value. ; (let lp ((list list)) ; Doesn't return the last PRED value.
; (or (not (pair? list)) ; (or (not (pair? list))
@ -160,7 +154,6 @@
(define (every pred lis1 . lists) (define (every pred lis1 . lists)
(check-arg procedure? pred 'every) (check-arg procedure? pred 'every)
(if (pair? lists) (if (pair? lists)
;; N-ary case ;; N-ary case
(receive (heads tails) (%cars+cdrs (cons lis1 lists)) (receive (heads tails) (%cars+cdrs (cons lis1 lists))
(or (not (pair? heads)) (or (not (pair? heads))
@ -169,7 +162,6 @@
(if (pair? next-heads) (if (pair? next-heads)
(and (apply pred heads) (lp next-heads next-tails)) (and (apply pred heads) (lp next-heads next-tails))
(apply pred heads)))))) ; Last PRED app is tail call. (apply pred heads)))))) ; Last PRED app is tail call.
;; Fast path ;; Fast path
(or (null-list? lis1) (or (null-list? lis1)
(let lp ((head (car lis1)) (tail (cdr lis1))) (let lp ((head (car lis1)) (tail (cdr lis1)))
@ -180,18 +172,15 @@
(define (list-index pred lis1 . lists) (define (list-index pred lis1 . lists)
(check-arg procedure? pred 'list-index) (check-arg procedure? pred 'list-index)
(if (pair? lists) (if (pair? lists)
;; N-ary case ;; N-ary case
(let lp ((lists (cons lis1 lists)) (n 0)) (let lp ((lists (cons lis1 lists)) (n 0))
(receive (heads tails) (%cars+cdrs lists) (receive (heads tails) (%cars+cdrs lists)
(and (pair? heads) (and (pair? heads)
(if (apply pred heads) n (if (apply pred heads) n
(lp tails (+ n 1)))))) (lp tails (+ n 1))))))
;; Fast path ;; Fast path
(let lp ((lis lis1) (n 0)) (let lp ((lis lis1) (n 0))
(and (not (null-list? lis)) (and (not (null-list? lis))
(if (pred (car lis)) n (lp (cdr lis) (+ n 1))))))) (if (pred (car lis)) n (lp (cdr lis) (+ n 1)))))))
)
;;; search.ss ends here ;;; search.ss ends here

15
collects/srfi/1/selector.ss
View File

@ -32,14 +32,12 @@
;; hold me liable for its use. Please send bug reports to shivers@ai.mit.edu. ;; hold me liable for its use. Please send bug reports to shivers@ai.mit.edu.
;; -Olin ;; -Olin
(module selector #lang mzscheme
mzscheme
(require srfi/optional) (require srfi/optional
(require srfi/8/receive) srfi/8/receive)
(provide (provide first second
first second
third fourth third fourth
fifth sixth fifth sixth
seventh eighth seventh eighth
@ -111,13 +109,11 @@
(check-arg integer? k 'drop-right!) (check-arg integer? k 'drop-right!)
(let ((lead (drop lis k))) (let ((lead (drop lis k)))
(if (pair? lead) (if (pair? lead)
(let lp ((lag lis) (lead (cdr lead))) ; Standard case (let lp ((lag lis) (lead (cdr lead))) ; Standard case
(if (pair? lead) (if (pair? lead)
(lp (cdr lag) (cdr lead)) (lp (cdr lag) (cdr lead))
(begin (set-cdr! lag '()) (begin (set-cdr! lag '())
lis))) lis)))
'()))) ; Special case dropping everything -- no cons to side-effect. '()))) ; Special case dropping everything -- no cons to side-effect.
(define (split-at x k) (define (split-at x k)
@ -136,7 +132,6 @@
(set-cdr! prev '()) (set-cdr! prev '())
(values x suffix)))) (values x suffix))))
(define (last lis) (car (last-pair lis))) (define (last lis) (car (last-pair lis)))
(define (last-pair lis) (define (last-pair lis)
@ -145,6 +140,4 @@
(let ((tail (cdr lis))) (let ((tail (cdr lis)))
(if (pair? tail) (lp tail) lis)))) (if (pair? tail) (lp tail) lis))))
)
;;; selector.ss ends here ;;; selector.ss ends here

9
collects/srfi/1/util.ss
View File

@ -32,13 +32,12 @@
;; hold me liable for its use. Please send bug reports to shivers@ai.mit.edu. ;; hold me liable for its use. Please send bug reports to shivers@ai.mit.edu.
;; -Olin ;; -Olin
(module util #lang mzscheme
mzscheme
(require srfi/optional (require srfi/optional
"predicate.ss" "predicate.ss"
"selector.ss") "selector.ss"
(require srfi/8/receive) srfi/8/receive)
(provide %cdrs (provide %cdrs
%cars+ %cars+
@ -120,6 +119,4 @@
(values (cons a cars) (cons d cdrs))))) (values (cons a cars) (cons d cdrs)))))
(values '() '())))) (values '() '()))))
)
;;; util.ss ends here ;;; util.ss ends here