About the Book
Update Dec 2014:
A lot of people have asked me when the book will be ready. I apologize for the delay! I'm actively working on it now and hope to have some news next month. Stay tuned, and thanks for your patience!
The goals of this book
This book will introduce you to the core concepts of functional programming and show you ways that these techniques can help in day-to-day development of mainstream commercial business software.
And on the way, I hope to open your mind to the joys of functional programming as well. It's corny but true; there really is fun in being functional!
Learn to think functionally. "Thinking functionally" is critical to getting the most out of a functional programming language like F#, so I will spend a lot of time on getting the basics down, and I will avoid too much discussion of the hybrid and OO features.
Useful examples. The book will mostly focus on mainstream business problems, such as domain driven design, data processing, business rules, and so on. In the examples I will try to use business concepts such as Customer, Product, and Order, rather than overly academic ones.
The examples are in F#, but the ideas can easily be transferred to similar languages such as OCaml and Haskell.
Don't be scared. A functional programming language like F# can look very intimidating if you look at complex code without any background. In the beginning I will keep it very simple, and I have tried to anticipate the questions that a newcomer to functional programming concepts will have. If you work through the examples slowly (and in the right order) you should have no problem understanding everything.
Have fun! Many people claim that learning to think functionally will "blow your mind". Well, it's true! Learning a completely new paradigm is exciting and stimulating. You may fall in love with programming again.
Overview of contentsPart I: Introducing Functional Programming
In this first part we'll demystify functional programming and take a quick tour.
- Introduction: Why is functional programming so hard? In which we look at some reasons why functional programming (FP) is thought to be hard while object-oriented programming is considered easy. As you'll see, FP is not really as hard as it seems.
- Why use functional programming? Before diving into specific concepts, we'll take a brief tour of the kinds of things you can do with FP. We'll see first that FP code is concise. Compared to say, C# or Java, you generally need many fewer lines of code to implement the same feature. We'll see also that FP code is convenient. Most boilerplate code (such equality and comparison) can be eliminated or dramatically reduced. Finally, we'll look at how FP code can ensure correctness. In many cases, business rules can actually be encoded into the type system. This ensures that you cannot even compile code that does not conform to the requirements.
In this part we'll look at the fundamental concepts behind functional programming.
- Thinking functionally. This chapter will introduce the concepts behind functions, and demystify terms like "currying" and "partial application".
- Understanding types. FP is not just about functions; the powerful type system is another key ingredient. And just as with functions, understanding the type system is critical to being fluent and comfortable in the language. The chapter will explain the concepts behind "algebraic types", and show why they are so useful for business applications.
- Expressions and pattern matching. In a FP language like F#, everything is an expression. Not just values and functions, but also control flows. This takes some getting used to, but has many benefits, as we will see. This chapter will also explain the key concept of "pattern-matching".
- Understanding lists and other collections. Lists and other collections are the workhorse of any language. But we'll see that the lists in F# are not quite the same as the lists you might be used to in an imperative language.
Next, we'll introduce some common approaches functional patterns and techniques.
- Designing with types. In this chapter we will look at basic types such as Option and Choice/Either. We'll also show how to use types to represent business rules and ensure correctness.
- Functional Patterns. We'll meet some idiomatic FP patterns and techniques, including partial application, composition, continuation passing, monoids, and applicatives.
Finally, we'll build on the previous concepts in order to create working programs.
- Organizing code, structuring an application. This chapter will look at various techniques for organizing code when you don't have classes.
- Implementing a complete use-case. Here, we'll look at building a complete use case, including validation, persistence, error messages, etc.
In this section, we'll provide some tips for porting imperative and object-oriented code to functional code. Topics covered will include: dealing with immutability, implementing inheritance, method overloading, and so on.
We'll also compare object-oriented patterns to functional patterns and find that most of the OO patterns such as "strategy" and "decorator" are trivial in FP.
Many of the topics in this book, and more, are covered on my website at fsharpforfunandprofit.com.
If you have any comments on the planned contents of the book, please leave them in the comments section. Also, please go to the comments to respond to some polls on variants of this book, such as: would you like editions with other language examples (Haskell, Scala?), and is there any demand for a hard-copy (dead tree) edition?
About the Author
Scott is a .NET developer, architect and author. He has over 20 years experience in a wide variety of areas from high-level UX/UI to low-level database implementations. He has written serious code in many languages, his favorites being Smalltalk. Python, and more recently, F#, which he blogs about at fsharpforfunandprofit.com.