164 research outputs found
Type Classes for Lightweight Substructural Types
Linear and substructural types are powerful tools, but adding them to
standard functional programming languages often means introducing extra
annotations and typing machinery. We propose a lightweight substructural type
system design that recasts the structural rules of weakening and contraction as
type classes; we demonstrate this design in a prototype language, Clamp.
Clamp supports polymorphic substructural types as well as an expressive
system of mutable references. At the same time, it adds little additional
overhead to a standard Damas-Hindley-Milner type system enriched with type
classes. We have established type safety for the core model and implemented a
type checker with type inference in Haskell.Comment: In Proceedings LINEARITY 2014, arXiv:1502.0441
Linear/non-Linear Types For Embedded Domain-Specific Languages
Domain-specific languages are often embedded inside of general-purpose host languages so that the embedded language can take advantage of host-language data structures, libraries, and tools. However, when the domain-specific language uses linear types, existing techniques for embedded languages fall short. Linear type systems, which have applications in a wide variety of programming domains including mutable state, I/O, concurrency, and quantum computing, can manipulate embedded non-linear data via the linear type !σ. However, prior work has not been able to produce linear embedded languages that have full and easy access to host-language data, libraries, and tools.
This dissertation proposes a new perspective on linear, embedded, domain-specific languages derived from the linear/non-linear (LNL) interpretation of linear logic. The LNL model consists of two distinct fragments---one with linear types and another with non-linear types---and provides a simple categorical interface between the two. This dissertation identifies the linear fragment with the linear embedded language and the non-linear fragment with the general-purpose host language.
The effectiveness of this framework is illustrated via a number of examples, implemented in a variety of host languages. In Haskell, linear domain-specific languages using mutable state and concurrency can take advantage of the monad that arises from the LNL model. In Coq, the QWIRE quantum circuit language uses linearity to enforce the no-cloning axiom of quantum mechanics. In homotopy type theory, quantum transformations can be encoded as higher inductive types to simplify the presentation of a quantum equational theory. These examples serve as case studies that prove linear/non-linear type theory is a natural and expressive interface in which to embed linear domain-specific languages
Benefits of Session Types for software Development
Session types are a formalism used to specify and check the correctness of communication based systems. Within their scope, they can guarantee the absence of communication errors such as deadlock, sending an unexpected message or failing to handle an incoming message. Introduced over two decades ago, they have developed into a significant theme in programming languages. In this paper we examine the beliefs that drive research into this area and make it popular. We look at the claims and motivation behind session types throughout the literature. We identify the hypotheses upon which session types have been designed and implemented, and attempt to clarify and formulate them in a more suitable manner for testing
Linearity and Uniqueness: An Entente Cordiale
Substructural type systems are growing in popularity because they allow for a resourceful interpretation of data which can be used to rule out various software bugs. Indeed, substructurality is finally taking hold in modern programming; Haskell now has linear types roughly based on Girard’s linear logic but integrated via graded function arrows, Clean has uniqueness types designed to ensure that values have at most a single reference to them, and Rust has an intricate ownership system for guaranteeing memory safety. But despite this broad range of resourceful type systems, there is comparatively little understanding of their relative strengths and weaknesses or whether their underlying frameworks can be unified. There is often confusion about whether linearity and uniqueness are essentially the same, or are instead ‘dual’ to one another, or somewhere in between. This paper formalises the relationship between these two well-studied but rarely contrasted ideas, building on two distinct bodies of literature, showing that it is possible and advantageous to have both linear and unique types in the same type system. We study the guarantees of the resulting system and provide a practical implementation in the graded modal setting of the Granule language, adding a third kind of modality alongside coeffect and effect modalities. We then demonstrate via a benchmark that our implementation benefits from expected efficiency gains enabled by adding uniqueness to a language that already has a linear basis
Density Matrices with Metric for Derivational Ambiguity
Recent work on vector-based compositional natural language semantics has
proposed the use of density matrices to model lexical ambiguity and (graded)
entailment (e.g. Piedeleu et al 2015, Bankova et al 2019, Sadrzadeh et al
2018). Ambiguous word meanings, in this work, are represented as mixed states,
and the compositional interpretation of phrases out of their constituent parts
takes the form of a strongly monoidal functor sending the derivational
morphisms of a pregroup syntax to linear maps in FdHilb. Our aims in this paper
are threefold. Firstly, we replace the pregroup front end by a Lambek
categorial grammar with directional implications expressing a word's
selectional requirements. By the Curry-Howard correspondence, the derivations
of the grammar's type logic are associated with terms of the (ordered) linear
lambda calculus; these terms can be read as programs for compositional meaning
assembly with density matrices as the target semantic spaces. Secondly, we
extend on the existing literature and introduce a symmetric, nondegenerate
bilinear form called a "metric" that defines a canonical isomorphism between a
vector space and its dual, allowing us to keep a distinction between left and
right implication. Thirdly, we use this metric to define density matrix spaces
in a directional form, modeling the ubiquitous derivational ambiguity of
natural language syntax, and show how this alows an integrated treatment of
lexical and derivational forms of ambiguity controlled at the level of the
interpretation.Comment: 24 pages, 10 figures. SemSpace 2019, to appear in J. of Applied
Logic
Command injection attacks, continuations, and the Lambek calculus
This paper shows connections between command injection attacks,
continuations, and the Lambek calculus: certain command injections, such as the
tautology attack on SQL, are shown to be a form of control effect that can be
typed using the Lambek calculus, generalizing the double-negation typing of
continuations. Lambek's syntactic calculus is a logic with two implicational
connectives taking their arguments from the left and right, respectively. These
connectives describe how strings interact with their left and right contexts
when building up syntactic structures. The calculus is a form of propositional
logic without structural rules, and so a forerunner of substructural logics
like Linear Logic and Separation Logic.Comment: In Proceedings WoC 2015, arXiv:1606.0583
Continuation Passing Style for Effect Handlers
We present Continuation Passing Style (CPS) translations for Plotkin and Pretnar's effect handlers with Hillerström and Lindley's row-typed fine-grain call-by-value calculus of effect handlers as the source language. CPS translations of handlers are interesting theoretically, to explain the semantics of handlers, and also offer a practical implementation technique that does not require special support in the target language's runtime. We begin with a first-order CPS translation into untyped lambda calculus which manages a stack of continuations and handlers as a curried sequence of arguments. We then refine the initial CPS translation first by uncurrying it to yield a properly tail-recursive translation and second by making it higher-order in order to contract administrative redexes at translation time. We prove that the higher-order CPS translation simulates effect handler reduction. We have implemented the higher-order CPS translation as a JavaScript backend for the Links programming language
- …