Here's a rough draft. Have at it, especially if you can think of ways to make it shorter and clearer. I chose python as an example language because its syntax is familiar to imperative programmers and because it's dynamic like scheme:
If you have programming experience, it's possible you've only used imperative style until now.
What is imperative style?
You're probably used to thinking about your computer as a processor attached to some memory. Variables are like buckets that can hold values, and our program can change the values these buckets hold.
An imperative style program is just (roughly) a sequence of changes to the contents of the program variables. Computation proceeds by explicitly changing the values in the variable buckets. If you've only ever programmed in imperative style, this is as natural as breathing.
For example, let's make a program that adds 4 to a number and then multiplies the result by 2. An imperative way of expressing this (in python) would be:
def example1(n): x = n + 4 x = x * 2 return x
We create a variable, x, and then modify its contents in a sequence of steps until it holds the result we're looking for.
What is functional style?
Functional style means viewing computation as evaluation of functions. There are NO variables in functional code in the sense we described above: that is, there are no variables that represent memory locations whose contents can change. There are NAMES bound to VALUES (you can bind x to 4, sure) but these don't stand for mutable memory locations. They're just synonyms for the value they're bound to.
So there's no hidden state you can modify in purely functional code; there's nothing like
x = x + 4
because x doesn't stand for a memory location whose contents can change. Expressions (the right hand side of the statement x = x + 4) can be evaluated, but their result can only be returned from a function or bound to a name: it cannot be assigned to any variable.
State can only be passed around the program explicitly as parameters in a function call, or returned as the result of function evaluation. This is the take-home message.
The above example would look like this:
def example2(n): return (n + 4) * 2
A name, n, is bound to a value (whatever the function example2 is called with). Functions are called (in this case, the built-in functions + and *). A value is returned: the result of evaluating (n + 4) * 2.
But NO assignment is taking place: no variables are being modified.
A less trivial, canonical example: the factorial function
n! = n * (n - 1) * (n - 2) * ... * 1
We might write this imperatively as a loop, which counts from 2 to n and uses a variable i for iteration and a variable accum to multiply all the i's together:
def fact1(n): accum = 1 for i in range(2, n+ 1): accum = accum * i return accum
Assignment is taking place both for i (it changes every iteration) and accum.
How could we write this in a functional style? You're probably familiar with the concept of recursion:
def fact2(n): if n < 2: return 1 else: return n * fact2(n - 1)
Notice no assignment is taking place: within fact2, n is bound to whatever the fact2 is called with, and functions are called and values returned, but no variables are changed.
Functional programs are like math equations. The "x" in a quadratic equation doesn't stand for a memory location that holds a particular number at a particular time, which changes during program execution. Neither does the x in a functional program.
Bear this in mind when you're starting out, and take a deep breath whenever you feel the urge to assign values to variables. Scheme does permit assignment (it's a multiparadigm language, not purely functional), but we'll do without it first.
If you want to pass state around, you'll have to return it as the result of a function: no assigning to a variable is permitted. You'll get the picture when you start working on the examples, but at least you're forewarned: do NOT try to write scheme as you would write C++.
