Abstract not found

This thesis describes techniques for transforming and analysing functional programs. We operate on a core language, to which Haskell programs can be reduced. We present a range of techniques, all of which have been implemented and evaluated. We make programs shorter by defining a library which abstracts over common data traversal patterns, removing boilerplate code. This library only supports traversals having value-specific behaviour for one type, allowing a simpler programming model. Our library allows concise expression of traversals with competitive performance. We make programs faster by applying a variant of supercompilation. As a result of practical experiments, we have identified modifications to the standard supercompilation techniques – particularly with respect to let bindings and the generalisation technique. We make programs safer by automatically checking for potential patternmatch errors. We define a transformation that takes a higher-order program

We propose an extension to list comprehensions that makes it easy to express the kind of queries one would write in SQL using ORDER BY, GROUP BY, and LIMIT. Our extension adds expressive power to comprehensions, and generalises the SQL constructs that inspired it. Moreover, it is easy to implement, using simple desugaring rules. 1.

Lists are ubiquitous in functional programming. The list constructor forms an instance of a monad capturing non-deterministic computations. Despite its popularity the list monad suffers from serious drawbacks: It relies in an essential way on lazy evaluation, it is inefficient, and it is not modular. We develop an alternative based on continuations, which remedies these shortcomings. Essential use is made of constructor classes and second-order types, which sets the work apart from other approaches. Continuation-based backtracking monads behave amazingly well in practice: If an optimizing compiler is used, their performance is commensurate to that of logic languages. The class mechanism greatly eases the task of adding features to the basic machinery. We study three extensions in detail: control

Recent excitement in the database community surrounding new applications—analytic, scientific, graph, geospatial, etc.—has led to an explosion in research on database storage systems. New storage systems are vital to the database community, as they are at the heart of making database systems perform well in new application domains. Unfortunately, each such system also represents a substantial engineering effort including a great deal of duplication of mechanisms for features such as transactions and caching. In this paper, we make the case for RodentStore, an adaptive and declarative storage system providing a high-level interface for describing the physical representation of data. Specifically, RodentStore uses a declarative storage algebra whereby administrators (or database design tools) specify how a logical schema should be grouped into collections of rows, columns, and/or arrays, and the order in which those groups should be laid out on disk. We describe the key operators and types of our algebra, outline the general architecture of RodentStore, which interprets algebraic expressions to generate a physical representation of the data, and describe the interface between RodentStore and other parts of a database system, such as the query optimizer and executor. We provide a case study of the potential use of RodentStore in representing dense geospatial data collected from a mobile sensor network, showing the ease with which different storage layouts can be expressed using some of our algebraic constructs and the potential performance gains that a RodentStore-built storage system can offer.

Abstract: There is a trend in programming language design toward adopting the same query and concurrency management mechanisms that have proven successful for databases, in the form of integrated query languages and transactional memory [HG06]. We focus on the demands placed on Object/Relational Mapping (ORM) in order to support comprehension queries, as known from LINQ and Scala. The additional expressive power enables the application of optimization techniques originating in the field of databases (query unnesting, ordering final instead of intermediate results, etc). As an interim step toward the proposed query integration, we describe a translator from a functional query language (comparable to LINQ) into JPQL, the query language of ORM engines following the JPA standard (JSR-317). A summary of related and ongoing work and an outlook of future work conclude this position paper. 1

plugins can handle nested languages:

Abstract. Relational database management systems (RDBMSs) provide the best understood and most carefully engineered query processing infrastructure available today. However, RDBMSs are often operated as plain stores that do little more than reproduce stored data items for further processing outside the database host, in the general-purpose programming language heap. One reason for this is that the aforementioned query processing capabilities require mastering of advanced features of query languages (e.g., SQL) in addition to the general-purpose language the application is programmed in. Moreover, the query languages are often inadequately integrated into the host programming language. One way to solve these problems is to use RDBMSs as a coprocessor for general-purpose programming languages, for those program parts that carry out data-intensive and data-parallel computations. In this paper we present a library for database-supported program execution in Haskell. Data-intensive and data-parallel computations are expressed using familiar combinators from the standard list prelude and expressive list comprehension notation. The library, in addition to queries of basic types, supports computations over arbitrarily nested tuples and lists. The implementation minimises unnecessary data transfer and context switching between the database coprocessor and the programming language run-time by ensuring that the least possible number of queries is generated when executing the library functions. Although Haskell has inspired a number of language-integrated query facilities (most notably LINQ in Microsoft’s.NET framework), as far as we know this is the first proposal and implementation of database-supported program execution facility for Haskell. 1

Abstract. Relational database management systems can be used as a coprocessor for general-purpose programming languages, especially for those program fragments that carry out data-intensive and data-parallel computations. In this paper we present a Haskell library for databasesupported program execution. Data-intensive and data-parallel computations are expressed using familiar combinators from the standard list prelude and are entirely executed on the database coprocessor. Programming with the expressive list comprehension notation is also supported. The library, in addition to queries of basic types, supports computations over arbitrarily nested tuples and lists. The implementation avoids unnecessary data transfer and context switching between the database coprocessor and the programming language runtime by ensuring that the number of generated relational queries is only determined by the program fragment’s type and not by the database size. 1

This thesis describes the implementation of a FERRY-based query backend for the LINKS programming language. In LINKS, queries are seamlessly embedded into the language: Queries formulated in a subset of the language are translated into single SQL queries. LINKS uses static checks to ensure that a type-correct query expression can be translated into an equivalent SQL query and allows abstraction over parts of a query. The queryizable subset of LINKS is, however, severely limited in terms of supported functions and the data type (limited to bags of flat records) of queries. The thesis begins with a description of the query facility and criticizes the limited functionality of the queryizable LINKS subset. The FERRY framework deals with the compilation of pure, declarative languages based on list comprehensions into SQL queries. It provides features that LINKS queries are lacking: query results involving nested lists and computed by a small, statically bounded number of SQL queries, ordered lists semantics and a larger number of supported functions. The thesis first reviews the compilation technique of the FERRY framework and adapts it to the specifics of LINKS. The queryizable subset of LINKS is higher-order and allows to treat functions as first-class values. To keep this property in the new query backend, the