Filters








93 Hits in 1.6 sec

Compiling ER Specifications into Declarative Programs [article]

Bernd Braßel, Michael Hanus, Marion Muller
2007 arXiv   pre-print
This paper proposes an environment to support high-level database programming in a declarative programming language. In order to ensure safe database updates, all access and update operations related to the database are generated from high-level descriptions in the entity- relationship (ER) model. We propose a representation of ER diagrams in the declarative language Curry so that they can be constructed by various tools and then translated into this representation. Furthermore, we have
more » ... ted a compiler from this representation into a Curry program that provides access and update operations based on a high-level API for database programming.
arXiv:0711.0348v1 fatcat:ci5jzljdprfedpsstivbbw6ao4

Implementing Equational Constraints in a Functional Language [article]

Bernd Braßel, Michael Hanus, Björn Peemöller, Fabian Reck
2011 arXiv   pre-print
KiCS2 is a new system to compile functional logic programs of the source language Curry into purely functional Haskell programs. The implementation is based on the idea to represent the search space as a data structure and logic variables as operations that generate their values. This has the advantage that one can apply various, and in particular, complete search strategies to compute solutions. However, the generation of all values for logic variables might be inefficient for applications
more » ... exploit constraints on partially known values. To overcome this drawback, we propose new techniques to implement equational constraints in this framework. In particular, we show how unification modulo function evaluation and functional patterns can be added without sacrificing the efficiency of the kernel implementation.
arXiv:1108.5609v1 fatcat:j5nee5yj5vfgdlt4llrdn76od4

The Kiel Curry System KiCS [chapter]

Bernd Braßel, Frank Huch
2009 Lecture Notes in Computer Science  
This paper presents the Kiel Curry System (KiCS) for the lazy functional logic language Curry. Its main features beyond other Curry implementations are: flexible search control by means of search trees, referentially transparent encapsulation and sharing across nondeterminism.
doi:10.1007/978-3-642-00675-3_13 fatcat:p2sqqptpjrcqroe4xg3aevilcm

Declaring Numbers

Bernd Braßel, Sebastian Fischer, Frank Huch
2008 Electronical Notes in Theoretical Computer Science  
Most implementations of functional and functional logic languages treat numbers and the basic numeric operations as external entities. The main reason for this is efficiency. However, this basic design decision has many unfortunate consequences for all programs using numbers. We present an approach to model numbers in a declarative way and argue that the loss in efficiency is compensated by the newly gained possibilities. Functional logic languages benefit the most from this proposal because
more » ... the numeric operations become fully narrowable. This enables the solving of simple equations on numbers in an efficient way without having to resort to external constraint solvers. The presented approach can either be used as a library for purely declarative numbers or it can be employed as a basic data type of functional (logic) languages. Indeed, we have integrated the presented data structures as the only numbers available in our compiler for the functional logic language Curry.
doi:10.1016/j.entcs.2008.06.037 fatcat:ytmdrmq36bdofewgkyp7mvhywe

Nondeterminism Analysis of Functional Logic Programs [chapter]

Bernd Braßel, Michael Hanus
2005 Lecture Notes in Computer Science  
Information about the nondeterminism behavior of a functional logic program is important for various reasons. For instance, a nondeterministic choice in I/O operations results in a run-time error. Thus, it is desirable to ensure at compile time that a given program is not going to crash in this way. Furthermore, knowledge about nondeterminism can be exploited to optimize programs. In particular, if functional logic programs are compiled to target languages without builtin support for
more » ... istic computations, the transformation can be much simpler if it is known that the source program is deterministic. In this paper we present a nondeterminism analysis of functional logic programs in form of a type/effect system. We present a type inferencer to approximate the nondeterminism behavior via nonstandard types and show its correctness w.r.t. the operational semantics of functional logic programs. The type inference is based on a new compact representation of sets of types and effects.
doi:10.1007/11562931_21 fatcat:sou72p5d2nf4hceh63ysujudne

Observing Functional Logic Computations [chapter]

Bernd Braßel, Olaf Chitil, Michael Hanus, Frank Huch
2004 Lecture Notes in Computer Science  
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 non-deterministic choices and
more » ... ogical 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, non-deterministic search, logical variables, concurrency and constraints. Both use and implementation of COOSy are described.
doi:10.1007/978-3-540-24836-1_14 fatcat:y5o7rafdovhnrcgd27xbdh4w6e

Lazy call-by-value evaluation

Bernd Braßel, Michael Hanus, Sebastian Fischer, Frank Huch, Germán Vidal
2007 SIGPLAN notices  
(Braßel et al. 2007 ).  ...  (Braßel et al. 2007 ). In the examples, we use lets with multiple bindings.  ... 
doi:10.1145/1291220.1291193 fatcat:i5vdjsyvv5fx7ljbcps2zm5rre

Implementing Equational Constraints in a Functional Language [chapter]

Bernd Braßel, Michael Hanus, Björn Peemöller, Fabian Reck
2013 Lecture Notes in Computer Science  
KiCS2 is a new system to compile functional logic programs of the source language Curry into purely functional Haskell programs. The implementation is based on the idea to represent the search space as a data structure and logic variables as operations that generate their values. This has the advantage that one can apply various, and in particular, complete search strategies to compute solutions. However, the generation of all values for logic variables might be inefficient for applications
more » ... exploit constraints on partially known values. To overcome this drawback, we propose new techniques to implement equational constraints in this framework. In particular, we show how unification modulo function evaluation and functional patterns can be added without sacrificing the efficiency of the kernel implementation.
doi:10.1007/978-3-642-45284-0_9 fatcat:jrt5kqbabbd2jdhimbzqyii264

Transforming Functional Logic Programs into Monadic Functional Programs [chapter]

Bernd Braßel, Sebastian Fischer, Michael Hanus, Fabian Reck
2011 Lecture Notes in Computer Science  
We present a high-level transformation scheme to translate lazy functional logic programs into pure Haskell programs. This transformation is based on a recent proposal to efficiently implement lazy non-deterministic computations in Haskell in a monadic style. We build on this work and define a systematic method to transform lazy functional logic programs into monadic programs with explicit sharing. This results in a transformation scheme which produces high-level and flexible target code. For
more » ... stance, the target code is parametric w.r.t. the concrete evaluation monad. Thus, different monad instances could, for example, define different search strategies (e.g., depth-first, breadth-first, parallel). We formally describe the basic compilation scheme and some useful extensions.
doi:10.1007/978-3-642-20775-4_2 fatcat:uukd3gt2yffpzitmhlm2mhp2v4

KiCS2: A New Compiler from Curry to Haskell [chapter]

Bernd Braßel, Michael Hanus, Björn Peemöller, Fabian Reck
2011 Lecture Notes in Computer Science  
Furthermore, Braßel [11] showed the semantical equivalence of narrowing computations in LOIS systems and rewriting computations in uniform programs.  ... 
doi:10.1007/978-3-642-22531-4_1 fatcat:cyitk3hjnncoddwrcobjih2a7q

A Framework for Interpreting Traces of Functional Logic Computations

Bernd Braßel
2007 Electronical Notes in Theoretical Computer Science  
This paper is part of a comprehensive approach to debugging for functional logic languages. The basic idea of the whole project is to trace the execution of functional logic programs by side effects and then give different views on the recorded data. In this way well known debugging techniques like declarative debugging, expression observation, redex trailing but also step-by-step debuggers and cost center oriented symbolic profiling can be implemented as special views on the recorded data. In
more » ... ddition, creating new views for special debugging purposes should be easy to implement. This is where the contribution of this work sets in. We describe how the recorded data is interpreted and preprocessed in order to yield an extremely simple yet versatile interface to base the different views on. Using this interface, formulating the basic functionality of declarative debugging, for example, is a matter of a few lines.
doi:10.1016/j.entcs.2007.01.006 fatcat:6g7k6snunbfblkgdq54c5dvuuq

From Functional Logic Programs to Purely Functional Programs Preserving Laziness [chapter]

Bernd Braßel, Sebastian Fischer
2011 Lecture Notes in Computer Science  
Functional logic languages extend the setting of functional programming by non-deterministic choices, free variables and narrowing. Most existing approaches to simulate logic features in functional languages do not preserve laziness, i.e., they can only model strict logic programming like in Prolog. Lazy functional logic programming however, has interesting properties supporting a more declarative style of programming search without sacrificing efficiency. We will present a recently developed
more » ... chnique to reduce all logic extensions to the single problem of generating unique identifiers. The impact of this reduction is a general scheme for compiling functional logic programs to lazy functional programs without side effects. One of the design goals is that the purely functional parts of a program should not suffer from significant run-time overhead. Preliminary experiments confirm our hope for significant improvements of run-time performance even for non-deterministic programs but suggest further work to improve the memory requirements of those.
doi:10.1007/978-3-642-24452-0_2 fatcat:puky3uofxjfxrfxjdigrxwylgq

A Technique to Build Debugging Tools for Lazy Functional Logic Languages

Bernd Braßel
2009 Electronical Notes in Theoretical Computer Science  
This paper is based on a recently developed technique to build debugging tools for lazy functional programming languages. With this technique it is possible to replay the execution of a lazy program with a strict semantics by recording information of unevaluated expressions. The recorded information is called an oracle and is very compact. Oracles contain the number of strict steps between discarding unevaluated expressions. The technique has already been successfully employed to construct a
more » ... ugger for lazy functional languages. This paper extends the technique to include also lazy functional logic languages. A debugging tool built with the technique can be downloaded at www-ps.informatik.uni-kiel.de/~bbr.
doi:10.1016/j.entcs.2009.07.014 fatcat:zqdfs4c37rb5djpcairhlnpwhy

Computing with subspaces

Sergio Antoy, Bernd Braßel
2007 Proceedings of the 9th ACM SIGPLAN international conference on Principles and practice of declarative programming - PPDP '07  
We propose a new definition and use of a primitive getAllValues, for computing all the values of a non-deterministic expression in a functional logic program. Our proposal restricts the validity of the argument of getAllValues. This restriction ensures that essential language features like the call-time choice semantics, the independence of the order of evaluation, and the referential transparency of the language are preserved when getAllValues is executed. Up to now, conflicts between these
more » ... guage features and primitives like getAllValues have been seen as one of the main problems for employing such primitives in functional logic languages.
doi:10.1145/1273920.1273936 dblp:conf/ppdp/AntoyB07 fatcat:qinqnuafgvgnlmjokn66oodhay

Lazy call-by-value evaluation

Bernd Braßel, Michael Hanus, Sebastian Fischer, Frank Huch, Germán Vidal
2007 Proceedings of the 2007 ACM SIGPLAN international conference on Functional programming - ICFP '07  
(Braßel et al. 2007 ).  ...  (Braßel et al. 2007 ). In the examples, we use lets with multiple bindings.  ... 
doi:10.1145/1291151.1291193 dblp:conf/icfp/BrasselHFHV07 fatcat:7ce6eaf55zel5ni2nsy7ovtlvy
« Previous Showing results 1 — 15 out of 93 results