Type-driven Development of Communicating Systems in Idris

Transcription

1 Type-driven Development of Communicating Systems in Idris Edwin Brady University of St Andrews, Scotland, Lambda World, October 1st 2016

2 Idris is a pure functional language with dependent types: Encourages Type-driven Development Totality checking In this talk: Total Functional Programming Termination and Productivity Total Functional Programming and Interaction A practical example: Type Safe Concurrency

3 What is Type-driven Development? Types as a plan for a program Write types first

4 What is Type-driven Development? Types as a plan for a program Write types first Define programs interactively Programs may contain holes Type checker directs programmer

5 What is Type-driven Development? Types as a plan for a program Write types first Define programs interactively Programs may contain holes Type checker directs programmer Refine type and program as necessary

6 What is Type-driven Development? Types as a plan for a program Write types first Define programs interactively Programs may contain holes Type checker directs programmer Refine type and program as necessary Process: Type, Define, Refine

7 Type-driven Development

8 Type-driven Development

9 Type-driven Development

10 Total Functional Programming A total function is a function which, for all well-typed inputs, either Terminates with a well-typed result Produces a finite prefix of a well-typed infinite result in finite time

11 Why do we care? If we care about types, we should care about totality Given f : T If f is total, we know that it will always give a result of type T If f is partial, we know that if it gives a result, it will be of type T Examples: Vectors and Streams

12 Why do we care? If we care about types, we should care about totality Given f : Theorem If f is total, we know that it will always give a result of type Theorem If f is partial, we know that if it gives a result, it will be of type Theorem??? Examples: Vectors and Streams

13 Totality Checking Idris checks: Coverage: patterns for all well-typed inputs Termination: there is a decreasing argument Productivity: recursive call is guarded by a constructor

14 Type-driven Development

15 Type-driven Development (thanks

16 Commercial Break

17 Interactive Programs in Idris Idris, like Haskell, uses IO for writing interactive programs A value of type IO ty is a description of an interactive action which results in a value of type ty Example: Sequencing IO Actions hello : IO () hello = do putstr "What is your name? " name <- getline putstr ("Hello " ++ name)

18 Interactive Programs in Idris Problem: we often want interactive programs to run indefinitely Example: Looping IO Actions loopy : IO () loopy = do putstr "What is your name? " name <- getline putstr ("Hello " ++ name) loopy -- Not total! Composing actions in a recursive function may not be total No structurally decreasing argument, in general

19 Interactive Total Functional Programs Solution: Describe looping programs as a stream of IO actions: data InfIO : Type where Do : IO a -> (a -> Inf InfIO) -> InfIO (>>=) : IO a -> (a -> Inf InfIO) -> InfIO (>>=) = Do

20 Interactive Total Functional Programs Then define a run function to execute those descriptions: run : InfIO -> IO ()

21 Interactive Total Functional Programs Then define a run function to execute those descriptions: run : InfIO -> IO () Compare with IO: IO ty is a description of actions which result in a ty The run-time system executes those actions run on InfIO does a similar job, at a different level

22 Example: Concurrency The Idris run-time system supports message passing concurrency A process can spawn another process A process can create a Channel, using: connect, which initiates a connection to another process listen, which waits for incoming connections Processes can send and receive messages on a Channel

23 Message Passing Concurrency in Idris

24 Message Passing Concurrency in Idris To write correct concurrent programs in this style, we d like to ensure, at least: Requests (like Add 2 3) and Responses (like 5) are well-typed w.r.t. each other Server processes (like Adder) run indefinitely That is, they are productive Server processes always complete responses to requests That is, processing a response terminates

25 Server Processes

26 Types for Message Passing We can achieve this with types: Define a type for Requests Define a function to calculate Response types from requests This describes valid message types for interactions between processes

27 Types for Message Passing We can achieve this with types: Define a type for Requests Define a function to calculate Response types from requests This describes valid message types for interactions between processes Define a type for servers, parameterised by the Request and Response types it services This defines the type of messages we can send to a process Like InfIO, a process is an infinite sequence of commands Like InfIO, it guarantees productivity Processes run indefinitely, and always complete requests

28 Types for Message Passing Adder Requests/Responses data Request = Add Nat Nat Response : Request -> Type Response (Add x y) = Nat Adder Implementation adder : ServerLoop Response () adder = do Accept (\msg => case msg of Add x y => Pure (x + y)) Loop adder

29 Demonstration Concurrent Processes in Action

30 Further Reading On total functional programming: David Turner, Elementary Strong Functional Programming, 2005 On interactive programming with dependent types Peter Hancock and Anton Setzer, Interactive Programs in Dependent Type Theory, 2000 On types for communicating systems: Kohei Honda, Types for Dyadic Interaction, 1993 Kohei Honda, Nobuko Yoshida, Marco Carbone, Multiparty Asynchronous Session Types, 2008 Philip Wadler, Propositions as Sessions, 2012

31 Summary Total programs are either terminating or productive Together, this allows us to write long running processes, where every request is processed in finite time A useful pattern for concurrent programming is to: Define server processes which respond to requests Write programs as a collection of client processes, making remote procedure calls to servers We can define long running, well typed, concurrent processes as potentially infinite streams of commands Using dependent types (in particular, first class functions), we ve described simple message passing protocols

32