One of my favorite sections in
SICP so far
has been section
1.3 Formulating Abstractions with Higher-Order
Procedures.
Higher-Order
Procedures are procedures that deal with other procedures.
They can take a procedure as an argument
and/or return a procedure as a result.
Though it is somewhat academic, I really like the example
that Abelson and Sussman use in section
1.3.1 to explain the “procedures as arguments” scenario. To illustrate this concept they implement summation 
using Scheme. They implement a higher-order
procedure called “sum” that takes two procedures and a range
of numbers as arguments. One procedure is used for
computing the value that is added to the sum and the other is used to determine
the next value to compute. The Scheme
code can be seen here.
It’s not as useful as map and
reduce,
but those are not discussed until Chapter 2.
As some of you may know C# 3.0 adds a whole slew
of functional/dynamic features. Whether
this is an effort to keep up with the cool
kids or merely a necessity for making LINQ work is not important to me. What I’m curious to know is if the features
make it easier to implement the concepts in SICP using C# 3.0.
Implementing “Sum” in
C# 3.0
Following along with the example from SICP - let’s say that
you have defined the following methods.
I decided to break with the book here and use iteration instead of recursion to make the code a little more digestible.
Common to each method is the idea of iterating over a range of
numbers and adding the result of each computation to the total. If we create a higher-order procedure called “Sum”
to abstract out this behavior we can then redefine each method.
The “=>” and “Func” constructs come from the new
Lambda expressions feature in C#.
Lambda expressions are a great new aspect of
the language and they make implementing higher-order procedures a lot easier. In this case the "term" and "next" arguments can be passed as Lambda expressions.
I had to cheat and do some casting shenanigans because the
division operation in "PiSum()" brings floating point numbers into the mix, but I
feel like this code does capture the essence of the original Scheme
implementation. Implementing "Sum" as a generic method might be a way to make the code more elegant.
If subverting the type system does not appeal to you, the
following JavaScript implementation might be of interest.
JavaScript is more similar to Scheme (dynamic typing/first class functions) so it makes
sense that the translation is smoother.
It turns out that there are other people interested in
implementing SICP in different languages.
Chris
Rathman has translated parts of SICP into 19 other languages. One disturbing thing to note about Chris’s C#
translation is that it doesn’t go beyond chapter 1. Does that mean that it is not possible to
implement the code from the rest of the book in C#?