Comparison of functional programming languages

Short description: none

The table shows a comparison of functional programming languages which compares various features and designs of different functional programming languages.

Name | Pure | Lazy evaluation | Typing | Abstract data types | Algebraic data types | Data is immutable | Type classes | Garbage collection | First appeared

|
|
|
|
|
|
|
|
|

Common Lisp | No[1] | Simulated with thunks[2] | Dynamic[3] | Yes[4] | Extension[5] | No[6] | ? | Yes | 1984
Scheme | No[7] | Yes[8] | Dynamic[7] | Yes[9] | Simulated with thunks[10] | No[11] | No | Yes | 1975
Racket | No | Default in Lazy Racket[12] | Strong, Dynamic, statically typed with gradual typing in Typed Racket[13] | Yes[14] | Yes, with Algebraic Racket[15] | Partial[16] | No | Yes | 1995
Clojure | No[17] | Yes[18] | Dynamic[19] | Yes[20] | Yes[21] | Yes[22] | No | Yes | 2007
Standard ML | No[23] | No[24][25] | Static[26] | Yes | Yes | Yes[27] | No | Yes | 1983
OCaml | No[28] | Yes[28] | Static[29] | Yes[30] | Yes[31] | Yes[32] | Simulated with parametric modules[33] | Yes | 1996
F# | No[34] | Yes[35] | Static[36] | Yes[37] | Yes[38] | Yes[39] | No | Yes | 2005
Haskell | Yes[40] | Default[41] | Static[42] | Yes[40] | Yes[43] | Yes[44] | Yes[45] | Yes | 1990
Scala | No[46] | Yes[47] | Static[46] | Yes[48] | Yes[48] | Yes[49] | Yes[50] | Yes | 2004
JavaScript | No | Extension[51] | Dynamic[52] | Extension[53] | Extension[54] | Partial[55][56] | ? | Yes | 1995
Clean | Yes[57] | Yes, with optional strictness annotations[58] | Static with uniqueness/optionally dynamic[59] | Yes[58] | Yes[58] | Yes, except for unique types[58] | Yes[58] | Yes | 1987
Miranda | Yes[60] | Default[61] | Static[60] | Yes[62] | Yes[60] | Yes | No | Yes | 1986
SASL | Yes[63] | Yes | Dynamic[64] | Yes | Yes | Yes | No | Yes | 1972
Elixir | No | Stream module[65] | Dynamic | Yes | No | Yes | ? | Yes | 2012
Erlang | No | No[66] | Dynamic | Yes[67] | No | Yes[68] | ? | Yes | 1986
Elm | Yes | No | Static[69] | ? | Yes[70] | Yes[69] | No | Yes | 2012
Futhark | Yes | No | Static[71] | Yes | Yes | Yes[69] | No | Yes | 2014
Python | No[72] | Simulated with generators | Dynamic[73] | Yes[74] | No | Partial[75] | ? | Yes | 1991
Idris | Yes[76] | Yes[76] | Static[76] | Yes[76] | Yes[76] | Yes[76] | Yes[76] | Yes | 2007
Nix | Yes[77] | Yes[77] | Dynamic[77] | No | Yes | Yes | No | Yes | 2003
Wolfram Language | No  | No  | Static  | Yes  | Yes  | Yes  | No  | Yes  | 1988
Kotlin | No  | Lazy delegation[78] and Sequence[79] | Static  | Yes  | No  | Yes  | No  | Yes  | 2011
Swift | No  | No  | Static  | Yes  | Yes  | Yes  | No  | Swift uses Automatic Reference Counting, which differs from tracing garbage collection but is designed to provide similar benefits with better performance.  | 2014
Julia | No  | No[80] | Dynamic[81] | Yes[81] | No  | Partial[81] | ?  | Yes  | 2012
PureScript | Yes  | No  | Static  | Yes  | Yes  | Yes  | Yes  | Yes  | 2013
Rust | No  | Lazy iterators[82] and external libraries[83] | Static[84] | Yes[85] | Yes[86] | Yes[87] | Yes, through traits[85] | No  | 2010
Bosque | No  | No  | Static  | Yes  | Yes  | Yes  | ?  | Yes  | 2019
D | Optional[88][89] | Optional[90] | Static[91] | ?  | Yes  | Yes[92] | No  | Yes[93] | 2001
Gleam | No[94] | Experimental external libraries | Static | Yes | Yes | Yes | No | Yes | 2019

## References

1. ↑ "LISP Introduction". http://www.math-cs.gordon.edu/courses/cps323/LISP/lisp.html.
2. ↑ Antoniotti, Marco. "CLAZY: Lazy Calling in Common Lisp". http://common-lisp.net/project/clazy/.
3. ↑ Tratt, Laurence (July 2009). "Dynamically Typed Languages". Advances in Computers 77: 149–184. doi:10.1016/s0065-2458(09)01205-4. http://tratt.net/laurie/research/pubs/html/tratt__dynamically_typed_languages/. Retrieved 26 November 2013.
4. ↑ "LISP Tutorial Lecture 3: Data Abstraction". http://www.cs.sfu.ca/CourseCentral/310/pwfong/Lisp/3/tutorial3.html.
5. ↑ "Algebraic data types in Common Lisp". https://github.com/stylewarning/cl-algebraic-data-type.
6. ↑ "Mutable Data Structures". http://caml.inria.fr/pub/docs/fpcl/fpcl-07.pdf.
7. ↑ 7.0 7.1 "Similar Functional Languages". http://caml.inria.fr/pub/docs/oreilly-book/html/book-ora202.html.
8. ↑ "(Scheme) 17. Lazy Evaluation". http://www.shido.info/lisp/scheme_lazy_e.html.
9. ↑ "Records - Revised6 Report on the Algorithmic Language Scheme". http://www.r6rs.org/final/html/r6rs-lib/r6rs-lib.html.
10. ↑ "Algebraic Data Types in Scheme". https://pavpanchekha.com/blog/adtscm.html.
11. ↑ "Programs with State". http://www.cs.uni.edu/~wallingf/teaching/cs3540/sessions/session26.html.
12. ↑ Barzilay, Eli. "Lazy Racket". https://docs.racket-lang.org/lazy/index.html.
13. ↑ Tobin-Hochstadt, Sam; St-Amour, Vincent; Dobson, Eric; Takikawa, Asumu. "Typed Racket". https://docs.racket-lang.org/ts-reference/index.html.
14. ↑ "The Racket Guide: Programmer-Defined Datatypes". https://docs.racket-lang.org/guide/define-struct.html.
15. ↑ Griffis, Eric. "Algebraic Racket". https://docs.racket-lang.org/algebraic/index.html.
16. ↑ Buttrick, Matthew. "Beautiful Racket: Data Structures". https://beautifulracket.com/explainer/data-structures.html.
17. ↑ "Clojure Functional Programing". http://clojure.org/functional_programming.
18. ↑ "Clojure - lazy". http://clojure.org/lazy.
19. ↑ "Exploring clojure: dynamic typing". 7 December 2012. http://tgoossens.wordpress.com/2012/12/07/dynamically-exploring-clojure/.
20. ↑ Engelberg, Mark (21 April 2009). "Thoughts On Programming". http://programming-puzzler.blogspot.com/2009/04/adts-in-clojure.html.
21. ↑ "clojure-contrib, typing example". https://code.google.com/p/clojure-contrib/source/browse/trunk/src/clojure/contrib/types/examples.clj?spec=svn596&r=596.
22. ↑ "clojure: functional programming overview". http://clojure.org/functional_programming.
23. ↑ "Introduction to Functional Programming". http://www.cl.cam.ac.uk/~jrh13/slides/funprog-jrh/l8.pdf.
24. ↑ "Lazy and Eager Evaluation". http://homepages.inf.ed.ac.uk/dts/fps/lecture-notes/lazy.pdf.
25. ↑ Harper, MacQueen, Milner. "Standard ML". Section 3.6. http://www.lfcs.inf.ed.ac.uk/reports/86/ECS-LFCS-86-2/ECS-LFCS-86-2.pdf.
26. ↑ Wikibooks:Standard ML Programming/Types
27. ↑ "Mutable and optional data". http://courses.cs.washington.edu/courses/cse341/04wi/lectures/08-ml-refs.html.
28. ↑ 28.0 28.1 "Functional Programming – OCaml". http://ocaml.org/learn/tutorials/functional_programming.html.
29. ↑ Hickey, Jason. "Introduction to Objective Caml". Section 2.4. Cambridge University Press. http://files.metaprl.org/doc/ocaml-book.pdf.
30. ↑ "Type and exception definitions". http://caml.inria.fr/pub/docs/manual-ocaml-4.00/manual016.html.
31. ↑ "Learn OCaml - Data Types". http://ocaml.org/learn/description.html#DataTypes.
32. ↑ "Learn OCaml - Imperative Features". http://ocaml.org/learn/description.html#Imperativefeatures.
33. ↑ "Implementing Type-Classes as OCaml Modules". https://accu.org/index.php/journals/2445.
34. ↑ "Learning F#". http://fsharpforfunandprofit.com/learning-fsharp/.
35. ↑ "Lazy Computations (F#)". Microsoft Developer Network. http://msdn.microsoft.com/en-us/library/vstudio/dd233247.aspx.
36. ↑ "About F#". http://fsharp.org/about/index.html.
37. ↑ "Structures - F#". https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/structures.
38. ↑ "Discriminated Unions". 15 September 2021. https://msdn.microsoft.com/en-us/library/dd233226.aspx.
39. ↑ "The F# 3.0 Language Specification: 1.1.2 Making Data Simple". http://fsharp.org/about/files/spec.pdf.
40. ↑ 40.0 40.1 "Haskell Wiki". http://www.haskell.org.
41. ↑ "Haskell Wiki Lazy Evaluation". http://www.haskell.org/haskellwiki/Lazy_evaluation.
42. ↑ "Haskell Typing". HaskellWiki. http://www.haskell.org/haskellwiki/Typing.
43. ↑ "Haskell Wiki Abstract Data Type". http://www.haskell.org/haskellwiki/Abstract_data_type.
44. ↑ "Haskell Wiki". http://www.haskell.org/haskellwiki/Functional_programming#Immutable_data.
45. ↑ "Type Classes and Overloading". http://www.haskell.org/tutorial/classes.html.
46. ↑ 46.0 46.1 "Scala Overview". http://www.scala-lang.org/old/sites/default/files/linuxsoft_archives/docu/files/ScalaOverview.pdf.
47. ↑ "Scala by Example". http://www.scala-lang.org/docu/files/ScalaByExample.pdf.
48. ↑ 48.0 48.1 "Scala Reference". http://www.scala-lang.org/files/archive/nightly/pdfs/ScalaReference.pdf.
49. ↑ "Mutable and Immutable Collections". http://docs.scala-lang.org/overviews/collections/overview.html.
50. ↑ "The Neophyte's Guide to Scala Part 12: Type Classes". http://danielwestheide.com/blog/2013/02/06/the-neophytes-guide-to-scala-part-12-type-classes.html.
51. ↑ Tao, Dan. "Lazy.js". Dan Tao. http://danieltao.com/lazy.js/.
52. ↑ "JavaScript Overview". Mozilla Developer Network. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/JavaScript_Overview.
53. ↑ Frank, Thomas. "Add some klass to JavaScript". thomasfrank.com. http://www.thomasfrank.se/klass.html.
54. ↑ Faubion, Nathan. "ADT". NPM. Joyent, nodejitsu. https://npmjs.org/package/adt.
55. ↑ Immutable object
56. ↑ "Javascript Data structures". Mozilla Developer Network. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures.
57. ↑ "FAQ - Clean". http://clean.cs.ru.nl/FAQ.
58. ↑ 58.0 58.1 58.2 58.3 58.4 Plasmeijer, Rinus; Van Eekelen, Marko; Van Groningen, John (December 2011). Clean Version 2.2 Language Report. Department of Software Technology, University of Nijmegen. http://clean.cs.ru.nl/download/doc/CleanLangRep.2.2.pdf. Retrieved 23 May 2018.
59. ↑ "Clean". http://clean.cs.ru.nl/Clean.
60. ↑ 60.0 60.1 60.2 "Miranda Official Website". http://miranda.org.uk/.
61. ↑ "An Overview of Miranda". http://www.cs.kent.ac.uk/people/staff/dat/miranda/Overview.html#Lazy.
62. ↑ "An Overview of Miranda". http://www.cs.kent.ac.uk/people/staff/dat/miranda/Overview.html#Abstract.
63. ↑ Turner, D.A. "An Implementation of SASL". University of St. Andrews, Department of Computer Science Technical Report. TR/75/4.
64. ↑ Kahn, Gilles; Bertot, Yves; Huet, Gérard; Lévy, Jean-Jacques; Plotkin, Gordon (2009-09-24). Kahn networks at the dawn of functional programming. Cambridge University Press. ISBN 9780521518253. https://books.google.com/books?id=W2baKp7710sC&q=sasl+dynamic+typing&pg=PA128.
65. ↑ "Stream — Elixir v1.17.2". https://hexdocs.pm/elixir/Stream.html.
66. ↑ "Erlang Reference Manual". http://www.erlang.org/doc/reference_manual/expressions.html#id76539.
67. ↑ "Erlang Programming Language - Abstract Patterns". http://www.erlang.org/eeps/eep-0029.html.
68. ↑ "Stack Overflow - How do I modify a record in erlang?". https://stackoverflow.com/questions/2715517/how-do-i-modify-a-record-in-erlang.
69. ↑ 69.0 69.1 69.2 "Elm Blog - Interactive Programming". http://elm-lang.org/blog/Interactive-Programming.elm.
70. ↑ "Elm Syntax - Algebraic Data Types". http://elm-lang.org/learn/Syntax.elm#algebraic-data-types.
71. ↑ "Type Inference". https://futhark.readthedocs.io/en/latest/language-reference.html#type-inference.
72. ↑ "Functional Programming in Python". https://docs.python.org/3/howto/functional.html.
73. ↑ "What is Python?". https://docs.python.org/3/faq/general.html#what-is-python.
74. ↑ "Abstract Data Types and Stacks". http://www.cs.utexas.edu/~byoung/cs313e/slides5-adt.pdf.
75. ↑ Immutable object
76. ↑ 76.0 76.1 76.2 76.3 76.4 76.5 76.6 "Idris Overview". http://www.idris-lang.org/.
77. ↑ 77.0 77.1 77.2 "Nix Language - Nix 2.34.0 Reference Manual". https://nix.dev/manual/nix/2.34/language/.
78. ↑ "Kotlin - Delegated Properties". https://kotlinlang.org/docs/reference/delegated-properties.html.
79. ↑ "kotlin-stdlib - kotlin.sequences". https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.sequences/.
80. ↑ "Noteworthy Differences from Other Languages - The Julia Language". https://docs.julialang.org/en/v1/manual/noteworthy-differences/.
81. ↑ 81.0 81.1 81.2 "Types - The Julia Language". https://docs.julialang.org/en/v1/manual/types/.
82. ↑ "The Rust Programming Language, Processing a Series of Items with Iterators". https://doc.rust-lang.org/book/ch13-02-iterators.html.
83. ↑ "Rust crate 'lazy'". https://crates.io/crates/lazy.
84. ↑ "The Rust Programming Language, Data Types". https://doc.rust-lang.org/book/ch03-02-data-types.html.
85. ↑ 85.0 85.1 "The Rust Programming Language, Traits". https://doc.rust-lang.org/book/ch10-02-traits.html.
86. ↑ "The Rust Programming Language, Enums". https://doc.rust-lang.org/book/ch06-00-enums.html.
87. ↑ "The Rust Programming Language, Variables and Mutability". https://doc.rust-lang.org/book/ch03-01-variables-and-mutability.html.
88. ↑ "D pure functions". https://dlang.org/spec/function.html#pure-functions.
89. ↑ "D safe functions". https://dlang.org/spec/function.html#safe-functions.
90. ↑ "Laziness - Dlang Tour". https://tour.dlang.org/tour/en/basics/laziness.
91. ↑ "Type System". https://dlang.org/spec/type.html.
92. ↑ "Immutable - Dlang Tour". https://tour.dlang.org/tour/en/basics/immutability.
93. ↑ "Garbage Collection". https://dlang.org/spec/garbage.html.
94. ↑ "Frequently asked questions – Gleam". https://gleam.run/frequently-asked-questions/#will-gleam-have-type-classes.

* v
* t
* e

Programming paradigms

Imperative|

| Structured|

* Jackson structures
* Block-structured
* Modular
* Non-structured
* Procedural
* Programming in the large and in the small
* Design by contract
* Invariant-based
* Nested function

|

Object-oriented|

* Class-based, Prototype-based, Object-based
* Agent
* Immutable object
* Persistent
* Uniform function call syntax

Declarative|

| Functional|

* Recursive
* Anonymous function (Partial application)
* Higher-order
* Purely functional
* Total
* Strict
* GADTs
* Dependent types
* Functional logic
* Point-free style
* Expression-oriented
* Applicative, Concatenative
* Function-level, Value-level
* Monad

|

Dataflow|

* Flow-based
* Reactive (Functional reactive)
* Signals
* Streams
* Synchronous

Logic|

* Abductive logic
* Answer set
* Constraint (Constraint logic)
* Inductive logic
* Nondeterministic
* Ontology
* Probabilistic logic
* Query

Domain-
specific
language
(DSL)|

* Algebraic modeling
* Array
* Automata-based (Action)
* Command (Spacecraft)
* Differentiable
* End-user
* Grammar-oriented
* Interface description
* Language-oriented
* List comprehension
* Low-code
* Modeling
* Natural language
* Non-English-based
* Page description
* Pipes and filters
* Probabilistic
* Quantum
* Scientific
* Scripting
* Set-theoretic
* Simulation
* Stack-based
* System
* Tactile
* Templating
* Transformation (Graph rewriting, Production, Pattern)
* Visual

Concurrent,
parallel|

* Actor-based
* Automatic mutual exclusion
* Choreographic programming
* Concurrent logic (Concurrent constraint logic)
* Concurrent OO
* Macroprogramming
* Multitier programming
* Organic computing
* Parallel programming models
* Partitioned global address space
* Process-oriented
* Relativistic programming
* Service-oriented
* Structured concurrency

Metaprogramming|

* Attribute-oriented
* Automatic (Inductive)
* Dynamic
* Extensible
* Generic
* Homoiconicity
* Interactive
* Macro (Hygienic)
* Metalinguistic abstraction
* Multi-stage
* Program synthesis (Bayesian, by demonstration, by example, vibe coding)
* Reflective
* Self-modifying code
* Symbolic
* Template

Separation
of concerns|

* Aspects
* Components
* Data-driven
* Data-oriented
* Event-driven
* Features
* Literate
* Roles
* Subjects

Comparisons/Lists|

Comparison (multi-paradigm, object-oriented, functional), List (OO, by type)

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Comparison of functional programming languages. Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Comparison_of_functional_programming_languages&oldid=4349434"
*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template