164 lines
4.2 KiB
Scheme
164 lines
4.2 KiB
Scheme
; -*- Mode: Scheme; Syntax: Scheme; Package: Scheme; -*-
|
|
; Copyright (c) 1993-2001 by Richard Kelsey and Jonathan Rees. See file COPYING.
|
|
|
|
|
|
; This is file util.scm.
|
|
|
|
;;;; Utilities
|
|
|
|
(define (unspecific) (if #f #f))
|
|
|
|
(define (reduce cons nil list) ;used by length, append, etc.
|
|
(if (null? list)
|
|
nil
|
|
(cons (car list) (reduce cons nil (cdr list)))))
|
|
|
|
(define (filter pred lst)
|
|
(reduce (lambda (x rest)
|
|
(if (pred x) (cons x rest) rest))
|
|
'()
|
|
lst))
|
|
|
|
; Position of an object within a list
|
|
|
|
(define (pos pred)
|
|
(lambda (thing l)
|
|
(let loop ((i 0) (l l))
|
|
(cond ((null? l) #f)
|
|
((pred thing (car l)) i)
|
|
(else (loop (+ i 1) (cdr l)))))))
|
|
|
|
(define posq (pos eq?))
|
|
(define posv (pos eqv?))
|
|
(define position (pos equal?))
|
|
|
|
; Is pred true of any element of l?
|
|
|
|
(define (any pred l)
|
|
;; (reduce or #f l), sort of
|
|
(if (null? l)
|
|
#f
|
|
(or (pred (car l))
|
|
(any pred (cdr l)))))
|
|
|
|
; Is pred true of every element of l?
|
|
|
|
(define (every pred l)
|
|
;; (reduce and #t l), sort of
|
|
(if (null? l)
|
|
#t
|
|
(and (pred (car l)) (every pred (cdr l)))))
|
|
|
|
(define (sublist l start end)
|
|
(if (> start 0)
|
|
(sublist (cdr l) (- start 1) (- end 1))
|
|
(let recur ((l l) (end end))
|
|
(if (= end 0)
|
|
'()
|
|
(cons (car l) (recur (cdr l) (- end 1)))))))
|
|
|
|
(define (last x)
|
|
(if (null? (cdr x))
|
|
(car x)
|
|
(last (cdr x))))
|
|
|
|
(define (insert x l <)
|
|
(cond ((null? l) (list x))
|
|
((< x (car l)) (cons x l))
|
|
(else (cons (car l) (insert x (cdr l) <)))))
|
|
|
|
;----------------
|
|
; Variations on a theme.
|
|
;
|
|
; FOLD is a tail-recursive version of REDUCE.
|
|
|
|
(define (fold folder list accumulator)
|
|
(do ((list list (cdr list))
|
|
(accum accumulator (folder (car list) accum)))
|
|
((null? list)
|
|
accum)))
|
|
|
|
(define (fold->2 folder list acc0 acc1)
|
|
(let loop ((list list) (acc0 acc0) (acc1 acc1))
|
|
(if (null? list)
|
|
(values acc0 acc1)
|
|
(call-with-values
|
|
(lambda ()
|
|
(folder (car list) acc0 acc1))
|
|
(lambda (acc0 acc1)
|
|
(loop (cdr list) acc0 acc1))))))
|
|
|
|
(define (fold->3 folder list acc0 acc1 acc2)
|
|
(let loop ((list list) (acc0 acc0) (acc1 acc1) (acc2 acc2))
|
|
(if (null? list)
|
|
(values acc0 acc1 acc2)
|
|
(call-with-values
|
|
(lambda ()
|
|
(folder (car list) acc0 acc1 acc2))
|
|
(lambda (acc0 acc1 acc2)
|
|
(loop (cdr list) acc0 acc1 acc2))))))
|
|
|
|
;----------------
|
|
; A version of LET and LET* which allows clauses that return multiple values.
|
|
;
|
|
; There is another copy of this in big/mvlet.scm.
|
|
;
|
|
; MV = multiple-value
|
|
;
|
|
; (mvlet (<clause> ...) <body>)
|
|
; (mvlet* (<clause> ...) <body>)
|
|
;
|
|
; <clause> ::= (<ids> <expression>)
|
|
; <ids> ::= <id> | (<id> ...) | (<id> ... . <id>)
|
|
;
|
|
; A clause of the form (<id> <exp>) is like a normal LET clause. There is no
|
|
; clause equivalent to
|
|
; (call-with-values (lambda () <expression>)
|
|
; (lambda <id> <body>))
|
|
|
|
(define-syntax mvlet
|
|
(syntax-rules ()
|
|
((mvlet () body ...)
|
|
(let () body ...))
|
|
((mvlet (clause ...) body ...)
|
|
(mvlet-helper (clause ...) () (body ...)))))
|
|
|
|
(define-syntax mvlet-helper
|
|
(syntax-rules ()
|
|
((mvlet-helper () clauses (body ...))
|
|
(let clauses body ...))
|
|
((mvlet-helper (((var . more-vars) val) more ...) clauses body)
|
|
(copy-vars (var . more-vars) () val (more ...) clauses body))
|
|
((mvlet-helper ((var val) more ...) clauses body)
|
|
(mvlet-helper (more ...) ((var val) . clauses) body))))
|
|
|
|
(define-syntax copy-vars
|
|
(syntax-rules ()
|
|
((copy-vars (var . more-vars) (copies ...)
|
|
val more clauses body)
|
|
(copy-vars more-vars (copies ... x)
|
|
val more ((var x) . clauses) body))
|
|
((copy-vars () copies val more clauses body)
|
|
(call-with-values
|
|
(lambda () val)
|
|
(lambda copies
|
|
(mvlet-helper more clauses body))))
|
|
((copy-vars last (copies ...) val more clauses body)
|
|
(call-with-values
|
|
(lambda () val)
|
|
(lambda (copies ... . lastx)
|
|
(mvlet-helper more ((last lastx) . clauses) body))))))
|
|
|
|
(define-syntax mvlet*
|
|
(syntax-rules ()
|
|
((mvlet* () body ...)
|
|
(let () body ...))
|
|
((mvlet* (((vars ...) val) clause ...) body ...)
|
|
(call-with-values
|
|
(lambda () val)
|
|
(lambda (vars ...)
|
|
(mvlet (clause ...) body ...))))
|
|
((mvlet* ((var val) clause ...) body ...)
|
|
(let ((var val)) (mvlet (clause ...) body ...)))))
|
|
|