Functional programming

Listen to this article
Source: Wikipedia, the free encyclopedia.

In

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

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

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

mutable values.[26] In addition, many other programming languages support programming in a functional style or have implemented features from functional programming, such as C++11, C#,[27] Kotlin,[28] Perl,[29] PHP,[30] Python,[31] Go,[32] Rust,[33] Raku,[34] Scala,[35] and Java (since Java 8).[36]

Due to their composability, functional programming paradigms can be suitable for microservices-based architectures. [37]

History

The

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.[39]

Church later developed a weaker system, the

simply-typed lambda calculus, which extended the lambda calculus by assigning a data type to all terms.[40]
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).[41] Lisp functions were defined using Church's lambda notation, extended with a label construct to allow recursive functions.[42] 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.[43]

Information Processing Language (IPL), 1956, is sometimes cited as the first computer-based functional programming language.[44] 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.

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,[45] the first abstract machine for a functional programming language,[46] described a correspondence between ALGOL 60 and the lambda calculus,[47][48] and proposed the ISWIM programming language.[49]

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".[50] 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.[51] NPL was based on Kleene Recursion Equations and was first introduced in their work on program transformation.[52] Burstall, MacQueen and Sannella then incorporated the polymorphic type checking from ML to produce the language Hope.[53] ML eventually developed into several dialects, the most common of which are now OCaml and Standard ML.

In the 1970s,

tail-call optimization
, features that encourage functional programming.

In the 1980s,

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 as of 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.[54]

Functional programming continues to be used in commercial settings.[55][56][57]

Concepts

A number of concepts[58] 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.[59]

First-class and higher-order functions

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

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
    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

Fortran 95 also lets functions be designated pure.[60]
C++11 added constexpr keyword with similar semantics.

Recursion

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.[61][62] 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.[63] 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,[64] 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

imperative languages
.

Most general purpose functional programming languages allow unrestricted recursion and are

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.[65]

Strict versus non-strict evaluation

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.[66] 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.[67] Harper 2009 proposes including both strict and lazy evaluation in the same language, using the language's type system to distinguish them.[68]

Type systems

Especially since the development of

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 data types 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

Compcert is a compiler for a subset of the language C that is written in Coq and formally verified.[73]

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

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.[78]

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

Purely functional

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.[80]

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, 0);

Sometimes the abstractions offered by functional programming might lead to development of more robust code that avoids certain issues that might arise when building upon large amount of complex, imperative code, such as off-by-one errors (see Greenspun's tenth rule).

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.[81] 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).[82]

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.[83]

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.[84] 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).[85] 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.[86] 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.[87] Even if the involved copying that may seem implicit when dealing with persistent immutable data structures might seem computationally costly, some functional programming languages, like Clojure solve this issue by implementing mechanisms for safe memory sharing between formally immutable data.[88] Rust distinguishes itself by its approach to data immutability which involves immutable references[89] and a concept called lifetimes.[90]

Immutable data with separation of identity and state and shared-nothing schemes can also potentially be more well-suited for concurrent and parallel programming by the virtue of reducing or eliminating the risk of certain concurrency hazards, since concurrent operations are usually atomic and this allows eliminating the need for locks. This is how for example java.util.concurrent classes are implemented, where some of them are immutable variants of the corresponding classes that are not suitable for concurrent use.[91] Functional programming languages often have a concurrency model that instead of shared state and synchronization, leverages message passing mechanisms (such as the actor model, where each actor is a container for state, behavior, child actors and a message queue).[92][93] This approach is common in Erlang/Elixir or Akka.

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[67] discusses theoretical issues related to memory leaks from lazy evaluation, and O'Sullivan et al. 2008[94] 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].

Abstraction cost

Some functional programming languages might not optimize abstractions such as higher order functions like "map" or "filter" as efficiently as the underlying imperative operations. Consider, as an example, the following two ways to check if 5 is an even number in Clojure:

(even? 5)
(.equals (mod 5 2) 0)

When

Java VM
version 22 and Clojure version 1.11.1, the first implementation, which is implemented as:

(defn even?
  "Returns true if n is even, throws an exception if n is not an integer"
  {:added "1.0"
   :static true}
   [n] (if (integer? n)
        (zero? (bit-and (clojure.lang.RT/uncheckedLongCast n) 1))
        (throw (IllegalArgumentException. (str "Argument must be an integer: " n)))))

has the mean execution time of 4.76 ms, while the second one, in which .equals is a direct invocation of the underlying

inlining.[96]

One distinguishing feature of Rust are zero-cost abstractions. This means that using them imposes no additional runtime overhead. This is achieved thanks to the compiler using loop unrolling, where each iteration of a loop, be it imperative or using iterators, is converted into a standalone Assembly instruction, without the overhead of the loop controlling code. If an iterative operation writes to an array, the resulting array's elements will be stored in specific CPU registers, allowing for constant-time access at runtime.[97]

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.

Fortran 95[60]
explicitly support pure functions.

]

In PHP,

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;[105] however, anonymous classes are not always proper replacements to closures because they have more limited capabilities.[106] Java 8 supports lambda expressions as a replacement for some anonymous classes.[107]

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

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,[108] for example the tuple in Python, which is an immutable array, and Object.freeze() in JavaScript.[109]

Comparison to logic programming

Logic programming can be viewed as a generalisation of functional programming, in which functions are a special case of relations.[110] For example, the function, mother(X) = Y, (every X has only one mother Y) can be represented by the relation mother(X, Y). Whereas functions have a strict input-output pattern of arguments, relations can be queried with any pattern of inputs and outputs. Consider the following logic program:

mother(charles, elizabeth).
mother(harry, diana).

The program can be queried, like a functional program, to generate mothers from children:

?- mother(harry, X).
X = diana.
?- mother(charles, X).
X = elizabeth.

But it can also be queried backwards, to generate children:

?- mother(X, elizabeth).
X = charles.
?- mother(X, diana).
X = harry.

It can even be used to generate all instances of the mother relation:

?- mother(X, Y).
X = charles,
Y = elizabeth.
X = harry,
Y = diana.

Compared with relational syntax, functional syntax is a more compact notation for nested functions. For example, the definition of maternal grandmother in functional syntax can be written in the nested form:

maternal_grandmother(X) = mother(mother(X)).

The same definition in relational notation needs to be written in the unnested form:

maternal_grandmother(X, Y) :- mother(X, Z), mother(Z, Y).

Here :- means if and , means and.

However, the difference between the two representations is simply syntactic. In Ciao Prolog, relations can be nested, like functions in functional programming:[111]

grandparent(X) := parent(parent(X)).
parent(X) := mother(X).
parent(X) := father(X).

mother(charles) := elizabeth.
father(charles) := phillip.
mother(harry) := diana.
father(harry) := charles.

?- grandparent(X,Y).
X = harry,
Y = elizabeth.
X = harry,
Y = phillip.

Ciao transforms the function-like notation into relational form and executes the resulting logic program using the standard Prolog execution strategy.

Applications

Text editors

Emacs, a highly extensible text editor family uses its own Lisp dialect for writing plugins. The original author of the most popular Emacs implementation, GNU Emacs and Emacs Lisp, Richard Stallman considers Lisp one of his favorite programming languages.[112]

Helix, since version 24.03 supports previewing AST as S-expressions, which are also the core feature of the Lisp programming language family.[113]

Spreadsheets

Spreadsheets can be considered a form of pure, zeroth-order, strict-evaluation functional programming system.[114] 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.[115]

Academia

Functional programming is an active area of research in the field of

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,

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

Allegro (one of the biggest e-commerce platforms in Poland)[128]'s classified ads platform Allegro Lokalnie.[129]

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.[130][131][132][133] Some treat it as an introductory programming concept[133] while others first teach imperative programming methods.[132][134]

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

In particular, Scheme has been a relatively popular choice for teaching programming for years.[136][137]

See also

Notes and references

  1. S2CID 207637854. Archived from the original
    (PDF) on 2016-01-31. Retrieved 2013-08-10.
  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). "Programming a Text Editor in MacScheme+Toolsmith". 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. Archived from the original on 2010-12-21. Retrieved 2009-08-26.
  6. ^ a b Cleis, Richard. Scheme in Space. CUFP 2006. Archived from the original on 2010-05-27. Retrieved 2009-08-26.
  7. ^ a b "Wolfram Language Guide: Functional Programming". 2015. Retrieved 2015-08-24.
  8. ^ "Functional vs. Procedural Programming Language". Department of Applied Math. University of Colorado. Archived from the original on 2007-11-13. Retrieved 2006-08-28.
  9. ^ "State-Based Scripting in Uncharted 2" (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. ^ .
  12. ^ .
  13. ^ "The Elixir Programming Language". Retrieved 2021-02-14.
  14. ^
    S2CID 30955392.{{cite journal}}: CS1 maint: DOI inactive as of November 2024 (link
    )
  15. ^ a b Leroy, Xavier. Some uses of Caml in Industry (PDF). CUFP 2007. Archived from the original (PDF) on 2011-10-08. 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. ^ . Retrieved 2013-09-26.
  18. ^ a b Mansell, Howard (2008). Quantitative Finance in F#. CUFP 2008. Archived from the original on 2015-07-08. Retrieved 2009-08-29.
  19. ^ 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.
  20. ISSN 1611-3349
    .
  21. ^ Banz, Matt (2017-06-27). "An introduction to functional programming in JavaScript". Opensource.com. Retrieved 2021-01-09.
  22. ^ "The useR! 2006 conference schedule includes papers on the commercial use of R". R-project.org. 2006-06-08. Retrieved 2011-06-20.
  23. .
  24. ^ Novatchev, Dimitre. "The Functional Programming Language XSLT — A proof through examples". Retrieved May 27, 2006.
  25. ^ Mertz, David. "XML Programming Paradigms (part four): Functional Programming approached to XML processing". IBM developerWorks. Retrieved May 27, 2006.
  26. ^ Chamberlin, Donald D.; Boyce, Raymond F. (1974). "SEQUEL: A structured English query language". Proceedings of the 1974 ACM SIGFIDET: 249–264.
  27. ^ Functional Programming with C# - Simon Painter - NDC Oslo 2020, 8 August 2021, archived from the original on 2021-10-30, retrieved 2021-10-23
  28. ^ a b "Functional programming - Kotlin Programming Language". Kotlin. Retrieved 2019-05-01.
  29. .
  30. .
  31. ^ The Cain Gang Ltd. "Python Metaclasses: Who? Why? When?" (PDF). Archived from the original (PDF) on 30 May 2009. Retrieved 27 June 2009.
  32. ^ "GopherCon 2020: Dylan Meeus - Functional Programming with Go". YouTube. 22 December 2020.
  33. ^ "Functional Language Features: Iterators and Closures - The Rust Programming Language". doc.rust-lang.org. Retrieved 2021-01-09.
  34. ^ Vanderbauwhede, Wim (18 July 2020). "Cleaner code with functional programming". Archived from the original on 28 July 2020. Retrieved 6 October 2020.
  35. ^ "Effective Scala". Scala Wiki. Archived from the original on 2012-06-19. Retrieved 2012-02-21. Effective Scala.
  36. ^ "Documentation for package java.util.function since Java 8 (also known as Java 1.8)". Retrieved 2021-06-16.
  37. .
  38. .
  39. ^ Haskell Brooks Curry; Robert Feys (1958). Combinatory Logic. North-Holland Publishing Company. Retrieved 10 February 2013.
  40. S2CID 15889861
    .
  41. .
  42. .
  43. .
  44. 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.
  45. .
  46. ^ Diehl, Stephan; Hartel, Pieter; Sestoft, Peter (2000). "Abstract machines for programming language implementation". Future Generation Computer Systems. Vol. 16. pp. 739–751.
  47. S2CID 6505810
    .
  48. .
  49. .
  50. .
  51. ^ 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)
  52. ^ 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)
  53. ^ R.M. Burstall, D.B. MacQueen and D.T. Sannella. HOPE: an experimental applicative language. Proceedings 1980 LISP Conference, Stanford, 136–143 (1980).
  54. ^ "Make discovering assign() easier!". OpenSCAD. Archived from the original on 2023-04-19.
  55. ^ Peter Bright (March 13, 2018). "Developers love trendy new languages but earn more with functional programming". Ars Technica.
  56. ^ John Leonard (January 24, 2017). "The stealthy rise of functional programming". Computing.
  57. ^ Leo Cheung (May 9, 2017). "Is functional programming better for your startup?". InfoWorld.
  58. ^ Sean Tull - Monoidal Categories for Formal Concept Analysis.
  59. ^ Pountain, Dick. "Functional Programming Comes of Age". Byte (August 1994). Archived from the original on 2006-08-27. Retrieved August 31, 2006.
  60. ^ a b "ISO/IEC JTC 1/SC 22/WG5/N2137 – Fortran 2015 Committee Draft (J3/17-007r2)" (PDF). International Organization for Standardization. July 6, 2017. pp. 336–338.
  61. ^ "Revised^6 Report on the Algorithmic Language Scheme". R6rs.org. Retrieved 2013-03-21.
  62. ^ "Revised^6 Report on the Algorithmic Language Scheme - Rationale". R6rs.org. Retrieved 2013-03-21.
  63. S2CID 16812984
    .
  64. ^ Baker, Henry (1994). "CONS Should Not CONS Its Arguments, Part II: Cheney on the M.T.A." Archived from the original on 2006-03-03. Retrieved 2020-04-29.
  65. .
  66. ^ The Implementation of Functional Programming Languages. Simon Peyton Jones, published by Prentice Hall, 1987
  67. ^ .
  68. ^ Robert W. Harper (2009). Practical Foundations for Programming Languages (PDF). Archived from the original (PDF) on 2016-04-07.
  69. .
  70. ^ Huet, Gérard (Sep 1976). Resolution d'Equations dans des Langages d'Ordre 1,2,...ω (Ph.D.) (in French). Universite de Paris VII.
  71. ^ 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.
  72. CiteSeerX 10.1.1.31.3590
    .
  73. ^ Leroy, Xavier (17 September 2018). "The Compcert verified compiler".
  74. ^ Peyton Jones, Simon; Vytiniotis, Dimitrios; Weirich, Stephanie; Geoffrey Washburn (April 2006). "Simple unification-based type inference for GADTs". Icfp 2006: 50–61.
  75. ^ "OCaml Manual". caml.inria.fr. Retrieved 2021-03-08.
  76. ^ "Algebraic Data Types". Scala Documentation. Retrieved 2021-03-08.
  77. ISBN 9781595930316. Archived from the original
    on 2006-12-29.
  78. ^ Hughes, John. "Why Functional Programming Matters" (PDF). Chalmers University of Technology.
  79. ^ L’orange, Jean Niklas. "polymatheia - Understanding Clojure's Persistent Vector, pt. 1". Polymatheia. Retrieved 2018-11-13.
  80. ^ Michael Barr, Charles Well - Category theory for computer science.
  81. ^ Newbern, J. "All About Monads: A comprehensive guide to the theory and practice of monadic programming in Haskell". Retrieved 2008-02-14.
  82. ^ "Thirteen ways of looking at a turtle". fF# for fun and profit. Retrieved 2018-11-13.
  83. . Retrieved 10 February 2013.
  84. ^ Spiewak, Daniel (26 August 2008). "Implementing Persistent Vectors in Scala". Code Commit. Archived from the original on 23 September 2015. Retrieved 17 April 2012.
  85. ^ "Which programs are fastest? | Computer Language Benchmarks Game". benchmarksgame.alioth.debian.org. Archived from the original on 2013-05-20. Retrieved 2011-06-20.
  86. S2CID 34527406
    .
  87. ^ "An In-Depth Look at Clojure Collections". InfoQ. Retrieved 2024-04-29.
  88. ^ "References and Borrowing - The Rust Programming Language". doc.rust-lang.org. Retrieved 2024-04-29.
  89. ^ "Validating References with Lifetimes - The Rust Programming Language". doc.rust-lang.org. Retrieved 2024-04-29.
  90. ^ "Concurrent Collections (The Java™ Tutorials > Essential Java Classes > Concurrency)". docs.oracle.com. Retrieved 2024-04-29.
  91. ^ "Understanding The Actor Model To Build Non-blocking, High-throughput Distributed Systems - Scaleyourapp". scaleyourapp.com. 2023-01-28. Retrieved 2024-04-29.
  92. .
  93. ^ "Chapter 25. Profiling and optimization". Book.realworldhaskell.org. Retrieved 2011-06-20.
  94. ^ Berthe, Samuel (2024-04-29), samber/lo, retrieved 2024-04-29
  95. ^ "Go Wiki: Compiler And Runtime Optimizations - The Go Programming Language". go.dev. Retrieved 2024-04-29.
  96. ^ "Comparing Performance: Loops vs. Iterators - The Rust Programming Language". doc.rust-lang.org. Retrieved 2024-04-29.
  97. S2CID 32346900. Archived from the original (PDF) on 2011-07-19. Retrieved 2006-05-28.; 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
    )
  98. ^ "Functions — D Programming Language 2.0". Digital Mars. 30 December 2012.
  99. ^ "Lua Unofficial FAQ (uFAQ)".
  100. ^ "First-Class Functions in Go - The Go Programming Language". golang.org. Retrieved 2021-01-04.
  101. ^ Eich, Brendan (3 April 2008). "Popularity".
  102. ^ van Rossum, Guido (2009-04-21). "Origins of Python's "Functional" Features". Retrieved 2012-09-27.
  103. ^ "functools — Higher order functions and operations on callable objects". Python Software Foundation. 2011-07-31. Retrieved 2011-07-31.
  104. ^ Skarsaune, Martin (2008). The SICS Java Port Project Automatic Translation of a Large Object Oriented System from Smalltalk to Java.
  105. ^ Gosling, James. "Closures". James Gosling: on the Java Road. Oracle. Archived from the original on 2013-04-14. Retrieved 11 May 2013.
  106. ^ Williams, Michael (8 April 2013). "Java SE 8 Lambda Quick Start".
  107. .
  108. ^ "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.
  109. ^ Daniel Friedman; William Byrd; Oleg Kiselyov; Jason Hemann (2018). The Reasoned Schemer, Second Edition. The MIT Press.
  110. ^ A. Casas, D. Cabeza, M. V. Hermenegildo. A Syntactic Approach to Combining Functional Notation, Lazy Evaluation and Higher-Order in LP Systems. The 8th International Symposium on Functional and Logic Programming (FLOPS'06), pages 142-162, April 2006.
  111. ^ "How I do my Computing". stallman.org. Retrieved 2024-04-29.
  112. ^ "Helix". helix-editor.com. Retrieved 2024-04-29.
  113. S2CID 29429059
    .
  114. on 2005-10-16.
  115. ^ Piro, Christopher (2009). Functional Programming at Facebook. CUFP 2009. Archived from the original on 2009-10-17. Retrieved 2009-08-29.
  116. ^ "Sim-Diasca: a large-scale discrete event concurrent simulation engine in Erlang". November 2011.
  117. ^ 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"
  118. ^ 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.
  119. ^ Graham, Paul (2003). "Beating the Averages". Retrieved 2009-08-29.
  120. ^ Sims, Steve (2006). Building a Startup with Standard ML (PDF). CUFP 2006. Retrieved 2009-08-29.
  121. ^ Laurikari, Ville (2007). Functional Programming in Communications Security. CUFP 2007. Archived from the original on 2010-12-21. Retrieved 2009-08-29.
  122. ^ Lorimer, R. J. (19 January 2009). "Live Production Clojure Application Announced". InfoQ.
  123. .
  124. ^ "Why developers like ClojureScript". StackShare. Retrieved 2024-04-29.
  125. ^ Herrick, Justin (2024-04-29), jah2488/elm-companies, retrieved 2024-04-29
  126. ^ "Why developers like PureScript". StackShare. Retrieved 2024-04-29.
  127. ^ Team, Editorial (2019-01-08). "ALLEGRO - all you need to know about the best Polish online marketplace". E-commerce Germany News. Retrieved 2024-04-29.
  128. ^ "Websites using Phoenix Framework - Wappalyzer". www.wappalyzer.com. Retrieved 2024-04-29.
  129. ^ "Functional Programming: 2019-2020". University of Oxford Department of Computer Science. Retrieved 28 April 2020.
  130. ^ "Programming I (Haskell)". Imperial College London Department of Computing. Retrieved 28 April 2020.
  131. ^ a b "Computer Science BSc - Modules". Retrieved 28 April 2020.
  132. ^ a b Abelson, Hal; Sussman, Gerald Jay (1985). "Preface to the Second Edition". Structure and Interpretation of Computer Programs (2 ed.). MIT Press.
  133. ^ John DeNero (Fall 2019). "Computer Science 61A, Berkeley". Department of Electrical Engineering and Computer Sciences, Berkeley. Retrieved 2020-08-14.
  134. ^ Emmanuel Schanzer of Bootstrap interviewed on the TV show Triangulation on the TWiT.tv network
  135. ^ "Why Scheme for Introductory Programming?". home.adelphi.edu. Retrieved 2024-04-29.
  136. ^ Staff, IMACS (2011-06-03). "What Is Scheme & Why Is it Beneficial for Students?". IMACS – Making Better Thinkers for Life. Retrieved 2024-04-29.

Further reading

Listen to this article (28 minutes)
Spoken Wikipedia icon
Audio help · More spoken articles
)