Try working through that example and then substitute the call to TRUE() with a call to FALSE(). Thus by using short circuit evaluation of boolean expressions we have found a way to eliminate conventional if/else statements from our programs. You may recall that in the recursion topic we observed that recursion could be used to replace the loop construct. Thus combining these to effects can remove all conventional control structures from our program, replacing them with pure expressions. This is a big step towards enabling pure FP style solutions.

Conclusions

At this point you may be wondering what exactly is the point of all of this? You would not be alone. Although FP appeals to many Computer Science academics (and often to mathemeticians) most practicing programmers seem to use FP techniques sparingly and in a kind of hybrid fashion mixing it with more traditional imperative styles as they feel appropriate.

When you have to apply operations to elements in a list such that map, reduce or filter seem the natural way to express the solution them by all means use them. Just occasionally you may even find that recursion is more appropriate than a conventional loop. Even more rarely will you find a use for short circuit evaluation rather than conventions if/else - particularly if required within an expression. As with any programming tool, don't get carried away with the philosophy, rather use whichever tool is most appropriate to the task in hand. At least you know that alternatives exist!

There is one final point to make about lambda. There is one area outside the scope of FP that lambda finds a real use and that's for defining event handlers in GUI programming. Event handlers are often very short functions, or maybe they simply call some larger function with a few hard wired argument values. In either case a lambda function can be used as the event handler which avoids the need to define lots of small individual functions and fill up the namespace with names that would only be used once. Remember that a lamda statement returns a function object. This function object is the one passed to the widget and is called at the time the event occurs. If you recall how we define a Button widget in Tkinter, then a lambda would appear like this:

def write(s): print s

b = Button(parent, text="Press Me",

command = lambda : write("I got pressed!"))

b.pack()

Of course in this case we could have done the same thing by just assigning a default parameter value to write() and assigning write to the command value of the Button. However even here using the lambda form gives us the advantage that the single write() function can now be used for multple buttons just by passing a different string from the lambda. Thus we can add a second button:

b2 = Button(parent, text="Or Me",

command = lambda : write("So did I!"))

b2.pack()

We can also employ lambda when using the bind technique, which sends an event object as an argument:

b3 = Button(parent, text="Press me as well") b3.bind(, lambda ev : write("Pressed"))

Well, that really is that for Functional Programming. There are lots of other resources if you want to look deeper into it, some are listed below.

98

Other resources

•There is an excellent article by David Mertz on the IBM website about FP in Python. It goes into more detail about control structures and provides more detailed examples of the concept.

•Other languages support FP even better than Python. Examples include:: Lisp, Scheme, Haskell, ML and some others. The Haskell web site in particular includes a wealth of information about FP.

•There is also a newsgroup, comp.lang.functional where you can catch up on the latest happenings and find a useful FAQ.

•There are several book references to be found on the above reference sites. One classic book, which is not entirely about FP but does cover the principles well is Structure & Interpretation of Computer Programs by Abelman Sussman and Sussman. This text focusses on Scheme an extended version of Lisp. My personal primary source has been The Haskell School of Expression which is, naturally enough, about Haskell.

If anyone else finds a good refernce drop me an email via the link below.

99