Wikipedia

Comparison of multi-paradigm programming languages: Difference between revisions

Browse history interactively
← Previous edit
Content deleted Content added
VisualWikitext
SdkbBot (talk | contribs)
Bots
363,682 edits
m Undid revision 1305042110 by Bender the Bot (talk) bot error fixed
 
(23 intermediate revisions by 15 users not shown)
Line 9:
* [[Constraint programming]] – relations between variables are expressed as constraints (or constraint networks), directing allowable solutions (uses constraint satisfaction or [[simplex algorithm]])
* [[Dataflow|Dataflow programming]] – forced recalculation of formulas when data values change (e.g. [[spreadsheet]]s)
* [[Declarative programming]] – describes what computation should perform, without specifying detailed state changes c.fcf. imperative programming (functional and logic programming are major subgroups of declarative programming)
* [[Distributed computing|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
Line 17:
* [[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
** [[reflection (computer programming)|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
** [[classClass (computer scienceprogramming)|Class-based]] – object-oriented programming in which inheritance is achieved by defining classes of objects, versus the objects themselves
** [[prototypePrototype-based programming|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 language|Visual programming]] – manipulating program elements graphically rather than by specifying them textually (e.g. [[Simulink]]); also termed ''diagrammatic programming''<ref>{{cite book |last1=Bragg |first1=S.D. |last2=Driskill |first2=C.G. |date=20–22 September 1994 |chapter=Diagrammatic-graphical programming languages and DoD-STD-2167A |publisher=[[Institute of Electrical and Electronics Engineers]] (IEEE) |doi=10.1109/AUTEST.1994.381508 |title=Proceedings of AUTOTESTCON '94 (IEEEXplore) |pages=211–220 |isbn=978-0-7803-1910-3 |s2cid=62509261}}</ref>
 
{{clear}}
 
==Language overview==
 
{{sticky header}}
<!--
{|class="wikitable sortable sticky-header" style="font-size:75%;"▼
###############################################################################
To minimize horizontal scrolling, please avoid edits that would significantly increase column widths. Put a space [ ] before each <ref> to allow text wrapping (in small table cells we don't need to worry about refs wrapping away from their subject). In paradigm cells, try not to exceed ~7-letter words - put anything longer in notes. Unless there's a dire need, don't put long templates like {{Citation needed}} in paradigm cells - either put them in the language name cell or in a note (also, precede with a <br /> any templates that don't wrap off otherwise).
###############################################################################
-->
▲{|class="wikitable sortable" style="font-size:75%;"
|+ List of multi-paradigm programming languages
|- style="font-size: 133%;"
Line 56 ⟶ 51:
! Other
|-
| style="font-size: 133%;" | [[Ada (programming language)|Ada]]{{wbr}}<ref>[http://www.adaic.org/standards/05rm/html/RM-TTL.html Ada Reference Manual, ISO/IEC 8652:2005(E) Ed. 3], [http://www.adaic.org/standards/05rm/html/RM-9.html Section 9: Tasks and Synchronization]</ref>{{wbr}}<ref>[http://www.adaic.org/standards/05rm/html/RM-TTL.html Ada Reference Manual, ISO/IEC 8652:2005(E) Ed. 3] [http://www.adaic.org/standards/05rm/html/RM-E.html Annex E: Distributed Systems]</ref>{{wbr}}<ref>[http://www.adaic.org/standards/05rm/html/RM-TTL.html Ada Reference Manual, ISO/IEC 8652:2005(E) Ed. 3], [http://www.adaic.org/standards/05rm/html/RM-12.html Section 12: Generic Units]</ref>{{wbr}}<ref>[http://www.adaic.org/standards/05rm/html/RM-TTL.html Ada Reference Manual, ISO/IEC 8652:2005(E) Ed. 3], [http://www.adaic.org/standards/05rm/html/RM-6.html Section 6: Subprograms]</ref>{{wbr}}<ref>[http://www.adaic.org/standards/05rm/html/RM-TTL.html Ada Reference Manual, ISO/IEC 8652:2005(E) Ed. 3], [http://www.adaic.org/standards/05rm/html/RM-3-9.html 3.9 Tagged Types and Type Extensions]</ref> || 5
| {{yes}} {{wbr}}<ref group="a" name="rend-mon">rendezvous and monitor-like based</ref> || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{yes}} || {{yes}} || {{non/a}} || {{non/a}} || {{yes}} {{wbr}}<ref group="a" name="class"/> || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}}
|-
| style="font-size: 133%;" | [[Algebraic Logic Functional programming language|ALF]] || 2
| {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}}
|-
| style="font-size: 133%;" | [[AmigaE]]<br/>{{Citation needed |date=March 2007}} || 2
| {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{yes}} {{wbr}}<ref group="a" name="class"/> || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}}
|-
| style="font-size: 133%;" | [[APL (programming language)|APL]] || 3
| {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || Array (multi-dimensional)
|-
| style="font-size: 133%;" | [[BETA (programming language)|BETA]]<br/>{{Citation needed |date=March 2007}} || 3
| {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{yes}} {{wbr}}<ref group="a" name="class"/> || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}}
|-
| style="font-size: 133%;" | [[C++]] || 7 (15)
| {{yes}} {{wbr}}<ref>[http://en.cppreference.com/w/cpp/thread Thread support]</ref>{{wbr}}<ref>[http://en.cppreference.com/w/cpp/atomic Atomics support]</ref>{{wbr}}<ref>[https://cppandbeyond.wordpress.com/2011/04/11/session-announcement-the-c0x-memory-model-and-why-you-care Memory model]</ref> || {{partial|Library}} {{wbr}}<ref>[http://www.gecode.org/ Gecode]</ref> || {{partial|Library}} {{wbr}}<ref>[http://www.accellera.org/downloads/standards/systemc/about_systemc/ SystemC]</ref>{{wbr}}<ref>[http://www.boost.org/libs/iostreams/ Boost.Iostreams]</ref> || {{partial|Library}} {{wbr}}<ref>[http://code.google.com/p/boolinq/ Boolinq]</ref>{{wbr}}<ref>{{Cite web |url=https://www.cs.technion.ac.il/~lkeren/scp.pdf |title=AraRat |access-date=2019-09-15 |archive-date=2019-08-19 |archive-url=https://web.archive.org/web/20190819105358/http://www.cs.technion.ac.il/~lkeren/scp.pdf |url-status=dead }}</ref> || {{partial|Library}} {{wbr}}<ref>[http://www.open-mpi.org/ OpenMPI]</ref>{{wbr}}<ref>[http://www.boost.org/libs/mpi/ Boost.MPI]</ref> || {{yes}} || {{yes}} {{wbr}}<ref>[http://www.boost.org/libs/mpl/ Boost.MPL]</ref> || {{yes}} {{wbr}}<ref group="a" name="temp-meta">template metaprogramming</ref> || {{yes}} || {{partial|Library}} {{wbr}}<ref>[http://cgi.di.uoa.gr/~smaragd/lc++/ LC++]</ref>{{wbr}}<ref>[http://www.mpprogramming.com/Cpp/Default.aspx Castor] {{webarchive |url=https://web.archive.org/web/20130125024854/http://www.mpprogramming.com/Cpp/Default.aspx |date=2013-01-25}}</ref> || {{partial|Library}} {{wbr}}<ref>[https://bytemaster.github.com/boost_reflect/ Reflect Library]</ref> || {{yes}} {{wbr}}<ref group="a" name="class"/> || {{yespartial|Library}}{{wbr}} <ref>[http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3534.html N3534]</ref> || {{non/a}} || {{partial|Library}} {{wbr}}<ref>[http://www.boost.org/libs/spirit/ Boost.Spirit]</ref> || Array (multi-dimensional; using [[Standard Template Library|STL]])
|-
| style="font-size: 133%;" | [[C Sharp (programming language)|C#]] || 6 (7)
| {{yes}} || {{non/a}} || {{partial|Library}} {{wbr}}<ref group="a" name="tpldf">using [http://msdn.microsoft.com/en-us/devlabs/gg585582.aspx TPL Dataflow]</ref> || {{non/a}} || {{non/a}} || {{yes}} {{wbr}}<ref group="a" name="lambda">only [[Lambda calculus|lambda]] support (lazy functional programming)</ref> || {{non/a}} || {{yes}} || {{yes}} || {{non/a}} || {{yes}} || {{yes}} {{wbr}}<ref group="a" name="class"/> || {{non/a}} || {{non/a}} || {{non/a}} || Reactive {{wbr}}<ref group="a" name="rx">using [http://msdn.microsoft.com/en-us/data/gg577609.aspx Reactive Extensions (Rx)]</ref>
|-
| style="font-size: 133%;" | [[ChucK]]<br/>{{Citation needed |date=March 2007}} || 3
| {{yes}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{yes}} {{wbr}}<ref group="a" name="class"/> || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}}
|-
| style="font-size: 133%;" | [[Claire (programming language)|Claire]] || 2
| {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} {{wbr}}<ref group="a" name="class"/> || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}}
|-
| style="font-size: 133%;" | [[Clojure]] || 5
| {{yes}} {{wbr}}<ref>[https://clojure.org/about/concurrent_programming Clojure - Concurrent Programming]</ref>{{wbr}}<ref>[https://github.com/clojure/core.async Clojure - core.async]</ref> || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{yes}} {{wbr}}<ref>[https://clojure.org/about/functional_programming Clojure - Functional Programming]</ref> || {{yes}} {{wbr}}<ref>[https://clojure.org/reference/macros Clojure - Macros]</ref> || {{non/a}} || {{non/a}} || {{partial|Library}} {{wbr}}<ref>[https://github.com/clojure/core.logic/ Clojure - core.logic]</ref> || {{non/a}} || {{non/a}} || {{yes}} {{wbr}}<ref>[https://clojure.org/guides/threading_macros Clojure - Threading Macros Guide]</ref> || {{partial|Editor}} <ref>{{Cite web |url=http:n//lighttable.com/ |title=Light Table |date=2019-04-08a}}</ref> || {{non/a}} || [[Multiple dispatch]],{{wbr}}<ref>[https://clojure.org/reference/multimethods Multimethods and Hierarchies]</ref> Agents {{wbr}}<ref>[https://clojure.org/reference/agents Agents and Asynchronous Actions]</ref>
|-
| style="font-size: 133%;" | [[Common Lisp]] || 7 (14)
| {{partial|Library}} {{wbr}}<ref>[{{Cite web |title=concurrency |url=https://www.cliki.net/Concurrency] many concurrency paradigms implemented as language extensions|website=CLiki}}</ref> || {{partial|Library}} {{wbr}}<ref>[https://www.cliki.net/screamer] constraint programming inside CL through extensions</ref> || {{partial|Library}} {{wbr}}<ref>[https://www.cliki.net/Cells] dataflow extension</ref> || {{yes}} {{wbr}}<ref>[http://www.gigamonkeys.com/book/practical-an-html-generation-library-the-interpreter.html] by creating DSLs using the built-in metaprogramming; also see note on functional, constraint and logic paradigms, which are part of declarative</ref> || {{partial|Library}} {{wbr}}<ref>[https://www.cliki.net/Distributed] MPI, etc via language extensions</ref> || {{yes}} || {{yes}} || {{yes}} {{wbr}}<ref>template metaprogramming using macros (see C++)</ref> || {{yes}} || {{partial|Library}} {{wbr}}<ref>[https://www.cliki.net/Prolog] [https://franz.com/products/prolog/] [http://www.lispworks.com/products/knowledgeworks.html] [[Prolog]] implemented as a language extension</ref> || {{yes}} || {{yes}} {{wbr}}<ref group="a" name="multiple-dispatch2">multiple dispatch, method combinations</ref> {{wbr}}<ref group="a" name="class"/> {{wbr}}<ref>[[Common Lisp Object System]] see Wikipedia article on CLOS, the Common Lisp Object System.</ref> || {{partial|Library}} {{wbr}}<ref>[http://blog.vjeux.com/2011/lisp/lisp-chaining-operator.html implemented by the user via a short macro, example of implementation]</ref> || {{partial|Library}} {{wbr}}<ref>[https://github.com/honix/Lire - Visual programming tool based on Common Lisp]</ref> || {{partial|Library}} {{wbr}}<ref>[httphttps://lisa.sourceforge.net/] rule-based programming extension</ref> || Multiple dispatch, meta-OOP system,{{wbr}}<ref>[https://common-lisp.net/project/ecl/static/manual/ch31.html] {{Webarchive|url=https://web.archive.org/web/20180426012208/https://common-lisp.net/project/ecl/static/manual/ch31.html|date=2018-04-26}} through the Meta Object Protocol</ref> Language is extensible via metaprogramming.
|-
| style="font-size: 133%;" | [[Curl (programming language)|Curl]] || 5
| {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{yes}} {{wbr}}<ref group="a" name="temp-meta"/> || {{yes}} || {{non/a}} || {{yes}} || {{yes}} {{wbr}}<ref group="a" name="class"/> || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}}
|-
| style="font-size: 133%;" | [[Curry (programming language)|Curry]] || 4
| {{yes}} || {{yes}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}}
|-
| style="font-size: 133%;" | [[D (programming language)|D]] (version 2.0) {{wbr}}<ref>[http://www.digitalmars.com/d/2.0/comparison.html D Language Feature Table]</ref>{{wbr}}<ref>[http://www.digitalmars.com/d/2.0/phobos/std_algorithm.html Phobos std.algorithm]</ref> || 7
| {{yes}} {{wbr}}<ref group="a" name="actor"/> || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{yes}} {{wbr}}<ref>[http://dlang.org/mixin.html D language String Mixins]</ref> {{wbr}}<ref group="a" name="temp-meta"/> || {{yes}} {{wbr}}<ref group="a" name="temp-meta"/> || {{yes}} || {{non/a}} || {{yes}} || {{yes}} {{wbr}}<ref group="a" name="class"/> || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}}
|-
| style="font-size: 133%;" | [[Delphi (software)|Delphi]] || 3
| {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} {{wbr}}<ref group="a" name="temp-meta"/> || {{yes}} || {{non/a}} || {{non/a}} || {{yes}} {{wbr}}<ref group="a" name="class"/> || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}}
|-
| style="font-size: 133%;" | [[Dylan (programming language)|Dylan]]<br/>{{Citation needed |date=March 2007}} || 3
| {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{yes}} {{wbr}}<ref group="a" name="class">class-based</ref> || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}}
|-
| style="font-size: 133%;" | [[E (programming language)|E]] || 3
| {{yes}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} {{wbr}}<ref group="a" name="class"/> || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}}
|-
| style="font-size: 133%;" | [[ECMAScript]]{{wbr}}<ref>[http://www.crockford.com/javascript/little.html The Little JavaScripter] demonstrates fundamental commonality with Scheme, a functional language.</ref>{{wbr}}<ref>[http://mckoss.com/jscript/object.htm Object-Oriented Programming in JavaScript] {{Webarchive |url=https://web.archive.org/web/20190210070220/http://mckoss.com/jscript/object.htm |date=2019-02-10}} gives an overview of object-oriented programming techniques in JavaScript.</ref> ([[ActionScript]], [[ECMAScript for XML|E4X]], [[JavaScript]], [[JScript]]) || 4 (5)
| {{partial}} {{wbr}}<ref group="a" name="promises">promises, native extensions</ref> {{wbr}}<ref group="a" name="nodejs-cluster">using [[Node.js]]' [https://nodejs.org/api/cluster.html cluster] module or [https://nodejs.org/api/child_process.html#child_process_child_process_fork_modulepath_args_options child_process.fork] method, [https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Using_web_workers web workers] in the browser, etc.</ref> || {{non/a}} || {{non/a}} || {{partial|Library}} {{wbr}}<ref>{{Cite web |url=https://reactjs.org/ |title=React – A JavaScript library for building user interfaces |date=2019-04-08}}</ref>{{wbr}}<ref>{{Cite web |url=https://github.com/getify/tng-hooks |title=TNG-Hooks |website=[[GitHub]] |date=2019-04-08}}</ref> || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{yes}} || {{yes}} {{wbr}}<ref group="a" name="prototype">Prototype-based</ref> || {{partial|Library}} {{wbr}}<ref>{{Cite web |url=https://lodash.com/docs/4.17.11#flow |title=Lodash documentation |date=2019-04-08}}</ref>{{wbr}}<ref>{{Cite web |url=https://swannodette.github.io/mori/#pipeline |title=mori |date=2019-04-08}}</ref> || {{partial|Editor}} <ref>{{Cite web |url=http:n//lighttable.com/ |title=Light Table |date=2019-04-08a}}</ref> || {{non/a}} || Reactive, {{wbr}}<ref group="a" name="rxjs">using [http://reactivex.io/rxjs/ Reactive Extensions (RxJS)]</ref>{{wbr}}<ref>{{Cite web |url=https://github.com/getify/tng-hooks |title=TNG-Hooks |website=[[GitHub]] |date=2019-04-08}}</ref> event driven {{wbr}}<ref group="a" name="node-events">in Node.js via their [https://nodejs.org/api/events.html events] module</ref> {{wbr}}<ref group="a" name="dom-events">in browsers via their native [https://developer.mozilla.org/en-US/docs/Web/API/EventTarget EventTarget] API</ref>
|-
| style="font-size: 133%;" | [[Erlang (programming language)|Erlang]] || 3
| {{yes}} || {{non/a}} || {{non/a}} || {{yes}} || {{yes}} || {{yes}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{non/a}}
|-
| style="font-size: 133%;" | [[Elixir (programming language)|Elixir]] || 4
| {{yes}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{yes}} || {{yes}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{non/a}}
|-
| style="font-size: 133%;" | [[Elm (programming language)|Elm]] || 6
| {{yes}} || {{non/a}} || {{yes}} || {{yes}} || {{non/a}} || {{yes}} ([[Purely functional programming|pure]]) {{wbr}}<ref group="a" name="pure-func">purely functional</ref> || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || Reactive
|-
| style="font-size: 133%;" | [[F Sharp (programming language)|F#]] || 7 (8)
| {{yes}} {{wbr}}<ref group="a" name="actor">actor programming</ref> || {{non/a}} || {{partial|Library}} {{wbr}}<ref group="a" name="tpldf"/> || {{yes}} || {{non/a}} || {{yes}} || {{non/a}} || {{yes}} || {{yes}} || {{non/a}} || {{yes}} || {{yes}} {{wbr}}<ref group="a" name="class"/> || {{non/a}} || {{non/a}} || {{non/a}} || Reactive {{wbr}}<ref group="a" name="rx"/>
|-
| style="font-size: 133%;" | [[Fortran]] || 4 (5)
| {{yes}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} {{wbr}}<ref group="a" name="pure-func">purely functional</ref> || {{non/a}} || {{yes}} {{wbr}}<ref group="a" name="param-class">parameterized classes</ref> || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} {{wbr}}<ref group="a" name="class"/> || {{non/a}} || {{non/a}} || {{non/a}} || Array (multi-dimensional)
|-
| style="font-size: 133%;" |[[Go (programming language)|Go]] || 4
| {{yes}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{yes}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{non/a}}
|-
| style="font-size: 133%;" | [[Haskell]] || 8 (15)
| {{yes}} || {{partial|Library}} {{wbr}}<ref>{{Cite web |url=https://hackage.haskell.org/package/hswip |title=Prolog embedding |website=Haskell.org}}</ref> || {{partial|Library}} {{wbr}}<ref>{{Cite web |url=https://wiki.haskell.org/Functional_Reactive_Programming |title=Functional Reactive Programming |website=HaskellWiki}}</ref> || {{yes}} || {{partial|Library}} {{wbr}}<ref>[https://haskell-distributed.github.io/ Cloud Haskell]</ref> || {{yes}} ([[lazy evaluation|lazy]]) ([[Purely functional programming|pure]]) {{wbr}}<ref group="a" name="pure-func">purely functional</ref> || {{yes}} {{wbr}}<ref>{{Cite web |url=https://wiki.haskell.org/Template_Haskell |title=Template Haskell |website=HaskellWiki}}</ref> || {{yes}} || {{yes}} || {{partial|Library}} {{wbr}}<ref>{{Cite web |url=https://hackage.haskell.org/package/logict |title=Logict: A backtracking logic-programming monad |website=Haskell.org}}</ref> || {{non/a}} || {{partial}} {{wbr}}<ref group="a" name="immutable">immutable</ref> || {{yes}} || {{yes}} || {{partial|Library}} {{wbr}}<ref>{{Cite web |last1=Kollmansberger |first1=Steve |last2=Erwig |first2=Martin |date=30 May 2006 |url=https://web.engr.oregonstate.edu/~erwig/HaskellRules/HaskellRules_June06.pdf |title=Haskell Rules: Embedding Rule Systems in Haskell |website=[[Oregon State University]]}}</ref> || Literate, reactive, dependent types (partial)
|- |
| style="font-size: 133%;" | [[Io (programming language)|Io]] || 4
| {{yes}} {{wbr}}<ref group="a" name="actor"/> || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{yes}} {{wbr}}<ref group="a" name="prototype"/> || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}}
|-
| style="font-size: 133%;" | [[J (programming language)|J]]<br/>{{Citation needed |date=March 2007}} || 3
| {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{yes}} {{wbr}}<ref group="a" name="class"/> || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}}
|-
| style="font-size: 133%;" | [[Java (programming language)|Java]] || 6
| {{yes}} || {{partial|Library}} {{wbr}}<ref>https://jcp.org/en/jsr/detail?id=331 JSR 331: Constraint Programming API</ref> || {{partial|Library}} {{wbr}}<ref>https://github.com/GoogleCloudPlatform/DataflowJavaSDK Google Cloud Platform Dataflow SDK</ref> || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{yes}} || {{yes}} || {{non/a}} || {{yes}} || {{yes}} {{wbr}}<ref group="a" name="class"/> || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}}
|-
| style="font-size: 133%;" | [[Julia (programming language)|Julia]] || 9 (17)
| {{yes}} || {{partial|Library}} {{wbr}}<ref>{{cite web |title=JuliaOpt/JuMP.jl |url=https://github.com/JuliaOpt/JuMP.jl |website=GitHub |publisher=JuliaOpt |access-date=12 February 2020 |date=11 February 2020}}</ref> || {{partial|Library}} {{wbr}}<ref>{{Cite web |url=https://github.com/MikeInnes/DataFlow.jl |title=GitHub - MikeInnes/DataFlow.jl |website=[[GitHub]] |date=2019-01-15}}</ref>{{wbr}}<ref>{{Cite web |url=https://github.com/JuliaGizmos/Reactive.jl |title=GitHub - JuliaGizmos/Reactive.jl: Reactive programming primitives for Julia |website=[[GitHub]] |date=2018-12-28}}</ref> || {{partial|Library}} {{wbr}}<ref>https://github.com/davidanthoff/Query.jl Query almost anything in julia</ref> || {{yes}} || {{yes}} ([[eager evaluation|eager]]) || {{yes}} || {{yes}} || {{yes}} || {{partial|Library}} {{wbr}}<ref>https://github.com/lilinjn/LilKanren.jl A collection of Kanren implementations in Julia</ref> || {{yes}} || {{yesPartial}}{{wbr}} <ref group="a" name="multiple-dispatch1">multipleUses dispatch,structs notwith traditionalfunction singlepolymorphism and multiple dispatch</ref> || {{yes}} || {{non/a}} || {{partial|Library}} {{wbr}}<ref>{{Cite web |url=https://github.com/abeschneider/PEGParser.jl |title=GitHub - abeschneider/PEGParser.jl: PEG Parser for Julia |website=[[GitHub]] |date=2018-12-03}}</ref>{{wbr}}<ref>{{Cite web |url=https://github.com/gitfoxi/Parsimonious.jl |title=GitHub - gitfoxi/Parsimonious.jl: A PEG parser generator for Julia |website=[[GitHub]] |date=2017-08-03}}</ref> || [[Multiple dispatch]],<br/>Array (multi-dimensional); optionally [[lazy evaluation|lazy]]{{wbr}}<ref>Lazy https://github.com/MikeInnes/Lazy.jl</ref> and reactive (with libraries)
|-
| style="font-size: 133%;" |[[Kotlin (programming language)|Kotlin]] || 8
| {{yes}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{non/a}} || {{yes}} || {{yes}} || {{yes}} || {{non/a}} || {{non/a}} || {{non/a}}
|- |
| style="font-size: 133%;" | [[LabVIEW]] || 4
| {{yes}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}}
|-
| style="font-size: 133%;" | [[Lava (programming language)|Lava]] || 2
| {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} {{wbr}}<ref group="a" name="class"/> || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}}
|-
| style="font-size: 133%;" | [[LispWorks]] (version 6.0 with support for symmetric multi-processing, rules, logic ([[Prolog]]), [[Common Object Request Broker Architecture|CORBA]]) || 9
| {{yes}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{yes}} || {{yes}} || {{non/a}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} {{wbr}}<ref group="a" name="class"/> || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}}
|-
| style="font-size: 133%;" | [[Lua (programming language)|Lua]]<br/>{{Citation needed |date=March 2007}} || 3
| {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{yes}} {{wbr}}<ref group="a" name="prototype"/> || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}}
|-
| style="font-size: 133%;" | [[MATLAB]] || 6 (10)
| {{partial|Toolbox}} {{wbr}}<ref>{{cite web |title=Execute loop iterations in parallel |url=http://mathworks.com/help/distcomp/parfor.html |website=mathworks.com |access-date=21 October 2016}}</ref> || {{partial|Toolbox}} {{wbr}}<ref>{{cite web |title=Write Constraints |url=https://mathworks.com/help/optim/write-constraints.html |website=mathworks.com |access-date=21 October 2016}}</ref> || {{yes}} {{wbr}}<ref>{{cite web |title=Getting Started with SimEvents |url=https://mathworks.com/help/simevents/getting-started-with-simevents.html |website=mathworks.com |access-date=21 October 2016}}</ref> || {{non/a}} || {{partial|Toolbox}} {{wbr}}<ref>{{cite web |title=Execute loop iterations in parallel |url=http://mathworks.com/help/distcomp/parfor.html |website=mathworks.com |access-date=21 October 2016}}</ref> || {{non/a}} || {{yes}} {{wbr}}<ref>{{cite web |title=Execute MATLAB expression in text - MATLAB eval |url=https://mathworks.com/help/matlab/ref/eval.html |website=mathworks.com |access-date=21 October 2016}}</ref> || {{yes}} {{wbr}}<ref>{{cite web |title=Determine class of object |url=https://mathworks.com/help/matlab/ref/class.html |website=mathworks.com |access-date=21 October 2016}}</ref> || {{non/a}} || {{non/a}} || {{yes}} {{wbr}}<ref>{{cite web |title=Class Metadata |url=https://mathworks.com/help/matlab/get-information-about-classes-and-objects.html |website=mathworks.com |access-date=21 October 2016}}</ref> || {{yes}} {{wbr}}<ref>{{cite web |title=Object-Oriented Programming |url=https://mathworks.com/help/matlab/object-oriented-programming.html |website=mathworks.com |access-date=21 October 2016}}</ref> || {{non/a}} || {{yes}} {{wbr}}<ref>{{cite web |title=Simulink |url=https://mathworks.com/help/simulink/ |website=mathworks.com |access-date=21 October 2016}}</ref> || {{non/a}} || Array (multi-dimensional)
|-
| style="font-size: 133%;" | [[Nemerle]] || 7
| {{yes}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{non/a}} || {{yes}} || {{yes}} {{wbr}}<ref group="a" name="class"/> || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}}
|-
| style="font-size: 133%;" | [[Object Pascal]] || 4
| {{yes}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{yes}} {{wbr}}<ref group="a" name="class"/> || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}}
|-
| style="font-size: 133%;" | [[OCaml]] || 4
| {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{yes}} || {{yes}} || {{non/a}} || {{non/a}} || {{yes}} {{wbr}}<ref group="a" name="class"/> || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}}
|-
| style="font-size: 133%;" | [[Oz (programming language)|Oz]] || 11
| {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{non/a}} || {{non/a}} || {{yes}} || {{yes}} || {{non/a}} || {{yes}} {{wbr}}<ref group="a" name="class"/> || {{yes}} || {{non/a}} || {{yes}} || {{non/a}}
|-
| style="font-size: 133%;" | [[Perl]]<br/>{{Citation needed |date=March 2007}} || 8 (9)
| {{yes}} {{wbr}}<ref>[http://perldoc.perl.org/threads.html interpreter based threads]</ref> || {{partial|Libraryn/a}} <ref>[[Moose (Perl)|Moose]]</ref> || {{yes}} {{wbr}}<ref>[http://hop.perl.plover.com/book/ Higher Order Perl]</ref> || {{non/a}} || {{non/a}} || {{yes}} || {{yes}} || {{non/a}} || {{yes}} || {{non/a}} || {{yes}} {{wbr}}<ref group="a" name="class"/> || {{yes}} {{wbr}}<ref group="a" name="class"/> || {{yes}} || {{non/a}} || {{non/a}} || {{non/a}}
|-
| style="font-size: 133%;" | [[PHP]]{{wbr}}<ref>[http://php.net/manual/en/index.php PHP Manual], [http://php.net/manual/en/language.functions.php Chapter 17. Functions]</ref>{{wbr}}<ref>[http://php.net/manual/en/index.php PHP Manual], [http://php.net/manual/en/language.oop5.php Chapter 19. Classes and Objects (PHP 5)]</ref>{{wbr}}<ref>[http://php.net/manual/en/index.php PHP Manual], [http://docs.php.net/functions.anonymous Anonymous functions]</ref> || 4
| {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{yes}} || {{yes}} {{wbr}}<ref group="a" name="class"/> || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}}
|-
| style="font-size: 133%;" | [[Poplog]] || 3
| {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{yes}} || {{yes}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}}
|-
| style="font-size: 133%;" | [[Prograph]] || 3
| {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} {{wbr}}<ref group="a" name="class"/> || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}}
|-
| style="font-size: 133%;" | [[Python (programming language)|Python]] || 5 (10)
| {{partial|Library}} {{wbr}}<ref>{{cite web |title=Parallel Processing and Multiprocessing in Python |url=https://wiki.python.org/moin/ParallelProcessing |website=Python Wiki |access-date=21 October 2016}}</ref>{{wbr}}<ref>{{cite web |title=threading — Higher-level threading interface |url=https://docs.python.org/2/library/threading.html |website=docs.python.org |access-date=21 October 2016}}</ref>
| {{partial|Library}} {{wbr}}<ref>{{cite web |title=python-constraint |url=https://pypi.python.org/pypi/python-constraint |website=pypi.python.org |access-date=21 October 2016}}</ref>
| {{non/a}}
| {{non/a}}
| {{partial|Library}} {{wbr}}<ref>{{cite web |title=DistributedProgramming |url=https://wiki.python.org/moin/DistributedProgramming |website=Python Wiki |access-date=21 October 2016}}</ref>
| {{yes}}
| {{yes}} {{wbr}}<ref>{{cite web |title=Chapter 9. Metaprogramming |url=http://chimera.labs.oreilly.com/books/1230000000393/ch09.html |website=chimera.labs.oreilly.com |access-date=22 October 2016 |archive-url=https://web.archive.org/web/20161023050954/http://chimera.labs.oreilly.com/books/1230000000393/ch09.html |archive-date=23 October 2016 |url-status=dead}}</ref>{{wbr}}<ref>{{cite web |title=Metaprogramming |url=https://python-3-patterns-idioms-test.readthedocs.io/en/latest/Metaprogramming.html |website=readthedocs.io |access-date=22 October 2016}}</ref>
| {{yes}} {{wbr}}<ref>{{cite web |title=PEP 443 – Single-dispatch generic functions |url=https://www.python.org/dev/peps/pep-0443/ |website=python.org |access-date=22 October 2016}}</ref>{{wbr}}<ref>{{cite web |title=PEP 484 – Type Hints |url=https://www.python.org/dev/peps/pep-0484/#generics |website=python.org |access-date=22 October 2016}}</ref> || {{yes}} || {{partial|Library}} {{wbr}}<ref>{{cite web |url=https://sites.google.com/site/pydatalog/ |title=PyDatalog |access-date=22 October 2016}}</ref> || {{yes}} || {{yes}} {{wbr}}<ref group="a" name="class"/>
| {{non/a}} || {{partial|Editor}} <ref>{{Cite web |url=http:n//lighttable.com/ |title=Light Table |date=2019-04-08a}}</ref> || {{non/a}} || [[Structured programming|Structured]]
|-
| style="font-size: 133%;" | [[R (programming language)|R]] || 4 (6)
| {{partial|Library}} {{wbr}}<ref>{{cite web |title=Futureverse |url=https://www.futureverse.org/}}</ref> || {{non/a}} || {{non/a}} || {{non/a}} || {{partial|Library}} {{wbr}}<ref>{{cite web |title=future batchtools |url=https://future.batchtools.futureverse.org/}}</ref> || {{yes}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{yes}} || {{yes}} || {{yes}} {{wbr}}<ref>{{cite web |title= Magrittr: A Forward Pipe Operator for R |url=https://cran.r-project.org/package=magrittr |website=cran.r-project.org\access-date=13 July 2017 |date=17 November 2020}}</ref> || {{non/a}} || {{non/a}} || Array (multi-dimensional)
|-
| style="font-size: 133%;" | [[Racket (programming language)|Racket]] || 10
| {{yes}} {{wbr}}<ref>[https://docs.racket-lang.org/guide/concurrency.html Racket Guide: Concurrency and Synchronization]</ref> || {{yes}} {{wbr}}<ref>[https://docs.racket-lang.org/rosette-guide/ The Rosette Guide]</ref> || {{yes}} {{wbr}}<ref>[https://docs.racket-lang.org/frtime/ FrTime: A Language for Reactive Programs]</ref> || {{non/a}} || {{yes}} {{wbr}}<ref>[https://docs.racket-lang.org/guide/parallelism.html#%28part._distributed-places%29 Racket Guide: Distributed Places]</ref> || {{yes}} || {{yes}} || {{non/a}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{non/a}} || {{non/a}} || {{non/a}} || Lazy {{wbr}}<ref>[https://docs.racket-lang.org/lazy/ Lazy Racket]</ref>
|-
| style="font-size: 133%;" | [[Raku (programming language)|Raku]] || 10
| {{yes}} {{wbr}}<ref>[https://docs.perl6.org/language/concurrency Channels and other mechanisms]</ref> || {{yespartial|Library}}{{wbr}} <ref>{{Cite web |url=https://docs.perl6raku.orgland/typegithub:FCO/Signature#Type_ConstraintsProblemSolver |title=ClassProblem SignatureSolver module}}</ref> || {{yes}} {{wbr}}<ref>[https://docs.perl6.org/routine/==%3E Feed operator]</ref> || {{non/a}} || {{partial|Library}} {{wbr}}<ref>https://github.com/perl6/doc/issues/1744#issuecomment-360565196 Cro module</ref> || {{yes}} || {{yes}} {{wbr}}<ref>{{Cite web |url=https://perl6advent.wordpress.com/2011/12/14/meta-programming-what-why-and-how/ |title=Meta-programming: What, why and how |date=2011-12-14}}</ref> || {{yes}} {{wbr}}<ref>https://perl6advent.wordpress.com/2009/12/18/day-18-roles/ Parametrized Roles</ref> || {{yes}} || {{non/a}} || {{yes}} {{wbr}}<ref>{{Cite web |url=https://docs.perl6.org/language/mop |title=Meta-object protocol (MOP)}}</ref> || {{yes}} {{wbr}}<ref>https://docs.perl6.org/language/classtut Classes and Roles</ref> || {{yes}} || {{non/a}} || {{non/a}} || Multiple dispatch, lazy lists, reactive.
|-
| style="font-size: 133%;" | [[ROOP (programming language)|ROOP]] || 3
| {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{yes}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}}
|-
| style="font-size: 133%;" | [[Ruby (programming language)|Ruby]] || 5
| {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{yes}} || {{non/a}} || {{yes}} || {{non/a}} || {{yes}} || {{yes}} {{wbr}}<ref group="a" name="class"/> || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}}
|-
| style="font-size: 133%;" | [[Rust (programming language)|Rust]] (version 1.0.0-alpha) || 6
| {{yes}} {{wbr}}<ref group="a" name="actor"/> || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{yes}} {{wbr}}<ref>{{cite web |title=The Rust macros guide |url=http://doc.rust-lang.org/1.0.0-alpha/book/macros.html |website=Rust |access-date=19 January 2015|ref=rust-macros}}</ref>{{wbr}}<ref>{{cite web |title=The Rust compiler plugins guide |url=http://doc.rust-lang.org/1.0.0-alpha/book/plugins.html |website=Rust |access-date=19 January 2015|ref=rust-plugins}}</ref> || {{yes}} {{wbr}}<ref>[http://doc.rust-lang.org/1.0.0-alpha/reference.html#generic-functions The Rust Reference §6.1.3.1]</ref> || {{yes}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{non/a}} || Linear, affline, and ownership types
|-
| style="font-size: 133%;" | [[Sather]]<br/>{{Citation needed |date=March 2007}} || 2
| {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} {{wbr}}<ref group="a" name="class"/> || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}}
|-
| style="font-size: 133%;" | [[Scala (programming language)|Scala]]{{wbr}}<ref>[http://www.scala-lang.org/sites/default/files/linuxsoft_archives/docu/files/ScalaOverview.pdf An Overview of the Scala Programming Language]</ref>{{wbr}}<ref>[https://wayback.archive-it.org/all/20171003043151/http://www.scala-lang.org/sites/default/files/linuxsoft_archives/docu/files/ScalaReference.pdf Scala Language Specification]</ref> || 9
| {{yes}} {{wbr}}<ref group="a" name="actor">actor programming</ref> || {{non/a}} || {{yes}} {{wbr}}<ref group="a" name="akka">[http://doc.akka.io/docs/akka/snapshot/scala/dataflow.html Akka] {{webarchive |url=https://web.archive.org/web/20130119045517/http://doc.akka.io/docs/akka/snapshot/scala/dataflow.html |date=2013-01-19}}</ref> || {{yes}} || {{non/a}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{non/a}} || {{yes}} || {{yes}} {{wbr}}<ref group="a" name="class"/> || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}}
|-
| style="font-size: 133%;" | [[Simula]]<br/>{{Citation needed |date=March 2007}} || 2
| {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{yes}} {{wbr}}<ref group="a" name="class"/> || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}}
|-
| style="font-size: 133%;" | [[SISAL]] || 3
| {{yes}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}}
|-
| style="font-size: 133%;" | [[Spreadsheet]]s || 2
| {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}}
|-
| style="font-size: 133%;" | [[Swift (programming language)|Swift]] || 7
| {{yes}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{non/a}} || {{yes}} || {{yes}} {{wbr}}<ref group="a" name="class"/> || {{non/a}} || {{non/a}} || {{non/a}} || Block-structured
|-
| style="font-size: 133%;" | [[Tcl]] with Snit extension<br/>{{Citation needed |date=March 2007}} || 3
| {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} {{wbr}}<ref>{{cite web |title=Tcl Programming/Introduction |url=https://en.wikibooks.org/wiki/Tcl_Programming/Introduction#One_language.2C_many_styles |website=en.wikibooks.org |access-date=22 October 2016}}</ref> || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{non/a}} || {{yes}} {{wbr}}<ref group="a" name="prototype"/> {{wbr}}<ref>{{cite web |title=TCLLIB - Tcl Standard Library: snitfaq |url=httphttps://tmml.sourceforge.net/doc/tcllib/snitfaq.html |website=sourceforge.net |access-date=22 October 2016}}</ref> || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}}
|-
| style="font-size: 133%;" | [[Visual Basic .NET]] || 6 (7)
| {{yes}} || {{non/a}} || {{partial|Library}} {{wbr}}<ref group="a" name="tpldf"/> || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{yes}} || {{yes}} || {{non/a}} || {{yes}} || {{yes}} {{wbr}}<ref group="a" name="class"/> || {{non/a}} || {{non/a}} || {{non/a}} || Reactive {{wbr}}<ref group="a" name="rx"/>
|-
| style="font-size: 133%;" | [[Windows PowerShell]] || 6
| {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{non/a}} || {{yes}} || {{non/a}} || {{yes}} || {{yes}} || {{non/a}} || {{yes}} || {{yes}} {{wbr}}<ref group="a" name="class"/> || {{yes}} || {{non/a}} || {{non/a}} || {{non/a}}
|-
| style="font-size: 133%;" | [[Wolfram Language]] & [[Mathematica]] || 13 {{wbr}}<ref>[http://www.wolfram.com/language/for-experts/ Notes for Programming Language Experts], Wolfram Language Documentation.</ref> (14)
| {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} || {{yes}} {{wbr}}<ref>[https://reference.wolfram.com/language/tutorial/ExternalPrograms.html External Programs], Wolfram Language Documentation.</ref> || {{non/a}} || {{yes}} || Knowledge Based
|}
<!-- Row Template:
|-
| lang || count || concurrent || constrain || dataf || decl || dist || func || meta || generic || imp || logic || reflect || OO || pipeline || visual || rules || other
{{yes}} {{non/a}}
-->
 
Retrieved from "https://en.wikipedia.org/wiki/Comparison_of_multi-paradigm_programming_languages"