;; the let-lift procedure
(define (reverse xs)
  (define (iter xs ys)
    (if (null? xs) ys
        (iter (cdr xs) (cons (car xs) ys))))
  (iter xs null))

;; wynik jako para (wyrazenie, licznik)
(define (ret-cons expr counter)
  (cons expr counter))
(define ret-expr car)
(define ret-counter cdr)

(define (eval-rec e env i)
  (define (eval-list done rest env i)
    (if (null? rest) (ret-cons (reverse done) i)
        (let ((e (eval-rec (car rest) env i)))
          (eval-list (cons (car e) done) (cdr rest) env (cdr e)))))
  (cond [(const? e) (ret-cons e i)]
        [(var? e) (ret-cons (find-in-env (var-var e) env) i)]
        [(op? e) (let ((args(eval-list '() (op-args e) env i)))
                   (ret-cons (cons (op-op e) (ret-expr args)) (cdr args)))]
        [(let? e) (let* ((def-expr (eval-rec (let-def-expr (let-def e)) env i))
                         (expr (eval-rec (let-expr e)
                                         (add-to-env (let-def-var (let-def e)) (number->symbol (ret-counter def-expr)) env)
                                         (+ 1 (ret-counter def-expr)))))
                    (ret-cons (let-cons (let-def-cons (number->symbol (ret-counter def-expr)) (ret-expr def-expr))
                                        (ret-expr expr))
                              (ret-counter expr)))]))