A semantics for imprecise exceptions

Authors:
Simon Peyton Jones;Alastair Reid;Fergus Henderson;Tony Hoare;Simon Marlow
Affiliations:
Microsoft Research Ltd., Cambridge;Yale University;The University of Melbourne;Cambridge University Computer Laboratory;Microsoft Research Ltd., Cambridge
Venue:
Proceedings of the ACM SIGPLAN 1999 conference on Programming language design and implementation
Year:
1999

Citing 6
Cited 36

Run-time scheduling and execution of loops on message passing machines

Journal of Parallel and Distributed Computing - Special issue: algorithms for hypercube computers
The high performance Fortran handbook

The high performance Fortran handbook
A parallel hashed Oct-Tree N-body algorithm

Proceedings of the 1993 ACM/IEEE conference on Supercomputing
The SPLASH-2 programs: characterization and methodological considerations

ISCA '95 Proceedings of the 22nd annual international symposium on Computer architecture
Implementing O(N) N-body algorithms efficiently in data-parallel languages

Scientific Programming
High performance Fortran for highly irregular problems

PPOPP '97 Proceedings of the sixth ACM SIGPLAN symposium on Principles and practice of parallel programming

Exploring the Interaction between Java's Implicitly Thrown Exceptions and Instruction Scheduling

International Journal of Parallel Programming
Asynchronous exceptions in Haskell

Proceedings of the ACM SIGPLAN 2001 conference on Programming language design and implementation
Exception analysis for non-strict languages

Proceedings of the seventh ACM SIGPLAN international conference on Functional programming
Interactive visual functional programming

Proceedings of the seventh ACM SIGPLAN international conference on Functional programming
The marriage of effects and monads

ACM Transactions on Computational Logic (TOCL)
Putting the Spine Back in the Spineless Tagless G-Machine: An Implementation of Resumable Black-Holes

IFL '98 Selected Papers from the 10th International Workshop on 10th International Workshop
Practical aspects of declarative debugging in Haskell 98

Proceedings of the 5th ACM SIGPLAN international conference on Principles and practice of declaritive programming
Optimistic evaluation: an adaptive evaluation strategy for non-strict programs

ICFP '03 Proceedings of the eighth ACM SIGPLAN international conference on Functional programming
Constructed product result analysis for Haskell

Journal of Functional Programming
Developing a high-performance web server in Concurrent Haskell

Journal of Functional Programming
Exceptional syntax

Journal of Functional Programming
Dynamic applications from the ground up

Proceedings of the 2005 ACM SIGPLAN workshop on Haskell
Combining the robustness of checked exceptions with the flexibility of unchecked exceptions using anchored exception declarations

OOPSLA '05 Proceedings of the 20th annual ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
EDO: Exception-directed optimization in java

ACM Transactions on Programming Languages and Systems (TOPLAS)
Dynamic state restoration using versioning exceptions

Higher-Order and Symbolic Computation
An extensible dynamically-typed hierarchy of exceptions

Proceedings of the 2006 ACM SIGPLAN workshop on Haskell
A history of Haskell: being lazy with class

Proceedings of the third ACM SIGPLAN conference on History of programming languages
Dually nondeterministic functions

ACM Transactions on Programming Languages and Systems (TOPLAS)
Implicitly-threaded parallelism in Manticore

Proceedings of the 13th ACM SIGPLAN international conference on Functional programming
Smallcheck and lazy smallcheck: automatic exhaustive testing for small values

Proceedings of the first ACM SIGPLAN symposium on Haskell
A System F with Call-by-Name Exceptions

ICALP '08 Proceedings of the 35th international colloquium on Automata, Languages and Programming, Part II
Asynchronous Exceptions as an Effect

MPC '08 Proceedings of the 9th international conference on Mathematics of Program Construction
Translation and optimization for a core calculus with exceptions

Proceedings of the 2009 ACM SIGPLAN workshop on Partial evaluation and program manipulation
A family of syntactic logical relations for the semantics of Haskell-like languages

Information and Computation
Transactional events1

Journal of Functional Programming
How to CPS Transform a Monad

CC '09 Proceedings of the 18th International Conference on Compiler Construction: Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2009
Parametricity for Haskell with Imprecise Error Semantics

TLCA '09 Proceedings of the 9th International Conference on Typed Lambda Calculi and Applications
Programming in Manticore, a heterogenous parallel functional language

CEFP'09 Proceedings of the Third summer school conference on Central European functional programming school
Implicitly threaded parallelism in manticore

Journal of Functional Programming
Declarative scripting in haskell

SLE'09 Proceedings of the Second international conference on Software Language Engineering
Purely functional lazy nondeterministic programming

Journal of Functional Programming - Dedicated to ICFP 2009
A functional shell that dynamically combines compiled code

IFL'03 Proceedings of the 15th international conference on Implementation of Functional Languages
A functional shell that operates on typed and compiled applications

AFP'04 Proceedings of the 5th international conference on Advanced Functional Programming
Practical typed lazy contracts

Proceedings of the 17th ACM SIGPLAN international conference on Functional programming
The Intel labs Haskell research compiler

Proceedings of the 2013 ACM SIGPLAN symposium on Haskell
A semantics for weakly encapsulated search in functional logic programs

Proceedings of the 15th Symposium on Principles and Practice of Declarative Programming

Quantified Score

Hi-index	0.00

Visualization

Abstract

Some modern superscalar microprocessors provide only imprecise exceptions. That is, they do not guarantee to report the same exception that would be encountered by a straightforward sequential execution of the program. In exchange, they offer increased performance or decreased chip area (which amount to much the same thing).This performance/precision tradeoff has not so far been much explored at the programming language level. In this paper we propose a design for imprecise exceptions in the lazy functional programming language Haskell. We discuss several designs, and conclude that imprecision is essential if the language is still to enjoy its current rich algebra of transformations. We sketch a precise semantics for the language extended with exceptions.The paper shows how to extend Haskell with exceptions without crippling the language or its compilers. We do not yet have enough experience of using the new mechanism to know whether it strikes an appropriate balance between expressiveness and performance.