Function template

There are several different sorts of templates, depending on how complex the data are. In addition, you can develop templates based on either the input data types or the output data type.

Input templates

1. All parameters are of simple types
2. Several cases
3. Compound data type (e.g. a structure defined with "define-struct")
4. Several different types
5. Checking input errors
6. Lists of Unknown Length
7. Natural Numbers
8. Other self-referential data structures
9. Multiple inputs of complex types

Output templates

1. Output is of a simple type
2. Output is one of several possibilities
3. Output is of a compound data type (e.g. a structure defined with "define-struct")
4. Output is one of several different types
5. Lists of unknown length
6. Natural numbers
7. Other self-referential data structures

Combining Input and Output Templates

If both input and output types are simple,

neither template will give you a lot of information. The input-based template tells you to use your parameters, and the output-based template tells you what type the resulting expression should be. You're on your own from here.

If the input types are all fairly simple, and the output type isn't,

use an output-based template.

If the output type is fairly simple, and at least one input type isn't,

use an input-based template.

If both input and output types are complex,

you may need to combine input-based and output-based templates. Very often, the input-based template gives you clues to the questions in each clause of a cond, while the output-based template gives clues to the answers. In this case, you just need to match up the correct question with the correct answer, and your work is almost done.
For example, if your function takes in a list and produces another list, the input template tells you that if the input is a non-empty list, you'll probably be calling the same function on the rest of the list, while the output template tells you that you'll probably be cons-ing some single element onto the result of calling the same function on somethingorother.

Input template

(define (func my-list)
   (cond [(empty? my-list) ...]
         [(cons? my-list)
          ... (first my-list) ...
          ... (func (rest my-list)) ...]))

Output template

(define (func my-list)
   (cond [... empty]
         [... (cons some-element
                    (func some-list))]))

Likely merged template

(define (func my-list)
   (cond [(empty? my-list) empty]
         [(cons? my-list)
          (cons ( ... (first my-list) ...)
                (func (rest my-list)))]))