define-indexable-sequence-procedures.sls

(library (sequences define-indexable-sequence-procedures)

  (export define-indexable-sequence-procedures)

  (import (rnrs)
          (dharmalab misc gen-id)
          (sequences indexable-functors))

  (define-syntax define-indexable-sequence-procedures

    (lambda (stx)

      (syntax-case stx ()

        ((_ type type-length type-ref type-set! new-of-size)

         (with-syntax ((type-fold-left              (gen-id #'type #'type "-fold-left"))
                       ;; (type-to-reverse-list     (gen-id #'type #'type "-reverse-list"))
                       (type-fold-right             (gen-id #'type #'type "-fold-right"))
                       (type-for-each               (gen-id #'type #'type "-for-each"))
                       (type-for-each-with-index    (gen-id #'type #'type "-for-each-with-index"))
                       (type-copy                   (gen-id #'type #'type "-copy"))
                       (type-map-to-reverse-list    (gen-id #'type #'type "-map-to-reverse-list"))
                       (type-from-reverse-list      (gen-id #'type #'type "-from-reverse-list"))
                       (type-map!                   (gen-id #'type #'type "-map!"))
                       (type-map                    (gen-id #'type #'type "-map"))
                       (type-subseq                 (gen-id #'type #'type "-subseq"))
                       (type-take                   (gen-id #'type #'type "-take"))
                       (type-drop                   (gen-id #'type #'type "-drop"))
                       (type-filter-to-reverse-list (gen-id #'type #'type "-filter-to-reverse-list"))
                       (type-filter                 (gen-id #'type #'type "-filter"))
                       (type-index                  (gen-id #'type #'type "-index"))
                       (type-find                   (gen-id #'type #'type "-find"))
                       (type-swap!                  (gen-id #'type #'type "-swap!"))
                       (type-reverse!               (gen-id #'type #'type "-reverse!"))
                       (type-reverse                (gen-id #'type #'type "-reverse")))

           #'(begin

               (define type-fold-left              (make-indexable-fold-left type-length type-ref))
               ;; (define type-to-reverse-list        (make-indexable-to-reverse-list type-length type-ref))
               (define type-fold-right             (make-indexable-fold-right type-length type-ref))
               (define type-for-each               (make-indexable-for-each type-length type-ref))
               (define type-for-each-with-index    (make-indexable-for-each-with-index type-length type-ref))
               (define type-copy                   (make-indexable-copy type-length type-ref type-set! new-of-size))
               (define type-map!                   (make-indexable-map! type-length type-ref type-set!))
               (define type-map                    (make-indexable-map type-length type-ref type-set! type-copy))
               (define type-subseq                 (make-indexable-subseq type-length type-ref type-set! new-of-size))
               (define type-take                   (make-indexable-take type-subseq))
               (define type-drop                   (make-indexable-drop type-length type-subseq))
               (define type-filter-to-reverse-list (make-indexable-filter-to-reverse-list type-length type-ref))
               (define type-filter                 (make-indexable-filter type-length type-ref type-set! new-of-size))
               (define type-index                  (make-indexable-index type-length type-ref))
               (define type-find                   (make-indexable-find type-length type-ref))
               (define type-swap!                  (make-indexable-swap! type-ref type-set!))
               (define type-reverse!               (make-indexable-reverse! type-length type-swap!))
               (define type-reverse                (make-indexable-reverse type-copy type-reverse!))

               ))))))

  )

f32-vectors.sls

(library (sequences f32-vectors)

  (export make-f32-vector
          f32-vector-length
          f32-vector-ref
          f32-vector-set!
          f32-vector
          
          f32-vector-fold-left
          f32-vector-fold-right
          f32-vector-for-each
          f32-vector-for-each-with-index
          f32-vector-copy
          f32-vector-map!
          f32-vector-map
          f32-vector-subseq
          f32-vector-take
          f32-vector-drop
          f32-vector-filter-to-reverse-list
          f32-vector-filter
          f32-vector-index
          f32-vector-find
          f32-vector-swap!
          f32-vector-reverse!
          f32-vector-reverse)

  (import (rnrs)
          (sequences indexable-functors)
          (sequences define-indexable-sequence-procedures))

  ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (define (make-f32-vector n)
    (make-bytevector (* 4 n)))

  (define (f32-vector-length bv)
    (/ (bytevector-length bv) 4))

  (define (f32-vector-ref bv i)
    (bytevector-ieee-single-native-ref bv (* i 4)))

  (define (f32-vector-set! bv i val)
    (bytevector-ieee-single-native-set! bv (* i 4) val))

  (define (f32-vector . lst)
    (let ((bv (make-f32-vector (length lst))))
      (let loop ((i 0) (lst lst))
        (cond ((null? lst) bv)
              (else
               (f32-vector-set! bv i (car lst))
               (loop (+ i 1) (cdr lst)))))))

  ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (define-indexable-sequence-procedures
    f32-vector
    f32-vector-length
    f32-vector-ref
    f32-vector-set!
    make-f32-vector)

  )

f64-vectors.sls

(library (sequences f64-vectors)

  (export make-f64-vector
          f64-vector-length
          f64-vector-ref
          f64-vector-set!
          f64-vector
          
          f64-vector-fold-left
          f64-vector-fold-right
          f64-vector-for-each
          f64-vector-for-each-with-index
          f64-vector-copy
          f64-vector-map!
          f64-vector-map
          f64-vector-subseq
          f64-vector-filter-to-reverse-list
          f64-vector-filter
          f64-vector-index
          f64-vector-find
          f64-vector-swap!
          f64-vector-reverse!
          f64-vector-reverse)

  (import (rnrs)
          (sequences indexable-functors)
          (sequences define-indexable-sequence-procedures))

  ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (define (make-f64-vector n)
    (make-bytevector (* 8 n)))

  (define (f64-vector-length bv)
    (/ (bytevector-length bv) 8))

  (define (f64-vector-ref bv i)
    (bytevector-ieee-double-native-ref bv (* i 8)))

  (define (f64-vector-set! bv i val)
    (bytevector-ieee-double-native-set! bv (* i 8) val))

  (define (f64-vector . lst)
    (let ((bv (make-f64-vector (length lst))))
      (let loop ((i 0) (lst lst))
        (cond ((null? lst) bv)
              (else
               (f64-vector-set! bv i (car lst))
               (loop (+ i 1) (cdr lst)))))))

  ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (define-indexable-sequence-procedures
    f64-vector
    f64-vector-length
    f64-vector-ref
    f64-vector-set!
    make-f64-vector)

  )

indexable-functors.sls

(library (sequences indexable-functors)

  (export make-indexable-fold-left
          make-indexable-fold-right
          make-indexable-for-each
          make-indexable-for-each-with-index
          make-indexable-copy
          make-indexable-map!
          make-indexable-map
          make-indexable-subseq
          make-indexable-take
          make-indexable-drop
          make-indexable-filter-to-reverse-list
          make-indexable-filter
          make-indexable-index
          make-indexable-find
          make-indexable-swap!
          make-indexable-reverse!
          make-indexable-reverse)

  (import (rnrs))

  ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (define (make-indexable-fold-left size ref)

    (define (fold-left seq val proc)
      (let ((n (size seq)))
        (let loop ((i 0) (val val))
          (if (>= i n)
              val
              (loop (+ i 1) (proc val (ref seq i)))))))

    fold-left)

  ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (define (make-indexable-fold-right size ref)

    (define (fold-right seq val proc)
      (let ((n (size seq)))
        (let loop ((i (- n 1)) (val val))
          (if (< i 0)
              val
              (loop (- i 1) (proc (ref seq i) val))))))

    fold-right)

  ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (define (make-indexable-for-each size ref)

    (let ((fold-left (make-indexable-fold-left size ref)))

      (define (for-each seq proc)
        (fold-left seq #f (lambda (val elt)
                            (proc elt))))

      for-each))

  ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (define (make-indexable-for-each-with-index size ref)

    (let ((fold-left (make-indexable-fold-left size ref)))

      (define (for-each-with-index seq proc)
        (fold-left seq 0 (lambda (i elt)
                           (proc i elt)
                           (+ i 1))))

      for-each-with-index))

  ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (define (make-indexable-copy size ref put! new-of-size)

    (let ((for-each-with-index (make-indexable-for-each-with-index size ref)))

      (define (copy seq)
        (let ((new (new-of-size (size seq))))
          (for-each-with-index seq (lambda (i elt)
                                     (put! new i elt)))
          new))

      copy))

  ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (define (make-indexable-map! size ref put!)

    (let ((for-each-with-index (make-indexable-for-each-with-index size ref)))

      (define (map! seq proc)
        (for-each-with-index seq
                             (lambda (i elt)
                               (put! seq i (proc elt))))
        seq)

      map!))

  ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (define (make-indexable-map size ref put! copy)

    (let ((map! (make-indexable-map! size ref put!)))
      
      (define (map seq proc)
        (map! (copy seq) proc))

      map))

  ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (define (make-indexable-subseq size ref put! new-of-size)

    (let ((for-each-with-index (make-indexable-for-each-with-index size ref)))

      (define (subseq seq start end)
        (let ((new (new-of-size (- end start))))
          (for-each-with-index new (lambda (i elt)
                                     (put! new i (ref seq (+ start i)))))
          new))

      subseq))

  ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (define (make-indexable-take subseq)

    (define (take seq n)
      (subseq seq 0 n))

    take)

  ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (define (make-indexable-drop size subseq)

    (define (drop seq n)
      (subseq seq n (size seq)))

    drop)

  ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (define (make-indexable-filter-to-reverse-list size ref)

    (let ((fold-left (make-indexable-fold-left size ref)))

      (define (filter-to-reverse-list seq proc)
        (fold-left seq '() (lambda (ls elt)
                             (if (proc elt)
                                 (cons elt ls)
                                 ls))))

      filter-to-reverse-list))

  ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (define (make-indexable-filter size ref put! new-of-size)

    (let ((subseq (make-indexable-subseq size ref put! new-of-size)))

      (define (filter seq proc)
        (let ((n (size seq)))
          (let ((new (new-of-size n)))
            (let loop ((i 0) (j 0))
              (if (>= i n)
                  (subseq new 0 j)
                  (let ((elt (ref seq i)))
                    (cond ((proc elt)
                           (put! new j elt)
                           (loop (+ i 1) (+ j 1)))
                          (else
                           (loop (+ i 1) j)))))))))

      filter))

  ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (define (make-indexable-index size ref)

    (define (index seq proc)
      (let ((n (size seq)))
        (let loop ((i 0))
          (if (>= i n)
              #f
              (let ((elt (ref seq i)))
                (if (proc elt)
                    i
                    (loop (+ i 1))))))))

    index)

  ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (define (make-indexable-find size ref)

    (let ((index (make-indexable-index size ref)))

      (define (find seq proc)

        (let ((i (index seq proc)))

          (if i (ref seq i) #f)))

      find))

  ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (define (make-indexable-swap! ref put!)

    (define (swap! seq i j)
      (let ((a (ref seq i))
            (b (ref seq j)))
        (put! seq i b)
        (put! seq j a)
        seq))

    swap!)

  ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (define (make-indexable-reverse! size swap!)

    (define (reverse! seq)
      (let ((n (size seq)))
        (let loop ((i 0) (j (- n 1)))
          (if (>= i j)
              seq
              (begin (swap! seq i j)
                     (loop (+ i 1) (- j 1)))))))

    reverse!)

  ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (define (make-indexable-reverse copy reverse!)

    (define (reverse seq)
      (reverse! (copy seq)))

    reverse)

  ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  )

iterable-functors.sls

(library (sequences iterable-functors)

  (export make-iterable-fold-left
          make-iterable-to-reverse-list
          make-iterable-fold-right
          make-iterable-for-each
          make-iterable-for-each-with-index
          make-iterable-map-to-reverse-list
          make-iterable-from-reverse-list
          make-iterable-map
          make-iterable-take
          make-iterable-drop
          make-iterable-subseq
          make-iterable-filter)

  (import (rnrs))

  ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (define (make-iterable-fold-left empty? next rest)

    (define (fold-left seq val proc)
      (let loop ((seq seq) (val val))
        (if (empty? seq)
            val
            (loop (rest seq)
                  (proc val (next seq))))))

    fold-left)

  ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (define list-fold-left (make-iterable-fold-left null? car cdr))

  ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (define (make-iterable-to-reverse-list fold-left)

    (define (to-reverse-list seq)
      (fold-left seq '() (lambda (ls elt) (cons elt ls))))

    to-reverse-list)

  ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (define (make-iterable-fold-right to-reverse-list)

    (define (fold-right seq val proc)
      (list-fold-left (to-reverse-list seq)
                      val
                      (lambda (b a)
                        (proc a b))))

    fold-right)

  ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (define (make-iterable-for-each fold-left)

    (define (for-each seq proc)
      (fold-left seq #f (lambda (val elt)
                          (proc elt))))

    for-each)

  ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (define (make-iterable-for-each-with-index fold-left)

    (define (for-each-with-index seq proc)
      (fold-left seq 0 (lambda (i elt)
                         (proc i elt)
                         (+ i 1))))

    for-each-with-index)

  ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (define (make-iterable-map-to-reverse-list fold-left)

    (define (map-to-reverse-list seq proc)
      (fold-left seq '() (lambda (ls elt)
                           (cons (proc elt) ls))))

    map-to-reverse-list)

  ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (define (make-iterable-from-reverse-list null kons)

    (define (from-reverse-list ls)
      (list-fold-left ls
                      null
                      (lambda (ls elt) (kons elt ls))))

    from-reverse-list)

  ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (define (make-iterable-map from-reverse-list map-to-reverse-list)

    (define (map seq proc)
      (from-reverse-list
       (map-to-reverse-list seq proc)))

    map)

  ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (define (make-iterable-take next rest from-reverse-list)

    (define (take seq n)
      (let loop ((seq seq) (n n) (accum '()))
        (if (= n 0)
            (from-reverse-list accum)
            (loop (rest seq)
                  (- n 1)
                  (cons (next seq) accum)))))

    take)

  ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (define (make-iterable-drop rest)

    (define (drop seq n)
      (let loop ((seq seq) (n n))
        (if (= n 0)
            seq
            (loop (rest seq) (- n 1)))))

    drop)

  ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (define (make-iterable-subseq take drop)

    (define (subseq seq start end)
      (take (drop seq start) (- end start)))

    subseq)

  ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

  (define (make-iterable-filter empty? next rest from-reverse-list)

    (define (filter seq proc)

      (let loop ((seq seq) (accum '()))

        (if (empty? seq)

            (from-reverse-list accum)

            (let ((elt (next seq)))

              (if (proc elt)
                  (loop (rest seq)
                        (cons elt accum))
                  (loop (rest seq) accum))))))

    filter)

  )

lists.sls

(library (sequences lists)

  (export list-fold-left
          list-to-reverse-list
          list-fold-right
          list-for-each
          list-for-each-with-index
          list-map-to-reverse-list
          list-from-reverse-list
          list-map
          list-take
          list-drop
          list-subseq
          list-filter)

  (import (rnrs)
          (sequences iterable-functors))

  (define list-fold-left  (make-iterable-fold-left null? car cdr))

  (define list-to-reverse-list (make-iterable-to-reverse-list list-fold-left))

  (define list-fold-right (make-iterable-fold-right list-to-reverse-list))

  (define list-for-each (make-iterable-for-each list-fold-left))

  (define list-for-each-with-index (make-iterable-for-each-with-index list-fold-left))

  (define list-map-to-reverse-list (make-iterable-map-to-reverse-list list-fold-left))

  (define list-from-reverse-list (make-iterable-from-reverse-list '() cons))

  (define list-map (make-iterable-map list-from-reverse-list list-map-to-reverse-list))

  (define list-take (make-iterable-take car cdr list-from-reverse-list))

  (define list-drop (make-iterable-drop cdr))

  (define list-subseq (make-iterable-subseq list-take list-drop))

  (define list-filter (make-iterable-filter null? car cdr list-from-reverse-list))

  )

ra-lists.sls

(library (sequences ra-lists)

  (export ra-list-fold-left
          ra-list-to-reverse-list
          ra-list-fold-right
          ra-list-for-each
          ra-list-map-to-reverse-list
          ra-list-from-reverse-list
          ra-list-map
          ra-list-take
          ra-list-drop
          ra-list-subseq
          ra-list-filter)

  (import (rnrs)
          (prefix (surfage s101 random-access-lists) ra-)
          (sequences iterable-functors))

  (define ra-list-fold-left (make-iterable-fold-left ra-null? ra-car ra-cdr))

  (define ra-list-to-reverse-list (make-iterable-to-reverse-list ra-list-fold-left))

  (define ra-list-fold-right (make-iterable-fold-right ra-list-to-reverse-list))

  (define ra-list-for-each (make-iterable-for-each ra-list-fold-left))

  (define ra-list-map-to-reverse-list
    (make-iterable-map-to-reverse-list ra-list-fold-left))

  (define ra-list-from-reverse-list
    (make-iterable-from-reverse-list (ra-list) ra-cons))

  (define ra-list-map
    (make-iterable-map ra-list-from-reverse-list ra-list-map-to-reverse-list))

  (define ra-list-take
    (make-iterable-take ra-car ra-cdr ra-list-from-reverse-list))

  (define ra-list-drop
    (make-iterable-drop ra-cdr))

  (define ra-list-subseq
    (make-iterable-subseq ra-list-take ra-list-drop))

  (define ra-list-filter
    (make-iterable-filter ra-null? ra-car ra-cdr ra-list-from-reverse-list))

  )

vectors.sls

(library (sequences vectors)

  (export vector-fold-left
          vector-fold-right
          vector-for-each
          vector-for-each-with-index
          vector-copy
          vector-map!
          vector-map
          vector-subseq
          vector-take
          vector-drop
          vector-filter-to-reverse-list
          vector-filter
          vector-index
          vector-find
          vector-swap!
          vector-reverse!
          vector-reverse)

  (import (except (rnrs) vector-for-each vector-map)
          (sequences indexable-functors)
          (sequences define-indexable-sequence-procedures))

  ;; (define vector-fold-left (make-indexable-fold-left vector-length vector-ref))

  ;; (define vector-fold-right (make-indexable-fold-right vector-length vector-ref))

  ;; (define vector-for-each (make-indexable-for-each vector-length vector-ref))

  ;; (define vector-for-each-with-index
  ;;   (make-indexable-for-each-with-index vector-length vector-ref))

  ;; (define vector-copy
  ;;   (make-indexable-copy vector-length vector-ref vector-set! make-vector))

  ;; (define vector-map! (make-indexable-map! vector-length vector-ref vector-set!))

  ;; (define vector-map
  ;;   (make-indexable-map vector-length vector-ref vector-set! vector-copy))

  ;; (define vector-subseq
  ;;   (make-indexable-subseq vector-length vector-ref vector-set! make-vector))

  ;; (define vector-filter-to-reverse-list
  ;;   (make-indexable-filter-to-reverse-list vector-length vector-ref))

  ;; (define vector-filter
  ;;   (make-indexable-filter vector-length vector-ref vector-set! make-vector))

  ;; (define vector-index (make-indexable-index vector-length vector-ref))

  ;; (define vector-find (make-indexable-find vector-length vector-ref))

  ;; (define vector-swap! (make-indexable-swap! vector-ref vector-set!))

  ;; (define vector-reverse! (make-indexable-reverse! vector-length vector-swap!))

  ;; (define vector-reverse (make-indexable-reverse vector-copy vector-reverse!))

  (define-indexable-sequence-procedures vector vector-length vector-ref vector-set!)

  )