Results 1  10
of
64
Arrows, Robots, and Functional Reactive Programming
 Advanced Functional Programming, 4th International School, volume 2638 of LNCS
, 2002
"... Functional reactive programming, or FRP, is a paradigm for programming hybrid systems  i.e., systems containing a combination of both continuous and discrete components  in a highlevel, declarative way. The key ideas in FRP are its notions of continuous, timevarying values, and timeordere ..."
Abstract

Cited by 68 (11 self)
 Add to MetaCart
(Show Context)
Functional reactive programming, or FRP, is a paradigm for programming hybrid systems  i.e., systems containing a combination of both continuous and discrete components  in a highlevel, declarative way. The key ideas in FRP are its notions of continuous, timevarying values, and timeordered sequences of discrete events.
Encoding information flow in Haskell
 In CSFW’06: the 19th IEEE Computer Security Foundations Workshop
, 2006
"... This paper presents an embedded security sublanguage for enforcing informationflow policies in the standard Haskell programming language. The sublanguage provides useful informationflow control mechanisms including dynamic security lattices, runtime code privileges and declassification, without m ..."
Abstract

Cited by 45 (4 self)
 Add to MetaCart
(Show Context)
This paper presents an embedded security sublanguage for enforcing informationflow policies in the standard Haskell programming language. The sublanguage provides useful informationflow control mechanisms including dynamic security lattices, runtime code privileges and declassification, without modifying the base language. This design avoids the redundant work of producing new languages, lowers the threshold for adopting securitytyped languages, and also provides great flexibility and modularity for using securitypolicy frameworks. The embedded security sublanguage is designed using a standard combinator interface called arrows. Computations constructed in the sublanguage have static and explicit controlflow components, making it possible to implement informationflow control using staticanalysis techniques at run time, while providing strong security guarantees. This paper presents a concrete Haskell implementation and an example application demonstrating the proposed techniques. 1.
Procera: A Language for HighLevel Reactive Network Control
"... Our previous experience building systems for implementing network policies in home and enterprise networks has revealed that the intuitive notion of network policy in these domains is inherently dynamic and stateful. Current configuration languages, both in traditional network architectures and in O ..."
Abstract

Cited by 38 (5 self)
 Add to MetaCart
(Show Context)
Our previous experience building systems for implementing network policies in home and enterprise networks has revealed that the intuitive notion of network policy in these domains is inherently dynamic and stateful. Current configuration languages, both in traditional network architectures and in OpenFlow systems, are not expressive enough to capture these policies. As a result, most prototype OpenFlow systems lack a configurable interface and instead require operators to program in the system implementation language, often C++. We describe Procera, a control architecture for softwaredefined networking (SDN) that includes a declarative policy language based on the notion of functional reactive programming; we extend this formalism with both signals relevant for expressing highlevel network policies in a variety of network settings, including home and enterprise networks, and a collection of constructs expressing temporal queries over event streams that occur frequently in network policies. Although sophisticated users can take advantage of Procera’s full expressiveness by expressing network policies directly in Procera, simpler configuration interfaces (e.g., graphical user interfaces) can also easily be built on top of this formalism.
Structuring quantum effects: superoperators as arrows
 Math. Struct. Comput. Sci
, 2006
"... ..."
(Show Context)
The essence of dataflow programming
 In APLAS
, 2005
"... Abstract. We propose a novel, comonadic approach to dataflow (streambased) computation. This is based on the observation that both general and causal stream functions can be characterized as coKleisli arrows of comonads and on the intuition that comonads in general must be a good means to structure ..."
Abstract

Cited by 23 (3 self)
 Add to MetaCart
(Show Context)
Abstract. We propose a novel, comonadic approach to dataflow (streambased) computation. This is based on the observation that both general and causal stream functions can be characterized as coKleisli arrows of comonads and on the intuition that comonads in general must be a good means to structure contextdependent computation. In particular, we develop a generic comonadic interpreter of languages for contextdependent computation and instantiate it for streambased computation. We also discuss distributive laws of a comonad over a monad as a means to structure combinations of effectful and contextdependent computation. We apply the latter to analyse clocked dataflow (partial stream based) computation. 1
The arrow calculus
, 2008
"... Abstract. We introduce the arrow calculus, a metalanguage for manipulating Hughes’s arrows with close relations both to Moggi’s metalanguage for monads and to Paterson’s arrow notation. Arrows are classically defined by extending lambda calculus with three constructs satisfying nine (somewhat idiosy ..."
Abstract

Cited by 20 (5 self)
 Add to MetaCart
(Show Context)
Abstract. We introduce the arrow calculus, a metalanguage for manipulating Hughes’s arrows with close relations both to Moggi’s metalanguage for monads and to Paterson’s arrow notation. Arrows are classically defined by extending lambda calculus with three constructs satisfying nine (somewhat idiosyncratic) laws. In contrast, the arrow calculus adds four constructs satisfying five laws. Two of the constructs are arrow abstraction and application (satisfying beta and eta laws) and two correspond to unit and bind for monads (satisfying left unit, right unit, and associativity laws). The five laws were previously known to be sound; we show that they are also complete, and hence that the five laws may replace the nine. We give a translation from classic arrows into the arrow calculus to complement Paterson’s desugaring and show that the two translations form an equational correspondence in the sense of Sabry and Felleisen. We are also the first to publish formal type rules (which are unusual in that they require two contexts), which greatly aided our understanding of arrows. The first fruit of our new calculus is to reveal some redundancies in the classic formulation: the nine classic arrow laws can be reduced to eight, and the three additional classic arrow laws for arrows with apply can be reduced to two. The calculus has also been used to clarify the relationship between idioms, arrows and monads and as the inspiration for a categorical semantics of arrows. 1
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 18 (1 self)
 Add to MetaCart
(Show Context)
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.
Safe Functional Reactive Programming through Dependent Types
"... 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 ..."
Abstract

Cited by 18 (0 self)
 Add to MetaCart
(Show Context)
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 reactive constructs. Statically guaranteeing correctness 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 checks that guarantee domainspecific properties, such as feedback loops always being wellformed. However, they are limited in their capabilities to support dynamism and higherorder dataflow compared with FRP. Thus, the onus of ensuring such properties of FRP programs has so far been on the programmer as established static techniques do not suffice. In this paper, we show how dependent types allow this concern to be addressed. We present an implementation of FRP embedded in the dependentlytyped language Agda, leveraging the type system of the host language to craft a domainspecific (dependent) type system for FRP. The implementation constitutes a discrete, operational semantics of FRP, and as it passes the Agda type, coverage, and termination checks, we know the operational semantics is total, which means our type system is safe. Categories and Subject Descriptors D.3.2 [Programming Languages]: Language Classifications—applicative (functional) languages, dataflow languages, specialized application languages General Terms Languages Keywords dependent types, domainspecific languages, DSELs, FRP, functional programming, reactive programming, synchronous dataflow
Arrows for Secure Information Flow
"... This paper presents an embedded security sublanguage for enforcing informationflow policies in the standard Haskell programming language. The sublanguage provides useful informationflow control mechanisms including dynamic security lattices, runtime code privileges and declassification all without ..."
Abstract

Cited by 17 (0 self)
 Add to MetaCart
This paper presents an embedded security sublanguage for enforcing informationflow policies in the standard Haskell programming language. The sublanguage provides useful informationflow control mechanisms including dynamic security lattices, runtime code privileges and declassification all without modifying the base language. This design avoids the redundant work of producing new languages, lowers the threshold for adopting securitytyped languages, and also provides great flexibility and modularity for using securitypolicy frameworks. The embedded security sublanguage is designed using a standard combinator interface called arrows. Computations constructed in the sublanguage have static and explicit controlflow components, making it possible to implement informationflow control using staticanalysis techniques at run time, while providing strong security guarantees. This paper presents a formal proof that our embedded sublanguage provides noninterference, a concrete Haskell implementation and an example application demonstrating the proposed techniques. 1
A Recursive do for Haskell
, 2002
"... Certain programs making use of monads need to perform recursion over the values of monadic actions. Although the donotation of Haskell provides a convenient framework for monadic programming, it lacks the generality to support such recursive bindings. In this paper, we describe an enhanced translat ..."
Abstract

Cited by 17 (1 self)
 Add to MetaCart
Certain programs making use of monads need to perform recursion over the values of monadic actions. Although the donotation of Haskell provides a convenient framework for monadic programming, it lacks the generality to support such recursive bindings. In this paper, we describe an enhanced translation schema for the donotation and its integration into Haskell. The new translation allows variables to be bound recursively, provided the underlying monad comes equipped with an appropriate fixedpoint operator.