#lang racket
(define saved-cont #f)

(define (test-cont)
  (let ((x 0))
    (call/cc
     (lambda (k)
            (set! saved-cont k)))
    (set! x (+ x 1))
    (display x)
    (newline)))

(define (iterate f v)
  (delay (cons v (iterate f (f v)))))

(define (take n prom)
  (if (= n 0)
      '()
      (let ((v (force prom)))
        (cons (car v) (take (- n 1) (cdr v))))))

(define (ftree treef treed)
  (cond
    ((null? treef) treed)
    ((list? treef) (cons (ftree (car treef) (car treed))
                         (ftree (cdr treef) (cdr treed))))
    (else; should be atoms
     (treef treed))))

(define (first x y) x)

(define (infinity) (+ 1 (infinity)))

(define lazy-infinity (delay (infinity)))

(define (re-map f L cond?)
  (let loop ((res '())
             (cur L))
    (if (null? cur)
        res
        (let* ((k #f)
               (v (call/cc
                   (lambda (cont)
                     (set! k cont)
                     (f (car cur))))))
          (if (cond? v)
              (cons k v)
              (loop (append res (list v))
                    (cdr cur)))))))

(struct cnode (value next) #:mutable)

(define *end* '---end---)

(define (cend)
  (let ((node (cnode *end* #f)))
    (set-cnode-next! node node)
    node))
(define (ccons x node)
  (if (cend? node)
      (let ((out (cnode x #f)))
        (set-cnode-next! out node)
        (set-cnode-next! node out)
        out)
      (let ((the-end (get-end node))
            (out (cnode x node)))
        (set-cnode-next! the-end out)
        out)))

(define (cend? clist)
  (and (cnode? clist)
       (eq? (cnode-value clist) *end*)))

(define (get-end clist)
  (if (cend? clist)
      clist
      (get-end (cnode-next clist))))

(define (cmap f clist)
  (if (cend? clist)
      (cend)
      (ccons (f (cnode-value clist))
             (cmap f (cnode-next clist)))))

(define-syntax-rule (my-while condition body ...)
  (let loop ()
    (when condition
      body ...
      (loop))))

(define (genFig n)
  (let loop ((f '())
             (k 0))
    (if (< k n)
           (loop (cons (genRow n k) f)
                 (+ k 1))
    f)))

(define (genRow n k)
  (let loop ((r '())
             (i 0))
    (if (< i n)
           (loop (cons (if (= i k) 1 0) r)
                 (+ i 1))
    r)))

(define (infinity)
  (+ 1 (infinity)))

(define (fst x y) x)

(define lazy-infinity (delay(infinity)))
;(fst 3 (infinity))
(force (fst 3 lazy-infinity))
(fst 3 lazy-infinity)
(define res (delay (+ 2 5)))
(force res)
(force (delay (fst 3 lazy-infinity)))