In functional programming, functions are treated asfirst-class entities, meaning that they can be bound to names (including localidentifiers), passed asarguments, andreturned from other functions, just as any otherdata type can. This allows programs to be written in adeclarative andcomposable style, where small functions are combined in amodular manner.
Functional programming is sometimes treated as synonymous withpurely functional programming, a subset of functional programming that treats all functions asdeterministic mathematicalfunctions, orpure functions. When a pure function is called with some given arguments, it will always return the same result, and cannot be affected by any mutablestate or otherside effects. This is in contrast with impureprocedures, common inimperative 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 fewerbugs, be easier todebug andtest, and be more suited toformal verification.[1][2]
Church later developed a weaker system, thesimply typed lambda calculus, which extended the lambda calculus by assigning adata type to all terms.[39] This forms the basis for statically typed functional programming.
The firsthigh-level functional programming language,Lisp, was developed in the late 1950s for theIBM 700/7000 series of scientific computers byJohn McCarthy while atMassachusetts Institute of Technology (MIT).[40] Lisp functions were defined using Church's lambda notation, extended with a label construct to allowrecursive functions.[41] Lisp first introduced many paradigmatic features of functional programming, though early Lisps weremulti-paradigm languages, and incorporated support for numerous programming styles as new paradigms evolved. Later dialects, such asScheme andClojure, and offshoots such asDylan andJulia, sought to simplify and rationalise Lisp around a cleanly functional core, whileCommon Lisp was designed to preserve and update the paradigmatic features of the numerous older dialects it replaced.[42]
Information Processing Language (IPL), 1956, is sometimes cited as the first computer-based functional programming language.[43] It is anassembly-style language for manipulating lists of symbols. It does have a notion ofgenerator, which amounts to a function that accepts a function as an argument, and, since it is alow-level programming 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 developedAPL in the early 1960s, described in his 1962 bookA Programming Language (ISBN9780471430148). APL was the primary influence onJohn Backus'sFP. In the early 1990s, Iverson andRoger Hui createdJ. In the mid-1990s,Arthur Whitney, who had previously worked with Iverson, createdK, which is used commercially in financial industries along with its descendantQ.
John Backus presentedFP in his 1977Turing Award lecture "Can Programming Be Liberated From thevon Neumann Style? A Functional Style and its Algebra of Programs".[49] 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 theprinciple of compositionality.[citation needed] Backus's paper popularized research into functional programming, though it emphasizedfunction-level programming rather than the lambda-calculus style now associated with functional programming.
The lazy functional language,Miranda, developed by David Turner, initially appeared in 1985 and had a strong influence onHaskell. With Miranda being proprietary, Haskell began with a consensus in 1987 to form anopen standard for functional programming research; implementation releases have been ongoing as of 1990.
More recently it has found use in niches such as parametricCAD in theOpenSCAD language built on theCGAL 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.[53]
Functional programming continues to be used in commercial settings.[54][55][56]
A number of concepts[57] and paradigms are specific to functional programming, and generally foreign toimperative programming (includingobject-oriented programming). However, programming languages often cater to several programming paradigms, so programmers using "mostly imperative" languages may have utilized some of these concepts.[58]
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 thedifferential operator, which returns thederivative of a function.
Higher-order functions are closely related tofirst-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 enablepartial application orcurrying, 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, thesuccessor function as the addition operator partially applied to thenatural number one.
Pure functions (or expressions) have noside 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 calledreferential transparency oridempotence), i.e., calling the pure function again with the same arguments returns the same result. (This can enable caching optimizations such asmemoization.)
If there is no data dependency between two pure expressions, their order can be reversed, or they can be performed inparallel and they cannot interfere with one another (in other terms, the evaluation of any pure expression isthread-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, usingdeforestation).
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 asgcc, add extra keywords for a programmer to explicitly mark external functions as pure, to enable such optimizations.Fortran 95 also lets functions be designatedpure.[59] C++11 addedconstexpr keyword with similar semantics.
Iteration (looping) in functional languages is usually accomplished viarecursion.Recursive functions invoke themselves, letting an operation be repeated until it reaches thebase case. In general, recursion requires maintaining astack, 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 astail 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 intocontinuation passing style during compiling, among other approaches.
TheScheme language standard requires implementations to support proper tail recursion, meaning they must allow an unbounded number of active tail calls.[60][61] 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.[62] 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 thestack overflow. However, when this happens, itsgarbage collector will claim space back,[63] 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, withcatamorphisms andanamorphisms (or "folds" and "unfolds") being the most obvious examples. Such recursion schemes play a role analogous to built-in control structures such asloops inimperative languages.
Most general purpose functional programming languages allow unrestricted recursion and areTuring complete, which makes thehalting problemundecidable, can cause unsoundness ofequational reasoning, and generally requires the introduction ofinconsistency into the logic expressed by the language'stype system. Some special purpose languages such asRocq allow onlywell-founded recursion and arestrongly normalizing (nonterminating computations can be expressed only with infinite streams of values calledcodata). 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 calledtotal functional programming.[64]
Functional languages can be categorized by whether they usestrict (eager) ornon-strict (lazy) evaluation, concepts that refer to how function arguments are processed when an expression is being evaluated. The technical difference is in thedenotational semantics of expressions containing failing or divergent computations. Under strict evaluation, the evaluation of any term containing a failing subterm fails. For example, thePython statement:
print(len([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 isgraph reduction.[65] Lazy evaluation is used by default in several pure functional languages, includingMiranda,Clean, andHaskell.
Hughes 1984 argues for lazy evaluation as a mechanism for improving program modularity throughseparation 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 anoperational semantics to aid in such analysis.[66] Harper 2009 proposes including both strict and lazy evaluation in the same language, using the language's type system to distinguish them.[67]
Especially since the development ofHindley–Milner type inference in the 1970s, functional programming languages have tended to usetyped lambda calculus, rejecting all invalid programs at compilation time and riskingfalse positive errors, as opposed to theuntyped lambda calculus, that accepts all valid programs at compilation time and risksfalse negative errors, used in Lisp and its variants (such asScheme), as they reject all invalid programs at runtime when the information is enough to not reject valid programs. The use ofalgebraic 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 liketest-driven development, whiletype inference frees the programmer from the need to manually declare types to the compiler in most cases.
Some research-oriented functional languages such asRocq,Agda,Cayenne, andEpigram are based onintuitionistic type theory, which lets types depend on terms. Such types are calleddependent types. These type systems do not have decidable type inference and are difficult to understand and program with.[68][69][70][71] But dependent types can express arbitrary propositions inhigher-order logic. Through theCurry–Howard isomorphism, then, well-typed programs in these languages become a means of writing formalmathematical proofs from which a compiler can generatecertified code. While these languages are mainly of interest in academic research (including informalized mathematics), they have begun to be used in engineering as well.Compcert is acompiler for a subset of the languageC that is written inRocq and formally verified.[72]
A limited form of dependent types calledgeneralized 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.[73] GADT's are available in theGlasgow Haskell Compiler, inOCaml[74] and inScala,[75] and have been proposed as additions to other languages including Java and C#.[76]
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.[77]
ConsiderC assignment statementx = x * 10, this changes the value assigned to the variablex. Let us say that the initial value ofx was1, then two consecutive evaluations of the variablex yields10 and100 respectively. Clearly, replacingx = x * 10 with either10 or100 gives a program a different meaning, and so the expressionis not referentially transparent. In fact, assignment statements are never referentially transparent.
Now, consider another function such asintplusOne(intx){returnx+1;}is transparent, as it does not implicitly change the input x and thus has no suchside effects.Functional programs exclusively use this type of function and are therefore referentially transparent.
Purely functionaldata structures are often represented in a different way to theirimperative counterparts.[78] For example, thearray with constant access and update times is a basic component of most imperative languages, and many imperative data-structures, such as thehash table andbinary heap, are based on arrays. Arrays can be replaced bymaps or random access lists, which admit purely functional implementation, but havelogarithmic access and update times. Purely functional data structures havepersistence, 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.[79]
Functional programming is very different fromimperative programming. The most significant differences stem from the fact that functional programming avoidsside 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.
The following two examples (written inJava) achieve the same effect: they multiply all even numbers in an array by 10 and add them all, storing the final sum in the variableresult.
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 asoff-by-one errors (seeGreenspun's tenth rule).
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 languageHaskell implements them usingmonads, derived fromcategory theory.[80] 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).[81]
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.[82]
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 asHoare logic anduniqueness have been developed to track side effects in programs. Some modern research languages useeffect systems to make the presence of side effects explicit.[83]
Functional programming languages are typically less efficient in their use ofCPU and memory than imperative languages such asC andPascal.[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 complexpointer 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 asOCaml andClean are only slightly slower than C according toThe Computer Language Benchmarks Game.[86] For programs that handle largematrices and multidimensionaldatabases,array functional languages (such asJ andK) 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 forinline 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, likeClojure solve this issue by implementing mechanisms for safe memory sharing betweenformallyimmutable data.[88]Rust distinguishes itself by its approach to data immutability which involves immutablereferences[89] and a concept calledlifetimes.[90]
Immutable data with separation of identity and state andshared-nothing schemes can also potentially be more well-suited forconcurrent and parallel programming by the virtue of reducing or eliminating the risk of certain concurrency hazards, since concurrent operations are usuallyatomic and this allows eliminating the need for locks. This is how for examplejava.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, leveragesmessage passing mechanisms (such as theactor model, where each actor is a container for state, behavior, child actors and a message queue).[92][93] This approach is common inErlang/Elixir orAkka.
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 introducememory leaks if used improperly). Launchbury 1993[66] discusses theoretical issues related to memory leaks from lazy evaluation, and O'Sullivanet 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].
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 inClojure:
(defneven?"Returns true if n is even, throws an exception if n is not an integer"{:added"1.0":statictrue}[n](if(integer?n)(zero?(bit-and(clojure.lang.RT/uncheckedLongCastn)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 underlyingJava method, has a mean execution time of 2.8 μs – roughly 1700 times faster. Part of that can be attributed to the type checking and exception handling involved in the implementation ofeven?. For instance thelo library forGo, which implements various higher-order functions common in functional programming languages usinggenerics. In a benchmark provided by the library's author, callingmap is 4% slower than an equivalentfor loop and has the sameallocation profile,[95] which can be attributed to various compiler optimizations, such asinlining.[96]
One distinguishing feature ofRust arezero-cost abstractions. This means that using them imposes no additional runtime overhead. This is achieved thanks to the compiler usingloop unrolling, where each iteration of a loop, be it imperative or using iterators, is converted into a standaloneAssembly instruction, without the overhead of the loop controlling code. If an iterative operation writes to an array, the resulting array's elementswill be stored in specific CPU registers, allowing forconstant-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.[98] For example, bothD[99] andFortran 95[59] explicitly support pure functions.
In Perl,lambda,map,reduce,filter, andclosures are fully supported and frequently used. The bookHigher-Order Perl, released in 2005, was written to provide an expansive guide on using Perl for functional programming.
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.
InJava, 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]
InC#, 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#.
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]
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:
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:
However, the difference between the two representations is simply syntactic. InCiao Prolog, relations can be nested, like functions in functional programming:[111]
Emacs, a highly extensible text editor family uses its ownLisp 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]
Spreadsheets can be considered a form of pure,zeroth-order, strict-evaluation functional programming system.[113] 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.[114]
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 toGröbner basis optimizations but also for regulatory frameworks such asComprehensive Capital Analysis and Review. Given the use of OCaml andCaml variations in finance, these systems are sometimes considered related to acategorical abstract machine. Functional programming is heavily influenced bycategory theory.[citation needed]
Manyuniversities 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 bookStructure and Interpretation of Classical Mechanics.
In particular,Scheme has been a relatively popular choice for teaching programming for years.[136][137]
^abArmstrong, 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.ISBN9781595937667.
^ab"Haskell in industry".Haskell Wiki. Retrieved2009-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.
^de Moura, Leonardo; Ullrich, Sebastian (July 2021). "The Lean 4 Theorem Prover and Programming Language".Lecture Notes in Artificial Intelligence. Conference on Automated Deduction. Vol. 12699. pp. 625–635.doi:10.1007/978-3-030-79876-5_37.ISSN1611-3349.
^Turing, A. M. (1937). "Computability and λ-definability".The Journal of Symbolic Logic.2 (4). Cambridge University Press:153–163.doi:10.2307/2268280.JSTOR2268280.S2CID2317046.
^Haskell Brooks Curry; Robert Feys (1958).Combinatory Logic. North-Holland Publishing Company. Retrieved10 February 2013.
^The memoir ofHerbert A. Simon (1991),Models of My Life pp.189-190ISBN0-465-04640-1 claims that he, Al Newell, and Cliff Shaw are "...commonly adjudged to be the parents of [the] artificial intelligence [field]," for writingLogic Theorist, a program that proved theorems fromPrincipia Mathematica automatically. To accomplish this, they had to invent a language and a paradigm that, viewed retrospectively, embeds functional programming.
^Diehl, Stephan; Hartel, Pieter; Sestoft, Peter (2000). "Abstract machines for programming language implementation".Future Generation Computer Systems. Vol. 16. pp. 739–751.
^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. Proceedings 1980 LISP Conference, Stanford, 136–143 (1980).
^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.ISBN0897919874.S2CID16812984.
^abLaunchbury, John (March 1993).A Natural Semantics for Lazy Evaluation. Symposium on Principles of Programming Languages. Charleston, South Carolina:ACM. pp. 144–154.doi:10.1145/158511.158618.
^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.
^Huet, Gérard (Sep 1976).Resolution d'Equations dans des Langages d'Ordre 1,2,...ω (Ph.D.) (in French). Universite de Paris VII.
^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.
^Wells, J. B. (1993). "Typability and type checking in the second-order lambda-calculus are equivalent and undecidable".Tech. Rep. 93-011:176–185.CiteSeerX10.1.1.31.3590.
^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.S2CID34527406.
^Cesarini, Francesco; Thompson, Simon (2009).Erlang programming: a concurrent approach to software development (1st ed.). O'Reilly Media, Inc. (published 2009-06-11). p. 6.ISBN978-0-596-55585-6.
^"Object.freeze() - JavaScript | MDN".developer.mozilla.org. Retrieved2021-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.
^Daniel Friedman; William Byrd; Oleg Kiselyov; Jason Hemann (2018).The Reasoned Schemer, Second Edition. The MIT Press.
^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.
Felleisen, Matthias; Findler, Robert; Flatt, Matthew; Krishnamurthi, Shriram (2018).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.ISBN978-0-486-28029-5.
O'Sullivan, Brian; Stewart, Don; Goerzen, John (2008).Real World Haskell. O'Reilly.
Pratt, Terrence W. andMarvin 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.
