Introducing Some Functional Features
Familiar territory
One of the ideas that emerge from the previous list of topics is that most functional
programming is already present in Python. Indeed, most functional programming is
already a very typical and common part of Object-Oriented Programming.
As a very specific example, a fluent Application Program Interface (API) is a very
clear example of functional programming. If we take time to create a class with
return self() in each method function, we can use it as follows:
some_object.foo().bar().yet_more()
We can just as easily write several closely-related functions that work as follows:
yet_more(bar(foo(some_object)))
We've switched the syntax from traditional object-oriented suffix notation to a more
functional prefix notation. Python uses both notations freely, often using a prefix
version of a special method name. For example, the len() function is generally
implemented by the class.len() special method.
Of course, the implementation of the class shown above might involve a highly
stateful object. Even then, a small change in viewpoint might reveal a functional
approach that can lead to more succinct or more expressive programming.
The point is not that imperative programming is broken in some way, or that
functional programming offers such a vastly superior technology. The point is
that functional programming leads to a change in viewpoint that can—in many
cases—be very helpful.
Saving some advanced concepts
We will set some more advanced concepts aside for consideration in later chapters.
These concepts are part of the implementation of a purely functional language.
Since Python isn't purely functional, our hybrid approach won't require deep
consideration of these topics.
We will identify these up-front for the benefit of folks who already know a functional
language such as Haskell and are learning Python. The underlying concerns are
present in all programming languages but we'll tackle them differently in Python.
In many cases, we can and will drop into imperative programming rather than use
a strictly functional approach.