(define my-eval '(let (first (lambda (a) (car a))) ;;dodatkowe selektory do list do ulatwienia
                   (let (second (lambda (a) (car (cdr a))))
                     (let (third (lambda (a) (car (cdr (cdr a)))))
                       (let (length (lambda (a) (let (iter (lambda-rec (iterr lis counter)
                                                                       (if (null? lis)
                                                                           counter
                                                                            (iterr (cdr lis) (+ counter 1)))))
                                                  (iter a 0))))
                       (let (arith-expr? (lambda (a) ;;predykat sprawdza czy to wyrazenie arytmetyczne
                                           (if (list? a)
                                               (if (= (length a) 3)
                                                   (if (eq? (first a) (quote +))
                                                       true
                                                       (if (eq? (first a) (quote -))
                                                           true
                                                           (if (eq? (first a) (quote *))
                                                               true
                                                               (if (eq? (first a) (quote /))
                                                                   true
                                                                   false))))
                                                   false)
                                               false)))
                         (let (arith-op (lambda (a) (first a))) ;;selektor operatora
                           (let (arith-left-arg (lambda (a) (second a))) ;;selektor pierwszego arg
                             (let (arith-right-arg (lambda (a) (third a))) ;;selektor drugiego arg
                               (let (eval ;;ewaluator
                                     (lambda-rec (eval-help expr)
                                                 (cond
                                                   [(arith-expr? expr) (cond ;;jesli wyrazenie arytemetyczne to
                                                                         ;;aplikuje odpowiednia procedure do
                                                                         ;;zewaluowanych argumentow
                                                                         [(eq? (arith-op expr) (quote +))
                                                                          (+ (eval-help (arith-left-arg expr))
                                                                             (eval-help (arith-right-arg expr)))]
                                                                         [(eq? (arith-op expr) (quote -))
                                                                          (- (eval-help (arith-left-arg expr))
                                                                             (eval-help (arith-right-arg expr)))]
                                                                         [(eq? (arith-op expr) (quote *))
                                                                          (* (eval-help (arith-left-arg expr))
                                                                             (eval-help (arith-right-arg expr)))]
                                                                         [(eq? (arith-op expr) (quote /))
                                                                          (/ (eval-help (arith-left-arg expr))
                                                                             (eval-help (arith-right-arg expr)))])]
                                                   [true expr] ;; jesli cos nie jest arith-expr to jest liczba
                                                   )))
                                 ;;TEST (* (+ (/ 4 2) (* 8 (+ 1 1))) (- 8 (+ 2 2)))
                                 (eval (list (quote *) ;; 18*4 = 72
                                              (list (quote +) ;; 2+16 = 18
                                                           (list (quote /) 4 2) ;; 4/2 = 2
                                                           (list (quote *) 8 ;;  8*2 = 16
                                                                 (list (quote +) 1 1))) ;; 1+1= 2
                                                    (list (quote -) 8 ;; 8 - 4 = 4
                                                          (list (quote +) 2 2)))) ;; 2+ 2 =4
                                 ))))))))))