Function templates for output of other self-referential data types

• An instance of the new data type can be any one of several other types. (For example, a list is either empty or a cons; a family-tree might be either the symbol 'unknown or a family-tree-node.) Use the several cases output template.
• An instance of the new data type contains several pieces, each of a previously-defined type. (For example, a posn contains two numbers; a family-tree-node might contain two symbols (name and eye-color), a number (birth-year), and two family-trees (mother and father).) Use the compound data type output template.
• You need to define two or more data types simultaneously, because each of them is built from the others in one of the above ways. Write a template for each, using the other or itself as appropriate.

  For example, in the above paragraphs we defined family-tree in terms of family-tree-node, and family-tree-node in terms of family-tree. You're likely to need a separate function template for each, and when you write actual functions based on the template, you're likely to need a separate function for each.

   (define (func-returning-family-tree ...)
     (cond [... 'unknown]
  	 [... (func-returning-family-tree-node ...)]))
  	  
   (define (func-returning-family-tree-node ...)
     (make-family-tree-node
        ... ; a symbol for the name
        ... ; a symbol for the eye-color
        ... ; a number for the birth-year
        ... (func-returning-family-tree-node ...) ; the mother
        ... (func-returning-family-tree-node ...) ; the father
     ))
   

  If some of these functions are to be used only as auxiliaries, and only one of the functions is "for public consumption", you can keep the auxiliary functions to yourself by defining them locally:

   (define (func-returning-family-tree ...)
     (local ((define (func-returning-family-tree-node ...)
                 (make-family-tree-node
                    ... ; a symbol for the name
                    ... ; a symbol for the eye-color
                    ... ; a number for the birth-year
                    ... (func-returning-family-tree-node ...) ; the mother
                    ... (func-returning-family-tree-node ...) ; the father
             ))
  	  )
         (cond [... 'unknown]
      	     [... (func-returning-family-tree-node ...)])
     ))
   

  This approach is particularly useful if the main function, the auxiliary function, or both, is recursive:

   (define (func-returning-n-ary-tree T)
     (local ((define (func-returning-children L)
  	     (cond [... empty]
  		   [... (cons (func-returning-n-ary-tree ...)
                                (func-returning-children ...))])
             ))
       (make-n-ary-tree
          ... ; the data
          (func-returning-n-ary-tree ...) ; the list of children
       )
     ))