(load "./stream.scm")
(import stream)

(define (prime? n)
  (define (square x) (* x x))
  (define (divisible? x y) (= 0 (modulo x y)))
  (define (iter ps)
    (cond ((> (square (stream-car ps)) n) #t)
          ((divisible? n (stream-car ps)) #f)
          (else (iter (stream-cdr ps)))))
  (iter primes))

(define primes
  (stream-cons 2 (stream-filter prime? (stream-from 3))))

;;(print (stream->list (stream-take 20 primes)))

;; -----------------------------------------------------------------
(define (find-prime-forms desc N form)
  (let loop ((i 1)
             (maximum N)
             (hits 0)
             (result ()))
    (cond ((= i maximum)
           (format #t "found ~s primes of form ~s for 0 <= n < ~s\n"
                   hits desc maximum)
           (reverse result))
          ((prime? (form i))
           (set! hits (+ hits 1))
           (loop (+ i 1) maximum hits (cons (list i (form i)) result)))
          (else
           (loop (+ i 1) maximum hits result)))))

(define-syntax fpf
  (syntax-rules ()
    ((_ N var form)
     (print (find-prime-forms 'form N (lambda (var) form))))))

(fpf 100 x (+ 1 (* x x)))
(fpf 10  x (- (expt 2 x) 1))
(fpf 10  x (+ (expt 2 x) 1))
(fpf 100 x (+ x 2))
(fpf 100 x (+ x 3))
(fpf 100 x (+ x x 1))

;; (print "enter prime form in terms of 'x':")
;; (let ((form (read)))
;;   (print "{" form "}")
;;   (fpf 100 x form))