Why dependent types matter

McKinna, James

doi:10.1145/1111037.1111038

Cited by 20 publications

(7 citation statements)

References 43 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…With the use of indexed (co-)datatypes [8,29], dependently typed programming [18,22] has been successful in offering 'intrinsic' guarantees about basic properties whose proofs closely follow program structures and can be implicitly embedded into programs. Typical examples include keeping indices within bounds [11], representing wellscoped and well-typed syntax trees of embedded languages [2], and tracking the available effects/resources used in programs [6].…”

Section: Interactive Type-driven Developmentmentioning

confidence: 99%

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

Ko¹

2020

Programming

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

Section: Interactive Type-driven Developmentmentioning

confidence: 99%

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

Ko¹

2020

Programming

View full text Add to dashboard Cite

show abstract

“…We see this paper as an intermediary and necessary step towards dependent types for which we first needed to understand the potential and limitations of a non-dependently typed pure functional approach in Haskell. Dependent types are extremely promising in functional programming as they allow us to express stronger guarantees about the correctness of programs and go as far as allowing to formulate programs and types as constructive proofs which must be total by definition [2,29,46]. So far no research using dependent types in agent-based simulation exists at all.…”

Section: Further Researchmentioning

confidence: 99%

Pure Functional Epidemics

Thaler

Altenkirch

Siebers

2018

Proceedings of the 30th Symposium on Implementation and Application of Functional Languages

View full text Add to dashboard Cite

Agent-Based Simulation (ABS) is a methodology in which a system is simulated in a bottom-up approach by modelling the micro interactions of its constituting parts, called agents, out of which the global system behaviour emerges. So far mainly object-oriented techniques and languages have been used in ABS. Using the SIR model of epidemiology, which simulates the spreading of an infectious disease through a population, we demonstrate how to use pure Functional Reactive Programming to implement ABS. With our approach we can guarantee the reproducibility of the simulation at compile time and rule out specific classes of run-time bugs, something that is not possible with traditional object-oriented languages. Also, we found that the representation in a purely functional format is conceptually quite elegant and opens the way to formally reason about ABS.

show abstract

“…In the case of nonterminating computations, one will in general get an infinite trace; to account for that case, one needs a coalgebraic rather than an algebraic reading of the tracing datatype. Perhaps this can all be conveniently captured in a 'strong functional programming' [48] or constructive type theory [33] setting, carefully distinguishing between terminating functions from algebraic datatypes and productive functions to coalgebraic codatatypes (in which case the constructions are technically no longer 'free' monads), or perhaps it really requires a shift from SET to CPO.…”

Section: Beyond Finite Supportmentioning

confidence: 99%

Unifying Theories of Programming with Monads

Gibbons

2013

Unifying Theories of Programming

View full text Add to dashboard Cite

Abstract. The combination of probabilistic and nondeterministic choice in program calculi is a notoriously tricky problem, and one with a long history. We present a simple functional programming approach to this challenge, based on algebraic theories of computational effects. We make use of the powerful abstraction facilities of modern functional languages, to introduce the choice operations as a little embedded domain-specific language rather than having to define a language extension; we rely on referential transparency, to justify straightforward equational reasoning about program behaviour.

show abstract

Why dependent types matter

Cited by 20 publications

References 43 publications

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

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

Pure Functional Epidemics

Unifying Theories of Programming with Monads

Contact Info

Product

Resources

About