indexable-functors.scm

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

(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)))))

    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)
      seq)

    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-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-from-list put! new-of-size)

;;   (define (from-list ls)
;;     (let ((new (new-of-size (length ls))))
;;       (list-for-each-with-index ls (lambda (i elt)
;;                                      (put! new i elt)))
;;       new))

;;   from-list)

;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; vector
;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(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-index (make-indexable-index vector-length vector-ref))

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