If we replace the Lam nodes with Case-Lam nodes of the form:

  ($ Case-Lam name ((params body) ...))

then we can no longer achieve the same logic with a single

match form, but need to factor out a utility function in order to

perform the recursion you suggest:

  (define (foo x)

    (define (match-body y)

      (match y

        (($ Cnd test pass fail)

         (foo-cnd test pass fail))

        (body

         (foo body))))

    (match x

      (($ Cnd test pass fail)

       (make-cnd (foo test) (foo pass) (foo fail)))

      (($ Seq ls)

       (make-seq (map foo ls)))

      (($ Case-Lam name ((params body) ...))

       (make-case-lam name (map list params (map match-body body))))

      (($ App ls ...)

       (make-app (map foo ls)))

      (else

       x)))

I would not want to write such compiler transformations on an

AST using case-lambda as a core form.