Abstract interpretation of declarative languages
Abstract interpretation of declarative languages
The system f of variable types, 15 years later
Logical foundations of functional programming
Compiling with continuations
Unboxed objects and polymorphic typing
POPL '92 Proceedings of the 19th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
An efficient implementation of multiple return values in Scheme
LFP '94 Proceedings of the 1994 ACM conference on LISP and functional programming
Flexible representation analysis
ICFP '97 Proceedings of the second ACM SIGPLAN international conference on Functional programming
ICFP '98 Proceedings of the third ACM SIGPLAN international conference on Functional programming
A transformation-based optimiser for Haskell
Science of Computer Programming - Special issue on the 6th European symposium on programming
A semantics for imprecise exceptions
Proceedings of the ACM SIGPLAN 1999 conference on Programming language design and implementation
Revised Report on the Algorithmic Language Scheme
Higher-Order and Symbolic Computation
Unboxed Values as First Class Citizens in a Non-Strict Functional Language
Proceedings of the 5th ACM Conference on Functional Programming Languages and Computer Architecture
The nofib Benchmark Suite of Haskell Programs
Proceedings of the 1992 Glasgow Workshop on Functional Programming
Non-determinism Analysis in a Parallel-Functional Language
IFL '00 Selected Papers from the 12th International Workshop on Implementation of Functional Languages
Proceedings of the 2nd ACM SIGPLAN symposium on Haskell
Harmonizing classes, functions, tuples, and type parameters in virgil iii
Proceedings of the 34th ACM SIGPLAN conference on Programming language design and implementation
| Hi-index | 0.00 |
Compilers for ML and Haskell typically go to a good deal of trouble to arrange that multiple arguments can be passed efficiently to a procedure. For some reason, less effort seems to be invested in ensuring that multiple results can also be returned efficiently. In the context of the lazy functional language Haskell, we describe an analysis, Constructed Product Result (CPR) analysis, that determines when a function can profitably return multiple results in registers. The analysis is based only on a function's definition, and not on its uses (so separate compilation is easily supported) and the results of the analysis can be expressed by a transformation of the function definition alone. We discuss a variety of design issues that were addressed in our implementation, and give measurements of the effectiveness of our approach across a substantial benchmark set. Overall, the price/performance ratio is good: the benefits are modest in general (though occasionally dramatic), but the costs in both complexity and compile time, are low.