(defun lisp-interpreter (expression)
  "Простейший интерпретатор Lisp."
  (let ((global-environment '()))
 
    (labels (
      (evaluate (expr env)
        (cond
          ((numberp expr) expr)
          ((symbolp expr) (or (lookup expr env) expr)) ; Ищем значение переменной
          ((listp expr)
           (let ((function (car expr))
                 (arguments (cdr expr)))
             (apply-function function arguments env)))
          (t (error "Неизвестный тип выражения: ~A" expr))))
 
      (lookup (symbol env)
        (assoc symbol env))
 
      (apply-function (function arguments env)
        (cond
          ((eql function 'quote) (car arguments))
          ((eql function 'car) (car (evaluate (car arguments) env)))
          ((eql function 'cdr) (cdr (evaluate (car arguments) env)))
          ((eql function 'cons) (cons (evaluate (car arguments) env) (evaluate (cadr arguments) env)))
          ((eql function '+) (apply '+ (mapcar #'(lambda (arg) (evaluate arg env)) arguments)))
          ((eql function '-) (apply '- (mapcar #'(lambda (arg) (evaluate arg env)) arguments)))
          ((eql function '*) (apply '* (mapcar #'(lambda (arg) (evaluate arg env)) arguments)))
          ((eql function '/) (apply '/ (mapcar #'(lambda (arg) (evaluate arg env)) arguments)))
          ((eql function '=) (= (evaluate (car arguments) env) (evaluate (cadr arguments) env)))
          ((eql function '<) (< (evaluate (car arguments) env) (evaluate (cadr arguments) env)))
          ((eql function '>) (> (evaluate (car arguments) env) (evaluate (cadr arguments) env)))
          ((eql function 'list) (mapcar #'(lambda (arg) (evaluate arg env)) arguments)) ; Реализация list
          ((eql function 'if)
           (if (evaluate (car arguments) env)
               (evaluate (cadr arguments) env)
               (evaluate (caddr arguments) env))) ; if
          ((eql function 'defun)
           (let ((name (car arguments))
                 (params (cadr arguments))
                 (body (caddr arguments)))
             (setf global-environment (acons name `(lambda ,params ,body) global-environment))
             name))
          ((eql function 'setq)
           (let ((symbol (car arguments))
                 (value (evaluate (cadr arguments) env)))
               (setf global-environment (acons symbol value global-environment))
               value))
            (t  ; Пользовательская функция или lambda (ищем в окружении)
             (let ((func-def (lookup function env)))
              (if func-def
                (let ((func (cdr func-def))
                      (params (cadr func))
                      (body (caddr func))
                      (evaluated-args (mapcar #'(lambda (arg) (evaluate arg env)) arguments)))
                    (evaluate body (append (mapcar #'cons params evaluated-args) env)))
                (let ((func-def-global (lookup function global-environment)))
                  (if func-def-global
                      (let ((func (cdr func-def-global))
                            (params (cadr func))
                            (body (caddr func))
                            (evaluated-args (mapcar #'(lambda (arg) (evaluate arg env)) arguments)))
                        (evaluate body (append (mapcar #'cons params evaluated-args) env)))
                    (error "Неизвестная функция: ~A" function))))))
          )))
 
      (evaluate expression global-environment))))
 
;; Примеры использования
(format t "Результат: ~A~%" (lisp-interpreter '(cons (car (cdr (quote (e r t w)))) (cons (cdr (quote (g h 6))) (quote ())))))
(format t "Результат: ~A~%" (lisp-interpreter '(+ 2 (* 3 4))))
(format t "Результат: ~A~%" (lisp-interpreter '(- 10 (/ 6 2))))
(format t "Результат: ~A~%" (lisp-interpreter '(if (> 5 3) 10 20)))
(format t "Результат: ~A~%" (lisp-interpreter '(if (= 5 3) 10 20)))
(format t "Результат: ~A~%" (lisp-interpreter '(car (list 1 2 3))))
 

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