Witnessing Purity, Constancy and Mutability APLAS Ben Lippmeier Australian National University 2009/12/14
|
|
|
- Calvin Doyle
- 5 years ago
- Views:
Transcription
1 Witnessing Purity, Constancy and Mutability APLAS 2009 Ben Lippmeier Australian National University 2009/12/14
2 The hidden cost of state monads map :: (a -> b) -> List a -> List b map f xs = case xs of Nil -> Nil Cons x xs -> Cons (f x) (map f xs)
3 The hidden cost of state monads map :: (a -> b) -> List a -> List b map f xs = case xs of Nil -> Nil Cons x xs -> Cons (f x) (map f xs) mapio :: (a -> IO b) -> List a -> IO (List b) mapio f xs = case xs of Nil -> return Nil Cons x xs -> do x <- f x xs <- mapio f xs return (Cons x xs )
4 The hidden cost of state monads We need two copies of every higher order function. It is possible to derive the non-monadic version from the monadic one, but in practice people rarely do. Library writers tend not to provide both versions.
5 Functions from Data.Map adjust :: Ord k => (a -> a) -> k -> Map k a -> Map k a mapwithkey :: (k -> a -> b) -> Map k a -> Map k b mapaccumwithkey :: (a -> k -> b -> (a, c)) -> a -> Map k b -> (a, Map k c) The library doesn t provide monadic versions of any of these functions...
6 Haskell lacks mutability polymorphism data List a = Nil Cons a (List a)
7 Haskell lacks mutability polymorphism data List a = Nil Cons a (List a) data MList a = MNil MCons a (IORef (MList a))
8 Haskell lacks mutability polymorphism data List a = Nil Cons a (List a) data MList a = MNil MCons a (IORef (MList a)) data MList2 a = MNil2 MCons2 (IORef a) (MList2 a)
9 Haskell lacks mutability polymorphism data List a = Nil Cons a (List a) data MList a = MNil MCons a (IORef (MList a)) data MList2 a = MNil2 MCons2 (IORef a) (MList2 a) data MList3 a = MNil3 MCons3 (IORef a) (IORef (MList3 a))
10 Haskell lacks mutability polymorphism data List a = Nil Cons a (List a) data MList a = MNil MCons a (IORef (MList a)) data MList2 a = MNil2 MCons2 (IORef a) (MList2 a) data MList3 a = MNil3 MCons3 (IORef a) (IORef (MList3 a)) These four data types are all incompatible. How many times do you want to rewrite the definitions of length, map, and fold?
11 The Plan Use region typing, effect typing, and type classes to introduce effect and mutability polymorphism. Re-use the syntax and other features of Haskell. Types become complex, but can be inferred. We usually don t write the following signatures in source programs.
12 The type of updateint updateint :: Int -> Int -> () updateint uses the value of the second argument to overwrite the value of the first.
13 The type of updateint updateint :: Int r1 -> Int r2 -> () updateint uses the value of the second argument to overwrite the value of the first. Region variables name what part of the store the arguments are located in.
14 The type of updateint updateint :: forall (r1, r2 : region). Int r1 -> Int r2 -> () updateint uses the value of the second argument to overwrite the value of the first. Region variables name what part of the store the arguments are located in.
15 The type of updateint updateint :: forall (r1, r2 : region). Int r1 -> Int r2 -(e1)> () :- e1 = Read r2 \/ Write r1 updateint uses the value of the second argument to overwrite the value of the first. Region variables name what part of the store the arguments are located in. When it is called it reads its second argument and writes to the first.
16 Mutability constraints updateint :: forall (r1, r2 : region). Mutable r1 => Int r1 -> Int r2 -(e1)> () :- e1 = Read r2 \/ Write r1 An object in region r1 is being updated, so that region must be Mutable.
17 Mutability constraints updateint :: forall (r1, r2 : region). Mutable r1 => Int r1 -> Int r2 -(e1)> () :- e1 = Read r2 \/ Write r1 An object in region r1 is being updated, so that region must be Mutable. Mutable r1 is a region class. (like a type class) To call updateint we must pass a witness to the fact that r1 really does support mutability.
18 Comparison with type classes notequal :: Eq a => a -> a -> Bool To call notequal, we must pass a dictionary containing an equality operator for values of type a. A dictionary is evidence that a type supports a particular operation (equality in this case). In contrast, the evidence for the mutability of a region exists at type level, and is erased during code generation.
19 swap :: Int -> Int -> () swap = \ (x : Int). \ (y : Int). let tmp = 0 _ = updateint tmp x _ = updateint x y _ = updateint y tmp in ()
20 swap :: Int r1 -> Int r2 -> () swap = \ (x : Int r1). \ (y : Int r2). let tmp = 0 _ = updateint tmp x _ = updateint x y _ = updateint y tmp in ()
21 swap :: Int r1 -> Int r2 -(e1)> () :- e1 = Read r1 \/ Read r2 \/ Write r1 \/ Write r2 swap = \ (x : Int r1). \ (y : Int r2). let tmp = 0 _ = updateint tmp x _ = updateint x y _ = updateint y tmp in ()
22 swap :: forall (r1, r2 : region). Int r1 -> Int r2 -(e1)> () :- e1 = Read r1 \/ Read r2 \/ Write r1 \/ Write r2 swap = \ (x : Int r1). \ (y : Int r2). let tmp = 0 _ = updateint tmp x _ = updateint x y _ = updateint y tmp in ()
23 swap :: forall (r1, r2 : region). Int r1 -> Int r2 -(e1)> () :- e1 = Read r1 \/ Read r2 \/ Write r1 \/ Write r2 swap = /\ (r1, r2 : region). \ (x : Int r1). \ (y : Int r2). let tmp = 0 _ = updateint tmp x _ = updateint x y _ = updateint y tmp in ()
24 swap :: forall (r1, r2 : region). Int r1 -> Int r2 -(e1)> () :- e1 = Read r1 \/ Read r2 \/ Write r1 \/ Write r2 swap = /\ (r1, r2 : region). \ (x : Int r1). \ (y : Int r2). let tmp = 0 _ = updateint tmp x _ = updateint x y _ = updateint y tmp in () updateint :: forall (r1, r2 : region). Mutable r1 => Int r1 -> Int r2 -(e1)> () :- e1 = Read r2 \/ Write r1
25 swap :: forall (r1, r2 : region). Int r1 -> Int r2 -(e1)> () :- e1 = Read r1 \/ Read r2 \/ Write r1 \/ Write r2 swap = /\ (r1, r2 : region). \ (x : Int r1). \ (y : Int r2). let tmp = 0 _ = updateint?????? tmp x _ = updateint?????? x y _ = updateint?????? y tmp in () updateint :: forall (r1, r2 : region). Mutable r1 => Int r1 -> Int r2 -(e1)> () :- e1 = Read r2 \/ Write r1
26 swap :: forall (r1, r2 : region). Int r1 -> Int r2 -(e1)> () :- e1 = Read r1 \/ Read r2 \/ Write r1 \/ Write r2 swap = /\ (r1, r2 : region). \ (x : Int r1). \ (y : Int r2). let tmp = 0 _ = updateint?? r1?? tmp x _ = updateint r1 r2?? x y _ = updateint r2???? y tmp in () updateint :: forall (r1, r2 : region). Mutable r1 => Int r1 -> Int r2 -(e1)> () :- e1 = Read r2 \/ Write r1
27 swap :: forall (r1, r2 : region). Int r1 -> Int r2 -(e1)> () :- e1 = Read r1 \/ Read r2 \/ Write r1 \/ Write r2 swap = /\ (r1, r2 : region). \ (x : Int r1). \ (y : Int r2). letregion r3 in let tmp = 0 r3 _ = updateint r3 r1?? tmp x _ = updateint r1 r2?? x y _ = updateint r2 r3?? y tmp in () updateint :: forall (r1, r2 : region). Mutable r1 => Int r1 -> Int r2 -(e1)> () :- e1 = Read r2 \/ Write r1
28 swap :: forall (r1, r2 : region). Mutable r1 => Mutable r2 => Int r1 -> Int r2 -(e1)> () :- e1 = Read r1 \/ Read r2 \/ Write r1 \/ Write r2 swap = /\ (r1, r2 : region). /\ (w1 : Mutable r1). /\ (w2 : Mutable r2). \ (x : Int r1). \ (y : Int r2). letregion r3 in let tmp = 0 r3 _ = updateint r3 r1?? tmp x _ = updateint r1 r2 w1 x y _ = updateint r2 r3 w2 y tmp in () updateint :: forall (r1, r2 : region). Mutable r1 => Int r1 -> Int r2 -(e1)> () :- e1 = Read r2 \/ Write r1
29 swap :: forall (r1, r2 : region). Mutable r1 => Mutable r2 => Int r1 -> Int r2 -(e1)> () :- e1 = Read r1 \/ Read r2 \/ Write r1 \/ Write r2 swap = /\ (r1, r2 : region). /\ (w1 : Mutable r1). /\ (w2 : Mutable r2). \ (x : Int r1). \ (y : Int r2). letregion r3 with w3 = MkMutable r3 in let tmp = 0 r3 _ = updateint r3 r1 w3 tmp x _ = updateint r1 r2 w1 x y _ = updateint r2 r3 w2 y tmp in () MkMutable :: PI(r : region). Mutable r
30 Suspension suspend :: forall (a, b : type) (e1 : effect). Pure e1 => (a -(e1)> b) -> a -> b The language is call-by-value by default. Laziness can be introduced with the suspend operator. Only pure functions can be suspended. Any read effects must involve constant regions.
31 Creating witnesses of purity suspend :: forall (a, b :: type) (e1 :: effect). Pure e1 => (a -(e1)> b) -> a -> b MkPurify :: PI(r : region). Const r -> Pure (Read r) MkPureJoin :: PI(e1, e2 : effect). Pure e1 -> Pure e2 -> Pure (e1 \/ e2) Type level combinators build witnesses to the purity of an effect from witnesses to the constancy of regions.
32 maplazy :: (a -> b) -> List a -> List b
33 maplazy :: (a -> b) -> List r1 a -> List r2 b
34 maplazy :: (a -(e1)> b) -> List r1 a -(e2)> List r2 b :- e2 = Read r1 \/ e1
35 maplazy :: Pure e1 => (a -(e1)> b) -> List r1 a -(e2)> List r2 b :- e2 = Read r1 \/ e1
36 maplazy :: Pure e1 => Const r1 => (a -(e1)> b) -> List r1 a -(e2)> List r2 b :- e2 = Read r1 \/ e1
37 maplazy :: forall (a, b : type) (r1, r2 : region) (e1 : effect). Pure e1 => Const r1 => (a -(e1)> b) -> List r1 a -(e2)> List r2 b :- e2 = Read r1 \/ e1
38 maplazy = \ (f : a -> b). \ (xx : List a). case xx of Nil -> Nil Cons x xs -> let x = f x mapl = maplazy f xs = suspend mapl xs in Cons x xs
39 maplazy = \ (f : a -(e1)> b). \ (xx : List r1 a). case xx of Nil -> Nil Cons x xs -> let x = f x mapl = maplazy f xs = suspend mapl xs in Cons x xs
40 maplazy = /\ (a, b : type) (r1, r2 : region) (e1 : effect) \ (f : a -(e1)> b). \ (xx : List r1 a). case xx of Nil -> Nil Cons x xs -> let x = f x mapl = maplazy f xs = suspend mapl xs in Cons x xs
41 maplazy = /\ (a, b : type) (r1, r2 : region) (e1 : effect) \ (f : a -(e1)> b). \ (xx : List r1 a). case xx of Nil -> Nil b r2 Cons x xs -> let x = f x mapl = maplazy a b r1 r2 e1 f xs = suspend mapl xs in Cons b r2 x xs
42 maplazy = /\ (a, b : type) (r1, r2 : region) (e1 : effect) \ (f : a -(e1)> b). \ (xx : List r1 a). case xx of Nil -> Nil b r2 Cons x xs -> let x = f x mapl = maplazy a b r1 r2 e1 f xs = suspend mapl xs in Cons b r2 x xs suspend :: forall (a, b : type) (e1 : effect). Pure e1 => (a -(e1)> b) -> a -> b
43 maplazy = /\ (a, b : type) (r1, r2 : region) (e1 : effect) \ (f : a -(e1)> b). \ (xx : List r1 a). case xx of Nil -> Nil b r2 Cons x xs -> let x = f x mapl = maplazy a b r1 r2 e1 f xs = suspend???????? mapl xs in Cons b r2 x xs suspend :: forall (a, b : type) (e1 : effect). Pure e1 => (a -(e1)> b) -> a -> b
44 maplazy = /\ (a, b : type) (r1, r2 : region) (e1 : effect) \ (f : a -(e1)> b). \ (xx : List r1 a). case xx of Nil -> Nil b r2 Cons x xs -> let x = f x mapl = maplazy a b r1 r2 e1 f xs = suspend (List r1 a) (List r2 b)???? mapl xs in Cons b r2 x xs suspend :: forall (a, b : type) (e1 : effect). Pure e1 => (a -(e1)> b) -> a -> b
45 maplazy = /\ (a, b : type) (r1, r2 : region) (e1 : effect) \ (f : a -(e1)> b). \ (xx : List r1 a). Read r1 case xx of Nil -> Nil b r2 Cons x xs -> e1 let x = f x mapl = maplazy a b r1 r2 e1 f xs = suspend (List r1 a) (List r2 b)???? mapl xs in Cons b r2 x xs suspend :: forall (a, b : type) (e1 : effect). Pure e1 => (a -(e1)> b) -> a -> b
46 maplazy = /\ (a, b : type) (r1, r2 : region) (e1 : effect) \ (f : a -(e1)> b). \ (xx : List r1 a). Read r1 case xx of Nil -> Nil b r2 Cons x xs -> e1 let x = f x mapl = maplazy a b r1 r2 e1 f xs = suspend (List r1 a) (List r2 b) (Read r1 \/ e1)?? mapl xs in Cons b r2 x xs suspend :: forall (a, b : type) (e1 : effect). Pure e1 => (a -(e1)> b) -> a -> b
47 maplazy = /\ (a, b : type) (r1, r2 : region) (e1 : effect) \ (f : a -(e1)> b). \ (xx : List r1 a). case xx of Nil -> Nil b r2 Cons x xs -> let x = f x mapl = maplazy a b r1 r2 e1 f xs = suspend (List r1 a) (List r2 b) (Read r1 \/ e1)?? mapl xs in Cons b r2 x xs suspend :: forall (a, b : type) (e1 : effect). Pure e1 => (a -(e1)> b) -> a -> b
48 maplazy = /\ (a, b : type) (r1, r2 : region) (e1 : effect). /\ (w1 : Pure e1). /\ (w2 : Const r1). \ (f : a -(e1)> b). \ (xx : List r1 a). case xx of Nil -> Nil b r2 Cons x xs -> let x = f x mapl = maplazy a b r1 r2 e1 w1 w2 f xs = suspend (List r1 a) (List r2 b) (Read r1 \/ e1)?? mapl xs in Cons b r2 x xs suspend :: forall (a, b : type) (e1 : effect). Pure e1 => (a -(e1)> b) -> a -> b
49 maplazy = /\ (a, b : type) (r1, r2 : region) (e1 : effect) /\ (w1 : Pure e1). /\ (w2 : Const r1). \ (f : a -(e1)> b). \ (xx : List r1 a). case xx of Nil -> Nil b r2 Cons x xs -> let x = f x mapl = maplazy a b r1 r2 e1 w1 w2 f xs = suspend (List r1 a) (List r2 b) (Read r1 \/ e1) (MkPureJoin (Read r1) e1 (MkPurify r1 w2) w1) mapl xs in Cons b r2 x xs suspend :: forall (a, b : type) (e1 : effect). Pure e1 => (a -(e1)> b) -> a -> b
50 In the paper: Formal definition of core language Dynamic semantics Typing rules Soundness theorem
51 Implemented In the Disciplined Disciple Compiler (0.1.2) Download from research prototype -- help gladly accepted.
52 Questions?
Witnessing Purity, Constancy and Mutability
Witnessing Purity, Constancy and Mutability Ben Lippmeier School of Computer Science Australian National University Ben.Lippmeier@anu.edu.au Abstract. Restricting destructive update to values of a distinguished
Haskell Introduction Lists Other Structures Data Structures. Haskell Introduction. Mark Snyder
Outline 1 2 3 4 What is Haskell? Haskell is a functional programming language. Characteristics functional non-strict ( lazy ) pure (no side effects*) strongly statically typed available compiled and interpreted
Software System Design and Implementation
Software System Design and Implementation Controlling Effects Gabriele Keller The University of New South Wales School of Computer Science and Engineering Sydney, Australia COMP3141 18s1 Examples of effects
Simon Peyton Jones Microsoft Research August 2012
Simon Peyton Jones Microsoft Research August 2012 A functional language Purely functional Lazy Statically typed Designed 1988-1990 By a committee For research, teaching, and practical use Geeks Practitioners
Logic - CM0845 Introduction to Haskell
Logic - CM0845 Introduction to Haskell Diego Alejandro Montoya-Zapata EAFIT University Semester 2016-1 Diego Alejandro Montoya-Zapata (EAFIT University) Logic - CM0845 Introduction to Haskell Semester
Advanced Functional Programming
Advanced Functional Programming Tim Sheard Portland State University Lecture 2: More about Type Classes Implementing Type Classes Higher Order Types Multi-parameter Type Classes Tim Sheard 1 Implementing
Overloading, Type Classes, and Algebraic Datatypes
Overloading, Type Classes, and Algebraic Datatypes Delivered by Michael Pellauer Arvind Computer Science and Artificial Intelligence Laboratory M.I.T. September 28, 2006 September 28, 2006 http://www.csg.csail.mit.edu/6.827
CS 11 Haskell track: lecture 1
CS 11 Haskell track: lecture 1 This week: Introduction/motivation/pep talk Basics of Haskell Prerequisite Knowledge of basic functional programming e.g. Scheme, Ocaml, Erlang CS 1, CS 4 "permission of
Towards Reasoning about State Transformer Monads in Agda. Master of Science Thesis in Computer Science: Algorithm, Language and Logic.
Towards Reasoning about State Transformer Monads in Agda Master of Science Thesis in Computer Science: Algorithm, Language and Logic Viet Ha Bui Department of Computer Science and Engineering CHALMERS
Informatics 1 Functional Programming Lecture 7. Map, filter, fold. Don Sannella University of Edinburgh
Informatics 1 Functional Programming Lecture 7 Map, filter, fold Don Sannella University of Edinburgh Part I Map Squares *Main> squares [1,-2,3] [1,4,9] squares :: [Int] -> [Int] squares xs [ x*x x
Imperative languages
Imperative languages Von Neumann model: store with addressable locations machine code: effect achieved by changing contents of store locations instructions executed in sequence, flow of control altered
The practice of Mezzo
The practice of Mezzo François Pottier INRIA IHP, April 2014 1 / 83 Acknowledgements Jonathan Protzenko, Thibaut Balabonski, Henri Chataing, Armaël Guéneau, Cyprien Mangin 2 / 83 Overview Two lectures
Functional Logic Programming Language Curry
Functional Logic Programming Language Curry Xiang Yin Department of Computer Science McMaster University November 9, 2010 Outline Functional Logic Programming Language 1 Functional Logic Programming Language
CSCI-GA Scripting Languages
CSCI-GA.3033.003 Scripting Languages 12/02/2013 OCaml 1 Acknowledgement The material on these slides is based on notes provided by Dexter Kozen. 2 About OCaml A functional programming language All computation
M-Structures (Continued)
M-Structures (Continued) plus Introduction to the I/O Monad Arvind Computer Science and Artificial Intelligence Laboratory M.I.T. October 24, 2006 October 24, 2006 http://www.csg.csail.mit.edu/6.827 L12-1
n n Try tutorial on front page to get started! n spring13/ n Stack Overflow!
Announcements n Rainbow grades: HW1-6, Quiz1-5, Exam1 n Still grading: HW7, Quiz6, Exam2 Intro to Haskell n HW8 due today n HW9, Haskell, out tonight, due Nov. 16 th n Individual assignment n Start early!
CSC312 Principles of Programming Languages : Functional Programming Language. Copyright 2006 The McGraw-Hill Companies, Inc.
CSC312 Principles of Programming Languages : Functional Programming Language Overview of Functional Languages They emerged in the 1960 s with Lisp Functional programming mirrors mathematical functions:
Introduction to Haskell
Introduction to Haskell Matt Mullins Texas A&M Computing Society October 6, 2009 Matt Mullins (TACS) Introduction to Haskell October 6, 2009 1 / 39 Outline Introduction to Haskell Functional Programming
Programming with Math and Logic
.. Programming with Math and Logic an invitation to functional programming Ed Morehouse Wesleyan University The Plan why fp? terms types interfaces The What and Why of Functional Programming Computing
Type-indexed functions in Generic Haskell
Type-indexed functions in Generic Haskell Johan Jeuring September 15, 2004 Introduction Today I will talk about: a Types of polymorphism. b Type-indexed functions. c Dependencies. Read about b, and c in
Software System Design and Implementation
Software System Design and Implementation Functional Programming Gabriele Keller The University of New South Wales School of Computer Science and Engineering Sydney, Australia COMP3141 16s1 Course software
Optimising Functional Programming Languages. Max Bolingbroke, Cambridge University CPRG Lectures 2010
Optimising Functional Programming Languages Max Bolingbroke, Cambridge University CPRG Lectures 2010 Objectives Explore optimisation of functional programming languages using the framework of equational
The design of a programming language for provably correct programs: success and failure
The design of a programming language for provably correct programs: success and failure Don Sannella Laboratory for Foundations of Computer Science School of Informatics, University of Edinburgh http://homepages.inf.ed.ac.uk/dts
Advanced Type System Features Tom Schrijvers. Leuven Haskell User Group
Advanced Type System Features Tom Schrijvers Leuven Haskell User Group Data Recursion Genericity Schemes Expression Problem Monads GADTs DSLs Type Type Families Classes Lists and Effect Free Other Handlers
GADTs. Wouter Swierstra and Alejandro Serrano. Advanced functional programming - Lecture 7. [Faculty of Science Information and Computing Sciences]
![GADTs. Wouter Swierstra and Alejandro Serrano. Advanced functional programming - Lecture 7. [Faculty of Science Information and Computing Sciences]](/thumbs/78/76904283.jpg "GADTs. Wouter Swierstra and Alejandro Serrano. Advanced functional programming - Lecture 7. [Faculty of Science Information and Computing Sciences]")
GADTs Advanced functional programming - Lecture 7 Wouter Swierstra and Alejandro Serrano 1 Today s lecture Generalized algebraic data types (GADTs) 2 A datatype data Tree a = Leaf Node (Tree a) a (Tree
GADTs. Alejandro Serrano. AFP Summer School. [Faculty of Science Information and Computing Sciences]
![GADTs. Alejandro Serrano. AFP Summer School. [Faculty of Science Information and Computing Sciences]](/thumbs/95/124893351.jpg "GADTs. Alejandro Serrano. AFP Summer School. [Faculty of Science Information and Computing Sciences]")
GADTs AFP Summer School Alejandro Serrano 1 Today s lecture Generalized algebraic data types (GADTs) 2 A datatype data Tree a = Leaf Node (Tree a) a (Tree a) This definition introduces: 3 A datatype data
Lazy Functional Programming in Haskell
Lazy Functional Programming in Haskell David Raymond Christiansen 25 November, 2013 What is Haskell? 2 What is Haskell? Pure functional language: no side effects 2 What is Haskell? Pure functional language:
Background Type Classes (1B) Young Won Lim 6/28/18
Background Type Classes (1B) Copyright (c) 2016-2017 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2
Pierce Ch. 3, 8, 11, 15. Type Systems
Pierce Ch. 3, 8, 11, 15 Type Systems Goals Define the simple language of expressions A small subset of Lisp, with minor modifications Define the type system of this language Mathematical definition using
An overview of Mezzo
An overview of Mezzo François Pottier INRIA Bertinoro, June 2015 1 / 91 Acknowledgements Jonathan Protzenko, Thibaut Balabonski, Henri Chataing, Armaël Guéneau, Cyprien Mangin 2 / 91 What is Mezzo? An
Type Soundness and Race Freedom for Mezzo
Type Soundness and Race Freedom for Mezzo Thibaut Balabonski François Pottier Jonathan Protzenko INRIA FLOPS 2014 1 / 42 Mezzo in a few words Mezzo is a high-level programming language, equipped with:
Advanced Programming Handout 7. Monads and Friends (SOE Chapter 18)
Advanced Programming Handout 7 Monads and Friends (SOE Chapter 18) The Type of a Type In previous chapters we discussed: Monomorphic types such as Int, Bool, etc. Polymorphic types such as [a], Tree a,
Lecture #13: Type Inference and Unification. Typing In the Language ML. Type Inference. Doing Type Inference
Lecture #13: Type Inference and Unification Typing In the Language ML Examples from the language ML: fun map f [] = [] map f (a :: y) = (f a) :: (map f y) fun reduce f init [] = init reduce f init (a ::
PROGRAMMING IN HASKELL. Chapter 2 - First Steps
PROGRAMMING IN HASKELL Chapter 2 - First Steps 0 The Hugs System Hugs is an implementation of Haskell 98, and is the most widely used Haskell system; The interactive nature of Hugs makes it well suited
CSE Programming Languages Midterm - Winter 2010
CSE 341 - Programming Languages Midterm - Winter 2010 Your Name: Open book and notes. No laptop computers, PDAs, internet-equipped cellphones, or similar devices. Please answer the problems on the exam
The Mezzo case. Jonathan Protzenko. François Pottier FSFMA'13. Why design a new programming language?
Why design a new programming language? The Mezzo case François Pottier francois.pottier@inria.fr Jonathan Protzenko jonathan.protzenko@inria.fr INRIA FSFMA'13 Jonathan Protzenko (INRIA) The Mezzo language
Instances for Free* Neil Mitchell (* Postage and packaging charges may apply)
Instances for Free* Neil Mitchell www.cs.york.ac.uk/~ndm (* Postage and packaging charges may apply) Haskell has type classes f :: Eq a => a -> a -> Bool f x y = x == y Polymorphic (for all type a) Provided
Haskell: From Basic to Advanced. Part 2 Type Classes, Laziness, IO, Modules
Haskell: From Basic to Advanced Part 2 Type Classes, Laziness, IO, Modules Qualified types In the types schemes we have seen, the type variables were universally quantified, e.g. ++ :: [a] -> [a] -> [a]
An introduction to functional programming. July 23, 2010
An introduction to functional programming July 23, 2010 About Outline About About What is functional programming? What is? Why functional programming? Why? is novel. is powerful. is fun. About A brief
Programming Languages. Thunks, Laziness, Streams, Memoization. Adapted from Dan Grossman s PL class, U. of Washington
Programming Languages Thunks, Laziness, Streams, Memoization Adapted from Dan Grossman s PL class, U. of Washington You ve been lied to Everything that looks like a function call in Racket is not necessarily
Fastest Lambda First. Neil Mitchell.
Fastest Lambda First λ Neil Mitchell www.cs.york.ac.uk/~ndm/ The Problem Count the number of lines in a file = 0 test = 1 test\n = 1 test\ntest = 2 Read from the console Using getchar only No buffering
CSE 130: Programming Languages. Polymorphism. Ranjit Jhala UC San Diego
CSE 130: Programming Languages Polymorphism Ranjit Jhala UC San Diego Q: What is the value of res? let f g = let x = 0 in g 2 let x = 100 let h y = x + y let res = f h (a) 0 (b) 2 (c) 100 (d) 102 (e) 12
Transforming Functional Logic Programs into Monadic Functional Programs
Transforming Functional Logic Programs into Monadic Functional Programs Bernd Braßel Sebastian Fischer Michael Hanus Fabian Reck Institut für Informatik, CAU Kiel, D-24098 Kiel, Germany {bbr sebf mh fre}@informatik.uni-kiel.de
Principles of Programming Languages
Principles of Programming Languages h"p://www.di.unipi.it/~andrea/dida2ca/plp- 14/ Prof. Andrea Corradini Department of Computer Science, Pisa Introduc;on to Hakell Lesson 27! 1 The origins: ML programming
Introduction to ML. Based on materials by Vitaly Shmatikov. General-purpose, non-c-like, non-oo language. Related languages: Haskell, Ocaml, F#,
Introduction to ML Based on materials by Vitaly Shmatikov slide 1 ML General-purpose, non-c-like, non-oo language Related languages: Haskell, Ocaml, F#, Combination of Lisp and Algol-like features (1958)
Haskell Refresher Informatics 2D
Haskell Purely functional! : Everything is a function Haskell Refresher Informatics 2D Kobby. K.A. Nuamah 30 January 2015 Main topics: Recursion Currying Higher-order functions List processing functions
Type-Safe Observable Sharing in Haskell
Type-Safe Observable Sharing in Haskell Andy Gill The University of Kansas September 3, 2009 Andy Gill (The University of Kansas) Type-Safe Observable Sharing in Haskell September 3, 2009 1 / 27 Domain
Stream Fusion. Wouter Swierstra 30/11/2010
Stream Fusion Wouter Swierstra 30/11/2010 1 Exercise: Write a function that sums the square of all the odd integers between two arguments m and n. 2 Haskell solution f : (Int,Int) -> Int f = sum. map square.
Haskell Overview III (3A) Young Won Lim 10/4/16
(3A) Copyright (c) 2016 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published
Extended Static Checking for Haskell (ESC/Haskell)
Extended Static Checking for Haskell (ESC/Haskell) Dana N. Xu University of Cambridge advised by Simon Peyton Jones Microsoft Research, Cambridge Program Errors Give Headache! Module UserPgm where f ::
Programming in Haskell Aug-Nov 2015
Programming in Haskell Aug-Nov 2015 LECTURE 14 OCTOBER 1, 2015 S P SURESH CHENNAI MATHEMATICAL INSTITUTE Enumerated data types The data keyword is used to define new types data Bool = False True data Day
IA014: Advanced Functional Programming
IA014: Advanced Functional Programming 8. GADT Generalized Algebraic Data Types (and type extensions) Jan Obdržálek obdrzalek@fi.muni.cz Faculty of Informatics, Masaryk University, Brno Motivation IA014
CS 320: Concepts of Programming Languages
CS 320: Concepts of Programming Languages Wayne Snyder Computer Science Department Boston University Lecture 03: Bare-Bones Haskell Continued: o Function Application = Rewriting by Pattern Matching o Haskell
Haskell Types, Classes, and Functions, Currying, and Polymorphism
1 CSCE 314: Programming Languages Dr. Flemming Andersen Haskell Types, Classes, and Functions, Currying, and Polymorphism 2 Types A type is a collection of related values. For example, Bool contains the
Structural polymorphism in Generic Haskell
Structural polymorphism in Generic Haskell Andres Löh andres@cs.uu.nl 5 February 2005 Overview About Haskell Genericity and other types of polymorphism Examples of generic functions Generic Haskell Overview
GADTs. Wouter Swierstra. Advanced functional programming - Lecture 7. Faculty of Science Information and Computing Sciences
GADTs Advanced functional programming - Lecture 7 Wouter Swierstra 1 Today s lecture Generalized algebraic data types (GADTs) 2 A datatype data Tree a = Leaf Node (Tree a) a (Tree a) This definition introduces:
Functional Programming Mid-term exam Tuesday 3/10/2017
Functional Programming Mid-term exam Tuesday 3/10/2017 Name: Student number: Before you begin: Do not forget to write down your name and student number above. If necessary, explain your answers in English.
Talen en Compilers. Jurriaan Hage , period 2. November 13, Department of Information and Computing Sciences Utrecht University
Talen en Compilers 2017-2018, period 2 Jurriaan Hage Department of Information and Computing Sciences Utrecht University November 13, 2017 1. Introduction 1-1 This lecture Introduction Course overview
Programming in Omega Part 1. Tim Sheard Portland State University
Programming in Omega Part 1 Tim Sheard Portland State University Tim Sheard Computer Science Department Portland State University Portland, Oregon PSU PL Research at Portland State University The Programming
Introduction. chapter Functions
chapter 1 Introduction In this chapter we set the stage for the rest of the book. We start by reviewing the notion of a function, then introduce the concept of functional programming, summarise the main
Solution sheet 1. Introduction. Exercise 1 - Types of values. Exercise 2 - Constructors
Solution sheet 1 Introduction Please note that there can be other solutions than those listed in this document. This is a literate Haskell file which is available as PDF, as well as literate Haskell source
Simon Peyton Jones Microsoft Research August 2013
Simon Peyton Jones Microsoft Research August 2013 reverse :: a. [a] -> [a] xs :: [Bool] foo :: [Bool] foo = reverse xs Instantiate reverse with a unification variable, standing for an as-yet-unknown type.
Exercise 1 (2+2+2 points)
1 Exercise 1 (2+2+2 points) The following data structure represents binary trees only containing values in the inner nodes: data Tree a = Leaf Node (Tree a) a (Tree a) 1 Consider the tree t of integers
According to Larry Wall (designer of PERL): a language by geniuses! for geniuses. Lecture 7: Haskell. Haskell 98. Haskell (cont) - Type-safe!
Lecture 7: Haskell CSC 131 Fall, 2014 Kim Bruce According to Larry Wall (designer of PERL): a language by geniuses for geniuses He s wrong at least about the latter part though you might agree when we
Submitted to the Onward track of OOPSLA-03 ABSTRACT. Keywords
GUI Environments for Functional Languages Daniel J. Pless & George F. Luger University of New Mexico, Computer Science Ferris Engineering Center Albuquerque, NM 87131 (505) 277-9424 {dpless,luger}@cs.unm.edu
Haskell Overview IV (4A) Young Won Lim 10/24/16
(4A) Copyright (c) 2016 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published
Advanced Topics in Programming Languages Lecture 2 - Introduction to Haskell
Advanced Topics in Programming Languages Lecture 2 - Introduction to Haskell Ori Bar El Maxim Finkel 01/11/17 1 History Haskell is a lazy, committee designed, pure functional programming language that
Topic 9: Type Checking
Recommended Exercises and Readings Topic 9: Type Checking From Haskell: The craft of functional programming (3 rd Ed.) Exercises: 13.17, 13.18, 13.19, 13.20, 13.21, 13.22 Readings: Chapter 13.5, 13.6 and
Topic 9: Type Checking
Topic 9: Type Checking 1 Recommended Exercises and Readings From Haskell: The craft of functional programming (3 rd Ed.) Exercises: 13.17, 13.18, 13.19, 13.20, 13.21, 13.22 Readings: Chapter 13.5, 13.6
How does ML deal with +?
How does ML deal with +? Moscow ML version 2.00 (June 2000) - op +; > val it = fn : int * int -> int - 1 + 1; > val it = 2 : int - 1.0 + 1.0; > val it = 2.0 : real - false + false;! Overloaded + cannot
Derek Dreyer. WG2.8 Meeting, Iceland July 16-20, 2007
Why Applicative Functors Matter Derek Dreyer Toyota Technological Institute at Chicago WG2.8 Meeting, Iceland July 16-20, 2007 Matthias Felleisen Gets In a Good Jab Matthias Felleisen, POPL PC Chair report,
Some Advanced ML Features
Some Advanced ML Features Mooly Sagiv Michael Clarkson, Cornell CS 3110 Data Structures and Functional Programming University of Washington: Dan Grossman ML is small Small number of powerful constructs
Week 5 Tutorial Structural Induction
Department of Computer Science, Australian National University COMP2600 / COMP6260 Formal Methods in Software Engineering Semester 2, 2016 Week 5 Tutorial Structural Induction You should hand in attempts
Programming Language Concepts, CS2104 Lecture 7
Reminder of Last Lecture Programming Language Concepts, CS2104 Lecture 7 Tupled Recursion Exceptions Types, ADT, Haskell, Components 5th Oct 2007 CS2104, Lecture 7 1 Overview 5th Oct 2007 CS2104, Lecture
Type Classes in Haskell Tom Schrijvers. Leuven Haskell User Group
Type Classes in Haskell Tom Schrijvers Leuven Haskell User Group Haskell Research Team Partners Monads Type Classes GHC Folds Pattern Matching Equational Reasoning DSLs Advanced Types Adhoc Overloading
An Introduction to Programming in Haskell. Gabriel J. Ferrer Hendrix College
An Introduction to Programming in Haskell Gabriel J. Ferrer Hendrix College Overview Functional programming Property testing Iteration Type system I/O Installation Go to: http://www.haskell.org/ Download
CMSC 330: Organization of Programming Languages. Functional Programming with Lists
CMSC 330: Organization of Programming Languages Functional Programming with Lists CMSC330 Spring 2018 1 Lists in OCaml The basic data structure in OCaml Lists can be of arbitrary length Implemented as
Assignment 1 CSCI 3136: Principles of Programming Languages
Assignment 1 CSCI 3136: Principles of Programming Languages Due Jan 29, 2018 Assignments are due on the due date before class and have to include this cover page. Plagiarism in assignment answers will
Functional Programming and Haskell
Functional Programming and Haskell Tim Dawborn University of Sydney, Australia School of Information Technologies Tim Dawborn Functional Programming and Haskell 1/22 What are Programming Paradigms? A programming
Simple Unification-based Type Inference for GADTs
Simple Unification-based Type Inference for GADTs Stephanie Weirich University of Pennsylvania joint work with Dimitrios Vytiniotis, Simon Peyton Jones and Geoffrey Washburn Overview Goal: Add GADTs to
Pawns: a declarative/imperative language
Pawns: a declarative/imperative language Lee Naish Computing and Information Systems University of Melbourne (actually, not quite... ) Naish, Lee (Melbourne Uni.) Pawns: a declarative/imperative language
Haskell Overview II (2A) Young Won Lim 8/9/16
(2A) Copyright (c) 2016 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published
CS The IO Monad. Slides from John Mitchell, K Fisher, and S. Peyton Jones
CS 242 2012 The IO Monad Slides from John Mitchell, K Fisher, and S. Peyton Jones Reading: Tackling the Awkward Squad, Sections 1-2 Real World Haskell, Chapter 7: I/O Beauty... Functional programming is
Exercises on ML. Programming Languages. Chanseok Oh
Exercises on ML Programming Languages Chanseok Oh chanseok@cs.nyu.edu Dejected by an arcane type error? - foldr; val it = fn : ('a * 'b -> 'b) -> 'b -> 'a list -> 'b - foldr (fn x=> fn y => fn z => (max
Module Title: Informatics 1 Functional Programming (first sitting) Exam Diet (Dec/April/Aug): December 2014 Brief notes on answers:
Module Title: Informatics 1 Functional Programming (first sitting) Exam Diet (Dec/April/Aug): December 2014 Brief notes on answers: -- Full credit is given for fully correct answers. -- Partial credit
Imprecise Exceptions - Exceptions in Haskell
Imprecise Exceptions - Exceptions in Haskell Christopher Krauß Universität des Saarlandes Informatik 22nd March 2006 Outline Introduction Exceptions Where do we use exceptions? Different kinds of exceptions
QuickCheck, SmallCheck & Reach: Automated Testing in Haskell. Tom Shackell
QuickCheck, SmallCheck & Reach: Automated Testing in Haskell By Tom Shackell A Brief Introduction to Haskell Haskell is a purely functional language. Based on the idea of evaluation of mathematical functions
Introduction to Functional Programming in Haskell 1 / 56
Introduction to Functional Programming in Haskell 1 / 56 Outline Why learn functional programming? The essence of functional programming What is a function? Equational reasoning First-order vs. higher-order
Outline. 1 About the course
Outline EDAF50 C++ Programming 1. Introduction 1 About the course Sven Gestegård Robertz Computer Science, LTH 2018 2 Presentation of C++ History Introduction Data types and variables 1. Introduction 2/1
INTRODUCTION TO HASKELL
INTRODUCTION TO HASKELL PRINCIPLES OF PROGRAMMING LANGUAGES Norbert Zeh Winter 2018 Dalhousie University 1/81 HASKELL: A PURELY FUNCTIONAL PROGRAMMING LANGUAGE Functions are first-class values: Can be
Graph reduction. Simple graph reduction with visualisation
Simple graph reduction with visualisation Outline The minifp language Graph representation of terms Tying the knot The compiler The reduction engine Literature The minifp language Small functional language,
Haskell & functional programming, some slightly more advanced stuff. Matteo Pradella
Haskell & functional programming, some slightly more advanced stuff Matteo Pradella pradella@elet.polimi.it IEIIT, Consiglio Nazionale delle Ricerche & DEI, Politecnico di Milano PhD course @ UniMi - Feb
CS 360: Programming Languages Lecture 12: More Haskell
CS 360: Programming Languages Lecture 12: More Haskell Geoffrey Mainland Drexel University Adapted from Brent Yorgey s course Introduction to Haskell. Section 1 Administrivia Administrivia Homework 5 due
Developing Good Habits for Bare-Metal Programming
Developing Good s for Bare-Metal Programming Mark P Jones, Iavor Diatchki (Galois), Garrett Morris, Creighton Hogg, Justin Bailey April 2010 Emphasis on Developing This is a talk about work in progress
CMSC 330: Organization of Programming Languages. Functional Programming with Lists
CMSC 330: Organization of Programming Languages Functional Programming with Lists 1 Lists in OCaml The basic data structure in OCaml Lists can be of arbitrary length Implemented as a linked data structure
Programming Languages
CSE 230: Winter 2008 Principles of Programming Languages Ocaml/HW #3 Q-A Session Push deadline = Mar 10 Session Mon 3pm? Lecture 15: Type Systems Ranjit Jhala UC San Diego Why Typed Languages? Development
Simon Peyton Jones (Microsoft Research) JAOO 2009
Simon Peyton Jones (Microsoft Research) JAOO 2009 A statically typed, purely functional language... designed 20 years ago... by a committee... of pointy-headed academics... as a research language. Doesn
Programming Languages Fall 2013
Programming Languages Fall 2013 Lecture 2: types Prof. Liang Huang huang@qc.cs.cuny.edu Recap of Lecture 1 functional programming vs. imperative programming basic Haskell syntax function definition lazy
Type Systems, Type Inference, and Polymorphism
6 Type Systems, Type Inference, and Polymorphism Programming involves a wide range of computational constructs, such as data structures, functions, objects, communication channels, and threads of control.
Type Classes and Instance Chains: A Relational Approach. John Garrett Morris
Type Classes and Instance Chains: A Relational Approach by John Garrett Morris A dissertation submitted in partial fulfillment of the requirements for the degree of Doctor of Philosophy in Computer Science