Results 1 
9 of
9
Arrows, like monads, are monoids
 Proc. of 22nd Ann. Conf. on Mathematical Foundations of Programming Semantics, MFPS XXII, v. 158 of Electron. Notes in Theoret. Comput. Sci
, 2006
"... Monads are by now wellestablished as programming construct in functional languages. Recently, the notion of “Arrow ” was introduced by Hughes as an extension, not with one, but with two type parameters. At first, these Arrows may look somewhat arbitrary. Here we show that they are categorically fai ..."
Abstract

Cited by 12 (1 self)
 Add to MetaCart
Monads are by now wellestablished as programming construct in functional languages. Recently, the notion of “Arrow ” was introduced by Hughes as an extension, not with one, but with two type parameters. At first, these Arrows may look somewhat arbitrary. Here we show that they are categorically fairly civilised, by showing that they correspond to monoids in suitable subcategories of bifunctors C op ×C → C. This shows that, at a suitable level of abstraction, arrows are like monads — which are monoids in categories of functors C → C. Freyd categories have been introduced by Power and Robinson to model computational effects, well before Hughes ’ Arrows appeared. It is often claimed (informally) that Arrows are simply Freyd categories. We shall make this claim precise by showing how monoids in categories of bifunctors exactly correspond to Freyd categories.
Causal commutative arrows and their optimization
 In Proc. International Conference on Functional Programming, ICFP ’09
, 2009
"... Arrows are a popular form of abstract computation. Being more general than monads, they are more broadly applicable, and in particular are a good abstraction for signal processing and dataflow computations. Most notably, arrows form the basis for a domain specific language called Yampa, which has be ..."
Abstract

Cited by 10 (1 self)
 Add to MetaCart
Arrows are a popular form of abstract computation. Being more general than monads, they are more broadly applicable, and in particular are a good abstraction for signal processing and dataflow computations. Most notably, arrows form the basis for a domain specific language called Yampa, which has been used in a variety of concrete applications, including animation, robotics, sound synthesis, control systems, and graphical user interfaces. computations captured by Yampa. Unfortunately, arrows are not concrete enough to do this with precision. To remedy this situation we introduce the concept of commutative arrows that capture a kind of noninterference property of concurrent computations. We also add an init operator, and identify a crucial law that captures the causal nature of arrow effects. We call the resulting computational model causal commutative arrows. To study this class of computations in more detail, we define an extension to the simply typed lambda calculus called causal commutative arrows (CCA), and study its properties. Our key contribution is the identification of a normal form for CCA called causal commutative normal form (CCNF). By defining a normalization procedure we have developed an optimization strategy that yields dramatic improvements in performance over conventional implementations of arrows. We have implemented this technique in Haskell, and conducted benchmarks that validate the effectiveness of our approach. When combined with stream fusion, the overall methodology can result in speedups of greater than two orders of magnitude.
On the Creation of Dynamic, Interactive Virtual Environments
 N PROCEEDINGS OF THE IEEE VR 2008 WORKSHOP "SEARIS  SOFTWARE ENGINEERING AND ARCHITECTURES FOR INTERACTIVE SYSTEMS"
, 2008
"... The creation of engaging, interactive virtual environments is a difficult task, but one that can be eased with the development of better software support. This paper proposes that a better understanding of the problem of building Dynamic, Interactive Virtual Environments must be developed. Equipped ..."
Abstract

Cited by 4 (0 self)
 Add to MetaCart
The creation of engaging, interactive virtual environments is a difficult task, but one that can be eased with the development of better software support. This paper proposes that a better understanding of the problem of building Dynamic, Interactive Virtual Environments must be developed. Equipped with an understanding of the design space of Dynamics, Dynamic Interaction, and Interactive Dynamics, the requirements for such a support system can be established. Finally, a system that supports the development of such environments is briefly presented, Functional Reactive Virtual Reality.
Optimisation of dynamic, hybrid signal function networks
 In Trends in Functional Programming (TFP ’08
, 2008
"... Abstract: Functional Reactive Programming (FRP) is an approach to reactive programming where systems are structured as networks of functions operating on signals. FRP is based on the synchronous dataflow paradigm and supports both continuoustime and discretetime signals (hybrid systems). What set ..."
Abstract

Cited by 3 (2 self)
 Add to MetaCart
Abstract: Functional Reactive Programming (FRP) is an approach to reactive programming where systems are structured as networks of functions operating on signals. FRP is based on the synchronous dataflow paradigm and supports both continuoustime and discretetime signals (hybrid systems). What sets FRP apart from most other languages for similar applications is its support for systems with dynamic structure and for higherorder dataflow constructs. This raises a range of implementation challenges. This paper contributes towards advancing the state of the art of FRP implementation by studying the notion of signal change and change propagation in a setting of hybrid signal function networks with dynamic structure. To sidestep some problems of certain previous FRP implementations that are structured using arrows, we suggest working with a notion of composable, multiinput and multioutput signal functions. A clear conceptual distinction is also made between continuoustime and discretetime signals. We then show how establishing changerelated properties of the signal functions in a network allows such networks to be simplified (static optimisation) and can help reducing the amount of computation needed for executing the networks (dynamic optimisation). Interestingly, distinguishing between continuoustime and discretetime signals allows us to characterise the changerelated properties of signal functions more precisely than what we otherwise would have been able to, which is helpful for optimisation.
TOWARDS SAFE AND EFFICIENT FUNCTIONAL REACTIVE PROGRAMMING
, 2011
"... Functional Reactive Programming (FRP) is an approach to reactive programming where systems are structured as networks of functions operating on timevarying values (signals). FRP is based on the synchronous dataflow paradigm and supports both continuoustime and discretetime signals (hybrid systems ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
Functional Reactive Programming (FRP) is an approach to reactive programming where systems are structured as networks of functions operating on timevarying values (signals). FRP is based on the synchronous dataflow paradigm and supports both continuoustime and discretetime signals (hybrid systems). What sets FRP apart from most other reactive languages is its support for systems with highly dynamic structure (dynamism) and higherorder reactive constructs (higherorder dataflow). However, the price paid for these features has been the loss of the safety and performance guarantees provided by other, less expressive, reactive languages. Statically guaranteeing safety properties of programs is an attractive proposition. This is true in particular for typical application domains for reactive programming such as embedded systems. To that end, many existing reactive languages have type systems or other static checksthatguaranteedomainspecificconstraints, suchasfeedbackbeingwellformed(causality analysis). However, comparedwithFRP,theyarelimitedintheircapacitytosupportdynamism andhigherorderdataflow. Ontheotherhand, asestablishedstatictechniquesdonotsufficefor highly structurally dynamic systems, FRP generally enforces few domainspecific constraints, leaving the FRP programmer to manually check that the constraints are respected. Thus, there
Functional Reactive Virtual Reality
 IN SHORT PAPER PROCEEDINGS OF IPTEGVE SYMPOSIUM (2007)
, 2007
"... In this paper we introduce a VR system extension that focuses on the creation of interactive, dynamic Virtual Environments. The extension uses the recently developed programming concept, Functional Reactive Programming. This paradigm focuses on an explicit and more natural concept of time in the mod ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
In this paper we introduce a VR system extension that focuses on the creation of interactive, dynamic Virtual Environments. The extension uses the recently developed programming concept, Functional Reactive Programming. This paradigm focuses on an explicit and more natural concept of time in the modeling of dynamics, without sacrificing interactivity. We present an implementation that embeds the Functional Reactive Programming concept
An Ultrametric Model of Reactive Programming
, 2010
"... We describe a denotational model of higherorder functional reactive programming using ultrametric spaces, which provide a natural Cartesian closed generalization of causal stream functions. We define a domainspecific language corresponding to the model. We then show how reactive programs written i ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
We describe a denotational model of higherorder functional reactive programming using ultrametric spaces, which provide a natural Cartesian closed generalization of causal stream functions. We define a domainspecific language corresponding to the model. We then show how reactive programs written in this language may be implemented efficiently using an imperatively updated dataflow graph and give a higherorder separation logic proof that this lowlevel implementation is correct with respect to the highlevel semantics.
Virtualizing RealWorld Objects in FRP
, 2011
"... We begin with a functional reactive programming (FRP) model in which every program is viewed as a signal function that converts a stream of input values into a stream of output values. We observe that objects in the real world – such as a keyboard or sound card – can be thought of as signal function ..."
Abstract
 Add to MetaCart
We begin with a functional reactive programming (FRP) model in which every program is viewed as a signal function that converts a stream of input values into a stream of output values. We observe that objects in the real world – such as a keyboard or sound card – can be thought of as signal functions as well. This leads us to a radically different approach to I/O – instead of treating realworld objects as being external to the program, we expand the sphere of influence of program execution to include them within the program. We call this virtualizing realworld objects. We explore how even virtual objects, such as GUI widgets, and nonlocal effects, such as are needed for debugging (using something that we call a “wormhole”) and random number generation, can be handled in the same way. Our methodology may at first seem naïve – one may ask how we prevent a virtualized device from being copied, thus potentially introducing nondeterminism as one part of a program competes for the same resource as another. To solve this problem, we introduce the notion of a resource type that assures that a virtualized object is not duplicated and that I/Oandnonlocaleffectsaresafe. Resourcetypesalsoprovideadeeperleveloftransparency:
Causal commutative arrows
"... Arrows are a popular form of abstract computation. Being more general than monads, they are more broadly applicable, and, in particular, are a good abstraction for signal processing and dataflow computations. Most notably, arrows form the basis for a domainspecific language called Yampa, which has ..."
Abstract
 Add to MetaCart
Arrows are a popular form of abstract computation. Being more general than monads, they are more broadly applicable, and, in particular, are a good abstraction for signal processing and dataflow computations. Most notably, arrows form the basis for a domainspecific language called Yampa, which has been used in a variety of concrete applications, including animation, robotics, sound synthesis, control systems, and graphical user interfaces. Our primary interest is in better understanding the class of abstract computations captured by Yampa. Unfortunately, arrows are not concrete enough to do this with precision. To remedy this situation, we introduce the concept of commutative arrows that capture a noninterference property of concurrent computations. We also add an init operator that captures the causal nature of arrow effects, and identify its associated law. To study this class of computations in more detail, we define an extension to arrows called causal commutative arrows (CCA), and study its properties. Our key contribution is the identification of a normal form for CCA called causal commutative normal form (CCNF). By defining a normalization procedure, we have developed an optimization strategy that yields dramatic improvements in performance over conventional implementations of arrows. We have implemented this technique in Haskell, and conducted benchmarks that validate the effectiveness of our approach. When compiled with the Glasgow Haskell Compiler (GHC), the overall methodology can result in significant speedups. 1