I got plenty o’ nuttin’

Research output: Chapter in Book/Report/Conference proceedingConference contribution book

8 Citations (Scopus)

Abstract

Work to date on combining linear types and dependent types has deliberately and successfully avoided doing so. Entirely fit for their own purposes, such systems wisely insist that types depend only on the replicable sublanguage, thus sidestepping the issue of counting uses of limited-use data either within types or in ways which are only really needed to shut the typechecker up. As a result, the linear implication ('lollipop') stubbornly remains a non-dependent ST. This paper defines and establishes the basic metatheory of a type theory supporting a 'dependent lollipop' (x:S) ⊸ T[x], where what the input used to be is in some way commemorated by the type of the output. For example, we might convert list to length-indexed vectors in place by a function with type (l: List X) ⊸ Vector X (length l). Usage is tracked with resource annotations belonging to an arbitrary rig, or 'riNg without Negation'. The key insight is to use the rig's zero to mark information in contexts which is present for purposes of contemplation rather than consumption, like a meal we remember fondly but cannot eat twice. We need no runtime copies of l to form the above vector type. We can have plenty of nothing with no additional runtime resource, and nothing is plenty for the construction of dependent types.

LanguageEnglish
Title of host publicationA List of Successes That Can Change the World
Subtitle of host publicationEssays Dedicated to Philip Wadler on the Occasion of His 60th Birthday
EditorsSam Lindley, Conor McBride, Phil Trinder, Don Sannella
Place of PublicationSwitzerland
PublisherSpringer
Pages207-233
Number of pages27
ISBN (Print)9783319309354
DOIs
Publication statusPublished - 25 Mar 2016

Publication series

NameLecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)
Volume9600
ISSN (Print)0302-9743

Fingerprint

Dependent
Resources
Type Theory
Convert
Annotation
Counting
Ring
Output
Zero
Arbitrary
Context

Keywords

  • computer science
  • computers
  • dependent types
  • in contexts
  • linear implications
  • linear types
  • meta-theory
  • runtimes
  • type theory
  • artificial intelligence

Cite this

McBride, C. (2016). I got plenty o’ nuttin’. In S. Lindley, C. McBride, P. Trinder, & D. Sannella (Eds.), A List of Successes That Can Change the World: Essays Dedicated to Philip Wadler on the Occasion of His 60th Birthday (pp. 207-233). (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics); Vol. 9600). Switzerland: Springer. https://doi.org/10.1007/978-3-319-30936-1_12
McBride, Conor. / I got plenty o’ nuttin’. A List of Successes That Can Change the World: Essays Dedicated to Philip Wadler on the Occasion of His 60th Birthday. editor / Sam Lindley ; Conor McBride ; Phil Trinder ; Don Sannella. Switzerland : Springer, 2016. pp. 207-233 (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)).
@inproceedings{778094c3a4764dd39e0e475dca67db9d,
title = "I got plenty o’ nuttin’",
abstract = "Work to date on combining linear types and dependent types has deliberately and successfully avoided doing so. Entirely fit for their own purposes, such systems wisely insist that types depend only on the replicable sublanguage, thus sidestepping the issue of counting uses of limited-use data either within types or in ways which are only really needed to shut the typechecker up. As a result, the linear implication ('lollipop') stubbornly remains a non-dependent S ⊸ T. This paper defines and establishes the basic metatheory of a type theory supporting a 'dependent lollipop' (x:S) ⊸ T[x], where what the input used to be is in some way commemorated by the type of the output. For example, we might convert list to length-indexed vectors in place by a function with type (l: List X) ⊸ Vector X (length l). Usage is tracked with resource annotations belonging to an arbitrary rig, or 'riNg without Negation'. The key insight is to use the rig's zero to mark information in contexts which is present for purposes of contemplation rather than consumption, like a meal we remember fondly but cannot eat twice. We need no runtime copies of l to form the above vector type. We can have plenty of nothing with no additional runtime resource, and nothing is plenty for the construction of dependent types.",
keywords = "computer science, computers, dependent types, in contexts, linear implications, linear types, meta-theory, runtimes, type theory, artificial intelligence",
author = "Conor McBride",
year = "2016",
month = "3",
day = "25",
doi = "10.1007/978-3-319-30936-1_12",
language = "English",
isbn = "9783319309354",
series = "Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)",
publisher = "Springer",
pages = "207--233",
editor = "Sam Lindley and Conor McBride and Phil Trinder and Don Sannella",
booktitle = "A List of Successes That Can Change the World",

}

McBride, C 2016, I got plenty o’ nuttin’. in S Lindley, C McBride, P Trinder & D Sannella (eds), A List of Successes That Can Change the World: Essays Dedicated to Philip Wadler on the Occasion of His 60th Birthday. Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics), vol. 9600, Springer, Switzerland, pp. 207-233. https://doi.org/10.1007/978-3-319-30936-1_12

I got plenty o’ nuttin’. / McBride, Conor.

A List of Successes That Can Change the World: Essays Dedicated to Philip Wadler on the Occasion of His 60th Birthday. ed. / Sam Lindley; Conor McBride; Phil Trinder; Don Sannella. Switzerland : Springer, 2016. p. 207-233 (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics); Vol. 9600).

Research output: Chapter in Book/Report/Conference proceedingConference contribution book

TY - GEN

T1 - I got plenty o’ nuttin’

AU - McBride, Conor

PY - 2016/3/25

Y1 - 2016/3/25

N2 - Work to date on combining linear types and dependent types has deliberately and successfully avoided doing so. Entirely fit for their own purposes, such systems wisely insist that types depend only on the replicable sublanguage, thus sidestepping the issue of counting uses of limited-use data either within types or in ways which are only really needed to shut the typechecker up. As a result, the linear implication ('lollipop') stubbornly remains a non-dependent S ⊸ T. This paper defines and establishes the basic metatheory of a type theory supporting a 'dependent lollipop' (x:S) ⊸ T[x], where what the input used to be is in some way commemorated by the type of the output. For example, we might convert list to length-indexed vectors in place by a function with type (l: List X) ⊸ Vector X (length l). Usage is tracked with resource annotations belonging to an arbitrary rig, or 'riNg without Negation'. The key insight is to use the rig's zero to mark information in contexts which is present for purposes of contemplation rather than consumption, like a meal we remember fondly but cannot eat twice. We need no runtime copies of l to form the above vector type. We can have plenty of nothing with no additional runtime resource, and nothing is plenty for the construction of dependent types.

AB - Work to date on combining linear types and dependent types has deliberately and successfully avoided doing so. Entirely fit for their own purposes, such systems wisely insist that types depend only on the replicable sublanguage, thus sidestepping the issue of counting uses of limited-use data either within types or in ways which are only really needed to shut the typechecker up. As a result, the linear implication ('lollipop') stubbornly remains a non-dependent S ⊸ T. This paper defines and establishes the basic metatheory of a type theory supporting a 'dependent lollipop' (x:S) ⊸ T[x], where what the input used to be is in some way commemorated by the type of the output. For example, we might convert list to length-indexed vectors in place by a function with type (l: List X) ⊸ Vector X (length l). Usage is tracked with resource annotations belonging to an arbitrary rig, or 'riNg without Negation'. The key insight is to use the rig's zero to mark information in contexts which is present for purposes of contemplation rather than consumption, like a meal we remember fondly but cannot eat twice. We need no runtime copies of l to form the above vector type. We can have plenty of nothing with no additional runtime resource, and nothing is plenty for the construction of dependent types.

KW - computer science

KW - computers

KW - dependent types

KW - in contexts

KW - linear implications

KW - linear types

KW - meta-theory

KW - runtimes

KW - type theory

KW - artificial intelligence

UR - http://www.scopus.com/inward/record.url?scp=84973863163&partnerID=8YFLogxK

UR - http://dx.doi.org/10.1007/978-3-319-30936-1

U2 - 10.1007/978-3-319-30936-1_12

DO - 10.1007/978-3-319-30936-1_12

M3 - Conference contribution book

SN - 9783319309354

T3 - Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)

SP - 207

EP - 233

BT - A List of Successes That Can Change the World

A2 - Lindley, Sam

A2 - McBride, Conor

A2 - Trinder, Phil

A2 - Sannella, Don

PB - Springer

CY - Switzerland

ER -

McBride C. I got plenty o’ nuttin’. In Lindley S, McBride C, Trinder P, Sannella D, editors, A List of Successes That Can Change the World: Essays Dedicated to Philip Wadler on the Occasion of His 60th Birthday. Switzerland: Springer. 2016. p. 207-233. (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)). https://doi.org/10.1007/978-3-319-30936-1_12