- Structural Recursion - use recursion to traverse inductively defined data structures (e.g. list ortree)
- Interface Procedure - use a helper method to adapt a function call if you need an extra argument
- Mutual Recursion - use multiple recursive functions to traverse inductively defined data structures where elements in the data structure are also inductively defined
- Accumulator Variable - use an additional parameter to carry calculations through recursion
- Syntax Procedure - extract methods that mean something rather than accessing raw members of data structures (e.g. for trees written as lists use
(lhs foo)instead of
- Local Procedure - use anonymous methods to hide details from the outside world
- Program Derivation - inline code if you want more performance
The relationship between patterns and refactoring has already been written about ("Refactoring to Patterns"). In this case the relationships are quite clear.
- Program Derivation => inline method.
- Interface Procedure => adapter pattern
- Local Procedure => encapsulation
- Syntax Procedure => extract method
- Structural Recursion/ Mutual Recursion => Visitor Pattern (might be a bit tenuous!)
Not all of the patterns are directly applicable to all languages. For example, Program Derivation is unwarranted for Lisp type languages because macros provide all those capabilities. I guess that's another one for the design patterns are a weakness of the language meme.