fbpx
Wikipedia

Functional programming

January 30, 2023

For subroutine-oriented programming, see Procedural programming.

In computer science, functional programming is a programming paradigm where programs are constructed by applying and composing functions. It is a declarative programming paradigm in which function definitions are trees of expressions that map values to other values, rather than a sequence of imperative statements which update the running state of the program.

In functional programming, functions are treated as first-class citizens, meaning that they can be bound to names (including local identifiers), passed as arguments, and returned from other functions, just as any other data type can. This allows programs to be written in a declarative and composable style, where small functions are combined in a modular manner.

Functional programming is sometimes treated as synonymous with purely functional programming, a subset of functional programming which treats all functions as deterministic mathematical functions, or pure functions. When a pure function is called with some given arguments, it will always return the same result, and cannot be affected by any mutable state or other side effects. This is in contrast with impure procedures, common in imperative programming, which can have side effects (such as modifying the program's state or taking input from a user). Proponents of purely functional programming claim that by restricting side effects, programs can have fewer bugs, be easier to debug and test, and be more suited to formal verification.[1][2]

Functional programming has its roots in academia, evolving from the lambda calculus, a formal system of computation based only on functions. Functional programming has historically been less popular than imperative programming, but many functional languages are seeing use today in industry and education, including Common Lisp, Scheme,[3][4][5][6] Clojure, Wolfram Language,[7][8] Racket,[9] Erlang,[10][11][12] Elixir,[13] OCaml,[14][15] Haskell,[16][17] and F#.[18][19] Functional programming is also key to some languages that have found success in specific domains, like JavaScript in the Web,[20] R in statistics,[21][22] J, K and Q in financial analysis, and XQuery/XSLT for XML.[23][24] Domain-specific declarative languages like SQL and Lex/Yacc use some elements of functional programming, such as not allowing mutable values.[25] In addition, many other programming languages support programming in a functional style or have implemented features from functional programming, such as C++11, C#,[26] Kotlin,[27] Perl,[28] PHP,[29] Python,[30] Go,[31] Rust,[32] Raku,[33] Scala,[34] and Java (since Java 8).[35]

History

The lambda calculus, developed in the 1930s by Alonzo Church, is a formal system of computation built from function application. In 1937 Alan Turing proved that the lambda calculus and Turing machines are equivalent models of computation,[36] showing that the lambda calculus is Turing complete. Lambda calculus forms the basis of all functional programming languages. An equivalent theoretical formulation, combinatory logic, was developed by Moses Schönfinkel and Haskell Curry in the 1920s and 1930s.[37]

Church later developed a weaker system, the simply-typed lambda calculus, which extended the lambda calculus by assigning a type to all terms.[38] This forms the basis for statically-typed functional programming.

The first high-level functional programming language, LISP, was developed in the late 1950s for the IBM 700/7000 series of scientific computers by John McCarthy while at Massachusetts Institute of Technology (MIT).[39] LISP functions were defined using Church's lambda notation, extended with a label construct to allow recursive functions.[40] Lisp first introduced many paradigmatic features of functional programming, though early Lisps were multi-paradigm languages, and incorporated support for numerous programming styles as new paradigms evolved. Later dialects, such as Scheme and Clojure, and offshoots such as Dylan and Julia, sought to simplify and rationalise Lisp around a cleanly functional core, while Common Lisp was designed to preserve and update the paradigmatic features of the numerous older dialects it replaced.[41]

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

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

In the mid 1960s, Peter Landin invented SECD machine,[43] the first abstract machine for a functional programming language,[44] described a correspondence between ALGOL 60 and the lambda calculus,[45][46] and proposed the ISWIM programming language.[47]

John Backus presented FP in his 1977 Turing Award lecture "Can Programming Be Liberated From the von Neumann Style? A Functional Style and its Algebra of Programs".[48] 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.[citation needed] Backus's paper popularized research into functional programming, though it emphasized function-level programming rather than the lambda-calculus style now associated with functional programming.

The 1973 language ML was created by Robin Milner at the University of Edinburgh, and David Turner developed the language SASL at the University of St Andrews. Also in Edinburgh in the 1970s, Burstall and Darlington developed the functional language NPL.[49] NPL was based on Kleene Recursion Equations and was first introduced in their work on program transformation.[50] Burstall, MacQueen and Sannella then incorporated the polymorphic type checking from ML to produce the language Hope.[51] ML eventually developed into several dialects, the most common of which are now OCaml and Standard ML.

In the 1970s, Guy L. Steele and Gerald Jay Sussman developed Scheme, as described in the Lambda Papers and the 1985 textbook Structure and Interpretation of Computer Programs. Scheme was the first dialect of lisp to use lexical scoping and to require tail-call optimization, features that encourage functional programming.

In the 1980s, Per Martin-Löf developed intuitionistic type theory (also called constructive type theory), which associated functional programs with constructive proofs expressed as dependent types. This led to new approaches to interactive theorem proving and has influenced the development of subsequent functional programming languages.[citation needed]

The lazy functional language, Miranda, developed by David Turner, initially appeared in 1985 and had a strong influence on Haskell. With Miranda being proprietary, Haskell began with a consensus in 1987 to form an open standard for functional programming research; implementation releases have been ongoing since 1990.

More recently it has found use in niches such as parametric CAD in the OpenSCAD language built on the CGAL framework, although its restriction on reassigning values (all values are treated as constants) has led to confusion among users who are unfamiliar with functional programming as a concept.[52]

Functional programming continues to be used in commercial settings.[53][54][55]

Concepts

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

First-class and higher-order functions

Main articles: First-class function and Higher-order function

Higher-order functions are functions that can either take other functions as arguments or return them as results. In calculus, an example of a higher-order function is the differential operator  , which returns the derivative of a function  .

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 for 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 partial application or currying, a technique that applies a function to its arguments one at a time, with each application returning a new function that accepts the next argument. This lets a programmer succinctly express, for example, the successor function as the addition operator partially applied to the natural number one.

Pure functions

Main article: Pure function

Pure functions (or expressions) have no side effects (memory or I/O). 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 arguments that cause no side-effects, the result is constant with respect to that argument list (sometimes called referential transparency or idempotence), i.e., calling the pure function again with the same arguments returns the same result. (This can enable caching optimizations such as memoization.)
  • If there is no data dependency between two pure expressions, 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 optimizations 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 optimizations. Fortran 95 also lets functions be designated pure.[58] C++11 added constexpr keyword with similar semantics.

Recursion

Main article: Recursion (computer science)

Iteration (looping) in functional languages is usually accomplished via recursion. Recursive functions invoke themselves, letting an operation be repeated until it reaches the base case. In general, recursion requires maintaining a stack, which consumes space in a linear amount to the depth of recursion. This could make recursion prohibitively expensive to use instead of imperative loops. However, a special form of recursion known as tail recursion can be recognized and optimized by a compiler into the same code used to implement iteration in imperative languages. Tail recursion optimization can be implemented by transforming the program into continuation passing style during compiling, among other approaches.

The Scheme language standard requires implementations to support proper tail recursion, meaning they must allow an unbounded number of active tail calls.[59][60] Proper tail recursion is not simply an optimization; it is a language feature that assures users that they can use recursion to express a loop and doing so would be safe-for-space.[61] Moreover, contrary to its name, it accounts for all tail calls, not just tail recursion. While proper tail recursion is usually implemented by turning code into imperative loops, implementations might implement it in other ways. For example, CHICKEN intentionally maintains a stack and lets the stack overflow. However, when this happens, its garbage collector will claim space back,[62] allowing an unbounded number of active tail calls even though it does not turn tail recursion into a loop.

Common patterns of recursion can be abstracted away using higher-order functions, with catamorphisms and anamorphisms (or "folds" and "unfolds") being the most obvious examples. Such recursion schemes 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.[63]

Strict versus non-strict evaluation

Main article: Evaluation strategy

Functional languages can be categorized by whether they use strict (eager) or non-strict (lazy) 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 fails. For example, the expression: 

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

fails under strict evaluation because of the division by zero in the third element of the list. Under lazy evaluation, the length function returns the value 4 (i.e., the number of items in the list), since evaluating it does not attempt to evaluate the terms making up the list. In brief, strict evaluation always fully evaluates function arguments before invoking the function. Lazy evaluation does not evaluate function arguments unless their values are required to evaluate the function call itself.

The usual implementation strategy for lazy evaluation in functional languages is graph reduction.[64] Lazy evaluation is used by default in several pure functional languages, including Miranda, Clean, and Haskell.

Hughes 1984 argues for lazy evaluation as a mechanism for improving program modularity through separation of concerns, by easing independent implementation of producers and consumers of data streams.[2] 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.[65] Harper 2009 proposes including both strict and lazy evaluation in the same language, using the language's type system to distinguish them.[66]

Type systems

Main article: Type system

Especially since the development of Hindley–Milner type inference in the 1970s, functional programming languages have tended to use typed lambda calculus, rejecting all invalid programs at compilation time and risking false positive errors, as opposed to the untyped lambda calculus, that accepts all valid programs at compilation time and risks false negative errors, used in Lisp and its variants (such as Scheme), as they reject all invalid programs at runtime when the information is enough to not reject valid programs. The use of algebraic datatypes makes manipulation of complex data structures convenient; the presence of strong compile-time type checking makes programs more reliable in absence of other reliability techniques like test-driven development, while type inference frees the programmer from the need to manually declare types to the compiler in most cases.

Some research-oriented functional languages such as Coq, Agda, Cayenne, and Epigram are based on intuitionistic type theory, which lets types 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.[67][68][69][70] But dependent types can express arbitrary propositions in higher-order 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 mainly 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.[71]

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.[72] GADT's are available in the Glasgow Haskell Compiler, in OCaml[73] and in Scala,[74] and have been proposed as additions to other languages including Java and C#.[75]

Referential transparency

Main article: Referential transparency

Functional programs do not have assignment statements, that is, the value of a variable in a functional program never changes once defined. This eliminates any chances of side effects because any variable can be replaced with its actual value at any point of execution. So, functional programs are referentially transparent.[76]

Consider C assignment statement x = x * 10, this changes the value assigned to the variable x. Let us say that the initial value of x was 1, then two consecutive evaluations of the variable x yields 10 and 100 respectively. Clearly, replacing x = x * 10 with either 10 or 100 gives a program a different meaning, and so the expression is not referentially transparent. In fact, assignment statements are never referentially transparent.

Now, consider another function such as int plusone(int x) {return x+1;} is transparent, as it does not implicitly change the input x and thus has no such side effects. Functional programs exclusively use this type of function and are therefore referentially transparent.

Data structures

Main article: Purely functional data structure

Purely functional data structures are often represented in a different way than their imperative counterparts.[77] For example, the array with constant access and update times is a basic component of most imperative languages, and many imperative data-structures, such as the hash table and binary heap, are based on arrays. Arrays can be replaced by maps or random access lists, which admit purely functional implementation, but have logarithmic access and update times. Purely functional data structures have persistence, a property of keeping previous versions of the data structure unmodified. In Clojure, persistent data structures are used as functional alternatives to their imperative counterparts. Persistent vectors, for example, use trees for partial updating. Calling the insert method will result in some but not all nodes being created.[78]

Comparison to 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 completely prevents side-effects and provides referential transparency.

Higher-order functions are rarely used in older imperative programming. A traditional imperative program might use a loop to traverse and modify a list. A functional program, on the other hand, would probably use a higher-order “map” function that takes a function and a list, generating and returning a new list by applying the function to each list item.

Imperative vs. functional programming

The following two examples (written in JavaScript) achieve the same effect: they multiply all even numbers in an array by 10 and add them all, storing the final sum in the variable "result".

Traditional Imperative Loop: 

const numList = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; let result = 0; for (let i = 0; i < numList.length; i++) { if (numList[i] % 2 === 0) { result += numList[i] * 10; } }

Functional Programming with higher-order functions: 

const result = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] .filter(n => n % 2 === 0) .map(a => a * 10) .reduce((a, b) => a + b);

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.[79] Monads 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 students find them difficult to understand conceptually, e.g., when asked to define new monads (which is sometimes needed for certain types of libraries).[80]

Functional languages also simulate states by passing around immutable states. This can be done by making a function accept the state as one of its parameters, and return a new state together with the result, leaving the old state unchanged.[81]

Impure functional languages usually include a more direct method of managing mutable state. Clojure, for example, uses managed references that can be updated by applying pure functions to the current state. This kind of approach enables mutability while still promoting the use of pure functions as the preferred way to express computations.[citation needed]

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 the presence of side effects explicit.[citation needed]

Efficiency issues

Functional programming languages are typically less efficient in their use of CPU and memory than imperative languages such as C and Pascal.[82] This is related to the fact that some mutable data structures like arrays have a very straightforward implementation using present hardware. Flat arrays may be accessed very efficiently with deeply pipelined CPUs, prefetched efficiently through caches (with no complex pointer chasing), or handled with SIMD instructions. It is also not easy to create their equally efficient general-purpose immutable counterparts. For purely functional languages, the worst-case slowdown is logarithmic in the number of memory cells used, because mutable memory can be represented by a purely functional data structure with logarithmic access time (such as a balanced tree).[83] However, such slowdowns are not universal. For programs that perform intensive numerical computations, functional languages such as OCaml and Clean are only slightly slower than C according to The Computer Language Benchmarks Game.[84] For programs that handle large matrices and multidimensional databases, array functional languages (such as J and K) were designed with speed optimizations.

Immutability of data can in many cases lead to execution efficiency by allowing the compiler to make assumptions that are unsafe in an imperative language, thus increasing opportunities for inline expansion.[85]

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 if used improperly). Launchbury 1993[65] discusses theoretical issues related to memory leaks from lazy evaluation, and O'Sullivan et al. 2008[86] give some practical advice for analyzing and fixing them. However, the most general implementations of lazy evaluation making extensive use of dereferenced code and data perform poorly on modern processors with deep pipelines and multi-level caches (where a cache miss may cost hundreds of cycles)[citation needed].

Functional programming in non-functional languages

It is possible to use a functional style of programming in languages that are not traditionally considered functional languages.[87] For example, both D[88] and Fortran 95[58] explicitly support pure functions.

JavaScript, Lua,[89] Python and Go[90] had first class functions from their inception.[91] Python had support for "lambda", "map", "reduce", and "filter" in 1994, as well as closures in Python 2.2,[92] though Python 3 relegated "reduce" to the functools standard library module.[93] First-class functions have been introduced into other mainstream languages such as PHP 5.3, Visual Basic 9, C# 3.0, C++11, and Kotlin.[27][citation needed]

In PHP, anonymous classes, closures and lambdas are fully supported. Libraries and language extensions for immutable data structures are being developed to aid programming in the functional style.

In Java, anonymous classes can sometimes be used to simulate closures;[94] however, anonymous classes are not always proper replacements to closures because they have more limited capabilities.[95] Java 8 supports lambda expressions as a replacement for some anonymous classes.[96]

In C#, anonymous classes are not necessary, because closures and lambdas are fully supported. Libraries and language extensions for immutable data structures are being developed to aid programming in the functional style in C#.

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.

Similarly, the idea of immutable data from functional programming is often included in imperative programming languages,[97] for example the tuple in Python, which is an immutable array, and Object.freeze() in JavaScript.[98]

Applications

Spreadsheets

Spreadsheets can be considered a form of pure, zeroth-order, strict-evaluation functional programming system.[99] However, spreadsheets generally lack higher-order functions as well as code reuse, and in some implementations, also lack recursion. Several extensions have been developed for spreadsheet programs to enable higher-order and reusable functions, but so far remain primarily academic in nature.[100]

Academia

Functional programming is an active area of research in the field of programming language theory. There are several peer-reviewed publication venues focusing on functional programming, including the International Conference on Functional Programming, the Journal of Functional Programming, and the Symposium on Trends in Functional Programming.

Industry

Functional programming has been employed in a wide range of industrial applications. For example, Erlang, which was developed by the Swedish company Ericsson in the late 1980s, was originally used to implement fault-tolerant telecommunications systems,[11] but has since become popular for building a range of applications at companies such as Nortel, Facebook, Électricité de France and WhatsApp.[10][12][101][102][103] Scheme, a dialect of Lisp, was used as the basis for several applications on early Apple Macintosh computers[3][4] and has been applied to problems such as training-simulation software[5] and telescope control.[6] OCaml, which was introduced in the mid-1990s, has seen commercial use in areas such as financial analysis,[14] driver verification, industrial robot programming and static analysis of embedded software.[15] Haskell, though initially intended as a research language,[17] has also been applied in areas such as aerospace systems, hardware design and web programming.[16][17]

Other functional programming languages that have seen use in industry include Scala,[104] F#,[18][19] Wolfram Language,[7] Lisp,[105] Standard ML[106][107] and Clojure.[108]

Functional "platforms" have been popular in finance for risk analytics (particularly with large investment banks). Risk factors are coded as functions that form interdependent graphs (categories) to measure correlations in market shifts, similar in manner to Gröbner basis optimizations but also for regulatory frameworks such as Comprehensive Capital Analysis and Review. Given the use of OCaml and Caml variations in finance, these systems are sometimes considered related to a categorical abstract machine. Functional programming is heavily influenced by category theory.[citation needed]

Education

Many universities teach functional programming.[109][110][111][112] Some treat it as an introductory programming concept[112] while others first teach imperative programming methods.[111][113]

Outside of computer science, functional programming is used to teach problem-solving, algebraic and geometric concepts.[114] It has also been used to teach classical mechanics, as in the book Structure and Interpretation of Classical Mechanics.

See also

References

  1. ^ 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. S2CID 207637854.
  2. ^ a b Hughes, John (1984). "Why Functional Programming Matters".
  3. ^ a b Clinger, Will (1987). "MultiTasking and MacScheme". MacTech. 3 (12). Retrieved 2008-08-28.
  4. ^ a b Hartheimer, Anne (1987). . MacTech. 3 (1). Archived from the original on 2011-06-29. Retrieved 2008-08-28.
  5. ^ a b Kidd, Eric. Terrorism Response Training in Scheme. CUFP 2007. Retrieved 2009-08-26.
  6. ^ a b Cleis, Richard. Scheme in Space. CUFP 2006. Retrieved 2009-08-26.
  7. ^ a b "Wolfram Language Guide: Functional Programming". 2015. Retrieved 2015-08-24.
  8. ^ . Department of Applied Math. University of Colorado. Archived from the original on 2007-11-13.
  9. ^ (PDF). Archived from the original (PDF) on 2012-12-15. Retrieved 2011-08-08.
  10. ^ a b "Who uses Erlang for product development?". Frequently asked questions about Erlang. Retrieved 2018-04-27.
  11. ^ a b Armstrong, Joe (June 2007). "A history of Erlang". Proceedings of the third ACM SIGPLAN conference on History of programming languages. Third ACM SIGPLAN Conference on History of Programming Languages. San Diego, California. doi:10.1145/1238844.1238850. ISBN 9781595937667.
  12. ^ a b Larson, Jim (March 2009). "Erlang for concurrent programming". Communications of the ACM. 52 (3): 48. doi:10.1145/1467247.1467263. S2CID 524392.
  13. ^ "The Elixir Programming Language". Retrieved 2021-02-14.
  14. ^ a b Minsky, Yaron; Weeks, Stephen (July 2008). "Caml Trading — experiences with functional programming on Wall Street". Journal of Functional Programming. 18 (4): 553–564. doi:10.1017/S095679680800676X. S2CID 30955392. Retrieved 2008-08-27.
  15. ^ a b Leroy, Xavier. Some uses of Caml in Industry (PDF). CUFP 2007. Retrieved 2009-08-26.
  16. ^ a b "Haskell in industry". Haskell Wiki. Retrieved 2009-08-26. Haskell has a diverse range of use commercially, from aerospace and defense, to finance, to web startups, hardware design firms and lawnmower manufacturers.
  17. ^ a b c Hudak, Paul; Hughes, J.; Jones, S. P.; Wadler, P. (June 2007). A history of Haskell: being lazy with class. Third ACM SIGPLAN Conference on History of Programming Languages. San Diego, California. doi:10.1145/1238844.1238856. Retrieved 2013-09-26.
  18. ^ a b Mansell, Howard (2008). Quantitative Finance in F#. CUFP 2008. Retrieved 2009-08-29.
  19. ^ a b Peake, Alex (2009). . CUFP 2009. Archived from the original on 2009-10-17. Retrieved 2009-08-29.
  20. ^ comments, 27 Jun 2017 Matt Banz Feed 603up 2. "An introduction to functional programming in JavaScript". Opensource.com. Retrieved 2021-01-09.
  21. ^ "The useR! 2006 conference schedule includes papers on the commercial use of R". R-project.org. 2006-06-08. Retrieved 2011-06-20.
  22. ^ Chambers, John M. (1998). Programming with Data: A Guide to the S Language. Springer Verlag. pp. 67–70. ISBN 978-0-387-98503-9.
  23. ^ Novatchev, Dimitre. "The Functional Programming Language XSLT — A proof through examples". Retrieved May 27, 2006.
  24. ^ Mertz, David. "XML Programming Paradigms (part four): Functional Programming approached to XML processing". IBM developerWorks. Retrieved May 27, 2006.
  25. ^ Chamberlin, Donald D.; Boyce, Raymond F. (1974). "SEQUEL: A structured English query language". Proceedings of the 1974 ACM SIGFIDET: 249–264.
  26. ^ Functional Programming with C# - Simon Painter - NDC Oslo 2020, archived from the original on 2021-10-30, retrieved 2021-10-23
  27. ^ a b "Functional programming - Kotlin Programming Language". Kotlin. Retrieved 2019-05-01.
  28. ^ Dominus, Mark J. (2005). Higher-Order Perl. Morgan Kaufmann. ISBN 978-1-55860-701-9.
  29. ^ Holywell, Simon (2014). Functional Programming in PHP. php[architect]. ISBN 9781940111056.
  30. ^ The Cain Gang Ltd. (PDF). Archived from the original (PDF) on 30 May 2009. Retrieved 27 June 2009.
  31. ^ "GopherCon 2020: Dylan Meeus - Functional Programming with Go". YouTube.com.{{cite web}}: CS1 maint: url-status (link)
  32. ^ "Functional Language Features: Iterators and Closures - The Rust Programming Language". doc.rust-lang.org. Retrieved 2021-01-09.
  33. ^ Vanderbauwhede, Wim. . Archived from the original on 11 Sep 2020. Retrieved 6 October 2020.
  34. ^ "Effective Scala". Scala Wiki. Retrieved 2012-02-21. Effective Scala.
  35. ^ "Documentation for package java.util.function since Java 8 (also known as Java 1.8)". Retrieved 2021-06-16.
  36. ^ Turing, A. M. (1937). "Computability and λ-definability". The Journal of Symbolic Logic. Cambridge University Press. 2 (4): 153–163. doi:10.2307/2268280. JSTOR 2268280. S2CID 2317046.
  37. ^ Haskell Brooks Curry; Robert Feys (1958). Combinatory Logic. North-Holland Publishing Company. Retrieved 10 February 2013.
  38. ^ Church, A. (1940). "A Formulation of the Simple Theory of Types". Journal of Symbolic Logic. 5 (2): 56–68. doi:10.2307/2266170. JSTOR 2266170. S2CID 15889861.
  39. ^ McCarthy, John (June 1978). History of Lisp (PDF). History of Programming Languages. Los Angeles, CA. pp. 173–185. doi:10.1145/800025.808387.
  40. ^ John McCarthy (1960). "Recursive functions of symbolic expressions and their computation by machine, Part I." (PDF). Communications of the ACM. ACM New York, NY, USA. 3 (4): 184–195. doi:10.1145/367177.367199. S2CID 1489409.
  41. ^ Guy L. Steele; Richard P. Gabriel (February 1996). The Evolution of Lisp (PDF). In ACM/SIGPLAN Second History of Programming Languages. pp. 233–330. doi:10.1145/234286.1057818. ISBN 978-0-201-89502-5. S2CID 47047140.
  42. ^ The memoir of Herbert A. Simon (1991), Models of My Life pp.189-190 ISBN 0-465-04640-1 claims that he, Al Newell, and Cliff Shaw are "...commonly adjudged to be the parents of [the] artificial intelligence [field]," for writing Logic Theorist, a program that proved theorems from Principia Mathematica automatically. To accomplish this, they had to invent a language and a paradigm that, viewed retrospectively, embeds functional programming.
  43. ^ Landin, Peter J. (1964). "The mechanical evaluation of expressions". The Computer Journal. British Computer Society. 6 (4): 308–320. doi:10.1093/comjnl/6.4.308.
  44. ^ Diehl, Stephan; Hartel, Pieter; Sestoft, Peter (2000). "Abstract machines for programming language implementation". Future Generation Computer Systems. Vol. 16. pp. 739–751.
  45. ^ Landin, Peter J. (February 1965a). "Correspondence between ALGOL 60 and Church's Lambda-notation: part I". Communications of the ACM. Association for Computing Machinery. 8 (2): 89–101. doi:10.1145/363744.363749. S2CID 6505810.
  46. ^ Landin, Peter J. (March 1965b). "A correspondence between ALGOL 60 and Church's Lambda-notation: part II". Communications of the ACM. Association for Computing Machinery. 8 (3): 158–165. doi:10.1145/363791.363804. S2CID 15781851.
  47. ^ Landin, Peter J. (March 1966b). "The next 700 programming languages". Communications of the ACM. Association for Computing Machinery. 9 (3): 157–166. doi:10.1145/365230.365257. S2CID 13409665.
  48. ^ Backus, J. (1978). "Can programming be liberated from the von Neumann style?: A functional style and its algebra of programs". Communications of the ACM. 21 (8): 613–641. doi:10.1145/359576.359579.
  49. ^ R.M. Burstall. Design considerations for a functional programming language. Invited paper, Proc. Infotech State of the Art Conf. "The Software Revolution", Copenhagen, 45–57 (1977)
  50. ^ R.M. Burstall and J. Darlington. A transformation system for developing recursive programs. Journal of the Association for Computing Machinery 24(1):44–67 (1977)
  51. ^ R.M. Burstall, D.B. MacQueen and D.T. Sannella. HOPE: an experimental applicative language. Proc. 1980 LISP Conference, Stanford, 136–143 (1980).
  52. ^ "Make discovering assign() easier!". OpenSCAD.
  53. ^ Peter Bright (March 13, 2018). "Developers love trendy new languages but earn more with functional programming". Ars Technica.
  54. ^ John Leonard (January 24, 2017). "The stealthy rise of functional programming". Computing.
  55. ^ Leo Cheung (May 9, 2017). "Is functional programming better for your startup?". InfoWorld.
  56. ^ Sean Tull - Monoidal Categories for Formal Concept Analysis.
  57. ^ Pountain, Dick. . BYTE.com (August 1994). Archived from the original on 2006-08-27. Retrieved August 31, 2006.
  58. ^ a b "ISO/IEC JTC 1/SC 22/WG5/N2137". International Organization for Standardization. July 6, 2017. {{cite journal}}: Cite journal requires |journal= (help)
  59. ^ "Revised^6 Report on the Algorithmic Language Scheme". R6rs.org. Retrieved 2013-03-21.
  60. ^ "Revised^6 Report on the Algorithmic Language Scheme - Rationale". R6rs.org. Retrieved 2013-03-21.
  61. ^ Clinger, William (1998). "Proper tail recursion and space efficiency". Proceedings of the ACM SIGPLAN 1998 conference on Programming language design and implementation - PLDI '98. pp. 174–185. doi:10.1145/277650.277719. ISBN 0897919874. S2CID 16812984.
  62. ^ Baker, Henry (1994). "CONS Should Not CONS Its Arguments, Part II: Cheney on the M.T.A."
  63. ^ Turner, D.A. (2004-07-28). "Total Functional Programming". Journal of Universal Computer Science. 10 (7): 751–768. doi:10.3217/jucs-010-07-0751.
  64. ^ The Implementation of Functional Programming Languages. Simon Peyton Jones, published by Prentice Hall, 1987
  65. ^ a b John Launchbury (1993). "A Natural Semantics for Lazy Evaluation": 144–154. CiteSeerX 10.1.1.35.2016. {{cite journal}}: Cite journal requires |journal= (help)
  66. ^ Robert W. Harper (2009). (PDF). Archived from the original (PDF) on 2016-04-07.
  67. ^ Huet, Gérard P. (1973). "The Undecidability of Unification in Third Order Logic". Information and Control. 22 (3): 257–267. doi:10.1016/s0019-9958(73)90301-x.
  68. ^ Huet, Gérard (Sep 1976). Resolution d'Equations dans des Langages d'Ordre 1,2,...ω (Ph.D.) (in French). Universite de Paris VII.
  69. ^ Huet, Gérard (2002). "Higher Order Unification 30 years later" (PDF). In Carreño, V.; Muñoz, C.; Tahar, S. (eds.). Proceedings, 15th International Conference TPHOL. LNCS. Vol. 2410. Springer. pp. 3–12.
  70. ^ Wells, J. B. (1993). "Typability and type checking in the second-order lambda-calculus are equivalent and undecidable". Tech. Rep. 93-011: 176–185. CiteSeerX 10.1.1.31.3590.
  71. ^ Leroy, Xavier (17 September 2018). "The Compcert verified compiler".
  72. ^ Peyton Jones, Simon; Vytiniotis, Dimitrios; Weirich, Stephanie; Geoffrey Washburn (April 2006). "Simple unification-based type inference for GADTs". Icfp 2006: 50–61.
  73. ^ "OCaml Manual". caml.inria.fr. Retrieved 2021-03-08.{{cite web}}: CS1 maint: url-status (link)
  74. ^ "Algebraic Data Types". Scala Documentation. Retrieved 2021-03-08.
  75. ^ Kennedy, Andrew; Russo, Claudio (October 2005). (PDF). OOPSLA. San Diego, California. ISBN 9781595930316. Archived from the original (PDF) on 2006-12-29. source of citation
  76. ^ Hughes, John. "Why Functional Programming Matters" (PDF). Chalmers University of Technology.
  77. ^ Purely functional data structures by Chris Okasaki, Cambridge University Press, 1998, ISBN 0-521-66350-4
  78. ^ L’orange, Jean Niklas. "polymatheia - Understanding Clojure's Persistent Vector, pt. 1". Polymatheia. Retrieved 2018-11-13.
  79. ^ Michael Barr, Charles Well - Category theory for computer science.
  80. ^ Newbern, J. "All About Monads: A comprehensive guide to the theory and practice of monadic programming in Haskell". Retrieved 2008-02-14.
  81. ^ "Thirteen ways of looking at a turtle". fF# for fun and profit. Retrieved 2018-11-13.
  82. ^ Paulson, Larry C. (28 June 1996). ML for the Working Programmer. Cambridge University Press. ISBN 978-0-521-56543-1. Retrieved 10 February 2013.
  83. ^ Spiewak, Daniel (26 August 2008). "Implementing Persistent Vectors in Scala". Code Commit.
  84. ^ . benchmarksgame.alioth.debian.org. Archived from the original on 2013-05-20. Retrieved 2011-06-20.
  85. ^ Igor Pechtchanski; Vivek Sarkar (2005). "Immutability specification and its applications". Concurrency and Computation: Practice and Experience. 17 (5–6): 639–662. doi:10.1002/cpe.853. S2CID 34527406.
  86. ^ "Chapter 25. Profiling and optimization". Book.realworldhaskell.org. Retrieved 2011-06-20.
  87. ^ Hartel, Pieter; Henk Muller; Hugh Glaser (March 2004). "The Functional C experience" (PDF). Journal of Functional Programming. 14 (2): 129–135. doi:10.1017/S0956796803004817. S2CID 32346900.; David Mertz. . IBM developerWorks. Archived from the original on 2007-10-16. Retrieved 2006-09-17.(, )
  88. ^ "Functions — D Programming Language 2.0". Digital Mars. 30 December 2012.
  89. ^ "Lua Unofficial FAQ (uFAQ)".
  90. ^ "First-Class Functions in Go - The Go Programming Language". golang.org. Retrieved 2021-01-04.
  91. ^ Eich, Brendan (3 April 2008). "Popularity".
  92. ^ van Rossum, Guido (2009-04-21). "Origins of Python's "Functional" Features". Retrieved 2012-09-27.
  93. ^ "functools — Higher order functions and operations on callable objects". Python Software Foundation. 2011-07-31. Retrieved 2011-07-31.
  94. ^ Skarsaune, Martin (2008). The SICS Java Port Project Automatic Translation of a Large Object Oriented System from Smalltalk to Java.
  95. ^ Gosling, James. . James Gosling: on the Java Road. Oracle. Archived from the original on 2013-04-14. Retrieved 11 May 2013.
  96. ^ Williams, Michael (8 April 2013). "Java SE 8 Lambda Quick Start".
  97. ^ Bloch, Joshua (2008). "Item 15: Minimize Mutability". Effective Java (Second ed.). Addison-Wesley. ISBN 978-0321356680.
  98. ^ "Object.freeze() - JavaScript | MDN". developer.mozilla.org. Retrieved 2021-01-04. The Object.freeze() method freezes an object. A frozen object can no longer be changed; freezing an object prevents new properties from being added to it, existing properties from being removed, prevents changing the enumerability, configurability, or writability of existing properties, and prevents the values of existing properties from being changed. In addition, freezing an object also prevents its prototype from being changed. freeze() returns the same object that was passed in.{{cite web}}: CS1 maint: url-status (link)
  99. ^ Wakeling, David (2007). "Spreadsheet functional programming" (PDF). Journal of Functional Programming. 17 (1): 131–143. doi:10.1017/S0956796806006186. ISSN 0956-7968. S2CID 29429059.
  100. ^ Peyton Jones, Simon; Burnett, Margaret; Blackwell, Alan (March 2003). . Archived from the original on 2005-10-16.
  101. ^ Piro, Christopher (2009). . CUFP 2009. Archived from the original on 2009-10-17. Retrieved 2009-08-29.
  102. ^ "Sim-Diasca: a large-scale discrete event concurrent simulation engine in Erlang". November 2011.
  103. ^ 1 million is so 2011 2014-02-19 at the Wayback Machine // WhatsApp blog, 2012-01-06: "the last important piece of our infrastracture is Erlang"
  104. ^ Momtahan, Lee (2009). . CUFP 2009. Archived from the original on 2009-10-17. Retrieved 2009-08-29.
  105. ^ Graham, Paul (2003). "Beating the Averages". Retrieved 2009-08-29.
  106. ^ Sims, Steve (2006). Building a Startup with Standard ML (PDF). CUFP 2006. Retrieved 2009-08-29.
  107. ^ Laurikari, Ville (2007). Functional Programming in Communications Security. CUFP 2007. Retrieved 2009-08-29.
  108. ^ Lorimer, R. J. (19 January 2009). "Live Production Clojure Application Announced". InfoQ.
  109. ^ "Functional Programming: 2019-2020". University of Oxford Department of Computer Science. Retrieved 28 April 2020.
  110. ^ "Programming I (Haskell)". Imperial College London Department of Computing. Retrieved 28 April 2020.
  111. ^ a b "Computer Science BSc - Modules". Retrieved 28 April 2020.
  112. ^ a b Abelson, Hal; Sussman, Gerald Jay (1985). "Preface to the Second Edition". Structure and Interpretation of Computer Programs (2 ed.). MIT Press.
  113. ^ John DeNero (Fall 2019). "Computer Science 61A, Berkeley". Department of Electrical Engineering and Computer Sciences, Berkeley. Retrieved 2020-08-14.
  114. ^ Emmanuel Schanzer of Bootstrap interviewed on the TV show Triangulation on the TWiT.tv network

Further reading

  • Abelson, Hal; Sussman, Gerald Jay (1985). Structure and Interpretation of Computer Programs. MIT Press.
  • 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 B.; Hindley, J. Roger; Seldin, Jonathan P. (1972). Combinatory Logic. Vol. II. Amsterdam: North Holland. ISBN 978-0-7204-2208-5.
  • Dominus, Mark Jason. Higher-Order Perl. Morgan Kaufmann. 2005.
  • Felleisen, Matthias; Findler, Robert; Flatt, Matthew; Krishnamurthi, Shriram (2001). How to Design Programs. MIT Press.
  • Graham, Paul. ANSI Common LISP. Englewood Cliffs, New Jersey: Prentice Hall, 1996.
  • MacLennan, Bruce J. Functional Programming: Practice and Theory. Addison-Wesley, 1990.
  • Michaelson, Greg (10 April 2013). An Introduction to Functional Programming Through Lambda Calculus. Courier Corporation. ISBN 978-0-486-28029-5.[1]
  • O'Sullivan, Brian; Stewart, Don; Goerzen, John (2008). Real World Haskell. O'Reilly.
  • Pratt, Terrence W. and Marvin Victor 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.

External links

Listen to this article (28 minutes)
 
This audio file was created from a revision of this article dated 25 August 2011 (2011-08-25), and does not reflect subsequent edits.
(Audio help · More spoken articles)
  • Ford, Neal. "Functional thinking". Retrieved 2021-11-10.
  • Akhmechet, Slava (2006-06-19). "defmacro – Functional Programming For The Rest of Us". Retrieved 2013-02-24. An introduction
  • Functional programming in Python (by David Mertz): part 1, part 2, part 3
  1. ^ "Greg Michaelson's Homepage". Mathematical and Computer Sciences. Riccarton, Edinburgh: Heriot-Watt University. Retrieved 6 November 2022.

January 30, 2023
functional, programming, subroutine, oriented, programming, procedural, programming, computer, science, functional, programming, programming, paradigm, where, programs, constructed, applying, composing, functions, declarative, programming, paradigm, which, fun. For subroutine oriented programming see Procedural programming In computer science functional programming is a programming paradigm where programs are constructed by applying and composing functions It is a declarative programming paradigm in which function definitions are trees of expressions that map values to other values rather than a sequence of imperative statements which update the running state of the program In functional programming functions are treated as first class citizens meaning that they can be bound to names including local identifiers passed as arguments and returned from other functions just as any other data type can This allows programs to be written in a declarative and composable style where small functions are combined in a modular manner Functional programming is sometimes treated as synonymous with purely functional programming a subset of functional programming which treats all functions as deterministic mathematical functions or pure functions When a pure function is called with some given arguments it will always return the same result and cannot be affected by any mutable state or other side effects This is in contrast with impure procedures common in imperative programming which can have side effects such as modifying the program s state or taking input from a user Proponents of purely functional programming claim that by restricting side effects programs can have fewer bugs be easier to debug and test and be more suited to formal verification 1 2 Functional programming has its roots in academia evolving from the lambda calculus a formal system of computation based only on functions Functional programming has historically been less popular than imperative programming but many functional languages are seeing use today in industry and education including Common Lisp Scheme 3 4 5 6 Clojure Wolfram Language 7 8 Racket 9 Erlang 10 11 12 Elixir 13 OCaml 14 15 Haskell 16 17 and F 18 19 Functional programming is also key to some languages that have found success in specific domains like JavaScript in the Web 20 R in statistics 21 22 J K and Q in financial analysis and XQuery XSLT for XML 23 24 Domain specific declarative languages like SQL and Lex Yacc use some elements of functional programming such as not allowing mutable values 25 In addition many other programming languages support programming in a functional style or have implemented features from functional programming such as C 11 C 26 Kotlin 27 Perl 28 PHP 29 Python 30 Go 31 Rust 32 Raku 33 Scala 34 and Java since Java 8 35 Contents 1 History 2 Concepts 2 1 First class and higher order functions 2 2 Pure functions 2 3 Recursion 2 4 Strict versus non strict evaluation 2 5 Type systems 2 6 Referential transparency 2 7 Data structures 3 Comparison to imperative programming 3 1 Imperative vs functional programming 3 2 Simulating state 3 3 Efficiency issues 3 4 Functional programming in non functional languages 4 Applications 4 1 Spreadsheets 4 2 Academia 4 3 Industry 4 4 Education 5 See also 6 References 7 Further reading 8 External linksHistory EditThe lambda calculus developed in the 1930s by Alonzo Church is a formal system of computation built from function application In 1937 Alan Turing proved that the lambda calculus and Turing machines are equivalent models of computation 36 showing that the lambda calculus is Turing complete Lambda calculus forms the basis of all functional programming languages An equivalent theoretical formulation combinatory logic was developed by Moses Schonfinkel and Haskell Curry in the 1920s and 1930s 37 Church later developed a weaker system the simply typed lambda calculus which extended the lambda calculus by assigning a type to all terms 38 This forms the basis for statically typed functional programming The first high level functional programming language LISP was developed in the late 1950s for the IBM 700 7000 series of scientific computers by John McCarthy while at Massachusetts Institute of Technology MIT 39 LISP functions were defined using Church s lambda notation extended with a label construct to allow recursive functions 40 Lisp first introduced many paradigmatic features of functional programming though early Lisps were multi paradigm languages and incorporated support for numerous programming styles as new paradigms evolved Later dialects such as Scheme and Clojure and offshoots such as Dylan and Julia sought to simplify and rationalise Lisp around a cleanly functional core while Common Lisp was designed to preserve and update the paradigmatic features of the numerous older dialects it replaced 41 Information Processing Language IPL 1956 is sometimes cited as the first computer based functional programming language 42 It is an assembly style language for manipulating lists of symbols It does have a notion of generator which amounts to a function that accepts a function as an argument and since it is an assembly level language code can be data so IPL can be regarded as having higher order functions However it relies heavily on the mutating list structure and similar imperative features Kenneth E Iverson developed APL in the early 1960s described in his 1962 book A Programming Language ISBN 9780471430148 APL was the primary influence on John Backus s FP In the early 1990s Iverson and Roger Hui created J In the mid 1990s Arthur Whitney who had previously worked with Iverson created K which is used commercially in financial industries along with its descendant Q In the mid 1960s Peter Landin invented SECD machine 43 the first abstract machine for a functional programming language 44 described a correspondence between ALGOL 60 and the lambda calculus 45 46 and proposed the ISWIM programming language 47 John Backus presented FP in his 1977 Turing Award lecture Can Programming Be Liberated From the von Neumann Style A Functional Style and its Algebra of Programs 48 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 citation needed Backus s paper popularized research into functional programming though it emphasized function level programming rather than the lambda calculus style now associated with functional programming The 1973 language ML was created by Robin Milner at the University of Edinburgh and David Turner developed the language SASL at the University of St Andrews Also in Edinburgh in the 1970s Burstall and Darlington developed the functional language NPL 49 NPL was based on Kleene Recursion Equations and was first introduced in their work on program transformation 50 Burstall MacQueen and Sannella then incorporated the polymorphic type checking from ML to produce the language Hope 51 ML eventually developed into several dialects the most common of which are now OCaml and Standard ML In the 1970s Guy L Steele and Gerald Jay Sussman developed Scheme as described in the Lambda Papers and the 1985 textbook Structure and Interpretation of Computer Programs Scheme was the first dialect of lisp to use lexical scoping and to require tail call optimization features that encourage functional programming In the 1980s Per Martin Lof developed intuitionistic type theory also called constructive type theory which associated functional programs with constructive proofs expressed as dependent types This led to new approaches to interactive theorem proving and has influenced the development of subsequent functional programming languages citation needed The lazy functional language Miranda developed by David Turner initially appeared in 1985 and had a strong influence on Haskell With Miranda being proprietary Haskell began with a consensus in 1987 to form an open standard for functional programming research implementation releases have been ongoing since 1990 More recently it has found use in niches such as parametric CAD in the OpenSCAD language built on the CGAL framework although its restriction on reassigning values all values are treated as constants has led to confusion among users who are unfamiliar with functional programming as a concept 52 Functional programming continues to be used in commercial settings 53 54 55 Concepts EditA number of concepts 56 and paradigms are specific to functional programming and generally foreign to imperative programming including object oriented programming However programming languages often cater to several programming paradigms so programmers using mostly imperative languages may have utilized some of these concepts 57 First class and higher order functions Edit Main articles First class function and Higher order function Higher order functions are functions that can either take other functions as arguments or return them as results In calculus an example of a higher order function is the differential operator d d x displaystyle d dx which returns the derivative of a function f displaystyle f 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 for 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 partial application or currying a technique that applies a function to its arguments one at a time with each application returning a new function that accepts the next argument This lets a programmer succinctly express for example the successor function as the addition operator partially applied to the natural number one Pure functions Edit Main article Pure function Pure functions or expressions have no side effects memory or I O 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 arguments that cause no side effects the result is constant with respect to that argument list sometimes called referential transparency or idempotence i e calling the pure function again with the same arguments returns the same result This can enable caching optimizations such as memoization If there is no data dependency between two pure expressions 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 optimizations 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 optimizations Fortran 95 also lets functions be designated pure 58 C 11 added constexpr keyword with similar semantics Recursion Edit Main article Recursion computer science Iteration looping in functional languages is usually accomplished via recursion Recursive functions invoke themselves letting an operation be repeated until it reaches the base case In general recursion requires maintaining a stack which consumes space in a linear amount to the depth of recursion This could make recursion prohibitively expensive to use instead of imperative loops However a special form of recursion known as tail recursion can be recognized and optimized by a compiler into the same code used to implement iteration in imperative languages Tail recursion optimization can be implemented by transforming the program into continuation passing style during compiling among other approaches The Scheme language standard requires implementations to support proper tail recursion meaning they must allow an unbounded number of active tail calls 59 60 Proper tail recursion is not simply an optimization it is a language feature that assures users that they can use recursion to express a loop and doing so would be safe for space 61 Moreover contrary to its name it accounts for all tail calls not just tail recursion While proper tail recursion is usually implemented by turning code into imperative loops implementations might implement it in other ways For example CHICKEN intentionally maintains a stack and lets the stack overflow However when this happens its garbage collector will claim space back 62 allowing an unbounded number of active tail calls even though it does not turn tail recursion into a loop Common patterns of recursion can be abstracted away using higher order functions with catamorphisms and anamorphisms or folds and unfolds being the most obvious examples Such recursion schemes 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 63 Strict versus non strict evaluation Edit Main article Evaluation strategy Functional languages can be categorized by whether they use strict eager or non strict lazy 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 fails For example the expression print length 2 1 3 2 1 0 5 4 fails under strict evaluation because of the division by zero in the third element of the list Under lazy evaluation the length function returns the value 4 i e the number of items in the list since evaluating it does not attempt to evaluate the terms making up the list In brief strict evaluation always fully evaluates function arguments before invoking the function Lazy evaluation does not evaluate function arguments unless their values are required to evaluate the function call itself The usual implementation strategy for lazy evaluation in functional languages is graph reduction 64 Lazy evaluation is used by default in several pure functional languages including Miranda Clean and Haskell Hughes 1984 argues for lazy evaluation as a mechanism for improving program modularity through separation of concerns by easing independent implementation of producers and consumers of data streams 2 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 65 Harper 2009 proposes including both strict and lazy evaluation in the same language using the language s type system to distinguish them 66 Type systems Edit Main article Type system Especially since the development of Hindley Milner type inference in the 1970s functional programming languages have tended to use typed lambda calculus rejecting all invalid programs at compilation time and risking false positive errors as opposed to the untyped lambda calculus that accepts all valid programs at compilation time and risks false negative errors used in Lisp and its variants such as Scheme as they reject all invalid programs at runtime when the information is enough to not reject valid programs The use of algebraic datatypes makes manipulation of complex data structures convenient the presence of strong compile time type checking makes programs more reliable in absence of other reliability techniques like test driven development while type inference frees the programmer from the need to manually declare types to the compiler in most cases Some research oriented functional languages such as Coq Agda Cayenne and Epigram are based on intuitionistic type theory which lets types 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 67 68 69 70 But dependent types can express arbitrary propositions in higher order 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 mainly 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 71 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 72 GADT s are available in the Glasgow Haskell Compiler in OCaml 73 and in Scala 74 and have been proposed as additions to other languages including Java and C 75 Referential transparency Edit Main article Referential transparency Functional programs do not have assignment statements that is the value of a variable in a functional program never changes once defined This eliminates any chances of side effects because any variable can be replaced with its actual value at any point of execution So functional programs are referentially transparent 76 Consider C assignment statement x x 10 this changes the value assigned to the variable x Let us say that the initial value of x was 1 then two consecutive evaluations of the variable x yields 10 and 100 respectively Clearly replacing x x 10 with either 10 or 100 gives a program a different meaning and so the expression is not referentially transparent In fact assignment statements are never referentially transparent Now consider another function such as span class kt int span span class w span span class nf plusone span span class p span span class kt int span span class w span span class n x span span class p span span class w span span class p span span class k return span span class w span span class n x span span class o span span class mi 1 span span class p span span class w span is transparent as it does not implicitly change the input x and thus has no such side effects Functional programs exclusively use this type of function and are therefore referentially transparent Data structures Edit Main article Purely functional data structure Purely functional data structures are often represented in a different way than their imperative counterparts 77 For example the array with constant access and update times is a basic component of most imperative languages and many imperative data structures such as the hash table and binary heap are based on arrays Arrays can be replaced by maps or random access lists which admit purely functional implementation but have logarithmic access and update times Purely functional data structures have persistence a property of keeping previous versions of the data structure unmodified In Clojure persistent data structures are used as functional alternatives to their imperative counterparts Persistent vectors for example use trees for partial updating Calling the insert method will result in some but not all nodes being created 78 Comparison to imperative programming EditFunctional 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 completely prevents side effects and provides referential transparency Higher order functions are rarely used in older imperative programming A traditional imperative program might use a loop to traverse and modify a list A functional program on the other hand would probably use a higher order map function that takes a function and a list generating and returning a new list by applying the function to each list item Imperative vs functional programming Edit The following two examples written in JavaScript achieve the same effect they multiply all even numbers in an array by 10 and add them all storing the final sum in the variable result Traditional Imperative Loop const numList 1 2 3 4 5 6 7 8 9 10 let result 0 for let i 0 i lt numList length i if numList i 2 0 result numList i 10 Functional Programming with higher order functions const result 1 2 3 4 5 6 7 8 9 10 filter n gt n 2 0 map a gt a 10 reduce a b gt a b Simulating state Edit 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 79 Monads 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 students find them difficult to understand conceptually e g when asked to define new monads which is sometimes needed for certain types of libraries 80 Functional languages also simulate states by passing around immutable states This can be done by making a function accept the state as one of its parameters and return a new state together with the result leaving the old state unchanged 81 Impure functional languages usually include a more direct method of managing mutable state Clojure for example uses managed references that can be updated by applying pure functions to the current state This kind of approach enables mutability while still promoting the use of pure functions as the preferred way to express computations citation needed 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 the presence of side effects explicit citation needed Efficiency issues Edit Functional programming languages are typically less efficient in their use of CPU and memory than imperative languages such as C and Pascal 82 This is related to the fact that some mutable data structures like arrays have a very straightforward implementation using present hardware Flat arrays may be accessed very efficiently with deeply pipelined CPUs prefetched efficiently through caches with no complex pointer chasing or handled with SIMD instructions It is also not easy to create their equally efficient general purpose immutable counterparts For purely functional languages the worst case slowdown is logarithmic in the number of memory cells used because mutable memory can be represented by a purely functional data structure with logarithmic access time such as a balanced tree 83 However such slowdowns are not universal For programs that perform intensive numerical computations functional languages such as OCaml and Clean are only slightly slower than C according to The Computer Language Benchmarks Game 84 For programs that handle large matrices and multidimensional databases array functional languages such as J and K were designed with speed optimizations Immutability of data can in many cases lead to execution efficiency by allowing the compiler to make assumptions that are unsafe in an imperative language thus increasing opportunities for inline expansion 85 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 if used improperly Launchbury 1993 65 discusses theoretical issues related to memory leaks from lazy evaluation and O Sullivan et al 2008 86 give some practical advice for analyzing and fixing them However the most general implementations of lazy evaluation making extensive use of dereferenced code and data perform poorly on modern processors with deep pipelines and multi level caches where a cache miss may cost hundreds of cycles citation needed Functional programming in non functional languages Edit It is possible to use a functional style of programming in languages that are not traditionally considered functional languages 87 For example both D 88 and Fortran 95 58 explicitly support pure functions JavaScript Lua 89 Python and Go 90 had first class functions from their inception 91 Python had support for lambda map reduce and filter in 1994 as well as closures in Python 2 2 92 though Python 3 relegated reduce to the functools standard library module 93 First class functions have been introduced into other mainstream languages such as PHP 5 3 Visual Basic 9 C 3 0 C 11 and Kotlin 27 citation needed In PHP anonymous classes closures and lambdas are fully supported Libraries and language extensions for immutable data structures are being developed to aid programming in the functional style In Java anonymous classes can sometimes be used to simulate closures 94 however anonymous classes are not always proper replacements to closures because they have more limited capabilities 95 Java 8 supports lambda expressions as a replacement for some anonymous classes 96 In C anonymous classes are not necessary because closures and lambdas are fully supported Libraries and language extensions for immutable data structures are being developed to aid programming in the functional style in C 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 Similarly the idea of immutable data from functional programming is often included in imperative programming languages 97 for example the tuple in Python which is an immutable array and Object freeze in JavaScript 98 Applications EditSpreadsheets Edit Spreadsheets can be considered a form of pure zeroth order strict evaluation functional programming system 99 However spreadsheets generally lack higher order functions as well as code reuse and in some implementations also lack recursion Several extensions have been developed for spreadsheet programs to enable higher order and reusable functions but so far remain primarily academic in nature 100 Academia Edit Functional programming is an active area of research in the field of programming language theory There are several peer reviewed publication venues focusing on functional programming including the International Conference on Functional Programming the Journal of Functional Programming and the Symposium on Trends in Functional Programming Industry Edit Functional programming has been employed in a wide range of industrial applications For example Erlang which was developed by the Swedish company Ericsson in the late 1980s was originally used to implement fault tolerant telecommunications systems 11 but has since become popular for building a range of applications at companies such as Nortel Facebook Electricite de France and WhatsApp 10 12 101 102 103 Scheme a dialect of Lisp was used as the basis for several applications on early Apple Macintosh computers 3 4 and has been applied to problems such as training simulation software 5 and telescope control 6 OCaml which was introduced in the mid 1990s has seen commercial use in areas such as financial analysis 14 driver verification industrial robot programming and static analysis of embedded software 15 Haskell though initially intended as a research language 17 has also been applied in areas such as aerospace systems hardware design and web programming 16 17 Other functional programming languages that have seen use in industry include Scala 104 F 18 19 Wolfram Language 7 Lisp 105 Standard ML 106 107 and Clojure 108 Functional platforms have been popular in finance for risk analytics particularly with large investment banks Risk factors are coded as functions that form interdependent graphs categories to measure correlations in market shifts similar in manner to Grobner basis optimizations but also for regulatory frameworks such as Comprehensive Capital Analysis and Review Given the use of OCaml and Caml variations in finance these systems are sometimes considered related to a categorical abstract machine Functional programming is heavily influenced by category theory citation needed Education Edit Many universities teach functional programming 109 110 111 112 Some treat it as an introductory programming concept 112 while others first teach imperative programming methods 111 113 Outside of computer science functional programming is used to teach problem solving algebraic and geometric concepts 114 It has also been used to teach classical mechanics as in the book Structure and Interpretation of Classical Mechanics See also Edit Computer programming portalPurely functional programming Comparison of programming paradigms Eager evaluation List of functional programming topics Nested function Inductive functional programming Functional reactive programmingReferences Edit 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 S2CID 207637854 a b Hughes John 1984 Why Functional Programming Matters a b Clinger Will 1987 MultiTasking and MacScheme MacTech 3 12 Retrieved 2008 08 28 a b Hartheimer Anne 1987 Programming a Text Editor in MacScheme Toolsmith MacTech 3 1 Archived from the original on 2011 06 29 Retrieved 2008 08 28 a b Kidd Eric Terrorism Response Training in Scheme CUFP 2007 Retrieved 2009 08 26 a b Cleis Richard Scheme in Space CUFP 2006 Retrieved 2009 08 26 a b Wolfram Language Guide Functional Programming 2015 Retrieved 2015 08 24 Functional vs Procedural Programming Language Department of Applied Math University of Colorado Archived from the original on 2007 11 13 State Based Scripting in Uncharted 2 PDF Archived from the original PDF on 2012 12 15 Retrieved 2011 08 08 a b Who uses Erlang for product development Frequently asked questions about Erlang Retrieved 2018 04 27 a b Armstrong Joe June 2007 A history of Erlang Proceedings of the third ACM SIGPLAN conference on History of programming languages Third ACM SIGPLAN Conference on History of Programming Languages San Diego California doi 10 1145 1238844 1238850 ISBN 9781595937667 a b Larson Jim March 2009 Erlang for concurrent programming Communications of the ACM 52 3 48 doi 10 1145 1467247 1467263 S2CID 524392 The Elixir Programming Language Retrieved 2021 02 14 a b Minsky Yaron Weeks Stephen July 2008 Caml Trading experiences with functional programming on Wall Street Journal of Functional Programming 18 4 553 564 doi 10 1017 S095679680800676X S2CID 30955392 Retrieved 2008 08 27 a b Leroy Xavier Some uses of Caml in Industry PDF CUFP 2007 Retrieved 2009 08 26 a b Haskell in industry Haskell Wiki Retrieved 2009 08 26 Haskell has a diverse range of use commercially from aerospace and defense to finance to web startups hardware design firms and lawnmower manufacturers a b c Hudak Paul Hughes J Jones S P Wadler P June 2007 A history of Haskell being lazy with class Third ACM SIGPLAN Conference on History of Programming Languages San Diego California doi 10 1145 1238844 1238856 Retrieved 2013 09 26 a b Mansell Howard 2008 Quantitative Finance in F CUFP 2008 Retrieved 2009 08 29 a b Peake Alex 2009 The First Substantial Line of Business Application in F CUFP 2009 Archived from the original on 2009 10 17 Retrieved 2009 08 29 comments 27 Jun 2017 Matt Banz Feed 603up 2 An introduction to functional programming in JavaScript Opensource com Retrieved 2021 01 09 The useR 2006 conference schedule includes papers on the commercial use of R R project org 2006 06 08 Retrieved 2011 06 20 Chambers John M 1998 Programming with Data A Guide to the S Language Springer Verlag pp 67 70 ISBN 978 0 387 98503 9 Novatchev Dimitre The Functional Programming Language XSLT A proof through examples Retrieved May 27 2006 Mertz David XML Programming Paradigms part four Functional Programming approached to XML processing IBM developerWorks Retrieved May 27 2006 Chamberlin Donald D Boyce Raymond F 1974 SEQUEL A structured English query language Proceedings of the 1974 ACM SIGFIDET 249 264 Functional Programming with C Simon Painter NDC Oslo 2020 archived from the original on 2021 10 30 retrieved 2021 10 23 a b Functional programming Kotlin Programming Language Kotlin Retrieved 2019 05 01 Dominus Mark J 2005 Higher Order Perl Morgan Kaufmann ISBN 978 1 55860 701 9 Holywell Simon 2014 Functional Programming in PHP php architect ISBN 9781940111056 The Cain Gang Ltd Python Metaclasses Who Why When PDF Archived from the original PDF on 30 May 2009 Retrieved 27 June 2009 GopherCon 2020 Dylan Meeus Functional Programming with Go YouTube com a href Template Cite web html title Template Cite web cite web a CS1 maint url status link Functional Language Features Iterators and Closures The Rust Programming Language doc rust lang org Retrieved 2021 01 09 Vanderbauwhede Wim Cleaner code with functional programming Archived from the original on 11 Sep 2020 Retrieved 6 October 2020 Effective Scala Scala Wiki Retrieved 2012 02 21 Effective Scala Documentation for package java util function since Java 8 also known as Java 1 8 Retrieved 2021 06 16 Turing A M 1937 Computability and l definability The Journal of Symbolic Logic Cambridge University Press 2 4 153 163 doi 10 2307 2268280 JSTOR 2268280 S2CID 2317046 Haskell Brooks Curry Robert Feys 1958 Combinatory Logic North Holland Publishing Company Retrieved 10 February 2013 Church A 1940 A Formulation of the Simple Theory of Types Journal of Symbolic Logic 5 2 56 68 doi 10 2307 2266170 JSTOR 2266170 S2CID 15889861 McCarthy John June 1978 History of Lisp PDF History of Programming Languages Los Angeles CA pp 173 185 doi 10 1145 800025 808387 John McCarthy 1960 Recursive functions of symbolic expressions and their computation by machine Part I PDF Communications of the ACM ACM New York NY USA 3 4 184 195 doi 10 1145 367177 367199 S2CID 1489409 Guy L Steele Richard P Gabriel February 1996 The Evolution of Lisp PDF In ACM SIGPLAN Second History of Programming Languages pp 233 330 doi 10 1145 234286 1057818 ISBN 978 0 201 89502 5 S2CID 47047140 The memoir of Herbert A Simon 1991 Models of My Life pp 189 190 ISBN 0 465 04640 1 claims that he Al Newell and Cliff Shaw are commonly adjudged to be the parents of the artificial intelligence field for writing Logic Theorist a program that proved theorems from Principia Mathematica automatically To accomplish this they had to invent a language and a paradigm that viewed retrospectively embeds functional programming Landin Peter J 1964 The mechanical evaluation of expressions The Computer Journal British Computer Society 6 4 308 320 doi 10 1093 comjnl 6 4 308 Diehl Stephan Hartel Pieter Sestoft Peter 2000 Abstract machines for programming language implementation Future Generation Computer Systems Vol 16 pp 739 751 Landin Peter J February 1965a Correspondence between ALGOL 60 and Church s Lambda notation part I Communications of the ACM Association for Computing Machinery 8 2 89 101 doi 10 1145 363744 363749 S2CID 6505810 Landin Peter J March 1965b A correspondence between ALGOL 60 and Church s Lambda notation part II Communications of the ACM Association for Computing Machinery 8 3 158 165 doi 10 1145 363791 363804 S2CID 15781851 Landin Peter J March 1966b The next 700 programming languages Communications of the ACM Association for Computing Machinery 9 3 157 166 doi 10 1145 365230 365257 S2CID 13409665 Backus J 1978 Can programming be liberated from the von Neumann style A functional style and its algebra of programs Communications of the ACM 21 8 613 641 doi 10 1145 359576 359579 R M Burstall Design considerations for a functional programming language Invited paper Proc Infotech State of the Art Conf The Software Revolution Copenhagen 45 57 1977 R M Burstall and J Darlington A transformation system for developing recursive programs Journal of the Association for Computing Machinery 24 1 44 67 1977 R M Burstall D B MacQueen and D T Sannella HOPE an experimental applicative language Proc 1980 LISP Conference Stanford 136 143 1980 Make discovering assign easier OpenSCAD Peter Bright March 13 2018 Developers love trendy new languages but earn more with functional programming Ars Technica John Leonard January 24 2017 The stealthy rise of functional programming Computing Leo Cheung May 9 2017 Is functional programming better for your startup InfoWorld Sean Tull Monoidal Categories for Formal Concept Analysis Pountain Dick Functional Programming Comes of Age BYTE com August 1994 Archived from the original on 2006 08 27 Retrieved August 31 2006 a b ISO IEC JTC 1 SC 22 WG5 N2137 International Organization for Standardization July 6 2017 a href Template Cite journal html title Template Cite journal cite journal a Cite journal requires journal help Revised 6 Report on the Algorithmic Language Scheme R6rs org Retrieved 2013 03 21 Revised 6 Report on the Algorithmic Language Scheme Rationale R6rs org Retrieved 2013 03 21 Clinger William 1998 Proper tail recursion and space efficiency Proceedings of the ACM SIGPLAN 1998 conference on Programming language design and implementation PLDI 98 pp 174 185 doi 10 1145 277650 277719 ISBN 0897919874 S2CID 16812984 Baker Henry 1994 CONS Should Not CONS Its Arguments Part II Cheney on the M T A Turner D A 2004 07 28 Total Functional Programming Journal of Universal Computer Science 10 7 751 768 doi 10 3217 jucs 010 07 0751 The Implementation of Functional Programming Languages Simon Peyton Jones published by Prentice Hall 1987 a b John Launchbury 1993 A Natural Semantics for Lazy Evaluation 144 154 CiteSeerX 10 1 1 35 2016 a href Template Cite journal html title Template Cite journal cite journal a Cite journal requires journal help Robert W Harper 2009 Practical Foundations for Programming Languages PDF Archived from the original PDF on 2016 04 07 Huet Gerard P 1973 The Undecidability of Unification in Third Order Logic Information and Control 22 3 257 267 doi 10 1016 s0019 9958 73 90301 x Huet Gerard Sep 1976 Resolution d Equations dans des Langages d Ordre 1 2 w Ph D in French Universite de Paris VII Huet Gerard 2002 Higher Order Unification 30 years later PDF In Carreno V Munoz C Tahar S eds Proceedings 15th International Conference TPHOL LNCS Vol 2410 Springer pp 3 12 Wells J B 1993 Typability and type checking in the second order lambda calculus are equivalent and undecidable Tech Rep 93 011 176 185 CiteSeerX 10 1 1 31 3590 Leroy Xavier 17 September 2018 The Compcert verified compiler Peyton Jones Simon Vytiniotis Dimitrios Weirich Stephanie Geoffrey Washburn April 2006 Simple unification based type inference for GADTs Icfp 2006 50 61 OCaml Manual caml inria fr Retrieved 2021 03 08 a href Template Cite web html title Template Cite web cite web a CS1 maint url status link Algebraic Data Types Scala Documentation Retrieved 2021 03 08 Kennedy Andrew Russo Claudio October 2005 Generalized Algebraic Data Types and Object Oriented Programming PDF OOPSLA San Diego California ISBN 9781595930316 Archived from the original PDF on 2006 12 29 source of citation Hughes John Why Functional Programming Matters PDF Chalmers University of Technology Purely functional data structures by Chris Okasaki Cambridge University Press 1998 ISBN 0 521 66350 4 L orange Jean Niklas polymatheia Understanding Clojure s Persistent Vector pt 1 Polymatheia Retrieved 2018 11 13 Michael Barr Charles Well Category theory for computer science Newbern J All About Monads A comprehensive guide to the theory and practice of monadic programming in Haskell Retrieved 2008 02 14 Thirteen ways of looking at a turtle fF for fun and profit Retrieved 2018 11 13 Paulson Larry C 28 June 1996 ML for the Working Programmer Cambridge University Press ISBN 978 0 521 56543 1 Retrieved 10 February 2013 Spiewak Daniel 26 August 2008 Implementing Persistent Vectors in Scala Code Commit Which programs are fastest Computer Language Benchmarks Game benchmarksgame alioth debian org Archived from the original on 2013 05 20 Retrieved 2011 06 20 Igor Pechtchanski Vivek Sarkar 2005 Immutability specification and its applications Concurrency and Computation Practice and Experience 17 5 6 639 662 doi 10 1002 cpe 853 S2CID 34527406 Chapter 25 Profiling and optimization Book realworldhaskell org Retrieved 2011 06 20 Hartel Pieter Henk Muller Hugh Glaser March 2004 The Functional C experience PDF Journal of Functional Programming 14 2 129 135 doi 10 1017 S0956796803004817 S2CID 32346900 David Mertz Functional programming in Python Part 3 IBM developerWorks Archived from the original on 2007 10 16 Retrieved 2006 09 17 Part 1 Part 2 Functions D Programming Language 2 0 Digital Mars 30 December 2012 Lua Unofficial FAQ uFAQ First Class Functions in Go The Go Programming Language golang org Retrieved 2021 01 04 Eich Brendan 3 April 2008 Popularity van Rossum Guido 2009 04 21 Origins of Python s Functional Features Retrieved 2012 09 27 functools Higher order functions and operations on callable objects Python Software Foundation 2011 07 31 Retrieved 2011 07 31 Skarsaune Martin 2008 The SICS Java Port Project Automatic Translation of a Large Object Oriented System from Smalltalk to Java Gosling James Closures James Gosling on the Java Road Oracle Archived from the original on 2013 04 14 Retrieved 11 May 2013 Williams Michael 8 April 2013 Java SE 8 Lambda Quick Start Bloch Joshua 2008 Item 15 Minimize Mutability Effective Java Second ed Addison Wesley ISBN 978 0321356680 Object freeze JavaScript MDN developer mozilla org Retrieved 2021 01 04 The Object freeze method freezes an object A frozen object can no longer be changed freezing an object prevents new properties from being added to it existing properties from being removed prevents changing the enumerability configurability or writability of existing properties and prevents the values of existing properties from being changed In addition freezing an object also prevents its prototype from being changed freeze returns the same object that was passed in a href Template Cite web html title Template Cite web cite web a CS1 maint url status link Wakeling David 2007 Spreadsheet functional programming PDF Journal of Functional Programming 17 1 131 143 doi 10 1017 S0956796806006186 ISSN 0956 7968 S2CID 29429059 Peyton Jones Simon Burnett Margaret Blackwell Alan March 2003 Improving the world s most popular functional language user defined functions in Excel Archived from the original on 2005 10 16 Piro Christopher 2009 Functional Programming at Facebook CUFP 2009 Archived from the original on 2009 10 17 Retrieved 2009 08 29 Sim Diasca a large scale discrete event concurrent simulation engine in Erlang November 2011 1 million is so 2011 Archived 2014 02 19 at the Wayback Machine WhatsApp blog 2012 01 06 the last important piece of our infrastracture is Erlang Momtahan Lee 2009 Scala at EDF Trading Implementing a Domain Specific Language for Derivative Pricing with Scala CUFP 2009 Archived from the original on 2009 10 17 Retrieved 2009 08 29 Graham Paul 2003 Beating the Averages Retrieved 2009 08 29 Sims Steve 2006 Building a Startup with Standard ML PDF CUFP 2006 Retrieved 2009 08 29 Laurikari Ville 2007 Functional Programming in Communications Security CUFP 2007 Retrieved 2009 08 29 Lorimer R J 19 January 2009 Live Production Clojure Application Announced InfoQ Functional Programming 2019 2020 University of Oxford Department of Computer Science Retrieved 28 April 2020 Programming I Haskell Imperial College London Department of Computing Retrieved 28 April 2020 a b Computer Science BSc Modules Retrieved 28 April 2020 a b Abelson Hal Sussman Gerald Jay 1985 Preface to the Second Edition Structure and Interpretation of Computer Programs 2 ed MIT Press John DeNero Fall 2019 Computer Science 61A Berkeley Department of Electrical Engineering and Computer Sciences Berkeley Retrieved 2020 08 14 Emmanuel Schanzer of Bootstrap interviewed on the TV show Triangulation on the TWiT tv networkFurther reading EditAbelson Hal Sussman Gerald Jay 1985 Structure and Interpretation of Computer Programs MIT Press 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 B Hindley J Roger Seldin Jonathan P 1972 Combinatory Logic Vol II Amsterdam North Holland ISBN 978 0 7204 2208 5 Dominus Mark Jason Higher Order Perl Morgan Kaufmann 2005 Felleisen Matthias Findler Robert Flatt Matthew Krishnamurthi Shriram 2001 How to Design Programs MIT Press Graham Paul ANSI Common LISP Englewood Cliffs New Jersey Prentice Hall 1996 MacLennan Bruce J Functional Programming Practice and Theory Addison Wesley 1990 Michaelson Greg 10 April 2013 An Introduction to Functional Programming Through Lambda Calculus Courier Corporation ISBN 978 0 486 28029 5 1 O Sullivan Brian Stewart Don Goerzen John 2008 Real World Haskell O Reilly Pratt Terrence W and Marvin Victor 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 External links EditListen to this article 28 minutes source source This audio file was created from a revision of this article dated 25 August 2011 2011 08 25 and does not reflect subsequent edits Audio help More spoken articles Ford Neal Functional thinking Retrieved 2021 11 10 Akhmechet Slava 2006 06 19 defmacro Functional Programming For The Rest of Us Retrieved 2013 02 24 An introduction Functional programming in Python by David Mertz part 1 part 2 part 3 Greg Michaelson s Homepage Mathematical and Computer Sciences Riccarton Edinburgh Heriot Watt University Retrieved 6 November 2022 Retrieved from https en wikipedia org w index php title Functional programming amp oldid 1134526432, wikipedia, wiki, book, books, library,

article

, read, download, free, free download, mp3, video, mp4, 3gp, jpg, jpeg, gif, png, picture, music, song, movie, book, game, games.