#lang scheme/base

;; Algebra of loop transformations.

;; Phase 1: build a substrate that makes verification of laws simple.
;; Let's take circular vectors of exact numbers.

(define N 10)
(define max-e 100)


(define (random-element . _)
  (inexact->exact (floor (* max-e (random)))))
(define (random-stream . _)
  (build-list N random-element))
(define (stream= s1 s2)
  (andmap = s1 s2))

(define stream-length length)
(define stream-ref list-ref)

(define (I stream) stream)
(define (Z stream)
  (append (cdr stream) (list (car stream))))


(define s1 (random-stream))
(define s2 (random-stream))


(define (quickcheck fn1 fn2 n [times 10])
  (for ((i (in-range times)))
    (let ((streams (build-list n random-stream)))
      (let ((r1 (apply fn1 streams))
            (r2 (apply fn2 streams)))
        (unless (stream= r1 r2)
          (printf "ERROR: in ~a\n~a != ~a\n" streams r1 r2))))))



(define (loop_I_Z binop s)
  (let-values
      (((rout last)
        (for/fold
            ((rout '())
             (ze (car s)))
            ((e (cdr s)))
            (values (cons (binop e ze) rout) e))))
    (reverse (cons (binop (car s) last) rout))))



;(define (_loop_I_Z binop s)
;  (let ((n (stream-length s)))
;    (let loop ((i 1)
;               (ze (stream-ref s 0))
               
                 
          
    
(quickcheck
 (lambda (s) (map + (I s) (Z s)))
 (lambda (s) (loop_I_Z + s))
 1 10)