scholarly journals Estimate the Memory Bounds Required by Shared Variables in Software Transactional Memory Programs

2021 ◽  
Vol 37 (2) ◽  
Author(s):  
Nguyen Ngoc Khai ◽  
Truong Anh Hoang ◽  
Dang Duc Hanh
Keyword(s):  
Transactional Memory ◽  
Type System ◽  
Type Systems ◽  
Research Topic ◽  
Software Transactional Memory ◽  
Loop Body ◽  
Shared Variables ◽  
New Type

Estimating memory required by complex programs is a well-known research topic. In this work, we build a type system to statically estimate the memory bounds required by shared variables in software transactional memory (STM) programs. This work extends our previous works with additional language features such as explicitly declared shared variables, introduction of primitive types, and allowing loop body to contain any statement, not required to be well-typed as in our previous works. Also, the new type system has better compositionality compared to available type systems.

scholarly journals A Unified Type System for Object-Oriented Programming

1990 ◽  
Vol 19 (341) ◽  
Author(s):  
Jens Palsberg ◽  
Michael I. Schwartzbach
Keyword(s):  
Type System ◽  
Object Oriented ◽  
Type Systems ◽  
Object Oriented Programming ◽  
Type Checking ◽  
Separate Compilation ◽  
Set Inclusion ◽  
New Type ◽  
Efficient Type ◽  
Object Oriented Languages

We present a new type system for object-oriented languages with assignments. Types are sets of classes, subtyping is set inclusion, and genericity is class substitution. The type system enables separate compilation, and unifies, generalizes, and simplifies the type systems underlying SIMULA/BETA, C++, EIFFEL, and Typed Smalltalk, and the type system with type substitutions proposed by Palsberg and Schwartzbach, Classes and types are both modeled as node-labeled, ordered regular trees; this allows an efficient type-checking algorithm.

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.

scholarly journals Reachability types: tracking aliasing and separation in higher-order functional programs

2021 ◽  
Vol 5 (OOPSLA) ◽  
pp. 1-32
Author(s):  
Yuyan Bao ◽  
Guannan Wei ◽  
Oliver Bračevac ◽  
Yuxuan Jiang ◽  
Qiyang He ◽  
...  
Keyword(s):  
Functional Programming ◽  
Type System ◽  
Type Systems ◽  
Higher Order ◽  
Ownership Type ◽  
Ownership Transfer ◽  
Reachability Sets ◽  
Programming Patterns ◽  
New Type ◽  
Higher Order Functions

Ownership type systems, based on the idea of enforcing unique access paths, have been primarily focused on objects and top-level classes. However, existing models do not as readily reflect the finer aspects of nested lexical scopes, capturing, or escaping closures in higher-order functional programming patterns, which are increasingly adopted even in mainstream object-oriented languages. We present a new type system, λ * , which enables expressive ownership-style reasoning across higher-order functions. It tracks sharing and separation through reachability sets, and layers additional mechanisms for selectively enforcing uniqueness on top of it. Based on reachability sets, we extend the type system with an expressive flow-sensitive effect system, which enables flavors of move semantics and ownership transfer. In addition, we present several case studies and extensions, including applications to capabilities for algebraic effects, one-shot continuations, and safe parallelization.

scholarly journals Automatic amortized resource analysis with the Quantum physicist’s method

2021 ◽  
Vol 5 (ICFP) ◽  
pp. 1-29
Author(s):  
David M. Kahn ◽  
Jan Hoffmann
Keyword(s):  
Quantum Tunneling ◽  
State Of The Art ◽  
Type System ◽  
Type Systems ◽  
Quantum Superposition ◽  
Resource Analysis ◽  
Linear Type ◽  
New Type ◽  
Novel Method ◽  
Standard Library

We present a novel method for working with the physicist's method of amortized resource analysis, which we call the quantum physicist's method. These principles allow for more precise analyses of resources that are not monotonically consumed, like stack. This method takes its name from its two major features, worldviews and resource tunneling, which behave analogously to quantum superposition and quantum tunneling. We use the quantum physicist's method to extend the Automatic Amortized Resource Analysis (AARA) type system, enabling the derivation of resource bounds based on tree depth. In doing so, we also introduce remainder contexts, which aid bookkeeping in linear type systems. We then evaluate this new type system's performance by bounding stack use of functions in the Set module of OCaml's standard library. Compared to state-of-the-art implementations of AARA, our new system derives tighter bounds with only moderate overhead.

scholarly journals Revisiting software transactional memory in Haskell

2018 ◽  
Vol 51 (12) ◽  
pp. 105-113
Author(s):  
Matthew Le ◽  
Ryan Yates ◽  
Matthew Fluet
Keyword(s):  
Transactional Memory ◽  
Software Transactional Memory

A system of constructor classes: overloading and implicit higher-order polymorphism

1995 ◽  
Vol 5 (1) ◽  
pp. 1-35 ◽  
Author(s):  
Mark P. Jones
Keyword(s):  
Type System ◽  
Type Systems ◽  
Natural Generalization ◽  
Higher Order ◽  
Functional Language ◽  
Effective Algorithm ◽  
Prototype Implementation ◽  
Type Classes

AbstractThis paper describes a flexible type system that combines overloading and higher-order polymorphism in an implicitly typed language using a system of constructor classes—a natural generalization of type classes in Haskell. We present a range of examples to demonstrate the usefulness of such a system. In particular, we show how constructor classes can be used to support the use of monads in a functional language. The underlying type system permits higher-order polymorphism but retains many of the attractive features that have made Hindley/Milner type systems so popular. In particular, there is an effective algorithm that can be used to calculate principal types without the need for explicit type or kind annotations. A prototype implementation has been developed providing, amongst other things, the first concrete implementation of monad comprehensions known to us at the time of writing.

The study of mixed assets allocation based on Black–Litterman model

2021 ◽  
pp. 2150022
Author(s):  
Jianwu Lin ◽  
Mengwei Tang ◽  
Jiachang Wang ◽  
Ping He
Keyword(s):  
Stock Market ◽  
Asset Allocation ◽  
Private Equity ◽  
Equity Market ◽  
Research Topic ◽  
Allocation Model ◽  
Quantitative Models ◽  
Challenging Research ◽  
Qualitative Models ◽  
New Type

With Private Funds having a new type of license for asset allocation practice in China, comprehensive asset allocation cross private equity and stock market has received more attention. However, most of the studies focus more on the stock market, and asset allocation models for private equity market that are mainly made based on experience. Thus, the joint allocation of assets crosses both markets making it a challenging research topic. This paper introduces the Black–Litterman model into the private equity market, realizing the transition from qualitative models to quantitative models. It lays a solid quantitative ground for the mixed asset allocation model in both the markets.

Sign in / Sign up

Export Citation Format

Share Document