;;; basic recursion
;;; top level list
;;; 10 pts

(define merge
  (lambda (ls1 ls2)
    (cond [(null? ls1) ls2]
	  [(null? ls2) ls1]
	  [(< (car ls1) (car ls2)) (cons (car ls1) (merge (cdr ls1) ls2))]
	  [else (cons (car ls2) (merge ls1 (cdr ls2)))])))



;;; 1st class procs: Passing a proc
;;; deep recursion
;;; give it a different name
;;; 10 pts

(define get-elements
  (lambda (proc ls)
    (cond [(null? ls) '()]
	  [(pair? (car ls)) (cons (get-elements proc (car ls))
				  (get-elements proc (cdr ls)))]
	  [(proc (car ls)) (cons (car ls) (get-elements proc (cdr ls)))]
	  [else (get-elements proc (cdr ls))])))


;;; accumulators along the lines of reverse or so.
;;; 10 pts

(define union
  (lambda (ls1 ls2)
    (if (member? (car ls1))
	(union (cdr ls1) ls2)
	(cons (car ls1) (union (cdr ls1) ls2)))))

(define intersection
  (lambda (ls1 ls2)
    (if (member? (car ls1))
	(cons (car ls1) (intersection (cdr ls1) ls2))
	(intersection (cdr ls1) ls2))))



;;; 1st class procs: returning (and using a proc)
;;; list-recur
;;; 10 pts
(define substitute-item
  (lambda (item new-item)
    (list-recur '() (lambda (x y) (if (eq? item x)
				      (cons new-item y)
				      (cons x y))))))

;;; take non-working code and ensure that the test script conks
;;; out on second run 

(define goo
  (lambda (item)
    (list-recur ()
		(let ([flag #f])
		  (lambda (x y)
		    (if (and (not flag)
			     (eq? x item))
			(begin (set! flag #t)
			       y)
			(cons x y)))))))

;;; good (hard for A+ students)
;;; 15 pts
(define substitute-last
  (lambda (item new-item ls)
    (let ([flag #f])
      ((list-recur '() (lambda (x y) (if (and (eq? item x)
					      (not flag))
					 (begin (set! flag #t)
						(cons new-item y))
					 (cons x y)))) ls))))
(define list-recur
  (lambda (init f)
    (letrec ([helper (lambda (ls)
		       (if (null? ls)
			   init
			   (f (car ls) (helper (cdr ls)))))])
      helper)))




(define remove-last-item
  (lambda (item ls)
    (let ([flag #f])
      ((list-recur '() (lambda (x y) (if (and (eq? item x)
					      (not flag))
					 (begin (set! flag #t)
						y)
					 (cons x y)))) ls))))