Peter Thiemann - Academia.edu (original) (raw)

Papers by Peter Thiemann

BMJ, 1968

Parallel or incremental versions of an algorithm can significantly outperform their counterparts,... more Parallel or incremental versions of an algorithm can significantly outperform their counterparts, but are often difficult to develop. Programming models that provide appropriate abstractions to decompose data and tasks can simplify parallelization. We show in this work that the same abstractions can enable both parallel and incremental execution.

Proceedings of the second international symposium on Parallel symbolic computation - PASCO '97, 1997

ACM Transactions on Programming Languages and Systems, 2000

The combination of modern programming languages and partial evaluation yields new approaches to o... more The combination of modern programming languages and partial evaluation yields new approaches to old problems. In particular, the combination of functional programming and partial evaluation can turn a general parser into a parser generator. We use an inherently functional approach to implement general LR(k) parsers and specialize them with respect to the input grammars using offline partial evaluation. The functional specification of LR parsing yields a concise implementation of the algorithms themselves. Furthermore, we demonstrate the elegance of the functional approach by incorporating on-the-fly attribute evaluation for S-attributed grammars and two schemes for error recovery, which lend themselves to natural and elegant implementation. The parsers require only minor changes to achieve good specialization results. The generated parsers have production quality and match those produced by traditional parser generators in speed and compactness.

Proceedings of the 1996 ACM symposium on Applied Computing - SAC '96, 1996

Partial evaluation can automatically generate program transformers from interpreters. In the cont... more Partial evaluation can automatically generate program transformers from interpreters. In the context of functional languages, we investigate the design space of higher-order interpreters to achieve certain transformation effects. Our work is based on the interpretive approach and exploits the language preservation property of offline partial evaluators.

ACM SIGPLAN Notices, 1996

Two key steps in the compilation of strict functional languages are the conversion of higher-orde... more Two key steps in the compilation of strict functional languages are the conversion of higher-order functions to data structures (closures) and the transformation to tail-recursive style. We show how to perform both steps at once by applying first-order offline partial evaluation to a suitable interpreter. The resulting code is easy to transliterate to low-level C or native code. We have implemented the compilation to C; it yields a performance comparable to that of other modern Scheme-to-C compilers. In addition, we have integrated various optimizations such as constant propagation, higherorder removal, and arity raising simply by modifying the underlying interpreter. Purely first-order methods suffice to achieve the transformations. Our approach is an instance of semantics-directed compiler generation.

Lecture Notes in Computer Science, 1996

Polyvariant expansion is a binding-time-improving transformation for o ine partial evaluation.

SIGPLAN Notices (ACM Special Interest Group on Programming Languages), 1997

One of the agship applications of partial evaluation is compilation and compiler generation. Howe... more One of the agship applications of partial evaluation is compilation and compiler generation. However, partial evaluation is usually expressed as a source-to-source transformation for high-level languages, whereas realistic compilers produce object code.

ACM SIGPLAN Notices, 2002

Functional logic overloading is a novel approach to user-defined overloading that extends Haskell... more Functional logic overloading is a novel approach to user-defined overloading that extends Haskell&#x27;s concept of type classes in significant ways. Whereas type classes are conceptually predicates on types in standard Haskell, they are in our approach. Thus, we can base type inference on the evaluation of functional logic programs. Functional logic programming provides a solid theoretical foundation for type functions

Proceedings of the 1995 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation - PEPM '95, 1995

Partial evaluation can turn a general parser into a parser generator. The generated parsers surpa... more Partial evaluation can turn a general parser into a parser generator. The generated parsers surpass those produced by traditional parser generators in speed and compactness. We use an inherently functional approach to implement general LR(k) parsers and specialize them using the partial evaluator Similix. The functional implementation of LR parsing allows for concise implementation of the algorithms themselves and requires only straightforward changes to achieve good specialization results. In contrast, a traditional, stack-based implementation of a general LR parser requires significant structural changes to make it amenable to satisfactory specialization.

Informatik aktuell, 1997

We have implemented a program generation library for polymorphically typed functional languages w... more We have implemented a program generation library for polymorphically typed functional languages with lazy evaluation. The library combinators perform program generation by partial evaluation, a technique which allows the generation of highly-customized and efficient specialized output programs from general, parameterized input programs. Previously implemented program generation libraries for polymorphically typed languages have either required dynamic typing or been in the context of specially designed program generation languages. In contrast, our library has been implemented in Gofer, a widely available functional language. Moreover, we exploit multi-parameter constructor classes which are part of Gofer's type system to construct program generators that are bindingtime polymorphic. An appropriate polymorphic binding-time analysis can provide the necessary type annotations to specify these properties. However, we designed and implemented a minor extension of Gofer's type reconstruction mechanism that can automatically infer binding times.

... The secretarial staff at DIKU and especially TOPPS group secretaries Karin Outzen and Karina ... more ... The secretarial staff at DIKU and especially TOPPS group secretaries Karin Outzen and Karina S0nderholm labored behind the scenes and provided assis-tance on the myriad of administrative tasks that come with preparing for such an event. ... Carsten K. Gomard. ...

Higher-Order and Symbolic Computation (formerly LISP and Symbolic Computation), 2000

Object-based languages,with dynamic,type systems are popular because they accelerate the developm... more Object-based languages,with dynamic,type systems are popular because they accelerate the development,of short programs. As larger programs are built with those languages, static analyses become,important tools for detecting programming,errors. We define such an analysis as a type system for an imperative object-based calculus and prove its type soundness. The calculus models essential features of the JavaScript language, as an example

A session type is an abstraction of a sequence of heteroge- neous values sent over one communicat... more A session type is an abstraction of a sequence of heteroge- neous values sent over one communication channel. Session types can be used for specifying stream-based Internet protocols. We consider session types in a setting with asynchronous communication over buffered channels. Due to buffering, a process may write ahead before the reading process picks up the data. Thus the types

Functional dependencies help resolve many of the ambiguities that result from the use of multi-pa... more Functional dependencies help resolve many of the ambiguities that result from the use of multi-parameter type classes. They eectively enable writing programs at the type-level which significantly enhances the expressive power of Haskell's type sys- tem. Among the applications of this technique are the emulation of dependent types, and precise typechecking for XML and HTML combinator libraries. Unfortunately, the notation

Lecture Notes in Computer Science, 2014

Lecture Notes in Computer Science, 2010

Binding-time polymorphism enables a highly flexible bindingtime analysis for offline partial eval... more Binding-time polymorphism enables a highly flexible bindingtime analysis for offline partial evaluation. This work provides the tools to translate this flexibility into efficient program specialization in the context of a polymorphic language. Following the cogen-combinator approach, a set of combinators is defined in Haskell that enables the straightforward transcription of a bindingtime polymorphic annotated program into the corresponding program generator. The typing of the combinators mimics the constraints of the binding-time analysis. The resulting program generator is safe, tag-free, and it has no interpretive overhead.

Electronic Notes in Theoretical Computer Science, 2000

The region calculus of Tofte and Talpin is an annotated polymorphically typed lambda calculus whi... more The region calculus of Tofte and Talpin is an annotated polymorphically typed lambda calculus which makes memory allocation and deallocation explicit. It is intended as an intermediate language in a compiler for ML-like languages. The region annotations are obtained by static region and eect inference, which makes it an attractive alternative for garbage collection. Soundness of the region and eect