#lang racket
(define (genFig n)
  (let loop ((f '())
             (k 0))
    (if(< k n)
       (loop (cons (genRow n k) f)
             (+ k 1))
       f)))
(define (genRow len pos)
  (let loop ((v '())
             (k 0))
    (if (< k len)
        (loop (cons (if(= pos k) 1 0) v)
              (+ k 1))
        v)))

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

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

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

(define (fst x y) x)

(define lazy-infinity (delay (infinity)))
(force (fst 3 lazy-infinity))
(delay (force infinity))

(fst 10 lazy-infinity)

(take 10 (iterate (lambda (x) (+ x 1)) 5))
(define succession (iterate (lambda (x) (+ x 1)) 3))
(print succession)
(newline)
(car (force (cdr (force (cdr (force succession))))))

(define lista '(1 2))
(print lista)
(newline)
(car lista)
(abs (car (cdr lista)))

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

;(define V (re-map (lambda (x) (+ x 1)) '(0 1 -4 3 -6 5) negative?))

(define mini-lista (cons 1 2))