   [clop A]
   (let [clop-A (clop A)]
     (loop [left     [A],                ;yet to consider
-           minimals []]                 ;minimals elements already found
+           minimals []]                 ;minimal elements already found
       (if (empty? left)
         (distinct minimals)
         (let [next (first left)]

     (all-closed-sets G clop #{}))
  ([G clop initial]
     (let [G (if (set? G)
	       (improve-basic-order G clop)
	       G)]
       (binding [subelts (memoize subelts)]
	 (take-while identity
		     (iterate (partial next-closed-set G clop)
			      (clop initial)))))))

(defn all-closed-sets-in-family
  "Computes all closed sets of a given closure operator on a given set

  "Implements oplus from the Next Closure Algorithm."
  [G clop A i]
  (clop (set (conj (filter #(contains? A %) (subelts G i))
                   i))))

(defn next-closed-set-in-family
  "Computes next closed set as with next-closed-set, which is in the
