;;; support code for problem 19

;;; Some predicates so can abstract over formulas
;;; But I leave the fact that formulas are lists visible...
(val variable? symbol?)
(define is-neg? (formula) 
  (if (pair? formula) 
      (if (= (car formula) 'not) #t #f)
      #f))
(define is-con? (formula)
    (if (pair? formula) 
      (if (= (car formula) 'and) #t #f)
      #f))
(define is-dis? (formula)
    (if (pair? formula) 
      (if (= (car formula) 'or) #t #f)
      #f))


;;; we use one of the book's implementations of sets for all-solutions

(define sub-alist? (al1 al2)
  (not (exists?
	(lambda (pair)
	  (not (equal? (cadr pair) (find (car pair) al2))))
	al1)))
(define =alist? (al1 al2)
  (if (sub-alist? al1 al2) (sub-alist? al2 al1) #f))

(val mk-set-ops 
     (lambda (eqfun)
       (list2
	(lambda (x s) (exists? ((curry eqfun) x) s)) ; member?
	(lambda (x s) ; add-element
	  (if (exists? ((curry eqfun) x) s) s (cons x s))))))
(val list-of-al-ops (mk-set-ops =alist?))
(val al-member?     (car list-of-al-ops))
(val al-add-element (cadr list-of-al-ops))
(val emptyset '())

;;; now, two test harnesses (ways of running your tests on your code):

;;; one solution (as per text)
(define one-solution (formula)
  (make-formula formula #t '() 
                (lambda () 'no-solution)
                (lambda (cur resume) cur)))

;;; all solutions in order found (as per text)
(define all-solutions (formula)
  (make-formula formula #t '()
                (lambda () '())
                (lambda (cur resume) 
                  (al-add-element cur (resume)))))