(define (require p) (cond ((not p) (amb))))

(define (member? x lst)
  (cond ((null? lst) #f)
        ((eq? x (car lst)) lst)
	(else (member? x (cdr lst)))))

LOGIC PUZZLE EXAMPLE

(define (distinct? lst)
  (cond ((null? lst) #t)
        ((null? (cdr lst)) #t)
	((member? (car lst) (cdr lst)) #f)
	(else (distinct? (cdr lst)))))

(define (bank-jobs)
((lambda (cashier manager teller)
  (require (distinct? (cons cashier (cons manager (cons teller ())))))
  (require (not (eq? teller 'smith)))
  (require (not (eq? manager 'smith)))
  (require (not (eq? teller 'brown)))
  (cons (cons 'cashier cashier)
        (cons (cons 'manager manager)
	      (cons (cons 'teller teller) ()))))
 (amb 'smith 'jones 'brown)
 (amb 'smith 'jones 'brown)
 (amb 'smith 'jones 'brown)))

NATURAL LANGUAGE PARSING EXAMPLE

(define *unparsed* ())

(define nouns '(n cats mice houses time flies arrows))

(define adjectives '(adj big time green))

(define verbs '(v time flies like eat))

(define prepositions '(prep on in like with))

(define (parse input)
  (set! *unparsed* input)
  ((lambda (sent)
     (require (null? *unparsed*))
     sent)
   (parse-sentence)))

(define (parse-sentence)
  (amb (cons 'S (cons (parse-verb-phrase) ()))
       (cons 'S (cons (parse-noun-phrase)
                      (cons (parse-verb-phrase) ())))))

(define (parse-noun-phrase)
  (amb (cons 'np (cons (parse-word nouns)()))
       (cons 'np (cons (parse-word adjectives) (cons (parse-noun-phrase) ())))))

(define (parse-verb-phrase)
  (define (maybe-direct-object verb-phrase)
    (amb verb-phrase
         (cons 'verb-phrase (cons verb-phrase (cons (parse-noun-phrase) ())))))
  (define (maybe-prep-phrase verb-phrase)
    (amb verb-phrase
         (maybe-prep-phrase (cons 'verb-phrase
	                          (cons verb-phrase
				        (cons (parse-prep-phrase) ()))))))
  (maybe-prep-phrase (maybe-direct-object (parse-word verbs))))

(define (parse-prep-phrase)
  (cons 'pp (cons (parse-word prepositions) (cons (parse-noun-phrase) ()))))

(define (parse-word lst)
  (require (not (null? *unparsed*)))
  (require (member? (car *unparsed*) (cdr lst)))
  ((lambda (word)
    (set! *unparsed* (cdr *unparsed*))
    (cons (car lst) (cons word ())))
   (car *unparsed*)))