881 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
Pluggable type-checking for custom type qualifiers in Java
We have created a framework for adding custom type qualifiers to the Javalanguage in a backward-compatible way. The type system designer definesthe qualifiers and creates a compiler plug-in that enforces theirsemantics. Programmers can write the type qualifiers in their programs andbe informed of errors or assured that the program is free of those errors.The system builds on existing Java tools and APIs.In order to evaluate our framework, we have written four type-checkersusing the framework: for a non-null type system that can detect andprevent null pointer errors; for an interned type system that can detectand prevent equality-checking errors; for a reference immutability typesystem, Javari, that can detect and prevent mutation errors; and for areference and object immutability type system, IGJ, that can detect andprevent even more mutation errors. We have conducted case studies usingeach checker to find real errors in existing software. These case studiesdemonstrate that the checkers and the framework are practical and useful
Automated Refinement Of Hierarchical Object Graphs
Object graphs help explain the runtime structure of a system. To make object graphs convey design intent, one insight is to use
abstraction by hierarchy, i.e., to show objects that are implementation details as children of architecturally-relevant objects from the application domain. But additional information is needed to express this object hierarchy, using ownership type qualifiers in the code. Adding qualifiers after the fact involves manual overhead, and requires developers to switch between adding qualifiers in the code and looking at abstract object graphs to understand the object structures that the qualifiers describe. We propose an approach where developers express their design intent by refining an object graph directly, while an inference analysis infers valid qualifiers in the code. We present, formalize and implement the inference analysis. Novel features of the inference analysis compared to closely related work include a larger set of qualifiers to support less restrictive object hierarchy (logical containment) in addition to strict hierarchy (strict encapsulation), as well as object uniqueness and object borrowing. A separate extraction analysis then uses these qualifiers and extracts an updated object graph. We evaluate the approach on two subject systems. One of the subject systems is reproduced from an experiment using related techniques and another ownership type system, which enables a meaningful comparison. For the other subject system, we use its documentation to pick refinements that express design intent. We compute metrics on the refinements (how many attempts on each subject system) and classify them by their type. We also compute metrics on the inferred qualifiers and metrics on the object graphs to enable quantitative comparison. Moreover, we qualitatively compare the hierarchical object graphs with the flat object graphs and with each other, by highlighting how they express design intent. Finally, we confirm that the approach can infer from refinements valid qualifiers such that the extracted object graphs reflect the design intent of the refinements
Interactive Refinement Of Hierarchical Object Graphs
Developers need to understand the runtime structure of object-oriented code, and abstract object graphs can help. To extract abstract object graphs that convey design intent in the form of object hierarchy, additional information is needed to express this hierarchy in the code using ownership types, but adding ownership type qualifiers after the fact involves manual overhead, and requires developers to switch between adding qualifiers in the code and looking at abstract object graphs to understand the object structures that the qualifiers describe. We describe an approach where developers express their design intent by refining an object graph directly, while an inference analysis infers valid qualifiers in the code. A separate extraction analysis then uses these qualifiers and extracts an updated object graph. We implement and test the approach on several small test cases and confirm its feasibility
Funqual: User-Defined, Statically-Checked Call Graph Constraints in C++
Static analysis tools can aid programmers by reporting potential programming mistakes prior to the execution of a program. Funqual is a static analysis tool that reads C++17 code ``in the wild\u27\u27 and checks that the function call graph follows a set of rules which can be defined by the user. This sort of analysis can help the programmer to avoid errors such as accidentally calling blocking functions in time-sensitive contexts or accidentally allocating memory in heap-sensitive environments. To accomplish this, we create a type system whereby functions can be given user-defined type qualifiers and where users can define their own restrictions on the call graph based on these type qualifiers. We demonstrate that this tool, when used with hand-crafted rules, can catch certain types of errors which commonly occur in the wild. We claim that this tool can be used in a production setting to catch certain kinds of errors in code before that code is even run
Liquid Intersection Types
We present a new type system combining refinement types and the
expressiveness of intersection type discipline. The use of such features makes
it possible to derive more precise types than in the original refinement
system. We have been able to prove several interesting properties for our
system (including subject reduction) and developed an inference algorithm,
which we proved to be sound.Comment: In Proceedings ITRS 2014, arXiv:1503.0437
Qualifying System F-sub
Type qualifiers offer a lightweight mechanism for enriching existing type
systems to enforce additional, desirable, program invariants. They do so by
offering a restricted but effective form of subtyping. While the theory of type
qualifiers is well understood and present in many programming languages today,
polymorphism over type qualifiers is an area that is less examined. We explore
how such a polymorphic system could arise by constructing a calculus System
F<:Q which combines the higher-rank bounded polymorphism of System F<: with the
theory of type qualifiers. We explore how the ideas used to construct System
F<:Q can be reused in situations where type qualifiers naturally arise -- in
reference immutability, function colouring, and capture checking. Finally, we
re-examine other qualifier systems in the literature in light of the
observations presented while developing System F<:Q.Comment: 24 page
Safe Stream-Based Programming with Refinement Types
In stream-based programming, data sources are abstracted as a stream of
values that can be manipulated via callback functions. Stream-based programming
is exploding in popularity, as it provides a powerful and expressive paradigm
for handling asynchronous data sources in interactive software. However,
high-level stream abstractions can also make it difficult for developers to
reason about control- and data-flow relationships in their programs. This is
particularly impactful when asynchronous stream-based code interacts with
thread-limited features such as UI frameworks that restrict UI access to a
single thread, since the threading behavior of streaming constructs is often
non-intuitive and insufficiently documented.
In this paper, we present a type-based approach that can statically prove the
thread-safety of UI accesses in stream-based software. Our key insight is that
the fluent APIs of stream-processing frameworks enable the tracking of threads
via type-refinement, making it possible to reason automatically about what
thread a piece of code runs on -- a difficult problem in general.
We implement the system as an annotation-based Java typechecker for Android
programs built upon the popular ReactiveX framework and evaluate its efficacy
by annotating and analyzing 8 open-source apps, where we find 33 instances of
unsafe UI access while incurring an annotation burden of only one annotation
per 186 source lines of code. We also report on our experience applying the
typechecker to two much larger apps from the Uber Technologies Inc. codebase,
where it currently runs on every code change and blocks changes that introduce
potential threading bugs
- …