Jump to content

Comparison of functional programming languages

Add links
From Wikipedia, the free encyclopedia
This is an old revision of this page, as edited by RProgrammer (talk | contribs) at 23:40, 27 December 2020 (Added PureScript; just let me know if references are necessary given its wikipedia page already has them. (Justification: PureScript is very much like Elm which is already on here, but is even more similar to Haskell, having type classes for example)). The present address (URL) is a permanent link to this revision, which may differ significantly from the current revision.

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 Closures
Common Lisp No[1] Partial, simulated with thunks[2] Dynamic[3] Yes[4] Partial, with extension[5] No[6] No Yes[7]
Scheme No[8] Yes[9] Dynamic[8] Yes[10] Partial, simulated with thunks[11] No[12] No Yes[13]
Racket No Yes, default in Lazy Racket[14] Dynamic by default, gradual with Typed Racket[15] Yes[16] Yes, with Algebraic Racket[17] Partial[18] No Yes[19]
Clojure No[20] Yes[21] Dynamic[22] Yes[23] Yes[24] Yes[25] No Yes[26]
Standard ML No[27] No[28][29] Static[30] ? ? Yes[31] ? Yes
Lazy ML Yes[32] Default[32] Static[33] ? ? Yes[31] ? Yes
OCaml No[34] Yes[34] Static[35] Yes[36] Yes[37] Yes[38] Partial, simulated with parametric modules[39] Yes[34]
F# No[40] Yes[41] Static[42] Yes[43] Yes[44] Yes[45] No Yes[46]
Haskell Yes[47] Default[48] Static[49] Yes[47] Yes[50] Yes[51] Yes[52] Yes[53]
Frege Yes[54] Default[54] Static[54] Yes[54] Yes[54] Yes[54] Yes[54] Yes[54]
Scala No[55] Yes[56] Static[55] Yes[57] Yes[57] Yes[58] Yes[59] Yes[57]
JavaScript No[60][unreliable source?] Partial, with extension[61] Dynamic[62] Partial, with extension[63] Partial, with extension[64] Partial[65][66] No Yes[67]
Clean Yes[68] Yes, with optional strictness annotations[69] Static with uniqueness/optionally dynamic[70] Yes[69] Yes[69] Yes, except for unique types[69] Yes[69] Yes[69]
Miranda Yes[71] Default[72] Static[71] Yes[73] Yes[71] ? ? ?
SASL Yes[74] ? Dynamic[75] ? ? ? ? ?
Elixir No Partial, with the Stream module[76] Dynamic Yes No Yes No Yes
Erlang No No[77] Dynamic Yes[78] No Yes[79] No Yes
Elm Yes No Static[80] ? Yes[81] Yes[80] No Yes[82]
Python No[83] Partial, simulated with generators Dynamic[84] Yes[85] No Partial[86] No Yes[87]
Candle Yes[88] ? Dynamic[89] Partial, only Sequence and Map[90] ? Partial[91] ? ?
Idris Yes[92] Yes[92] Static[92] Yes[92] Yes[92] Yes[92] Yes[92] Yes[92]
Kotlin No Partial, lazy delegation[93] and Sequence[94] Static Yes No Yes No Yes
Julia No No[95] Dynamic[96] Yes[96] No Partial[96] No Yes
PureScript Yes No Static Yes Yes Yes Yes Yes

References

  1. ^ "LISP Introduction". Retrieved 26 November 2013.
  2. ^ Antoniotti, Marco. "CLAZY: Lazy Calling in Common Lisp". Retrieved 26 November 2013.
  3. ^ Tratt, Laurence (July 2009). "Dynamically Typed Languages". Advances in Computers. 77: 149–184. doi:10.1016/s0065-2458(09)01205-4. Retrieved 26 November 2013.
  4. ^ "LISP Tutorial Lecture 3: Data Abstraction".
  5. ^ "Algebraic data types in Common Lisp". Retrieved 11 May 2020.
  6. ^ "Mutable Data Structures" (PDF). Retrieved 28 November 2013.
  7. ^ "Closures in Lisp". Archived from the original on 12 October 2014. Retrieved 6 December 2013.
  8. ^ a b "Similar Functional Languages". Retrieved 26 November 2013.
  9. ^ "(Scheme) 17. Lazy Evaluation". Retrieved 30 April 2020.
  10. ^ "Records - Revised6 Report on the Algorithmic Language Scheme". Retrieved 11 May 2020.
  11. ^ "Algebraic Data Types in Scheme". Retrieved 11 May 2020.
  12. ^ "Programs with State". Retrieved 29 November 2013.
  13. ^ "Procedures as Closures in Scheme".
  14. ^ Barzilay, Eli. "Lazy Racket". Retrieved 8 February 2020.
  15. ^ Tobin-Hochstadt, Sam; St-Amour, Vincent; Dobson, Eric; Takikawa, Asumu. "Typed Racket". Retrieved 8 February 2020.
  16. ^ "The Racket Guide: Programmer-Defined Datatypes". Retrieved 8 February 2020.
  17. ^ Griffis, Eric. "Algebraic Racket". Retrieved 8 February 2020.
  18. ^ Buttrick, Matthew. "Beautiful Racket: Data Structures". Retrieved 8 February 2020.
  19. ^ "The Racket Reference: Procedures". Retrieved 8 February 2020.
  20. ^ "Clojure Functional Programing".
  21. ^ "Clojure - lazy". Retrieved 27 November 2013.
  22. ^ "Exploring clojure: dynamic typing". Retrieved 26 November 2013.
  23. ^ Engelberg, Mark. "Thoughts On Programming". Retrieved 26 November 2013.
  24. ^ "clojure-contrib, typing example". Retrieved 26 November 2013.
  25. ^ "clojure: functional programming overview". Retrieved 26 November 2013.
  26. ^ "Clojure - Higher Order Functions".
  27. ^ "Introduction to Functional Programming" (PDF). Retrieved 26 November 2013.
  28. ^ "Lazy and Eager Evaluation" (PDF). Retrieved 26 November 2013.
  29. ^ Harper, MacQueen, Milner. "Standard ML" (PDF). Section 3.6.{{cite web}}: CS1 maint: multiple names: authors list (link)
  30. ^ Wikibooks:Standard ML Programming/Types
  31. ^ a b "Mutable and optional data". Retrieved 28 November 2013.
  32. ^ a b "The Interactive Lazy ML System". Retrieved 15 December 2013.
  33. ^ "A Compiler for Lazy ML". Retrieved 15 December 2013.
  34. ^ a b c "Functional Programming – OCaml". Retrieved 26 November 2013.
  35. ^ Hickey, Jason. "Introduction to Objective Caml" (PDF). Section 2.4. Cambridge University Press. Archived from the original (PDF) on 2 October 2013. Retrieved 26 November 2013.
  36. ^ "Type and exception definitions".
  37. ^ "Learn OCaml - Data Types".
  38. ^ "Learn OCaml - Imperative Features".
  39. ^ "Implementing Type-Classes as OCaml Modules". Retrieved 11 May 2020.
  40. ^ "Learning F#". Retrieved 6 December 2013.
  41. ^ "Lazy Computations (F#)". Microsoft Developer Network. Retrieved 26 November 2013.
  42. ^ "About F#". Retrieved 26 November 2013.
  43. ^ "Structures - F#". Retrieved 11 May 2020.
  44. ^ "Discriminated Unions".
  45. ^ "The F# 3.0 Language Specification: 1.1.2 Making Data Simple" (PDF). Retrieved 26 November 2013.
  46. ^ "F# Closure reference".
  47. ^ a b "Haskell Wiki". Retrieved 26 November 2013.
  48. ^ "Haskell Wiki Lazy Evaluation". Retrieved 26 November 2013.
  49. ^ "Haskell Typing". HaskellWiki. Retrieved 26 November 2013.
  50. ^ "Haskell Wiki Abstract Data Type". Retrieved 26 November 2013.
  51. ^ "Haskell Wiki". Retrieved 27 November 2013.
  52. ^ "Type Classes and Overloading".
  53. ^ "Haskell Wiki Closure". Retrieved 26 November 2013.
  54. ^ a b c d e f g h "Frege Language Reference" (PDF). Retrieved 26 February 2014.
  55. ^ a b "Scala Overview" (PDF). Retrieved 26 November 2013.
  56. ^ "Scala by Example" (PDF). Retrieved 26 November 2013.
  57. ^ a b c "Scala Reference" (PDF). Retrieved 26 November 2013.
  58. ^ "Mutable and Immutable Collections". Retrieved 26 November 2013.
  59. ^ "The Neophyte's Guide to Scala Part 12: Type Classes". Retrieved 29 November 2013.
  60. ^ List of multi-paradigm programming languages#Language overview
  61. ^ Tao, Dan. "Lazy.js". Dan Tao. Retrieved 26 November 2013.
  62. ^ "JavaScript Overview". Mozilla Developer Network. Mozilla Developer Network. Retrieved 26 November 2013.
  63. ^ Frank, Thomas. "Add some klass to JavaScript". thomasfrank.com. Archived from the original on 8 December 2013. Retrieved 26 November 2013.
  64. ^ Faubion, Nathan. "ADT". NPM. Joyent, nodejitsu. Retrieved 26 November 2013.
  65. ^ Immutable object#JavaScript
  66. ^ "Javascript Data structures". Mozilla Developer Network. Mozilla Developer Network. Retrieved 26 November 2013.
  67. ^ "Javascript Closures". Retrieved 26 November 2013.
  68. ^ "FAQ - Clean".
  69. ^ a b c d e f Plasmeijer, Rinus; Van Eekelen, Marko; Van Groningen, John (December 2011). Clean Version 2.2 Language Report (PDF). Department of Software Technology, University of Nijmegen. Retrieved 23 May 2018.
  70. ^ "Clean".
  71. ^ a b c "Miranda Official Website".
  72. ^ "An Overview of Miranda".
  73. ^ "An Overview of Miranda".
  74. ^ Turner, D.A. "An Implementation of SASL". University of St. Andrews, Department of Computer Science Technical Report. TR/75/4.
  75. ^ Kahn, Gilles; Bertot, Yves; Huet, Gérard; Lévy, Jean-Jacques; Plotkin, Gordon (2009-09-24). Kahn networks at the dawn of functional programming. ISBN 9780521518253.
  76. ^ "Stream - Elixir v.1.6.0".
  77. ^ "Erlang Reference Manual". Retrieved 27 November 2013.
  78. ^ "Erlang Programming Language - Abstract Patterns".
  79. ^ "Stack Overflow - How do I modify a record in erlang?". Retrieved 15 December 2013.
  80. ^ a b "Elm Blog - Interactive Programming". Archived from the original on 6 October 2013. Retrieved 29 November 2013.
  81. ^ "Elm Syntax - Algebraic Data Types". Archived from the original on 13 March 2016. Retrieved 29 November 2013.
  82. ^ "Closures and Currying - Programming with Elm".
  83. ^ "Functional Programming in Python".
  84. ^ "What is Python?".
  85. ^ "Abstract Data Types and Stacks" (PDF).
  86. ^ Immutable object#Python
  87. ^ "PEP 3104 -- Access to Names in Outer Spaces".
  88. ^ "Candle Overview". Retrieved 30 November 2013.
  89. ^ "Candle Overview".
  90. ^ "Candle Date Model Reference". Retrieved 30 November 2013.
  91. ^ "Candle's Procedural Design". Retrieved 30 November 2013.
  92. ^ a b c d e f g h "Idris Overview". Retrieved 6 December 2013.
  93. ^ "Kotlin - Delegated Properties".
  94. ^ "kotlin-stdlib - kotlin.sequences".
  95. ^ "Noteworthy Differences from Other Languages - The Julia Language".
  96. ^ a b c "Types - The Julia Language".
Retrieved from "https://en.wikipedia.org/w/index.php?title=Comparison_of_functional_programming_languages&oldid=996663122"