Fcalva/chibi-scheme
1
0
Fork 0
mirror of https://github.com/ashinn/chibi-scheme.git synced 2025-05-18 21:29:19 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

adding (srfi 116)

Browse source
This commit is contained in:
Alex Shinn 2017-08-24 21:29:33 +09:00
parent 32bd7fbad6
commit 22af18dd18
4 changed files with 564 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

82
lib/srfi/1/immutable.sld Normal file
View file

@ -0,0 +1,82 @@
(define-library (srfi 1 immutable)
(export
caaaar caaadr caadar caaddr cadaar cadadr caddar cadddr
cdaaar cdaadr cdadar cdaddr cddaar cddadr cdddar cddddr
caaar caadr cadar caddr cdaar cdadr cddar cdddr
caar cadr cdar cddr car cdr
pair? list?
list-ref length apply map for-each member memv memq assoc assv assq
cons list xcons cons* make-list list-tabulate list-copy circular-list iota
proper-list? circular-list? dotted-list? not-pair? null-list? list=
first second third fourth fifth sixth seventh eighth ninth tenth
car+cdr take drop take-right drop-right split-at
last last-pair length+ concatenate append-reverse append reverse
zip unzip1 unzip2 unzip3 unzip4 unzip5 count
fold unfold pair-fold reduce fold-right unfold-right
pair-fold-right reduce-right
append-map pair-for-each filter-map map-in-order
filter partition remove find find-tail any every
list-index take-while drop-while span break
delete delete-duplicates
alist-cons alist-copy alist-delete
lset<= lset= lset-adjoin lset-union lset-intersection
lset-difference lset-xor lset-diff+intersection)
(import (rename (chibi)
(cons mcons)
(list mlist)
(reverse mreverse)
(append mappend)
(map mmap))
(scheme cxr)
(only (chibi ast) make-immutable!))
(begin
(define (cons a b)
(let ((res (mcons a b)))
(make-immutable! res)
res))
(define (list . args)
(let lp ((ls args))
(cond
((pair? ls)
(make-immutable! ls)
(lp (cdr ls)))))
args)
(define (reverse ls)
(let lp ((ls ls) (res '()))
(if (pair? ls)
(lp (cdr ls) (cons (car ls) res))
res)))
(define (append2 ls1 ls2)
(let lp ((ls1 (reverse ls1)) (ls2 ls2))
(if (pair? ls1)
(lp (cdr ls1) (cons (car ls1) ls2))
ls2)))
(define (append . o)
(let lp ((lol (reverse o)) (res '()))
(if (pair? lol)
(lp (cdr lol) (append2 (car lol) res))
res)))
(define (map proc ls . lol)
(define (map1 proc ls res)
(if (pair? ls)
(map1 proc (cdr ls) (cons (proc (car ls)) res))
(reverse res)))
(define (mapn proc lol res)
(if (every pair? lol)
(mapn proc
(map1 cdr lol '())
(cons (apply proc (map1 car lol '())) res))
(reverse res)))
(if (null? lol)
(map1 proc ls '())
(mapn proc (cons ls lol) '()))))
(include "predicates.scm"
"selectors.scm"
"search.scm"
"misc.scm"
"constructors.scm"
"fold.scm"
"deletion.scm"
"alists.scm"
"lset.scm"))

142
lib/srfi/116.sld Normal file
View file

@ -0,0 +1,142 @@
(define-library (srfi 116)
(export
;; Syntax
iq
;; Constructors
ipair ilist
xipair ipair* make-ilist ilist-tabulate
ilist-copy iiota
;; Predicates
ipair? proper-ilist? ilist? dotted-ilist?
not-ipair? null-ilist?
ilist=
;; Selectors
icar icdr icaar icadr icdar icddr
icaaaar icaaadr icaadar icaaddr
icadaar icadadr icaddar icadddr
icdaaar icdaadr icdadar icdaddr
icddaar icddadr icdddar icddddr
icaaar icaadr icadar icaddr
icdaar icdadr icddar icdddr
ilist-ref
ifirst isecond ithird ifourth ififth isixth iseventh ieighth ininth itenth
icar+icdr
itake idrop ilist-tail
itake-right idrop-right
isplit-at
ilast last-ipair
;; Miscellaneous: length, append, concatenate, reverse, zip & count
ilength
iappend iconcatenate ireverse iappend-reverse
izip iunzip1 iunzip2 iunzip3 iunzip4 iunzip5
icount
;; Fold, unfold & map
imap ifor-each
ifold iunfold ipair-fold ireduce
ifold-right iunfold-right ipair-fold-right ireduce-right
iappend-map ipair-for-each ifilter-map imap-in-order
;; Filtering & partitioning
ifilter ipartition iremove
;; Searching
imember imemq imemv
ifind ifind-tail
iany ievery
ilist-index
itake-while idrop-while
ispan ibreak
;; Deleting
idelete idelete-duplicates
;; Immutable association lists
iassoc iassq iassv
ialist-cons ialist-delete
;; Replacement
replace-icar replace-icdr
;; Conversion
pair->ipair ipair->pair
list->ilist ilist->list
tree->itree itree->tree
gtree->itree gtree->tree
;; Procedure application
iapply
;; Comparators
ipair-comparator ilist-comparator
make-ilist-comparator make-improper-ilist-comparator
make-icar-comparator make-icdr-comparator)
(import (scheme base)
(rename (prefix (srfi 1 immutable) i)
(imake-list make-ilist)
(icar+cdr icar+icdr)
(ilast-pair last-ipair)
(icons ipair)
(ixcons xipair)
(icons* ipair*)
(inull-list? null-ilist?)
(idotted-list? dotted-ilist?)
(iproper-list? proper-ilist?))
(rename (srfi 128)
(make-pair-comparator make-ipair-comparator)
(make-list-comparator make-ilist-comparator)))
(begin
(define-syntax iq
(syntax-rules ()
((iq x ...)
(ilist 'x ...))))
(define (pair->ipair x)
(ipair (car x) (cdr x)))
(define (ipair->pair x)
(cons (car x) (cdr x)))
(define (not-ipair? x)
(not (ipair? x)))
(define (replace-icar x obj)
(ipair obj (cdr x)))
(define (replace-icdr x obj)
(ipair (car x) obj))
(define ilist-tail idrop)
(define list->ilist ilist-copy)
(define ilist->list list-copy)
(define (tree->itree x)
(if (pair? x)
(ipair (tree->itree (car x)) (tree->itree (cdr x)))
x))
(define (itree->tree x)
(if (ipair? x)
(cons (itree->tree (car x)) (itree->tree (cdr x)))
x))
(define gtree->itree tree->itree)
(define gtree->tree itree->tree)
(define ipair-comparator (make-default-comparator))
(define ilist-comparator (make-default-comparator))
(define make-improper-ilist-comparator make-ilist-comparator)
(define (make-field-comparator comparator pred field)
(make-comparator
(lambda (x)
(and (pred x)
((comparator-type-test-predicate comparator) (field x))))
(lambda (x y)
((comparator-equality-predicate comparator) (field x) (field y)))
(lambda (x y)
((comparator-ordering-predicate comparator) (field x) (field y)))
(lambda (x)
((comparator-hash-function comparator) (field x)))))
(define (make-icar-comparator comparator)
(make-field-comparator comparator ipair? icar))
(define (make-icdr-comparator comparator)
(make-field-comparator comparator ipair? icdr))
))

338
lib/srfi/116/test.sld Normal file
View file

@ -0,0 +1,338 @@
(define-library (srfi 116 test)
(import (scheme base) (srfi 116) (chibi test))
(export run-tests)
(begin
(define (run-tests)
(test-group "ilists"
(test-group "ilists/constructors"
(define abc (ilist 'a 'b 'c))
(define abc-dot-d (ipair* 'a 'b 'c 'd))
(define abc-copy (ilist-copy abc))
(test 'a (icar abc))
(test 'b (icadr abc))
(test 'c (icaddr abc))
(test (ipair 2 1) (xipair 1 2))
(test 'd (icdddr abc-dot-d))
(test (iq c c c c) (make-ilist 4 'c))
(test (iq 0 1 2 3) (ilist-tabulate 4 values))
(test (iq 0 1 2 3 4) (iiota 5))
(test abc abc-copy)
(test-assert (not (eq? abc abc-copy))))
(test-group "ilists/predicates"
(test-assert (ipair? (ipair 1 2)))
(test-assert (proper-ilist? '()))
(test-assert (proper-ilist? (iq 1 2 3)))
(test-assert (ilist? '()))
(test-assert (ilist? (iq 1 2 3)))
(test-assert (dotted-ilist? (ipair 1 2)))
(test-assert (dotted-ilist? 2))
(test-assert (null-ilist? '()))
(test-assert (not (null-ilist? (iq 1 2 3))))
;;(test-error (null-ilist? 'a))
(test-assert (not-ipair? 'a))
(test-assert (not (not-ipair? (ipair 'a 'b))))
(test-assert (ilist= = (iq 1 2 3) (iq 1 2 3)))
(test-assert (ilist= = (iq 1 2 3) (iq 1 2 3) (iq 1 2 3)))
(test-assert (not (ilist= = (iq 1 2 3 4) (iq 1 2 3))))
(test-assert (not (ilist= = (iq 1 2 3) (iq 1 2 3 4))))
(test-assert (ilist= = (iq 1 2 3) (iq 1 2 3)))
(test-assert (not (ilist= = (iq 1 2 3) (iq 1 2 3 4) (iq 1 2 3 4))))
(test-assert (not (ilist= = (iq 1 2 3) (iq 1 2 3) (iq 1 2 3 4)))))
(test-group "ilist/cxrs"
(define ab (ipair 'a 'b))
(define cd (ipair 'c 'd))
(define ef (ipair 'e 'f))
(define gh (ipair 'g 'h))
(define abcd (ipair ab cd))
(define efgh (ipair ef gh))
(define abcdefgh (ipair abcd efgh))
(define ij (ipair 'i 'j))
(define kl (ipair 'k 'l))
(define mn (ipair 'm 'n))
(define op (ipair 'o 'p))
(define ijkl (ipair ij kl))
(define mnop (ipair mn op))
(define ijklmnop (ipair ijkl mnop))
(define abcdefghijklmnop (ipair abcdefgh ijklmnop))
(test 'a (icaar abcd))
(test 'b (icdar abcd))
(test 'c (icadr abcd))
(test 'd (icddr abcd))
(test 'a (icaaar abcdefgh))
(test 'b (icdaar abcdefgh))
(test 'c (icadar abcdefgh))
(test 'd (icddar abcdefgh))
(test 'e (icaadr abcdefgh))
(test 'f (icdadr abcdefgh))
(test 'g (icaddr abcdefgh))
(test 'h (icdddr abcdefgh))
(test 'a (icaaaar abcdefghijklmnop))
(test 'b (icdaaar abcdefghijklmnop))
(test 'c (icadaar abcdefghijklmnop))
(test 'd (icddaar abcdefghijklmnop))
(test 'e (icaadar abcdefghijklmnop))
(test 'f (icdadar abcdefghijklmnop))
(test 'g (icaddar abcdefghijklmnop))
(test 'h (icdddar abcdefghijklmnop))
(test 'i (icaaadr abcdefghijklmnop))
(test 'j (icdaadr abcdefghijklmnop))
(test 'k (icadadr abcdefghijklmnop))
(test 'l (icddadr abcdefghijklmnop))
(test 'm (icaaddr abcdefghijklmnop))
(test 'n (icdaddr abcdefghijklmnop))
(test 'o (icadddr abcdefghijklmnop))
(test 'p (icddddr abcdefghijklmnop)))
(test-group "ilists/selectors"
(define ten (ilist 1 2 3 4 5 6 7 8 9 10))
(define abcde (iq a b c d e))
(define dotted (ipair 1 (ipair 2 (ipair 3 'd))))
(test 'c (ilist-ref (iq a b c d) 2))
(test 1 (ifirst ten))
(test 2 (isecond ten))
(test 3 (ithird ten))
(test 4 (ifourth ten))
(test 5 (ififth ten))
(test 6 (isixth ten))
(test 7 (iseventh ten))
(test 8 (ieighth ten))
(test 9 (ininth ten))
(test 10 (itenth ten))
(test-error (ilist-ref '() 2))
(test '(1 2) (call-with-values (lambda () (icar+icdr (ipair 1 2))) list))
(test (iq a b) (itake abcde 2))
(test (iq c d e) (idrop abcde 2))
(test (iq c d e) (ilist-tail abcde 2))
(test (iq 1 2) (itake dotted 2))
(test (ipair 3 'd) (idrop dotted 2))
(test (ipair 3 'd) (ilist-tail dotted 2))
(test 'd (idrop dotted 3))
(test 'd (ilist-tail dotted 3))
(test abcde (iappend (itake abcde 4) (idrop abcde 4)))
(test (iq d e) (itake-right abcde 2))
(test (iq a b c) (idrop-right abcde 2))
(test (ipair 2 (ipair 3 'd)) (itake-right dotted 2))
(test (iq 1) (idrop-right dotted 2))
(test 'd (itake-right dotted 0))
(test (iq 1 2 3) (idrop-right dotted 0))
(test abcde (call-with-values (lambda () (isplit-at abcde 3)) iappend))
(test 'c (ilast (iq a b c)))
(test (iq c) (last-ipair (iq a b c))))
(test-group "ilists/misc"
(test 0 (ilength '()))
(test 3 (ilength (iq 1 2 3)))
(test (iq x y) (iappend (iq x) (iq y)))
(test (iq a b c d) (iappend (iq a b) (iq c d)))
(test (iq a) (iappend '() (iq a)))
(test (iq x y) (iappend (iq x y)))
(test '() (iappend))
(test (iq a b c d) (iconcatenate (iq (a b) (c d))))
(test (iq c b a) (ireverse (iq a b c)))
(test (iq (e (f)) d (b c) a) (ireverse (iq a (b c) d (e (f)))))
(test (ipair 2 (ipair 1 'd)) (iappend-reverse (iq 1 2) 'd))
(test (iq (one 1 odd) (two 2 even) (three 3 odd))
(izip (iq one two three) (iq 1 2 3) (iq odd even odd)))
(test (iq (1) (2) (3)) (izip (iq 1 2 3)))
(test (iq 1 2 3) (iunzip1 (iq (1) (2) (3))))
(test (iq (1 2 3) (one two three))
(call-with-values
(lambda () (iunzip2 (iq (1 one) (2 two) (3 three))))
ilist))
(test (iq (1 2 3) (one two three) (a b c))
(call-with-values
(lambda () (iunzip3 (iq (1 one a) (2 two b) (3 three c))))
ilist))
(test (iq (1 2 3) (one two three) (a b c) (4 5 6))
(call-with-values
(lambda () (iunzip4 (iq (1 one a 4) (2 two b 5) (3 three c 6))))
ilist))
(test (iq (1 2 3) (one two three) (a b c) (4 5 6) (#t #f #t))
(call-with-values
(lambda () (iunzip5 (iq (1 one a 4 #t) (2 two b 5 #f) (3 three c 6 #t))))
ilist))
(test 3 (icount even? (iq 3 1 4 1 5 9 2 5 6)))
(test 3 (icount < (iq 1 2 4 8) (iq 2 4 6 8 10 12 14 16))))
(test-group "ilists/folds"
;; We have to be careful to test both single-list and multiple-list
;; code paths, as they are different in this implementation.
(define squares (iq 1 4 9 16 25 36 49 64 81 100))
(define lis (iq 1 2 3))
(define (z x y ans) (ipair (ilist x y) ans))
(define z2 (let ((count 0)) (lambda (ignored) (set! count (+ count 1)) count)))
(test 6 (ifold + 0 lis))
(test (iq 3 2 1) (ifold ipair '() lis))
(test 2 (ifold
(lambda (x count) (if (symbol? x) (+ count 1) count))
0
(iq a 0 b)))
(test 4 (ifold
(lambda (s max-len) (max max-len (string-length s)))
0
(iq "ab" "abcd" "abc")))
(test 32 (ifold
(lambda (a b ans) (+ (* a b) ans))
0
(iq 1 2 3)
(iq 4 5 6)))
(test (iq (b d) (a c))
(ifold z '() (iq a b) (iq c d)))
(test lis (ifold-right ipair '() lis))
(test (iq 0 2 4) (ifold-right
(lambda (x l) (if (even? x) (ipair x l) l))
'()
(iq 0 1 2 3 4)))
(test (iq (a c) (b d))
(ifold-right z '() (iq a b) (iq c d)))
(test (iq (c) (b c) (a b c))
(ipair-fold ipair '() (iq a b c)))
(test (iq ((b) (d)) ((a b) (c d)))
(ipair-fold z '() (iq a b) (iq c d)))
(test (iq (a b c) (b c) (c))
(ipair-fold-right ipair '() (iq a b c)))
(test (iq ((a b) (c d)) ((b) (d)))
(ipair-fold-right z '() (iq a b) (iq c d)))
(test 5 (ireduce max 0 (iq 1 3 5 4 2 0)))
(test 1 (ireduce - 0 (iq 1 2)))
(test -1 (ireduce-right - 0 (iq 1 2)))
(test squares
(iunfold (lambda (x) (> x 10))
(lambda (x) (* x x))
(lambda (x) (+ x 1))
1))
(test squares
(iunfold-right zero?
(lambda (x) (* x x))
(lambda (x) (- x 1))
10))
(test (iq 1 2 3) (iunfold null-ilist? icar icdr (iq 1 2 3)))
(test (iq 3 2 1) (iunfold-right null-ilist? icar icdr (iq 1 2 3)))
(test (iq 1 2 3 4)
(iunfold null-ilist? icar icdr (iq 1 2) (lambda (x) (iq 3 4))))
(test (iq b e h) (imap icadr (iq (a b) (d e) (g h))))
(test (iq b e h) (imap-in-order icadr (iq (a b) (d e) (g h))))
(test (iq 5 7 9) (imap + (iq 1 2 3) (iq 4 5 6)))
(test (iq 5 7 9) (imap-in-order + (iq 1 2 3) (iq 4 5 6)))
(test (iq 1 2) (imap-in-order z2 (iq a b)))
(test '#(0 1 4 9 16)
(let ((v (make-vector 5)))
(ifor-each (lambda (i)
(vector-set! v i (* i i)))
(iq 0 1 2 3 4))
v))
(test '#(5 7 9 11 13)
(let ((v (make-vector 5)))
(ifor-each (lambda (i j)
(vector-set! v i (+ i j)))
(iq 0 1 2 3 4)
(iq 5 6 7 8 9))
v))
(test (iq 1 -1 3 -3 8 -8)
(iappend-map (lambda (x) (ilist x (- x))) (iq 1 3 8)))
(test (iq 1 4 2 5 3 6)
(iappend-map ilist (iq 1 2 3) (iq 4 5 6)))
(test (vector (iq 0 1 2 3 4) (iq 1 2 3 4) (iq 2 3 4) (iq 3 4) (iq 4))
(let ((v (make-vector 5)))
(ipair-for-each (lambda (lis) (vector-set! v (icar lis) lis)) (iq 0 1 2 3 4))
v))
(test (vector (iq 5 6 7 8 9) (iq 6 7 8 9) (iq 7 8 9) (iq 8 9) (iq 9))
(let ((v (make-vector 5)))
(ipair-for-each (lambda (i j) (vector-set! v (icar i) j))
(iq 0 1 2 3 4)
(iq 5 6 7 8 9))
v))
(test (iq 1 9 49)
(ifilter-map (lambda (x) (and (number? x) (* x x))) (iq a 1 b 3 c 7)))
(test (iq 5 7 9)
(ifilter-map
(lambda (x y) (and (number? x) (number? y) (+ x y)))
(iq 1 a 2 b 3 4)
(iq 4 0 5 y 6 z2))))
(test-group "ilists/filtering"
(test (iq 0 8 8 -4) (ifilter even? (iq 0 7 8 8 43 -4)))
(test (list (iq one four five) (iq 2 3 6))
(call-with-values
(lambda () (ipartition symbol? (iq one 2 3 four five 6)))
list))
(test (iq 7 43) (iremove even? (iq 0 7 8 8 43 -4))))
(test-group "ilists/searching"
(test 2 (ifind even? (iq 1 2 3)))
(test #t (iany even? (iq 1 2 3)))
(test #f (ifind even? (iq 1 7 3)))
(test #f (iany even? (iq 1 7 3)))
;;(test-error (ifind even? (ipair 1 (ipair 3 'x))))
;;(test-error (iany even? (ipair 1 (ipair 3 'x))))
(test 4 (ifind even? (iq 3 1 4 1 5 9)))
(test (iq -8 -5 0 0) (ifind-tail even? (iq 3 1 37 -8 -5 0 0)))
(test (iq 2 18) (itake-while even? (iq 2 18 3 10 22 9)))
(test (iq 3 10 22 9) (idrop-while even? (iq 2 18 3 10 22 9)))
(test (list (iq 2 18) (iq 3 10 22 9))
(call-with-values
(lambda () (ispan even? (iq 2 18 3 10 22 9)))
list))
(test (list (iq 3 1) (iq 4 1 5 9))
(call-with-values
(lambda () (ibreak even? (iq 3 1 4 1 5 9)))
list))
(test #t (iany integer? (iq a 3 b 2.7)))
(test #f (iany integer? (iq a 3.1 b 2.7)))
(test #t (iany < (iq 3 1 4 1 5) (iq 2 7 1 8 2)))
(test #t (ievery integer? (iq 1 2 3 4 5)))
(test #f (ievery integer? (iq 1 2 3 4.5 5)))
(test #t (ievery (lambda (a b) (< a b)) (iq 1 2 3) (iq 4 5 6)))
(test 2 (ilist-index even? (iq 3 1 4 1 5 9)))
(test 1 (ilist-index < (iq 3 1 4 1 5 9 2 5 6) (iq 2 7 1 8 2)))
(test #f (ilist-index = (iq 3 1 4 1 5 9 2 5 6) (iq 2 7 1 8 2)))
(test (iq a b c) (imemq 'a (iq a b c)))
(test (iq b c) (imemq 'b (iq a b c)))
(test #f (imemq 'a (iq b c d)))
(test #f (imemq (ilist 'a) (iq b (a) c)))
(test (iq (a) c) (imember (ilist 'a) (iq b (a) c)))
(test (iq 101 102) (imemv 101 (iq 100 101 102))))
(test-group "ilists/deletion"
(test (iq 1 2 4 5) (idelete 3 (iq 1 2 3 4 5)))
(test (iq 3 4 5) (idelete 5 (iq 3 4 5 6 7) <))
(test (iq a b c z) (idelete-duplicates (iq a b a c a b c z))))
(test-group "ilists/alists"
(define e (iq (a 1) (b 2) (c 3)))
(define e2 (iq (2 3) (5 7) (11 13)))
(test (iq a 1) (iassq 'a e))
(test (iq b 2) (iassq 'b e))
(test #f (iassq 'd e))
(test #f (iassq (ilist 'a) (iq ((a)) ((b)) ((c)))))
(test (iq (a)) (iassoc (ilist 'a) (iq ((a)) ((b)) ((c)))))
(test (iq 5 7) (iassv 5 e2))
(test (iq 11 13) (iassoc 5 e2 <))
(test (ipair (iq 1 1) e2) (ialist-cons 1 (ilist 1) e2))
(test (iq (2 3) (11 13)) (ialist-delete 5 e2))
(test (iq (2 3) (5 7)) (ialist-delete 5 e2 <))
)
(test-group "ilists/replacers"
(test (ipair 1 3) (replace-icar (ipair 2 3) 1))
(test (ipair 1 3) (replace-icdr (ipair 1 2) 3)))
(test-group "ilists/conversion"
(test (ipair 1 2) (pair->ipair '(1 . 2)))
(test '(1 . 2) (ipair->pair (ipair 1 2)))
(test (iq 1 2 3) (list->ilist '(1 2 3)))
(test '(1 2 3) (ilist->list (iq 1 2 3)))
(test (ipair 1 (ipair 2 3)) (list->ilist '(1 2 . 3)))
(test '(1 2 . 3) (ilist->list (ipair 1 (ipair 2 3))))
(test (ipair (ipair 1 2) (ipair 3 4)) (tree->itree '((1 . 2) . (3 . 4))))
(test '((1 . 2) . (3 . 4)) (itree->tree (ipair (ipair 1 2) (ipair 3 4))))
(test (ipair (ipair 1 2) (ipair 3 4)) (gtree->itree (cons (ipair 1 2) (ipair 3 4))))
(test '((1 . 2) . (3 . 4)) (gtree->tree (cons (ipair 1 2) (ipair 3 4))))
(test 6 (iapply + (iq 1 2 3)))
(test 15 (iapply + 1 2 (iq 3 4 5))))
))))

2
tests/lib-tests.scm
View file

@ -11,6 +11,7 @@
(rename (srfi 69 test) (run-tests run-srfi-69-tests))
(rename (srfi 95 test) (run-tests run-srfi-95-tests))
(rename (srfi 99 test) (run-tests run-srfi-99-tests))
(rename (srfi 116 test) (run-tests run-srfi-116-tests))
(rename (srfi 117 test) (run-tests run-srfi-117-tests))
(rename (srfi 121 test) (run-tests run-srfi-121-tests))
(rename (srfi 128 test) (run-tests run-srfi-128-tests))
@ -61,6 +62,7 @@
(run-srfi-69-tests)
(run-srfi-95-tests)
(run-srfi-99-tests)
(run-srfi-116-tests)
(run-srfi-117-tests)
(run-srfi-121-tests)
(run-srfi-128-tests)