Explicit Connection Actions in Multiparty Session Types

Session Types offer a typing discipline that allows protocol specifications to be used during typechecking, ensuring that implementations adhere to a given specification. When looking to realise global session types in a dependently typed language care must be taken that values introduced in the description are used by roles that know about the value.We present Sessions, a Resource Dependent Embedded Domain Specific Language (EDSL) for describing global session descriptions in the dependently typed language Idris. As we construct session descriptions the values parameterising the EDSLs' type keeps track of roles and messages they have encountered. We can use this knowledge to ensure that message values are only used by those who know the value. Sessions supports protocol descriptions that are computable, composable, higher-order, and value-dependent. We demonstrate Sessions expressiveness by describing the TCP Handshake, a multi-modal server providing echo and basic arithmetic operations, and a Higher-Order protocol that supports an authentication interaction step.

Section: Discussionmentioning

confidence: 99%

Value-Dependent Session Design in a Dependently Typed Language

Muijnck-Hughes

Brady

Vanderbauwhede

2019

“…As it leaves the other end of a channel at the sender's side, we need the dual of the carried (delegated) session type, which is why we have both carried type S0 and its dual T0 in a delegation type Deleg<S0,T0,S>. Thus, delegation Deleg and its bound-output variant DelegNew is defined as follows: cliCh3.Receive(out var ans).Close(); 8 Console.WriteLine("Tak(16,3,2) = " + ans); 9 }, right: cliCh3 => { 10 cliCh3.Close(); 11 Console.WriteLine("Cancelled"); 12 }); Figure 5: A tak Client with a Timeout…”

Section: Binders As Out Parameters and Async/await Integrationmentioning

confidence: 99%

Fluent Session Programming in C#

Kimura

Imai

2020

We propose SessionC#, a lightweight session typed library for safe concurrent/distributed programming. The key features are (1) the improved fluent interface which enables writing communication in chained method calls, by exploiting C#'s out variables, and (2) amalgamation of session delegation with async/await, which materialises session cancellation in a limited form, which we call session intervention. We show the effectiveness of our proposal via a Bitcoin miner application. IntroductionSession types [8] are a theoretical framework for statically specifying and verifying communication protocols in concurrent and distributed programs. Session types guarantee that a well-typed program follows a safe communication protocol free from reception errors (unexpected messages) and deadlocks.The major gaps between session types and "mainstream" programming language type system are the absence of the two key features: (1) duality for checking the communication protocol realises reciprocal communication actions between two peers, and (2) linearity ensuring that each peer is exactly following the protocol, in the way that channel variables are exclusively used from one site for the exact number of times. Various challenges have been made for incorporating them into general-purpose languages including Java [12], Scala [28], Haskell [25,14,19,23], OCaml [24,13] and Rust [15,16].We observe that the above-mentioned gaps in session-based programming can be narrowed further by the recent advancement of programming languages, which is driven by various real-world programming issues. In particular, C# [1] is widely used in areas ranging from Windows and web application platforms to gaming (e.g. Unity), and known to be eagerly adopting various language features including async/await, reifiable generics, named parameters, out variables and extension methods.In this paper, we propose SessionC# -a library implementation of session types on top of the rich set of features in C#, and show its usefulness in concurrent/distributed programming, aiming for practicality. client server (int,int,int) «delegation» left right int choice (completed) (cancelled) cancel (asynchronously)Namely, (1) it has an improved fluent interface (i.e., method calls can be chained) via C#'s out variables, reducing the risk of linearity violation in an idiomatic way. Furthermore, (2) it enables session cancellation in a limited form -which we call session intervention -by utilising amalgamation of C#'s async/await and session delegation in thread-based concurrency. We illustrate the essential bits of SessionC# where a cancellable computation is guided by session types, by a use-case where a C# thread calculates a cancellable tak function which is designed to have a long running time [20]. The figure on the right depicts the overall communication protocol, which can be written in SessionC# as a protocol specification describing a client-server communication protocol from the client's viewpoint, as follows: var prot = Send(Val<(int,int,int)>, Deleg(chan:Recv(Unit,...

“…We also aim at getting global types, the difference being that this is obtained out of the global types describing the two systems which are connected. The "dynamic" addition of participants (they can join/leave the session after it's been set up) is supported in the calculus of [19]. In that work the extension of a system is part of the global protocol.…”

Section: Related Workmentioning

confidence: 99%

Open Multiparty Sessions

Barbanera

Dezani‐Ciancaglini

2019

Multiparty sessions are systems of concurrent processes, which allow several participants to communicate by sending and receiving messages. Their overall behaviour can be described by means of global types. Typable multiparty session enjoy lock-freedom. We look at multiparty sessions as open systems by a suitable definition of connection transforming compatible processes into gateways (forwarders). A relation resembling the standard subtyping relation for session types is used to formalise compatibility. We show that the session obtained by connection can be typed by manipulating the global types of the starting sessions. This allows us to prove that lock-freedom is preserved by connection. * Partially supported by the project "Piano Triennale Ricerca" DMI-Università di Catania. † Partially supported by Ateneo/Compagnia di San Paolo 2016/2018 project "MnemoComputing -Components for Processing In Memory". Definition 2.3 (LTS for Multiparty Sessions) The labelled transition system (LTS) for multiparty sessions is the closure under structural congruence of the reduction specified by the unique rule: [COMM] makes the communication possible: participant p sends message ℓ to participant q. This rule is non-deterministic in the choice of messages. The condition msg(Λ) ⊆ msg(Λ ′ ) assures that the sender can freely choose the message, since the receiver must offer all sender messages and possibly more. This allows us to distinguish in the operational semantics between internal and external choices.We use M λ − → M ′ as shorthand for M pℓq − − → M ′ . We sometimes omit the label writing −→. As usual, −→ * denotes the reflexive and transitive closure of −→.Example 2.4 Let us consider a system (inspired by a similar one in [1]) with participants p, q, and h interacting according the following protocol. Participant p keeps on sending text messages to q, which