Programming with ornaments

Ko, Hsiang−Shang; Gibbons, Jeremy

doi:10.1017/s0956796816000307

Cited by 11 publications

(6 citation statements)

References 22 publications

(48 reference statements)

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Using ornaments (Dagand, 2013; McBride, 2010 (unpublished)), we might be able to give a generic account of this construction. In particular, the work by Ko & Gibbons (2016) on binomial heaps would be a valuable starting point for such exploration.…”

Section: Discussionmentioning

confidence: 99%

Heterogeneous binary random-access lists

Swierstra¹

2020

J. Funct. Prog.

View full text Add to dashboard Cite

Section: Discussionmentioning

confidence: 99%

Heterogeneous binary random-access lists

Swierstra¹

2020

J. Funct. Prog.

View full text Add to dashboard Cite

“…But this kind of guarantee is also achievable 'extrinsically' with proof assistants, where proofs are written explicitly and separately from programs -we know how to prove theorems saying that indices are always within bounds or that a program transformation always produces well-typed programs, and it is not hard to prove these theorems formally, especially with proof assistants that have decent automation [3,24]. What distinguishes dependently typed programming from other methodologies is that it makes the idea of interactive type-driven development much more powerful: the more properties we encode intrinsically into types, the more hints the type-checker can offer the programmer during an interactive development process, so that the more heavyweight typing becomes an aid rather than a burden [14,19,20].…”

Section: Interactive Type-driven Developmentmentioning

confidence: 99%

“…As illustrated in figure 6(a), placing a row is equivalent to transforming an input list as into a new one as and also a vertical edge b. We therefore introduce the following function fill IH for filling a row: 14 fill IH : {s :…”

Section: Horizontal Placementmentioning

confidence: 99%

Programming Metamorphic Algorithms: An Experiment in Type-Driven Algorithm Design

Ko¹

2020

Programming

Self Cite

View full text Add to dashboard Cite

In dependently typed programming, proofs of basic, structural properties can be embedded implicitly into programs and do not need to be written explicitly. Besides saving the effort of writing separate proofs, a most distinguishing and fascinating aspect of dependently typed programming is that it makes the idea of interactive type-driven development much more powerful, where expressive type information becomes useful hints that help the programmer to complete a program. There have not been many attempts at exploiting the full potential of the idea, though. As a departure from the usual properties dealt with in dependently typed programming, and as a demonstration that the idea of interactive type-driven development has more potential to be discovered, we conduct an experiment in 'type-driven algorithm design': we develop algorithms from their specifications encoded in sophisticated types, to see how useful the hints provided by a type-aware interactive development environment can be. The algorithmic problem we choose is metamorphisms, whose definitional behaviour is consuming a data structure to compute an intermediate value and then producing a codata structure from that value, but there are other ways to compute metamorphisms. We develop Gibbons's streaming algorithm and Nakano's jigsaw model in the interactive development environment provided by the dependently typed language Agda, turning intuitive ideas about these algorithms into formal conditions and programs that are correct by construction.

show abstract

“…Lifting functions and proofs necessitates some additional automation beyond the addition of ornaments to a language. So far, ornaments exist in various forms as deep embeddings in Agda (Dagand, 2017;Williams et al, 2014;Ko and Gibbons, 2016), and as tooling for proof reuse (Section 6.4.3) in Coq.…”

Section: Proof Organization and Scalabilitymentioning

confidence: 99%

QED at Large: A Survey of Engineering of Formally Verified Software

Ringer

Palmskog

Sergey

et al. 2019

FNT in Programming Languages

View full text Add to dashboard Cite

Development of formal proofs of correctness of programs can increase actual and perceived reliability and facilitate better understanding of program specifications and their underlying assumptions. Tools supporting such development have been available for over 40 years, but have only recently seen wide practical use. Projects based on construction of machine-checked formal proofs are now reaching an unprecedented scale, comparable to large software projects, which leads to new challenges in proof development and maintenance. Despite its increasing importance, the field of proof engineering is seldom considered in its own right; related theories, techniques, and tools span many fields and venues. This survey of the literature presents a holistic understanding of proof engineering for program correctness, covering impact in practice, foundations, proof automation, proof organization, and practical proof development.

show abstract

Programming with ornaments

Cited by 11 publications

References 22 publications

Heterogeneous binary random-access lists

Heterogeneous binary random-access lists

Programming Metamorphic Algorithms: An Experiment in Type-Driven Algorithm Design

QED at Large: A Survey of Engineering of Formally Verified Software

Contact Info

Product

Resources

About