;;;
;;; every-other
;;;
;;;  


(define (every-other-every proc sent) ;; buggy
  (cond ((empty? sent) '())
	((odd? (count sent)) 
	 (se (proc (first sent)) (every-other-every proc (bf sent))) )
	(else (se (first sent) (every-other-every proc (bf sent))))) )

(define (every-other-every proc sent) ;; one way to fix
  (define (eoe-helper proc sent flag)
    (cond ((empty? sent) '())
	  (flag (se (proc (first sent)) (eoe-helper proc (bf sent) #f)))
	  (else (se (first sent) (eoe-helper proc (bf sent) #t)))))
  (eoe-helper proc sent #t))


(define (every-other-every proc sent) ;; another way
  (cond ((empty? sent) '())
	((empty? (bf sent)) (proc (first sent)))
	(else (se (proc (first sent)) (first (bf sent)) 
		  (every-other-every proc (bf (bf sent)))))))


(define (remove-every-other sent) 
  (if (or (empty? sent) (empty? (bf sent))) 
      sent
      (every bf 
	     (accumulate (lambda (x y) 
			   (cond ((word? y) (se  (word '_ y)) )
				 ((equal? (first (first y)) '*) 
				  (se (word '_ (bf (first y))) (bf y)) )
				 (else (se (word '* x) y))))
			 sent))))


;;;
;;; Error checking 
;;;   (the procedures below are buggy)

(define (all-true? pred sent)
  (every pred sent))

(define (square-all-odd sent)
  (every (if (odd? x)
	     (* x x)
	     x)
	 sent))

(define (merge-ajacent sent)
  (every (lambda (x y) (word x y)) sent))

(define (square-all-odd sent)
  (keep (lambda (x) (if (odd? x) 
			(* x x)
			x))
	sent))

(define (all-true? pred sent) 
  (accumulate (lambda (x y)
		(and (pred x) (pred y)))
	      sent))

(define (all-true? pred sent) ;; non-buggy version
  (accumulate (lambda (x y)
		(if (word? y)
		    (and (pred x) (pred y))
		    (and (pred x) y)))
	      sent))

(define (product-of-all sent)
  (accumulate (lambda (x) (* x y)) sent))



;;;
;;; Lambda, Let, Define
;;;

(define  mystery  (lambda (x) (* x x)) )

(define (mystery) (lambda (x) (* x x)) )

(define (mystery) (lambda () (lambda (x) (* x x)) (lambda (x y) (* x y))))

(define (square-all sent)
  (every (lambda (x) (* x x)) sent))

(define (square-all sent)
  (define (square x) (* x x))
  (every square sent))

(define (square-all sent)
  (let ((square (lambda (x) (* x x))))
    (every square sent)))

(define (square-all sent)
  ((lambda (square)
    (every square sent))
   (lambda (x) (* x x ))))

(define (echo wd num)
  (if (= num 0)
      (se wd)
      (se (echo wd (- num 1))
	  (echo wd (- num 1)))))

(define (echo wd num)
  (if (= num 0) 
      (se wd)
      (let ((echo-sent (echo wd (- num 1))))
	(se echo-sent 
	    echo-sent))))

;;;
;;; Defining Higher Order Procedures
;;;

(define (paired-every proc sent)
  (cond ((odd? (count sent)) #f)
	((empty? sent) '())
	(else (se (proc (first sent) (first (bf sent))) 
		  (paired-every proc (bf (bf sent)))))) )

(define (double-every proc sent1 sent2)
  (cond ((empty? sent1) sent2)
	((empty? sent2) sent1)
	(else (se (proc (first sent1) (first sent2)) 
		  (double-every proc (bf sent1) (bf sent2))))))