Manning have today published Functional Programming in Scala by Rúnar Bjarnason and Paul Chiusano. The book is constructed around a carefully graded sequence of exercises where you find yourself attempting to build things of increasing complexity. It's aim is to teach functional programming concepts through the medium of Scala and this means that you must construct your programs from pure functions, free of side effects. If, like me, you come from an OO background, this causes a massive rethink - there are whole swathes of the language that you just don't use. For example, you can't reassign a variable; your functions mustn't throw exceptions; you will not develop class hierarchies. You will use case classes but their use is restricted to the creation of algebraic data types. I found that I had to go through the exercises very slowly and deliberately. The introductory exercises are relatively straightforward and fun to attempt and your confidence grows, but I found that the material quite soon becomes very challenging indeed. In fact, whilst studying the various revisions of this book, I was reminded yet again of Feynman - his algorithm:
Write down the problem.
Think real hard.
Write down the solution.
This, as opposed to an approach I've tended to used in OO:
Write down the problem.
do {
Think a little bit.
Type a little bit.
See what happens
} until problem solved.
Write down the solution.
The problem when lesser mortals attempt Feynman's algorithm is that it tends not to terminate. When it works, however, you often tend to end up with an elegant, terse solution, often incomprehensible to the casual reader. But the main thing is that you gain enormous understanding - you will get no benefit unless you attempt the exercises.The material is presented tersely, with just enough explanation of the concept and the scala syntax you need to express it. Some of the problems are very tricky and I would occasionally find myself pondering single questions for an hour or two, struggling to get the types to match. The satisfaction when you do tease out a solution is immense. The accompanying material on the web site includes pro-forma Scala exercise files for each chapter with placeholders for the answer, usually in the fom of stubs like this:
def compose[A,B,C](f: B => C, g: A => B): A => C =
???
If you get stuck, hints and solutions for each question are provided, as is a fully fleshed-out answer file for each chapter. Some later chapters use material developed in earlier ones and so, when attempting a new chapter, you need either to have completed the previous ones or to compile the supplied answers before you can proceed.There are four main sections. The first is an introduction to FP concepts and the authors have given a lot of thought to the progression of ideas. This allows you gradually to gain confidence in manipulating functions until finally you're able to develop a lazily-evaluated Stream data type and then a purely functional representation of State. If you just get this far, it's of tremendous benefit.
Then the style of the book changes tack to some extent in three chapters devoted to functional design. The idea is to illustrate some of the thought processes and alternative approaches that can be involved in groping your way towards the development of a combinator library that tackles a particular design space. Three completely different problems (parallelism, test frameworks and parsers) are used. This is illuminating but sometimes a little at odds with the progression of exercises because your approach and the authors' may legitimately diverge. This means you may occasionally have to look ahead to the answers to keep yourself on track. What is interesting here is that the three different areas evolve solutions with a deep structure in common and you develop something of an intuition of what it is that makes Monads inevitable.
The third section then discusses Monoids, Monads, Functors and Applicatives. This is familiar territory if you've read Learn You a Haskell but there is considerably more depth of coverage, and because you've spent so much time thinking about the diverse design problems in the previous section, you may well find that your understanding of these deep abstractions takes a more tangible form.
Section 4 deals with the question - if your program is completely pure, how do you deal with an effect such as IO? There are many aspects to this and the authors review the strengths and limitations of the IO Monad and discuss different alternatives to the problem of handling mutable state. The book ends with a fascinating chapter on Streaming IO. This was a brave thing to do - the discussion is exploratory in style and feels its way towards a thorough explanation of the design principles behind the scalaz-stream library. It seems as though the chapter might have been developed in parallel with the development of the library itself and you almost think that you are one of the team. Surprisingly, no mention is made of scalaz, however you will learn many of the design principles that underpin it. (This won't give you everything you need for the scalaz syntax, though. For this, I would recommend learning-scalaz.)
This is a book which has already taught me a great deal and given me a huge amount of pleasure. It is one that I will keep going back to until I finally feel that I am getting the hang of that mysterious activity which is called functional programming.
