Results 1  10
of
73
Stream Fusion. From Lists to Streams to Nothing at All
 ICFP’07
, 2007
"... This paper presents an automatic deforestation system, stream fusion, based on equational transformations, that fuses a wider range of functions than existing shortcut fusion systems. In particular, stream fusion is able to fuse zips, left folds and functions over nested lists, including list compr ..."
Abstract

Cited by 67 (8 self)
 Add to MetaCart
This paper presents an automatic deforestation system, stream fusion, based on equational transformations, that fuses a wider range of functions than existing shortcut fusion systems. In particular, stream fusion is able to fuse zips, left folds and functions over nested lists, including list comprehensions. A distinguishing feature of the framework is its simplicity: by transforming list functions to expose their structure, intermediate values are eliminated by general purpose compiler optimisations. We have reimplemented the Haskell standard List library on top of our framework, providing stream fusion for Haskell lists. By allowing a wider range of functions to fuse, we see an increase in the number of occurrences of fusion in typical Haskell programs. We present benchmarks documenting time and space improvements.
Certification of termination proofs using CeTA
 In Proc. TPHOLs’09, LNCS 5674
, 2009
"... Abstract. There are many automatic tools to prove termination of term rewrite systems, nowadays. Most of these tools use a combination of many complex termination criteria. Hence generated proofs may be of tremendous size, which makes it very tedious (if not impossible) for humans to check those pro ..."
Abstract

Cited by 46 (30 self)
 Add to MetaCart
(Show Context)
Abstract. There are many automatic tools to prove termination of term rewrite systems, nowadays. Most of these tools use a combination of many complex termination criteria. Hence generated proofs may be of tremendous size, which makes it very tedious (if not impossible) for humans to check those proofs for correctness. In this paper we use the theorem prover Isabelle/HOL to automatically certify termination proofs. To this end, we first formalized the required theory of term rewriting including three major termination criteria: dependency pairs, dependency graphs, and reduction pairs. Second, for each of these techniques we developed an executable check which guarantees the correct application of that technique as it occurs in the generated proofs. Moreover, if a proof is not accepted, a readable error message is displayed. Finally, we used Isabelle’s code generation facilities to generate a highly efficient and certified Haskell program, CeTA, which can be used to certify termination proofs without even having Isabelle installed. 1
Nettle: Functional Reactive Programming for OpenFlow Networks
, 2010
"... We describe a languagecentric approach to solving the complex, lowlevel, and errorprone nature of network control. Specifically, we have designed a domainspecific language called Nettle, embeddedinHaskell, thatallowsprogrammingOpenFlow networksinanelegant, declarative style. Nettle is designed i ..."
Abstract

Cited by 26 (0 self)
 Add to MetaCart
(Show Context)
We describe a languagecentric approach to solving the complex, lowlevel, and errorprone nature of network control. Specifically, we have designed a domainspecific language called Nettle, embeddedinHaskell, thatallowsprogrammingOpenFlow networksinanelegant, declarative style. Nettle is designed in layers to accommodate a family of DSLs targeted for specific network applications. The primary core of Nettle is based on the principles of functional reactive programming (FRP). Aside from its useful signal abstraction, FRP facilitates the integration of components written in different higherlevel DSLs. We demonstrate our methodology by writing several nontrivial OpenFlow controllers. 1 1
Generative Type Abstraction and Typelevel Computation (Extended Version)
"... Modular languages support generative type abstraction, ensuring that an abstract type is distinct from its representation, except inside the implementation where the two are synonymous. We show that this wellestablished feature is in tension with the nonparametric features of newer type systems, s ..."
Abstract

Cited by 23 (14 self)
 Add to MetaCart
Modular languages support generative type abstraction, ensuring that an abstract type is distinct from its representation, except inside the implementation where the two are synonymous. We show that this wellestablished feature is in tension with the nonparametric features of newer type systems, such as indexed type families and GADTs. In this paper we solve the problem by using kinds to distinguish between parametric and nonparametric contexts. The result is directly applicable to Haskell, which is rapidly developing support for typelevel computation, but the same issues should arise whenever generativity and nonparametric features are combined.
Modular Type Classes
"... ML modules and Haskell type classes have proven to be highly effective tools for program structuring. Modules emphasize explicit configuration of program components and the use of data abstraction. Type classes emphasize implicit program construction and ad hoc polymorphism. In this paper, we show h ..."
Abstract

Cited by 21 (8 self)
 Add to MetaCart
ML modules and Haskell type classes have proven to be highly effective tools for program structuring. Modules emphasize explicit configuration of program components and the use of data abstraction. Type classes emphasize implicit program construction and ad hoc polymorphism. In this paper, we show how the implicitlytyped style of type class programming may be supported within the framework of an explicitlytyped module language by viewing type classes as a particular mode of use of modules. This view offers a harmonious integration of modules and type classes, where type class features, such as class hierarchies and associated types, arise naturally as uses of existing modulelanguage constructs, such as module hierarchies and type components. In addition, programmers have explicit control over which type class instances are available for use by type inference in a given scope. We formalize our approach as a HarperStonestyle elaboration relation, and provide a sound type inference algorithm as a guide to implementation.
Specifying strategies for exercises
 SUZUKI & F. WIEDIJK, EDS, ‘AISC/CALCULEMUS/MKM 2008’, LNAI 5144, SPRINGERVERLAG
, 2008
"... The feedback given by elearning tools that support incrementally solving problems in mathematics, logic, physics, etc. is limited, or laborious to specify. In this paper we introduce a language for specifying strategies for solving exercises. This language makes it easier to automatically calculat ..."
Abstract

Cited by 17 (12 self)
 Add to MetaCart
The feedback given by elearning tools that support incrementally solving problems in mathematics, logic, physics, etc. is limited, or laborious to specify. In this paper we introduce a language for specifying strategies for solving exercises. This language makes it easier to automatically calculate feedback when users make erroneous steps in a calculation. Although we need the power of a full programming language to specify strategies, we carefully distinguish between contextfree and noncontextfree sublanguages of our strategy language. This separation is the key to automatically calculating all kinds of desirable feedback.
Observing Functional Logic Computations
 In Proc. of the Sixth International Symposium on Practical Aspects of Declarative Languages (PADL’04
, 2004
"... Abstract. A lightweight approach to debugging functional logic programs by observations is presented, implemented for the language Curry. The Curry Object Observation System (COOSy) comprises a portable library plus a viewing tool. A programmer can observe data structures and functions by annotating ..."
Abstract

Cited by 13 (11 self)
 Add to MetaCart
(Show Context)
Abstract. A lightweight approach to debugging functional logic programs by observations is presented, implemented for the language Curry. The Curry Object Observation System (COOSy) comprises a portable library plus a viewing tool. A programmer can observe data structures and functions by annotating expressions in his program. The possibly partial values of observed expressions that are computed during program execution are recorded in a trace file, including information on nondeterministic choices and logical variables. A separate viewing tool displays the trace content. COOSy covers all aspects of modern functional logic multiparadigm languages such as lazy evaluation, higher order functions, nondeterministic search, logical variables, concurrency and constraints. Both use and implementation of COOSy are described. 1
Functional programming with structured graphs
 In Proceedings of the 17th ACM SIGPLAN international conference on Functional programming, ICFP ’12
, 2012
"... This paper presents a new functional programming model for graph structures called structured graphs. Structured graphs extend conventional algebraic datatypes with explicit definition and manipulation of cycles and/or sharing, and offer a practical and convenient way to program graphs in functional ..."
Abstract

Cited by 12 (1 self)
 Add to MetaCart
(Show Context)
This paper presents a new functional programming model for graph structures called structured graphs. Structured graphs extend conventional algebraic datatypes with explicit definition and manipulation of cycles and/or sharing, and offer a practical and convenient way to program graphs in functional programming languages like Haskell. The representation of sharing and cycles (edges) employs recursive binders and uses an encoding inspired by parametric higherorder abstract syntax. Unlike traditional approaches based on mutable references or node/edge lists, wellformedness of the graph structure is ensured statically and reasoning can be done with standard functional programming techniques. Since the binding structure is generic, we can define many useful generic combinators for manipulating structured graphs. We give applications and show how to reason about structured graphs.
Specifying Rewrite Strategies for Interactive Exercises
"... Abstract. Strategies specify how a wide range of exercises can be solved incrementally, such as bringing a logic proposition to disjunctive normal form, reducing a matrix, or calculating with fractions. In this paper we introduce a language for specifying strategies for solving exercises. This langu ..."
Abstract

Cited by 11 (11 self)
 Add to MetaCart
(Show Context)
Abstract. Strategies specify how a wide range of exercises can be solved incrementally, such as bringing a logic proposition to disjunctive normal form, reducing a matrix, or calculating with fractions. In this paper we introduce a language for specifying strategies for solving exercises. This language makes it easier to automatically calculate feedback, for example when a user makes an erroneous step in a calculation. We can automatically generate workedout examples, track the progress of a student by inspecting submitted intermediate answers, and report back suggestions in case the student deviates from the strategy. Thus it becomes less laborintensive and less adhoc to specify new exercise domains and exercises within that domain. A strategy describes valid sequences of rewrite rules, which turns tracking intermediate steps into a parsing problem. This is a promising view at interactive exercises because it allows us to take advantage of many years of experience in parsing sentences of contextfree languages, and transfer this knowledge and technology to the domain of stepwise solving exercises. In this paper we work out the similarities between parsing and solving exercises incrementally, we discuss generating feedback on strategies, and the implementation of a strategy recognizer.