# Functional programming

In computer science, functional programming is a programming paradigm that treats computation as the evaluation of mathematical functions and avoids state and mutable data. It emphasizes the application of functions, in contrast to the imperative programming style, which emphasizes changes in state.[1] Functional programming has its roots in the lambda calculus, a formal system developed in the 1930s to investigate function definition, function application, and recursion. Many functional programming languages can be viewed as embellishments to the lambda calculus.[1]

In practice, the difference between a mathematical function and the notion of a "function" used in imperative programming is that imperative functions can have side effects, changing the value of already calculated computations. Because of this they lack referential transparency, i.e. the same language expression can result in different values at different times depending on the state of the executing program. Conversely, in functional code, the output value of a function depends only on the arguments that are input to the function, so calling a function f twice with the same value for an argument x will produce the same result f(x) both times. Eliminating side-effects can make it much easier to understand and predict the behavior of a program, which is one of the key motivations for the development of functional programming.[1]

Functional programming languages, especially purely functional ones, have largely been emphasized in academia rather than in commercial software development. However, notable functional programming languages used in industry and commercial applications include Erlang,[2] OCaml,[3] Haskell,[4] Scheme[5][6] and domain-specific programming languages like R (statistics),[7] Mathematica (symbolic math),[8] J and K (financial analysis), and XSLT (XML).[9][10] Widespread declarative domain specific languages like SQL and Lex/Yacc, use some elements of functional programming, especially in eschewing mutable values.[11] Spreadsheets can also be viewed as functional programming languages.[12]

Programming in a functional style can be accomplished in languages, such as C, C++, Python, or Java, that aren't specifically designed for functional programming.

## History

Lambda calculus provides a theoretical framework for describing functions and their evaluation. Although it is a mathematical abstraction rather than a programming language, it forms the basis of almost all functional programming languages today. An equivalent theoretical formulation, combinatory logic, is commonly perceived as more abstract than lambda calculus and preceded it in invention. It is used in some esoteric languages including Unlambda. Combinatory logic and lambda calculus were both originally developed to achieve a clearer approach to the foundations of mathematics.[13]

An early functional-flavored language was LISP, developed by John McCarthy while at MIT for the IBM 700/7000 series scientific computers in the late 1950s.[14] LISP introduced many features now found in functional languages, though LISP is technically a multi-paradigm language. Scheme and Dylan were later attempts to simplify and improve LISP.

Information Processing Language (IPL) is sometimes cited as the first computer-based functional programming language. It is an assembly-style language for manipulating lists of symbols. It does have a notion of "generator", which amounts to a function accepting a function as an argument, and, since it is an assembly-level language, code can be used as data, so IPL can be regarded as having higher-order functions. However, it relies heavily on mutating list structure and similar imperative features.

Kenneth E. Iverson developed the APL programming language in the early 1960s, described in his 1962 book A Programming Language (ISBN 9780471430148). APL was the primary influence on John Backus's FP programming language. In the early 1990s, Iverson and Roger Hui created a successor to APL, the J programming language. In the mid 1990s, Arthur Whitney, who had previously worked with Iverson, created the K programming language, which is used commercially in financial industries.

John Backus presented the FP programming language in his 1977 Turing Award lecture Can Programming Be Liberated From the von Neumann Style? A Functional Style and its Algebra of Programs. He defines functional programs as being built up in a hierarchical way by means of "combining forms" that allow an "algebra of programs"; in modern language, this means that functional programs follow the principle of compositionality. Backus's paper popularized research into functional programming, though it emphasized function-level programming rather than the lambda-calculus style which has come to be associated with functional programming.

In the 1970s the ML programming language was created by Robin Milner at the University of Edinburgh, and David Turner developed initially the language SASL at the University of St. Andrews and later the language Miranda at the University of Kent. ML eventually developed into several dialects, the most common of which are now Objective Caml and Standard ML. Also in the 1970s, the development of the Scheme programming language (a partly-functional dialect of Lisp), as described in the influential Lambda Papers and the 1985 textbook Structure and Interpretation of Computer Programs, brought awareness of the power of functional programming to the wider programming-languages community.

In the 1980s, Per Martin-Löf developed Intuitionistic type theory (also called Constructive type theory), which associated functional programs with constructive proofs of arbitrarily complex mathematical propositions expressed as dependent types. This led to powerful new approaches to interactive theorem proving and has influenced the development of many subsequent functional programming languages.

The Haskell programming language was released in the late 1980s in an attempt to gather together many ideas in functional programming research.

## Concepts

A number of concepts and paradigms are specific to functional programming, and generally foreign to imperative programming (including object oriented programming). However, programming languages are often hybrids of several programming paradigms so programmers using "mostly imperative" languages may have utilized some of these concepts.[15]

### Higher-order functions

Functions are higher-order when they can take other functions as arguments, and return them as results. (Operators in mathematics, such as the differential operator d / dx that produces the derivative in calculus when applied to a function f, are examples of this.)

Higher-order functions are closely related to first-class functions, in that higher-order functions and first-class functions both allow functions as arguments and results of other functions. The distinction between the two is subtle: "higher-order" describes a mathematical concept of functions that operate on other functions, while "first-class" is a computer science term that describes programming language entities that have no restriction on their use (thus first-class functions can appear anywhere in the program that other first-class entities like numbers can, including as arguments to other functions and as their return values).

Higher-order functions enable currying, a technique in which a function is applied to its arguments one at a time, with each application returning a new function that accepts the next argument.

### Pure functions

Purely functional functions (or expressions) have no memory or I/O side effects, unless the computation of the result in itself is counted as a side-effect. This means that pure functions have several useful properties, many of which can be used to optimize the code:

• If the result of a pure expression is not used, it can be removed without affecting other expressions.
• If a pure function is called with parameters that cause no side-effects, the result is constant with respect to that parameter list (sometimes called referential transparency), i.e. if the pure function is again called with the same parameters, the same result will be returned (this can enable caching optimisations such as memoization).
• If there is no data dependency between two pure expressions, then their order can be reversed, or they can be performed in parallel and they cannot interfere with one another (in other terms, the evaluation of any pure expression is thread-safe).
• If the entire language does not allow side-effects, then any evaluation strategy can be used; this gives the compiler freedom to reorder or combine the evaluation of expressions in a program (for example, using deforestation).

While most compilers for imperative programming languages detect pure functions, and perform common-subexpression elimination for pure function calls, they cannot always do this for pre-compiled libraries, which generally do not expose this information, thus preventing optimisations that involve those external functions. Some compilers, such as gcc, add extra keywords for a programmer to explicitly mark external functions as pure, to enable such optimisations. Fortran 95 allows functions to be designated "pure".

### Recursion

Iteration (looping) in functional languages is usually accomplished via recursion. Recursive functions invoke themselves, allowing an operation to be performed over and over. Recursion may require maintaining a stack, but tail recursion can be recognized and optimized by a compiler into the same code used to implement iteration in imperative languages. The Scheme programming language standard requires implementations to recognize and optimize tail recursion. Tail recursion optimization can be implemented by transforming the program into continuation passing style during compilation, among other approaches.

Common patterns of recursion can be factored out using higher order functions, catamorphisms and anamorphisms (or "folds" and "unfolds") being the most obvious examples. Such higher order functions play a role analogous to built-in control structures such as loops in imperative languages.

Most general purpose functional programming languages allow unrestricted recursion and are Turing complete, which makes the halting problem undecidable, can cause unsoundness of equational reasoning, and generally requires the introduction of inconsistency into the logic expressed by the language's type system. Some special purpose languages such as Coq allow only well-founded recursion and are strongly normalizing (nonterminating computations can be expressed only with infinite streams of values called codata). As a consequence, these languages fail to be Turing complete and expressing certain functions in them is impossible, but they can still express a wide class of interesting computations while avoiding the problems introduced by unrestricted recursion. Functional programming limited to well-founded recursion with a few other constraints is called total functional programming. See Turner 2004 for more discussion. [16]

### Strict versus non-strict evaluation

Functional languages can be categorized by whether they use strict or non-strict evaluation, concepts that refer to how function arguments are processed when an expression is being evaluated. The technical difference is in the denotational semantics of expressions containing failing or divergent computations. Under strict evaluation, the evaluation of any term containing a failing subterm will itself fail. For example, the expression

``` print length([2+1, 3*2, 1/0, 5-4])
```

will fail under strict evaluation because of the division by zero in the third element of the list. Under nonstrict evaluation, the length function will return the value 4, since evaluating it will not attempt to evaluate the terms making up the list. In brief, strict evaluation always fully evaluates function arguments before invoking the function. Non-strict evaluation does not evaluate function arguments unless their values are required to evaluate the function call itself.

The usual implementation strategy for non-strict evaluation in functional languages is graph reduction. Non-strict evaluation is used by default in several pure functional languages, including Miranda, Clean and Haskell.

Hughes 1984 argues for non-strict (lazy) evaluation as a mechanism for improving program modularity through separation of concerns, by easing independent implementation of producers and consumers of data streams.[17] Launchbury 1993 describes some difficulties that lazy evaluation introduces, particularly in analyzing a program's storage requirements, and proposes an operational semantics to aid in such analysis.[18] Harper 2009 proposes including both strict and nonstrict evaluation in the same language, using the language's type system to distinguish them.[19]

### Type systems and pattern matching

Especially since the development of Hindley-Milner type inference in the 1970s, functional programming languages have tended to use typed lambda calculus, as opposed to the untyped lambda calculus used in Lisp and its variants (such as Scheme). The use of algebraic datatypes and pattern matching makes manipulation of complex data structures more convenient and expressive; the presence of strong compile-time type checking makes programs more reliable, while type inference frees the programmer from the need to manually declare types to the compiler.

Some research-oriented functional languages such as Coq, Agda, Cayenne, and Epigram are based on Intuitionistic type theory, which allows types to depend on terms. Such types are called dependent types. These type systems do not have decidable type inference and are difficult to understand and program with. But dependent types can express arbitrary propositions in predicate logic. Through the Curry-Howard isomorphism, then, well-typed programs in these languages become a means of writing formal mathematical proofs from which a compiler can generate certified code. While these languages are primarily of interest in academic research (including in formalized mathematics), they have begun to be used in engineering as well. Compcert is a compiler for a subset of the C programming language that is written in Coq and formally verified.[20]

A limited form of dependent types called generalized algebraic data types (GADT's) can be implemented in a way that provides some of the benefits of dependently-typed programming while avoiding most of its inconvenience.[21] GADT's are available in the Glasgow Haskell Compiler and in Scala (as "case classes"), and have been proposed as additions to other languages including Java and C#.[22]

### Functional programming in non-functional languages

It is possible to employ a functional style of programming in languages that are not traditionally considered functional languages.[23] Some non-functional languages have borrowed features such as higher-order functions, and list comprehensions from functional programming languages. This makes it easier to adopt a functional style when using these languages. Functional constructs such as higher-order functions and lazy lists can be obtained in C++ via libraries.[24] In C, function pointers can be used to get some of the effects of higher-order functions. For example the common function map can be implemented using function pointers. In C# version 3.0 and higher, lambda functions can be employed to write programs in a functional style. In Java, anonymous classes can sometimes be used to simulate closures, however anonymous classes cannot always be proper replacements to closures because they have more limited capabilities.

Many object-oriented design patterns are expressible in functional programming terms: for example, the Strategy pattern simply dictates use of a higher-order function, and the Visitor pattern roughly corresponds to a Catamorphism, or fold.

The benefits of immutable data can be seen even in imperative programs, so programmers often strive to make some data immutable even in imperative programs.

## Comparison of functional and imperative programming

Functional programming is very different from imperative programming. The most significant differences stem from the fact that functional programming avoids side effects, which are used in imperative programming to implement state and I/O. Pure functional programming disallows side effects completely. Disallowing side effects provides for referential transparency, which makes it easier to verify, optimize, and parallelize programs, and easier to write automated tools to perform those tasks.

Higher order functions are rarely used in older imperative programming. Where a traditional imperative program might use a loop to traverse a list, a functional style would often use a higher-order function, map, that takes as arguments a function and a list, applies the function to each element of the list, and returns a list of the results.

### Simulating state

There are tasks—for example, maintaining a bank account balance—that often seem most naturally implemented with state. Pure functional programming performs these tasks, and I/O tasks such as accepting user input and printing to the screen, in a different way.

The pure functional programming language Haskell implements them using monads, derived from category theory. Monads are powerful and offer a way to abstract certain types of computational patterns, including (but not limited to) modeling of computations with mutable state (and other side effects such as I/O) in an imperative manner without losing purity. While existing monads may be easy to apply in a program, given appropriate templates and examples, many find them difficult to understand conceptually, e.g., when asked to define new monads (which is sometimes needed for certain types of libraries).[25]

Alternative methods such as Hoare logic and uniqueness have been developed to track side effects in programs. Some modern research languages use effect systems to make explicit the presence of side effects.

### Efficiency issues

Functional programming languages have been perceived as less efficient in their use of CPU and memory than imperative languages such as C and Pascal.[26] However, for programs that perform intensive numerical computations, functional languages such as OCaml and Clean are similar in speed to C. For programs that handle large matrices and multidimensional databases, array functional languages (such as J and K) were designed with speed optimization in mind.

Purely functional languages have a reputation for being slower than imperative languages. However, immutability of data can, in many cases, lead to execution efficiency in allowing the compiler to make assumptions that are unsafe in an imperative language, vastly increasing opportunities for inlining..

Lazy evaluation may also speed up the program, even asymptotically, whereas it may slow it down at most by a constant factor (however, it may introduce memory leaks when used improperly).

### Coding styles

Imperative programs tend to emphasize the series of steps taken by a program in carrying out an action, while functional programs tend to emphasize the composition and arrangement of functions, often without specifying explicit steps. A simple example of two solutions to the same programming goal (using the same multi-paradigm language Python) illustrates this.

```# imperative style
target = [] # create empty list
for item in source_list: # iterate over each thing in source
trans1 = G(item) # transform the item with the G() function
trans2 = F(trans1) # second transform with the F() function
target.append(trans2) # add transformed item to target
```

A functional version has a different feel to it:

```# functional style
# FP-oriented languages often have standard compose()
compose2 = lambda A, B: lambda x: A(B(x)) # Define how to apply two generic transformations
target = map(compose2(F, G), source_list) # Apply two specific functions F and G to each item in source
```

In contrast to the imperative style that describes the steps involved in building `target`, the functional style describes the mathematical relationship between `source_list` and `target`.

In practice in Python that code is often written with a list comprehension, a form of syntactic sugar for the for loop with implicit append:

```target = [F(G(item)) for item in source_list]
```

## References

1. ^ a b c Hudak, Paul (September 1989). "Conception, evolution, and application of functional programming languages" (PDF). ACM Computing Surveys 21 (3): 359–411. doi:10.1145/72551.72554.
2. ^ "Who uses Erlang for product development?". Frequently asked questions about Erlang. Retrieved on 2007-08-05.
3. ^ Minsky, Yaron; Weeks, Stephen (July 2008). "Caml Trading - experiences with functional programming on Wall Street". Journal of Functional Programming (Cambridge University Press) 18 (4): 553–564. doi:10.1017/S095679680800676X. Retrieved on 2008-08-27.
5. ^ Clinger, Will (1987). "MultiTasking and MacScheme". MacTech 3 (12). Retrieved on 2008-08-28.
6. ^ Hartheimer, Anne (1987). "Programming a Text Editor in MacScheme+Toolsmith". MacTech 3 (1). Retrieved on 2008-08-28.
7. ^ The useR! 2006 conference schedule includes papers on the commercial use of R
8. ^ Department of Applied Math, University of Colorado. "Functional vs. Procedural Programming Language". Retrieved on 2006-08-28.
9. ^ Dimitre Novatchev. "The Functional Programming Language XSLT - A proof through examples". TopXML. Retrieved on May 27 2006.
10. ^ David Mertz. "XML Programming Paradigms (part four): Functional Programming approached to XML processing". IBM developerWorks. Retrieved on May 27 2006.
11. ^ Donald D. Chamberlin and Raymond F. Boyce (1974). "SEQUEL: A structured English query language". Proceedings of the 1974 ACM SIGFIDET: 249–264. . In this paper, one of the first formal presentations of the concepts of SQL (and before the name was later abbreviated), Chamberlin and Boyce emphasize that SQL was developed "Without resorting to the concepts of bound variables and quantifiers".
12. ^ Simon Peyton Jones, Margaret Burnett, Alan Blackwell (March 2003). "Improving the world's most popular functional language: user-defined functions in Excel".
13. ^ Curry, Haskell Brooks; Robert Feys and Craig, William (1958). Combinatory Logic. Volume I. Amsterdam: North-Holland Publishing Company.
14. ^ McCarthy, John (June 1978). "History of Lisp". In ACM SIGPLAN History of Programming Languages Conference: 173–196.  " The implementation of LISP began in Fall 1958."
15. ^ Dick Pountain. "Functional Programming Comes of Age". BYTE.com (August 1994). Retrieved on August 31 2006.
16. ^ Turner, D.A. (), "Total Functional Programming", Journal of Universal Computer Science 10 (7): 751–768
17. ^ John Hughes. "Why Functional Programming Matters".
18. ^ John Launchbury (1993). "A Natural Semantics for Lazy Evaluation".
19. ^ Robert W. Harper (2009). Practical Foundations for Programming Languages.  (in preparation), section XIV.
20. ^ "The Compcert verified compiler".
21. ^ Simon Peyton Jones, Dimitrios Vytiniotis, Stephanie Weirich, and Geoffrey Washburn. "Simple unification-based type inference for GADTs". ICFP 2006. 50-61.
22. ^ Andrew Kennedy and Claudio Russo (October 2005). "Generalized Algebraic Data Types and Object-Oriented Programming". written at San Diego, California. OOPSLA.  source of citation
23. ^ Hartel, Pieter; Henk Muller and Hugh Glaser (March 2004). "The Functional C experience" (PDF). The Journal of Functional Programming 14 (2): 129–135. doi:10.1017/S0956796803004817. ; David Mertz. "Functional programming in Python, Part 3". IBM developerWorks. Retrieved on 2006-09-17. (Part 1, Part 2)
24. ^ McNamara, B.. "FC++: Functional Programming in C++". Retrieved on 2006-05-28.
25. ^ Newbern, J.. "All About Monads: A comprehensive guide to the theory and practice of monadic programming in Haskell". Retrieved on 2008-02-14. , "The sheer number of different monad tutorials on the internet is a good indication of the difficulty many people have understanding the concept. This is due to the abstract nature of monads and to the fact that they are used in several different capacities, which can confuse the picture of exactly what a monad is and what it is good for."
26. ^ Lawrence C. Paulson, ML for the Working Programmer. Cambridge UP, 1996. ISBN: 052156543X.

• Abelson, Hal and Sussman, Gerald Jay. Structure and Interpretation of Computer Programs. MIT Press, 1985. on-line
• Cousineau, Guy and Michel Mauny. The Functional Approach to Programming. Cambridge, UK: Cambridge University Press, 1998.
• Curry, Haskell Brooks and Feys, Robert and Craig, William. Combinatory Logic. Volume I. North-Holland Publishing Company, Amsterdam, 1958.
• Curry, Haskell Brooks and Hindley, J. Roger and Seldin, Jonathan P. Combinatory Logic. Volume II. North-Holland Publishing Company, Amsterdam * London, 1972.
• Dominus, Mark Jason. Higher-Order Perl. Morgan Kaufman. 2005.
• Felleisen, Matthias, Robert Findler, Matthew Flatt, and Shriram Krishnamurthi. How to Design Programs HTDP. MIT Press. 2001. on-line
• Graham, Paul. ANSI Common LISP. Englewood Cliffs, New Jersey: Prentice Hall, 1996.
• MacLennan, Bruce J. Functional Programming: Practice and Theory. Addison-Wesley, 1990.
• O'Sullivan, Brian; Stewart, Don; and Goerzen, John. Real World Haskell. O'Reilly, 2008. on-line
• Pratt, Terrence, W. and Marvin V. Zelkowitz. Programming Languages: Design and Implementation. 3rd ed. Englewood Cliffs, New Jersey: Prentice Hall, 1996.
• Salus, Peter H. Functional and Logic Programming Languages. Vol. 4 of Handbook of Programming Languages. Indianapolis, Indiana: Macmillan Technical Publishing, 1998.
• Thompson, Simon. Haskell: The Craft of Functional Programming. Harlow, England: Addison-Wesley Longman Limited, 1996.