iterable-functors.scm

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

;; iterable: list ra-list stream

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

(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 (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 empty? next rest)

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

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

    for-each))

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

(define (make-iterable-for-each-with-index empty? next rest)

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

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

;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; list
;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

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

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

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

(define list-for-each (make-iterable-for-each null? car cdr))

(define list-for-each-with-index
  (make-iterable-for-each-with-index null? car cdr))

(define list-to-reverse-list
  (make-iterable-to-reverse-list 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-list
;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(import (prefix (surfage s101 random-access-lists) ra-))

(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-null? ra-car ra-cdr))

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

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