Save this PDF as:

Size: px
Start display at page:

## Transcription

2 ADT vs GADT Algebraic Datatype Data List a = Nil Cons a (List a) Data Tree a b = Tip a Node (Tree a b) b Fork (Tree a b) (Tree a b) Note that types than can be expressed as an ADT always have the identical range types on all their constructors Generalized Algebraic Datatype Data List a where Nil:: List a Cons:: a -> List a -> List a Data Tree a b where Tip a : Tree a b Node: Tree a b -> b -> Tree a b Fork:: Tree a b -> Tree a b -> Tree a b

3 GADTs relax the range restriction data Even n where Base:: Even Z NE:: Odd n -> Even (S n) data Rep:: * -> * where Int:: Rep Int Char:: Rep Char Float:: Rep Float Bool :: Rep Bool Pair:: Rep a -> Rep b -> Rep (a,b) List :: Rep a -> Rep [a] The range is always the type being defined, (Even & Rep) but that type s arguments can vary. We call an argument that varies and index.

4 Examples Length indexed lists Balanced Trees Redblack trees 2-threes trees AVL trees Representation types Well-typed terms Terms as typing judgements Tagless interpreters Subject reduction Type inference Witnesses Odd and Even Well formed join and cross product in relational algebra Well structured paths in trees Units of measure (inches, centimeters, etc) Provable Equality Proof carrying code

5 Length indexed lists data Z data S n Note we introduce uninhabited types that have the structure of the Natural numbers to serve as indexes to LList data LList :: * -> * -> * where LNil:: LList a Z LCons:: a -> LList a n -> LList a (S n) Note the range type is always LList But they differ in the indexes.

6 Promotion As of GHC version 7 GHC allows indexes to be ordinary datatypes. One says the datatype is promoted to the type level. This is very usefull, as it enforces a typing system on the indexes. For example does (LList Int String) make any sense. The index is supposed to be drawn from Z and S

7 Length indexed lists again An ordinary algebraic datatype data Nat = Zero Succ Nat The type Nat is promoted to a Kind data Vec:: * -> Nat -> * where Nil :: Vec a Zero Cons:: a -> Vec a n -> Vec a (Succ n) The index is always drawn from well typed values of type Nat, so values of type Nat are promoted to Types

8 GADTs as proof objects data EvenX:: Nat -> * where BaseX:: EvenX Zero NEX:: OddX n -> EvenX (Succ n) data OddX:: Nat -> * where NOX:: EvenX n -> OddX (Succ n) What type does NEX (NOX BaseX) have?

9 The Curry-Howard isomorphism The Curry-Howard isomorphism says that two things have exactly the same structure. A term has a type A proof proves a proposition A term Has a type NEX (NOX BaseX) :: EvenX (Succ (Succ Zero)) A proof Proves a proposition Note that there is no term with type: EvenX (Succ Zero)

10 Proofs and witnesses GADTs make the Curry-Howard isomorphism useful in Haskell. Sometime we say a term witnesses a property. I.e the term NEX (NOX BaseX) witnesses that 2 is even. We use GADTs has indexes to show that some things are not possible.

11 Paths and Trees data Shape = Tp Nd Fk Shape Shape data Path :: Shape -> * where Here:: Path Nd Left:: Path x -> Path (Fk x y) Right:: Path y -> Path (Fk x y) Note there are no paths with index Tp data Tree:: Shape -> * -> * where Tip :: Tree Tp a Node:: a -> Tree Nd a Fork :: Tree x a -> Tree y a -> Tree (Fk x y) a

12 Well formed paths find:: Eq a => a -> Tree sh a -> [Path sh] find n Tip = [] find n (Node m) = if n==m then [Here] else [] find n (Fork x y) = (map Left (find n x)) ++ (map Right (find n y))

13 Using a path. No possibility of failure extract:: Eq a => Tree sh a -> Path sh -> a extract (Node n) (Here) = n extract (Fork l r) (Left p) = extract l p extract (Fork l r) (Right p) = extract r p -- No other cases are possible, -- Since there are no Paths with index Tp

14 Balanced Trees Balanced trees are used as binary search mechanisms. They support log(n) time searches for trees that have n elements They rely on the trees being balanced. Usually saying that all paths from root to leaf have roughly the same length Indexes make perfect tools to represent these invariants.

15 Red Black Trees A red-black tree is a binary search tree with the following additional invariants: Each node is colored either red or black The root is black The leaves are black Each Red node has Black children for all internal nodes, each path from that node to a descendant leaf contains the same number of black nodes. We can encode these invariants by thinking of each internal node as having two attributes: a color and a black-height.

16 Red Black Tree as a GADT data Color = Red Black data SubTree :: Color -> Nat -> * where LeafRB :: SubTree Black Zero RNode :: SubTree Black n -> Int -> SubTree Black n -> SubTree Red n BNode :: SubTree cl m -> Int -> SubTree cr m -> SubTree Black (Succ m) data RBTree where Root:: (forall n. (SubTree Black n)) -> RBTree

17 AVL Trees In an AVL tree, the heights of the two child sub trees of any node differ by at most one; data Balance:: Nat -> Nat -> Nat -> * where Same :: Balance n n n Less :: Balance n (Succ n) (Succ n) More :: Balance (Succ n) n (Succ n) data Avl:: Nat -> * where TipA:: Avl Zero NodeA:: Balance i j k -> Avl i -> Int -> Avl j -> Avl (Succ k) data AVL = forall h. AVL (Avl h) A witness type that witnesses only the legal height differences.

18

19

20 insert :: Int -> AVL -> AVL Insertion insert x (AVL t) = case ins x t of L t -> AVL t; R t -> AVL t ins :: Int -> Avl n -> (Avl n + Avl (Succ n)) ins x TipA = R(NodeA Same TipA x TipA) ins x (NodeA bal lc y rc) x == y = L(NodeA bal lc y rc) x < y = case ins x lc of L lc -> L(NodeA bal lc y rc) R lc -> case bal of Same -> R(NodeA More lc y rc) Less -> L(NodeA Same lc y rc) More -> rotr lc y rc -- rebalance x > y = case ins x rc of L rc -> L(NodeA bal lc y rc) R rc -> case bal of Note the rotations in red Same -> R(NodeA Less lc y rc) More -> L(NodeA Same lc y rc) Less -> rotl lc y rc -- rebalance

21

22

23 Example code The rest is in the accompanying Haskell file data (+) a b = L a R b rotr :: Avl(Succ(Succ n)) -> Int -> Avl n -> (Avl(Succ(Succ n))+avl(succ(succ(succ n)))) -- rotr Tip u a = unreachable rotr (NodeA Same b v c) u a = R(NodeA Less b v (NodeA More c u a)) rotr (NodeA More b v c) u a = L(NodeA Same b v (NodeA Same c u a)) -- rotr (NodeA Less b v TipA) u a = unreachable rotr (NodeA Less b v (NodeA Same x m y)) u a = L(NodeA Same (NodeA Same b v x) m (NodeA Same y u a)) rotr (NodeA Less b v (NodeA Less x m y)) u a = L(NodeA Same (NodeA More b v x) m (NodeA Same y u a)) rotr (NodeA Less b v (NodeA More x m y)) u a = L(NodeA Same (NodeA Same b v x) m (NodeA Less y u a))

24 At the top level Insertion may make the height of the tree grow. Hide the height of the tree as an existentially quantified index. data AVL = forall h. AVL (Avl h)

25 2-3-Tree a tree where every node with children (internal node) has either two children (2-node) and one data element or three children (3- nodes) and two data elements. Nodes on the outside of the tree (leaf nodes) have no children and zero, one or two data elements data Tree23:: Nat -> * -> * where Three :: (Tree23 n a) -> a -> (Tree23 n a) -> a -> (Tree23 (Succ n) a) Two:: (Tree23 n a) -> a -> (Tree23 n a) -> (Tree23 (Succ n) a) Leaf1 :: a -> (Tree23 Zero a) Leaf2 :: a -> a -> (Tree23 Zero a) Leaf0 :: (Tree23 Zero a)

26 Witnessing equality Sometimes we need to prove that two types are equal. We need a type that represents this proposition. We call this a witness, since legal terms with this type only witness that the two types are the same. This is sometimes called provable equality (since it is possible to write a function that returns an element of this type). data Equal:: k -> k -> * where Refl :: Equal x x

27 Representation types data Rep:: * -> * where Int:: Rep Int Char:: Rep Char Float:: Rep Float Bool :: Rep Bool Pair:: Rep a -> Rep b -> Rep (a,b) List :: Rep a -> Rep [a] Some times this is called a Universe, since it witnesses only those types representable.

28 Generic Programming eq:: Rep a -> a -> a -> Bool eq Int x y = x==y eq Char x y = x==y eq Float x y = x==y eq Bool x y = x==y eq (Pair t1 t2)(a,b) (c,d) = (eq t1 a c) && (eq t2 b d) eq (List t) xs ys not(length xs == length ys) = False otherwise = and (zipwith (eq t) xs ys)

29 Using provable equality We need a program to inspect two Rep types (at runtime) to possible produce a proof that the types that they represent are the same. test:: Rep a -> Rep b -> Maybe(Equal a b) This is sort of like an equality test, but reflects in its type that the two types are really equal.

30 Code for test test:: Rep a -> Rep b -> Maybe(Equal a b) test Int Int = Just Refl test Char Char = Just Refl test Float Float = Just Refl test Bool Bool = Just Refl test (Pair x y) (Pair m n) = do { Refl <- test x m ; Refl <- test y n ; Just Refl } test (List x) (List y) = do { Refl <- test x y ; Just Refl} test = Nothing When we pattern match against Refl, the compiler know that the two types are statically equal in the scope of the match.

31 Well typed terms data Exp:: * -> * where IntE :: Int -> Exp Int CharE:: Char -> Exp Char PairE :: Exp a -> Exp b -> Exp (a,b) VarE:: String -> Rep t -> Exp t LamE:: String -> Rep t -> Exp s -> Exp (t -> s) ApplyE:: Exp (a -> b) -> Exp a -> Exp b FstE:: Exp(a,b) -> Exp a SndE:: Exp(a,b) -> Exp b

32 Typing judgements Well typed terms have the exact same structure as a typing judgment. Consider the constructor ApplyE ApplyE:: Exp (a -> b) -> Exp a -> Exp b Compare it to the typing judgement f : a b x : a f x : b

33 Tagless interpreter An interpreter gives a value to a term. Usually we need to invent a value datatype like data Value = IntV Int FunV (Value -> Value) PairV Value Value We also need to store Values in an environment data Env = E [(String,Value)]

34 Valueless environments data Env where Empty :: Env Extend :: String -> Rep t -> t -> Env -> Env Note that the type variable t is existentially quantified. Given a pattern (Extend var rep t more) There is not much we can do with t, since we do not know its type.

35 Tagless interpreter eval:: Exp t -> Env -> t eval (IntE n) env = n eval (CharE c) env = c eval (PairE x y) env = (eval x env, eval y env) eval (VarE s t) Empty = error ("Variable not found: "++s) eval (LamE nm t body) env = (\ v -> eval body (Extend nm t v env)) eval (ApplyE f x) env = (eval f env) (eval x env) eval (FstE x) env = fst(eval x env) eval (SndE x) env = snd(eval x env) eval s t1)) (Extend nm t2 value more) s==nm = case test t1 t2 of Just Refl -> value Nothing -> error "types don't match" otherwise = eval v more

36 Units of measure data TempUnit = Fahrenheit Celsius Kelvin data Degree:: TempUnit -> * where F:: Float -> Degree Fahrenheit C:: Float -> Degree Celsius K:: Float -> Degree Kelvin add:: Degree u -> Degree u -> Degree u add (F x) (F y) = F(x+y) add (C x) (C y) = C(x+y) add (K x) (K y) = K(x+y)

37 N-way zip zipn 1 (+1) [1,2,3] [2,3,4] zipn 2 (+) [1,2,3] [4,5,6] [5,7,9] zipn 3 (\ x y z -> (x+z,y))[2,3] [5,1] [6,8] [(8,5),(11,1)]

38 The Natural Numbers with strange types data Zip :: * -> * -> * where Z:: Zip a [a] S:: Zip b c -> Zip (a -> b) ([a] -> c) Z :: Zip a [a] (S Z) :: Zip (a -> b) ([a] -> [b]) (S (S Z)) :: Zip (a -> a1 -> b) ([a] -> [a1] -> [b]) (S(S (S Z))) :: Zip (a -> a1 -> a2 -> b) ([a] -> [a1] -> [a2] -> [b])

39 Why these types. f :: (a -> b -> c -> d) (f x) :: (b -> c -> d) (f x y) :: (c -> d) (f x y z) :: d (zip f) :: ([a] -> [b] -> [c] -> [d]) (zip f xs) :: ([b] -> [c] -> [d]) (zip f xs ys) :: ([c] -> [d]) (zip f xs ys za) :: [d]

40 zero = Z one = S Z two = S (S Z) help:: Zip a b -> a -> b -> b help Z x xs = x:xs help (S n) f rcall = (\ ys -> case ys of (z:zs) -> help n (f z) (rcall zs) other -> skip n)

41 Code skip:: Zip a b -> b skip Z = [] skip (S n) = \ ys -> skip n zipn:: Zip a b -> a -> b zipn Z = \ n -> [n] zipn m)) = let zip f = help n f (\ x -> zip f x) in zip

### Programming in Omega Part 2. Tim Sheard Portland State University

Programming in Omega Part 2 Tim Sheard Portland State University Recall Introduce new kinds Use GADTs to build indexed data Indexed data can supports singleton types (Nat ) relationships between types

### 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

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

### Note that this is a rep invariant! The type system doesn t enforce this but you need it to be true. Should use repok to check in debug version.

Announcements: Prelim tonight! 7:30-9:00 in Thurston 203/205 o Handed back in section tomorrow o If you have a conflict you can take the exam at 5:45 but can t leave early. Please email me so we have a

### Informatics 1 Functional Programming Lecture 12. Data Abstraction. Don Sannella University of Edinburgh

Informatics 1 Functional Programming Lecture 12 Data Abstraction Don Sannella University of Edinburgh Part I Sets as lists without abstraction We will look again at our four ways of implementing sets.

### Some Search Structures. Balanced Search Trees. Binary Search Trees. A Binary Search Tree. Review Binary Search Trees

Some Search Structures Balanced Search Trees Lecture 8 CS Fall Sorted Arrays Advantages Search in O(log n) time (binary search) Disadvantages Need to know size in advance Insertion, deletion O(n) need

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

### 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

### Lecture 4: Higher Order Functions

Lecture 4: Higher Order Functions Søren Haagerup Department of Mathematics and Computer Science University of Southern Denmark, Odense September 26, 2017 HIGHER ORDER FUNCTIONS The order of a function

### Algorithms. AVL Tree

Algorithms AVL Tree Balanced binary tree The disadvantage of a binary search tree is that its height can be as large as N-1 This means that the time needed to perform insertion and deletion and many other

### Trees. Eric McCreath

Trees Eric McCreath 2 Overview In this lecture we will explore: general trees, binary trees, binary search trees, and AVL and B-Trees. 3 Trees Trees are recursive data structures. They are useful for:

Advanced features of Functional Programming (Haskell) Polymorphism and overloading January 10, 2017 Monomorphic and polymorphic types A (data) type specifies a set of values. Examples: Bool: the type of

### CIS265/ Trees Red-Black Trees. Some of the following material is from:

CIS265/506 2-3-4 Trees Red-Black Trees Some of the following material is from: Data Structures for Java William H. Ford William R. Topp ISBN 0-13-047724-9 Chapter 27 Balanced Search Trees Bret Ford 2005,

### 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

### Chapter 20: Binary Trees

Chapter 20: Binary Trees 20.1 Definition and Application of Binary Trees Definition and Application of Binary Trees Binary tree: a nonlinear linked list in which each node may point to 0, 1, or two other

### Lesson 4 Typed Arithmetic Typed Lambda Calculus

Lesson 4 Typed Arithmetic Typed Lambda 1/28/03 Chapters 8, 9, 10 Outline Types for Arithmetic types the typing relation safety = progress + preservation The simply typed lambda calculus Function types

### 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

### void insert( Type const & ) void push_front( Type const & )

6.1 Binary Search Trees A binary search tree is a data structure that can be used for storing sorted data. We will begin by discussing an Abstract Sorted List or Sorted List ADT and then proceed to describe

### 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

T O Y H Advances in Programming Languages APL8: Multiparameter Type Classes, Constructor Classes Ian Stark School of Informatics The University of Edinburgh Thursday 4 February Semester 2 Week 4 E H U

### EE 368. Weeks 5 (Notes)

EE 368 Weeks 5 (Notes) 1 Chapter 5: Trees Skip pages 273-281, Section 5.6 - If A is the root of a tree and B is the root of a subtree of that tree, then A is B s parent (or father or mother) and B is A

### CS102 Binary Search Trees

CS102 Binary Search Trees Prof Tejada 1 To speed up insertion, removal and search, modify the idea of a Binary Tree to create a Binary Search Tree (BST) Binary Search Trees Binary Search Trees have one

### Programming Languages

CSE 130 : Winter 2013 Programming Languages Lecture 3: Crash Course, Datatypes Ranjit Jhala UC San Diego 1 Story So Far... Simple Expressions Branches Let-Bindings... Today: Finish Crash Course Datatypes

### Functional dependencies versus type families and beyond

Functional dependencies versus type families and beyond Martin Sulzmann National University of Singapore Joint work with Tom Schrijvers Functional dependencies versus type families and beyond p.1 What

### Lecture 21: Red-Black Trees

15-150 Lecture 21: Red-Black Trees Lecture by Dan Licata April 3, 2012 Last time, we talked about the signature for dictionaries: signature ORDERED = sig type t val compare : t * t -> order signature DICT

### Lecture 2: List algorithms using recursion and list comprehensions

Lecture 2: List algorithms using recursion and list comprehensions Søren Haagerup Department of Mathematics and Computer Science University of Southern Denmark, Odense September 12, 2017 Expressions, patterns

Advanced Functional Programming Tim Sheard Polymorphism Hindley-Milner Polymorphism Rank 2 polymorphism Tim Sheard 1 Polymorphism A function is polymorphic if it can work on any kind of argument. f x =

### Inductive Data Types

Inductive Data Types Lars-Henrik Eriksson Functional Programming 1 Original slides by Tjark Weber Lars-Henrik Eriksson (UU) Inductive Data Types 1 / 42 Inductive Data Types Today Today New names for old

### 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

### Writing code that I'm not smart enough to write. A funny thing happened at Lambda Jam

Writing code that I'm not smart enough to write A funny thing happened at Lambda Jam Background "Let s make a lambda calculator" Rúnar Bjarnason Task: write an interpreter for the lambda calculus Lambda

### Red-black trees (19.5), B-trees (19.8), trees

Red-black trees (19.5), B-trees (19.8), 2-3-4 trees Red-black trees A red-black tree is a balanced BST It has a more complicated invariant than an AVL tree: Each node is coloured red or black A red node

### CSC148 Week 7. Larry Zhang

CSC148 Week 7 Larry Zhang 1 Announcements Test 1 can be picked up in DH-3008 A1 due this Saturday Next week is reading week no lecture, no labs no office hours 2 Recap Last week, learned about binary trees

### 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

### 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

Haskell Overloading (1) LiU-FP2016: Lecture 8 Type Classes Henrik Nilsson University of Nottingham, UK What is the type of (==)? E.g. the following both work: 1 == 2 a == b I.e., (==) can be used to compare

### A set of nodes (or vertices) with a single starting point

Binary Search Trees Understand tree terminology Understand and implement tree traversals Define the binary search tree property Implement binary search trees Implement the TreeSort algorithm 2 A set of

### Abstract Types, Algebraic Types, and Type Classes

Informatics 1 Functional Programming Lectures 13 and 14 Monday 9 and Tuesday 10 November 2009 Abstract Types, Algebraic Types, and Type Classes Philip Wadler University of Edinburgh Reminders Tutorial

### Module 4: Index Structures Lecture 13: Index structure. The Lecture Contains: Index structure. Binary search tree (BST) B-tree. B+-tree.

The Lecture Contains: Index structure Binary search tree (BST) B-tree B+-tree Order file:///c /Documents%20and%20Settings/iitkrana1/My%20Documents/Google%20Talk%20Received%20Files/ist_data/lecture13/13_1.htm[6/14/2012

### 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

Processadors de Llenguatge II Functional Paradigm II Pratt A.7 Robert Harper s SML tutorial (Sec II) Rafael Ramirez Dep Tecnologia Universitat Pompeu Fabra User-Defined Types How to define the new type.

### AVL Trees. (AVL Trees) Data Structures and Programming Spring / 17

AVL Trees (AVL Trees) Data Structures and Programming Spring 2017 1 / 17 Balanced Binary Tree The disadvantage of a binary search tree is that its height can be as large as N-1 This means that the time

### These notes are intended exclusively for the personal usage of the students of CS352 at Cal Poly Pomona. Any other usage is prohibited without

These notes are intended exclusively for the personal usage of the students of CS352 at Cal Poly Pomona. Any other usage is prohibited without previous written authorization. 1 2 The simplest way to create

### Multiway Search Trees. Multiway-Search Trees (cont d)

Multiway Search Trees Each internal node v of a multi-way search tree T has at least two children contains d-1 items, where d is the number of children of v an item is of the form (k i,x i ) for 1 i d-1,

### 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

### Processadors de Llenguatge II. Functional Paradigm. Pratt A.7 Robert Harper s SML tutorial (Sec II)

Processadors de Llenguatge II Functional Paradigm Pratt A.7 Robert Harper s SML tutorial (Sec II) Rafael Ramirez Dep Tecnologia Universitat Pompeu Fabra Paradigm Shift Imperative Paradigm State Machine

### CSc 372. Comparative Programming Languages. 8 : Haskell Function Examples. Department of Computer Science University of Arizona

1/43 CSc 372 Comparative Programming Languages 8 : Haskell Function Examples Department of Computer Science University of Arizona collberg@gmail.com Copyright c 2013 Christian Collberg Functions over Lists

### Introduction to dependent types in Coq

October 24, 2008 basic use of the Coq system In Coq, you can play with simple values and functions. The basic command is called Check, to verify if an expression is well-formed and learn what is its type.

### 8. Binary Search Tree

8 Binary Search Tree Searching Basic Search Sequential Search : Unordered Lists Binary Search : Ordered Lists Tree Search Binary Search Tree Balanced Search Trees (Skipped) Sequential Search int Seq-Search

### Search Structures. Kyungran Kang

Search Structures Kyungran Kang (korykang@ajou.ac.kr) Ellis Horowitz, Sartaj Sahni and Susan Anderson-Freed, Fundamentals of Data Structures in C, 2nd Edition, Silicon Press, 2007. Contents Binary Search

### Type Checking and Type Inference

Type Checking and Type Inference Principles of Programming Languages CSE 307 1 Types in Programming Languages 2 Static Type Checking 3 Polymorphic Type Inference Version: 1.8 17:20:56 2014/08/25 Compiled

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

### Type system. Type theory. Haskell type system. EDAN40: Functional Programming Types and Type Classes (revisited)

Type system EDAN40: Functional Programming Types and Type Classes (revisited) Jacek Malec Dept. of Computer Science, Lund University, Sweden April 3rd, 2017 In programming languages, a type system is a

### 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

### Shell CSCE 314 TAMU. Functions continued

1 CSCE 314: Programming Languages Dr. Dylan Shell Functions continued 2 Outline Defining Functions List Comprehensions Recursion 3 A Function without Recursion Many functions can naturally be defined in

### - 1 - Handout #22S May 24, 2013 Practice Second Midterm Exam Solutions. CS106B Spring 2013

CS106B Spring 2013 Handout #22S May 24, 2013 Practice Second Midterm Exam Solutions Based on handouts by Eric Roberts and Jerry Cain Problem One: Reversing a Queue One way to reverse the queue is to keep

### Monad Background (3A) Young Won Lim 11/18/17

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 or any later version published

### List Functions, and Higher-Order Functions

List Functions, and Higher-Order Functions Björn Lisper Dept. of Computer Science and Engineering Mälardalen University bjorn.lisper@mdh.se http://www.idt.mdh.se/ blr/ List Functions, and Higher-Order

### Questions from the material presented in this lecture

Advanced Data Structures Questions from the material presented in this lecture January 8, 2015 This material illustrates the kind of exercises and questions you may get at the final colloqium. L1. Introduction.

### CSci 4223 Principles of Programming Languages

CSci 4223 Principles of Programming Languages Lecture 11 Review Features learned: functions, tuples, lists, let expressions, options, records, datatypes, case expressions, type synonyms, pattern matching,

### B-Trees. Based on materials by D. Frey and T. Anastasio

B-Trees Based on materials by D. Frey and T. Anastasio 1 Large Trees n Tailored toward applications where tree doesn t fit in memory q operations much faster than disk accesses q want to limit levels of

Advanced Tree Data Structures Fawzi Emad Chau-Wen Tseng Department of Computer Science University of Maryland, College Park Binary trees Traversal order Balance Rotation Multi-way trees Search Insert Overview

### Data Structures and Algorithms

Data Structures and Algorithms Spring 2009-2010 Outline BST Trees (contd.) 1 BST Trees (contd.) Outline BST Trees (contd.) 1 BST Trees (contd.) The bad news about BSTs... Problem with BSTs is that there

### Trees! Ellen Walker! CPSC 201 Data Structures! Hiram College!

Trees! Ellen Walker! CPSC 201 Data Structures! Hiram College! ADTʼs Weʼve Studied! Position-oriented ADT! List! Stack! Queue! Value-oriented ADT! Sorted list! All of these are linear! One previous item;

### 2-3 Tree. Outline B-TREE. catch(...){ printf( "Assignment::SolveProblem() AAAA!"); } ADD SLIDES ON DISJOINT SETS

Outline catch(...){ printf( "Assignment::SolveProblem() AAAA!"); } Balanced Search Trees 2-3 Trees 2-3-4 Trees Slide 4 Why care about advanced implementations? Same entries, different insertion sequence:

### Priority Queues. 1 Introduction. 2 Naïve Implementations. CSci 335 Software Design and Analysis III Chapter 6 Priority Queues. Prof.

Priority Queues 1 Introduction Many applications require a special type of queuing in which items are pushed onto the queue by order of arrival, but removed from the queue based on some other priority

L28: Advanced functional programming Exercise 2 Due on 8th March 2017 Submission instructions Your solutions for this exericse should be handed in to the Graduate Education Office by 4pm on the due date.

### Type Checking. Outline. General properties of type systems. Types in programming languages. Notation for type rules.

Outline Type Checking General properties of type systems Types in programming languages Notation for type rules Logical rules of inference Common type rules 2 Static Checking Refers to the compile-time

### COMP171. AVL-Trees (Part 1)

COMP11 AVL-Trees (Part 1) AVL Trees / Slide 2 Data, a set of elements Data structure, a structured set of elements, linear, tree, graph, Linear: a sequence of elements, array, linked lists Tree: nested

### Lists. Michael P. Fourman. February 2, 2010

Lists Michael P. Fourman February 2, 2010 1 Introduction The list is a fundamental datatype in most functional languages. ML is no exception; list is a built-in ML type constructor. However, to introduce

### CSE 3302 Programming Languages Lecture 8: Functional Programming

CSE 3302 Programming Languages Lecture 8: Functional Programming (based on the slides by Tim Sheard) Leonidas Fegaras University of Texas at Arlington CSE 3302 L8 Spring 2011 1 Functional Programming Languages

### # true;; - : bool = true. # false;; - : bool = false 9/10/ // = {s (5, "hi", 3.2), c 4, a 1, b 5} 9/10/2017 4

Booleans (aka Truth Values) Programming Languages and Compilers (CS 421) Sasa Misailovic 4110 SC, UIUC https://courses.engr.illinois.edu/cs421/fa2017/cs421a # true;; - : bool = true # false;; - : bool

### Problem Set 5 Solutions

Introduction to Algorithms November 4, 2005 Massachusetts Institute of Technology 6.046J/18.410J Professors Erik D. Demaine and Charles E. Leiserson Handout 21 Problem Set 5 Solutions Problem 5-1. Skip

### Outline. General properties of type systems. Types in programming languages. Notation for type rules. Common type rules. Logical rules of inference

Type Checking Outline General properties of type systems Types in programming languages Notation for type rules Logical rules of inference Common type rules 2 Static Checking Refers to the compile-time

### Libraries for Generic Programming in Haskell

Libraries for Generic Programming in Haskell Johan Jeuring, Sean Leather, José PedroMagalhães, and Alexey Rodriguez Yakushev Universiteit Utrecht, The Netherlands Abstract. These lecture notes introduce

### Recap: ML s Holy Trinity

Recap: ML s Holy Trinity Expressions (Syntax) Exec-time Dynamic Values (Semantics) Compile-time Static Types 1. Programmer enters expression 2. ML checks if expression is well-typed Using a precise set

### Introduction. for large input, even access time may be prohibitive we need data structures that exhibit times closer to O(log N) binary search tree

Chapter 4 Trees 2 Introduction for large input, even access time may be prohibitive we need data structures that exhibit running times closer to O(log N) binary search tree 3 Terminology recursive definition

### Infinite Objects and Proofs 1

Infinite Objects and Proofs 1 Pierre Castéran Beijing, August 2009 1 This lecture corresponds to the chapter 13 : Infinite Objects and Proofs of the book. In this lecture, we shall see how to represent

### Booleans (aka Truth Values) Programming Languages and Compilers (CS 421) Booleans and Short-Circuit Evaluation. Tuples as Values.

Booleans (aka Truth Values) Programming Languages and Compilers (CS 421) Elsa L Gunter 2112 SC, UIUC https://courses.engr.illinois.edu/cs421/fa2017/cs421d # true;; - : bool = true # false;; - : bool =

### Binary Search Trees. Contents. Steven J. Zeil. July 11, Definition: Binary Search Trees The Binary Search Tree ADT...

Steven J. Zeil July 11, 2013 Contents 1 Definition: Binary Search Trees 2 1.1 The Binary Search Tree ADT.................................................... 3 2 Implementing Binary Search Trees 7 2.1 Searching

### 4 Programming with Types

4 Programming with Types 4.1 Polymorphism We ve been working a lot with lists of numbers, but clearly programs also need to be able to manipulate lists whose elements are drawn from other types lists of

### Priority Queues and Binary Heaps

Yufei Tao ITEE University of Queensland In this lecture, we will learn our first tree data structure called the binary heap which serves as an implementation of the priority queue. Priority Queue A priority

### CS 209 Functional Programming

CS 209 Functional Programming Lecture 03 - Intro to Monads Dr. Greg Lavender Department of Computer Science Stanford University "The most important thing in a programming language is the name. A language

### CSC324- TUTORIAL 5. Shems Saleh* *Some slides inspired by/based on Afsaneh Fazly s slides

CSC324- TUTORIAL 5 ML Shems Saleh* *Some slides inspired by/based on Afsaneh Fazly s slides Assignment 1 2 More questions were added Questions regarding the assignment? Starting ML Who am I? Shems Saleh

### OPPA European Social Fund Prague & EU: We invest in your future.

OPPA European Social Fund Prague & EU: We invest in your future. Data structures and algorithms Part 9 Searching and Search Trees II Petr Felkel 10.12. 2007 Topics Red-Black tree Insert Delete B-Tree Motivation

### CSE 130 Programming Languages. Lecture 3: Datatypes. Ranjit Jhala UC San Diego

CSE 130 Programming Languages Lecture 3: Datatypes Ranjit Jhala UC San Diego News? PA #2 (coming tonight) Ocaml-top issues? Pleas post questions to Piazza Recap: ML s Holy Trinity Expressions (Syntax)

### News. Programming Languages. Complex types: Lists. Recap: ML s Holy Trinity. CSE 130: Spring 2012

News CSE 130: Spring 2012 Programming Languages On webpage: Suggested HW #1 PA #1 (due next Fri 4/13) Lecture 2: A Crash Course in ML Please post questions to Piazza Ranjit Jhala UC San Diego Today: A

### Computer Science 210 Data Structures Siena College Fall Topic Notes: Binary Search Trees

Computer Science 10 Data Structures Siena College Fall 016 Topic Notes: Binary Search Trees Possibly the most common usage of a binary tree is to store data for quick retrieval. Definition: A binary tree

### Chapter 12 Digital Search Structures

Chapter Digital Search Structures Digital Search Trees Binary Tries and Patricia Multiway Tries C-C Tsai P. Digital Search Tree A digital search tree is a binary tree in which each node contains one element.

### Queues. ADT description Implementations. October 03, 2017 Cinda Heeren / Geoffrey Tien 1

Queues ADT description Implementations Cinda Heeren / Geoffrey Tien 1 Queues Assume that we want to store data for a print queue for a student printer Student ID Time File name The printer is to be assigned

### Trees 2: Linked Representation, Tree Traversal, and Binary Search Trees

Trees 2: Linked Representation, Tree Traversal, and Binary Search Trees Linked representation of binary tree Again, as with linked list, entire tree can be represented with a single pointer -- in this

### 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)

### Self-Balancing Search Trees. Chapter 11

Self-Balancing Search Trees Chapter 11 Chapter Objectives To understand the impact that balance has on the performance of binary search trees To learn about the AVL tree for storing and maintaining a binary

### Applying Type-Level and Generic Programming in Haskell

Summer School on Generic and Effectful Programming Applying Type-Level and Generic Programming in Haskell Andres Löh, Well-Typed LLP July 4, 2015 Contents 1 Introduction and type-level programming 5 1.1

### Programming with (co-)inductive types in Coq

Programming with (co-)inductive types in Coq Matthieu Sozeau February 3rd 2014 Programming with (co-)inductive types in Coq Matthieu Sozeau February 3rd 2014 Last time 1. Record Types 2. Mathematical Structures

### Multi-Way Search Trees

Multi-Way Search Trees Manolis Koubarakis 1 Multi-Way Search Trees Multi-way trees are trees such that each internal node can have many children. Let us assume that the entries we store in a search tree

### FUNCTIONALLY OBLIVIOUS (AND SUCCINCT) Edward Kmett

FUNCTIONALLY OBLIVIOUS (AND SUCCINCT) Edward Kmett BUILDING BETTER TOOLS Cache-Oblivious Algorithms Succinct Data Structures RAM MODEL Almost everything you do in Haskell assumes this model Good for ADTs,