Function templates for input 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 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 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-for-family-tree tree)
     (cond [(eqv? tree 'unknown) ...]
  	 [(family-tree-node? tree) ... (func-for-family-tree-node tree) ...]))
  	  
   (define (func-for-family-tree-node node)
     ... (family-tree-node-name node) ... ; a symbol
     ... (family-tree-node-eye-color node) ... ; a symbol
     ... (family-tree-node-birth-year node) ... ; a number
     ... (family-tree-node-mother node) ... ; a family-tree
     ... (family-tree-node-father node) ... ; a family-tree
     ... (func-for-family-tree (family-tree-node-mother node)) ... ; whatever type this returns
     ... (func-for-family-tree (family-tree-node-father node)) ... ; whatever type this returns
     ... )
   

  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-for-family-tree tree)
     (local ((define (func-for-family-tree-node node)
               ... (family-tree-node-name node) ... ; a symbol
               ... (family-tree-node-eye-color node) ... ; a symbol
               ... (family-tree-node-birth-year node) ... ; a number
               ... (family-tree-node-mother node) ... ; a family-tree
               ... (family-tree-node-father node) ... ; a family-tree
               ... (func-for-family-tree (family-tree-node-mother node)) ... ; whatever type this returns
               ... (func-for-family-tree (family-tree-node-father node)) ... ; whatever type this returns
               ... )
  	  )
         (cond [(eqv? tree 'unknown) ...]
      	 [(family-tree-node? tree) ... (func-for-family-tree-node tree) ...])
     ))
   

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

   (define (func-for-n-ary-tree T)
     (local ((define (func-for-children L)
  	     (cond [(empty? L) ...]
  		   [(cons? L) ...
  		    ... (first L) ...
  		    ... (func-for-n-ary-tree (first L)) ...
  		    ... (rest L) ...
  		    ... (func-for-children (rest L)) ...])))
       ... (n-ary-tree-data T) ...
       ... (n-ary-tree-children T) ...
       ... (func-for-children (n-ary-tree-children T)) ...
     ))