(load "chez-init.ss")

(define (rl) (load "11.ss"))

(define member?
  (lambda (e ls)
    (cond [(null? ls) #f]
	  [(eq? (car ls) e) #t]
	  [else (member? e (cdr ls))])))

(define member?-cps
  (lambda (e ls k)
    (cond [(null? ls) (apply-cont k #f)]
	  [(eq? (car ls) e) (apply-cont k #t)]
	  [else (member?-cps e (cdr ls) k)])))

(define-datatype continuation continuation?
  (halt-cont)
  (set?-cps-cont
   (ls list?)
   (k continuation?))
  (cons-cont
   (v scheme-value?)
   (k continuation?))
  (andmap-cont
   (proc scheme-value?)
   (ls list?)
   (k continuation?))
  (matrix?-cont
   (m (list-of (list-of number?)))
   (k continuation?))
  (intersection-cont
   (ls1 list?)
   (ls2 list?)
   (k continuation?))
  (length-cont
   (l (list-of number?))
   (k continuation?))
  (eq-cont
   (v scheme-value?)
   (k continuation?))
  (some-continuation
   (m (list-of (list-of number?)))
   (k continuation?)))

(define scheme-value?
  (lambda (x) #t))

(define apply-cont
  (lambda (cont val)
    (cases continuation cont
	   [halt-cont () val]
	   [cons-cont (v k)
		      (apply-cont k (cons v val))]
	   [set?-cps-cont (ls k)
			  (if val
			      (apply-cont k #f)
			      (set?-cps ls k))]
	   [intersection-cont (ls1 ls2 k)
			      (if val
				  (intersection-cps (cdr ls1) ls2 (cons-cont (car ls1) k))
				  (intersection-cps (cdr ls1) ls2 k))]
	   [andmap-cont (proc ls k)	   
			(if val
			    (andmap-cps proc ls k)
			    (apply-cont k #f))]
	   [matrix?-cont (m k)
			 (if val
			     (andmap-cps list?-cps
					 m
					 (some-continuation m k))
			     (apply-cont k #f))]
	   [length-cont (l k)
			(length-cps l (eq-cont val k))]
	   [eq-cont (v k)
		    (apply-cont k (= v val))]
	   [some-continuation (m k)
			      (if val
				  (andmap-cps (lambda (L cont)
						(length-cps L (length-cont (car m) k)))
					      (cdr m)
					      k)
				  (apply-cont k #f))])))




(define set?
  (lambda (ls)
    (cond
     [(null? ls) #t]
     [(member? (car ls) (cdr ls)) #f]
     [else (set? (cdr ls))])))


(define set?-cps
  (lambda (ls k)
    (if (null? ls)
	(apply-cont k #t)
	(member?-cps (car ls) (cdr ls) (set?-cps-cont (cdr ls) k)))))

(define intersection
  (lambda (los1 los2)
    (cond
     [(null? los1) '()]
     [(member? (car los1) los2)
      (cons (car los1)
	    (intersection (cdr los1) los2))]
     [else (intersection (cdr los1) los2)])))


(define intersection-cps
  (lambda (ls1 ls2 k)
    (if (null? ls1)
	(apply-cont k '())
	(member?-cps (car ls1) ls2 (intersection-cont ls1 ls2 k)))))


(define make-cps
  (lambda (p)
    (lambda (x k)
      (apply-cont k (p x)))))


(define andmap-cps
  (lambda (p-cps ls k)
    (if (null? ls)
	(apply-cont k #t)
	(p-cps (car ls) (andmap-cont p-cps (cdr ls) k)))))


(define matrix?
  (lambda (m)
    (and (list? m)
	 (not (null? m))
	 (not (null? (car m)))
	 (andmap list? m)
	 (andmap (lambda (L) (= (length L) (length (car m))))
		 (cdr m)))))

(define matrix?-V2
  (lambda (m)
    (if (and (list? m)
	     (not (null? m))
	     (not (null? (car m))))
	(if (andmap list? m)
	    (andmap (lambda (L) (= (length L) (length (car m))))
		    (cdr m))
	    #f)
	#f)))


(define matrix?-cps
  (lambda (m k)
    (if (and (not (null? m))
	     (not (null? (car m))))
	(list?-cps m (matrix?-cont m k))
	(apply-cont k #f))))

(define length-cps
  (make-cps length))


(define list?-cps
  (make-cps list?))