Functional reactive programming - Revision history

2ndjpeg: /* Implementations */ Added reference to Sodium

2024-10-05T21:31:45Z

Implementations: Added reference to Sodium

← Previous revision		Revision as of 21:31, 5 October 2024
Line 47:		Line 47:
	* [[Flapjax]] is a behavior–event FRP implementation in [[JavaScript]].		* [[Flapjax]] is a behavior–event FRP implementation in [[JavaScript]].
	* React is an [[OCaml]] module for functional reactive programming.		* React is an [[OCaml]] module for functional reactive programming.
	* Sodium is a push FRP implementation independent of a specific [[user interface]] (UI) framework for several languages, such as [[Java (programming language)\|Java]], [[TypeScript]], and [[C Sharp (programming language)\|C#]].		* Sodium is a push FRP implementation independent of a specific [[user interface]] (UI) framework for several languages, such as [[Java (programming language)\|Java]], [[TypeScript]], and [[C Sharp (programming language)\|C#]].<ref>{{cite web \|url=https://github.com/SodiumFRP/sodium \|title=Sodium FRP Library on Github \|access-date=October 5, 2024}}</ref>
	* Dunai is a fast implementation in Haskell using [[Monadic Stream Functions]] that supports Classic and Arrowized FRP.		* Dunai is a fast implementation in Haskell using [[Monadic Stream Functions]] that supports Classic and Arrowized FRP.
	* ObservableComputations, a cross-platform [[.NET]] implementation.		* ObservableComputations, a cross-platform [[.NET]] implementation.

Citation bot: Added doi-access. | Use this bot. Report bugs. | Suggested by Headbomb | Linked from Wikipedia:WikiProject_Academic_Journals/Journals_cited_by_Wikipedia/Sandbox2 | #UCB_webform_linked 499/1051

2024-07-29T00:58:54Z

Added doi-access. | Use this bot. Report bugs. | Suggested by Headbomb | Linked from Wikipedia:WikiProject_Academic_Journals/Journals_cited_by_Wikipedia/Sandbox2 | #UCB_webform_linked 499/1051

← Previous revision		Revision as of 00:58, 29 July 2024
Line 50:		Line 50:
	* Dunai is a fast implementation in Haskell using [[Monadic Stream Functions]] that supports Classic and Arrowized FRP.		* Dunai is a fast implementation in Haskell using [[Monadic Stream Functions]] that supports Classic and Arrowized FRP.
	* ObservableComputations, a cross-platform [[.NET]] implementation.		* ObservableComputations, a cross-platform [[.NET]] implementation.
	* Stella is an [[actor model]]-based reactive language that demonstrates a model of "actors" and "reactors" which aims to avoid the issues of combining imperative code with reactive code (by separating them in actors and reactors).<ref name="stella">{{Citation \|url=https://drops.dagstuhl.de/opus/volltexte/2020/13176/ \|first1=Sam \|last1=Van den Vonder \|first2=Thierry \|last2=Renaux \|first3=Bjarno \|last3=Oeyen \|first4=Joeri \|last4=De Koster \|first5=Wolfgang \|last5=De Meuter \|contribution=Tackling the Awkward Squad for Reactive Programming: The Actor-Reactor Model \|title=Leibniz International Proceedings in Informatics (LIPIcs) \|volume=166 \|year=2020 \|pages=19:1–19:29 \|doi=10.4230/LIPIcs.ECOOP.2020.19 \|isbn=9783959771542 \|s2cid=260445152}}</ref> Actors are suitable for use in distributed reactive systems.<ref name="stella2">{{Citation \|url=https://programming-journal.org/2022/6/14/ \|first1=Sam \|last1=Van den Vonder \|first2=Thierry \|last2=Renaux \|first3=Wolfgang \|last3=De Meuter \|contribution=Topology-Level Reactivity in Distributed Reactive Programs: Reactive Acquaintance Management using Flocks \|title=The Art, Science, and Engineering of Programming \|volume=6 \|year=2022 \|issue=3 \|pages=14:1–14:36 \|doi=10.22152/programming-journal.org/2022/6/14 \|s2cid=246979565\|doi-access=free \|arxiv=2202.09228 }}</ref>		* Stella is an [[actor model]]-based reactive language that demonstrates a model of "actors" and "reactors" which aims to avoid the issues of combining imperative code with reactive code (by separating them in actors and reactors).<ref name="stella">{{Citation \|url=https://drops.dagstuhl.de/opus/volltexte/2020/13176/ \|first1=Sam \|last1=Van den Vonder \|first2=Thierry \|last2=Renaux \|first3=Bjarno \|last3=Oeyen \|first4=Joeri \|last4=De Koster \|first5=Wolfgang \|last5=De Meuter \|contribution=Tackling the Awkward Squad for Reactive Programming: The Actor-Reactor Model \|title=Leibniz International Proceedings in Informatics (LIPIcs) \|volume=166 \|year=2020 \|pages=19:1–19:29 \|doi=10.4230/LIPIcs.ECOOP.2020.19 \|doi-access=free \|isbn=9783959771542 \|s2cid=260445152}}</ref> Actors are suitable for use in distributed reactive systems.<ref name="stella2">{{Citation \|url=https://programming-journal.org/2022/6/14/ \|first1=Sam \|last1=Van den Vonder \|first2=Thierry \|last2=Renaux \|first3=Wolfgang \|last3=De Meuter \|contribution=Topology-Level Reactivity in Distributed Reactive Programs: Reactive Acquaintance Management using Flocks \|title=The Art, Science, and Engineering of Programming \|volume=6 \|year=2022 \|issue=3 \|pages=14:1–14:36 \|doi=10.22152/programming-journal.org/2022/6/14 \|s2cid=246979565\|doi-access=free \|arxiv=2202.09228 }}</ref>
	*[[TidalCycles]] is a pure FRP domain specific language for musical pattern, embedded in the [[Haskell]] language.		*[[TidalCycles]] is a pure FRP domain specific language for musical pattern, embedded in the [[Haskell]] language.

GreenC bot: Reformat 4 archive links. Wayback Medic 2.5 per WP:URLREQ#iaboterr

2024-05-16T06:37:24Z

Reformat 4 archive links. Wayback Medic 2.5 per WP:URLREQ#iaboterr

InternetArchiveBot: Rescuing 4 sources and tagging 0 as dead.) #IABot (v2.0.9.5

2024-05-14T17:51:23Z

Rescuing 4 sources and tagging 0 as dead.) #IABot (v2.0.9.5

Mathnerd314159: change paradigms template to navbox (see Template talk:Programming paradigms#too long)

2024-02-01T22:54:03Z

change paradigms template to navbox (see Template talk:Programming paradigms#too long)

← Previous revision		Revision as of 22:54, 1 February 2024
Line 1:		Line 1:
	{{Short description\|Programming paradigm}}		{{Short description\|Programming paradigm}}
	{{Distinguish\|text=factory reset protection (FRP), a feature in some [[Android (operating system)\|Android]] devices}}		{{Distinguish\|text=factory reset protection (FRP), a feature in some [[Android (operating system)\|Android]] devices}}
⚫	{{Programming paradigms}}
	'''Functional reactive programming''' ('''FRP''') is a [[programming paradigm]] for [[reactive programming]] ([[asynchronous programming\|asynchronous]] [[dataflow programming]]) using the building blocks of [[functional programming]] (e.g., [[Map (higher-order function)\|map]], [[Fold (higher-order function)\|reduce]], [[Filter (higher-order function)\|filter]]). FRP has been used for programming [[graphical user interface]]s (GUIs), [[robotics]], games, and music, aiming to simplify these problems by explicitly modeling time.{{Citation needed\|date=March 2016}}		'''Functional reactive programming''' ('''FRP''') is a [[programming paradigm]] for [[reactive programming]] ([[asynchronous programming\|asynchronous]] [[dataflow programming]]) using the building blocks of [[functional programming]] (e.g., [[Map (higher-order function)\|map]], [[Fold (higher-order function)\|reduce]], [[Filter (higher-order function)\|filter]]). FRP has been used for programming [[graphical user interface]]s (GUIs), [[robotics]], games, and music, aiming to simplify these problems by explicitly modeling time.{{Citation needed\|date=March 2016}}

Line 62:		Line 61:
	== References ==		== References ==
	{{Reflist}}		{{Reflist}}

		⚫	{{Programming paradigms navbox}}

	{{DEFAULTSORT:Functional reactive programming}}		{{DEFAULTSORT:Functional reactive programming}}

OAbot: Open access bot: arxiv updated in citation with #oabot.

2024-01-05T09:31:32Z

Open access bot: arxiv updated in citation with #oabot.

← Previous revision		Revision as of 09:31, 5 January 2024
Line 51:		Line 51:
	* Dunai is a fast implementation in Haskell using [[Monadic Stream Functions]] that supports Classic and Arrowized FRP.		* Dunai is a fast implementation in Haskell using [[Monadic Stream Functions]] that supports Classic and Arrowized FRP.
	* ObservableComputations, a cross-platform [[.NET]] implementation.		* ObservableComputations, a cross-platform [[.NET]] implementation.
	* Stella is an [[actor model]]-based reactive language that demonstrates a model of "actors" and "reactors" which aims to avoid the issues of combining imperative code with reactive code (by separating them in actors and reactors).<ref name="stella">{{Citation \|url=https://drops.dagstuhl.de/opus/volltexte/2020/13176/ \|first1=Sam \|last1=Van den Vonder \|first2=Thierry \|last2=Renaux \|first3=Bjarno \|last3=Oeyen \|first4=Joeri \|last4=De Koster \|first5=Wolfgang \|last5=De Meuter \|contribution=Tackling the Awkward Squad for Reactive Programming: The Actor-Reactor Model \|title=Leibniz International Proceedings in Informatics (LIPIcs) \|volume=166 \|year=2020 \|pages=19:1–19:29 \|doi=10.4230/LIPIcs.ECOOP.2020.19 \|isbn=9783959771542 \|s2cid=260445152}}</ref> Actors are suitable for use in distributed reactive systems.<ref name="stella2">{{Citation \|url=https://programming-journal.org/2022/6/14/ \|first1=Sam \|last1=Van den Vonder \|first2=Thierry \|last2=Renaux \|first3=Wolfgang \|last3=De Meuter \|contribution=Topology-Level Reactivity in Distributed Reactive Programs: Reactive Acquaintance Management using Flocks \|title=The Art, Science, and Engineering of Programming \|volume=6 \|year=2022 \|issue=3 \|pages=14:1–14:36 \|doi=10.22152/programming-journal.org/2022/6/14 \|s2cid=246979565\|doi-access=free }}</ref>		* Stella is an [[actor model]]-based reactive language that demonstrates a model of "actors" and "reactors" which aims to avoid the issues of combining imperative code with reactive code (by separating them in actors and reactors).<ref name="stella">{{Citation \|url=https://drops.dagstuhl.de/opus/volltexte/2020/13176/ \|first1=Sam \|last1=Van den Vonder \|first2=Thierry \|last2=Renaux \|first3=Bjarno \|last3=Oeyen \|first4=Joeri \|last4=De Koster \|first5=Wolfgang \|last5=De Meuter \|contribution=Tackling the Awkward Squad for Reactive Programming: The Actor-Reactor Model \|title=Leibniz International Proceedings in Informatics (LIPIcs) \|volume=166 \|year=2020 \|pages=19:1–19:29 \|doi=10.4230/LIPIcs.ECOOP.2020.19 \|isbn=9783959771542 \|s2cid=260445152}}</ref> Actors are suitable for use in distributed reactive systems.<ref name="stella2">{{Citation \|url=https://programming-journal.org/2022/6/14/ \|first1=Sam \|last1=Van den Vonder \|first2=Thierry \|last2=Renaux \|first3=Wolfgang \|last3=De Meuter \|contribution=Topology-Level Reactivity in Distributed Reactive Programs: Reactive Acquaintance Management using Flocks \|title=The Art, Science, and Engineering of Programming \|volume=6 \|year=2022 \|issue=3 \|pages=14:1–14:36 \|doi=10.22152/programming-journal.org/2022/6/14 \|s2cid=246979565\|doi-access=free \|arxiv=2202.09228 }}</ref>
	*[[TidalCycles]] is a pure FRP domain specific language for musical pattern, embedded in the [[Haskell]] language.		*[[TidalCycles]] is a pure FRP domain specific language for musical pattern, embedded in the [[Haskell]] language.

OAbot: Open access bot: doi updated in citation with #oabot.

2023-12-16T00:26:04Z

Open access bot: doi updated in citation with #oabot.

← Previous revision		Revision as of 00:26, 16 December 2023
Line 51:		Line 51:
	* Dunai is a fast implementation in Haskell using [[Monadic Stream Functions]] that supports Classic and Arrowized FRP.		* Dunai is a fast implementation in Haskell using [[Monadic Stream Functions]] that supports Classic and Arrowized FRP.
	* ObservableComputations, a cross-platform [[.NET]] implementation.		* ObservableComputations, a cross-platform [[.NET]] implementation.
	* Stella is an [[actor model]]-based reactive language that demonstrates a model of "actors" and "reactors" which aims to avoid the issues of combining imperative code with reactive code (by separating them in actors and reactors).<ref name="stella">{{Citation \|url=https://drops.dagstuhl.de/opus/volltexte/2020/13176/ \|first1=Sam \|last1=Van den Vonder \|first2=Thierry \|last2=Renaux \|first3=Bjarno \|last3=Oeyen \|first4=Joeri \|last4=De Koster \|first5=Wolfgang \|last5=De Meuter \|contribution=Tackling the Awkward Squad for Reactive Programming: The Actor-Reactor Model \|title=Leibniz International Proceedings in Informatics (LIPIcs) \|volume=166 \|year=2020 \|pages=19:1–19:29 \|doi=10.4230/LIPIcs.ECOOP.2020.19 \|isbn=9783959771542 \|s2cid=260445152}}</ref> Actors are suitable for use in distributed reactive systems.<ref name="stella2">{{Citation \|url=https://programming-journal.org/2022/6/14/ \|first1=Sam \|last1=Van den Vonder \|first2=Thierry \|last2=Renaux \|first3=Wolfgang \|last3=De Meuter \|contribution=Topology-Level Reactivity in Distributed Reactive Programs: Reactive Acquaintance Management using Flocks \|title=The Art, Science, and Engineering of Programming \|volume=6 \|year=2022 \|issue=3 \|pages=14:1–14:36 \|doi=10.22152/programming-journal.org/2022/6/14 \|s2cid=246979565}}</ref>		* Stella is an [[actor model]]-based reactive language that demonstrates a model of "actors" and "reactors" which aims to avoid the issues of combining imperative code with reactive code (by separating them in actors and reactors).<ref name="stella">{{Citation \|url=https://drops.dagstuhl.de/opus/volltexte/2020/13176/ \|first1=Sam \|last1=Van den Vonder \|first2=Thierry \|last2=Renaux \|first3=Bjarno \|last3=Oeyen \|first4=Joeri \|last4=De Koster \|first5=Wolfgang \|last5=De Meuter \|contribution=Tackling the Awkward Squad for Reactive Programming: The Actor-Reactor Model \|title=Leibniz International Proceedings in Informatics (LIPIcs) \|volume=166 \|year=2020 \|pages=19:1–19:29 \|doi=10.4230/LIPIcs.ECOOP.2020.19 \|isbn=9783959771542 \|s2cid=260445152}}</ref> Actors are suitable for use in distributed reactive systems.<ref name="stella2">{{Citation \|url=https://programming-journal.org/2022/6/14/ \|first1=Sam \|last1=Van den Vonder \|first2=Thierry \|last2=Renaux \|first3=Wolfgang \|last3=De Meuter \|contribution=Topology-Level Reactivity in Distributed Reactive Programs: Reactive Acquaintance Management using Flocks \|title=The Art, Science, and Engineering of Programming \|volume=6 \|year=2022 \|issue=3 \|pages=14:1–14:36 \|doi=10.22152/programming-journal.org/2022/6/14 \|s2cid=246979565\|doi-access=free }}</ref>
	*[[TidalCycles]] is a pure FRP domain specific language for musical pattern, embedded in the [[Haskell]] language.		*[[TidalCycles]] is a pure FRP domain specific language for musical pattern, embedded in the [[Haskell]] language.

Jerryobject: WP:REFerence WP:CITation parameters: respaces, adds, fills, conform to master templates. Small WP:COPYEDITs WP:EoS: WP:TERSE, clarify. Cut needless carriage return whitespace characters in sections: standardize, aid work via small screens. WP:LINKs: adds, update-standardizes, needless WP:PIPEs > WP:NOPIPEs. WP:SLASHes > WP:NDASHes. MOS:FIRSTABBReviations clarify, define before WP:ABBRs in parentheses.

2023-10-24T07:25:46Z

WP:REFerence WP:CITation parameters: respaces, adds, fills, conform to master templates. Small WP:COPYEDITs WP:EoS: WP:TERSE, clarify. Cut needless carriage return whitespace characters in sections: standardize, aid work via small screens. WP:LINKs: adds, update-standardizes, needless WP:PIPEs > WP:NOPIPEs. WP:SLASHes > WP:NDASHes. MOS:FIRSTABBReviations clarify, define before WP:ABBRs in parentheses.

Show changes

Citation bot: Alter: volume. Add: s2cid. | Use this bot. Report bugs. | Suggested by Abductive | #UCB_webform 1405/3840

2023-09-23T14:44:44Z

Alter: volume. Add: s2cid. | Use this bot. Report bugs. | Suggested by Abductive | #UCB_webform 1405/3840

← Previous revision		Revision as of 14:44, 23 September 2023
Line 52:		Line 52:
	* Dunai is a fast implementation in Haskell using [[Monadic Stream Functions]] that supports Classic and Arrowized FRP.		* Dunai is a fast implementation in Haskell using [[Monadic Stream Functions]] that supports Classic and Arrowized FRP.
	* ObservableComputations, a cross-platform .NET implementation.		* ObservableComputations, a cross-platform .NET implementation.
	* Stella is an actor-based reactive programming language that demonstrates a model of "actors" and "reactors" which aims to avoid the issues of combining imperative code with reactive code (by separating them in actors and reactors).<ref name="stella">{{Citation \| url = https://drops.dagstuhl.de/opus/volltexte/2020/13176/ \| first1 = Sam \| last1 = Van den Vonder \| first2 = Thierry \| last2 = Renaux \| first3 = Bjarno \| last3 = Oeyen \| first4 = Joeri \| last4 = De Koster \| first5 = Wolfgang \| last5 = De Meuter \| contribution = Tackling the Awkward Squad for Reactive Programming: The Actor-Reactor Model \| title = Leibniz International Proceedings in Informatics (LIPIcs) \| volume = 166 \| year = 2020 \| pages = 19:1–19:29 \| doi = 10.4230/LIPIcs.ECOOP.2020.19\| isbn = 9783959771542 }}.</ref> Actors are suitable for use in distributed reactive systems.<ref name="stella2">{{Citation \| url = https://programming-journal.org/2022/6/14/ \| first1 = Sam \| last1 = Van den Vonder \| first2 = Thierry \| last2 = Renaux \| first3 = Wolfgang \| last3 = De Meuter \| contribution = Topology-Level Reactivity in Distributed Reactive Programs: Reactive Acquaintance Management using Flocks \| title = The Art, Science, and Engineering of Programming \| volume = 6:3 \| year = 2022 \| issue = 3 \| pages = 14:1–14:36 \| doi = 10.22152/programming-journal.org/2022/6/14 \| s2cid = 246979565 }}</ref>		* Stella is an actor-based reactive programming language that demonstrates a model of "actors" and "reactors" which aims to avoid the issues of combining imperative code with reactive code (by separating them in actors and reactors).<ref name="stella">{{Citation \| url = https://drops.dagstuhl.de/opus/volltexte/2020/13176/ \| first1 = Sam \| last1 = Van den Vonder \| first2 = Thierry \| last2 = Renaux \| first3 = Bjarno \| last3 = Oeyen \| first4 = Joeri \| last4 = De Koster \| first5 = Wolfgang \| last5 = De Meuter \| contribution = Tackling the Awkward Squad for Reactive Programming: The Actor-Reactor Model \| title = Leibniz International Proceedings in Informatics (LIPIcs) \| volume = 166 \| year = 2020 \| pages = 19:1–19:29 \| doi = 10.4230/LIPIcs.ECOOP.2020.19\| isbn = 9783959771542 \| s2cid = 260445152 }}.</ref> Actors are suitable for use in distributed reactive systems.<ref name="stella2">{{Citation \| url = https://programming-journal.org/2022/6/14/ \| first1 = Sam \| last1 = Van den Vonder \| first2 = Thierry \| last2 = Renaux \| first3 = Wolfgang \| last3 = De Meuter \| contribution = Topology-Level Reactivity in Distributed Reactive Programs: Reactive Acquaintance Management using Flocks \| title = The Art, Science, and Engineering of Programming \| volume = 6 \| year = 2022 \| issue = 3 \| pages = 14:1–14:36 \| doi = 10.22152/programming-journal.org/2022/6/14 \| s2cid = 246979565 }}</ref>
	*[[TidalCycles]] is a pure FRP domain specific language for musical pattern, embedded in the [[Haskell (programming language)\|Haskell]] programming language.		*[[TidalCycles]] is a pure FRP domain specific language for musical pattern, embedded in the [[Haskell (programming language)\|Haskell]] programming language.

C. A. Russell: capitalize Android (operating system)|

2023-09-16T22:09:13Z

capitalize Android (operating system)

← Previous revision		Revision as of 22:09, 16 September 2023
Line 1:		Line 1:
	{{Short description\|Programming paradigm}}		{{Short description\|Programming paradigm}}
	{{Distinguish\|text=factory reset protection (FRP), a feature in some [[Android (operating system)\|~~android~~]] devices}}		{{Distinguish\|text=factory reset protection (FRP), a feature in some [[Android (operating system)\|Android]] devices}}
	{{Programming paradigms}}		{{Programming paradigms}}
	'''Functional reactive programming''' ('''FRP''') is a [[programming paradigm]] for [[reactive programming]] ([[asynchronous programming\|asynchronous]] [[dataflow programming]]) using the building blocks of [[functional programming]] (e.g. [[Map (higher-order function)\|map]], [[Fold (higher-order function)\|reduce]], [[Filter (higher-order function)\|filter]]). FRP has been used for programming [[graphical user interface]]s (GUIs), [[robotics]], games, and music, aiming to simplify these problems by explicitly modeling time.{{Citation needed\|date = March 2016}}		'''Functional reactive programming''' ('''FRP''') is a [[programming paradigm]] for [[reactive programming]] ([[asynchronous programming\|asynchronous]] [[dataflow programming]]) using the building blocks of [[functional programming]] (e.g. [[Map (higher-order function)\|map]], [[Fold (higher-order function)\|reduce]], [[Filter (higher-order function)\|filter]]). FRP has been used for programming [[graphical user interface]]s (GUIs), [[robotics]], games, and music, aiming to simplify these problems by explicitly modeling time.{{Citation needed\|date = March 2016}}

← Previous revision		Revision as of 06:37, 16 May 2024
Line 18:		Line 18:

	=== Discrete ===		=== Discrete ===
	Formulations such as Event-Driven FRP and versions of [[Elm (programming language)\|Elm]] prior to 0.17 require that updates are discrete and event-driven.<ref>{{Citation \|first1=Walid \|last1=Taha \|first2=Zhanyong \|last2=Wan \|first3=Paul \|last3=Hudak \|url=http://www.cs.yale.edu/homes/zwan/papers/mcu/efrp.pdf \|contribution=Event-Driven FRP \|title=PADL \|year=2002 \|publisher=Yale \|access-date=2013-09-23 \|archive-url=https://web.archive.org/web/20130928163653/http://www.cs.yale.edu/homes/zwan/papers/mcu/efrp.pdf \|archive-date=2013-09-28 \|url-status=~~deviated \|archivedate=2013-09-28 \|archiveurl=https://web.archive.org/web/20130928163653/http://www.cs.yale.edu/homes/zwan/papers/mcu/efrp.pdf~~ }}</ref> These formulations have pushed for practical FRP, focusing on semantics that have a simple API that can be implemented efficiently in a setting such as robotics or in a web-browser.<ref>{{Citation \|first1=Evan \|last1=Czaplicki \|first2=Stephen \|last2=Chong \|publisher=Harvard \|contribution-url=http://people.seas.harvard.edu/~chong/abstracts/CzaplickiC13.html \|contribution=Asynchronous Functional Reactive Programming for GUIs \|title=PLDI \|year=2013}}</ref>		Formulations such as Event-Driven FRP and versions of [[Elm (programming language)\|Elm]] prior to 0.17 require that updates are discrete and event-driven.<ref>{{Citation \|first1=Walid \|last1=Taha \|first2=Zhanyong \|last2=Wan \|first3=Paul \|last3=Hudak \|url=http://www.cs.yale.edu/homes/zwan/papers/mcu/efrp.pdf \|contribution=Event-Driven FRP \|title=PADL \|year=2002 \|publisher=Yale \|access-date=2013-09-23 \|archive-url=https://web.archive.org/web/20130928163653/http://www.cs.yale.edu/homes/zwan/papers/mcu/efrp.pdf \|archive-date=2013-09-28 \|url-status=dead }}</ref> These formulations have pushed for practical FRP, focusing on semantics that have a simple API that can be implemented efficiently in a setting such as robotics or in a web-browser.<ref>{{Citation \|first1=Evan \|last1=Czaplicki \|first2=Stephen \|last2=Chong \|publisher=Harvard \|contribution-url=http://people.seas.harvard.edu/~chong/abstracts/CzaplickiC13.html \|contribution=Asynchronous Functional Reactive Programming for GUIs \|title=PLDI \|year=2013}}</ref>

	In these formulations, it is common that the ideas of behaviors and events are combined into signals that always have a current value, but change discretely.<ref>{{Citation \|date=Feb 2011 \|first1=Zhanyong \|last1=Wan \|first2=Walid \|last2=Taha \|first3=Paul \|last3=Hudak \|url=http://haskell.cs.yale.edu/wp-content/uploads/2011/02/rt-frp.pdf \|contribution=Real-Time FRP \|title=ICFP \|number=1 \|access-date=2013-09-23 \|archive-url=https://web.archive.org/web/20130928163734/http://haskell.cs.yale.edu/wp-content/uploads/2011/02/rt-frp.pdf \|archive-date=2013-09-28 \|url-status=~~deviated \|archivedate=2013-09-28 \|archiveurl=https://web.archive.org/web/20130928163734/http://haskell.cs.yale.edu/wp-content/uploads/2011/02/rt-frp.pdf~~ }}</ref>		In these formulations, it is common that the ideas of behaviors and events are combined into signals that always have a current value, but change discretely.<ref>{{Citation \|date=Feb 2011 \|first1=Zhanyong \|last1=Wan \|first2=Walid \|last2=Taha \|first3=Paul \|last3=Hudak \|url=http://haskell.cs.yale.edu/wp-content/uploads/2011/02/rt-frp.pdf \|contribution=Real-Time FRP \|title=ICFP \|number=1 \|access-date=2013-09-23 \|archive-url=https://web.archive.org/web/20130928163734/http://haskell.cs.yale.edu/wp-content/uploads/2011/02/rt-frp.pdf \|archive-date=2013-09-28 \|url-status=dead }}</ref>

	==Interactive FRP==		==Interactive FRP==
Line 26:		Line 26:
	*Create a data structure of actions which appear as the outputs. The actions must be run by an external interpreter or environment. This inherits all of the difficulties of the original stream [[input/output]] (I/O) system of [[Haskell]].<ref>{{cite web \|url=https://courses.cs.washington.edu/courses/cse505/01au/functional/functional-io.pdf \|title=I/O in Purely Functional Languages \|first=Alan \|last=Borning \|archive-url=https://web.archive.org/web/20220428171557/https://courses.cs.washington.edu/courses/cse505/01au/functional/functional-io.pdf \|archive-date=2022-04-28 \|url-status=live}}</ref>		*Create a data structure of actions which appear as the outputs. The actions must be run by an external interpreter or environment. This inherits all of the difficulties of the original stream [[input/output]] (I/O) system of [[Haskell]].<ref>{{cite web \|url=https://courses.cs.washington.edu/courses/cse505/01au/functional/functional-io.pdf \|title=I/O in Purely Functional Languages \|first=Alan \|last=Borning \|archive-url=https://web.archive.org/web/20220428171557/https://courses.cs.washington.edu/courses/cse505/01au/functional/functional-io.pdf \|archive-date=2022-04-28 \|url-status=live}}</ref>
	*Use Arrowized FRP and embed arrows which are capable of performing actions. The actions may also have identities, which allows them to maintain separate mutable stores for example. This is the approach taken by the Fudgets library<ref>{{Cite web\|url=https://cth.altocumulus.org/~hallgren/Thesis/fudgets_thesis_color.pdf\|title=Fudgets – Purely Functional Processes with applications to Graphical User Interfaces\|first1=Magnus\|last1=Carlsson\|first2=Thomas\|last2=Hallgren\|year=1998\|archive-url=https://web.archive.org/web/20221015141447/https://cth.altocumulus.org/~hallgren/Thesis/fudgets_thesis_color.pdf\|archive-date=2022-10-15\|url-status=live}}</ref> and, more generally, Monadic Stream Functions.<ref>{{Citation \|date=July 2016 \|first1=Ivan \|last1=Perez \|first2=Manuel \|last2=Barenz \|first3=Henrik \|last3=Nilsson \|url=http://www.cs.nott.ac.uk/~psxip1/papers/2016-HaskellSymposium-Perez-Barenz-Nilsson-FRPRefactored-short.pdf \|contribution=Functional Reactive Programming, Refactored \|title=Haskell Symposium}}</ref>		*Use Arrowized FRP and embed arrows which are capable of performing actions. The actions may also have identities, which allows them to maintain separate mutable stores for example. This is the approach taken by the Fudgets library<ref>{{Cite web\|url=https://cth.altocumulus.org/~hallgren/Thesis/fudgets_thesis_color.pdf\|title=Fudgets – Purely Functional Processes with applications to Graphical User Interfaces\|first1=Magnus\|last1=Carlsson\|first2=Thomas\|last2=Hallgren\|year=1998\|archive-url=https://web.archive.org/web/20221015141447/https://cth.altocumulus.org/~hallgren/Thesis/fudgets_thesis_color.pdf\|archive-date=2022-10-15\|url-status=live}}</ref> and, more generally, Monadic Stream Functions.<ref>{{Citation \|date=July 2016 \|first1=Ivan \|last1=Perez \|first2=Manuel \|last2=Barenz \|first3=Henrik \|last3=Nilsson \|url=http://www.cs.nott.ac.uk/~psxip1/papers/2016-HaskellSymposium-Perez-Barenz-Nilsson-FRPRefactored-short.pdf \|contribution=Functional Reactive Programming, Refactored \|title=Haskell Symposium}}</ref>
	*The novel approach is to allow actions to be run now (in the IO monad) but defer the receipt of their results until later.<ref>{{Cite web \|url=http://www.cse.chalmers.se/~atze/papers/prprfrp.pdf \|title=Practical Principled FRP \|author1=Atze van der Ploeg \|first2=Koen \|last2=Claessen \|access-date=2015-07-24 \|archive-url=https://web.archive.org/web/20150701030428/http://www.cse.chalmers.se/~atze/papers/prprfrp.pdf \|archive-date=2015-07-01 \|url-status=~~deviated \|archivedate=2015-07-01 \|archiveurl=https://web.archive.org/web/20150701030428/http://www.cse.chalmers.se/~atze/papers/prprfrp.pdf~~ }}</ref> This makes use of an interaction between the Event and IO monads, and is compatible with a more expression-oriented FRP:		*The novel approach is to allow actions to be run now (in the IO monad) but defer the receipt of their results until later.<ref>{{Cite web \|url=http://www.cse.chalmers.se/~atze/papers/prprfrp.pdf \|title=Practical Principled FRP \|author1=Atze van der Ploeg \|first2=Koen \|last2=Claessen \|access-date=2015-07-24 \|archive-url=https://web.archive.org/web/20150701030428/http://www.cse.chalmers.se/~atze/papers/prprfrp.pdf \|archive-date=2015-07-01 \|url-status=dead }}</ref> This makes use of an interaction between the Event and IO monads, and is compatible with a more expression-oriented FRP:
	{{sxhl\|2=elm\|		{{sxhl\|2=elm\|
	planNow :: Event (IO a) -> IO (Event a)		planNow :: Event (IO a) -> IO (Event a)
Line 41:		Line 41:
	Implementations exist for many [[programming language]]s, including:		Implementations exist for many [[programming language]]s, including:
	* Yampa is an arrowized, efficient, pure [[Haskell]] implementation with SDL, SDL2, OpenGL and HTML DOM support.		* Yampa is an arrowized, efficient, pure [[Haskell]] implementation with SDL, SDL2, OpenGL and HTML DOM support.
	* The language [[Elm (programming language)\|Elm]] used to support FRP<ref>{{Citation \|first=Evan \|last=Czaplicki \|url=https://www.seas.harvard.edu/sites/default/files/files/archived/Czaplicki.pdf \|title=Elm: Concurrent FRP for Functional GUIs \|date=Apr 2012 \|place=Harvard \|type=thesis \|access-date=2015-02-17 \|archive-url=https://web.archive.org/web/20160604000246/http://www.seas.harvard.edu/sites/default/files/files/archived/Czaplicki.pdf \|archive-date=2016-06-04 \|url-status=~~deviated \|archivedate=2016-06-04 \|archiveurl=https://web.archive.org/web/20160604000246/https://www.seas.harvard.edu/sites/default/files/files/archived/Czaplicki.pdf~~ }}</ref> but has since replaced it with a different pattern.<ref>{{cite web \|last1=Czaplicki \|first1=Evan \|title=A Farewell to FRP \|url=http://elm-lang.org/blog/farewell-to-frp \|website=elm \|access-date=14 July 2018 \|ref=farewell-to-frp}}</ref>		* The language [[Elm (programming language)\|Elm]] used to support FRP<ref>{{Citation \|first=Evan \|last=Czaplicki \|url=https://www.seas.harvard.edu/sites/default/files/files/archived/Czaplicki.pdf \|title=Elm: Concurrent FRP for Functional GUIs \|date=Apr 2012 \|place=Harvard \|type=thesis \|access-date=2015-02-17 \|archive-url=https://web.archive.org/web/20160604000246/http://www.seas.harvard.edu/sites/default/files/files/archived/Czaplicki.pdf \|archive-date=2016-06-04 \|url-status=dead }}</ref> but has since replaced it with a different pattern.<ref>{{cite web \|last1=Czaplicki \|first1=Evan \|title=A Farewell to FRP \|url=http://elm-lang.org/blog/farewell-to-frp \|website=elm \|access-date=14 July 2018 \|ref=farewell-to-frp}}</ref>
	* reflex is an efficient push–pull FRP implementation in Haskell with hosts for [[web browser]] – [[Document Object Model]] (DOM), [[Simple DirectMedia Layer]] (SDL), and Gloss.		* reflex is an efficient push–pull FRP implementation in Haskell with hosts for [[web browser]] – [[Document Object Model]] (DOM), [[Simple DirectMedia Layer]] (SDL), and Gloss.
	* reactive-banana is a target-agnostic push FRP implementation in Haskell.		* reactive-banana is a target-agnostic push FRP implementation in Haskell.

← Previous revision		Revision as of 17:51, 14 May 2024
Line 18:		Line 18:

	=== Discrete ===		=== Discrete ===
	Formulations such as Event-Driven FRP and versions of [[Elm (programming language)\|Elm]] prior to 0.17 require that updates are discrete and event-driven.<ref>{{Citation \|first1=Walid \|last1=Taha \|first2=Zhanyong \|last2=Wan \|first3=Paul \|last3=Hudak \|url=http://www.cs.yale.edu/homes/zwan/papers/mcu/efrp.pdf \|contribution=Event-Driven FRP \|title=PADL \|year=2002 \|publisher=Yale \|access-date=2013-09-23 \|archive-url=https://web.archive.org/web/20130928163653/http://www.cs.yale.edu/homes/zwan/papers/mcu/efrp.pdf \|archive-date=2013-09-28 \|url-status=~~dead~~}}</ref> These formulations have pushed for practical FRP, focusing on semantics that have a simple API that can be implemented efficiently in a setting such as robotics or in a web-browser.<ref>{{Citation \|first1=Evan \|last1=Czaplicki \|first2=Stephen \|last2=Chong \|publisher=Harvard \|contribution-url=http://people.seas.harvard.edu/~chong/abstracts/CzaplickiC13.html \|contribution=Asynchronous Functional Reactive Programming for GUIs \|title=PLDI \|year=2013}}</ref>		Formulations such as Event-Driven FRP and versions of [[Elm (programming language)\|Elm]] prior to 0.17 require that updates are discrete and event-driven.<ref>{{Citation \|first1=Walid \|last1=Taha \|first2=Zhanyong \|last2=Wan \|first3=Paul \|last3=Hudak \|url=http://www.cs.yale.edu/homes/zwan/papers/mcu/efrp.pdf \|contribution=Event-Driven FRP \|title=PADL \|year=2002 \|publisher=Yale \|access-date=2013-09-23 \|archive-url=https://web.archive.org/web/20130928163653/http://www.cs.yale.edu/homes/zwan/papers/mcu/efrp.pdf \|archive-date=2013-09-28 \|url-status=deviated \|archivedate=2013-09-28 \|archiveurl=https://web.archive.org/web/20130928163653/http://www.cs.yale.edu/homes/zwan/papers/mcu/efrp.pdf }}</ref> These formulations have pushed for practical FRP, focusing on semantics that have a simple API that can be implemented efficiently in a setting such as robotics or in a web-browser.<ref>{{Citation \|first1=Evan \|last1=Czaplicki \|first2=Stephen \|last2=Chong \|publisher=Harvard \|contribution-url=http://people.seas.harvard.edu/~chong/abstracts/CzaplickiC13.html \|contribution=Asynchronous Functional Reactive Programming for GUIs \|title=PLDI \|year=2013}}</ref>

	In these formulations, it is common that the ideas of behaviors and events are combined into signals that always have a current value, but change discretely.<ref>{{Citation \|date=Feb 2011 \|first1=Zhanyong \|last1=Wan \|first2=Walid \|last2=Taha \|first3=Paul \|last3=Hudak \|url=http://haskell.cs.yale.edu/wp-content/uploads/2011/02/rt-frp.pdf \|contribution=Real-Time FRP \|title=ICFP \|number=1 \|access-date=2013-09-23 \|archive-url=https://web.archive.org/web/20130928163734/http://haskell.cs.yale.edu/wp-content/uploads/2011/02/rt-frp.pdf \|archive-date=2013-09-28 \|url-status=~~dead~~}}</ref>		In these formulations, it is common that the ideas of behaviors and events are combined into signals that always have a current value, but change discretely.<ref>{{Citation \|date=Feb 2011 \|first1=Zhanyong \|last1=Wan \|first2=Walid \|last2=Taha \|first3=Paul \|last3=Hudak \|url=http://haskell.cs.yale.edu/wp-content/uploads/2011/02/rt-frp.pdf \|contribution=Real-Time FRP \|title=ICFP \|number=1 \|access-date=2013-09-23 \|archive-url=https://web.archive.org/web/20130928163734/http://haskell.cs.yale.edu/wp-content/uploads/2011/02/rt-frp.pdf \|archive-date=2013-09-28 \|url-status=deviated \|archivedate=2013-09-28 \|archiveurl=https://web.archive.org/web/20130928163734/http://haskell.cs.yale.edu/wp-content/uploads/2011/02/rt-frp.pdf }}</ref>

	==Interactive FRP==		==Interactive FRP==
Line 26:		Line 26:
	*Create a data structure of actions which appear as the outputs. The actions must be run by an external interpreter or environment. This inherits all of the difficulties of the original stream [[input/output]] (I/O) system of [[Haskell]].<ref>{{cite web \|url=https://courses.cs.washington.edu/courses/cse505/01au/functional/functional-io.pdf \|title=I/O in Purely Functional Languages \|first=Alan \|last=Borning \|archive-url=https://web.archive.org/web/20220428171557/https://courses.cs.washington.edu/courses/cse505/01au/functional/functional-io.pdf \|archive-date=2022-04-28 \|url-status=live}}</ref>		*Create a data structure of actions which appear as the outputs. The actions must be run by an external interpreter or environment. This inherits all of the difficulties of the original stream [[input/output]] (I/O) system of [[Haskell]].<ref>{{cite web \|url=https://courses.cs.washington.edu/courses/cse505/01au/functional/functional-io.pdf \|title=I/O in Purely Functional Languages \|first=Alan \|last=Borning \|archive-url=https://web.archive.org/web/20220428171557/https://courses.cs.washington.edu/courses/cse505/01au/functional/functional-io.pdf \|archive-date=2022-04-28 \|url-status=live}}</ref>
	*Use Arrowized FRP and embed arrows which are capable of performing actions. The actions may also have identities, which allows them to maintain separate mutable stores for example. This is the approach taken by the Fudgets library<ref>{{Cite web\|url=https://cth.altocumulus.org/~hallgren/Thesis/fudgets_thesis_color.pdf\|title=Fudgets – Purely Functional Processes with applications to Graphical User Interfaces\|first1=Magnus\|last1=Carlsson\|first2=Thomas\|last2=Hallgren\|year=1998\|archive-url=https://web.archive.org/web/20221015141447/https://cth.altocumulus.org/~hallgren/Thesis/fudgets_thesis_color.pdf\|archive-date=2022-10-15\|url-status=live}}</ref> and, more generally, Monadic Stream Functions.<ref>{{Citation \|date=July 2016 \|first1=Ivan \|last1=Perez \|first2=Manuel \|last2=Barenz \|first3=Henrik \|last3=Nilsson \|url=http://www.cs.nott.ac.uk/~psxip1/papers/2016-HaskellSymposium-Perez-Barenz-Nilsson-FRPRefactored-short.pdf \|contribution=Functional Reactive Programming, Refactored \|title=Haskell Symposium}}</ref>		*Use Arrowized FRP and embed arrows which are capable of performing actions. The actions may also have identities, which allows them to maintain separate mutable stores for example. This is the approach taken by the Fudgets library<ref>{{Cite web\|url=https://cth.altocumulus.org/~hallgren/Thesis/fudgets_thesis_color.pdf\|title=Fudgets – Purely Functional Processes with applications to Graphical User Interfaces\|first1=Magnus\|last1=Carlsson\|first2=Thomas\|last2=Hallgren\|year=1998\|archive-url=https://web.archive.org/web/20221015141447/https://cth.altocumulus.org/~hallgren/Thesis/fudgets_thesis_color.pdf\|archive-date=2022-10-15\|url-status=live}}</ref> and, more generally, Monadic Stream Functions.<ref>{{Citation \|date=July 2016 \|first1=Ivan \|last1=Perez \|first2=Manuel \|last2=Barenz \|first3=Henrik \|last3=Nilsson \|url=http://www.cs.nott.ac.uk/~psxip1/papers/2016-HaskellSymposium-Perez-Barenz-Nilsson-FRPRefactored-short.pdf \|contribution=Functional Reactive Programming, Refactored \|title=Haskell Symposium}}</ref>
	*The novel approach is to allow actions to be run now (in the IO monad) but defer the receipt of their results until later.<ref>{{Cite web \|url=http://www.cse.chalmers.se/~atze/papers/prprfrp.pdf \|title=Practical Principled FRP \|author1=Atze van der Ploeg \|first2=Koen \|last2=Claessen \|access-date=2015-07-24 \|archive-url=https://web.archive.org/web/20150701030428/http://www.cse.chalmers.se/~atze/papers/prprfrp.pdf \|archive-date=2015-07-01 \|url-status=~~dead~~}}</ref> This makes use of an interaction between the Event and IO monads, and is compatible with a more expression-oriented FRP:		*The novel approach is to allow actions to be run now (in the IO monad) but defer the receipt of their results until later.<ref>{{Cite web \|url=http://www.cse.chalmers.se/~atze/papers/prprfrp.pdf \|title=Practical Principled FRP \|author1=Atze van der Ploeg \|first2=Koen \|last2=Claessen \|access-date=2015-07-24 \|archive-url=https://web.archive.org/web/20150701030428/http://www.cse.chalmers.se/~atze/papers/prprfrp.pdf \|archive-date=2015-07-01 \|url-status=deviated \|archivedate=2015-07-01 \|archiveurl=https://web.archive.org/web/20150701030428/http://www.cse.chalmers.se/~atze/papers/prprfrp.pdf }}</ref> This makes use of an interaction between the Event and IO monads, and is compatible with a more expression-oriented FRP:
	{{sxhl\|2=elm\|		{{sxhl\|2=elm\|
	planNow :: Event (IO a) -> IO (Event a)		planNow :: Event (IO a) -> IO (Event a)
Line 41:		Line 41:
	Implementations exist for many [[programming language]]s, including:		Implementations exist for many [[programming language]]s, including:
	* Yampa is an arrowized, efficient, pure [[Haskell]] implementation with SDL, SDL2, OpenGL and HTML DOM support.		* Yampa is an arrowized, efficient, pure [[Haskell]] implementation with SDL, SDL2, OpenGL and HTML DOM support.
	* The language [[Elm (programming language)\|Elm]] used to support FRP<ref>{{Citation \|first=Evan \|last=Czaplicki \|url=https://www.seas.harvard.edu/sites/default/files/files/archived/Czaplicki.pdf \|title=Elm: Concurrent FRP for Functional GUIs \|date=Apr 2012 \|place=Harvard \|type=thesis \|access-date=2015-02-17 \|archive-url=https://web.archive.org/web/20160604000246/http://www.seas.harvard.edu/sites/default/files/files/archived/Czaplicki.pdf \|archive-date=2016-06-04 \|url-status=~~dead~~}}</ref> but has since replaced it with a different pattern.<ref>{{cite web \|last1=Czaplicki \|first1=Evan \|title=A Farewell to FRP \|url=http://elm-lang.org/blog/farewell-to-frp \|website=elm \|access-date=14 July 2018 \|ref=farewell-to-frp}}</ref>		* The language [[Elm (programming language)\|Elm]] used to support FRP<ref>{{Citation \|first=Evan \|last=Czaplicki \|url=https://www.seas.harvard.edu/sites/default/files/files/archived/Czaplicki.pdf \|title=Elm: Concurrent FRP for Functional GUIs \|date=Apr 2012 \|place=Harvard \|type=thesis \|access-date=2015-02-17 \|archive-url=https://web.archive.org/web/20160604000246/http://www.seas.harvard.edu/sites/default/files/files/archived/Czaplicki.pdf \|archive-date=2016-06-04 \|url-status=deviated \|archivedate=2016-06-04 \|archiveurl=https://web.archive.org/web/20160604000246/https://www.seas.harvard.edu/sites/default/files/files/archived/Czaplicki.pdf }}</ref> but has since replaced it with a different pattern.<ref>{{cite web \|last1=Czaplicki \|first1=Evan \|title=A Farewell to FRP \|url=http://elm-lang.org/blog/farewell-to-frp \|website=elm \|access-date=14 July 2018 \|ref=farewell-to-frp}}</ref>
	* reflex is an efficient push–pull FRP implementation in Haskell with hosts for [[web browser]] – [[Document Object Model]] (DOM), [[Simple DirectMedia Layer]] (SDL), and Gloss.		* reflex is an efficient push–pull FRP implementation in Haskell with hosts for [[web browser]] – [[Document Object Model]] (DOM), [[Simple DirectMedia Layer]] (SDL), and Gloss.
	* reactive-banana is a target-agnostic push FRP implementation in Haskell.		* reactive-banana is a target-agnostic push FRP implementation in Haskell.