Lazy Assertions

@inproceedings{Chitil2003LazyA,
  title={Lazy Assertions},
  author={Olaf Chitil and Daniel William Peter McNeill and Colin Runciman},
  booktitle={IFL},
  year={2003}
}
Assertions test expected properties of run-time values without disrupting the normal working of a program. So in a lazy functional language assertions should be lazy – not forcing evaluation, but only examining what is evaluated by other parts of the program. We explore the subtle semantics of lazy assertions and describe sequential and concurrent variants of a method for checking lazy assertions. All variants are implemented in Haskell. 
A Pattern Logic for Prompt Lazy Assertions . In :
TLDR
A library for enriching programs in the lazy language Haskell with assertions, which test expected properties of run-time values without disrupting the normal computation of a program.
A Pattern Logic for Prompt Lazy Assertions in Haskell
TLDR
A library for enriching programs in the lazy language Haskell with assertions, which test expected properties of run-time values without disrupting the normal computation of a program.
Monadic, Prompt Lazy Assertions in Haskell
TLDR
This work presents a library for enriching Haskell programs with assertions, which test expected properties of run-time values without disrupting the normal computation of a program.
True Lies: Lazy Contracts for Lazy Languages
TLDR
This paper discusses three approaches to contract monitoring for lazy programming languages, eager, semi-eager, and lazy monitoring, all of which are flawed and may change program behavior.
Lazy and Enforceable Assertions for Functional Logic Programs
TLDR
This work proposes enforceable assertions that are delayed as lazy assertions but can be explicitly enforced at some point where faith is required, e.g., at the end of the program execution or before irrevocable I/O actions.
Lazy and Faithful Assertions for Functional Logic Programs
TLDR
This paper proposes an intermediate approach where the user can choose between lazy or faithful assertions and proposes to delay them until an explicit point where faith is required, e.g., at the end of the program execution or before I/O actions.
Static contract checking for Haskell
  • Na Xu
  • Computer Science
    POPL '09
  • 2009
TLDR
A sound and automatic static verification framework for Haskell, that is based on contracts and symbolic execution, that gives precise blame assignments at compile-time in the presence of higher-order functions and laziness is described.
A semantics for lazy assertions
TLDR
The first denotational semantics for lazy assertions is developed, which defines a weak disjunction combinator and together with a conjunction combinator assertions form a bounded distributive lattice.
Practical typed lazy contracts
TLDR
This paper presents the design and implementation of a small, easy-to-use, purely functional contract library for Haskell, which, when a contract is violated, also provides more useful information than the classical blaming of one contract partner.
A Transformation Tool for Functional Logic Program Development ?
TLDR
A tool to develop functional logic programs from their specifications that can either instrument ordinary programs with run-time assertions obtained from declarative contracts or transform declaratives contracts into prototypical implementations.
...
...

References

SHOWING 1-10 OF 13 REFERENCES
Applicative Assertions
TLDR
It turns out that this can be achieved wholly within the language itself, so one has the full power of the language in formulating the assertions, hence decreasing problems with expressiveness.
Testing and Tracing Lazy Functional Programs Using QuickCheck and Hat
TLDR
It is a very undesirable situation that today’s software often contains errors; even the most advanced functional programmers are not infallible; they misunderstand the properties of their own programs, or those of others, and so commit errors.
Debugging Haskell by Observing Intermediate Data Structures
  • Andy Gill
  • Computer Science
    Electron. Notes Theor. Comput. Sci.
  • 2000
QuickCheck: a lightweight tool for random testing of Haskell programs
TLDR
Quick Check is a tool which aids the Haskell programmer in formulating and testing properties of programs, and can be automatically tested on random input, but it is also possible to define custom test data generators.
Tackling the Awkward Squad: monadic input/output, concurrency, exceptions, and foreign-language calls in Haskell
TLDR
Various proposed extensions to Haskell are introduced along the way, and an operational semantics that explains what these extensions mean are offered, and a few errors corrected are corrected.
Stretching the Storage Manager: Weak Pointers and Stable Names in Haskell
TLDR
Every now and then, a user of the Glasgow Haskell Compiler asks for a feature that requires specialised support from the storage manager, and here are some examples.
Multiple-View Tracing for Haskell: a New Hat
TLDR
This work presents the design of a trace that can serve several views, which is generated and written to file as the computation proceeds.
Engineering Theories of Software Construction
TLDR
This text examines the software engineering techniques used for industrial tasks through mathematical foundations of software engineering and engineering methods in their theoretical substance in the step towards practical applications.
XQuery: A Typed Functional Language for Querying XML
  • P. Wadler
  • Computer Science, Art
    Advanced Functional Programming
  • 2002
XQuery is a typed, functional language for querying XML, currently being designed by the XML Query Working Group of the World-Wide Web Consortium. Here are examples of XQuery queries on a suitable
...
...