Kindly bent to free us

Radanne, Gabriel; Saffrich, Hannes; Thiemann, Peter

doi:10.1145/3408985

Cited by 5 publications

(4 citation statements)

References 31 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Finally, unique types [BS95] enforce that resources have a single reference to them which enables aggressive optimisations for purely functional parallel languages [HSE + 17] while preserving data race freedom. Several systems provide formal proofs of non-concurrent accesses for resources used linearly [Wal02,RST20].…”

Section: Linear Typesmentioning

confidence: 99%

A Survey on Parallelism and Determinism

et al. 2023

View full text Add to dashboard Cite

Parallelism is often required for performance. In these situations an excess of non-determinism is harmful as it means the program can have several different behaviours or even different results. Even in domains such as high-performance computing where parallelism is crucial for performance, the computed value should be deterministic. Unfortunately, non-determinism in programs also allows dynamic scheduling of tasks, reacting to the first task that succeeds, cancelling tasks that cannot lead to a result, etc. Non-determinism is thus both a desired asset or an undesired property depending on the situation. In practice, it is often necessary to limit non-determinism and to identify precisely the sources of non-determinism in order to control what parts of a program are deterministic or not. This survey takes the perspective of programming languages, and studies how programming models can ensure the determinism of parallel programs. This survey studies not only deterministic languages but also programming models that prevent one particularly demanding source of non-determinism: data races. Our objective is to compare existing solutions to the following questions: How programming languages can help programmers write programs that run in a parallel manner without visible non-determinism? What programming paradigms ensure this kind of properties? We study these questions and discuss the merits and limitations of different approaches.

show abstract

Section: Linear Typesmentioning

confidence: 99%

A Survey on Parallelism and Determinism

et al. 2023

View full text Add to dashboard Cite

show abstract

“…[14] demonstrated the relationship between regions and unique pointers, observing that "unique pointers are essentially lightweight, dynamic regions that hold exactly one object." Beyond that, Rust's lifetimes are heavily based on regions, and there exists an extension of ML called Affe [43] which aims to support both linearity and borrowing using regions.…”

Section: Compilation and Evaluationmentioning

confidence: 99%

Linearity and Uniqueness: An Entente Cordiale

Marshall

Vollmer

Orchard

2022

Lecture Notes in Computer Science

View full text Add to dashboard Cite

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.

show abstract

“…Quill also has a type inference algorithm which was proven sound and complete. Affe [13] is an ML-like language with support to linear, affine and unrestricted types. Like Quill, Affe uses kinds and constrained types to distinguish between linear and affine types.…”

Section: Introductionmentioning

confidence: 99%

“…The works more closely related to FREEST are Quill [9], Affe [13], Alms [17], F • [8], FuSe {} [11] and Linear Haskell [4]. All these languages feature substructural type systems for dealing with linear, functional and affine types (in the case of Affe).…”

Section: Introductionmentioning

confidence: 99%

Kind Inference for the FreeST Programming Language

Almeida

Mordido

Vasconcelos

2023

Electron. Proc. Theor. Comput. Sci.

View full text Add to dashboard Cite

We present a kind inference algorithm for the FREEST programming language. The input to the algorithm is FREEST source code with (possibly part of) kind annotations replaced by kind variables. The algorithm infers concrete kinds for all kind variables. We ran the algorithm on the FREEST test suite by first replacing kind annotation on all type variables by fresh kind variables, and concluded that the algorithm correctly infers all kinds. Non surprisingly, we found out that programmers do not choose the most general kind in 20% of the cases.

show abstract

Kindly bent to free us

Cited by 5 publications

References 31 publications

A Survey on Parallelism and Determinism

A Survey on Parallelism and Determinism

Linearity and Uniqueness: An Entente Cordiale

Kind Inference for the FreeST Programming Language

Contact Info

Product

Resources

About