1. Getting Started
This introductory chapter will address some of the major questions you may have about F# and functional programming.
What Is Functional Programming?
Functional programming (FP) is the oldest of the three major programming paradigms. The first FP language, IPL, was invented in 1955, about a year before FORTRAN . The second, Lisp, was invented in 1958, a year before COBOL . Both Fortran and Cobol are imperative (or procedural) languages, and their immediate success in scientific and business computing made imperative programming the dominant paradigm for more than 30 years. The rise of the object-oriented (OO) paradigm in the 1970s and the gradual maturing of OO languages ever since have made OO programming the most popular paradigm today.
Since the 1950s there has been vigorous and continual development of powerful FP languagesSML, Objective Caml (OCaml), APL, and Clean, among othersand FP-like languagesErlang, Lisp, and Haskell being the most successful for real-world applications . However, FP remained a primarily academic pursuit until recently. The early commercial success of imperative languages made it the dominant paradigm for decades. Object-oriented languages gained broad acceptance only when enterprises recognized the need for more sophisticated computing solutions. Today, the promise of FP is finally being realized to solve even more complex problemsas well as the simpler ones.
Pure functional programming views all programs as collections of functions that accept arguments and return values. Unlike imperative and object-oriented programming, it allows no side effects and uses recursion instead of loops for iteration. The functions in a functional program are very much like mathematical functions because they do not change the state of the program. In the simplest terms, once a value is assigned to an identifier, it never changes; functions do not alter parameter values; and the results that functions return are completely new values. In typical underlying implementations, once a value is assigned to an area in memory, it does not change. To create results, functions copy values and then change the copies, leaving the original values free to be used by other functions and eventually to be thrown away when no longer needed. (This is where the idea of garbage collection originated.)
The mathematical basis for pure functional programming is elegant, and FP therefore provides beautiful, succinct solutions for many computing problems. That said, the stateless and recursive nature of FP can make it seem harder to apply for many common programming tasks. However, one of F#s great strengths is that you can use multiple paradigms and mix them to solve problems in the way you find most convenient.
Why Is Functional Programming Important?
When people think of functional programming, they often view its statelessness as a fatal flaw without considering its advantages. One could argue that since an imperative program is often 90 percent assignment and since a functional program has no assignment, a functional program could be 90 percent shorter. However, not many people are convinced by such arguments or attracted to the ascetic world of stateless recursive programming, as John Hughes pointed out in his classic paper Why Functional Programming Matters.
The functional programmer sounds rather like a medieval monk, denying himself the pleasures of life in the hope that it will make him virtuous.
John Hughes, Chalmers University of Technology
( www.cse.chalmers.se/~rjmh/Papers/whyfp.html )
To see the advantages of functional programming, you must look at what FP permits rather than what it prohibits. For example, functional programming allows you to treat functions themselves as values and pass them to other functions. This might not seem all that important at first glance, but its implications are extraordinary. Eliminating the distinction between data and functions means that many problems can be more naturally solved. Functional programs can be shorter and more modular than corresponding imperative and object-oriented programs.
In addition to treating functions as values, functional languages offer other features that borrow from mathematics and are not commonly found in imperative languages. For example, functional programming languages often offer curried functions, where arguments can be passed to a function one at a time and, if all arguments are not given, the result is a residual function waiting for the rest of its parameters. Its also common for functional languages to offer type systems with much better power-to-weight ratios, providing more performance and correctness for less effort.
Further, a function might return multiple values, and the calling function is free to consume them as it likes. Well discuss these ideas, along with many more, in detail and with plenty of examples in Chapter .
What Is F# ?
Functional programming is the best approach to solving many thorny computing problems, but pure FP isnt suitable for general-purpose programming. So FP languages have gradually embraced aspects of the imperative and OO paradigms, remaining true to the FP model but incorporating features needed to easily write any kind of program. F# is a natural successor on this path. It is also much more than just an FP language.
Some of the most popular functional languages, including OCaml, Haskell, Lisp, and Scheme, have traditionally been implemented using custom runtimes, which leads to problems such as lack of interoperability. F# is a general-purpose programming language for .NET (a general-purpose runtime) and for .NETs open source counterparts. It smoothly integrates all three major programming paradigms. With F#, you can choose whichever approach works best to solve problems in the most effective way. You can do pure FP if youre a purist, but you can easily combine functional, imperative, and object-oriented styles in the same program and exploit the strengths of each. Like other typed functional languages, F# is strongly typed but also uses inferred typing, so programmers dont need to spend time explicitly specifying types unless an ambiguity exists. Further, F# seamlessly integrates with the .NET Framework Base Class Library (BCL). Using the BCL in F# is as simple as using it in C# or Visual Basic (and maybe even simpler).
F# was modelled on OCaml, a successful object-oriented FP language, and then tweaked and extended to mesh well technically and philosophically with .NET. It fully embraces .NET and enables users to do everything that .NET allows. The F# compiler can compile for all implementations of the Common Language Infrastructure (CLI) and it supports .NET generics without changing any code. The F# compiler not only produces executables for any CLI but can also run on any environment that has a CLI, which means F# is not limited to Windows but can run on Linux, Apple Mac OS X, Apple iOS, FreeBSD, and Android. (Chapter covers some routes to using F# on these diverse platforms.)
The F# compiler is distributed with Visual Studio 2015: you simply need to select the F# option during installation. It is also available in Xamarin Studio ( http://xamarin.com/studio ). Although there are commercial versions of Visual Studio and Xamarin Studio, in both cases the free edition fully supports F#. Alternatively, Ionide ( http://ionide.io ) provides an F# IDE for the Atom and Visual Studio Code editors. You can also download and integrate F# with other editors and IDEs such as Emacs and Vim. F# supports IntelliSense expression completion and automatic expression checking. It also gives tool tips to show what types have been inferred for expressions. Programmers often comment that this really helps bring the language to life.
