Functional programming is a programming paradigm that treats computation as the evaluation of mathematical functions and avoids state and mutable data. It emphasizes the application of functions, in contrast with the imperative programming style that emphasizes changes in state.^[1] A programming paradigm is a paradigmatic style of programming (compare with a methodology, which is a paradigmatic style of doing software engineering). ... Look up computation in Wiktionary, the free dictionary. ... Graph of example function, The mathematical concept of a function expresses the intuitive idea of deterministic dependence between two quantities, one of which is viewed as primary (the independent variable, argument of the function, or its input) and the other as secondary (the value of the function, or output). A... One of the key concepts in computer programming is the idea of state, essentially a snapshot of the measure of various conditions in the system. ... In computer science, an immutable object, as opposed to a mutable object, is a kind of object whose internal states cannot be modified after it is created. ... In computer science, imperative programming, as opposed to declarative programming, is a programming paradigm that describes computation in terms of a program state and statements that change the program state. ...

Functional languages include APL, Clean, Erlang, Haskell, Lisp, ML, Oz, F# and Scheme. APL (for A Programming Language) is an array programming language based on a notation invented in 1957 by Kenneth E. Iverson while at Harvard University. ... In computer science, Clean is a general-purpose purely functional computer programming language. ... Erlang is a general-purpose concurrent programming language and runtime system. ... Haskell is a standardized purely functional programming language with non-strict semantics, named after the logician Haskell Curry. ... “LISP” redirects here. ... ML is a general-purpose functional programming language developed by Robin Milner and others in the late 1970s at the University of Edinburgh, whose syntax is inspired by ISWIM. Historically, ML stands for metalanguage as it was conceived to develop proof tactics in the LCF theorem prover (the language of... Oz is a multiparadigm programming language, developed in the Programming Systems Lab at Saarland University. ... F# (pronounced F sharp) is a functional and object oriented programming language for the Microsoft . ... Scheme is a multi-paradigm programming language. ...

Functional programming languages, especially purely functional ones, have largely been emphasized in academia rather than in commercial software development. However, notable functional programming languages used in industry and commercial applications include Erlang (concurrent applications),^[2] R (statistics),^[3] Mathematica (symbolic math),^[4] Haskell, ML,^[5] J and K (financial analysis), and domain-specific programming languages like XSLT.^[6][7] Programming redirects here. ... Purely functional is a term in computing used to describe algorithms, data structures or programming languages that exclude destructive modifications (updates). ... Plato is credited with the inception of academia: the body of knowledge, its development and transmission across generations. ... Erlang is a general-purpose concurrent programming language and runtime system. ... Screenshot of Mac OS X RAqua desktop The R programming language, sometimes described as GNU S, is a programming language and software environment for statistical computing and graphics. ... For other uses, see Mathematica (disambiguation). ... Haskell is a standardized purely functional programming language with non-strict semantics, named after the logician Haskell Curry. ... ML is a general-purpose functional programming language developed by Robin Milner and others in the late 1970s at the University of Edinburgh, whose syntax is inspired by ISWIM. Historically, ML stands for metalanguage as it was conceived to develop proof tactics in the LCF theorem prover (the language of... The J programming language, developed in the early 1990s by Ken Iverson and Roger Hui, is a synthesis of APL (also by Iverson) and the FP and FL function-level languages created by John Backus. ... K is a proprietary array processing language developed by Arthur Whitney and commercialized by Kx Systems. ... A domain-specific programming language (domain-specific language, DSL) is a programming language designed to be useful for a specific set of tasks. ... ...

The lambda calculus provides the model for functional programming. Modern functional languages can be viewed as embellishments to the lambda calculus.^[8] The lambda calculus is a formal system designed to investigate function definition, function application, and recursion. ...

History

Lambda calculus provides a theoretical framework for describing functions and their evaluation. Though it is a mathematical abstraction rather than a programming language, it forms the basis of almost all functional programming languages today. The lambda calculus is a formal system designed to investigate function definition, function application, and recursion. ...

Combinatory logic is an equivalent theoretical foundation, developed by Moses Schönfinkel and Haskell Curry. It was originally developed to achieve a clearer approach to the foundations of mathematics.^[9] Combinatory logic is commonly perceived as more abstract than lambda calculus and preceded it in invention. Not to be confused with combinational logic, a topic in digital electronics. ... Moses Schönfinkel, also known as Moisei Isaievich Sheinfinkel Шейнфинкель (September 4, 1889 Ekaterinoslav (now Dnipropetrovsk, Ukraine) – 1942, Moscow) was a Jewish/Soviet logician and mathematician. ... Haskell Brooks Curry (September 12, 1900, Millis, Massachusetts - September 1, 1982, State College, Pennsylvania) was an American mathematician and logician. ... The lambda calculus is a formal system designed to investigate function definition, function application, and recursion. ...

An early functional-flavored language was LISP, developed by John McCarthy while at MIT for the IBM 700/7000 series scientific computers in the late 1950s.^[10] LISP introduced many features now found in functional languages, though LISP is technically a multi-paradigm language. Scheme and Dylan were later attempts to simplify and improve LISP. Lisp is a family of computer programming languages with a long history and a distinctive fully-parenthesized syntax. ... John McCarthy (born September 4, 1927, in Boston, Massachusetts, sometimes known affectionately as Uncle John McCarthy), is a prominent computer scientist who received the Turing Award in 1971 for his major contributions to the field of Artificial Intelligence. ... “MIT” redirects here. ... The IBM 700/7000 series was a series of incompatible large scale (mainframe) computer systems made by IBM through the 1950s and early 1960s. ... Scheme is a multi-paradigm programming language. ... The Dylan programming language (pronounced , like the name) is functional, object-oriented, reflective and dynamic. ...

Information Processing Language (IPL) is sometimes cited as the first computer-based functional programming language. It is an assembly-style language for manipulating lists of symbols. It does have a notion of "generator", which amounts to a function accepting a function as an argument, and, since it is an assembly-level language, code can be used as data, so IPL can be regarded as having higher-order functions. However, it relies heavily on mutating list structure and similar imperative features. Information Processing Language (IPL) is a programming language developed by Allen Newell, Cliff Shaw, and Herbert Simon at RAND Corporation and the Carnegie Institute of Technology from about 1956. ...

Kenneth E. Iverson developed the APL programming language in the early 1960s, described in his 1962 book "A Programming Language." APL was the primary influence on John Backus's FP programming language. In the early 1990s, Iverson and Roger Hui created a successor to APL, the J programming language. In the mid 1990s, Arthur Whitney, who had previously worked with Iverson, created the K programming language, which is used commercially in financial industries. Kenneth Eugene Iverson (17 December 1920, Camrose, Alberta, Canada – 19 October 2004, Toronto, Ontario, Canada) was a computer scientist most notable for developing the APL programming language in 1957. ... APL (for A Programming Language) is an array programming language based on a notation invented in 1957 by Kenneth E. Iverson while at Harvard University. ... John Backus (born December 3, 1924) is an American computer scientist, notable as the inventor of the first high-level programming language (FORTRAN), the Backus-Naur form (BNF, the almost universally used notation to define formal language syntax), and the concept of Function-level programming. ... FP (short for Function Programming) is a programming language created by John Backus to support the Function-level programming paradigm. ... Roger Hui was co-developer of the J Programming Language. ... The J programming language, developed in the early 1990s by Ken Iverson and Roger Hui, is a synthesis of APL (also by Iverson) and the FP and FL functional programming languages created by John Backus (of FORTRAN, ALGOL, and BNF fame). ... Arthur Whitney is a computer scientist most notable for developing the K programming language. ... K is a high level array programming language developed by Arthur Whitney, an influential APL programmer. ...

John Backus presented the FP programming language in his 1977 Turing Award lecture Can Programming Be Liberated From the von Neumann Style? A Functional Style and its Algebra of Programs. He defines functional programs as being built up in a hierarchical way by means of "combining forms" that allow an "algebra of programs"; in modern language, this means that functional programs follow the principle of compositionality. Backus's paper popularized research into functional programming, though it emphasized function-level programming rather than the lambda-calculus style which has come to be associated with functional programming. John Backus (born December 3, 1924) is an American computer scientist, notable as the inventor of the first high-level programming language (FORTRAN), the Backus-Naur form (BNF, the almost universally used notation to define formal language syntax), and the concept of Function-level programming. ... FP (short for Function Programming) is a programming language created by John Backus to support the Function-level programming paradigm. ... The A.M. Turing Award is given annually by the Association for Computing Machinery to a person selected for contributions of a technical nature made to the computing community. ... In mathematics, semantics, and philosophy of language, the Principle of Compositionality is the principle that the meaning of a complex expression is determined by the meanings of its constituent expressions and the rules used to combine them. ... Function-level programming refers to one of the two contrasting programming paradigms identified by John Backus in his work on Programs as mathematical objects, the other being Value-level programming. ...

In the 1970s the ML programming language was created by Robin Milner at the University of Edinburgh, and David Turner developed the language Miranda at the University of Kent. ML eventually developed into several dialects, the most common of which are now Objective Caml and Standard ML. The Haskell programming language was released in the late 1980s in an attempt to gather together many ideas in functional programming research. ML is a general-purpose functional programming language developed by Robin Milner and others in the late 1970s at the University of Edinburgh, whose syntax is inspired by ISWIM. Historically, ML stands for metalanguage as it was conceived to develop proof tactics in the LCF theorem prover (the language of... Robin Milner is a prominent British computer scientist. ... The University of Edinburgh (Scottish Gaelic: ), founded in 1582,[4] is a renowned centre for teaching and research in Edinburgh, Scotland. ... David A. Turner is a prominent British computer scientist. ... Miranda is a non-strict purely functional programming language developed by Professor David Turner as a successor to his earlier programming languages SASL and KRC, using some concepts from ML and Hope. ... Affiliations University Alliance Association of Commonwealth Universities European University Association Website http://www. ... Objective Caml (OCaml) is the main implementation of the Caml programming language, created by Xavier Leroy, Jérôme Vouillon, Damien Doligez, Didier Rémy and others in 1996. ... Standard ML (SML) is a general-purpose, modular, functional programming language with compile-time type checking and type inference. ... Haskell is a standardized purely functional programming language with non-strict semantics, named after the logician Haskell Curry. ...

Concepts

A number of concepts and paradigms are specific to functional programming, and generally foreign to imperative programming (including object oriented programming). However, programming languages are often hybrids of several programming paradigms so programmers using "mostly imperative" languages may have utilized some of these concepts.^[11] Object-oriented programming (OOP) is a computer programming paradigm in which a software system is modeled as a set of objects that interact with each other. ...

Higher-order functions

Functions are higher-order when they can take other functions as arguments, and return them as results. (The derivative and antiderivative in calculus are examples of this.) This article is about derivatives and differentiation in mathematical calculus. ... In calculus, an antiderivative, primitive or indefinite integral of a function f is a function F whose derivative is equal to f, i. ... For other uses, see Calculus (disambiguation). ...

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

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

Pure functions

Purely functional programs have no side effects. This makes it easier to reason about their behavior. However, almost no programmers bother to write purely functional programs, since, by definition, a program with no side effects (one that accepts no input, produces no output, and interfaces with no external devices ) is formally equivalent to a program that does nothing; typically, purity is used to enforce a separation of concerns where one clearly-delineated section of the program does impure operations like I/O, and calls pure functions and libraries as needed to compute answers. Purely functional is a term in computing used to describe algorithms, data structures or programming languages that exclude destructive modifications (updates). ... In computer science, a function is said to produce a side effect if it modifies some state other than its return value. ... In computer science, separation of concerns (SoC) is the process of breaking a computer program into distinct features that overlap in functionality as little as possible. ...

For example, the result of applying a pure function to pure arguments does not depend on the order of evaluation. As a result, a language which has no impure functions (a "purely functional language," such as Haskell) may use call-by-need evaluation. However, not all functional languages are pure. The Lisp family of languages are not pure because they allow side-effects. Haskell is a standardized purely functional programming language with non-strict semantics, named after the logician Haskell Curry. ... In computer science, an evaluation strategy is a set of (usually deterministic) rules for determining the evaluation of expressions in a programming language. ...

Since pure functions do not modify shared variables, pure functions can be executed in parallel without interfering with one another. Pure functions are therefore thread-safe, which allow interpreters and compilers to use call-by-future evaluation. Thread-safety is a computer programming concept applicable to multi-threaded programs. ... In computer science, an evaluation strategy is a set of (usually deterministic) rules for determining the evaluation of expressions in a programming language. ...

Pure functional programming languages typically enforce referential transparency, which is the notion that 'equals can be substituted for equals': if two expressions have "equal" values (for some notion of equality), then one can be substituted for the other in any larger expression without affecting the result of the computation. For example, in Referential transparency is a property of parts of computer programs. ...

 y = f(x) * f(x); 

a compiler can factor out f(x) if it is pure, transforming the program to

 z = f(x); y = z * z; 

and eliminating the second evaluation of the (possibly costly) call to f(x). This optimization is called common subexpression elimination. In compiler theory, common subexpression elimination (CSE) is the practice of finding repeated redundant expression evaluations, and replacing them with a single computation assigned to a temporary variable. ...

However, if a function has side effects, the function call cannot be eliminated. Consider the following program fragment:

 y = random() * random(); 

The second call to random cannot be eliminated, because its return value may be different from that of the first call. Similarly,

 y = printf("x") * printf("x"); 

cannot be optimized away; even if printf returns the same value both times; failing to make the second call would result in different program output.

While most compilers for imperative programming languages detect pure functions, and perform common subexpression elimination for pure function calls, pre-compiled libraries generally do not expose this information, preventing calls to external functions from being optimized away. Some compilers, such as gcc, add extra keywords for a programmer to explicitly mark external functions as pure so that this optimization can be performed in the presence of precompiled libraries. Fortran 95 allows functions without side-effects to be designated "pure". The GNU Compiler Collection (usually shortened to GCC) is a set of programming language compilers produced by the GNU Project. ... Fortran (previously FORTRAN[1]) is a general-purpose[2], procedural,[3] imperative programming language that is especially suited to numeric computation and scientific computing. ...

Recursion

Iteration (looping) in functional languages is usually accomplished via recursion. Recursive functions invoke themselves, allowing an operation to be performed over and over. Recursion may require maintaining a stack, but tail recursion can be recognized and optimized by a compiler into the same code used to implement iteration in imperative languages. The Scheme programming language standard requires implementations to recognize and optimize tail recursion. The word iteration is sometimes used in everyday English with a meaning virtually identical to repetition. ... This article is about the concept of recursion. ... A common method of simplification is to divide a problem into subproblems of the same type. ... In computer science, tail recursion (or tail-end recursion) is a special case of recursion in which the last operation of the function is a recursive call. ... Scheme is a multi-paradigm programming language. ...

Common patterns of recursion can be factored out using higher order functions, catamorphisms and anamorphisms (or "folds" and "unfolds") being the most obvious examples. Such higher order functions play a role analogous to built-in control structures such as loops in imperative languages. The concept of a catamorphism is grounded in category theory, and has been applied to functional programming. ... For other uses, see Anamorphosis (disambiguation). ... // A loop is generally something that closes back on itself such as a circle or ring. ... In computer science, imperative programming, as opposed to declarative programming, is a programming paradigm that describes computation in terms of a program state and statements that change the program state. ...

Strict, non-strict and lazy evaluation

Functional languages can be categorized by whether they use strict or non-strict evaluation, concepts that refer to how function arguments are processed when an expression is being evaluated. To illustrate, consider the following two functions f and g:

 f(x) := x^2+x+1 g(x, y) := x+y 

The following expression can be evaluated in one of two ways.

 f(g(1, 4)) 

Evaluate the innermost function g first:

 f(g(1, 4)) → f(1+4) → f(5) → 5^2+5+1 → 31 

Or evaluate the outermost function f first:

 f(g(1, 4)) → g(1,4)^2+g(1,4)+1 → (1+4)^2+(1+4)+1 → 5^2+5+1 → 31 

The first case is an instance of strict evaluation: arguments to a function are evaluated before the function call; while the second case is an instance of non-strict evaluation where arguments are passed to the function unevaluated and the calling function determines when the arguments are to be evaluated.

Strict evaluation has efficiency advantages. An argument is evaluated once with strict evaluation, while it may be evaluated multiple times with non-strict evaluation, as can be seen in the above example where g(1,4) is evaluated twice. Also, strict evaluation is easier to implement since the arguments passed to a function are data values, whereas with non-strict evaluation arguments may be expressions, requiring some notion of closure. For these reasons, the earliest functional languages, such as Lisp, ISWIM and ML use strict evaluation. In computer science, a closure is a function that is evaluated in an environment containing one or more bound variables. ...

However there are reasons for preferring non-strict evaluation. Lambda calculus provides a stronger theoretic foundation for languages that employ non-strict evaluation.^[12] Also non-strict evaluation provides for a more expressive language. For example, it supports infinite data structures, such as a list of all prime numbers (such structures are of use when an indefinite but finite part of the structure is required).

The need for a more efficient form of non-strict evaluation led to the development of lazy evaluation, a type of non-strict evaluation, where the initial evaluation of an argument is shared throughout the evaluation sequence. Consequently an argument (such as g(1,4) in the above example) is never evaluated more than once. Lazy evaluation tends to be used by pure functional languages such as Miranda, Clean and Haskell; however many other more recent functional languages continue to use strict evaluation.^{[citation needed]} Miranda is a non-strict purely functional programming language developed by Professor David Turner as a successor to his earlier programming languages Sasl and KRC, using some concepts from ML and Hope. ... In computer science, Clean is a general-purpose purely functional computer programming language. ... Haskell is a standardized purely functional programming language with non-strict semantics, named after the logician Haskell Curry. ...

Functional programming in non-functional languages

It is possible to employ a functional style of programming in languages that are not traditionally considered functional languages.^[13] Some non-functional languages have borrowed features such as higher-order functions, and list comprehensions from functional programming languages. This makes it easier to adopt a functional style when using these languages. Functional constructs such as higher-order functions and lazy lists can be obtained in C++ via libraries.^[14] In C one can use function pointers to get some of the effects of higher-order functions, for example one can implement the common function map using function pointers. Widespread declarative domain specific languages like SQL and Lex/Yacc, while not always Turing-complete, use some elements of functional programming, especially in eschewing mutable values.^[15] In mathematics and computer science, higher-order functions are functions which can take other functions as arguments, and may also return functions as results. ... List comprehension is a programming language construct for list processing, analogous to the set-builder notation (set comprehension), that is, the mathematical notation such as the following: The earliest reference to the list comprehension notation is in Rod Burstall and John Darlingtons description of their programming language, NPL from... In many programming languages, map is the name of a higher-order function that applies a given function to a sequence of elements (such as a list) and returns a sequence of results. ... SQL (IPA: or ), commonly expanded as Structured Query Language, is a computer language designed for the retrieval and management of data in relational database management systems, database schema creation and modification, and database object access control management. ... lex is a program that generates lexical analyzers (scanners or lexers). Lex is commonly used with the yacc parser generator. ... yacc is a computer program that serves as the standard parser generator on Unix systems. ... In computability theory a programming language or any other logical system is called Turing-complete if it has a computational power equivalent to a universal Turing machine. ...

Comparison of functional and imperative programming

Functional programming is very different from imperative programming. The most significant differences stem from the fact that functional programming avoids side effects, which are used in imperative programming to implement state and I/O. Pure functional programming disallows side effects completely. Disallowing side effects provides for referential transparency, which makes it easier to verify, optimize, and parallelize programs, and easier to write automated tools to perform those tasks. In computer science, imperative programming, as opposed to declarative programming, is a programming paradigm that describes computation in terms of a program state and statements that change the program state. ... Referential transparency is a property of parts of computer programs. ...

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

Simulating state

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

The pure functional programming language Haskell implements them using monads, derived from category theory. Monads are powerful and offer an intuitive way to model state (and other side effects such as IO) in an imperative manner without losing purity. While existing monads are easy to use, many find it difficult to understand how to define new monads (which is sometimes needed for certain types of libraries).^[16] Wikibooks Haskell has a page on the topic of Understanding monads Some functional programming languages make use of monads[1] [2] to structure programs which include operations that must be executed in a specific order. ... In mathematics, category theory deals in an abstract way with mathematical structures and relationships between them. ...

Alternative methods such as Hoare logic and uniqueness have been developed to track side effects in programs. Some modern research languages use effect systems to make explicit the presence of side effects. The introduction to this article provides insufficient context for those unfamiliar with the subject matter. ... In computing, a unique type guarantees that an object is used in a single-threaded way, without duplicating references to it. ... An effect system is a formal system which describes the computational effects of computer programs, such as side effects. ...

Efficiency issues

Functional programming languages have automatic memory management with garbage collection, in contrast to older imperative languages like C and Pascal which use explicit memory management. Functional programming languages have been perceived as less efficient in their use of CPU and memory than those languages. However, many modern imperative languages such as Java, Perl, Python, and Ruby also perform automatic memory management. Memory management is the act of managing computer memory. ... In computer science, garbage collection (GC) is a form of automatic memory management. ... CPU redirects here. ...

Functional programming languages have become more efficient over the years. For programs which perform intensive numerical computations, functional languages such as OCaml and Clean are similar in speed to C. For programs that handle large matrices and multidimensional databases, array functional languages (such as J and K) were designed with speed optimization in mind. Objective Caml, also known as OCaml or OCaml for short, is an advanced programming language that is part of the ML family. ... In computer science, Clean is a general-purpose purely functional computer programming language. ... C is a general-purpose, block structured, procedural, imperative computer programming language developed in 1972 by Dennis Ritchie at the Bell Telephone Laboratories for use with the Unix operating system. ... In mathematics, a matrix (plural matrices) is a rectangular table of elements (or entries), which may be numbers or, more generally, any abstract quantities that can be added and multiplied. ... This article is about computing. ... Array programming languages (also known as vector or multidimensional languages) generalize operations on scalars to apply transparently to vectors, matrices, and higher dimensional arrays. ... The J programming language, developed in the early 1990s by Ken Iverson and Roger Hui, is a synthesis of APL (also by Iverson) and the FP and FL functional programming languages created by John Backus (of FORTRAN, ALGOL, and BNF fame). ... K is a high level array programming language developed by Arthur Whitney, an influential APL programmer. ...

Purely functional languages have a reputation for being slower than imperative languages. However, immutability of data can, in many cases, lead to execution efficiency in allowing the compiler to make assumptions that are unsafe in an imperative language. The worst-case slowdown was shown to be exponential.^[17] Situations where such slowdowns arise occur very rarely in practice. They do imply, however, that non-functional supersets of applicative languages are sometimes important.

Coding styles

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

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

In practice, Python programmers use its list comprehension syntax and write the following: In some programming languages, list comprehension is a syntactic construct for creating a list based on existing lists, analogous to the set-builder notation (set comprehension), that is, the mathematical notation such as the following: For an example, in Haskells list comprehension syntax, the example set-builder construct above...

 target = [F(G(x)) for x in source list] 

A functional version has a different feel to it:

 # functional style # FP-oriented languages often have standard compose() compose2 = lambda F, G: lambda x: F(G(x)) target = map(compose2(F,G), source_list) 

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

See also

Eager evaluation is the evaluation model in most traditional programming languages. ... Function-level programming refers to one of the two contrasting programming paradigms identified by John Backus in his work on Programs as mathematical objects, the other being Value-level programming. ... In computer science, imperative programming, as opposed to declarative programming, is a programming paradigm that describes computation in terms of a program state and statements that change the program state. ... The lambda calculus is a formal system designed to investigate function definition, function application, and recursion. ... This is a list of functional programming topics, by Wikipedia page. ... Logic programming (which might better be called logical programming by analogy with mathematical programming and linear programming) is, in its broadest sense, the use of mathematical logic for computer programming. ... A nested function is a function which can only be called from its parent function. ... This does not adequately cite its references or sources. ... Purely functional is a term in computing used to describe algorithms, data structures or programming languages that exclude destructive modifications (updates). ... Front cover Structure and Interpretation of Computer Programs (SICP) is a textbook published in 1985 about general computer programming concepts from MIT press written by Massachusetts Institute of Technology professors Harold Abelson and Gerald Jay Sussman, with Julie Sussman. ...

References

The Association for Computing Machinery, or ACM, was founded in 1947 as the worlds first scientific and educational computing society. ... Year 2007 (MMVII) is the current year, a common year starting on Monday of the Gregorian calendar and the AD/CE era in the 21st century. ... is the 217th day of the year (218th in leap years) in the Gregorian calendar. ... Year 2006 (MMVI) was a common year starting on Sunday of the Gregorian calendar. ... is the 240th day of the year (241st in leap years) in the Gregorian calendar. ... John McCarthy may be: Government: John McCarthy (1857–1943), American politician Science: John McCarthy (born 1927), American computer scientist John McCarthy (born 1953), American phonologist Sports: John McCarthy, Mixed martial arts referee Johnny McCarthy, a NBA player Johnny McCarthy, a MLB first baseman John McCarthy, a former Australian rules footballer... The Association for Computing Machinery, or ACM, was founded in 1947 as the worlds first scientific and educational computing society. ... Year 2006 (MMVI) was a common year starting on Sunday of the Gregorian calendar. ... is the 260th day of the year (261st in leap years) in the Gregorian calendar. ... Year 2006 (MMVI) was a common year starting on Sunday of the Gregorian calendar. ... is the 148th day of the year (149th in leap years) in the Gregorian calendar. ... Donald D. Chamberlin is best known as one of the principal designers of the original SQL language specification. ... Raymond ‘Ray’ Boyce grew up in New York, he went to college in Providence, Rhode Island and got his PhD in Purdue in 1971 [1] . After he left Purdue he worked on database projects for IBM in Yorktown Heights, New York. ... Year 2006 (MMVI) was a common year starting on Sunday of the Gregorian calendar. ... is the 147th day of the year (148th in leap years) in the Gregorian calendar. ...

Further reading

• Cousineau, Guy and Michel Mauny. The Functional Approach to Programming. Cambridge, UK: Cambridge University Press, 1998.
• Felleisen, Matthias, Robert Findler, Matthew Flatt, and Shriram Krishnamurthi. How to Design Programs HTDP. MIT Press. 2001. on-line
• Graham, Paul. ANSI Common LISP. Englewood Cliffs, New Jersey: Prentice Hall, 1996.
• Curry, Haskell Brooks and Feys, Robert and Craig, William. Combinatory Logic. Volume I. North-Holland Publishing Company, Amsterdam, 1958.
• Curry, Haskell Brooks and Hindley, J. Roger and Seldin, Jonathan P. Combinatory Logic. Volume II. North-Holland Publishing Company, Amsterdam * London, 1972.
• MacLennan, Bruce J. Functional Programming: Practice and Theory. Addison-Wesley, 1990.
• Pratt, Terrence, W. and Marvin V. Zelkowitz. Programming Languages: Design and Implementation. 3rd ed. Englewood Cliffs, New Jersey: Prentice Hall, 1996.
• Salus, Peter H. Functional and Logic Programming Languages. Vol. 4 of Handbook of Programming Languages. Indianapolis, Indiana: Macmillan Technical Publishing, 1998.
• Thompson, Simon. Haskell: The Craft of Functional Programming. Harlow, England: Addison-Wesley Longman Limited, 1996.

The headquarters of the Cambridge University Press, in Trumpington Street, Cambridge. ... Front cover How to Design Programs (HTDP) is a textbook from MIT Press on the systematic design of computer programs. ... Pearson can mean Pearson PLC the media conglomerate. ... Pearson can mean Pearson PLC the media conglomerate. ...

External links

• Why Functional Programming Matters by John Hughes
• Functional Programming for the Rest of Us An introduction
• "Functional Programming" — Chapter 4 of Advanced Programming Language Design by Raphael Finkel, an introductory explanation of functional programming
• Functional programming in Python (by David Mertz): part 1, part 2, part 3
• The Implementation of Functional Programming Languages Simon Peyton Jones, published by Prentice Hall, 1987.