This is a preliminary list of procedures for the R7RS vector library. It is an upward compatible extension of the vector libraries of R5RS, R7RS-small, and SRFI 43, with additional procedures that are analogous to procedures in the SRFI 1 list library and the SRFI 13 string library. As a single exception, the vector-copy procedure in R7RS-small does not provide the fill argument present in SRFI 43.
The procedures that are already in R7RS-small will not be overridden by this library, and are listed only for completeness.
Numeric vector analogues of these procedures, excluding the ones in NumericVectorsCowan, will be provided in a separate library.
make-vector (R5RS), vector (R5RS), vector-unfold (SRFI 43), vector-unfold-right (SRFI 43), vector-copy (R7RS), vector-copy! (R7RS), vector-reverse-copy (SRFI 43+), vector-reverse-copy! (SRFI 43+), vector-append (R7RS), vector-append! (SRFI 1), vector-append-subvectors (see below), vector-concatenate (SRFI 43), vector-concatenate! (SRFI 1), vector-concatenate-reverse (SRFI 13), vector-concatenate-reverse (SRFI 13), vector-tabulate (SRFI 1/13), vector-tabulate! (SRFI 1/13)
vector? (R5RS), vector-empty? (SRFI 43), vector= (SRFI 43+)
vector-ref (R5RS), vector-length (R5RS), vector-take (SRFI 1/13), vector-take-right (SRFI 1/13), vector-drop (SRFI 1/13), vector-drop-right (SRFI 13), vector-split-at (SRFI 1),
vector-fold (SRFI 43+), vector-fold-right (SRFI 43+), vector-reduce (SRFI 43+), vector-reduce-right (SRFI 43+), vector-map (SRFI 43+), vector-map! (SRFI 43+), vector-for-each (R7RS)
The above procedures do not pass the index value to the mapping function, for compatibility with R7RS vector-map and vector-fold. The following versions, which are compatible with SRFI 43 pass the index value as the first argument.
vector-fold-index (SRFI 43+), vector-fold-right-index (SRFI 43+), vector-reduce-index (SRFI 43+), vector-reduce-right-index (SRFI 43+), vector-map-index (SRFI 43+), vector-map-index! (SRFI 43+), vector-for-each-index (R7RS)
vector-count (SRFI 43+), vector-filter (SRFI 1/13), vector-remove (SRFI 1/13), vector-partition (SRFI 1), vector-filter! (SRFI 1), vector-remove! (SRFI 1), vector-partition! (SRFI 1)
vector-delete (SRFI 1/13), vector-delete-duplicates (SRFI 1), vector-delete! (SRFI 1/13), vector-delete-duplicates! (SRFI 1)
vector-prefix-length (SRFI 13), vector-suffix-length (SRFI 13), vector-prefix? (SRFI 13), vector-suffix? (SRFI 13)
vector-find (SRFI 1), vector-index (SRFI 43+), vector-index-right (SRFI 43+), vector-skip (SRFI 43+), vector-skip-right (SRFI 43+), vector-any (SRFI 43+), vector-every (SRFI 43+), vector-take-while (SRFI 1+), vector-drop-while (SRFI 1+), vector-binary-search (SRFI 43+), vector-span (SRFI 1), vector-span! (SRFI 1), vector-break (SRFI 1), vector-break! (SRFI 1)
vector-set! (R5RS), vector-swap! (SRFI 43), vector-fill! (R5RS+), vector-reverse! (SRFI 43+), vector-copy! (R7RS), vector-reverse-copy! (SRFI 43+)
vector->list (R5RS+), reverse-vector->list (SRFI 43+), list->vector (R5RS), reverse-list->vector (SRFI 43), vector->string (R7RS), string->vector (R7RS)
(vector-append-subvectors k fill ( at vector start end ) ...)
Returns a newly allocated vector of length k after copying the portion of each vector from start to end into the new vector starting at at. Any additional locations are initialized with fill. This procedure is a generalization of vector-copy and vector-copy!. Implementations may optimize this procedure using an unsafe primitive that creates an uninitialized vector, in order to avoid touching each element of the result twice. Racket code for an analogue:
(struct range (from to from-vector from-vector-start)) (define (make-vector-from-pieces dim default . inits) (define sorted-inits (sort inits range-<)) (let ((vector (make-vector dim))) (let loop ((cur 0) (inits sorted-inits)) (cond ((null? inits) (vector-fill vector cur dim default)) (else (define init (first inits)) (vector-fill vector cur (range-from init) default) (vector-block-copy vector init) (loop (range-to init) (rest inits))))) vector)) (define (range-< range1 range2) (< (range-from range1) (range-from range2))) (define (vector-block-copy vector range) (define to (range-to range)) (define from-vector (range-from-vector range)) (let loop ((cur (range-from range)) (i (range-from-vector-start range))) (when (< cur to) (vector-set! vector cur (vector-ref from-vector i)) (loop (add1 cur) (add1 i))))) (define (vector-fill vector from to value) (let loop ((from from)) (when (< from to) (vector-set! vector from value) (loop (add1 from)))))