scholarly journals Relational nullable types with Boolean unification

2021 ◽  
Vol 5 (OOPSLA) ◽  
pp. 1-28
Author(s):  
Magnus Madsen ◽  
Jaco van de Pol
Keyword(s):  
Open Source ◽  
Programming Languages ◽  
Type System ◽  
Type Systems ◽  
Type Inference ◽  
System A ◽  
Wide Range ◽  
Programming Patterns ◽  
Null Value ◽  
Preliminary Study

We present a simple, practical, and expressive relational nullable type system. A relational nullable type system captures whether an expression may evaluate to null based on its type, but also based on the type of other related expressions. The type system extends the Hindley-Milner type system with Boolean constraints, supports parametric polymorphism, and preserves principal types modulo Boolean equivalence. We show how to support full Hindley-Milner style type inference with an extension of Algorithm W. We conduct a preliminary study of open source projects showing that there is a need for relational nullable type systems across a wide range of programming languages. The most important findings from the study are: (i) programmers use programming patterns where the nullability of one expression depends on the nullability of other related expressions, (ii) such invariants are commonly enforced with run-time exceptions, and (iii) reasoning about these programming patterns requires not only knowledge of when an expression may evaluate to null, but also when it may evaluate to a non-null value. We incorporate these observations in the design of the proposed relational nullable type system.

scholarly journals Implicit self-adjusting computation for purely functional programs

2014 ◽  
Vol 24 (1) ◽  
pp. 56-112 ◽  
Author(s):  
YAN CHEN ◽  
JOSHUA DUNFIELD ◽  
MATTHEW A. HAMMER ◽  
UMUT A. ACAR
Keyword(s):  
Programming Languages ◽  
Type System ◽  
Type Systems ◽  
Type Inference ◽  
Source Program ◽  
Target Program ◽  
Implicit Approach ◽  
Asymptotic Complexity ◽  
Cost Semantics ◽  
Output Behavior

AbstractComputational problems that involve dynamic data, such as physics simulations and program development environments, have been an important subject of study in programming languages. Building on this work, recent advances in self-adjusting computation have developed techniques that enable programs to respond automatically and efficiently to dynamic changes in their inputs. Self-adjusting programs have been shown to be efficient for a reasonably broad range of problems, but the approach still requires an explicit programming style, where the programmer must use specific monadic types and primitives to identify, create, and operate on data that can change over time. We describe techniques for automatically translating purely functional programs into self-adjusting programs. In this implicit approach, the programmer need only annotate the (top-level) input types of the programs to be translated. Type inference finds all other types, and a type-directed translation rewrites the source program into an explicitly self-adjusting target program. The type system is related to information-flow type systems and enjoys decidable type inference via constraint solving. We prove that the translation outputs well- typed self-adjusting programs and preserves the source program's input–output behavior, guaranteeing that translated programs respond correctly to all changes to their data. Using a cost semantics, we also prove that the translation preserves the asymptotic complexity of the source program.

Introduction to the Special Issue on Dependent Type Theory Meets Practical Programming

2004 ◽  
Vol 14 (1) ◽  
pp. 1-2
Author(s):  
GILLES BARTHE ◽  
PETER DYBJEN ◽  
PETER THIEMANN
Keyword(s):  
Programming Languages ◽  
Type Theory ◽  
Type System ◽  
Type Systems ◽  
Special Issue ◽  
Dependent Type Theory ◽  
Dependent Type

Modern programming languages rely on advanced type systems that detect errors at compile-time. While the benefits of type systems have long been recognized, there are some areas where the standard systems in programming languages are not expressive enough. Language designers usually trade expressiveness for decidability of the type system. Some interesting programs will always be rejected (despite their semantical soundness) or be assigned uninformative types.

Weak polymorphism can be sound

1996 ◽  
Vol 6 (1) ◽  
pp. 111-141 ◽  
Author(s):  
John Greiner
Keyword(s):  
New Jersey ◽  
Type System ◽  
Type Systems ◽  
Type Inference ◽  
Inference Algorithm ◽  
Standard Ml ◽  
Polymorphic Type

AbstractThe weak polymorphic type system of Standard ML of New Jersey (SML/NJ) (MacQueen, 1992) has only been presented as part of the implementation of the SML/NJ compiler, not as a formal type system. As a result, it is not well understood. And while numerous versions of the implementation have been shown unsound, the concept has not been proved sound or unsound. We present an explanation of weak polymorphism and show that a formalization of this is sound. We also relate this to the SML/NJ implementation of weak polymorphism through a series of type systems that incorporate elements of the SML/NJ type inference algorithm.

scholarly journals Featherweight generic confinement

2006 ◽  
Vol 16 (6) ◽  
pp. 793-811 ◽  
Author(s):  
ALEX POTANIN ◽  
JAMES NOBLE ◽  
DAVE CLARKE ◽  
ROBERT BIDDLE
Keyword(s):  
Programming Languages ◽  
Ad Hoc ◽  
Type System ◽  
Type Systems ◽  
General Purpose ◽  
Ownership Type ◽  
Essential Change ◽  
Polymorphic Type ◽  
Syntactic Restrictions

Existing approaches to object encapsulation either rely on ad hoc syntactic restrictions or require the use of specialised type systems. Syntactic restrictions are difficult to scale and to prove correct, while specialised type systems require extensive changes to programming languages. We demonstrate that confinement can be enforced cheaply in Featherweight Generic Java, with no essential change to the underlying language or type system. This result demonstrates that polymorphic type parameters can simultaneously act as ownership parameters and should facilitate the adoption of confinement and ownership type systems in general-purpose programming languages.

scholarly journals Conditional Independence by Typing

2022 ◽  
Vol 44 (1) ◽  
pp. 1-54
Author(s):  
Maria I. Gorinova ◽  
Andrew D. Gordon ◽  
Charles Sutton ◽  
Matthijs Vákár
Keyword(s):  
Programming Languages ◽  
Conditional Independence ◽  
Probabilistic Models ◽  
Type System ◽  
Type Inference ◽  
Practical Application ◽  
Probabilistic Programming ◽  
Variable Elimination ◽  
Gradient Based ◽  
Inference Methods

A central goal of probabilistic programming languages (PPLs) is to separate modelling from inference. However, this goal is hard to achieve in practice. Users are often forced to re-write their models to improve efficiency of inference or meet restrictions imposed by the PPL. Conditional independence (CI) relationships among parameters are a crucial aspect of probabilistic models that capture a qualitative summary of the specified model and can facilitate more efficient inference. We present an information flow type system for probabilistic programming that captures conditional independence (CI) relationships and show that, for a well-typed program in our system, the distribution it implements is guaranteed to have certain CI-relationships. Further, by using type inference, we can statically deduce which CI-properties are present in a specified model. As a practical application, we consider the problem of how to perform inference on models with mixed discrete and continuous parameters. Inference on such models is challenging in many existing PPLs, but can be improved through a workaround, where the discrete parameters are used implicitly , at the expense of manual model re-writing. We present a source-to-source semantics-preserving transformation, which uses our CI-type system to automate this workaround by eliminating the discrete parameters from a probabilistic program. The resulting program can be seen as a hybrid inference algorithm on the original program, where continuous parameters can be drawn using efficient gradient-based inference methods, while the discrete parameters are inferred using variable elimination. We implement our CI-type system and its example application in SlicStan: a compositional variant of Stan. 1

MOSQITO: an open-source and free toolbox for sound quality metrics in the industry and education

2021 ◽  
Vol 263 (5) ◽  
pp. 1164-1175
Author(s):  
Roberto San Millán-Castillo ◽  
Eduardo Latorre-Iglesias ◽  
Martin Glesser ◽  
Salomé Wanty ◽  
Daniel Jiménez-Caminero ◽  
...  
Keyword(s):  
Open Source ◽  
Programming Languages ◽  
Open Source Software ◽  
Objective Assessment ◽  
Sound Quality ◽  
Quality Metrics ◽  
Point Of View ◽  
Wide Range ◽  
Efficient Learning ◽  
High Level

Sound quality metrics provide an objective assessment of the psychoacoustics of sounds. A wide range of metrics has been already standardised while others remain as active research topics. Calculation algorithms are available in commercial equipment or Matlab scripts. However, they may not present available data on general documentation and validation procedures. Moreover, the use of these tools might be unaffordable for some students and independent researchers. In recent years, the scientific and technical community has been developing uncountable open-source software projects in several knowledge fields. The permission to use, study, modify, improve and distribute open-source software make it extremely valuable. It encourages collaboration and sharing, and thus transparency and continuous improvement of the coding. Modular Sound Quality Integrated Toolbox (MOSQITO) project relies on one of the most popular high-level and free programming languages: Python. The main objective of MOSQITO is to provide a unified and modular framework of key sound quality and psychoacoustics metrics, free and open-source, which supports reproducible testing. Moreover, open-source projects can be efficient learning tools at University degrees. This paper presents the current structure of the toolbox from a technical point of view. Besides, it discusses open-source development contributions to graduates training.

Linearization of the lambda-calculus and its relation with intersection type systems

2004 ◽  
Vol 14 (5) ◽  
pp. 519-546 ◽  
Author(s):  
MÁRIO FLORIDO ◽  
LUÍS DAMAS
Keyword(s):  
Programming Languages ◽  
Functional Programming ◽  
Type System ◽  
Lambda Calculus ◽  
Type Systems ◽  
Functional Programming Languages

In this paper we present a notion of expansion of a term in the lambda-calculus which transforms terms into linear terms. This transformation replaces each occurrence of a variable in the original term by a fresh variable taking into account non-trivial implications in the structure of the term caused by these simple replacements. We prove that the class of terms which can be expanded is the same of terms typable in an Intersection Type System, i.e. the strongly normalizable terms. We then show that expansion is preserved by weak-head reduction, the reduction considered by functional programming languages.

scholarly journals Coercions in a polymorphic type system

2008 ◽  
Vol 18 (4) ◽  
pp. 729-751 ◽  
Author(s):  
ZHAOHUI LUO
Keyword(s):  
Programming Languages ◽  
Functional Programming ◽  
Type System ◽  
Type Inference ◽  
Inference Algorithm ◽  
Functional Programming Languages ◽  
Polymorphic Type ◽  
And Function ◽  
Dependent Type

We incorporate the idea of coercive subtyping, a theory of abbreviation for dependent type theories, into the polymorphic type system in functional programming languages. The traditional type system with let-polymorphism is extended with argument coercions and function coercions, and a corresponding type inference algorithm is presented and proved to be sound and complete.

scholarly journals A certified lightweight non-interference Java bytecode verifier

2013 ◽  
Vol 23 (5) ◽  
pp. 1032-1081 ◽  
Author(s):  
GILLES BARTHE ◽  
DAVID PICHARDIE ◽  
TAMARA REZK
Keyword(s):  
Programming Languages ◽  
Information Flow ◽  
Type System ◽  
Type Systems ◽  
Program Execution ◽  
Flow Type ◽  
Java Bytecode ◽  
First Sound ◽  
Coq Proof Assistant ◽  
High Level

Non-interference guarantees the absence of illicit information flow throughout program execution. It can be enforced by appropriate information flow type systems. Much of the previous work on type systems for non-interference has focused on calculi or high-level programming languages, and existing type systems for low-level languages typically omit objects, exceptions and method calls. We define an information flow type system for a sequential JVM-like language that includes all these programming features, and we prove, in the Coq proof assistant, that it guarantees non-interference. An additional benefit of the formalisation is that we have extracted from our proof a certified lightweight bytecode verifier for information flow. Our work provides, to the best of our knowledge, the first sound and certified information flow type system for such an expressive fragment of the JVM.

scholarly journals Elaborating intersection and union types

2014 ◽  
Vol 24 (2-3) ◽  
pp. 133-165 ◽  
Author(s):  
JOSHUA DUNFIELD
Keyword(s):  
Programming Languages ◽  
Type System ◽  
Type Systems ◽  
Prototype Implementation ◽  
Value Evaluation ◽  
Source Program ◽  
Parametric Polymorphism ◽  
New Type ◽  
Dynamic Typing ◽  
System Feature

AbstractDesigning and implementing typed programming languages is hard. Every new type system feature requires extending the metatheory and implementation, which are often complicated and fragile. To ease this process, we would like to provide general mechanisms that subsume many different features. In modern type systems, parametric polymorphism is fundamental, but intersection polymorphism has gained little traction in programming languages. Most practical intersection type systems have supported onlyrefinement intersections, which increase the expressiveness of types (more precise properties can be checked) without altering the expressiveness of terms; refinement intersections can simply be erased during compilation. In contrast,unrestrictedintersections increase the expressiveness of terms, and can be used to encode diverse language features, promising an economy of both theory and implementation. We describe a foundation for compiling unrestricted intersection and union types: an elaboration type system that generates ordinary λ-calculus terms. The key feature is a Forsythe-like merge construct. With this construct, not all reductions of the source program preserve types; however, we prove that ordinary call-by-value evaluation of the elaborated program corresponds to a type-preserving evaluation of the source program. We also describe a prototype implementation and applications of unrestricted intersections and unions: records, operator overloading, and simulating dynamic typing.

Sign in / Sign up

Export Citation Format

Share Document