(define iota
  (lambda (num)
    (letrec ((kernel 
              (lambda (n lst) 
                (if (= n 0)
                    lst
                    (kernel (- n 1)
                            (cons (- n 1) lst))))))
      (cond
        ((not (integer? num)) (error "iota: expects an integer"))
        ((not (exact? num)) (error "iota: expects an exact integer"))
        ((< num 0) (error "iota: expects a non-negative integer"))
        (else (kernel num null))))))

(define iota-b
  (lambda (num)
    (cond
      ((not (integer? num)) (error "iota: expects an integer"))
      ((not (exact? num)) (error "iota: expects an exact integer"))
      ((< num 0) (error "iota: expects a non-negative integer"))
      (else
       (let kernel ((n num)
                    (lst null)) 
                        (if (= n 0)
                    lst
                    (kernel (- n 1)
                            (cons (- n 1) lst))))))))

(define take
  (lambda (lst n)
    (letrec ((kernel (lambda (remaining
                              so-far
                              num)
                       (if (zero? num)
                           (reverse so-far)
                           (kernel (cdr remaining)
                                   (cons (car remaining) so-far)
                                   (- num 1))))))
      (cond
        ((not (list? lst)) (error "take: Expects a list as first parameter."))
        ((not (integer? n)) (error "take: expects an integer as second parameter"))
        ((not (exact? n)) (error "take: expects an exact integer as second parameter"))
        ((< n 0) (error "take: expects a non-negative integer as second parameter"))
        ((> n (length lst)) (error "take: trying to take too many values"))
        (else (kernel lst null n))))))

; (let kernel ((param1 initial1)
;              (param2 initial2))
;         body)