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

extending (scheme red)

Browse source
This commit is contained in:
Alex Shinn 2018-01-24 23:54:09 +09:00
parent ab88f53e48
commit eb38a5836a
7 changed files with 809 additions and 391 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

31
lib/scheme/ideque.sld Normal file
View file

@ -0,0 +1,31 @@
(define-library (scheme ideque)
(import (srfi 134))
(export ideque ideque-tabulate ideque-unfold ideque-unfold-right
ideque? ideque-empty? ideque= ideque-any ideque-every
ideque-front ideque-add-front ideque-remove-front
ideque-back ideque-add-back ideque-remove-back
ideque-ref
ideque-take ideque-take-right ideque-drop ideque-drop-right
ideque-split-at
ideque-length ideque-append ideque-reverse
ideque-count ideque-zip
ideque-map ideque-filter-map
ideque-for-each ideque-for-each-right
ideque-fold ideque-fold-right
ideque-append-map
ideque-filter ideque-remove ideque-partition
ideque-find ideque-find-right
ideque-take-while ideque-take-while-right
ideque-drop-while ideque-drop-while-right
ideque-span ideque-break
list->ideque ideque->list
generator->ideque ideque->generator
))

25
lib/scheme/lseq.sld Normal file
View file

@ -0,0 +1,25 @@
(define-library (scheme lseq)
(import (srfi 127))
(export
;; Constructors
generator->lseq
;; Predicates
lseq? lseq=?
;; Selectors
lseq-car lseq-cdr
lseq-first lseq-rest lseq-ref
lseq-take lseq-drop
;; The whole lazy sequence
lseq-realize lseq->generator
lseq-length
lseq-append lseq-zip
;; Mapping and filtering
lseq-map lseq-for-each
lseq-filter lseq-remove
;; Searching
lseq-find lseq-find-tail
lseq-any lseq-every
lseq-index
lseq-take-while lseq-drop-while
lseq-member lseq-memq lseq-memv))

960
lib/scheme/red.sld
View file

@ -14,409 +14,587 @@
(scheme file) (scheme file)
(scheme generator) (scheme generator)
(scheme hash-table) (scheme hash-table)
(scheme ideque)
(scheme ilist) (scheme ilist)
(scheme inexact) (scheme inexact)
(scheme lazy) (scheme lazy)
(scheme list-queue) (scheme list-queue)
(scheme list) (scheme list)
(scheme load) (scheme load)
(scheme lseq)
(scheme process-context) (scheme process-context)
(scheme read) (scheme read)
(scheme repl) (scheme repl)
(scheme rlist)
(scheme set)
(scheme sort) (scheme sort)
(scheme stream)
(scheme text)
(scheme time) (scheme time)
(scheme vector) (scheme vector)
(scheme write)) (scheme write))
(export (export
* + * +
- ->char-set - ->char-set
... / ... /
< <= < <=
<=? <? <=? <?
= => = =>
=? > =? >
>= >=? >= >=?
>? _ >? _
abs acos abs acos
alist->hash-table alist->bag alist->hash-table
alist-cons alist-copy alist-cons alist-copy
alist-delete alist-delete! alist-delete alist-delete!
and angle and angle
any append any append
append! append! append-map
append-map append-map! append-map! append-reverse
append-reverse append-reverse! append-reverse! apply
apply asin assoc
asin assq assv
assoc assq atan bag
assv atan bag->alist bag->list
begin bag->set bag->set
binary-port? bag-adjoin bag-adjoin!
boolean-hash boolean=? bag-any? bag-comparator
boolean? box bag-comparator bag-contains?
box? break bag-copy bag-count
break! bytevector bag-decrement! bag-decrement!
bytevector->generator bytevector-append bag-delete bag-delete!
bytevector-copy bytevector-copy! bag-delete-all bag-delete-all!
bytevector-length bytevector-u8-ref bag-difference bag-difference!
bytevector-u8-set! bytevector? bag-disjoint? bag-element-comparator
caaaar caaadr bag-element-count bag-element-count
caaar caadar bag-empty? bag-every?
caaddr caadr bag-filter bag-filter!
caar cadaar bag-find bag-fold
cadadr cadar bag-fold-unique bag-fold-unique
caddar cadddr bag-for-each bag-for-each-unique
caddr cadr bag-for-each-unique bag-increment!
call-with-current-continuation call-with-input-file bag-increment! bag-intersection
call-with-output-file bag-intersection! bag-map
call-with-port bag-member bag-partition
call-with-values call/cc bag-partition! bag-product
car car+cdr bag-product bag-product!
case case-lambda bag-product! bag-remove
cdaaar cdaadr bag-remove! bag-replace
cdaar cdadar bag-replace! bag-search!
cdaddr cdadr bag-size bag-sum
cdar cddaar bag-sum bag-sum!
cddadr cddar bag-sum! bag-unfold
cdddar cddddr bag-union bag-union!
cdddr cddr bag-unique-size bag-xor
cdr ceiling bag-xor! bag<=?
char->integer char-alphabetic? bag<? bag=?
char-ci-hash char-ci<=? bag>=? bag>?
char-ci<? char-ci=? bag? begin
char-ci>=? char-ci>? binary-port? boolean-hash
char-downcase char-foldcase boolean=? boolean?
char-hash char-lower-case? box box?
char-numeric? char-ready? break break!
char-set char-set->list bytevector bytevector->generator
char-set->string char-set-adjoin bytevector-append bytevector-copy
char-set-adjoin! char-set-any bytevector-copy! bytevector-length
char-set-complement char-set-complement! bytevector-u8-ref bytevector-u8-set!
char-set-contains? char-set-copy bytevector? caaaar
char-set-count char-set-cursor caaadr caaar
char-set-cursor-next char-set-delete caadar caaddr
char-set-delete! char-set-diff+intersection caadr caar
char-set-diff+intersection! char-set-difference cadaar cadadr
char-set-difference! char-set-every cadar caddar
char-set-filter char-set-filter! cadddr caddr
char-set-fold char-set-for-each cadr call-with-current-continuation
char-set-hash char-set-intersection call-with-input-file call-with-output-file
char-set-intersection! char-set-map call-with-port call-with-values
char-set-ref char-set-size call/cc car
char-set-unfold char-set-unfold! car+cdr case
char-set-union char-set-union! case-lambda cdaaar
char-set-xor char-set-xor! cdaadr cdaar
char-set:ascii char-set:blank cdadar cdaddr
char-set:digit char-set:empty cdadr cdar
char-set:full char-set:graphic cddaar cddadr
char-set:hex-digit char-set:iso-control cddar cdddar
char-set:letter char-set:letter+digit cddddr cdddr
char-set:lower-case char-set:printing cddr cdr
char-set:punctuation char-set:symbol ceiling char->integer
char-set:title-case char-set:upper-case char-alphabetic? char-ci-hash
char-set:whitespace char-set<= char-ci<=? char-ci<?
char-set= char-upcase char-ci=? char-ci>=?
char-upper-case? char-whitespace? char-ci>? char-downcase
char<=? char<? char-foldcase char-hash
char=? char>=? char-lower-case? char-numeric?
char>? char? char-ready? char-set
circular-list circular-list? char-set->list char-set->string
close-input-port close-output-port char-set-adjoin char-set-adjoin!
close-port char-set-any char-set-complement
command-line comparator-check-type char-set-complement! char-set-contains?
comparator-equality-predicate comparator-hash char-set-copy char-set-count
comparator-hash-function comparator-hashable? char-set-cursor char-set-cursor-next
comparator-if<=> comparator-ordered? char-set-delete char-set-delete!
comparator-ordering-predicate comparator-register-default! char-set-diff+intersection char-set-diff+intersection!
comparator-test-type comparator-type-test-predicate char-set-difference char-set-difference!
comparator? char-set-every char-set-filter
complex? concatenate char-set-filter! char-set-fold
concatenate! cond char-set-for-each char-set-hash
cond-expand cons char-set-intersection char-set-intersection!
cons* char-set-map char-set-ref
cos char-set-size char-set-unfold
count char-set-unfold! char-set-union
current-error-port char-set-union! char-set-xor
current-input-port current-jiffy char-set-xor! char-set:ascii
current-output-port char-set:blank char-set:digit
current-second default-hash char-set:empty char-set:full
define char-set:graphic char-set:hex-digit
define-record-type define-syntax char-set:iso-control char-set:letter
define-values delay char-set:letter+digit char-set:lower-case
delay-force delete char-set:printing char-set:punctuation
delete! delete-duplicates char-set:symbol char-set:title-case
delete-duplicates! delete-file char-set:upper-case char-set:whitespace
denominator char-set<= char-set=
digit-value display char-upcase char-upper-case?
do dotted-list? char-whitespace? char<=?
drop drop-right char<? char=?
drop-right! drop-while char>=? char>?
dynamic-wind eighth char? circular-list
else emergency-exit circular-list? close-input-port
end-of-char-set? close-output-port close-port
environment command-line comparator-check-type
eof-object eof-object? comparator-equality-predicate comparator-hash
ephemeron-broken? ephemeron-key comparator-hash-function comparator-hashable?
ephemeron-datum ephemeron? comparator-if<=> comparator-ordered?
eq? equal? comparator-ordering-predicate comparator-register-default!
eqv? comparator-test-type comparator-type-test-predicate
error eval comparator? complex?
even? every concatenate concatenate!
exact cond cond-expand
exact-integer-sqrt cons cons*
exact-integer? cos count
exact? current-error-port current-input-port
exit exp current-jiffy current-output-port
expt features current-second default-hash
fifth file-error? define define-record-type
file-exists? define-stream define-syntax
filter filter! define-values delay
filter-map find delay-force delete
find-tail delete! delete-duplicates
finite? first delete-duplicates! delete-file
floor floor-quotient denominator digit-value
floor-remainder floor/ display do
flush-output-port dotted-list? drop
fold fold-right drop-right drop-right!
for-each force drop-while dynamic-wind
fourth gappend eighth else
gcd emergency-exit end-of-char-set?
gcombine gcons* environment eof-object
gdelete gdelete-neighbor-dups eof-object? ephemeron-broken?
gdrop gdrop-while ephemeron-datum ephemeron-key
generator ephemeron? eq?
generator->list generator->reverse-list equal? eqv?
generator->string generator->vector error eval
generator->vector! generator-any even? every
generator-count generator-every exact exact-integer-sqrt
generator-find generator-fold exact-integer? exact?
generator-for-each generator-unfold exit exp
get-environment-variable get-environment-variables expt features
get-output-bytevector get-output-string fifth file-error?
gfilter gindex file-exists? filter
gremove gselect filter! filter-map
gtake gtake-while find find-tail
gtree->itree gtree->tree finite? first
guard hash floor floor-quotient
hash-bound hash-by-identity floor-remainder floor/
hash-salt hash-table flush-output-port fold
hash-table->alist hash-table-clear! fold-right for-each
hash-table-contains? hash-table-copy force fourth
hash-table-count hash-table-delete! gappend gcd
hash-table-difference! hash-table-empty-copy gcombine gcons*
hash-table-empty? hash-table-entries gdelete gdelete-neighbor-dups
hash-table-equivalence-function hash-table-exists? gdrop gdrop-while
hash-table-find hash-table-fold generator generator->ideque
hash-table-for-each hash-table-hash-function generator->list generator->lseq
hash-table-intern! hash-table-intersection! generator->reverse-list generator->string
hash-table-keys hash-table-map generator->vector generator->vector!
hash-table-map! hash-table-map->list generator-any generator-count
hash-table-merge! hash-table-mutable? generator-every generator-find
hash-table-pop! hash-table-prune! generator-fold generator-for-each
hash-table-ref hash-table-ref/default generator-unfold get-environment-variable
hash-table-set! hash-table-size get-environment-variables get-output-bytevector
hash-table-unfold hash-table-union! get-output-string gfilter
hash-table-update! hash-table-update!/default gindex gremove
hash-table-values hash-table-walk gselect gtake
hash-table-xor! hash-table=? gtake-while gtree->itree
hash-table? gtree->tree guard
if ilist->list hash hash-bound
ilist-comparator ilist-tail hash-by-identity hash-salt
imag-part hash-table hash-table->alist
include include-ci hash-table-clear! hash-table-contains?
inexact hash-table-copy hash-table-count
inexact? infinite? hash-table-delete! hash-table-difference!
input-port-open? input-port? hash-table-empty-copy hash-table-empty?
integer->char integer? hash-table-entries hash-table-equivalence-function
interaction-environment iota hash-table-exists? hash-table-find
ipair->pair ipair-comparator hash-table-fold hash-table-for-each
iq hash-table-hash-function hash-table-intern!
itree->tree hash-table-intersection! hash-table-keys
jiffies-per-second lambda hash-table-map hash-table-map!
last last-pair hash-table-map->list hash-table-merge!
lcm hash-table-mutable? hash-table-pop!
length hash-table-prune! hash-table-ref
length+ let hash-table-ref/default hash-table-set!
let* let*-values hash-table-size hash-table-unfold
let-syntax hash-table-union! hash-table-update!
let-values letrec hash-table-update!/default hash-table-values
letrec* letrec-syntax hash-table-walk hash-table-xor!
list list->char-set hash-table=? hash-table?
list->char-set! list->generator ideque ideque->generator
list->ilist list->string ideque->list ideque-add-back
list->vector list-copy ideque-add-front ideque-any
list-delete-neighbor-dups list-delete-neighbor-dups! ideque-append ideque-append-map
list-index list-merge ideque-back ideque-break
list-merge! list-queue ideque-count ideque-drop
list-queue-add-back! list-queue-add-front! ideque-drop-right ideque-drop-while
list-queue-append list-queue-append! ideque-drop-while-right ideque-empty?
list-queue-back list-queue-concatenate ideque-every ideque-filter
list-queue-copy list-queue-empty? ideque-filter-map ideque-find
list-queue-first-last list-queue-for-each ideque-find-right ideque-fold
list-queue-front list-queue-list ideque-fold-right ideque-for-each
list-queue-map list-queue-map! ideque-for-each-right ideque-front
list-queue-remove-all! list-queue-remove-back! ideque-length ideque-map
list-queue-remove-front! list-queue-set-list! ideque-partition ideque-ref
list-queue-unfold list-queue-unfold-right ideque-remove ideque-remove-back
list-queue? list-ref ideque-remove-front ideque-reverse
list-set! list-sort ideque-span ideque-split-at
list-sort! list-sorted? ideque-tabulate ideque-take
list-stable-sort list-stable-sort! ideque-take-right ideque-take-while
list-tabulate list-tail ideque-take-while-right ideque-unfold
list= list? ideque-unfold-right ideque-zip
load ideque= ideque?
log if ilist->list
lset-adjoin ilist-comparator ilist-tail
lset-diff+intersection lset-diff+intersection! imag-part include
lset-difference lset-difference! include-ci inexact
lset-intersection lset-intersection! inexact? infinite?
lset-union lset-union! input-port-open? input-port?
lset-xor lset-xor! integer->char integer?
lset<= lset= interaction-environment iota
magnitude make-bytevector ipair->pair ipair-comparator
make-comparator iq itree->tree
make-coroutine-generator make-default-comparator jiffies-per-second lambda
make-ephemeron last last-pair
make-eq-comparator make-equal-comparator lcm length
make-eqv-comparator length+ let
make-for-each-generator let* let*-values
make-hash-table make-icar-comparator let-syntax let-values
make-icdr-comparator make-improper-ilist-comparator letrec letrec*
make-iota-generator make-list letrec-syntax list
make-list-comparator make-list-queue list->bag list->bag!
make-pair-comparator make-parameter list->char-set list->char-set!
make-polar make-promise list->generator list->ideque
make-range-generator make-rectangular list->ilist list->rlist
make-string list->set list->set
make-unfold-generator make-vector list->set! list->set!
make-vector-comparator map list->stream list->string
map! map-in-order list->text list->vector
max member list-copy list-delete-neighbor-dups
memq memv list-delete-neighbor-dups! list-index
min modulo list-merge list-merge!
nan? negative? list-queue list-queue-add-back!
newline ninth list-queue-add-front! list-queue-append
not not-ipair? list-queue-append! list-queue-back
not-pair? list-queue-concatenate list-queue-copy
null-list? null? list-queue-empty? list-queue-first-last
number->string number-hash list-queue-for-each list-queue-front
number? numerator list-queue-list list-queue-map
odd? list-queue-map! list-queue-remove-all!
open-binary-input-file open-binary-output-file list-queue-remove-back! list-queue-remove-front!
open-input-bytevector open-input-file list-queue-set-list! list-queue-unfold
open-input-string list-queue-unfold-right list-queue?
open-output-bytevector open-output-file list-ref list-set!
open-output-string list-sort list-sort!
or output-port-open? list-sorted? list-stable-sort
output-port? pair->ipair list-stable-sort! list-tabulate
pair-fold pair-fold-right list-tail list=
pair-for-each list? load
pair? log lseq->generator
parameterize partition lseq-any lseq-append
partition! peek-char lseq-car lseq-cdr
peek-u8 lseq-drop lseq-drop-while
port? positive? lseq-every lseq-filter
procedure? lseq-find lseq-find-tail
promise? proper-list? lseq-first lseq-for-each
quasiquote quote lseq-index lseq-length
quotient raise lseq-map lseq-member
raise-continuable lseq-memq lseq-memv
rational? rationalize lseq-realize lseq-ref
read read-bytevector lseq-remove lseq-rest
read-bytevector! read-char lseq-take lseq-take-while
read-error? read-line lseq-zip lseq=?
read-string read-u8 lseq? lset-adjoin
real-part lset-diff+intersection lset-diff+intersection!
real? reduce lset-difference lset-difference!
reduce-right lset-intersection lset-intersection!
remainder lset-union lset-union!
remove remove! lset-xor lset-xor!
replace-icar replace-icdr lset<= lset=
reverse reverse! magnitude make-bytevector
reverse-list->vector reverse-vector->generator make-comparator make-coroutine-generator
reverse-vector->list make-default-comparator make-ephemeron
round make-eq-comparator make-equal-comparator
second set! make-eqv-comparator make-for-each-generator
set-box! set-car! make-hash-table make-icar-comparator
set-cdr! make-icdr-comparator make-improper-ilist-comparator
seventh sin make-iota-generator make-list
sixth make-list-comparator make-list-queue
span make-pair-comparator make-parameter
span! split-at make-polar make-promise
split-at! sqrt make-range-generator make-rectangular
square string make-rlist make-string
string->char-set string->char-set! make-text make-unfold-generator
string->generator string->list make-vector make-vector-comparator
string->number string->symbol map map!
string->utf8 string->vector map-in-order max
string-append string-ci-hash member memq
string-ci<=? string-ci<? memv min
string-ci=? string-ci>=? modulo nan?
string-ci>? negative? newline
string-copy string-copy! ninth not
string-downcase string-fill! not-ipair? not-pair?
string-foldcase string-for-each null-list? null?
string-hash number->string number-hash
string-length string-map number? numerator
string-ref string-set! odd? open-binary-input-file
string-upcase open-binary-output-file open-input-bytevector
string<=? string<? open-input-file open-input-string
string=? string>=? open-output-bytevector open-output-file
string>? string? open-output-string or
substring output-port-open? output-port?
symbol->string symbol-hash pair->ipair pair-fold
symbol=? symbol? pair-fold-right pair-for-each
syntax-error pair? parameterize
syntax-rules partition partition!
take peek-char peek-u8
take! take-right port->stream port?
take-while take-while! positive? procedure?
tan tenth promise? proper-list?
textual-port? third quasiquote quote
tree->itree quotient raise
truncate truncate-quotient raise-continuable rappend
truncate-remainder truncate/ rational? rationalize
u8-ready? rcaaaar rcaaadr
ucs-range->char-set ucs-range->char-set! rcaaar rcaadar
unbox unfold rcaaddr rcaadr
unfold-right unless rcaar rcadaar
unquote unquote-splicing rcadadr rcadar
unzip1 unzip2 rcaddar rcadddr
unzip3 unzip4 rcaddr rcadr
unzip5 utf8->string rcar rcdaaar
values vector rcdaadr rcdaar
vector->generator vector->list rcdadar rcdaddr
vector->string vector-any rcdadr rcdar
vector-append vector-append-subvectors rcddaar rcddadr
vector-binary-search vector-concatenate rcddar rcdddar
vector-copy vector-copy! rcddddr rcdddr
vector-count vector-cumulate rcddr rcdr
vector-delete-neighbor-dups vector-delete-neighbor-dups! rcons read
vector-empty? vector-every read-bytevector read-bytevector!
vector-fill! vector-find-median read-char read-error?
vector-find-median! vector-fold read-line read-string
vector-fold-right vector-for-each read-u8 real-part
vector-index vector-index-right real? reduce
vector-length vector-map reduce-right remainder
vector-map! vector-merge remove remove!
vector-merge! vector-partition replace-icar replace-icdr
vector-ref vector-reverse! reverse reverse!
vector-reverse-copy vector-reverse-copy! reverse-list->text reverse-list->vector
vector-select! vector-separate! reverse-vector->generator reverse-vector->list
vector-set! vector-skip rfor-each rlength
vector-skip-right vector-sort rlist rlist->list
vector-sort! vector-sorted? rlist-ref rlist-ref/update
vector-stable-sort vector-stable-sort! rlist-set rlist-tail
vector-swap! vector-unfold rlist? rmap
vector-unfold! vector-unfold-right rnull? round
vector-unfold-right! vector= rpair? rquote
vector? rreverse second
when with-exception-handler set set
with-input-from-file set! set->bag
with-output-to-file write set->bag set->bag!
write-bytevector write-char set->bag! set->list
write-string write-u8 set->list set-adjoin
xcons set-adjoin set-adjoin!
zero? set-adjoin! set-any?
zip set-any? set-box!
set-car! set-cdr!
set-comparator set-comparator
set-contains? set-contains?
set-copy set-copy
set-count set-count
set-delete set-delete
set-delete! set-delete!
set-delete-all set-delete-all
set-delete-all! set-delete-all!
set-difference set-difference
set-difference! set-difference!
set-disjoint? set-disjoint?
set-element-comparator set-element-comparator
set-empty? set-empty?
set-every? set-every?
set-filter set-filter
set-filter! set-filter!
set-find set-find
set-fold set-fold
set-for-each set-for-each
set-intersection set-intersection
set-intersection! set-intersection!
set-map set-map
set-member set-member
set-partition set-partition
set-partition! set-partition!
set-remove set-remove
set-remove! set-remove!
set-replace set-replace
set-replace! set-replace!
set-search! set-search!
set-size set-size
set-unfold set-unfold
set-union set-union
set-union! set-union!
set-xor set-xor
set-xor! set-xor!
set<=? set<=?
set<? set<?
set=? set=?
set>=? set>=?
set>? set>?
set? set?
seventh sin
sixth span
span! split-at
split-at! sqrt
square stream
stream->list stream-append
stream-car stream-cdr
stream-concat stream-cons
stream-constant stream-drop
stream-drop-while stream-filter
stream-fold stream-for-each
stream-from stream-iterate
stream-lambda stream-length
stream-let stream-map
stream-match stream-null
stream-null? stream-of
stream-pair? stream-range
stream-ref stream-reverse
stream-scan stream-take
stream-take-while stream-unfold
stream-unfolds stream-zip
stream? string
string->char-set string->char-set!
string->generator string->list
string->number string->symbol
string->text string->utf8
string->vector string-append
string-ci-hash string-ci<=?
string-ci<? string-ci=?
string-ci>=? string-ci>?
string-copy string-copy!
string-downcase string-fill!
string-foldcase string-for-each
string-hash string-length
string-map string-ref
string-set! string-upcase
string<=? string<?
string=? string>=?
string>? string?
substring subtext
subtextual symbol->string
symbol-hash symbol=?
symbol? syntax-error
syntax-rules take
take! take-right
take-while take-while!
tan tenth
text text-length
text-ref text-tabulate
text-unfold text-unfold-right
text? textual->list
textual->string textual->text
textual->utf16 textual->utf16be
textual->utf16le textual->utf8
textual->vector textual-any
textual-append textual-ci<=?
textual-ci<? textual-ci=?
textual-ci>=? textual-ci>?
textual-concatenate textual-concatenate-reverse
textual-contains textual-contains-right
textual-copy textual-count
textual-downcase textual-drop
textual-drop-right textual-every
textual-filter textual-fold
textual-fold-right textual-foldcase
textual-for-each textual-for-each-index
textual-index textual-index-right
textual-join textual-length
textual-map textual-map-index
textual-null? textual-pad
textual-pad-right textual-port?
textual-prefix-length textual-prefix?
textual-ref textual-remove
textual-replace textual-replicate
textual-skip textual-skip-right
textual-split textual-suffix-length
textual-suffix? textual-take
textual-take-right textual-titlecase
textual-trim textual-trim-both
textual-trim-right textual-upcase
textual<=? textual<?
textual=? textual>=?
textual>? textual?
third tree->itree
truncate truncate-quotient
truncate-remainder truncate/
u8-ready? ucs-range->char-set
ucs-range->char-set! unbox
unfold unfold-right
unless unquote
unquote-splicing unzip1
unzip2 unzip3
unzip4 unzip5
utf16->text utf16be->text
utf16le->text utf8->string
utf8->text values
vector vector->generator
vector->list vector->string
vector->text vector-any
vector-append vector-append-subvectors
vector-binary-search vector-concatenate
vector-copy vector-copy!
vector-count vector-cumulate
vector-delete-neighbor-dups vector-delete-neighbor-dups!
vector-empty? vector-every
vector-fill! vector-find-median
vector-find-median! vector-fold
vector-fold-right vector-for-each
vector-index vector-index-right
vector-length vector-map
vector-map! vector-merge
vector-merge! vector-partition
vector-ref vector-reverse!
vector-reverse-copy vector-reverse-copy!
vector-select! vector-separate!
vector-set! vector-skip
vector-skip-right vector-sort
vector-sort! vector-sorted?
vector-stable-sort vector-stable-sort!
vector-swap! vector-unfold
vector-unfold! vector-unfold-right
vector-unfold-right! vector=
vector? when
with-exception-handler with-input-from-file
with-output-to-file write
write-bytevector write-char
write-string write-u8
xcons zero?
zip
)) ))

53
lib/scheme/rlist.sld Normal file
View file

@ -0,0 +1,53 @@
(define-library (scheme rlist)
(import (srfi 101))
(export (rename quote rquote)
(rename pair? rpair?)
(rename cons rcons)
(rename car rcar)
(rename cdr rcdr)
(rename caar rcaar)
(rename cadr rcadr)
(rename cddr rcddr)
(rename cdar rcdar)
(rename caaar rcaaar)
(rename caadr rcaadr)
(rename caddr rcaddr)
(rename cadar rcadar)
(rename cdaar rcdaar)
(rename cdadr rcdadr)
(rename cdddr rcdddr)
(rename cddar rcddar)
(rename caaaar rcaaaar)
(rename caaadr rcaaadr)
(rename caaddr rcaaddr)
(rename caadar rcaadar)
(rename cadaar rcadaar)
(rename cadadr rcadadr)
(rename cadddr rcadddr)
(rename caddar rcaddar)
(rename cdaaar rcdaaar)
(rename cdaadr rcdaadr)
(rename cdaddr rcdaddr)
(rename cdadar rcdadar)
(rename cddaar rcddaar)
(rename cddadr rcddadr)
(rename cddddr rcddddr)
(rename cdddar rcdddar)
(rename null? rnull?)
(rename list? rlist?)
(rename list rlist)
(rename make-list make-rlist)
(rename length rlength)
(rename append rappend)
(rename reverse rreverse)
(rename list-tail rlist-tail)
(rename list-ref rlist-ref)
(rename list-set rlist-set)
(rename list-ref/update rlist-ref/update)
(rename map rmap)
(rename for-each rfor-each)
(rename random-access-list->linear-access-list
rlist->list)
(rename linear-access-list->random-access-list
list->rlist)))

60
lib/scheme/set.sld Normal file
View file

@ -0,0 +1,60 @@
(define-library (scheme set)
(import (srfi 113))
(export
set set-contains? set-unfold
;; Predicates:
set? set-empty? set-disjoint?
;; Accessors:
set-member set-element-comparator
;; Updaters:
set-adjoin set-adjoin! set-replace set-replace!
set-delete set-delete! set-delete-all set-delete-all!
set-search!
;; The whole set:
set-size set-find set-count set-any? set-every?
;; Mapping and folding:
set-map set-for-each set-fold set-filter set-filter!
set-remove set-remove! set-partition set-partition!
;; Copying and conversion:
set-copy set->list list->set list->set!
;; Subsets:
set=? set<? set>? set<=? set>=?
;; Set theory operations:
set-union set-intersection set-difference set-xor
set-union! set-intersection! set-difference! set-xor!
;; Comparators:
set-comparator
;; Constructors:
bag bag-contains? bag-unfold
;; Predicates:
bag? bag-empty? bag-disjoint?
;; Accessors:
bag-member bag-element-comparator
;; Updaters:
bag-adjoin bag-adjoin! bag-replace bag-replace!
bag-delete bag-delete! bag-delete-all bag-delete-all!
bag-search!
;; The whole bag:
bag-size bag-find bag-count bag-any? bag-every?
;; Mapping and folding:
bag-map bag-for-each bag-fold bag-filter bag-filter!
bag-remove bag-remove! bag-partition bag-partition!
;; Copying and conversion:
bag-copy bag->list list->bag list->bag!
;; Subbags:
bag=? bag<? bag>? bag<=? bag>=?
;; Bag theory operations:
bag-union bag-intersection bag-difference bag-xor
bag-union! bag-intersection! bag-difference! bag-xor!
;; Comparators:
bag-comparator
;; Additional bag procedures:
bag-unique-size
bag-sum bag-sum! bag-product bag-product! bag-element-count
bag-for-each-unique bag-fold-unique bag-increment! bag-decrement!
bag->set set->bag set->bag!
bag->alist alist->bag
))

12
lib/scheme/stream.sld Normal file
View file

@ -0,0 +1,12 @@
(define-library (scheme stream)
(import (srfi 41))
(export
stream-null stream-cons stream? stream-null? stream-pair?
stream-car stream-cdr stream-lambda
define-stream list->stream port->stream stream stream->list
stream-append stream-concat stream-constant stream-drop
stream-drop-while stream-filter stream-fold stream-for-each stream-from
stream-iterate stream-length stream-let stream-map stream-match _
stream-of stream-range stream-ref stream-reverse stream-scan stream-take
stream-take-while stream-unfold stream-unfolds stream-zip))

59
lib/scheme/text.sld Normal file
View file

@ -0,0 +1,59 @@
(define-library (scheme text)
(import (srfi 135))
(export
;; Predicates
text? textual?
textual-null?
textual-every textual-any
;; Constructors
make-text text
text-tabulate
text-unfold text-unfold-right
;; Conversion
textual->text
textual->string textual->vector textual->list
string->text vector->text list->text reverse-list->text
textual->utf8 textual->utf16be
textual->utf16 textual->utf16le
utf8->text utf16be->text
utf16->text utf16le->text
;; Selection
text-length textual-length
text-ref textual-ref
subtext subtextual
textual-copy
textual-take textual-take-right
textual-drop textual-drop-right
textual-pad textual-pad-right
textual-trim textual-trim-right textual-trim-both
;; Replacement
textual-replace
;; Comparison
textual=? textual-ci=?
textual<? textual-ci<?
textual>? textual-ci>?
textual<=? textual-ci<=?
textual>=? textual-ci>=?
;; Prefixes & suffixes
textual-prefix-length textual-suffix-length
textual-prefix? textual-suffix?
;; Searching
textual-index textual-index-right
textual-skip textual-skip-right
textual-contains textual-contains-right
;; Case conversion
textual-upcase textual-downcase
textual-foldcase textual-titlecase
;; Concatenation
textual-append textual-concatenate textual-concatenate-reverse
textual-join
;; Fold & map & friends
textual-fold textual-fold-right
textual-map textual-for-each
textual-map-index textual-for-each-index
textual-count
textual-filter textual-remove
;; Replication & splitting
textual-replicate textual-split
))