Declarative programming - Revision history

Panamitsu: rm blank lines

2025-06-08T23:38:53Z

rm blank lines

← Previous revision		Revision as of 23:38, 8 June 2025
Line 124:		Line 124:
	\| isbn = 0-201-71012-9		\| isbn = 0-201-71012-9
	}}</ref>		}}</ref>


	===Prolog===		===Prolog===
	[[Prolog]] (1972) stands for "PROgramming in LOGic." It was developed for natural language [[question answering]],<ref name="PrologHistory">{{cite web		[[Prolog]] (1972) stands for "PROgramming in LOGic." It was developed for natural language [[question answering]],<ref name="PrologHistory">{{cite web

2607:FEA8:25A3:A100:9A88:FE89:A336:1C34: /* Lisp */ use srfi-1's 'iota' rather than the python-like 'range' in the scheme example code

2025-01-29T06:58:40Z

Lisp: use srfi-1's 'iota' rather than the python-like 'range' in the scheme example code

← Previous revision		Revision as of 06:58, 29 January 2025
Line 79:		Line 79:
	<syntaxhighlight lang=scheme>		<syntaxhighlight lang=scheme>
	(define (first-n-squares n)		(define (first-n-squares n)
			(map (lambda (x) (* x x)) ;;; A function mapping x -> x^2
	(map
	~~(lambda~~ (x) (* x ~~x))~~ ;;; ~~A function~~ ~~mapping~~ x -> ~~x^2~~		(iota n))) ;;; Lists the first n naturals
	(range n))) ;;; List of the first n non-negative integers
	</syntaxhighlight>		</syntaxhighlight>

Jochen Burghardt: Undid revision 1259404164 by 45.141.239.74 (talk)

2024-11-25T10:54:14Z

Undid revision 1259404164 by 45.141.239.74 (talk)

← Previous revision		Revision as of 10:54, 25 November 2024
Line 35:		Line 35:
	===Domain-specific languages===		===Domain-specific languages===
	{{main\|Domain-specific language}}		{{main\|Domain-specific language}}
	Well-known examples of declarative domain-specific languages (DSLs) include the [[yacc]] parser generator input language, [[QML]], the [[Make (software)\|Make]] build [[specification language]], [[Puppet (software)\|Puppet]]'s configuration management language, [[regular expression]]s, [[Datalog]], [[answer set programming]] and a subset of [[SQL]] (SELECT queries, for example). DSLs have the advantage of being useful while not necessarily needing to be [[Turing-complete]], which makes it easier for a language to be purely declarative.		Well-known examples of declarative domain-specific languages (DSLs) include the [[yacc]] parser generator input language, [[QML]], the [[Make (software)\|Make]] build specification language, [[Puppet (software)\|Puppet]]'s configuration management language, [[regular expression]]s, [[Datalog]], [[answer set programming]] and a subset of [[SQL]] (SELECT queries, for example). DSLs have the advantage of being useful while not necessarily needing to be [[Turing-complete]], which makes it easier for a language to be purely declarative.

	Many markup languages such as [[HTML]], [[MXML]], [[XAML]], [[XSLT]] or other [[user-interface markup language]]s are often declarative. HTML, for example, only describes what should appear on a webpage - it specifies neither [[control flow]] for rendering a page nor the page's possible [[human-computer interaction\|interactions with a user]].		Many markup languages such as [[HTML]], [[MXML]], [[XAML]], [[XSLT]] or other [[user-interface markup language]]s are often declarative. HTML, for example, only describes what should appear on a webpage - it specifies neither [[control flow]] for rendering a page nor the page's possible [[human-computer interaction\|interactions with a user]].

45.141.239.74: /* Domain-specific languages */

2024-11-24T23:44:29Z

Domain-specific languages

← Previous revision		Revision as of 23:44, 24 November 2024
Line 35:		Line 35:
	===Domain-specific languages===		===Domain-specific languages===
	{{main\|Domain-specific language}}		{{main\|Domain-specific language}}
	Well-known examples of declarative domain-specific languages (DSLs) include the [[yacc]] parser generator input language, [[QML]], the [[Make (software)\|Make]] build specification language, [[Puppet (software)\|Puppet]]'s configuration management language, [[regular expression]]s, [[Datalog]], [[answer set programming]] and a subset of [[SQL]] (SELECT queries, for example). DSLs have the advantage of being useful while not necessarily needing to be [[Turing-complete]], which makes it easier for a language to be purely declarative.		Well-known examples of declarative domain-specific languages (DSLs) include the [[yacc]] parser generator input language, [[QML]], the [[Make (software)\|Make]] build [[specification language]], [[Puppet (software)\|Puppet]]'s configuration management language, [[regular expression]]s, [[Datalog]], [[answer set programming]] and a subset of [[SQL]] (SELECT queries, for example). DSLs have the advantage of being useful while not necessarily needing to be [[Turing-complete]], which makes it easier for a language to be purely declarative.

	Many markup languages such as [[HTML]], [[MXML]], [[XAML]], [[XSLT]] or other [[user-interface markup language]]s are often declarative. HTML, for example, only describes what should appear on a webpage - it specifies neither [[control flow]] for rendering a page nor the page's possible [[human-computer interaction\|interactions with a user]].		Many markup languages such as [[HTML]], [[MXML]], [[XAML]], [[XSLT]] or other [[user-interface markup language]]s are often declarative. HTML, for example, only describes what should appear on a webpage - it specifies neither [[control flow]] for rendering a page nor the page's possible [[human-computer interaction\|interactions with a user]].

Guy Harris: Put back original version of the reference.

2024-09-15T23:21:10Z

Put back original version of the reference.

← Previous revision		Revision as of 23:21, 15 September 2024
Line 5:		Line 5:
	In [[computer science]], '''declarative programming''' is a [[programming paradigm]]—a style of building the structure and elements of computer programs—that expresses the logic of a [[computation]] without describing its [[control flow]].<ref>{{citation\|last=Lloyd\|first=J.W.\|title=Practical Advantages of Declarative Programming}}</ref>		In [[computer science]], '''declarative programming''' is a [[programming paradigm]]—a style of building the structure and elements of computer programs—that expresses the logic of a [[computation]] without describing its [[control flow]].<ref>{{citation\|last=Lloyd\|first=J.W.\|title=Practical Advantages of Declarative Programming}}</ref>

	Many languages that apply this style attempt to minimize or eliminate [[side effect (computer science)\|side effects]] by describing ''what'' the program must accomplish in terms of the [[domain knowledge\|problem domain]], rather than describing ''how'' to accomplish it as a sequence of the programming [[language primitive]]s<ref name="FOLDOC 2004">{{cite web \|~~date~~=~~May~~ ~~17, 2004~~ \|~~title~~=FOLDOC: ~~declarative~~ ~~language~~ \|url=https://foldoc.org/declarative+language \|~~url~~-~~status~~= \|archive-~~url~~= \|archive-~~date~~= \|~~access~~-~~date~~=~~September~~ ~~7, 2023 \|website=FOLDOC~~}}</ref> (the ''how'' being left up to the language's [[programming language implementation\|implementation]]). This is in contrast with [[imperative programming]], which implements [[algorithm]]s in explicit steps.<ref name="Sebesta 2016">{{cite book \| last=Sebesta \| first=Robert \| title=Concepts of programming languages \| publisher=Pearson \| publication-place=Boston \| year=2016 \| isbn=978-0-13-394302-3 \| oclc=896687896}}</ref><ref>{{Cite web \|date=2021-05-21 \|title=Imperative programming: Overview of the oldest programming paradigm \|url=https://www.ionos.com/digitalguide/websites/web-development/imperative-programming/ \|access-date=2023-05-23 \|website=IONOS Digital Guide \|language=en-US \|archive-date=2022-05-03 \|archive-url=https://web.archive.org/web/20220503083342/https://www.ionos.com/digitalguide/websites/web-development/imperative-programming/ \|url-status=live }}</ref>		Many languages that apply this style attempt to minimize or eliminate [[side effect (computer science)\|side effects]] by describing ''what'' the program must accomplish in terms of the [[domain knowledge\|problem domain]], rather than describing ''how'' to accomplish it as a sequence of the programming [[language primitive]]s<ref name="FOLDOC 2004">{{cite web \| title=declarative language \| website=FOLDOC \| date=17 May 2004 \| url=https://foldoc.org/declarative+language \| access-date=7 September 2023 \| archive-date=7 September 2023 \| archive-url=https://web.archive.org/web/20230907151526/https://foldoc.org/declarative+language \| url-status=live }}</ref> (the ''how'' being left up to the language's [[programming language implementation\|implementation]]). This is in contrast with [[imperative programming]], which implements [[algorithm]]s in explicit steps.<ref name="Sebesta 2016">{{cite book \| last=Sebesta \| first=Robert \| title=Concepts of programming languages \| publisher=Pearson \| publication-place=Boston \| year=2016 \| isbn=978-0-13-394302-3 \| oclc=896687896}}</ref><ref>{{Cite web \|date=2021-05-21 \|title=Imperative programming: Overview of the oldest programming paradigm \|url=https://www.ionos.com/digitalguide/websites/web-development/imperative-programming/ \|access-date=2023-05-23 \|website=IONOS Digital Guide \|language=en-US \|archive-date=2022-05-03 \|archive-url=https://web.archive.org/web/20220503083342/https://www.ionos.com/digitalguide/websites/web-development/imperative-programming/ \|url-status=live }}</ref>

	Declarative programming often considers [[program (machine)\|programs]] as theories of a [[Mathematical_logic#Formal_logical_systems\|formal logic]], and computations as deductions in that logic space. Declarative programming may greatly simplify writing [[parallel computing\|parallel programs]].<ref>{{cite web\|url=http://www.cse.unsw.edu.au/~pls/damp09/ \|title=DAMP 2009: Workshop on Declarative Aspects of Multicore Programming \|publisher=Cse.unsw.edu.au \|date=20 January 2009 \|access-date=15 August 2013 \|archive-url=https://web.archive.org/web/20130913162703/http://www.cse.unsw.edu.au/~pls/damp09/ \|archive-date=13 September 2013 \|url-status=dead}}</ref>		Declarative programming often considers [[program (machine)\|programs]] as theories of a [[Mathematical_logic#Formal_logical_systems\|formal logic]], and computations as deductions in that logic space. Declarative programming may greatly simplify writing [[parallel computing\|parallel programs]].<ref>{{cite web\|url=http://www.cse.unsw.edu.au/~pls/damp09/ \|title=DAMP 2009: Workshop on Declarative Aspects of Multicore Programming \|publisher=Cse.unsw.edu.au \|date=20 January 2009 \|access-date=15 August 2013 \|archive-url=https://web.archive.org/web/20130913162703/http://www.cse.unsw.edu.au/~pls/damp09/ \|archive-date=13 September 2013 \|url-status=dead}}</ref>

KEmel49: Citation: Fixed issue

2024-08-24T04:39:55Z

Citation: Fixed issue

← Previous revision		Revision as of 04:39, 24 August 2024
Line 5:		Line 5:
	In [[computer science]], '''declarative programming''' is a [[programming paradigm]]—a style of building the structure and elements of computer programs—that expresses the logic of a [[computation]] without describing its [[control flow]].<ref>{{citation\|last=Lloyd\|first=J.W.\|title=Practical Advantages of Declarative Programming}}</ref>		In [[computer science]], '''declarative programming''' is a [[programming paradigm]]—a style of building the structure and elements of computer programs—that expresses the logic of a [[computation]] without describing its [[control flow]].<ref>{{citation\|last=Lloyd\|first=J.W.\|title=Practical Advantages of Declarative Programming}}</ref>

	Many languages that apply this style attempt to minimize or eliminate [[side effect (computer science)\|side effects]] by describing ''what'' the program must accomplish in terms of the [[domain knowledge\|problem domain]], rather than describing ''how'' to accomplish it as a sequence of the programming [[language primitive]]s<ref name="FOLDOC 2004">{{cite web \|date= \|title= ~~\|url=~~ ~~\|url-status=un~~ \|~~archive-~~url=~~526/~~https://foldoc.org/declarative+language \|archive-date= \|access-date=7 September 2023 \|website=FOLDOC}}</ref> (the ''how'' being left up to the language's [[programming language implementation\|implementation]]). This is in contrast with [[imperative programming]], which implements [[algorithm]]s in explicit steps.<ref name="Sebesta 2016">{{cite book \| last=Sebesta \| first=Robert \| title=Concepts of programming languages \| publisher=Pearson \| publication-place=Boston \| year=2016 \| isbn=978-0-13-394302-3 \| oclc=896687896}}</ref><ref>{{Cite web \|date=2021-05-21 \|title=Imperative programming: Overview of the oldest programming paradigm \|url=https://www.ionos.com/digitalguide/websites/web-development/imperative-programming/ \|access-date=2023-05-23 \|website=IONOS Digital Guide \|language=en-US \|archive-date=2022-05-03 \|archive-url=https://web.archive.org/web/20220503083342/https://www.ionos.com/digitalguide/websites/web-development/imperative-programming/ \|url-status=live }}</ref>		Many languages that apply this style attempt to minimize or eliminate [[side effect (computer science)\|side effects]] by describing ''what'' the program must accomplish in terms of the [[domain knowledge\|problem domain]], rather than describing ''how'' to accomplish it as a sequence of the programming [[language primitive]]s<ref name="FOLDOC 2004">{{cite web \|date=May 17, 2004 \|title=FOLDOC: declarative language \|url=https://foldoc.org/declarative+language \|url-status= \|archive-url= \|archive-date= \|access-date=September 7, 2023 \|website=FOLDOC}}</ref> (the ''how'' being left up to the language's [[programming language implementation\|implementation]]). This is in contrast with [[imperative programming]], which implements [[algorithm]]s in explicit steps.<ref name="Sebesta 2016">{{cite book \| last=Sebesta \| first=Robert \| title=Concepts of programming languages \| publisher=Pearson \| publication-place=Boston \| year=2016 \| isbn=978-0-13-394302-3 \| oclc=896687896}}</ref><ref>{{Cite web \|date=2021-05-21 \|title=Imperative programming: Overview of the oldest programming paradigm \|url=https://www.ionos.com/digitalguide/websites/web-development/imperative-programming/ \|access-date=2023-05-23 \|website=IONOS Digital Guide \|language=en-US \|archive-date=2022-05-03 \|archive-url=https://web.archive.org/web/20220503083342/https://www.ionos.com/digitalguide/websites/web-development/imperative-programming/ \|url-status=live }}</ref>

	Declarative programming often considers [[program (machine)\|programs]] as theories of a [[Mathematical_logic#Formal_logical_systems\|formal logic]], and computations as deductions in that logic space. Declarative programming may greatly simplify writing [[parallel computing\|parallel programs]].<ref>{{cite web\|url=http://www.cse.unsw.edu.au/~pls/damp09/ \|title=DAMP 2009: Workshop on Declarative Aspects of Multicore Programming \|publisher=Cse.unsw.edu.au \|date=20 January 2009 \|access-date=15 August 2013 \|archive-url=https://web.archive.org/web/20130913162703/http://www.cse.unsw.edu.au/~pls/damp09/ \|archive-date=13 September 2013 \|url-status=dead}}</ref>		Declarative programming often considers [[program (machine)\|programs]] as theories of a [[Mathematical_logic#Formal_logical_systems\|formal logic]], and computations as deductions in that logic space. Declarative programming may greatly simplify writing [[parallel computing\|parallel programs]].<ref>{{cite web\|url=http://www.cse.unsw.edu.au/~pls/damp09/ \|title=DAMP 2009: Workshop on Declarative Aspects of Multicore Programming \|publisher=Cse.unsw.edu.au \|date=20 January 2009 \|access-date=15 August 2013 \|archive-url=https://web.archive.org/web/20130913162703/http://www.cse.unsw.edu.au/~pls/damp09/ \|archive-date=13 September 2013 \|url-status=dead}}</ref>

2001:FB1:16E:5C3D:BB77:7048:1AFF:3DDB at 01:43, 24 August 2024

2024-08-24T01:43:02Z

← Previous revision		Revision as of 01:43, 24 August 2024
Line 5:		Line 5:
	In [[computer science]], '''declarative programming''' is a [[programming paradigm]]—a style of building the structure and elements of computer programs—that expresses the logic of a [[computation]] without describing its [[control flow]].<ref>{{citation\|last=Lloyd\|first=J.W.\|title=Practical Advantages of Declarative Programming}}</ref>		In [[computer science]], '''declarative programming''' is a [[programming paradigm]]—a style of building the structure and elements of computer programs—that expresses the logic of a [[computation]] without describing its [[control flow]].<ref>{{citation\|last=Lloyd\|first=J.W.\|title=Practical Advantages of Declarative Programming}}</ref>

	Many languages that apply this style attempt to minimize or eliminate [[side effect (computer science)\|side effects]] by describing ''what'' the program must accomplish in terms of the [[domain knowledge\|problem domain]], rather than describing ''how'' to accomplish it as a sequence of the programming [[language primitive]]s<ref name="FOLDOC 2004">{{cite web \| title=~~declarative language~~ \| ~~website~~=~~FOLDOC~~ \| ~~date~~=~~17 May 2004~~ \| url=https://foldoc.org/declarative+language \| ~~access~~-date=~~7 September 2023~~ \| ~~archive~~-date=7 September 2023 \| ~~archive-url~~=~~https://web.archive.org/web/20230907151526/https://foldoc.org/declarative+language \| url-status=live~~ }}</ref> (the ''how'' being left up to the language's [[programming language implementation\|implementation]]). This is in contrast with [[imperative programming]], which implements [[algorithm]]s in explicit steps.<ref name="Sebesta 2016">{{cite book \| last=Sebesta \| first=Robert \| title=Concepts of programming languages \| publisher=Pearson \| publication-place=Boston \| year=2016 \| isbn=978-0-13-394302-3 \| oclc=896687896}}</ref><ref>{{Cite web \|date=2021-05-21 \|title=Imperative programming: Overview of the oldest programming paradigm \|url=https://www.ionos.com/digitalguide/websites/web-development/imperative-programming/ \|access-date=2023-05-23 \|website=IONOS Digital Guide \|language=en-US \|archive-date=2022-05-03 \|archive-url=https://web.archive.org/web/20220503083342/https://www.ionos.com/digitalguide/websites/web-development/imperative-programming/ \|url-status=live }}</ref>		Many languages that apply this style attempt to minimize or eliminate [[side effect (computer science)\|side effects]] by describing ''what'' the program must accomplish in terms of the [[domain knowledge\|problem domain]], rather than describing ''how'' to accomplish it as a sequence of the programming [[language primitive]]s<ref name="FOLDOC 2004">{{cite web \|date= \|title= \|url= \|url-status=un \|archive-url=526/https://foldoc.org/declarative+language \|archive-date= \|access-date=7 September 2023 \|website=FOLDOC}}</ref> (the ''how'' being left up to the language's [[programming language implementation\|implementation]]). This is in contrast with [[imperative programming]], which implements [[algorithm]]s in explicit steps.<ref name="Sebesta 2016">{{cite book \| last=Sebesta \| first=Robert \| title=Concepts of programming languages \| publisher=Pearson \| publication-place=Boston \| year=2016 \| isbn=978-0-13-394302-3 \| oclc=896687896}}</ref><ref>{{Cite web \|date=2021-05-21 \|title=Imperative programming: Overview of the oldest programming paradigm \|url=https://www.ionos.com/digitalguide/websites/web-development/imperative-programming/ \|access-date=2023-05-23 \|website=IONOS Digital Guide \|language=en-US \|archive-date=2022-05-03 \|archive-url=https://web.archive.org/web/20220503083342/https://www.ionos.com/digitalguide/websites/web-development/imperative-programming/ \|url-status=live }}</ref>

	Declarative programming often considers [[program (machine)\|programs]] as theories of a [[Mathematical_logic#Formal_logical_systems\|formal logic]], and computations as deductions in that logic space. Declarative programming may greatly simplify writing [[parallel computing\|parallel programs]].<ref>{{cite web\|url=http://www.cse.unsw.edu.au/~pls/damp09/ \|title=DAMP 2009: Workshop on Declarative Aspects of Multicore Programming \|publisher=Cse.unsw.edu.au \|date=20 January 2009 \|access-date=15 August 2013 \|archive-url=https://web.archive.org/web/20130913162703/http://www.cse.unsw.edu.au/~pls/damp09/ \|archive-date=13 September 2013 \|url-status=dead}}</ref>		Declarative programming often considers [[program (machine)\|programs]] as theories of a [[Mathematical_logic#Formal_logical_systems\|formal logic]], and computations as deductions in that logic space. Declarative programming may greatly simplify writing [[parallel computing\|parallel programs]].<ref>{{cite web\|url=http://www.cse.unsw.edu.au/~pls/damp09/ \|title=DAMP 2009: Workshop on Declarative Aspects of Multicore Programming \|publisher=Cse.unsw.edu.au \|date=20 January 2009 \|access-date=15 August 2013 \|archive-url=https://web.archive.org/web/20130913162703/http://www.cse.unsw.edu.au/~pls/damp09/ \|archive-date=13 September 2013 \|url-status=dead}}</ref>

SFBB: replacing misnomer/mistranslation (see article)

2024-07-31T21:08:23Z

replacing misnomer/mistranslation (see article)

← Previous revision		Revision as of 21:08, 31 July 2024
Line 16:		Line 16:
	* A high-level program that describes what a computation should perform.		* A high-level program that describes what a computation should perform.
	* Any programming language that lacks [[side effect (computer science)\|side effects]] (or more specifically, is [[referential transparency\|referentially transparent]]).		* Any programming language that lacks [[side effect (computer science)\|side effects]] (or more specifically, is [[referential transparency\|referentially transparent]]).
	* A language with a clear correspondence to [[mathematical logic]].<ref>{{cite thesis \|first=Manuel M. T. \|last=Chakravarty \|date=14 February 1997 \|url=http://www.cse.unsw.edu.au/~chak/papers/diss.ps.gz \|title=On the Massively Parallel Execution of Declarative Programs \|type=Doctoral dissertation \|publisher=[[~~Technical~~ ~~University of~~ Berlin]] \|access-date=26 February 2015 \|quote=In this context, the criterion for calling a programming language declarative is the existence of a clear, mathematically established correspondence between the language and mathematical logic such that a declarative semantics for the language can be based on the model or the proof theory (or both) of the logic. \|archive-date=23 September 2015 \|archive-url=https://web.archive.org/web/20150923211531/http://www.cse.unsw.edu.au/~chak/papers/diss.ps.gz \|url-status=live }}</ref><!-- this citation is just for this bullet point -->		* A language with a clear correspondence to [[mathematical logic]].<ref>{{cite thesis \|first=Manuel M. T. \|last=Chakravarty \|date=14 February 1997 \|url=http://www.cse.unsw.edu.au/~chak/papers/diss.ps.gz \|title=On the Massively Parallel Execution of Declarative Programs \|type=Doctoral dissertation \|publisher=[[Technische Universität Berlin]] \|access-date=26 February 2015 \|quote=In this context, the criterion for calling a programming language declarative is the existence of a clear, mathematically established correspondence between the language and mathematical logic such that a declarative semantics for the language can be based on the model or the proof theory (or both) of the logic. \|archive-date=23 September 2015 \|archive-url=https://web.archive.org/web/20150923211531/http://www.cse.unsw.edu.au/~chak/papers/diss.ps.gz \|url-status=live }}</ref><!-- this citation is just for this bullet point -->

	These definitions overlap substantially.		These definitions overlap substantially.

Guy Harris: /* Lisp */ Get rid of unnecessary piping. Use "such as", not "like", for examples.

2024-07-31T09:13:39Z

Lisp: Get rid of unnecessary piping. Use "such as", not "like", for examples.

← Previous revision		Revision as of 09:13, 31 July 2024
Line 60:		Line 60:

	===Lisp===		===Lisp===
	[[Lisp (programming language) \|Lisp]] is a family of programming languages loosely inspired by mathematical notation and [[Alonzo Church]]'s [[lambda calculus]]. Some dialects, ~~like~~ [[Common Lisp]], are primarily imperative but support functional programming. Others, ~~like~~ [[Scheme (programming language)\|Scheme]], are designed for functional programming.		[[Lisp (programming language) \|Lisp]] is a family of programming languages loosely inspired by mathematical notation and [[Alonzo Church]]'s [[lambda calculus]]. Some dialects, such as [[Common Lisp]], are primarily imperative but support functional programming. Others, such as [[Scheme (programming language)\|Scheme]], are designed for functional programming.

	In Scheme, the [[factorial]] function can be defined as follows:		In Scheme, the [[factorial]] function can be defined as follows:
Line 73:		Line 73:
	This defines the factorial function using its recursive definition. In contrast, it is more typical to define a procedure for an imperative language.		This defines the factorial function using its recursive definition. In contrast, it is more typical to define a procedure for an imperative language.

	In lisps and lambda calculus, functions are generally [[first-class citizen ~~\|first-class citizens~~]]. Loosely, this means that functions can be inputs and outputs for other functions. This can simplify the definition of some functions.		In lisps and lambda calculus, functions are generally [[first-class citizen]]s. Loosely, this means that functions can be inputs and outputs for other functions. This can simplify the definition of some functions.

	For example, writing a function to output the first n [[~~Square~~ number~~\|square numbers~~]] in [[Racket (programming language)\|Racket]] can be done accordingly:		For example, writing a function to output the first n [[square number]]s in [[Racket (programming language)\|Racket]] can be done accordingly:

	<syntaxhighlight lang=scheme>		<syntaxhighlight lang=scheme>
Line 84:		Line 84:
	</syntaxhighlight>		</syntaxhighlight>

	The [[Map (higher-order function) \|map]] function accepts a function and list; the output is a list of results of the input function on each element of the input list.		The [[Map (higher-order function) \|map]] function accepts a function and a list; the output is a list of results of the input function on each element of the input list.

	===ML===		===ML===

Mitch Ames: /* See also */ Remove recently unlinked item: Comparison of programming paradigms

2024-07-02T03:35:17Z

See also: Remove recently unlinked item: Comparison of programming paradigms

← Previous revision		Revision as of 03:35, 2 July 2024
Line 188:		Line 188:

	==See also==		==See also==
	* Comparison of programming paradigms
	* [[Inductive programming]]		* [[Inductive programming]]
	* [[List of programming languages by type#Declarative_languages\|List of declarative programming languages]]		* [[List of programming languages by type#Declarative_languages\|List of declarative programming languages]]

← Previous revision		Revision as of 23:21, 15 September 2024
Line 5:		Line 5:
	In [[computer science]], '''declarative programming''' is a [[programming paradigm]]—a style of building the structure and elements of computer programs—that expresses the logic of a [[computation]] without describing its [[control flow]].<ref>{{citation\|last=Lloyd\|first=J.W.\|title=Practical Advantages of Declarative Programming}}</ref>		In [[computer science]], '''declarative programming''' is a [[programming paradigm]]—a style of building the structure and elements of computer programs—that expresses the logic of a [[computation]] without describing its [[control flow]].<ref>{{citation\|last=Lloyd\|first=J.W.\|title=Practical Advantages of Declarative Programming}}</ref>

	Many languages that apply this style attempt to minimize or eliminate [[side effect (computer science)\|side effects]] by describing ''what'' the program must accomplish in terms of the [[domain knowledge\|problem domain]], rather than describing ''how'' to accomplish it as a sequence of the programming [[language primitive]]s<ref name="FOLDOC 2004">{{cite web \|~~date~~=~~May~~ ~~17, 2004~~ \|~~title~~=FOLDOC: ~~declarative~~ ~~language~~ \|url=https://foldoc.org/declarative+language \|~~url~~-~~status~~= \|archive-~~url~~= \|archive-~~date~~= \|~~access~~-~~date~~=~~September~~ ~~7, 2023 \|website=FOLDOC~~}}</ref> (the ''how'' being left up to the language's [[programming language implementation\|implementation]]). This is in contrast with [[imperative programming]], which implements [[algorithm]]s in explicit steps.<ref name="Sebesta 2016">{{cite book \| last=Sebesta \| first=Robert \| title=Concepts of programming languages \| publisher=Pearson \| publication-place=Boston \| year=2016 \| isbn=978-0-13-394302-3 \| oclc=896687896}}</ref><ref>{{Cite web \|date=2021-05-21 \|title=Imperative programming: Overview of the oldest programming paradigm \|url=https://www.ionos.com/digitalguide/websites/web-development/imperative-programming/ \|access-date=2023-05-23 \|website=IONOS Digital Guide \|language=en-US \|archive-date=2022-05-03 \|archive-url=https://web.archive.org/web/20220503083342/https://www.ionos.com/digitalguide/websites/web-development/imperative-programming/ \|url-status=live }}</ref>		Many languages that apply this style attempt to minimize or eliminate [[side effect (computer science)\|side effects]] by describing ''what'' the program must accomplish in terms of the [[domain knowledge\|problem domain]], rather than describing ''how'' to accomplish it as a sequence of the programming [[language primitive]]s<ref name="FOLDOC 2004">{{cite web \| title=declarative language \| website=FOLDOC \| date=17 May 2004 \| url=https://foldoc.org/declarative+language \| access-date=7 September 2023 \| archive-date=7 September 2023 \| archive-url=https://web.archive.org/web/20230907151526/https://foldoc.org/declarative+language \| url-status=live }}</ref> (the ''how'' being left up to the language's [[programming language implementation\|implementation]]). This is in contrast with [[imperative programming]], which implements [[algorithm]]s in explicit steps.<ref name="Sebesta 2016">{{cite book \| last=Sebesta \| first=Robert \| title=Concepts of programming languages \| publisher=Pearson \| publication-place=Boston \| year=2016 \| isbn=978-0-13-394302-3 \| oclc=896687896}}</ref><ref>{{Cite web \|date=2021-05-21 \|title=Imperative programming: Overview of the oldest programming paradigm \|url=https://www.ionos.com/digitalguide/websites/web-development/imperative-programming/ \|access-date=2023-05-23 \|website=IONOS Digital Guide \|language=en-US \|archive-date=2022-05-03 \|archive-url=https://web.archive.org/web/20220503083342/https://www.ionos.com/digitalguide/websites/web-development/imperative-programming/ \|url-status=live }}</ref>

	Declarative programming often considers [[program (machine)\|programs]] as theories of a [[Mathematical_logic#Formal_logical_systems\|formal logic]], and computations as deductions in that logic space. Declarative programming may greatly simplify writing [[parallel computing\|parallel programs]].<ref>{{cite web\|url=http://www.cse.unsw.edu.au/~pls/damp09/ \|title=DAMP 2009: Workshop on Declarative Aspects of Multicore Programming \|publisher=Cse.unsw.edu.au \|date=20 January 2009 \|access-date=15 August 2013 \|archive-url=https://web.archive.org/web/20130913162703/http://www.cse.unsw.edu.au/~pls/damp09/ \|archive-date=13 September 2013 \|url-status=dead}}</ref>		Declarative programming often considers [[program (machine)\|programs]] as theories of a [[Mathematical_logic#Formal_logical_systems\|formal logic]], and computations as deductions in that logic space. Declarative programming may greatly simplify writing [[parallel computing\|parallel programs]].<ref>{{cite web\|url=http://www.cse.unsw.edu.au/~pls/damp09/ \|title=DAMP 2009: Workshop on Declarative Aspects of Multicore Programming \|publisher=Cse.unsw.edu.au \|date=20 January 2009 \|access-date=15 August 2013 \|archive-url=https://web.archive.org/web/20130913162703/http://www.cse.unsw.edu.au/~pls/damp09/ \|archive-date=13 September 2013 \|url-status=dead}}</ref>

← Previous revision		Revision as of 04:39, 24 August 2024
Line 5:		Line 5:
	In [[computer science]], '''declarative programming''' is a [[programming paradigm]]—a style of building the structure and elements of computer programs—that expresses the logic of a [[computation]] without describing its [[control flow]].<ref>{{citation\|last=Lloyd\|first=J.W.\|title=Practical Advantages of Declarative Programming}}</ref>		In [[computer science]], '''declarative programming''' is a [[programming paradigm]]—a style of building the structure and elements of computer programs—that expresses the logic of a [[computation]] without describing its [[control flow]].<ref>{{citation\|last=Lloyd\|first=J.W.\|title=Practical Advantages of Declarative Programming}}</ref>

	Many languages that apply this style attempt to minimize or eliminate [[side effect (computer science)\|side effects]] by describing ''what'' the program must accomplish in terms of the [[domain knowledge\|problem domain]], rather than describing ''how'' to accomplish it as a sequence of the programming [[language primitive]]s<ref name="FOLDOC 2004">{{cite web \|date= \|title= ~~\|url=~~ ~~\|url-status=un~~ \|~~archive-~~url=~~526/~~https://foldoc.org/declarative+language \|archive-date= \|access-date=7 September 2023 \|website=FOLDOC}}</ref> (the ''how'' being left up to the language's [[programming language implementation\|implementation]]). This is in contrast with [[imperative programming]], which implements [[algorithm]]s in explicit steps.<ref name="Sebesta 2016">{{cite book \| last=Sebesta \| first=Robert \| title=Concepts of programming languages \| publisher=Pearson \| publication-place=Boston \| year=2016 \| isbn=978-0-13-394302-3 \| oclc=896687896}}</ref><ref>{{Cite web \|date=2021-05-21 \|title=Imperative programming: Overview of the oldest programming paradigm \|url=https://www.ionos.com/digitalguide/websites/web-development/imperative-programming/ \|access-date=2023-05-23 \|website=IONOS Digital Guide \|language=en-US \|archive-date=2022-05-03 \|archive-url=https://web.archive.org/web/20220503083342/https://www.ionos.com/digitalguide/websites/web-development/imperative-programming/ \|url-status=live }}</ref>		Many languages that apply this style attempt to minimize or eliminate [[side effect (computer science)\|side effects]] by describing ''what'' the program must accomplish in terms of the [[domain knowledge\|problem domain]], rather than describing ''how'' to accomplish it as a sequence of the programming [[language primitive]]s<ref name="FOLDOC 2004">{{cite web \|date=May 17, 2004 \|title=FOLDOC: declarative language \|url=https://foldoc.org/declarative+language \|url-status= \|archive-url= \|archive-date= \|access-date=September 7, 2023 \|website=FOLDOC}}</ref> (the ''how'' being left up to the language's [[programming language implementation\|implementation]]). This is in contrast with [[imperative programming]], which implements [[algorithm]]s in explicit steps.<ref name="Sebesta 2016">{{cite book \| last=Sebesta \| first=Robert \| title=Concepts of programming languages \| publisher=Pearson \| publication-place=Boston \| year=2016 \| isbn=978-0-13-394302-3 \| oclc=896687896}}</ref><ref>{{Cite web \|date=2021-05-21 \|title=Imperative programming: Overview of the oldest programming paradigm \|url=https://www.ionos.com/digitalguide/websites/web-development/imperative-programming/ \|access-date=2023-05-23 \|website=IONOS Digital Guide \|language=en-US \|archive-date=2022-05-03 \|archive-url=https://web.archive.org/web/20220503083342/https://www.ionos.com/digitalguide/websites/web-development/imperative-programming/ \|url-status=live }}</ref>

	Declarative programming often considers [[program (machine)\|programs]] as theories of a [[Mathematical_logic#Formal_logical_systems\|formal logic]], and computations as deductions in that logic space. Declarative programming may greatly simplify writing [[parallel computing\|parallel programs]].<ref>{{cite web\|url=http://www.cse.unsw.edu.au/~pls/damp09/ \|title=DAMP 2009: Workshop on Declarative Aspects of Multicore Programming \|publisher=Cse.unsw.edu.au \|date=20 January 2009 \|access-date=15 August 2013 \|archive-url=https://web.archive.org/web/20130913162703/http://www.cse.unsw.edu.au/~pls/damp09/ \|archive-date=13 September 2013 \|url-status=dead}}</ref>		Declarative programming often considers [[program (machine)\|programs]] as theories of a [[Mathematical_logic#Formal_logical_systems\|formal logic]], and computations as deductions in that logic space. Declarative programming may greatly simplify writing [[parallel computing\|parallel programs]].<ref>{{cite web\|url=http://www.cse.unsw.edu.au/~pls/damp09/ \|title=DAMP 2009: Workshop on Declarative Aspects of Multicore Programming \|publisher=Cse.unsw.edu.au \|date=20 January 2009 \|access-date=15 August 2013 \|archive-url=https://web.archive.org/web/20130913162703/http://www.cse.unsw.edu.au/~pls/damp09/ \|archive-date=13 September 2013 \|url-status=dead}}</ref>

← Previous revision		Revision as of 01:43, 24 August 2024
Line 5:		Line 5:
	In [[computer science]], '''declarative programming''' is a [[programming paradigm]]—a style of building the structure and elements of computer programs—that expresses the logic of a [[computation]] without describing its [[control flow]].<ref>{{citation\|last=Lloyd\|first=J.W.\|title=Practical Advantages of Declarative Programming}}</ref>		In [[computer science]], '''declarative programming''' is a [[programming paradigm]]—a style of building the structure and elements of computer programs—that expresses the logic of a [[computation]] without describing its [[control flow]].<ref>{{citation\|last=Lloyd\|first=J.W.\|title=Practical Advantages of Declarative Programming}}</ref>

	Many languages that apply this style attempt to minimize or eliminate [[side effect (computer science)\|side effects]] by describing ''what'' the program must accomplish in terms of the [[domain knowledge\|problem domain]], rather than describing ''how'' to accomplish it as a sequence of the programming [[language primitive]]s<ref name="FOLDOC 2004">{{cite web \| title=~~declarative language~~ \| ~~website~~=~~FOLDOC~~ \| ~~date~~=~~17 May 2004~~ \| url=https://foldoc.org/declarative+language \| ~~access~~-date=~~7 September 2023~~ \| ~~archive~~-date=7 September 2023 \| ~~archive-url~~=~~https://web.archive.org/web/20230907151526/https://foldoc.org/declarative+language \| url-status=live~~ }}</ref> (the ''how'' being left up to the language's [[programming language implementation\|implementation]]). This is in contrast with [[imperative programming]], which implements [[algorithm]]s in explicit steps.<ref name="Sebesta 2016">{{cite book \| last=Sebesta \| first=Robert \| title=Concepts of programming languages \| publisher=Pearson \| publication-place=Boston \| year=2016 \| isbn=978-0-13-394302-3 \| oclc=896687896}}</ref><ref>{{Cite web \|date=2021-05-21 \|title=Imperative programming: Overview of the oldest programming paradigm \|url=https://www.ionos.com/digitalguide/websites/web-development/imperative-programming/ \|access-date=2023-05-23 \|website=IONOS Digital Guide \|language=en-US \|archive-date=2022-05-03 \|archive-url=https://web.archive.org/web/20220503083342/https://www.ionos.com/digitalguide/websites/web-development/imperative-programming/ \|url-status=live }}</ref>		Many languages that apply this style attempt to minimize or eliminate [[side effect (computer science)\|side effects]] by describing ''what'' the program must accomplish in terms of the [[domain knowledge\|problem domain]], rather than describing ''how'' to accomplish it as a sequence of the programming [[language primitive]]s<ref name="FOLDOC 2004">{{cite web \|date= \|title= \|url= \|url-status=un \|archive-url=526/https://foldoc.org/declarative+language \|archive-date= \|access-date=7 September 2023 \|website=FOLDOC}}</ref> (the ''how'' being left up to the language's [[programming language implementation\|implementation]]). This is in contrast with [[imperative programming]], which implements [[algorithm]]s in explicit steps.<ref name="Sebesta 2016">{{cite book \| last=Sebesta \| first=Robert \| title=Concepts of programming languages \| publisher=Pearson \| publication-place=Boston \| year=2016 \| isbn=978-0-13-394302-3 \| oclc=896687896}}</ref><ref>{{Cite web \|date=2021-05-21 \|title=Imperative programming: Overview of the oldest programming paradigm \|url=https://www.ionos.com/digitalguide/websites/web-development/imperative-programming/ \|access-date=2023-05-23 \|website=IONOS Digital Guide \|language=en-US \|archive-date=2022-05-03 \|archive-url=https://web.archive.org/web/20220503083342/https://www.ionos.com/digitalguide/websites/web-development/imperative-programming/ \|url-status=live }}</ref>

	Declarative programming often considers [[program (machine)\|programs]] as theories of a [[Mathematical_logic#Formal_logical_systems\|formal logic]], and computations as deductions in that logic space. Declarative programming may greatly simplify writing [[parallel computing\|parallel programs]].<ref>{{cite web\|url=http://www.cse.unsw.edu.au/~pls/damp09/ \|title=DAMP 2009: Workshop on Declarative Aspects of Multicore Programming \|publisher=Cse.unsw.edu.au \|date=20 January 2009 \|access-date=15 August 2013 \|archive-url=https://web.archive.org/web/20130913162703/http://www.cse.unsw.edu.au/~pls/damp09/ \|archive-date=13 September 2013 \|url-status=dead}}</ref>		Declarative programming often considers [[program (machine)\|programs]] as theories of a [[Mathematical_logic#Formal_logical_systems\|formal logic]], and computations as deductions in that logic space. Declarative programming may greatly simplify writing [[parallel computing\|parallel programs]].<ref>{{cite web\|url=http://www.cse.unsw.edu.au/~pls/damp09/ \|title=DAMP 2009: Workshop on Declarative Aspects of Multicore Programming \|publisher=Cse.unsw.edu.au \|date=20 January 2009 \|access-date=15 August 2013 \|archive-url=https://web.archive.org/web/20130913162703/http://www.cse.unsw.edu.au/~pls/damp09/ \|archive-date=13 September 2013 \|url-status=dead}}</ref>