Suppose we want to write a function which sums the squares of the odd leaves in a tree. Here's a first implementation:
;; For each leaf of the tree, pick the ones that are odd, ;; square them, and add the results. (define (sum-odd-squares tree) (if (leaf? tree) (if (odd? tree) (square tree) 0) (+ (sum-odd-squares (left-branch tree)) (sum-odd-squares (right-branch tree)))))
Here's what it looks like using streams:
(define (sum-odd-squares tree) (accumulate + 0 (map square (filter odd (leaves tree)))))Note that the code is now its own documentation. Only a graphical language could make it clearer. The computational primitives
leavesare general enough to construct many other functions. For example, multiplying the odd Fibonacci numbers Fib(k), where k ranges over the leaves of a tree:
(define (mul-odd-fibs tree) (accumulate * 1 (filter odd (map fib (leaves tree)))))
PLE used this example to demonstrate functional programming. Entire languages (e.g. APL, FP) have been built around this pattern.
The UNIX shell is good example of this approach. It points out another benefit: the computational units are independent enough to be implemented by different people or even in different languages. It is commonplace and natural to pipe a shell command into a C program into a Perl script into Tcl/Tk. This approach puts the value in the design, not the implementation.