Value-Dependent Session Design in a Dependently Typed Language

TL;DR

This paper introduces Sessions, a dependently typed language embedded domain-specific language (EDSL) in Idris, for designing value-dependent session types that ensure protocol correctness and value usage safety.

Contribution

It presents a novel resource-dependent EDSL for dependently typed languages that enforces value-aware protocol adherence in session descriptions.

Findings

Successfully describes TCP Handshake protocol.

Supports multi-modal server interactions.

Enables higher-order, value-dependent protocol descriptions.

Abstract

Session Types offer a typing discipline that allows protocol specifications to be used during type-checking, 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 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.

Full text

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.

1 Introduction

Multi-Party Session Types (MPSTs) are a well-known typing discipline for describing sequences of message exchanges over communication channels [21]. Global session types present an overview of the interactions made between each component, and local session types describe the interactions respective to each participant. When realising MPSTs both global and local types are commonly presented either as bespoke Domain Specific Languages (DSLs) [40]; EDSLs that extend an existing programming language [25]; or a language extension [27].

MPSTs are, however, limited in their expressiveness. Session designers cannot specify value dependencies between sent messages, or reason about message contents. Recent work has extended the theory of MPST to incorporate value based reasoning on messages [38, 39, 6, 28].

Dependent types allow for more precise reasoning on programs by allowing types to depend on values. Existing work has shown how dependent types provide greater control over programs, and how they can be used to reason about communication in concurrent programs [13, 12, 11, 39] and communicating systems [20]. More generally, earlier work [9, 14] has shown how dependent types can provide resource-based type-level reasoning about programs.

Idris is a general purpose functional language with dependent types [8], Figure 1(a) presents a naïve implementation of a global session description as an EDSL within Idris. The type for expressions, Session, is indexed by a type describing participants (role) and type associated with expressions—type. Message passing is described using Send in which the sending and receiving roles are specified, together with the type of message being sent. Expressions are sequenced using a standard Let construct. This is possible by indexing Session by the type associated with individual expressions. The Let expression also leads to Do-notation through implementation of Idris’ monadic bind operator—(>>=). Sessions descriptions are concluded using End.

Figure 1(b) demonstrates use of Session to describe the well-known TCP-handshake [34]. The roles of “Alice” and “Bob” describe the client and server, and Packet describes the TCP messages themselves. Each send operation describes how Alice and Bob send the packet and sequence numbers in a tuple. However, our session description does not describe the value dependencies between the sequence numbers, nor which constructor of Packet should be sent. Specifically, we should be able to provide guarantees that the sequence numbers are incremented by one when they are returned to their originators.

The Let construct of Session allows binding of, and pattern matching on, message values to an identifier that can be reasoned about using standard Idris constructs. Figure 2(a) demonstrates how we can use these bound values to describe messages that rely on previously seen values. A dependent pair provides existential quantification that the type of Bob’s response to Alice contains the sequence number x incremented by one. Standard equality types (=) ensure this relation is available at the type-level. Similar use of dependent pairs ensures that the same incremented sequence number is returned to Bob, together with their sequence number y also incremented by one. However, our EDSL does not reason about message origin, nor who is aware of these values. Figure 2(b) demonstrates how we can insert a third participant “Charlie” into the protocol who can send a message to Alice whose type depends on a value that Charlie is not aware of. When specifying EDSLs for global session descriptions in a dependently typed language we must prevent roles from depending on values they are not aware of.

1.1 Contributions

Taking inspiration from Multi-Party Session Types we have been investigating how dependent types, as presented in Idris, can be used to design, implement, and reason about communicating systems. Existing work has presented a type-driven approach for designing and developing communicating concurrent systems [12]. A limitation in this work is not being able to specify value-dependencies on messages for multi-party protocols. This paper presents the initial outcomes of our research to address this limitation.

Resource-Dependent EDSLs are a common design pattern associated with EDSL construction in Idris [11, 10] derived from existing work on parameterised monads and Hoare monads [4, 7]. Such construction allows us to associate, and manage, an abstract state within the type of the EDSL itself. Using this construction we can index the type of our EDSL by a knowledge index that captures the messages seen by each participant. Using this index we ensure that value dependent messages are only sent by participants using values that the participant knows about.

Our main contributions are:

Sessions, a Resource-Dependent EDSL to specify global session descriptions. Sessions improves upon existing EDSL designs by introducing global session descriptions that are computable, composable, higher-order, and value-dependent. 2. 2.

Several example session descriptions that describe the TCP Handshake (Section 3.1), a multi-modal server providing echo and basic arithmetic operations (Section 3.2), and a higher-order session description that emulates an authentication interaction—Section 3.3.

Sessions has been realised using Idris, however, the construction techniques presented are agnostic to dependently typed languages. Other languages such as Agda [30] should be capable of realising this EDSL.

2 A Language for Describing Sessions

Figure 3 presents Sessions, our EDSL for specifying global session descriptions. Messages are represented using variables that have an associated abstract state that keeps track of roles that have seen the message. Central to the EDSLs operation is a parameterised monad that manages the set of variables and their abstract state: The Knowledge Index.

Knowledge Index

Figure 4(a) presents the various type-level data structures that make the knowledge index. Roles within our EDSL are represented as an indexed data type tagged with a descriptive name. The type Role is indexed by the type associated with roles to ensure that all roles are from the same family. This representation of roles is a marked difference from the naïve implementation presented in Figure 1(a). Tagging of roles with a string value provides role comparison and reuse of existing predicates for list quantification. Each message in a session description is represented by an indexed type Var, whose type is indexed by the type of the message being sent. During type checking Idris’ elaborator allows us to distinguish between different instances of Var based on their names and type-level values. The knowledge index itself is a list of state items. Items within our knowledge index associate a message type, with a variable, and a list of roles that are aware of the message. Standard list quantifiers, such as Any and All, help reason about the knowledge context itself, and such quantifiers allow construction of operations acting on knowledge index instances—see Figure 4(b).

Parameterised Type

Sessions is a resource dependent EDSL in which the program’s abstract state is the knowledge index. The parameters of Sessions form a Hoare monad [4, 7] where the resulting type-level state is dependent on the expression value: type—the expression’s return type; roleType—the underlying type for roles; participants—the set of roles involved in the protocol; old—the knowledge index in which the expression must operate; and new—a function that computes the resulting knowledge index that is dependent upon the result associated with the expression. A Let-binding allows us to sequence expressions, and bind message values to identifiers. Each expression describes how the knowledge index is affected by the result of the expression. When the result is not dependent on the expression value the function const (which drops its first parameter) allows one to state the new value. When sequencing expressions, together with result dependent changes, the value of the knowledge index will change dynamically as we step through a session description.

Message Creation

NewMsg and NewDepMsg are responsible for introducing message descriptions. The constructor NewMsg will introduce a message of type mType created by creator if creator was in the global set of participants ps. A list quantifier provides this guarantee. Creation of the message will extend the knowledge context with a new Item instance that populates the list of roles with creator. The constructor NewDepMsg will introduce a dependently typed message that depends on a previously seen value if said value is known to the message creator. This proof is provided by prfKnows, an instance of a list quantification that the predicate KnowsData holds for at least one element in the knowledge index. Figure 5 presents the definition for KnowsData that states the given role is an element in the list of roles associated with the given message. The parameter pred is a function that constructs the type of the message to be sent, with the actual returned message type being a dependent pair that details the value associated with dep that is passed to pred.

Sending Messages

The expression Send allows one to specify the type of message that is to be sent and which roles are sending and receiving the message. As with all the other expressions evidence must be given to ensure expression correctness. We require that both the sender and receiver are elements of ps, and that the sender knows the message to be sent—cf. predicates associated with dependent message creation. If a send is successfully described the knowledge index will be updated to add receiver to the list of roles that know about msg using the function update.

Accessing Values

By design Sessions forbids message descriptions to be bound to a value explicitly, as not all participants will know the value. However, if all participants in the protocol are aware of the message, then we can depend on the value. The expression Read facilitates this. The predicate AllKnow (presented in Figure 5) constructs an inductive proof that each role in the session has knowledge of the message. Section 3 presents an example of Read in action.

Recursion

Not all sessions comprise of a linear sequence of actions, interactions between roles may repeat. Rec and Call allow for recursively calling an already described session, and calling an external session. These functions are restricted such that the knowledge of the called session must begin and end with an empty context i.e. no knowledge is learned about the supplied session. A further restriction is on the set of participants respective to the calling function. For Rec the caller and callee must have the same set, while a call to Call must have overlapping sets. Here Overlapping is a thinning [2] that ensures elements of ps appear in order within ss. A thinning allows for structures to be weakened respective to some decision procedure [16, 3].

A Clean API

Separately, we provide a high-level API for protocol designers to use when specifying protocols. Without this API the proofs required for each expression have to be explicitly presented. We can use Idris’ auto implicit feature to automatically construct the proofs associated with an expression. Idris’ compiler will attempt to search and combine values, found in the expressions context, that together satisfy the type of the presented predicate. If a suitable value cannot be constructed the expression will fail to type-check. Figure 6 demonstrates this approach for the Send expression. Further, we can provide a function (Session) to describe the expected initial and final state of the knowledge index together with the final expression type such that the only expression that will satisfy the end conditions would be the End expression.

3 Example Sessions

This section considers the expressiveness of our EDSL by considering three protocol descriptions. The first example presents the TCP Handshake that demonstrates how we can construct value dependent message descriptions. The second example is a multi-modal server that demonstrates how we can compose protocol descriptions together and make interaction decisions based of message values. The final example demonstrates how we can construct higher-order protocols.

3.1 TCP Handshake

Figure 7 illustrates how the TCP handshake (presented earlier in Section 1) can be specified using Sessions. Central to operation of the handshake is the sending of two sequence numbers that have been correctly transformed. Within this example, Alice sends a non-dependently typed message (m1) to Bob that contains the initial packet and Alice’s sequence number. In response, Bob constructs a value dependent message (m2) that depends on the content of m1. The anonymous function states that m2 must have a type in which the second postion in the tuple is the sequence number from m1 incremented by one. Here the type Next is a type synonym for a dependent pair stating the transformation on the sequence number from m1. The final message sent by Alice (m3) is dependent on m2. Alice must send a packet together with the incremented sequence number from m2, and the second sequence number incremented by one. Recall that the type of m2 is a dependent pair in which the message type is in the second position and the dependend upon value is in the first. Therefore to access the underlying values we have to project into these pairs, and their contents, accordingly. Use of anonymous functions here does complicate the session description. Such complication can be resolved with named functions.

3.2 Multi-Modal Server

Figure 8 presents the complete specification of a global session description for interacting with a server that offers simple arithmetic calculations, and an echo service. Figure 8(a) presents the messages sent. Within this example: Alice represents the client; Bob the server; and Charlie a third-party for performing simple arithmetic. Figure 8(d) presents the top-level interactions between Alice and Bob. Alice sends a message of type CMD to Bob. Once Bob has received the message all participants specified in the top-level protocol have seen the value. This enables the Read expression to access the value, and allow case-splitting (analogous to offer and choice from MPST) to change behaviour based on the message’s value. If the command was: Math then we call the Maths protocol and loop—Figure 8(b); Echo then we call the Echo protocol and loop—Figure 8(c); or Quit then we end the interaction.

The doEcho protocol is a non-recursive implementation of RFC862/RFC347 [35, 33] in which Bob repeats the message Alice sent, back to Alice. We ensure this repetition of values using a dependent message with a predicate to reason about the sent value. Here Literal is a type-synonym for a dependent pair with an equality predicate. Note the use of Literal to ensure that the welcome message is the literal string value given. The doMath protocol allows Alice to send Bob simple arithmetic expressions (MathsCMD), that Bob sends to Charlie. Bob can use Charlie to generate a response to send to Alice.

3.3 Higher-Order Protocols

Figure 9 presents a Higher-Order Protocol, in which we treat session descriptions as first class constructs. Rather than explicitly calling a named description (cf. Figure 8(d)) we pass in descriptions as parameters. The predicate Overlapping ensures that the participants of body (the called description) overlap with those specified in HoppyServer. The description presented in Figure 9 presents a decision procedure reminiscent of an authentication procedure. Alice sends some message that is checked by Bob who responds with a decision, and the protocol’s next steps are based on that decision. This is not secure but nonetheless demonstrates the potential power of Sessions. We can construct protocol descriptions that are composable and higher-order.

4 Discussion

Sessions is an EDSL for describing global session descriptions within a dependently typed host language. We introduce value dependent messages and reason about messages within a paramterised monad. Construction of Sessions as a EDSL allows session descriptions to be first class, composable, and computable. Overriding Do notation facilitates use of Idris’ control structures to describe decisions. Here choice differs from branching/selection as traditionally seen in session type implementations. Sessions supports value based choice using pattern-matching on message values or constant values.

MPSTs can provide guarantees towards several protocol properties. Namely, session fidelity, communication safety, liveness, and progress [21, 22]. Many of these properties are for complete systems, Sessions describes global descriptions only. Existing work has shown a correct-by-construction approach to linking session descriptions to implementations within a dependently typed language [12]. Global descriptions are projected to compute the local type for the viewpoint of a protocol participant as a continuation. The type of the implementation is indexed by the continuation to ensure there is an intrinsic link between the specified global session description and its implementation. Thus providing communication safety and session fidelity. We are currently investigating how to build a similar framework that includes our value dependent session descriptions.

Further, Idris is a total language that checks for program termination and coverage of pattern matching clauses. Thus, our global session descriptions are checked for termination and coverage in the same way as regular Idris programs. We believe that implementing local types and implementations within a total language will help to provide guarantees towards liveness and progress.

5 Related Work

There are many implementations of Session Types available111http://simonjf.com/2016/05/28/session-type-implementations.html. Generally, there are three approaches to implementation either: as a DSL; as an EDSL; or as a language extension.

DSL

Scribble is a DSL for describing MPSTs [40]. The DSL is limited in describing non-value dependent message exchanges. There are various existing runtimes that generate code from these descriptions [29, 25, 15]. As Sessions is an EDSL the resulting specifications cannot not be directly resused by other projects222Idris does, however, support multiple code generation targets, however, embedding compiled Idris code into other code projects is non-trivial.. However, the library can be extended to generate Scribble specifications directly from the Session specification. StMungo is a Java oriented tool for generating local types from Scribble descriptions [25].

Scribble-Refined

Recent work [28] has extended Scribble specifically for F# to leverage the language’s support for refinement types  [18] and type providers [32]. The authors present an expressive refinement language to specify boolean refinements related to messages being sent. Sessions complements this work by showing an alternative realisation to reasoning about value messages.

EDSL

EDSLs have been realised for: Haskell [37, 31, 36]; Go [26]; and Rust [23]. These approaches follow our approach, however, the host language chosen is not as expressive in describing global session description and thus do not allow for reasoning on message descriptions.

Language Extension

Not all implementations follow the DSL approach. Others have extended existing programming languages to embedded MPST directly within the language. For example, Links and SIL [17, 27, 5]. However, these approaches require extending the language and compiler. Sessions presents an opportunity to develop the specification in the same language as the implementation without major changes required to the language itself.

MPST Theory

Our work in using a dependently typed language to realise value dependent global session descriptions compliments existing theoretical work [39, 38, 6]. Sessions achieves value-dependent session descriptions by maintaining a knowledge index. This compliments existing work [38, 28] in which the authors define knowledge in much the same way. However, we have embedded the knowledge index directly within the type-system of the global session description ensuring that our EDSL instances are correct-by-construction with respect to value dependencies. A Design-By-Contract approach has been taken to extend MPST with message oriented assertions [6]. We remark that the assertions associated with messages are comparable to the dependent pair construct in which the message (first position) must satisfy the predicate in the second position. Our use of dependent pair’s is different: the value in the first position presents evidence that the predicate (message) in the second position is valid.

6 Conclusion

Type systems in modern programming languages are expressive enough to support EDSLs describing session types. With the additional expressivity given by dependent types, we have shown that dependently typed languages such as Idris provide a natural setting to further enhance the expressiveness of EDSLs for describing global session descriptions.

Sessions demonstrates how we incorporate reasoning on value-dependencies between messages, and provide first-class global session descriptions. Idris’ auto implicit mechanism has proven useful in presenting correct-by-construction guarantees towards protocol design. With this new setting for global session design we expect to be able to use Idris’ type-system to verify additional correctness guarantees of our global descriptions. Especially properties required by security protocols [19, 24] where we also need to reason about the content of messages, and more importantly how messages are related.

Sessions is an EDSL for global session descriptions. We wish to compliment our EDSL with a complete system for protocol design, implementation, and verification such that we provide a self-contained system within a single language. Of importance will be how we can correctly project our descriptions to local types such that only correct local actions and knowledge are carried over.