Poly-HO! COS 326 David Walker Princeton University. polymorphic, higher-order programming
|
|
|
- Drusilla Stewart
- 5 years ago
- Views:
Transcription
1 Poly-HO! COS 326 David Walker Princeton University polymorphic, higher-order programming slides copyright David Walker and Andrew W. Appel permission granted to reuse these slides for non-commercial educajonal purposes
2 Some Design & Coding Rules 2
3 Some Design & Coding Rules Laziness can be a really good force in design. Never write the same code twice. factor out the common bits into a reusable procedure. beoer, use someone else s (well-tested, well-documented, and well-maintained) procedure. Why is this a good idea? why don t we just cut-and-paste snippets of code using the editor instead of abstracjng them into procedures? 3
4 Some Design & Coding Rules Laziness can be a really good force in design. Never write the same code twice. factor out the common bits into a reusable procedure. beoer, use someone else s (well-tested, well-documented, and well-maintained) procedure. Why is this a good idea? why don t we just cut-and-paste snippets of code using the editor instead of abstracjng them into procedures? find and fix a bug in one copy, have to fix in all of them. decide to change the funcjonality, have to track down all of the places where it gets used. 4
5 Consider these definijons: Factoring Code in OCaml let rec inc_all (xs:int list) : int list = hd::tl -> (hd+1)::(inc_all tl) let rec square_all (xs:int list) : int list = hd::tl -> (hd*hd)::(square_all tl) 5
6 Consider these definijons: Factoring Code in OCaml let rec inc_all (xs:int list) : int list = hd::tl -> (hd+1)::(inc_all tl) let rec square_all (xs:int list) : int list = hd::tl -> (hd*hd)::(square_all tl) The code is almost idenjcal factor it out! 6
7 Factoring Code in OCaml A higher-order funcjon captures the recursion paoern: let rec map (f:int->int) (xs:int list) : int list = hd::tl -> (f hd)::(map f tl);; 7
8 Factoring Code in OCaml A higher-order funcjon captures the recursion paoern: let rec map (f:int->int) (xs:int list) : int list = hd::tl -> (f hd)::(map f tl);; Uses of the funcjon: let inc x = x+1;; let inc_all xs = map inc xs;; 8
9 Factoring Code in OCaml A higher-order funcjon captures the recursion paoern: let rec map (f:int->int) (xs:int list) : int list = hd::tl -> (f hd)::(map f tl);; Uses of the funcjon: let inc x = x+1;; let inc_all xs = map inc xs;; WriJng liole funcjons like inc just so we call map is a pain. let square y = y*y;; let square_all xs = map square xs;; 9
10 Factoring Code in OCaml A higher-order funcjon captures the recursion paoern: let rec map (f:int->int) (xs:int list) : int list = hd::tl -> (f hd)::(map f tl);; We can use an anonymous funcjon instead. Uses of the funcjon: let inc_all xs = map (fun x -> x + 1) xs;; let square_all xs = map (fun y -> y * y) xs;; Originally, Church wrote this funcjon using λ instead of fun: (λx. x+1) or (λx. x*x) 10
![Another example let rec sum (xs:int list) : int = [] -> 0 hd::tl -> hd + (sum tl) ;; let rec prod (xs:int list) : int = [] -> 1 hd::tl -> hd * (prod tl) ;; Goal: Create a funcjon called reduce that](/docs-images/94/121759471/images/11-2.jpg "when supplied with a few arguments can implement both sum and prod. Define sum2 and prod2 using reduce.")
11 Another example let rec sum (xs:int list) : int = [] -> 0 hd::tl -> hd + (sum tl) ;; let rec prod (xs:int list) : int = [] -> 1 hd::tl -> hd * (prod tl) ;; Goal: Create a funcjon called reduce that when supplied with a few arguments can implement both sum and prod. Define sum2 and prod2 using reduce. Goal: If you finish early, use map and reduce together to find the sum of the squares of the elements of a list. (Try it) (Try it) 11
12 A generic reducer let add x y = x + y;; let mul x y = x * y;; let rec reduce (f:int->int->int) (u:int) (xs:int list) : int = [] -> u hd::tl -> f hd (reduce f u tl);; let sum xs = reduce add 0 xs ;; let prod xs = reduce mul 1 xs ;; 12
![Using Anonymous FuncJons let rec reduce (f:int->int->int) (u:int) (xs:int list) : int = [] -> u hd::tl -> f hd](/docs-images/94/121759471/images/13-2.jpg "(reduce f u tl);; let sum xs = reduce (fun x y -> x+y) 0 xs ;; let prod xs = reduce (fun x y -> x*y) 1 xs ;;")
13 Using Anonymous FuncJons let rec reduce (f:int->int->int) (u:int) (xs:int list) : int = [] -> u hd::tl -> f hd (reduce f u tl);; let sum xs = reduce (fun x y -> x+y) 0 xs ;; let prod xs = reduce (fun x y -> x*y) 1 xs ;; 13
![Using Anonymous FuncJons let rec reduce (f:int->int->int) (u:int) (xs:int list) : int = [] -> u hd::tl -> f hd (reduce f u tl);; let sum xs = reduce (fun x y](/docs-images/94/121759471/images/14-2.jpg "-> x+y) 0 xs ;; let prod xs = reduce (fun x y -> x*y) 1 xs ;; let sum_of_squares xs = sum (map (fun x -> x * x) xs) let pairify xs = map (fun x -> (x,x)) xs")
14 Using Anonymous FuncJons let rec reduce (f:int->int->int) (u:int) (xs:int list) : int = [] -> u hd::tl -> f hd (reduce f u tl);; let sum xs = reduce (fun x y -> x+y) 0 xs ;; let prod xs = reduce (fun x y -> x*y) 1 xs ;; let sum_of_squares xs = sum (map (fun x -> x * x) xs) let pairify xs = map (fun x -> (x,x)) xs 14
15 More on Anonymous FuncJons (nonrecursive) FuncJon declarajons are actually abbreviajons: let square x = x*x ;; let add x y = x+y ;; are syntac6c sugar for: let square = (fun x -> x*x) ;; let add = (fun x y -> x+y) ;; So, func6ons are values we can bind to a variable, just like 3 or moo or true. OCaml obeys the principle of orthogonal language design. 15
16 Simplifying further: One argument, one result let add = (fun x y -> x+y) is shorthand for: let add = (fun x -> (fun y -> x+y)) That is, add is a funcjon which: when given a value x, returns a func6on (fun y -> x+y) which: when given a value y, returns x+y. 16
17 Curried FuncJons fun x -> (fun y -> x+y) (* curried *) fun x y -> x + y (* curried *) fun (x,y) -> x+y (* uncurried *) Currying: encoding a mulj-argument funcjon using nested, higher-order funcjons. Named ager the logician Haskell B. Curry (1950s). was trying to find minimal logics that are powerful enough to encode tradijonal logics. much easier to prove something about a logic with 3 connecjves than one with 20. the ideas translate directly to math (set & category theory) as well as to computer science. (actually, Moses Schönfinkel did some of this in 1924) (thankfully, we don't have to talk about Schönfinkelled funcjons) 17
18 What is the type of add? let add = (fun x -> (fun y -> x+y)) Add s type is: int -> (int -> int) which we can write as: int -> int -> int That is, the arrow type is right-associajve. 18
19 What s so good about Currying? In addijon to simplifying the language (orthogonal design), currying funcjons so that they only take one argument leads to two major wins: 1. We can par6ally apply a funcjon. 2. We can more easily compose funcjons. 19
20 ParJal ApplicaJon let add = (fun x -> (fun y -> x+y)) ;; Curried funcjons allow defs of new, parjally applied funcjons: Equivalent to wrijng: let inc = add 1;; let inc = (fun y -> 1+y);; which is equivalent to wrijng: also: let inc y = 1+y;; let inc2 = add 2;; let inc3 = add 3;; 20
21 SIMPLE REASONING ABOUT HIGHER-ORDER FUNCTIONS
22 We can factor this program Reasoning About DefiniJons let square_all ys = match ys with hd::tl -> (square hd)::(square_all tl) ;; into this program: let rec map f xs = hd::tl -> (f hd)::(map f tl);; let square_all = map square;; a more concise and readable definijon of square_all (assuming we already had defined map) 22
23 Reasoning About DefiniJons let square_all ys = match ys with hd::tl -> (square hd)::(square_all tl) ;; let square_all = map square;; Goal: Rewrite definijons so my program is simpler, easier to understand, more concise, Ques6on: What are the reasoning principles for rewrijng programs without breaking them? For reasoning about the behavior of programs? About the equivalence of two programs? I want some rules for doing so that never fail. 23
24 Simple EquaJonal Reasoning Rewrite 1 (FuncJon de-sugaring): let f x = body == let f = (fun x -> body) Rewrite 2 (SubsJtuJon): if arg is a value or, when executed, will always terminate without effect and produce a value (fun x ->... x...) arg ==... arg... Rewrite 3 (Eta-expansion): let f = def == roughly: all occurrences of x replaced by arg (though geong this exactly right is shockingly difficult) let f x = (def) x if f has a funcjon type chose name x wisely so it does not shadow other names used in def
25 Eta-expansion is an example of Leibniz s law Gotried Wilhelm von Leibniz German Philosopher Leibniz s law: If every predicate possessed by x is also possessed by y and vice versa, then enjjes x and y are idenjcal. Frequently invoked in modern logic and philosophy. Rewrite 3 (Eta-expansion): let f = def == let f = fun x -> (def)x if f has a funcjon type chose name x wisely so it does not shadow other names used in def
26 let rec map f xs = EliminaJng the Sugar in Map hd::tl -> (f hd)::(map f tl);; 26
27 let rec map f xs = EliminaJng the Sugar in Map hd::tl -> (f hd)::(map f tl);; let rec map = (fun f -> (fun xs -> hd::tl -> (f hd)::(map f tl)));; 27
28 let rec map = (fun f -> (fun xs -> Consider square_all hd::tl -> (f hd)::(map f tl)));; let square_all = map square ;; 28
29 SubsJtute map definijon into square_all let rec map = (fun f -> (fun xs -> hd::tl -> (f hd)::(map f tl)));; let square_all = (fun f -> (fun xs -> ) ) square ;; hd::tl -> (f hd)::(map f tl) 29
30 SubsJtute map definijon into square_all let rec map = (fun f -> (fun xs -> hd::tl -> (f hd)::(map f tl)));; let square_all = (fun f -> (fun xs -> ) ) square ;; hd::tl -> (f hd)::(map f tl) 30
31 SubsJtute map definijon into square_all let rec map = (fun f -> (fun xs -> hd::tl -> (f hd)::(map f tl)));; let square_all = (fun f -> (fun xs -> ) ) square ;; hd::tl -> (f hd)::(map f tl) 31
32 let rec map = (fun f -> (fun xs -> SubsJtute Square hd::tl -> (f hd)::(map f tl)));; let square_all = ( (fun xs -> ) hd::tl -> (square hd)::(map square tl) ;; argument square subsjtuted for parameter f 32
33 let rec map = (fun f -> (fun xs -> Expanding map square hd::tl -> (f hd)::(map f tl)));; let square_all ys = ;; (fun xs -> ) ys add argument via eta-expansion hd::tl -> (square hd)::(map square tl) 33
34 let rec map = (fun f -> (fun xs -> Expanding map square hd::tl -> (f hd)::(map f tl)));; let square_all ys = match ys with subsjtute again (argument ys for parameter xs) hd::tl -> (square hd)::(map square tl) ;; 34
35 So Far let rec map f xs = hd::tl -> (f hd)::(map f tl);; let square_all xs = map square xs let square_all ys = match ys with hd::tl -> (square hd)::(map square tl) ;; proof by simple rewrijng unrolls definijon once 35
36 Next Step let rec map f xs = hd::tl -> (f hd)::(map f tl);; let square_all xs = map square xs let square_all ys = match ys with hd::tl -> (square hd)::(map square tl) ;; let square_all ys = match ys with hd::tl -> (square hd)::(square_all tl) ;; proof by simple rewrijng unrolls definijon once proof by induc6on eliminates recursive funcjon map 36
37 Summary We saw this: let rec map f xs = hd::tl -> (f hd)::(map f tl);; let square_all ys = map square Is equivalent to this: let square_all ys = match ys with hd::tl -> (square hd)::(map square tl) ;; Moral of the story (1) OCaml s HOT (higher-order, typed) funcjons capture recursion paoerns (2) we can figure out what is going on by equa6onal reasoning. (3)... but we typically need to do proofs by induc6on to reason about recursive (inducjve) funcjons 37
38 POLY-HO!
39 Here s an annoying thing let rec map (f:int->int) (xs:int list) : int list = hd::tl -> (f hd)::(map f tl);; What if I want to increment a list of floats? Alas, I can t just call this map. It works on ints! 39
40 Here s an annoying thing let rec map (f:int->int) (xs:int list) : int list = hd::tl -> (f hd)::(map f tl);; What if I want to increment a list of floats? Alas, I can t just call this map. It works on ints! let rec mapfloat (f:float->float) (xs:float list) : float list = hd::tl -> (f hd)::(mapfloat f tl);; 40
![Turns out let rec map f xs = hd::tl -> (f hd)::(map f tl);; map (fun x -> x + 1) [1; 2; 3; 4] ;;](/docs-images/94/121759471/images/41-2.jpg "map (fun x -> x +. 2.0) [3.1415; 2.718; 42.0] ;; map String.")
41 Turns out let rec map f xs = hd::tl -> (f hd)::(map f tl);; map (fun x -> x + 1) [1; 2; 3; 4] ;; map (fun x -> x ) [3.1415; 2.718; 42.0] ;; map String.uppercase [ greg ; victor ; joe ] ;; 41
42 Type of the undecorated map? let rec map f xs = hd::tl -> (f hd)::(map f tl) ;; map : ('a -> 'b) -> 'a list -> 'b list 42
43 Type of the undecorated map? let rec map f xs = hd::tl -> (f hd)::(map f tl) ;; map : ('a -> 'b) -> 'a list -> 'b list We ogen use greek leoers like α or β to represent type variables. Read as: for any types 'a and 'b, if you give map a funcjon from 'a to 'b, it will return a funcjon which when given a list of 'a values, returns a list of 'b values. 43
44 We can say this explicitly let rec map (f:'a -> 'b) (xs:'a list) : 'b list = hd::tl -> (f hd)::(map f tl) ;; map : ( a -> b) -> a list -> b list The OCaml compiler is smart enough to figure out that this is the most general type that you can assign to the code. We say map is polymorphic in the types 'a and 'b just a fancy way to say map can be used on any types 'a and 'b. Java generics derived from ML-style polymorphism (but added ager the fact and more complicated due to subtyping) 44
![More realisjc polymorphic funcjons let rec merge (lt:'a->'a->bool) (xs:'a list) (ys:'a list) : 'a list = match (xs,ys) with ([],_) -> ys (_,[]) -> xs (x::xst, y::yst) -> if lt x y then x::(merge lt](/docs-images/94/121759471/images/45-2.jpg "xst ys) else y::(merge lt xs yst) ;; let rec split (xs:'a list) (ys:'a list) (zs:'a list) : 'a list * 'a list = [] -> (ys, zs) x::rest -> split rest zs (x::ys) ;; let rec mergesort (lt:'a->'a->bool)")
45 More realisjc polymorphic funcjons let rec merge (lt:'a->'a->bool) (xs:'a list) (ys:'a list) : 'a list = match (xs,ys) with ([],_) -> ys (_,[]) -> xs (x::xst, y::yst) -> if lt x y then x::(merge lt xst ys) else y::(merge lt xs yst) ;; let rec split (xs:'a list) (ys:'a list) (zs:'a list) : 'a list * 'a list = [] -> (ys, zs) x::rest -> split rest zs (x::ys) ;; let rec mergesort (lt:'a->'a->bool) (xs:'a list) : 'a list = ([] _::[]) -> xs _ -> let (first,second) = split xs [] [] in merge lt (mergesort lt first) (mergesort lt second) ;; 45
![More realisjc polymorphic funcjons mergesort : ('a->'a->bool) -> 'a list -> 'a list mergesort (<) [3;2;7;1] == [1;2;3;7] mergesort (>) [2.718; 3.1415; 42.0] == [42.0 ; 3.1415; 2.](/docs-images/94/121759471/images/46-2.jpg "718] mergesort (fun x y -> String.compare x y < 0) [ Hi ; Bi ] == [ Bi ; Hi ] let int_sort = mergesort (<) ;; let int_sort_down = mergesort (>) ;; let str_sort = mergesort (fun x y -> String.")
46 More realisjc polymorphic funcjons mergesort : ('a->'a->bool) -> 'a list -> 'a list mergesort (<) [3;2;7;1] == [1;2;3;7] mergesort (>) [2.718; ; 42.0] == [42.0 ; ; 2.718] mergesort (fun x y -> String.compare x y < 0) [ Hi ; Bi ] == [ Bi ; Hi ] let int_sort = mergesort (<) ;; let int_sort_down = mergesort (>) ;; let str_sort = mergesort (fun x y -> String.compare x y < 0) ;; 46
47 Another InteresJng FuncJon let comp f g x = f (g x) ;; let mystery = comp (add 1) square ;; let comp = fun f -> (fun g -> (fun x -> f (g x))) ;; let mystery = comp (add 1) square ;; let mystery = (fun f -> (fun g -> (fun x -> f (g x)))) (add 1) square ;; let mystery = fun x -> (add 1) (square x) ;; let mystery x = add 1 (square x) ;; 47
48 OpJmizaJon What does this program do? map f (map g [x1; x2; ; xn]) For each element of the list x1, x2, x3... xn, it executes g, creajng: map f ([g x1; g x2; ; g xn]) Then for each element of the list [g x1, g x2, g x3... g xn], it executes f, creajng: [f (g x1); f (g x2); ; f (g xn)] Is there a faster way? Yes! (And query opjmizers for SQL do it for you.) map (comp f g) [x1; x2;...; xn] 48
49 DeforestaJon map f (map g [x1; x2; ; xn]) This kind of opjmizajon has a name: deforestajon (because it eliminates intermediate lists and, um, trees ) map (comp f g) [x1; x2;...; xn] 49
50 What is the type of comp? let comp f g x = f (g x) ;; 50
51 What is the type of comp? let comp f g x = f (g x) ;; comp : ('b -> 'c) -> ('a -> 'b) -> ('a -> 'c) 51
52 let rec reduce f u xs = [] -> u How about reduce? hd::tl -> f hd (reduce f u tl);; What s the most general type of reduce? 52
![let rec reduce f u xs = [] -> u How about reduce?](/docs-images/94/121759471/images/53-2.jpg "hd::tl -> f hd (reduce f u tl);; What s the most general type of reduce?")
53 let rec reduce f u xs = [] -> u How about reduce? hd::tl -> f hd (reduce f u tl);; What s the most general type of reduce? Based on the paoerns, we know xs must be a ('a list) for some type 'a. 53
54 How about reduce? let rec reduce f u (xs: 'a list) = [] -> u hd::tl -> f hd (reduce f u tl);; What s the most general type of reduce? 54
55 How about reduce? let rec reduce f u (xs: 'a list) = [] -> u hd::tl -> f hd (reduce f u tl);; What s the most general type of reduce? f is called so it must be a funcjon of two arguments. 55
56 How about reduce? let rec reduce (f:? ->? ->?) u (xs: 'a list) = [] -> u hd::tl -> f hd (reduce f u tl);; What s the most general type of reduce? 56
57 How about reduce? let rec reduce (f:? ->? ->?) u (xs: 'a list) = [] -> u hd::tl -> f hd (reduce f u tl);; What s the most general type of reduce? Furthermore, hd came from xs, so f must take an 'a value as its first argument. 57
58 How about reduce? let rec reduce (f:'a ->? ->?) u (xs: 'a list) = [] -> u hd::tl -> f hd (reduce f u tl);; What s the most general type of reduce? 58
59 How about reduce? let rec reduce (f:'a ->? ->?) u (xs: 'a list) = [] -> u hd::tl -> f hd (reduce f u tl);; What s the most general type of reduce? The second argument to f must have the same type as the result of reduce. Let s call it 'b. 59
60 How about reduce? let rec reduce (f:'a -> 'b ->?) u (xs: 'a list) : 'b = [] -> u hd::tl -> f hd (reduce f u tl);; What s the most general type of reduce? The result of f must have the same type as the result of reduce overall: 'b. 60
61 How about reduce? let rec reduce (f:'a -> 'b -> 'b) u (xs: 'a list) : 'b = [] -> u hd::tl -> f hd (reduce f u tl);; What s the most general type of reduce? 61
62 How about reduce? let rec reduce (f:'a -> 'b ->?) u (xs: 'a list) : 'b = [] -> u hd::tl -> f hd (reduce f u tl);; What s the most general type of reduce? If xs is empty, then reduce returns u. So u s type must be 'b. 62
63 How about reduce? let rec reduce (f:'a -> 'b -> 'b) (u:'b) (xs: 'a list) : 'b = [] -> u hd::tl -> f hd (reduce f u tl);; What s the most general type of reduce? 63
64 How about reduce? let rec reduce (f:'a -> 'b -> 'b) (u:'b) (xs: 'a list) : 'b = [] -> u hd::tl -> f hd (reduce f u tl);; What s the most general type of reduce? ('a -> 'b -> 'b) -> 'b -> 'a list -> 'b 64
65 The List Library NB: map and reduce are already defined in the List library. However, reduce is called fold_right. (Good bet there s a fold_leg too.) I ll use reduce instead of fold_right, for 3 reasons: Analogy with Google s Map/Reduce The library s arguments to fold_right are in the "wrong" order Makes the example fit on a slide. 65
66 Summary Map and reduce are two higher-order func6ons that capture very, very common recursion paferns Reduce is especially powerful: related to the visitor paoern of OO languages like Java. can implement most list-processing funcjons using it, including things like copy, append, filter, reverse, map, etc. We can write clear, terse, reusable code by exploijng: higher-order funcjons anonymous funcjons first-class funcjons polymorphism 66
67 PracJce Problems Using map, write a funcjon that takes a list of pairs of integers, and produces a list of the sums of the pairs. e.g., list_add [(1,3); (4,2); (3,0)] = [4; 6; 3] Write list_add directly using reduce. Using map, write a funcjon that takes a list of pairs of integers, and produces their quojent if it exists. e.g., list_div [(1,3); (4,2); (3,0)] = [Some 0; Some 2; None] Write list_div directly using reduce. Using reduce, write a funcjon that takes a list of opjonal integers, and filters out all of the None s. e.g., filter_none [Some 0; Some 2; None; Some 1] = [0;2;1] Why can t we directly use filter? How would you generalize filter so that you can compute filter_none? AlternaJvely, rig up a solujon using filter + map. Using reduce, write a funcjon to compute the sum of squares of a list of numbers. e.g., sum_squares = [3,5,2] = 38 67
COSE212: Programming Languages. Lecture 4 Recursive and Higher-Order Programming
COSE212: Programming Languages Lecture 4 Recursive and Higher-Order Programming Hakjoo Oh 2016 Fall Hakjoo Oh COSE212 2016 Fall, Lecture 4 September 27, 2016 1 / 21 Recursive and Higher-Order Programming
Thinking Induc,vely. COS 326 David Walker Princeton University
Thinking Induc,vely COS 326 David Walker Princeton University slides copyright 2017 David Walker permission granted to reuse these slides for non-commercial educa,onal purposes Administra,on 2 Assignment
Tuples. CMSC 330: Organization of Programming Languages. Examples With Tuples. Another Example
CMSC 330: Organization of Programming Languages OCaml 2 Higher Order Functions Tuples Constructed using (e1,..., en) Deconstructed using pattern matching Patterns involve parens and commas, e.g., (p1,p2,
Thinking Induc,vely. COS 326 David Walker Princeton University
Thinking Induc,vely COS 326 David Walker Princeton University slides copyright 2013-2015 David Walker and Andrew W. Appel permission granted to reuse these slides for non-commercial educa,onal purposes
CSE341: Programming Languages Lecture 9 Function-Closure Idioms. Dan Grossman Fall 2011
CSE341: Programming Languages Lecture 9 Function-Closure Idioms Dan Grossman Fall 2011 More idioms We know the rule for lexical scope and function closures Now what is it good for A partial but wide-ranging
Lecture #23: Conversion and Type Inference
Lecture #23: Conversion and Type Inference Administrivia. Due date for Project #2 moved to midnight tonight. Midterm mean 20, median 21 (my expectation: 17.5). Last modified: Fri Oct 20 10:46:40 2006 CS164:
Conversion vs. Subtyping. Lecture #23: Conversion and Type Inference. Integer Conversions. Conversions: Implicit vs. Explicit. Object x = "Hello";
Lecture #23: Conversion and Type Inference Administrivia. Due date for Project #2 moved to midnight tonight. Midterm mean 20, median 21 (my expectation: 17.5). In Java, this is legal: Object x = "Hello";
Lab 10: OCaml sequences, comparators, stable sorting 12:00 PM, Nov 12, 2017
Integrated Introduction to Computer Science Hughes Lab 10: OCaml sequences, comparators, stable sorting 12:00 PM, Nov 12, 2017 Contents 1 A last OCaml type, and its utility 1 1.1 Sequences in OCaml....................................
Implemen'ng OCaml in OCaml
1 An OCaml defini'on of OCaml evalua'on, or, Implemen'ng OCaml in OCaml COS 326 David Walker Princeton University slides copyright 2013-2015 David Walker and Andrew W. Appel permission granted to reuse
CSE341: Programming Languages Lecture 9 Function-Closure Idioms. Dan Grossman Winter 2013
CSE341: Programming Languages Lecture 9 Function-Closure Idioms Dan Grossman Winter 2013 More idioms We know the rule for lexical scope and function closures Now what is it good for A partial but wide-ranging
CSCE 314 Programming Languages
CSCE 314 Programming Languages Haskell: Higher-order Functions Dr. Hyunyoung Lee 1 Higher-order Functions A function is called higher-order if it takes a function as an argument or returns a function as
CS Lecture 6: Map and Fold. Prof. Clarkson Spring Today s music: Selections from the soundtrack to 2001: A Space Odyssey
CS 3110 Lecture 6: Map and Fold Prof. Clarkson Spring 2015 Today s music: Selections from the soundtrack to 2001: A Space Odyssey Review Course so far: Syntax and semantics of (most of) OCaml Today: No
Introduction to OCaml
Introduction to OCaml Jed Liu Department of Computer Science Cornell University CS 6110 Lecture 26 January 2009 Based on CS 3110 course notes and an SML tutorial by Mike George Jed Liu Introduction to
COSE212: Programming Languages. Lecture 3 Functional Programming in OCaml
COSE212: Programming Languages Lecture 3 Functional Programming in OCaml Hakjoo Oh 2017 Fall Hakjoo Oh COSE212 2017 Fall, Lecture 3 September 18, 2017 1 / 44 Why learn ML? Learning ML is a good way of
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 ::
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,
Background. CMSC 330: Organization of Programming Languages. Useful Information on OCaml language. Dialects of ML. ML (Meta Language) Standard ML
CMSC 330: Organization of Programming Languages Functional Programming with OCaml 1 Background ML (Meta Language) Univ. of Edinburgh, 1973 Part of a theorem proving system LCF The Logic of Computable Functions
The Haskell HOP: Higher-order Programming
The Haskell HOP: Higher-order Programming COS 441 Slides 6 Slide content credits: Ranjit Jhala, UCSD Agenda Haskell so far: First-order functions This time: Higher-order functions: Functions as data, arguments
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
SNU Programming Language Theory
SNU 4541.574 Programming Language Theory Polymorphism Polymorphism We encountered the concept of polymorphism very briefly last time. Let s look at it now in a bit more detail. # let rec last l = match
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
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
CS Lecture 6: Map and Fold. Prof. Clarkson Fall Today s music: Selections from the soundtrack to 2001: A Space Odyssey
CS 3110 Lecture 6: Map and Fold Prof. Clarkson Fall 2014 Today s music: Selections from the soundtrack to 2001: A Space Odyssey Review Features so far: variables, operators, let expressions, if expressions,
OCaml. ML Flow. Complex types: Lists. Complex types: Lists. The PL for the discerning hacker. All elements must have same type.
OCaml The PL for the discerning hacker. ML Flow Expressions (Syntax) Compile-time Static 1. Enter expression 2. ML infers a type Exec-time Dynamic Types 3. ML crunches expression down to a value 4. Value
Type Inference. COS 326 David Walker Princeton University
Type Inference COS 326 David Walker Princeton University slides copyright 2017 David Walker permission granted to reuse these slides for non-commercial educafonal purposes 2 Midterm Exam Wed Oct 25, 2017
A Second Look At ML. Chapter Seven Modern Programming Languages, 2nd ed. 1
A Second Look At ML Chapter Seven Modern Programming Languages, 2nd ed. 1 Outline Patterns Local variable definitions A sorting example Chapter Seven Modern Programming Languages, 2nd ed. 2 Two Patterns
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 =
CS152: Programming Languages. Lecture 11 STLC Extensions and Related Topics. Dan Grossman Spring 2011
CS152: Programming Languages Lecture 11 STLC Extensions and Related Topics Dan Grossman Spring 2011 Review e ::= λx. e x e e c v ::= λx. e c τ ::= int τ τ Γ ::= Γ, x : τ (λx. e) v e[v/x] e 1 e 1 e 1 e
Shell CSCE 314 TAMU. Higher Order Functions
1 CSCE 314: Programming Languages Dr. Dylan Shell Higher Order Functions 2 Higher-order Functions A function is called higher-order if it takes a function as an argument or returns a function as a result.
# 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
Introduction to Programming, Aug-Dec 2006
Introduction to Programming, Aug-Dec 2006 Lecture 3, Friday 11 Aug 2006 Lists... We can implicitly decompose a list into its head and tail by providing a pattern with two variables to denote the two components
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
Introduction to OCaml
Fall 2018 Introduction to OCaml Yu Zhang Course web site: http://staff.ustc.edu.cn/~yuzhang/tpl References Learn X in Y Minutes Ocaml Real World OCaml Cornell CS 3110 Spring 2018 Data Structures and Functional
Patterns The Essence of Functional Programming
Patterns The Essence of Functional Programming Up to now we have defined functions in a very traditional way: function name + variable name parameters Read Chap 7 In functional programming we can exploit
Haske k ll An introduction to Functional functional programming using Haskell Purely Lazy Example: QuickSort in Java Example: QuickSort in Haskell
Haskell An introduction to functional programming using Haskell Anders Møller amoeller@cs.au.dk The most popular purely functional, lazy programming language Functional programming language : a program
Modules and Representation Invariants
Modules and Representation Invariants COS 326 Andrew W. Appel Princeton University slides copyright 2013-2015 David Walker and Andrew W. Appel In previous classes: Reasoning about individual OCaml expressions.
To figure this out we need a more precise understanding of how ML works
Announcements: What are the following numbers: 74/2/70/17 (2:30,2:30,3:35,7:30) PS2 due Thursday 9/20 11:59PM Guest lecture on Tuesday 9/25 o No RDZ office hours next Friday, I am on travel A brief comment
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
Chapter 3 Linear Structures: Lists
Plan Chapter 3 Linear Structures: Lists 1. Two constructors for lists... 3.2 2. Lists... 3.3 3. Basic operations... 3.5 4. Constructors and pattern matching... 3.6 5. Simple operations on lists... 3.9
CSc 372 Comparative Programming Languages
CSc 372 Comparative Programming Languages 8 : Haskell Function Examples Christian Collberg collberg+372@gmail.com Department of Computer Science University of Arizona Copyright c 2005 Christian Collberg
Today s Plan. Programming Languages. Example : Factorial. Recursion. CSE 130 : Spring Lecture 6: Higher-Order Functions
CSE 130 : Spring 2011 Programming Languages Lecture 6: Higher-Order Ranjit Jhala UC San Diego Today s Plan A little more practice with recursion Base Pattern -> Base Expression Induction Pattern -> Induction
An introduction introduction to functional functional programming programming using usin Haskell
An introduction to functional programming using Haskell Anders Møller amoeller@cs.au.dkau Haskell The most popular p purely functional, lazy programming g language Functional programming language : a program
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
Functional Programming and λ Calculus. Amey Karkare Dept of CSE, IIT Kanpur
Functional Programming and λ Calculus Amey Karkare Dept of CSE, IIT Kanpur 0 Software Development Challenges Growing size and complexity of modern computer programs Complicated architectures Massively
Introduction to ML. Mooly Sagiv. Cornell CS 3110 Data Structures and Functional Programming
Introduction to ML Mooly Sagiv Cornell CS 3110 Data Structures and Functional Programming The ML Programming Language General purpose programming language designed by Robin Milner in 1970 Meta Language
Functional Programming. Pure Functional Programming
Functional Programming With examples in F# Pure Functional Programming Functional programming involves evaluating expressions rather than executing commands. Computation is largely performed by applying
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
5. Introduction to the Lambda Calculus. Oscar Nierstrasz
5. Introduction to the Lambda Calculus Oscar Nierstrasz Roadmap > What is Computability? Church s Thesis > Lambda Calculus operational semantics > The Church-Rosser Property > Modelling basic programming
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
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
PROGRAMMING IN HASKELL. CS Chapter 6 - Recursive Functions
PROGRAMMING IN HASKELL CS-205 - Chapter 6 - Recursive Functions 0 Introduction As we have seen, many functions can naturally be defined in terms of other functions. factorial :: Int Int factorial n product
Parallelism; Parallel Collections
Parallelism; Parallel Collections COS 326 Andrew W. Appel Princeton University slides copyright 2013-2015 David Walker and Andrew W. Appel let x = 1 + 2 in 3 + x Visualizing Computational Costs Visualizing
Chapter 3 Linear Structures: Lists
Plan Chapter 3 Linear Structures: Lists 1. Lists... 3.2 2. Basic operations... 3.4 3. Constructors and pattern matching... 3.5 4. Polymorphism... 3.8 5. Simple operations on lists... 3.11 6. Application:
Functional Programming. Introduction To Cool
Functional Programming Introduction To Cool #1 Cunning Plan ML Functional Programming Fold Sorting Cool Overview Syntax Objects Methods Types #2 This is my final day... as your... companion... through
Introduction to the Lambda Calculus
Introduction to the Lambda Calculus Overview: What is Computability? Church s Thesis The Lambda Calculus Scope and lexical address The Church-Rosser Property Recursion References: Daniel P. Friedman et
Lecture 6: Sequential Sorting
15-150 Lecture 6: Sequential Sorting Lecture by Dan Licata February 2, 2012 Today s lecture is about sorting. Along the way, we ll learn about divide and conquer algorithms, the tree method, and complete
Chapter 11 :: Functional Languages
Chapter 11 :: Functional Languages Programming Language Pragmatics Michael L. Scott Copyright 2016 Elsevier 1 Chapter11_Functional_Languages_4e - Tue November 21, 2017 Historical Origins The imperative
Recap: Functions as first-class values
Recap: Functions as first-class values Arguments, return values, bindings What are the benefits? Parameterized, similar functions (e.g. Testers) Creating, (Returning) Functions Iterator, Accumul, Reuse
Lambda expressions, functions and binding
Informatics 1 Functional Programming Lecture 8 Lambda expressions, functions and binding Don Sannella University of Edinburgh Part I Lambda expressions A failed attempt to simplify f :: [Int] -> Int f
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-505: Programming Languages. Lecture 20.5 Recursive Types. Zach Tatlock 2016
CSE-505: Programming Languages Lecture 20.5 Recursive Types Zach Tatlock 2016 Where are we System F gave us type abstraction code reuse strong abstractions different from real languages (like ML), but
Programming Languages 3. Definition and Proof by Induction
Programming Languages 3. Definition and Proof by Induction Shin-Cheng Mu Oct. 22, 2015 Total Functional Programming The next few lectures concerns inductive definitions and proofs of datatypes and programs.
Fundamentals and lambda calculus. Deian Stefan (adopted from my & Edward Yang s CSE242 slides)
Fundamentals and lambda calculus Deian Stefan (adopted from my & Edward Yang s CSE242 slides) Logistics Assignments: Programming assignment 1 is out Homework 1 will be released tomorrow night Podcasting:
COMP 1130 Lambda Calculus. based on slides by Jeff Foster, U Maryland
COMP 1130 Lambda Calculus based on slides by Jeff Foster, U Maryland Motivation Commonly-used programming languages are large and complex ANSI C99 standard: 538 pages ANSI C++ standard: 714 pages Java
Introduction to ML. Mooly Sagiv. Cornell CS 3110 Data Structures and Functional Programming
Introduction to ML Mooly Sagiv Cornell CS 3110 Data Structures and Functional Programming Typed Lambda Calculus Chapter 9 Benjamin Pierce Types and Programming Languages Call-by-value Operational Semantics
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
CS-XXX: Graduate Programming Languages. Lecture 17 Recursive Types. Dan Grossman 2012
CS-XXX: Graduate Programming Languages Lecture 17 Recursive Types Dan Grossman 2012 Where are we System F gave us type abstraction code reuse strong abstractions different from real languages (like ML),
Anonymous Functions CMSC 330: Organization of Programming Languages
Anonymous Functions CMSC 330: Organization of Programming Languages Recall code blocks in Ruby (1..10).each { x print x Here, we can think of { x print x as a function OCaml 2 Higher Order Functions 1
Dialects of ML. CMSC 330: Organization of Programming Languages. Dialects of ML (cont.) Features of ML. Functional Languages. Features of ML (cont.
CMSC 330: Organization of Programming Languages OCaml 1 Functional Programming Dialects of ML ML (Meta Language) Univ. of Edinburgh,1973 Part of a theorem proving system LCF The Logic of Computable Functions
Programming Languages
CSE 130 : Winter 2009 Programming Languages News PA 2 out, and due Mon 1/26 5pm Lecture 5: Functions and Datatypes t UC San Diego Recap: Environments Phone book Variables = names Values = phone number
Introduction to ML. Mooly Sagiv. Cornell CS 3110 Data Structures and Functional Programming
Introduction to ML Mooly Sagiv Cornell CS 3110 Data Structures and Functional Programming The ML Programming Language General purpose programming language designed by Robin Milner in 1970 Meta Language
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
INF121: Functional Algorithmic and Programming
INF121: Functional Algorithmic and Programming Lecture 6: Polymorphism, Higher-order, and Currying Academic Year 2011-2012 In the previous episodes of INF 121 Basic Types: Booleans, Integers, Floats, Chars,
Functional Programming
Functional Programming COMS W4115 Prof. Stephen A. Edwards Spring 2003 Columbia University Department of Computer Science Original version by Prof. Simon Parsons Functional vs. Imperative Imperative programming
CSE 505: Concepts of Programming Languages
CSE 505: Concepts of Programming Languages Dan Grossman Fall 2003 Lecture 6 Lambda Calculus Dan Grossman CSE505 Fall 2003, Lecture 6 1 Where we are Done: Modeling mutation and local control-flow Proving
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
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
FUNCTIONAL PROGRAMMING
FUNCTIONAL PROGRAMMING Map, Fold, and MapReduce Prof. Clarkson Summer 2015 Today s music: Selections from the soundtrack to 2001: A Space Odyssey Review Yesterday: Lists: OCaml's awesome built-in datatype
Programming Languages. Tail Recursion. CSE 130: Winter Lecture 8: NOT TR. last thing function does is a recursive call
CSE 130: Winter 2010 News Programming Languages Lecture 8: Higher-Order Od Functions Ranjit Jhala UC San Diego Today s Plan Finish Static Scoping Tail Recursion last thing function does is a recursive
COP4020 Programming Languages. Functional Programming Prof. Robert van Engelen
COP4020 Programming Languages Functional Programming Prof. Robert van Engelen Overview What is functional programming? Historical origins of functional programming Functional programming today Concepts
Case by Case. Chapter 3
Chapter 3 Case by Case In the previous chapter, we used the conditional expression if... then... else to define functions whose results depend on their arguments. For some of them we had to nest the conditional
Types, Type Inference and Unification
Types, Type Inference and Unification Mooly Sagiv Slides by Kathleen Fisher and John Mitchell Cornell CS 6110 Summary (Functional Programming) Lambda Calculus Basic ML Advanced ML: Modules, References,
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
CSci 4223 Lecture 12 March 4, 2013 Topics: Lexical scope, dynamic scope, closures
CSci 4223 Lecture 12 March 4, 2013 Topics: Lexical scope, dynamic scope, closures 1 Lexical Scope SML, and nearly all modern languages, follow the Rule of Lexical Scope: the body of a function is evaluated
Sometimes it s good to be lazy
Chapter 8 Sometimes it s good to be lazy Typically, languages such as OCaml (SML, Lisp or Scheme) evaluate expressions by a call-by-value discipline. All variables in OCaml are bound by value, which means
Cunning Plan. One-Slide Summary. Functional Programming. Functional Programming. Introduction to COOL #1. Classroom Object-Oriented Language
Functional Programming Introduction to COOL #1 Cunning Plan Functional Programming Types Pattern Matching Higher-Order Functions Classroom Object-Oriented Language Methods Attributes Inheritance Method
02157 Functional Programming. Michael R. Ha. Lecture 2: Functions, Types and Lists. Michael R. Hansen
Lecture 2: Functions, Types and Lists nsen 1 DTU Compute, Technical University of Denmark Lecture 2: Functions, Types and Lists MRH 13/09/2018 Outline Functions as first-class citizens Types, polymorphism
Watch out for the arrows. Recollecting Haskell, Part V. A start on higher types: Mapping, 1. A start on higher types: Mapping, 2.
Watch out for the arrows Recollecting Haskell, Part V Higher Types CIS 352/Spring 2018 Programming Languages January 30, 2018 1 / 28 2 / 28 A start on higher types: Mapping, 1 Mapping via list comprehension
Functions. Nate Foster Spring 2018
Functions Nate Foster Spring 2018 A0: Warmup Worth only 1% of final grade; other assignments will be 5% much easier coding problems intended to give you low-stakes experience with 3110 workflow Please
Tail Calls. CMSC 330: Organization of Programming Languages. Tail Recursion. Tail Recursion (cont d) Names and Binding. Tail Recursion (cont d)
CMSC 330: Organization of Programming Languages Tail Calls A tail call is a function call that is the last thing a function does before it returns let add x y = x + y let f z = add z z (* tail call *)
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
News. Programming Languages. Recap. Recap: Environments. Functions. of functions: Closures. CSE 130 : Fall Lecture 5: Functions and Datatypes
CSE 130 : Fall 2007 Programming Languages News PA deadlines shifted PA #2 now due 10/24 (next Wed) Lecture 5: Functions and Datatypes Ranjit Jhala UC San Diego Recap: Environments Phone book Variables
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
Programming Languages
CSE 130: Fall 2009 Programming Languages Lecture 2: A Crash Course in ML News On webpage: Suggested HW #1 PA #1 (due next Fri 10/9) Technical issues installing Ocaml - should be resolved soon! Ranjit Jhala
Review. CS152: Programming Languages. Lecture 11 STLC Extensions and Related Topics. Let bindings (CBV) Adding Stuff. Booleans and Conditionals
Review CS152: Programming Languages Lecture 11 STLC Extensions and Related Topics e ::= λx. e x ee c v ::= λx. e c (λx. e) v e[v/x] e 1 e 2 e 1 e 2 τ ::= int τ τ Γ ::= Γ,x : τ e 2 e 2 ve 2 ve 2 e[e /x]:
CMSC 330: Organization of Programming Languages. Operational Semantics
CMSC 330: Organization of Programming Languages Operational Semantics Notes about Project 4, Parts 1 & 2 Still due today (7/2) Will not be graded until 7/11 (along with Part 3) You are strongly encouraged
Fundamentals and lambda calculus
Fundamentals and lambda calculus Again: JavaScript functions JavaScript functions are first-class Syntax is a bit ugly/terse when you want to use functions as values; recall block scoping: (function ()
Efficient Mergesort. Christian Sternagel. August 28, 2014
Efficient Mergesort Christian Sternagel August 28, 2014 Abstract We provide a formalization of the mergesort algorithm as used in GHC s Data.List module, proving correctness and stability. Furthermore,
ML Built-in Functions
ML Built-in Functions Since ML is a functional programming language, many of its built-in functions are concerned with function application to objects and structures. In ML, built-in functions are curried
Programming Language Concepts: Lecture 14
Programming Language Concepts: Lecture 14 Madhavan Mukund Chennai Mathematical Institute madhavan@cmi.ac.in http://www.cmi.ac.in/~madhavan/courses/pl2009 PLC 2009, Lecture 14, 11 March 2009 Function programming