What  is this error  in clojure
Execution error (FileNotFoundException) at test/eval138$loading (main.clj:3).
Could not locate api__init.class, api.clj or api.cljc on classpath.

Full report at:
/tmp/clojure-7149624166054919882.edn

[Execution complete with exit code 1]
and how I need to fix this code


(ns test
  (:use api)
  (:require [clojure.test :as test]))

(test/deftest defpackage-test
  (test/testing "dnf-test"
    (test/is (=
              (dnf (IMPL (variable :x) (variable :y)))
              (OR (NOT (variable :x)) (variable :y))))
    (test/is (=
              (dnf (NOT (OR (OR (NOT (variable :x)) (variable :y)) (NOT (IMPL (variable :y) (variable :z))))))
              (OR (AND (variable :x) (NOT (variable :y))) (AND (variable :x) (NOT (variable :y)) (variable :z)))))
    (test/is (=
              (dnf (IMPL (IMPL (NOT (variable :x)) (NOT (variable :y))) (IMPL (AND (variable :y) (variable :z)) (AND (NOT (variable :x)) (variable :z)))))
              (OR (NOT (variable :y)) (NOT (variable :z)) (AND (NOT (variable :x)) (variable :z)) (NOT (variable :x)))))
    (test/is (=
              (dnf (OR (variable :x) (IMPL (variable :y) (AND (variable :y) (variable :x))))) 
              (OR (variable :x) (NOT (variable :y)) (AND (variable :y) (variable :x)))))
    )
  (test/testing "substitution-test"
    (test/is (=
              (eliminate-constant-domination (dnf (substitution (IMPL (variable :x) (variable :y)) {:x 1})))
              (variable :y)))
    (test/is (=
              (eliminate-constant-domination(dnf (substitution (NOT (OR (OR (NOT (variable :x)) (variable :y)) (NOT (IMPL (variable :y) (variable :z))))) {:x 0, :y 1})))
              (constant 0)))
    (test/is (=
              (eliminate-constant-domination (dnf (substitution (NOT (OR (OR (NOT (variable :x)) (variable :y)) (NOT (IMPL (variable :y) (variable :z))))) {:z 0})))
              (AND (variable :x) (NOT (variable :y)))))
    (test/is (= 
              (eliminate-constant-domination(dnf (substitution (OR (variable :x) (IMPL (variable :y) (AND (variable :y) (variable :x)))) {:x 0})))
              (NOT (variable :y))))))

(test/run-tests 'test)

(ns api)

(defn constant
  "Конструктор константы со значением value"
  [value]
  {:pre [(or (= value 0) (= value 1))]}
  (list ::const value))

(defn constant?
  "Проверка, является ли выражение expr константой"
  [expr]
  (= (first expr) ::const))

(defn constant-value
  "Вернуть значение константы"
  [expr]
  {:pre [(constant? expr)]}
  (second expr))

(defn same-constants?
  "Проверить, являются ли константы const1 и const2 идентичными"
  [const1 const2]
  (and
   (constant? const1)
   (constant? const2)
   (= (constant-value const1)
      (constant-value const2))))

(defn variable
  "Конструктор переменной с именем name"
  [name]
  {:pre [(keyword? name)]}
  (list ::var name))

(defn variable?
  "Проверка, является ли выражение expr переменной"
  [expr]
  (= (first expr) ::var))

(defn variable-name
  "Вернуть имя переменной var"
  [var]
  (second var))

(defn same-variables?
  "Проверить, являются ли переменные var1 и var2 идентичными"
  [var1 var2]
  (and
   (variable? var1)
   (variable? var2)
   (= (variable-name var1)
      (variable-name var2))))

(defn AND
  "Конструктор конъюнкции (&)"
  [expr & rest]
  (if (empty? rest)
    expr
    (cons ::and (cons expr rest))))

(defn AND?
  "Проверить, является ли выражение expr конъюнкцией"
  [expr]
  (= (first expr) ::and))

(defn OR
  "Конструктор дизъюнкции (|)"
  [expr & rest]
  (if (empty? rest)
    expr
    (cons ::or (cons expr rest))))

(defn OR?
  "Проверить, является ли выражение expr дизъюнкцией"
  [expr]
  (= (first expr) ::or))

(defn NOT
  "Конструктор отрицания (~)"
  [expr]
  (list ::not expr))

(defn NOT?
  "Проверить, является ли выражение expr отрицанием"
  [expr]
  (= (first expr) ::not))

(defn IMPL
  "Конструктор импликации (->)"
  [expr1 expr2]
  (list ::impl expr1 expr2))

(defn IMPL?
  "Проверить, является ли выражение expr импликацией"
  [expr]
  (= (first expr) ::impl))

(defn same-type?
  "Проверить, имеют ли выражения один и тот же тип"
  [expr1 expr2]
  (= (first expr1) (first expr2)))

(defn args
  "Вернуть аргументы выражения"
  [expr]
  (rest expr))

(defn merge-same-pred-args
  "Объединить выражения с одной логической операцией"
  [expr]
  (if (or (constant? expr) (variable? expr))
    (list expr)
    (->> (args expr)
         (mapcat #(if (same-type? expr %)
                    (merge-same-pred-args %)
                    (list %))))))

(defn find-same-const
  "Найти хотя бы одну константу const в выражении expr"
  [expr const]
  (some #(same-constants? const %) (args expr)))

(defn same-not-variable?
  "Сравнить, являются ли expr отрицанием переменной variable
  (variable = A, expr = ~A) -> true"
  [variable expr]
  (if (NOT? expr)
    (same-variables? variable (second expr))
    false))

(defn find-same-not-variable
  "Найти хотя бы одно отрицание variable в выражении expr"
  [expr variable]
  (some #(same-not-variable? variable %) (args expr)))

(defn return-all-except-const
  "Вернуть все из expr, за исключением константы const"
  [expr const]
  (filter #(not (same-constants? const %)) (args expr)))

(defn substitution
  "Функция для выполнения подстановки константных значений в выражение expr"
  ([expr] expr)
  ([expr vars]
   (cond
     (constant? expr) expr
     (variable? expr) (let [var-name (variable-name expr)]
                        (if (contains? vars var-name)
                          (constant (get vars var-name))
                          expr))
     :else (cons (first expr) (map #(substitution % vars) (args expr))))))

(defn express-through-basics
  "Функция для выражения всех логических операций через конъюнкцию, дизъюнкцию и отрицание"
  [expr]
  (let [first-arg (first (args expr)),
        second-arg (second (args expr))]
    (cond
      (OR? expr) (apply OR (map #(express-through-basics %) (args expr)))
      (AND? expr) (apply AND (map #(express-through-basics %) (args expr)))
      (NOT? expr) (NOT (express-through-basics first-arg))
      (IMPL? expr) (OR (NOT (express-through-basics first-arg)) (express-through-basics second-arg))
      :else expr)))

(defn de-morgan-rule
  "Функция для замены знаков отрицания на основании законов де Моргана
  ~(A | ... | B) = ~A & ... & ~B
  ~(A & ... & B) = ~A | ... | ~B
  ~(~A) = A
  ~0 = 1
  ~1 = 0"
  [expr]
  (let [not-expr (first (args expr))]
    (cond
      (OR? expr) (apply OR (map #(de-morgan-rule %) (args expr)))
      (AND? expr) (apply AND (map #(de-morgan-rule %) (args expr)))
      (NOT? expr) (cond
                    (constant? not-expr) (if (zero? (constant-value not-expr)) (constant 1) (constant 0))
                    (NOT? not-expr) (de-morgan-rule (first (args not-expr)))
                    (OR? not-expr) (apply AND (map #(de-morgan-rule (NOT %)) (args not-expr)))
                    (AND? not-expr) (apply OR (map #(de-morgan-rule (NOT %)) (args not-expr)))
                    :else expr)
      :else expr)))
  

(defn distributivity-rule
  "Функция для раскрытия скобок по дистрибутивности
  A & (B | C) = A & B | A & C
  A | (B & C) = (A | B) & (A | C)"
  [expr]
  (let [first-arg (first (args expr)),
        second-arg (second (args expr))]
    (cond
      (AND? expr) (cond
                    (OR? first-arg) (OR (distributivity-rule (AND second-arg (first (args first-arg))))
                                        (distributivity-rule (AND second-arg (second (args first-arg)))))
                    (OR? second-arg) (OR (distributivity-rule (AND first-arg (first (args second-arg))))
                                         (distributivity-rule (AND first-arg (second (args second-arg)))))
                    :else expr)
      (OR? expr) (cond
                   (AND? first-arg) (AND (distributivity-rule (OR second-arg (first (args first-arg))))
                                         (distributivity-rule (OR second-arg (second (args first-arg)))))
                   (AND? second-arg) (AND (distributivity-rule (OR first-arg (first (args second-arg))))
                                          (distributivity-rule (OR first-arg (second (args second-arg)))))
                   :else expr)
      :else expr)))

(defn simplify-same-preds
  "Функция для упрощения вложенных выражений с одной логической операцией
  A & (B & C) = A & B & C
  A | (B | C) = A | B | C"
  [expr]
  (if (or (OR? expr) (AND? expr))
    (cons (first expr) (map #(simplify-same-preds %) (merge-same-pred-args expr)))
    expr))

(defn idempotention-rule
  "Функция для применения идемпотентности конъюнкции и дизъюнкции
  A & A = A
  A | A = A"
  [expr]
  (cond
    (AND? expr) (apply AND (map #(idempotention-rule %) (distinct (args expr))))
    (OR? expr) (apply OR (map #(idempotention-rule %) (distinct (args expr))))
    (NOT? expr) (NOT (idempotention-rule (first (args expr))))
    :else expr))

(defn eliminate-negation-matching
  "Функция для замены выражений по правилам:
  A & ~A = 0
  A | ~A = 1"
  [expr]
  (cond
    (AND? expr) (cond
                  (some #(true? %) (map #(find-same-not-variable expr %) (args expr))) (constant 0)
                  :else (apply AND (map #(eliminate-negation-matching %) (args expr))))
    (OR? expr) (cond
                 (some #(true? %) (map #(find-same-not-variable expr %) (args expr))) (constant 1)
                 :else (apply OR (map #(eliminate-negation-matching %) (args expr))))
    :else expr))

(defn eliminate-constant-domination
  "Функция для замены выражений по правилам:
  A & 0 = 0
  A & 1 = A
  A | 0 = A
  A | 1 = 1"
  [expr]
  (cond
       (AND? expr) (cond
                     (find-same-const expr (constant 0)) (constant 0)
                     (find-same-const expr (constant 1)) (eliminate-constant-domination (apply AND (return-all-except-const expr (constant 1))))
                     :else (apply AND (map #(eliminate-constant-domination %) (args expr))))
       (OR? expr) (cond
                    (find-same-const expr (constant 1)) (constant 1)
                    (find-same-const expr (constant 0)) (eliminate-constant-domination (apply OR (return-all-except-const expr (constant 0))))
                    :else (apply OR (map #(eliminate-constant-domination %) (args expr))))
       :else expr))

(defn dnf
  "Функция для построяния ДНФ выражения expr"
  [expr]
  (->> expr
       (express-through-basics)
       (de-morgan-rule)
       (distributivity-rule)
       (simplify-same-preds)
       (idempotention-rule)
       (eliminate-negation-matching)
       (eliminate-constant-domination)))