Dependent type providers

Authors:
David Raymond Christiansen
Affiliations:
IT University of Copenhagen, Copenhagen, Denmark
Venue:
Proceedings of the 9th ACM SIGPLAN workshop on Generic programming
Year:
2013

Citing 9
Cited 0

A new approach to generic functional programming

Proceedings of the 27th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Generic Programming within Dependently Typed Programming

Proceedings of the IFIP TC2/WG2.1 Working Conference on Generic Programming
The view from the left

Journal of Functional Programming
Universes for generic programs and proofs in dependent type theory

Nordic Journal of Computing
Freebase: a collaboratively created graph database for structuring human knowledge

Proceedings of the 2008 ACM SIGMOD international conference on Management of data
The power of Pi

Proceedings of the 13th ACM SIGPLAN international conference on Functional programming
Z3: an efficient SMT solver

TACAS'08/ETAPS'08 Proceedings of the Theory and practice of software, 14th international conference on Tools and algorithms for the construction and analysis of systems
Ur: statically-typed metaprogramming with type-level record computation

PLDI '10 Proceedings of the 2010 ACM SIGPLAN conference on Programming language design and implementation
IDRIS ---: systems programming meets full dependent types

Proceedings of the 5th ACM workshop on Programming languages meets program verification

Quantified Score

Hi-index	0.00

Visualization

Abstract

Type providers, pioneered in the F# programming language, are a practical and powerful means of gaining the benefits of a modern static type system when working with data schemas that are defined outside of the programming language, such as relational databases. F# type providers are implemented using a form of compile-time code generation, which requires the compiler to expose an internal API and can undermine type safety. We show that with dependent types it is possible to define a type provider mechanism that does not rely on code generation. Using this mechanism, a type provider becomes a kind of generic program that is instantiated for a particular external schema, which can be represented using an ordinary datatype. Because these dependent type providers use the ordinary abstraction mechanisms of the type system, they preserve its safety properties. We evaluate the practicality of this technique and explore future extensions.