(define largest-in-lists
  (lambda (L) ; list of lists
    (trace-let list-loop ([big-list L]
		    [largest #f])
      (if (null? big-list)
	  largest
	  (trace-let item-loop ([inner-list (car big-list)]
			  [largest largest])
	    (if (null? inner-list)
		(list-loop (cdr big-list) largest)
		(item-loop (cdr inner-list)
			   (if (or (not largest)
				   (> (car inner-list) largest))
			       (car inner-list)
			       largest))))))))

(define largest-in-lists
  (letrec (
    [largest-of-two 
     (lambda (x y)
       (cond [(not x) y]
             [(not y) x]
             [else (max x y)]))]
    [largest-in-one-list 
     (lambda (L)
       (if (null? L) 
           #f
           (largest-of-two 
            (car L)   
            (largest-in-one-list (cdr L)))))])
    (lambda (L) ; list of lists
      (largest-in-one-list (map largest-in-one-list L)))))


;; A simpler solution that uses a procedure from Assignment 4.
'(define largest-in-lists
  (lambda (list-of-lists)
    (let ([maxed-filtered-list
           (map (lambda (L) (apply max L))
                (filter-out null? list-of-lists))])
      (and (pair? maxed-filtered-list)
           (apply max maxed-filtered-list)))))

;;; filter-out procedure from A4 is needed here; then you
;;; can unquote the above definition.


(cons (largest-in-lists '((1 3 5) () (4) (2 6 1) (4)))
      (largest-in-lists '(() () ())))