Syntax of Object Comprehensions Es ::= E j E , Es E ::= E union E j E differ E j [ Xs --- E ] j E and E j E or E j not E j E hasClass E j E hasClass E with E j Y E ! Y E j E / E j E . E j I( Es ) j I j K j f Es g j f E : : : E g j E . [ E ] j A E j ( E ) Xs ::= j X j X ; Xs X ::= D j L j E D ::= I / E L ::= I as E Y ::= j some j atleast E j just E j atmost E j every A ::= size ::= set j bag j list ! ::= = j = j ? j ?= j ! j != j == j == / ::= * j / j + j - B Abstract Syntax of Function Arguments F ::= I . E j F ffi F Es ::= E j E, Es E ::= E . E j I( Es ) j E ff E j E ! E j E / E j I j K j ( E ) j Q ff ::= j j : ! ::= = j = j ? j ?= j ! j != / ::= * j / j + j - 22 References ...

This paper is concerned with the transparent parallelisation of declarative database queries, based on theoretical principles. We have designed an entire database architecture suitable for use on any generalpurpose parallel machine. This architecture addresses the shortcomings in flexibility and scalability of commercial parallel databases. A substantial benefit is that the mathematical principles underlying our framework allow provably correct parallel evaluations and optimisations, using compile-time transformations. We address parallelism in a language-independent way through the choice of monoids as a formulation for expressing and modelling queries. Queries expressed in our declarative language are transformed into applications of a higher--order function, the monoid homomorphism. The evaluation of this function is partitioned at run-time, giving a tree-like processor topology, the depth and breadth of which can be varied with a declarative execution plan. Leaf nodes within the ev...

This paper presents the results of a simulation study of cache coherency issues in parallel implementations of functional programming languages. Parallel graph reduction uses a heap shared between processors for all synchronisation and communication. We show that a high degree of spatial locality is often present and that the rate of synchronisation is much greater than for imperative programs. We propose a modified coherency protocol with static cache line ownership and show that this allows locality to be exploited to at least the level of a conventional protocol, but without the unnecessary serialisation and network transactions this usually causes. The new protocol avoids false sharing, and makes it possible to reduce the number of messages exchanged, but relies on increasing the size of the cache lines exchanged to do so. It is therefore of most benefit with a high-bandwidth interconnection network with relatively high communication latencies or message handling overhead...

The integration of database and programming languages is difficult due to the different data models and type systems prevalent in each field. We present a solution where the developer may express queries encompassing program and database data. The notation used for queries is based on comprehensions, a declarative style that does not impose any specific execution strategy. In our approach, the type safety of language-integrated queries is analyzed at compile-time, followed by a translation that optimizes for database evaluation. We show the translation total and semantics preserving, and introduce a language-independent classification. According to this classification, our approach compares favorably with Microsoft’s LINQ, today’s best known representative. We provide an implementation in terms of Scala compiler plugins, accepting two notations for queries: LINQ and the native Scala syntax for comprehensions. The prototype relies on Ferry, a query language that already supports comprehensions yet targets SQL:1999. The reported techniques pave the way for further progress in bridging the programming and the database worlds. 1

ing out and studying those patterns of computation as useful objects in their own right leads to further insights into the nature of computation. The list operators studied later in these notes follow this approach. ffl Functional programs are usually an order of magnitude more concise than their imperative counterparts. Besides being shorter, they can be much more readable. The functional community like to cite studies that show the number of bugs per line is more or less constant, independent of the level of the language in use. Higher-level languages encode more concept per line, and therefore have relatively fewer bugs. ffl Functional programs are often more akin to formal specifications than their conventional counterparts. A good notation goes a long way towards solving the problem[47]. ffl Lazy evaluation permits a new approach to some algorithms. It is a simple but powerful idea that can remove the need for explicit backtracking, and can allow the programmer to manipulate in...

The extension of programming languages with database query capabilities is called language-integrated query. This is a desirable goal in connection with two recent developments (from the programming and the database communities): (a) the functional-object paradigm; and (b) enhanced expressiveness and conciseness of functional query languages. In addition, the extensible compiler architectures for modern programming languages along with the advanced optimization techniques for functional query languages bring new perspectives to persistent programming languages. The main results of the present master project work are contributions that fall under the larger ScalaQL project. The ScalaQL project proposes a translation algorithm from two source languages, LINQ and Scala, to SQL:1999 queries with the Ferry query language as an intermediate language. The underlying translations are required to be total and semantics preserving. The master work contributes to (a) providing the syntactic and semantic foundation for the second translation (from Scala into Ferry); (b) covering the relevant aspects of both the Scala and Ferry type systems; and (c) establishing the required isomorphism of types between the supported Scala subset and Ferry. Finally, the proposed approach has been implemented as a Scala compiler plugin that allows compile-time processing of LINQ queries and preparing well-formed SQL:1999 queries amenable to relational DBMS evaluation. Declaration I declare that: this work has been prepared by myself, all literal or content based quotations are clearly pointed out, and no other sources or aids than the declared ones have been used.