Lisp - Type Error bug simple program

If you use SBCL you can see the source where the error happens.

The code needs to be compiled with a higher debug value:

(declaim (optimize (debug 3)))

Example:

CL-USER> (eval-clause '(A (NOT B) C) *state*)

debugger invoked on a TYPE-ERROR: The value A is not of type LIST.

Type HELP for debugger help, or (SB-EXT:EXIT) to exit from SBCL.

restarts (invokable by number or by possibly-abbreviated name):
  0: [RETRY            ] Retry SLIME REPL evaluation request.
  1: [ABORT            ] Return to SLIME's top level.
  2: [REMOVE-FD-HANDLER] Remove #<SB-IMPL::HANDLER INPUT on descriptor 12: #<CLOSURE (LABELS SWANK-BACKEND::RUN :IN SWANK-BACKEND:ADD-FD-HANDLER) {1004DC423B}>>
  3:                     Exit debugger, returning to top level.
(EVAL-CLAUSE (A (NOT B) C) ((A T) (B T) (C T) (D T)))
   source: (CADR (CAR CLAUSE))

You can find out about the source:

0] source

(CADR (CAR CLAUSE)) 

You can't call CAR on a symbol A.

One more enclosing form:

0] source 1

(EVAL-VAR (#:***HERE*** (CADR (CAR CLAUSE))) STATE) 

Two more enclosing forms:

0] source 2

(NOT (EVAL-VAR (#:***HERE*** (CADR (CAR CLAUSE))) STATE)) 

0] source 3

(IF (EQUAL (CADR CLAUSE) 'B)
    (EVAL-VAR (CADR CLAUSE) STATE)
    (NOT (EVAL-VAR (#:***HERE*** (CADR (CAR CLAUSE))) STATE))) 

You now see the form where it happens in enough context.

It seems like what you're trying to achieve is to evaluate a set of logical expressions in *clause* using variables from *state*. Your current code is kinda messy, so I just wrote a solution myself instead of fixing it.

I used a library called Optima for pattern matching. You can install it with quicklisp by running (ql:quickload :optima) before loading the below code.

;; My solution supports NOT, AND and OR operators. AND and OR can only
;; be used with exactly two arguments. These will be evaluated
;; recursively, so they can be nested too.
(defparameter *clause* '((or b c)
                         (not b)
                         (or c (and a b))))

;; I used cons cells here instead of lists. More efficient this way.
;; You can use CAR and CDR to access the parts of a cons cell. Note
;; that accessing the second part is done with just a CDR, rather than
;; with CADR like with lists.
(defparameter *state* '((a . t)
                        (b . t)
                        (c . nil)
                        (d . nil)))

(defun get-var (var state)
  "Get VAR in STATE. Signals an error if VAR doesn't exist."
  ;; You can use ASSOC to find values in an "association list" like
  ;; *STATE*. ASSOC returns the whole cons, so CDR is used to return
  ;; the value of the variable.
  (cdr (or (assoc var state)
           (error "Unknown variable ~a." var))))

(defun eval-clause (clause state)
  "Recursively evaluate CLAUSE using variables in STATE."
  ;; OPTIMA:MATCH performs pattern matching with the first argument
  ;; (CLAUSE in this case). Pattern matching is much like a CASE,
  ;; except it allows you to match against various kinds of patterns
  ;; instead of simple values.
  (optima:match clause
    ;; This matches a single atom (such as A or B) and returns its
    ;; value.
    ((optima:guard var (atom var)) (get-var var state))
    ;; The patterns like `(LIST 'AND a b)` match a list that starts
    ;; with AND and has two elements after it; the two elements will
    ;; be bound to variables A and B, which can then be used in the
    ;; following form.
    ((list 'not a) (not (eval-clause a state)))
    ((list 'and a b) (and (eval-clause a state)
                          (eval-clause b state)))
    ((list 'or a b) (or (eval-clause a state)
                        (eval-clause b state)))
    ;; If CLAUSE doesn't match anything above, signal an error.
    (err-form (error "Unknown expression: ~a." err-form))))

(defun eval-all-clauses (clauses state)
  "Evaluate all logical expressions in CLAUSES using variables in STATE.
Returns a list of results."
  (mapcar (lambda (c) (eval-clause c state)) clauses))

;; Run it
(eval-all-clauses *clause* *state*)
; => (T NIL T)