(define eval-arith
  '(let (member?
         (lambda-rec (member-in-list? e list)
                     (cond
                       [(my-null? list ) false]
                       [(eq? e (car list)) true]
                       [true (member-in-list? e (cdr list))])))

     (let
         (length
          (lambda-rec (lenght list)
                      (if (my-null? list)
                          0
                          (+ 1 (len (cdr list))))))
       (let
           (is-list?
            (lambda-rec (is-list? list)
                        (or (my-null? list)
                            (and (pair? list)
                                 (is-list? (cdr list))))))

         (let
             (binop?
              (lambda (e)
                (and (is-list? e)
                     (and (= (length e) 3)
                          (member? (car e) (cons-cons '+ (cons-cons '- (cons-cons '* (cons-cons '/ null)))))))))

           (let (binop-op (lambda (t) (car t)))
             (let (binop-left (lambda (t) (car (cdr t))))
               (let (binop-right (lambda (t) (car (cdr (cdr t)))))
                 (let (op->proc (lambda (op)
                                  (cond ((eq? op '+) (lambda (x y) (+ x y)))
                                        ((eq? op '-) (lambda (x y) (- x y)))
                                        ((eq? op '*) (lambda (x y) (* x y)))
                                        ((eq? op '/) (lambda (x y) (/ x y))))))
                   (lambda-rec (eval e)
                               (cond ((number? e) e)
                                     ((binop? e)
                                      ((op->proc (binop-op e))
                                       (eval (binop-left e))
                                       (eval (binop-right e)))))))))))))))

(define (eval-arithmetic expr)
  (eval (list eval-arith expr)))