(define (numbers-from n)
  (cons n (numbers-from (add1 n))))

;; Try: (list-ref (numbers-from 0) 100)

(define (just-evens l)
  (cond
    [(even? (first l)) (cons (car l)
                             (just-evens (cdr l)))]
    [else (just-evens (cdr l))]))

;; Try: (list-ref (just-evens (numbers-from 0)) 100)

(define (sift n l)
  (cond
    [(zero? (modulo (first l) n))
     (sift n (rest l))]
    [else (cons (first l) (sift n (rest l)))]))

(define (sieve l)
  (cons (first l)
        (sieve (sift (first l) (rest l)))))

(define natural (numbers-from 0))

(define primes (sieve (numbers-from 2)))

;; Try: (!! (take 20 primes))
;;   [the `take' function is built in]

;; ----------------------------------------

(define-type List
  [mt]
  [kons (n number?)
        (rest List?)])

(define (Numbers-From n)
  (kons n
        (Numbers-From (add1 n))))

(define (List-Ref l n)
  (type-case List l
    [mt () (error "too far")]
    [kons (m rest)
          (if (zero? n)
              m
              (List-Ref rest (sub1 n)))]))

;; Try: (List-ref (Numbers-From 1) 200)

;; ----------------------------------------

(define-type Tree
  [leaf (n number?)]
  [node (left Tree?)
        (right Tree?)])


;; Generates an infinite tree like this:
;;       /\
;;      n  \
;;         /\
;;        /\ ...
;;     n+1  \
;;          /\
;;         /\ ...
;;        /\ ...
;;      n+2 \
;;          /\
;;        ... ...
;; (The left branches keep getting longer.)
(define (generate d n)
  (cond
    [(zero? d) (leaf n)]
    [else (node (generate (sub1 d) n)
                (generate (add1 d) (add1 n)))]))


;; sum-until : tree num -> (list total remaining)
;;   Sums leaves in the tree until `n' leaves
;;   have been found. The result is a list
;;   containing the sum and the number of additional
;;   leaves still needed to get to `n' leaves.
(define (sum-until l n)
  (cond
    [(zero? n) (list 0 0)]
    [else (type-case Tree l
            [leaf (m) (list m (sub1 n))]
            [node (l r) (let ([res (sum-until l n)])
                          (if (zero? (second res))
                              res
                              (let ([res2 (sum-until r (second res))])
                                (list (+ (first res)
                                         (first res2))
                                      (second res2)))))])]))

;; Try (!! (sum-until (generate 0 1) 10))