Comparison of multi-paradigm programming languages

Short description: none

Programming paradigms

* Action
* Agent-oriented
* Array-oriented
* Automata-based
* Concurrent computing
* Relativistic programming
* Data-driven
* Declarative (contrast: Imperative)
* Functional
* Functional logic
* Purely functional
* Logic
* Abductive logic
* Answer set
* Concurrent logic
* Functional logic
* Inductive logic
* Constraint
* Constraint logic
* Concurrent constraint logic
* Dataflow
* Flow-based
* Reactive
* Ontology
* Differentiable
* Dynamic/scripting
* Event-driven
* Function-level (contrast: Value-level)
* Point-free style
* Concatenative
* Generic
* Imperative (contrast: Declarative)
* Procedural
* Object-oriented
* Polymorphic
* Intentional
* Language-oriented
* Domain-specific
* Literate
* Natural-language programming
* Metaprogramming
* Automatic
* Inductive programming
* Reflective
* Attribute-oriented
* Macro
* Template
* Non-structured (contrast: Structured)
* Array
* Nondeterministic
* Parallel computing
* Process-oriented
* Probabilistic
* Quantum
* Set-theoretic
* Stack-based
* Structured (contrast: Non-structured)
* Block-structured
* Structured concurrency
* Object-oriented
* Actor-based
* Class-based
* Concurrent
* Prototype-based
* By separation of concerns:
* Aspect-oriented
* Role-oriented
* Subject-oriented
* Recursive
* Symbolic
* Value-level (contrast: Function-level)

* v
* t
* e

Programming languages can be grouped by the number and types of paradigms supported.

## Contents

* 1 Paradigm summaries
* 2 Language overview
* 3 See also
* 4 Notes
* 5 Citations
* 6 References

## Paradigm summaries

A concise reference for the programming paradigms listed in this article.

* Concurrent programming – have language constructs for concurrency, these may involve multi-threading, support for distributed computing, message passing, shared resources (including shared memory), or futures
* Actor programming – concurrent computation with actors that make local decisions in response to the environment (capable of selfish or competitive behaviour)
* Constraint programming – relations between variables are expressed as constraints (or constraint networks), directing allowable solutions (uses constraint satisfaction or simplex algorithm)
* Dataflow programming – forced recalculation of formulas when data values change (e.g. spreadsheets)
* Declarative programming – describes what computation should perform, without specifying detailed state changes c.f. imperative programming (functional and logic programming are major subgroups of declarative programming)
* Distributed programming – have support for multiple autonomous computers that communicate via computer networks
* Functional programming – uses evaluation of mathematical functions and avoids state and mutable data
* Generic programming – uses algorithms written in terms of to-be-specified-later types that are then instantiated as needed for specific types provided as parameters
* Imperative programming – explicit statements that change a program state
* Logic programming – uses explicit mathematical logic for programming
* Metaprogramming – writing programs that write or manipulate other programs (or themselves) as their data, or that do part of the work at compile time that would otherwise be done at runtime
* Template metaprogramming – metaprogramming methods in which a compiler uses templates to generate temporary source code, which is merged by the compiler with the rest of the source code and then compiled
* Reflective programming – metaprogramming methods in which a program modifies or extends itself
* Object-oriented programming – uses data structures consisting of data fields and methods together with their interactions (objects) to design programs
* Class-based – object-oriented programming in which inheritance is achieved by defining classes of objects, versus the objects themselves
* Prototype-based – object-oriented programming that avoids classes and implements inheritance via cloning of instances
* Pipeline programming – a simple syntax change to add syntax to nest function calls to language originally designed with none
* Rule-based programming – a network of rules of thumb that comprise a knowledge base and can be used for expert systems and problem deduction & resolution
* Visual programming – manipulating program elements graphically rather than by specifying them textually (e.g. Simulink); also termed diagrammatic programming[1]

## Language overview

List of multi-paradigm programming languages  Language  | Number of paradigms  | Concurrent  | Constraints  | Data­flow  | Declarative  | Distributed  | Functional  | Meta­programming  | Generic  | Imperative  | Logic  | Reflection  | Object­oriented  | Pipe­lines  | Visual  | Rule-­based  | Other paradigms

|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|

Ada[2][3][4][5][6] | 5  | Yes[a 1] | No | No | No | Yes | No | No | Yes | Yes | No | No | Yes[a 2] | No | No | No | No
ALF | 2  | No | No | No | No | No | Yes | No | No | No | Yes | No | No | No | No | No | No
AmigaE | style="background:#F99;vertical-align:middle;text-align:center;" class="table-no"|No | No | No | No | No | No | No | No | Yes | No | No | Yes[a 2] | No | No | No | No
APL | 3  | No | No | No | No | No | Yes | No | No | Yes | No | No | No | No | No | No | Array (multi-dimensional)
BETA[citation needed] | 3  | No | No | No | No | No | Yes | No | No | Yes | No | No | Yes[a 2] | No | No | No | No
C++ | 7 (15)  | Yes[7][8][9] | Library[10] | Library[11][12] | Library[13][14] | Library[15][16] | Yes | Yes[17] | Yes[a 3] | Yes | Library[18][19] | Library[20] | Yes[a 2] | Yes[21] | No | Library[22] | Array (multi-dimensional; using STL)
C# | 6 (7)  | Yes | No | Library[a 4] | No | No | Yes[a 5] | No | Yes | Yes | No | Yes | Yes[a 2] | No | No | No | reactive[a 6]
ChucK | style="background:#9F9;vertical-align:middle;text-align:center;" class="table-yes"|Yes | No | No | No | No | No | No | No | Yes | No | No | Yes[a 2] | No | No | No | No
Claire | 2  | No | No | No | No | No | Yes | No | No | No | No | No | Yes[a 2] | No | No | No | No
Clojure | 5  | Yes[23][24] | No | No | Yes | No | Yes[25] | Yes[26] | No | No | Library[27] | No | No | Yes[28] | Editor[29] | No | Multiple dispatch,[30] Agents[31]
Common Lisp | 7 (14)  | Library[32] | Library[33] | Library[34] | Yes[35] | Library[36] | Yes | Yes | Yes[37] | Yes | Library[38] | Yes | Yes (multiple dispatch, method combinations)[39][a 2] | Library[40] | Library[41] | Library[42] | Multiple dispatch, meta-OOP system,[43] Language is extensible via metaprogramming.
Curl | 5  | No | No | No | No | No | Yes | No | Yes[a 3] | Yes | No | Yes | Yes[a 2] | No | No | No | No
Curry | 4  | Yes | Yes | No | No | No | Yes | No | No | No | Yes | No | No | No | No | No | No
D (version 2.0)[44][45] | 7  | Yes[a 7] | No | No | No | No | Yes | Yes[46][a 3] | Yes[a 3] | Yes | No | Yes | Yes[a 2] | No | No | No | No
Delphi | 3  | No | No | No | No | No | No | No | Yes[a 3] | Yes | No | No | Yes[a 2] | No | No | No | No
Dylan[citation needed] | 3  | No | No | No | No | No | Yes | No | No | No | No | Yes | Yes[a 2] | No | No | No | No
E | 3  | Yes | No | No | No | Yes | No | No | No | No | No | No | Yes[a 2] | No | No | No | No
ECMAScript[47][48] (ActionScript, E4X, JavaScript, JScript) | 4 (5)  | partial (promises, native extensions)[a 8] | No | No | Library[49][50] | No | Yes | No | No | Yes | No | Yes | Yes[a 9] | Library[51][52] | Editor[53] | No | reactive,[a 10][54] event driven[a 11][a 12]
Erlang | 3  | Yes | No | No | Yes | Yes | Yes | No | No | No | No | No | No | Yes | No | No | No
Elixir | 4  | Yes | No | No | No | Yes | Yes | Yes | No | No | No | No | No | Yes | No | No | No
Elm | 6  | Yes | No | Yes | Yes | No | Yes (pure)[a 13] | No | Yes | No | No | No | No | Yes | No | No | reactive
F# | 7 (8)  | Yes[a 7] | No | Library[a 4] | Yes | No | Yes | No | Yes | Yes | No | Yes | Yes[a 2] | No | No | No | reactive[a 6]
Fortran | 4 (5)  | Yes | No | No | No | No | Yes[a 13] | No | Yes[a 14] | No | No | No | Yes[a 2] | No | No | No | Array (multi-dimensional)
Go | 4  | Yes | No | No | No | No | No | No | No | Yes | No | Yes | No | Yes | No | No | No
Haskell | 8 (15)  | Yes | Library[55] | Library[56] | Yes | Library[57] | Yes (lazy) (pure)[a 13] | Yes[58] | Yes | Yes | Library[59] | No | Immutable | Yes | Yes | Library[60] | literate, reactive, dependent types (partial)
Io | 4  | Yes[a 7] | No | No | No | No | Yes | No | No | Yes | No | No | Yes[a 9] | No | No | No | No
J[citation needed] | 3  | No | No | No | No | No | Yes | No | No | Yes | No | No | Yes[a 2] | No | No | No | No
Java | 6  | Yes | Library[61] | Library[62] | No | No | Yes | No | Yes | Yes | No | Yes | Yes[a 2] | No | No | No | No
Julia | 9 (17)  | Yes | Library[63] | Library[64][65] | Library[66] | Yes | Yes (eager) | Yes | Yes | Yes | Library[67] | Yes | Yes (multiple dispatch, not traditional single) | Yes | No | Library[68][69] | Multiple dispatch,
Array (multi-dimensional); optionally lazy[70] and reactive (with libraries)
Kotlin | 8  | Yes | No | No | No | No | Yes | Yes | Yes | Yes | No | Yes | Yes | Yes | No | No | No
LabVIEW | 4  | Yes | No | Yes | No | No | No | No | No | No | No | No | Yes | No | Yes | No | No
Lava | 2  | No | No | No | No | No | No | No | No | No | No | No | Yes[a 2] | No | Yes | No | No
LispWorks (version 6.0 with support for symmetric multi-processing, rules, logic (Prolog), CORBA) | 9  | Yes | No | No | No | Yes | Yes | Yes | No | Yes | Yes | Yes | Yes[a 2] | No | No | Yes | No
Lua[citation needed] | 3  | No | No | No | No | No | Yes | No | No | Yes | No | No | Yes[a 9] | No | No | No | No
MATLAB | 6 (10)  | Toolbox[71] | Toolbox[72] | Yes[73] | No | Toolbox[74] | No | Yes[75] | Yes[76] | No | No | Yes[77] | Yes[78] | No | Yes[79] | No | Array (multi-dimensional)
Nemerle | 7  | Yes | No | No | No | No | Yes | Yes | Yes | Yes | No | Yes | Yes[a 2] | No | No | No | No
Object Pascal | 4  | Yes | No | No | No | No | Yes | No | No | Yes | No | No | Yes[a 2] | No | No | No | No
OCaml | 4  | No | No | No | No | No | Yes | No | Yes | Yes | No | No | Yes[a 2] | No | No | No | No
Oz | 11  | Yes | Yes | Yes | Yes | Yes | Yes | No | No | Yes | Yes | No | Yes[a 2] | Yes | No | Yes | No
Perl | style="background:#9F9;vertical-align:middle;text-align:center;" class="table-yes"|Yes[80] | Library[81] | Yes[82] | No | No | Yes | Yes | No | Yes | No | Yes[a 2] | Yes[a 2] | Yes | No | No | No
PHP[83][84][85] | 4  | No | No | No | No | No | Yes | No | No | Yes | No | Yes | Yes[a 2] | No | No | No | No
Poplog | 3  | No | No | No | No | No | Yes | No | No | Yes | Yes | No | No | No | No | No | No
Prograph | 3  | No | No | Yes | No | No | No | No | No | No | No | No | Yes[a 2] | No | Yes | No | No
Python | 5 (10)  | Library[86][87] | Library[88] | No  | No  | Library[89] | Yes  | Yes[90][91] | Yes[92][93] | Yes | Library[94] | Yes | Yes[a 2] | No | Editor[95] | No | structured
R | 4 (6)  | Library[96] | No | No | No | Library[97] | Yes | No | No | Yes | No | Yes | Yes | Yes[98] | No | No | Array (multi-dimensional)
Racket | 10  | Yes[99] | Yes[100] | Yes[101] | No | Yes[102] | Yes | Yes | No | Yes | Yes | Yes | Yes | No | No | No | Lazy[103]
Raku | 10  | Yes[104] | Yes[105] | Yes[106] | No | Library[107] | Yes | Yes[108] | Yes[109] | Yes | No | Yes[110] | Yes[111] | Yes | No | No | Multiple dispatch, lazy lists, reactive.
ROOP | 3  | No | No | No | No | No | No | No | No | Yes | Yes | No | No | No | No | Yes | No
Ruby | 5  | No | No | No | No | No | Yes | Yes | No | Yes | No | Yes | Yes[a 2] | No | No | No | No
Rust (version 1.0.0-alpha) | 6  | Yes[a 7] | No | No | No | No | Yes | Yes[112][113] | Yes[114] | Yes | No | No | Yes | No | No | No | linear, affline, and ownership types
Sather | style="background:#F99;vertical-align:middle;text-align:center;" class="table-no"|No | No | No | No | No | Yes | No | No | No | No | No | Yes[a 2] | No | No | No | No
Scala[115][116] | 9  | Yes[a 7] | No | Yes[a 15] | Yes | No | Yes | Yes | Yes | Yes | No | Yes | Yes[a 2] | No | No | No | No
Simula | style="background:#F99;vertical-align:middle;text-align:center;" class="table-no"|No | No | No | No | No | No | No | No | Yes | No | No | Yes[a 2] | No | No | No | No
SISAL | 3  | Yes | No | Yes | No | No | Yes | No | No | No | No | No | No | No | No | No | No
Spreadsheets | 2  | No | No | No | No | No | Yes | No | No | No | No | No | No | No | Yes | No | No
Swift | 7  | Yes | No | No | No | No | Yes | Yes | Yes | Yes | No | Yes | Yes[a 2] | No | No | No | block-structured
Tcl with Snit extension[citation needed] | 3  | No | No | No | No | No | Yes[117] | No | No | Yes | No | No | Yes[a 9][118] | No | No | No | No
Visual Basic .NET | 6 (7)  | Yes | No | Library[a 4] | No | No | Yes | No | Yes | Yes | No | Yes | Yes[a 2] | No | No | No | reactive[a 6]
Windows PowerShell | 6  | No | No | No | No | No | Yes | No | Yes | Yes | No | Yes | Yes[a 2] | Yes | No | No | No
Wolfram Language & Mathematica | 13[119] (14)  | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes[120] | No | Yes | Knowledge Based

## See also

* Programming paradigm
* List of programming languages by type
* Domain-specific language
* Domain-specific multimodeling

## Notes

1. ↑ rendezvous and monitor-like based
2. ↑ 2.00 2.01 2.02 2.03 2.04 2.05 2.06 2.07 2.08 2.09 2.10 2.11 2.12 2.13 2.14 2.15 2.16 2.17 2.18 2.19 2.20 2.21 2.22 2.23 2.24 2.25 2.26 2.27 2.28 2.29 2.30 2.31 2.32 2.33 2.34 Class-based
3. ↑ 3.0 3.1 3.2 3.3 3.4 Template metaprogramming
4. ↑ 4.0 4.1 4.2 using TPL Dataflow
5. ↑ only lambda support (lazy functional programming)
6. ↑ 6.0 6.1 6.2 using Reactive Extensions (Rx)
7. ↑ 7.0 7.1 7.2 7.3 7.4 actor programming
8. ↑ using Node.js' cluster module or child_process.fork method, web workers in the browser, etc.
9. ↑ 9.0 9.1 9.2 9.3 Prototype-based
10. ↑ using Reactive Extensions (RxJS)
11. ↑ in Node.js via their events module
12. ↑ in browsers via their native EventTarget API
13. ↑ 13.0 13.1 13.2 purely functional
14. ↑ parameterized classes
15. ↑ Akka

## Citations

1. ↑ Bragg, S.D.; Driskill, C.G. (20–22 September 1994). "Diagrammatic-graphical programming languages and DoD-STD-2167A". Proceedings of AUTOTESTCON '94 (IEEEXplore). Institute of Electrical and Electronics Engineers (IEEE). pp. 211–220. doi:10.1109/AUTEST.1994.381508. ISBN 978-0-7803-1910-3.
2. ↑ Ada Reference Manual, ISO/IEC 8652:2005(E) Ed. 3, Section 9: Tasks and Synchronization
3. ↑ Ada Reference Manual, ISO/IEC 8652:2005(E) Ed. 3 Annex E: Distributed Systems
4. ↑ Ada Reference Manual, ISO/IEC 8652:2005(E) Ed. 3, Section 12: Generic Units
5. ↑ Ada Reference Manual, ISO/IEC 8652:2005(E) Ed. 3, Section 6: Subprograms
6. ↑ Ada Reference Manual, ISO/IEC 8652:2005(E) Ed. 3, 3.9 Tagged Types and Type Extensions
7. ↑ Thread support
8. ↑ Atomics support
9. ↑ Memory model
10. ↑ Gecode
11. ↑ SystemC
12. ↑ Boost.Iostreams
13. ↑ Boolinq
14. ↑ "AraRat". https://www.cs.technion.ac.il/~lkeren/scp.pdf.
15. ↑ OpenMPI
16. ↑ Boost.MPI
17. ↑ Boost.MPL
18. ↑ LC++
19. ↑ Castor
20. ↑ Reflect Library
21. ↑ N3534
22. ↑ Boost.Spirit
23. ↑ Clojure - Concurrent Programming
24. ↑ Clojure - core.async
25. ↑ Clojure - Functional Programming
26. ↑ Clojure - Macros
27. ↑ Clojure - core.logic
28. ↑ Clojure - Threading Macros Guide
29. ↑ "Light Table". 2019-04-08. http://lighttable.com/.
30. ↑ Multimethods and Hierarchies
31. ↑ Agents and Asynchronous Actions
32. ↑ [1] many concurrency paradigms implemented as language extensions
33. ↑ [2] constraint programming inside CL through extensions
34. ↑ [3] dataflow extension
35. ↑ [4] by creating DSLs using the built-in metaprogramming; also see note on functional, constraint and logic paradigms, which are part of declarative
36. ↑ [5] MPI, etc via language extensions
37. ↑ template metaprogramming using macros (see C++)
38. ↑ [6] [7] [8] Prolog implemented as a language extension
39. ↑ Common Lisp Object System see Wikipedia article on CLOS, the Common Lisp Object System.
40. ↑ implemented by the user via a short macro, example of implementation
41. ↑ \- Visual programming tool based on Common Lisp
42. ↑ [9] rule-based programming extension
43. ↑ [10] through the Meta Object Protocol
44. ↑ D Language Feature Table
45. ↑ Phobos std.algorithm
46. ↑ D language String Mixins
47. ↑ The Little JavaScripter demonstrates fundamental commonality with Scheme, a functional language.
48. ↑ Object-Oriented Programming in JavaScript gives an overview of object-oriented programming techniques in JavaScript.
49. ↑ "React – A JavaScript library for building user interfaces". 2019-04-08. https://reactjs.org/.
50. ↑ "TNG-Hooks". 2019-04-08. https://github.com/getify/tng-hooks.
51. ↑ "Lodash documentation". 2019-04-08. https://lodash.com/docs/4.17.11#flow.
52. ↑ "mori". 2019-04-08. https://swannodette.github.io/mori/#pipeline.
53. ↑ "Light Table". 2019-04-08. http://lighttable.com/.
54. ↑ "TNG-Hooks". 2019-04-08. https://github.com/getify/tng-hooks.
55. ↑ "Prolog embedding". https://hackage.haskell.org/package/hswip.
56. ↑ "Functional Reactive Programming". https://wiki.haskell.org/Functional_Reactive_Programming.
57. ↑ Cloud Haskell
58. ↑ "Template Haskell". https://wiki.haskell.org/Template_Haskell.
59. ↑ "Logict: A backtracking logic-programming monad". https://hackage.haskell.org/package/logict.
60. ↑ Kollmansberger, Steve; Erwig, Martin (30 May 2006). "Haskell Rules: Embedding Rule Systems in Haskell". https://web.engr.oregonstate.edu/~erwig/HaskellRules/HaskellRules_June06.pdf.
61. ↑ https://jcp.org/en/jsr/detail?id=331 JSR 331: Constraint Programming API
62. ↑ https://github.com/GoogleCloudPlatform/DataflowJavaSDK Google Cloud Platform Dataflow SDK
63. ↑ "JuliaOpt/JuMP.jl". JuliaOpt. 11 February 2020. https://github.com/JuliaOpt/JuMP.jl.
64. ↑ "GitHub - MikeInnes/DataFlow.jl". 2019-01-15. https://github.com/MikeInnes/DataFlow.jl.
65. ↑ "GitHub - JuliaGizmos/Reactive.jl: Reactive programming primitives for Julia". 2018-12-28. https://github.com/JuliaGizmos/Reactive.jl.
66. ↑ https://github.com/davidanthoff/Query.jl Query almost anything in julia
67. ↑ https://github.com/lilinjn/LilKanren.jl A collection of Kanren implementations in Julia
68. ↑ "GitHub - abeschneider/PEGParser.jl: PEG Parser for Julia". 2018-12-03. https://github.com/abeschneider/PEGParser.jl.
69. ↑ "GitHub - gitfoxi/Parsimonious.jl: A PEG parser generator for Julia". 2017-08-03. https://github.com/gitfoxi/Parsimonious.jl.
70. ↑ Lazy https://github.com/MikeInnes/Lazy.jl
71. ↑ "Execute loop iterations in parallel". http://mathworks.com/help/distcomp/parfor.html.
72. ↑ "Write Constraints". https://mathworks.com/help/optim/write-constraints.html.
73. ↑ "Getting Started with SimEvents". https://mathworks.com/help/simevents/getting-started-with-simevents.html.
74. ↑ "Execute loop iterations in parallel". http://mathworks.com/help/distcomp/parfor.html.
75. ↑ "Execute MATLAB expression in text - MATLAB eval". https://mathworks.com/help/matlab/ref/eval.html.
76. ↑ "Determine class of object". https://mathworks.com/help/matlab/ref/class.html.
77. ↑ "Class Metadata". https://mathworks.com/help/matlab/get-information-about-classes-and-objects.html.
78. ↑ "Object-Oriented Programming". https://mathworks.com/help/matlab/object-oriented-programming.html.
79. ↑ "Simulink". https://mathworks.com/help/simulink/.
80. ↑ interpreter based threads
81. ↑ Moose
82. ↑ Higher Order Perl
83. ↑ PHP Manual, Chapter 17. Functions
84. ↑ PHP Manual, Chapter 19. Classes and Objects (PHP 5)
85. ↑ PHP Manual, Anonymous functions
86. ↑ "Parallel Processing and Multiprocessing in Python". https://wiki.python.org/moin/ParallelProcessing.
87. ↑ "threading — Higher-level threading interface". https://docs.python.org/2/library/threading.html.
88. ↑ "python-constraint". https://pypi.python.org/pypi/python-constraint.
89. ↑ "DistributedProgramming". https://wiki.python.org/moin/DistributedProgramming.
90. ↑ "Chapter 9. Metaprogramming". http://chimera.labs.oreilly.com/books/1230000000393/ch09.html.
91. ↑ "Metaprogramming". https://python-3-patterns-idioms-test.readthedocs.io/en/latest/Metaprogramming.html.
92. ↑ "PEP 443 – Single-dispatch generic functions". https://www.python.org/dev/peps/pep-0443/.
93. ↑ "PEP 484 – Type Hints". https://www.python.org/dev/peps/pep-0484/#generics.
94. ↑ "PyDatalog". https://sites.google.com/site/pydatalog/.
95. ↑ "Light Table". 2019-04-08. http://lighttable.com/.
96. ↑ "Futureverse". https://www.futureverse.org/.
97. ↑ "future batchtools". https://future.batchtools.futureverse.org/.
98. ↑ "Magrittr: A Forward Pipe Operator for R". 17 November 2020. https://cran.r-project.org/package=magrittr.
99. ↑ Racket Guide: Concurrency and Synchronization
100. ↑ The Rosette Guide
101. ↑ FrTime: A Language for Reactive Programs
102. ↑ Racket Guide: Distributed Places
103. ↑ Lazy Racket
104. ↑ Channels and other mechanisms
105. ↑ "Class Signature". https://docs.perl6.org/type/Signature#Type_Constraints.
106. ↑ Feed operator
107. ↑ https://github.com/perl6/doc/issues/1744#issuecomment-360565196 Cro module
108. ↑ "Meta-programming: What, why and how". 2011-12-14. https://perl6advent.wordpress.com/2011/12/14/meta-programming-what-why-and-how/.
109. ↑ https://perl6advent.wordpress.com/2009/12/18/day-18-roles/ Parametrized Roles
110. ↑ "Meta-object protocol (MOP)". https://docs.perl6.org/language/mop.
111. ↑ https://docs.perl6.org/language/classtut Classes and Roles
112. ↑ "The Rust macros guide". http://doc.rust-lang.org/1.0.0-alpha/book/macros.html.
113. ↑ "The Rust compiler plugins guide". http://doc.rust-lang.org/1.0.0-alpha/book/plugins.html.
114. ↑ The Rust Reference §6.1.3.1
115. ↑ An Overview of the Scala Programming Language
116. ↑ Scala Language Specification
117. ↑ "Tcl Programming/Introduction". https://en.wikibooks.org/wiki/Tcl_Programming/Introduction#One_language.2C_many_styles.
118. ↑ "TCLLIB - Tcl Standard Library: snitfaq". http://tmml.sourceforge.net/doc/tcllib/snitfaq.html.
119. ↑ Notes for Programming Language Experts, Wolfram Language Documentation.
120. ↑ External Programs, Wolfram Language Documentation.

## References

* Jim Coplien, Multiparadigm Design for C++, Addison-Wesley Professional, 1998.

* v
* t
* e

Types of programming languages

* Actor-based
* Array
* Aspect-oriented
* Class-based
* Concatenative
* Concurrent
* Dataflow
* Declarative
* Domain-specific
* Dynamic
* Esoteric
* Event-driven
* Extensible
* Functional
* Imperative
* Logic
* Macro
* Metaprogramming
* Multi-paradigm
* Object-based
* Object-oriented
* Pipeline
* Procedural
* Prototype-based
* Reflective
* Rule-based
* Scripting
* Stack based
* Synchronous
* Tactile
* Templating

* Assembly
* Compiled
* Interpreted
* Machine

* Low-level
* High-level
* Very high-level

* First generation
* Second generation
* Third generation
* Fourth generation
* Fifth generation

* Non-English-based
* Visual

0.00

(0 votes)

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

|

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