Typestate: A programming language concept for enhancing software reliability
IEEE Transactions on Software Engineering
Theoretical Computer Science
CLEAN: A language for functional graph rewriting
Proc. of a conference on Functional programming languages and computer architecture
Region-based memory management
Information and Computation
Dependent types in practical programming
Proceedings of the 26th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Operational reasoning for functions with local state
Higher order operational techniques in semantics
Typed memory management via static capabilities
ACM Transactions on Programming Languages and Systems (TOPLAS)
Enforcing high-level protocols in low-level software
Proceedings of the ACM SIGPLAN 2001 conference on Programming language design and implementation
Adoption and focus: practical linear types for imperative programming
PLDI '02 Proceedings of the ACM SIGPLAN 2002 Conference on Programming language design and implementation
ESOP '00 Proceedings of the 9th European Symposium on Programming Languages and Systems
Separation Logic: A Logic for Shared Mutable Data Structures
LICS '02 Proceedings of the 17th Annual IEEE Symposium on Logic in Computer Science
Semantics of types for mutable state
Semantics of types for mutable state
Transition predicate abstraction and fair termination
Proceedings of the 32nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Proceedings of the 32nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A step-indexed model of substructural state
Proceedings of the tenth ACM SIGPLAN international conference on Functional programming
A very modal model of a modern, major, general type system
Proceedings of the 34th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Local Action and Abstract Separation Logic
LICS '07 Proceedings of the 22nd Annual IEEE Symposium on Logic in Computer Science
L3: A Linear Language with Locations
Fundamenta Informaticae - Typed Lambda Calculi and Applications 2005, Selected Papers
Hiding Local State in Direct Style: A Higher-Order Anti-Frame Rule
LICS '08 Proceedings of the 2008 23rd Annual IEEE Symposium on Logic in Computer Science
State-dependent representation independence
Proceedings of the 36th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Hoare type theory, polymorphism and separation1
Journal of Functional Programming
ESOP '09 Proceedings of the 18th European Symposium on Programming Languages and Systems: Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2009
A relational modal logic for higher-order stateful ADTs
Proceedings of the 37th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Verifying event-driven programs using ramified frame properties
Proceedings of the 5th ACM SIGPLAN workshop on Types in language design and implementation
Lightweight linear types in system f°
Proceedings of the 5th ACM SIGPLAN workshop on Types in language design and implementation
Checking interference with fractional permissions
SAS'03 Proceedings of the 10th international conference on Static analysis
The impact of higher-order state and control effects on local relational reasoning
Proceedings of the 15th ACM SIGPLAN international conference on Functional programming
A modality for safe resource sharing and code reentrancy
ICTAC'10 Proceedings of the 7th International colloquium conference on Theoretical aspects of computing
Concurrent abstract predicates
ECOOP'10 Proceedings of the 24th European conference on Object-oriented programming
Abstraction and refinement for local reasoning
VSTTE'10 Proceedings of the Third international conference on Verified software: theories, tools, experiments
The essence of monotonic state
Proceedings of the 7th ACM SIGPLAN workshop on Types in language design and implementation
Explicit stabilisation for modular rely-guarantee reasoning
ESOP'10 Proceedings of the 19th European conference on Programming Languages and Systems
Step-Indexed syntactic logical relations for recursive and quantified types
ESOP'06 Proceedings of the 15th European conference on Programming Languages and Systems
ESOP'12 Proceedings of the 21st European conference on Programming Languages and Systems
The type discipline of behavioral separation
POPL '13 Proceedings of the 40th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Views: compositional reasoning for concurrent programs
POPL '13 Proceedings of the 40th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Linear dependent types for differential privacy
POPL '13 Proceedings of the 40th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Subjective auxiliary state for coarse-grained concurrency
POPL '13 Proceedings of the 40th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Abstract effects and proof-relevant logical relations
Proceedings of the 41st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages
Proceedings of the ACM SIGPLAN 2014 Workshop on Programming Languages meets Program Verification
Aliasing in Object-Oriented Programming
Hi-index | 0.00 |
Many substructural type systems have been proposed for controlling access to shared state in higher-order languages. Central to these systems is the notion of a *resource*, which may be split into disjoint pieces that different parts of a program can manipulate independently without worrying about interfering with one another. Some systems support a *logical* notion of resource (such as permissions), under which two resources may be considered disjoint even if they govern the *same* piece of state. However, in nearly all existing systems, the notions of resource and disjointness are fixed at the outset, baked into the model of the language, and fairly coarse-grained in the kinds of sharing they enable. In this paper, inspired by recent work on "fictional disjointness" in separation logic, we propose a simple and flexible way of enabling any module in a program to create its own custom type of splittable resource (represented as a commutative monoid), thus providing fine-grained control over how the module's private state is shared with its clients. This functionality can be incorporated into an otherwise standard substructural type system by means of a new typing rule we call *the sharing rule*, whose soundness we prove semantically via a novel resource-oriented Kripke logical relation.