Functional Programming
|
|
|
- Charleen Chandler
- 6 years ago
- Views:
Transcription
1 Functional Programming A Brief Introduction to Standard ML Arnd Poetzsch-Heffter Software Technology Group Fachbereich Informatik Technische Universität Kaiserslautern Sommersemester 2010 Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
2 Outline I Overview 1 Overview Functional Programming Standard ML 2 Standard ML in Examples Evalutation and Bindings Operations and Functions Standard Data Types Polymorphism and Type Inference Miscellaneous 3 Cases and Pattern Matching Tuples Case Analysis 4 Data Types Simple Data Types Recursive Data Types Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
3 Outline II Overview 5 Modules Structures Signatures Modules in Moscow ML 6 Implementing a Simple Theorem Prover Introduction Basic Data Structures Substitution and Unification 7 Summary Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
4 Functional Programming Overview Functional Programming Fact A functional program consists of function declarations data type declarations an expression Functional Programs do not have variables, assigments, statements, loops,... instead: let-expressions recursive functions higher-order functions Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
5 Functional Programming Overview Functional Programming Advantages clearer semantics corresponds more directly to abstract mathematical objects more freedom in implementation Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
6 Overview Standard ML The SML Programming Language Overview functional programming language interpreter and compiler available strongly typed, with: type inference abstract data types parametric polymorphism exception-handling mechanisms Motivation ML is similar to functional core of Isabelle/HOL specification language ML is the implementation language of the theorem prover Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
7 Outline I SML in Examples 1 Overview Functional Programming Standard ML 2 Standard ML in Examples Evalutation and Bindings Operations and Functions Standard Data Types Polymorphism and Type Inference Miscellaneous 3 Cases and Pattern Matching Tuples Case Analysis 4 Data Types Simple Data Types Recursive Data Types Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
8 Outline II SML in Examples 5 Modules Structures Signatures Modules in Moscow ML 6 Implementing a Simple Theorem Prover Introduction Basic Data Structures Substitution and Unification 7 Summary Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
9 Evaluation and Bindings SML in Examples Evalutation and Bindings Example (Evaluation) 2 + 3; val it = 5 : int rev [1,2,3,4,5]; val it = [5,4,3,2,1] : int list Example (Simple Bindings) val n = ; val n = 21 : int n 2; val it = 42 : int Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
10 Bindings SML in Examples Evalutation and Bindings Example (Special Identifier it) it ; val it = 42 : int Example (Multiple Bindings) val one = 1 and two = 2; val one = 1 : int val two = 2 : int Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
11 Local Bindings SML in Examples Evalutation and Bindings Example (Simple Local Binding) val n = 0; val n = 0 : int let val n = 12 in n div 6 end; val it = 2 : int n; val it = 0 : int Example (Multiple Local Bindings) let val n = 5 val m = 6 in n + m end; val it = 11 : int Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
12 Booleans SML in Examples Operations and Functions Example (Operations) val b1 = true and b2 = false; val b1 = true : bool val b2 = false : bool 1 = (1 + 1); val it = false : bool not (b1 orelse b2); val it = false : bool (7 < 3) andalso (false orelse 2 > 0); val it = false : bool Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
13 Integers SML in Examples Operations and Functions Example (Operations) val n = 2 + (3 4); val n = 14 : int val n = (10 div 2) 7; val n = ~2 : int Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
14 Applying Functions SML in Examples Operations and Functions General Rules type of functions from σ 1 to σ 2 is σ 1 σ 2 application f x applies function f to argument x call-by-value (obvious!) left associative: m n o p = (((m n)o)p) Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
15 Defining Functions SML in Examples Operations and Functions Example (One Argument) fun f n = n + 2; val f = fn : int > int f 22; val it = 24 : int Example (Two or More Arguments) fun plus n (m:int) = n + m; val plus = fn : int > int > int plus 2 3; val it = 5 : int Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
16 Currying SML in Examples Operations and Functions Example (Curried Addition) fun plus n (m:int) = n + m; val plus = fn : int > int > int plus 1 2; val it = 3 : int Example (Partial Application) val inc = plus 1; val inc = fn : int > int inc 7; val it = 8 : int Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
17 Higher-Order Functions SML in Examples Operations and Functions Example (Higher-Order Functions) fun foo f n = ( f (n+1)) div 2 ; val foo = fn : ( int > int) > int > int foo inc 3; val it = 2 : int Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
18 Recursive Functions SML in Examples Operations and Functions Example (Defining Recursive Functions) fun f n = if (n=0) then 1 else n f (n 1); val f = fn : int > int f 3; val it = 6 : int fun member x [] = false member x (h::t) = (x=h) orelse (member x t); val member = fn : a > a list > bool member 3 [1,2,3,4]; val it = true : bool Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
19 Lambda Abstractions SML in Examples Operations and Functions Example (The Increment Function) fn x=> x + 1; val it = fn : int > int (fn x=> x + 1) 2; val it = 3 : int Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
20 Lambda Abstractions SML in Examples Operations and Functions Example (Curried Multiplication) fn x=> fn y=> x (y: int ); val it = fn : int > int > int val double = (fn x=> fn y=> x (y: int )) 2; val double = fn : int > int double 22; val it = 44 : int Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
21 Clausal Definitions SML in Examples Operations and Functions Example (Fibonacci) fun fib 0 = 1 fib 1 = 1 fib n = fib (n 1) + fib(n 2); Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
22 Exceptions SML in Examples Operations and Functions Example (Failure) hd []; uncaught exception Hd 1 div 0; uncaught exception Div Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
23 User-Defined Exceptions SML in Examples Operations and Functions Example (Explicitly Generating Failure) exception negative_argument_to_fact; exception negative_argument_to_fact fun fact n = if (n<0) then raise negative_argument_to_fact else if (n=0) then 1 else n fact (n 1); val fact = fn : int > int fact (~1); uncaught exception negative_argument_to_fact Example (Exception Handling) (fact(~1)) handle negative_argument_to_fact => 0; val it = 0 : int Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
24 Unit SML in Examples Standard Data Types Example (Unit) (); val it = () : unit close_theory; val it = fn : unit > unit Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
25 Character Strings SML in Examples Standard Data Types Example (String Operations) "abc"; val it = "abc" : string chr; val it = fn : int > string chr 97; val it = "a" : string Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
26 List Constructors SML in Examples Standard Data Types Example (Empty Lists) null l ; val it = false : bool null []; val it = true : bool Example (Construction and Concatenation) 9 :: l ; val it = [9,2,3,5] : int list [true, false [false,true ]; val it = [true, false, false,true] : bool list Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
27 List Operations SML in Examples Standard Data Types Example (Head and Tail) val l = [2,3,2+3]; val l = [2,3,5] : int list hd l; val it = 2 : int tl l ; val it = [3,5] : int list Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
28 Pattern Matching SML in Examples Standard Data Types Example (Pattern Matching and Lists) fun bigand [] = true bigand (h:: t ) = h andalso bigand t; val bigand = fn : bool list > bool Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
29 Pairs SML in Examples Standard Data Types Example (Pair Functions) val p = (2,3); val p = (2,3) : int int fst p; val it = 2 : int snd p; val it = 3 : int Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
30 Records SML in Examples Standard Data Types Example (Date Record) val date = {day=4,month="february",year=1967} : {day: int, month:string, year: int } val {day=d,month=m,year=y} = date; val d = 4 : int val m = "february" : string val y = 1967 : int #month date; val it = "february" : string Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
31 Polymorphism SML in Examples Polymorphism and Type Inference Example (Head Function) hd [2,3]; val it = 2 : int hd [true, false ]; val it = true : bool Problem What is the type of hd? int list > int or bool list > bool Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
32 Polymorphism SML in Examples Polymorphism and Type Inference Example (Type of Head Function) hd; val it = fn : a list > a Example (Polymorphic Head Function) head function has both types a is a type variable. hd can have any type of the form σ list > σ (where σ is an SML type) Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
33 Type Inference SML in Examples Polymorphism and Type Inference Example (Mapping Function) fun map f l = if ( null l ) then [] else f (hd l )::( map f ( tl l )); val map = fn : ( a > b) > a list > b list map (fn x=>0); val it = fn : a list > int list Fact (ML Type Inference) SML infers the most general type. Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
34 Standard List Operations SML in Examples Polymorphism and Type Inference Example (Mapping) fun map f [] = [] map f (h:: t ) = f h :: map f t ; val ( a, b) map = fn : ( a > b) > a list > b list Example (Filtering) fun filter P [] = [] filter P (h:: t ) = if P h then h:: filter P t else filter P t ; val a filter = fn : ( a > bool) > a list > a list Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
35 Type Inference SML in Examples Polymorphism and Type Inference Example (Function Composition) fun comp f g x = f(g x); val comp = fn:( a > b) > ( c > a) > c > b comp null (map (fn y=> y+1)); val it = fn : int list > bool Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
36 Some System Functions SML in Examples Miscellaneous Example (Load a file called file.sml) use; val it = fn : string > unit use " file.sml"; [opening file.sml]... Key Commands terminate the session: <Ctrl> D interrupt: <Ctrl> C Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
37 Outline I Cases and Pattern Matching 1 Overview Functional Programming Standard ML 2 Standard ML in Examples Evalutation and Bindings Operations and Functions Standard Data Types Polymorphism and Type Inference Miscellaneous 3 Cases and Pattern Matching Tuples Case Analysis 4 Data Types Simple Data Types Recursive Data Types Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
38 Outline II Cases and Pattern Matching 5 Modules Structures Signatures Modules in Moscow ML 6 Implementing a Simple Theorem Prover Introduction Basic Data Structures Substitution and Unification 7 Summary Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
39 Tuples Cases and Pattern Matching Tuples Example (Tuples) val pair = (2,3); > val pair = (2, 3) : int int val triple = (2,2.0, "2" ); > val triple = (2, 2.0, "2") : int real string val pairs_of_pairs = ((2,3),(2.0,3.0)); > val pairs_of_pairs = ((2, 3), (2.0, 3.0)) : ( int int ) ( real real ) Example (Unit Type) val null_tuple = (); > val null_tuple = () : unit Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
40 Cases and Pattern Matching Accessing Components Tuples Example (Navigating to the Position) val xy1 = #1 pairs_of_pairs; > val xy1 = (2, 3) : int int val y1 = #2 (#1 pairs_of_pairs ); > val y1 = 3 : int Example (Using Pattern Matching) val ((x1,y1 ),( x2,y2)) = pairs_of_pairs; > val x1 = 2 : int val y1 = 3 : int val x2 = 2.0 : real val y2 = 3.0 : real Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
41 Pattern Matching Cases and Pattern Matching Tuples Example (Granularity) val ((x1,y1),xy2) = pairs_of_pairs; > val x1 = 2 : int val y1 = 3 : int val xy2 = (2.0, 3.0) : real real Example (Wildcard Pattern) val ((_,y1 ),( _,_)) = pairs_of_pairs; > val y1 = 3 : int val ((_,y1),_) = pairs_of_pairs; > val y1 = 3 : int Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
42 Pattern Matching Cases and Pattern Matching Tuples Example (Value Patterns) val 0 = 1 1; val (0,x) = (1 1,34); > val x = 34 : int val (0,x) = (2 1,34);! Uncaught exception:! Bind Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
43 Binding Values Cases and Pattern Matching Tuples General Rules The variable binding val var = val is irreducible. The wildcard binding val _ = val is discarded. The tuple binding val(pat1,..., patn) = (val1,..., valn ) is reduced to val pat1 = valn... val patn = valn Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
44 Cases and Pattern Matching Clausal Function Expressions Case Analysis Example (Clausal Function Expressions) fun not true = false not false = true; > val not = fn : bool > bool Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
45 Redundant Cases Cases and Pattern Matching Case Analysis Example (Redundant Cases) fun not True = false not False = true;! Warning: some cases are unused in this match. > val a not = fn : a > bool not false; > val it = false : bool not 3; > val it = false : bool Fact (Redundant Cases) Redundant cases are always a mistake! Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
46 Inexhaustive Matches Cases and Pattern Matching Case Analysis Example (Inexhaustive Matches) fun first_ten 0 = true first_ten 1 = true first_ten 2 = true first_ten 3 = true first_ten 4 = true first_ten 5 = true first_ten 6 = true first_ten 7 = true first_ten 8 = true first_ten 9 = true;! Warning: pattern matching is not exhaustive > val first_ten = fn : int > bool first_ten 5; > val it = true : bool first_ten ~1;! Uncaught exception: Match Fact (Inexhaustive Matches) Inexhaustive matches may be a problem. Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
47 Catch-All Clauses Cases and Pattern Matching Case Analysis Example (Catch-All Clauses) fun first_ten 0 = true first_ten 1 = true first_ten 2 = true first_ten 3 = true first_ten 4 = true first_ten 5 = true first_ten 6 = true first_ten 7 = true first_ten 8 = true first_ten 9 = true first_ten _ = false ; > val first_ten = fn : int > bool Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
48 Overlapping Cases Cases and Pattern Matching Case Analysis Example (Overlapping Cases) fun foo1 1 _ = 1 foo1 _ 1 = 2 foo1 = 0; > val foo1 = fn : int > int > int fun foo2 _ 1 = 1 foo2 1 _ = 2 foo2 = 0; > val foo2 = fn : int > int > int foo1 1 1; > val it = 1 : int foo2 1 1; > val it = 1 : int Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
49 Cases and Pattern Matching Recursively Defined Functions Case Analysis Example (Recursively Defined Function) fun factorial 0 = 1 factorial n = n factorial (n 1); > val factorial = fn : int > int val rec factorial = fn Example (Recursively Defined Lambda Abstraction) val rec factorial = fn 0 => 1 n => n factorial (n 1); Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
50 Mutual Recursion Cases and Pattern Matching Case Analysis Example (Mutual Recursion) fun even 0 = true even n = odd (n 1) and odd 0 = false odd n = even (n 1); > val even = fn : int > bool val odd = fn : int > bool (even 5,odd 5); > val it = ( false, true) : bool bool Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
51 Outline I Data Types 1 Overview Functional Programming Standard ML 2 Standard ML in Examples Evalutation and Bindings Operations and Functions Standard Data Types Polymorphism and Type Inference Miscellaneous 3 Cases and Pattern Matching Tuples Case Analysis 4 Data Types Simple Data Types Recursive Data Types Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
52 Outline II Data Types 5 Modules Structures Signatures Modules in Moscow ML 6 Implementing a Simple Theorem Prover Introduction Basic Data Structures Substitution and Unification 7 Summary Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
53 Type Abbreviations Data Types Simple Data Types type Keyword type abbreviations record definitions Example (Type Abbreviation) type boolpair = bool bool; > type boolpair = bool bool (true,true ): boolpair; > val it = (true, true) : bool bool Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
54 Defining a Record Type Data Types Simple Data Types Example (Record) type hyperlink = { protocol : string, address : string, display : string }; > type hyperlink = {address : string, display : string, protocol : string } val hol_webpage = { protocol="http", address="rsg.informatik.uni kl.de/teaching/hol", display="hol Course" }; > val hol_webpage = { address = "rsg. informatik. uni kl.de/teaching/hol", display = "HOL Course", protocol = "http"} :{ address : string, display : string, protocol : string } Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
55 Data Types Accessing Record Components Simple Data Types Example (Type Abbreviation) val {protocol=p, display=d, address=a } = hol_webpage; > val p = "http" : string val d = "HOL Course" : string val a = "rsg. informatik. uni kl.de/teaching/hol" : string val {protocol=_, display=_, address=a } = hol_webpage; > val a = "rsg. informatik. uni kl.de/teaching/hol" : string val {address=a,...} = hol_webpage; > val a = "rsg. informatik. uni kl.de/teaching/hol" : string val {address,...} = hol_webpage; > val address = "rsg. informatik. uni kl.de/teaching/hol" : string Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
56 Data Types Defining Really New Data Types Simple Data Types datatype Keyword programmer-defined (recursive) data types, introduces one or more new type constructors one or more new value constructors Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
57 Non-Recursive Data Type Data Types Simple Data Types Example (Non-Recursive Datatype) datatype threeval = TT UU FF; > New type names: =threeval datatype threeval = (threeval,{ con FF : threeval, con TT : threeval, con UU : threeval}) con FF = FF : threeval con TT = TT : threeval con UU = UU : threeval fun not3 TT = FF not3 UU = UU not3 FF = TT; > val not3 = fn : threeval > threeval not3 TT; > val it = FF : threeval Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
58 Data Types Simple Data Types Parameterised Non-Recursive Data Types Example (Option Type) datatype a option = NONE SOME of a; > New type names: =option datatype a option = ( a option,{ con a NONE : a option, con a SOME : a > a option}) con a NONE = NONE : a option con a SOME = fn : a > a option constant NONE values of the form SOME v (where v has the type a) Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
59 Option Types Data Types Simple Data Types Example (Option Type) fun reciprocal 0.0 = NONE reciprocal x = SOME (1.0/x) > val reciprocal = fn : real > real option fun inv_reciprocal NONE = 0.0 inv_reciprocal (SOME x) = 1.0/x; > val inv_reciprocal = fn : real option > real fun identity x = inv_reciprocal ( reciprocal x); > val identity = fn : real > real identity 42.0; > val it = 42.0 : real identity 0.0; > val it = 0.0 : real Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
60 Recursive Data Types Data Types Recursive Data Types Example (Binary Tree) datatype a tree = Empty Node of a tree a a tree ; > New type names: =tree datatype a tree = ( a tree, {con a Empty : a tree, con a Node : a tree a a tree > a tree}) con a Empty = Empty : a tree con a Node = fn : a tree a a tree > a tree Empty is an empty binary tree (Node (t 1,v,t 2 ) is a tree if t 1 and t 2 are trees and v has the type a nothing else is a binary tree Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
61 Data Types Recursive Data Types Functions and Recursive Data Types Example (Binary Tree) fun treeheight Empty = 0 treeheight (Node (leftsubtree, _, rightsubtree)) = 1 + max(treeheight leftsubtree, treeheight rightsubtree); > val a treeheight = fn : a tree > int Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
62 Data Types Mutually Recursive Datatypes Recursive Data Types Example (Binary Tree) datatype a tree = Empty Node of a a forest and a forest = None Tree of a tree a forest ; > New type names: =forest, =tree... Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
63 Abstract Syntax Data Types Recursive Data Types Example (Defining Expressions) datatype expr = Numeral of int Plus of expr expr Times of expr expr; > New type names: =expr datatype expr = (expr, {con Numeral : int > expr, con Plus : expr expr > expr, con Times : expr expr > expr}) con Numeral = fn : int > expr con Plus = fn : expr expr > expr con Times = fn : expr expr > expr Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
64 Abstract Syntax Data Types Recursive Data Types Example (Evaluating Expressions) fun eval (Numeral n) = Numeral n eval (Plus(e1,e2)) = let val Numeral n1 = eval e1 val Numeral n2 = eval e2 in Numeral(n1+n2) end eval (Times (e1,e2)) = let val Numeral n1 = eval e1 val Numeral n2 = eval e2 in Numeral(n1 n2) end; > val eval = fn : expr > expr eval( Plus( Numeral 2, Times( Numeral 5, Numeral 8 ) ) ); > val it = Numeral 42 : expr Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
65 Outline I Modules 1 Overview Functional Programming Standard ML 2 Standard ML in Examples Evalutation and Bindings Operations and Functions Standard Data Types Polymorphism and Type Inference Miscellaneous 3 Cases and Pattern Matching Tuples Case Analysis 4 Data Types Simple Data Types Recursive Data Types Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
66 Outline II Modules 5 Modules Structures Signatures Modules in Moscow ML 6 Implementing a Simple Theorem Prover Introduction Basic Data Structures Substitution and Unification 7 Summary Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
67 Structuring ML Programs Modules Structures Modules structuring programs into separate units program units in ML: structures contain a collection of types, exceptions and values (incl. functions) parameterised units possible composition of structures mediated by signatures Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
68 Structures Modules Structures Purpose structures = implementation Example (Structure) structure Queue = struct type a queue = a list a list val empty = (nil, nil ) fun insert ( x, (bs,fs )) = (x :: bs, fs) exception Empty fun remove (nil, nil ) = raise Empty remove (bs, f :: fs) = ( f, (bs,fs )) remove (bs, nil)= remove (nil, rev bs) end Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
69 Modules Structures Accessing Structure Components Identifier Scope components of a structure: local scope must be accessed by qualified names Example (Accessing Structure Components) Queue.empty; > val ( a, b) it = ([], []) : a list b list open Queue; >... empty; > val ( a, b) it = ([], []) : a list b list Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
70 Modules Structures Accessing Structure Components Usage of open open a structure to incorporate its bindings directly cannot open two structures with components that share a common names prefer to use open in let and local blocks Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
71 Signatures Modules Signatures Purpose signatures = interface Example (Signature) signature QUEUE = sig type a queue exception Empty val empty : a queue val insert : a a queue > a queue val remove: a queue > q a queue end Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
72 Signature Ascription Modules Signatures Transparent Ascription descriptive ascription extract principal signature always existing for well-formed structures most specific description everything needed for type checking source code needed Opaque Ascription restrictive ascription enforce data abstraction Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
73 Opaque Ascription Modules Signatures Example (Opaque Ascription) structure Queue :> QUEUE struct type a queue = a list a list val empty = (nil, nil ) fun insert ( x, (bs,fs )) = (x :: bs, fs) exception Empty fun remove (nil, nil ) = raise Empty remove (bs, f :: fs) = ( f, (bs,fs )) remove (bs, nil)= remove (nil, rev bs) end Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
74 Signature Matching Modules Signatures Conditions structure may provide more components structure may provide more general types than required structure may provide a concrete datatype instead of a type declarations in any order Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
75 Modules Modular Compilation in Moscow ML Modules in Moscow ML Compiler mosmlc save structure Foo to file Foo.sml compile module: mosmlc Foo.sml compiled interface in Foo.ui and compiled bytecode Foo.uo load module load "Foo.ui" load "Queue"; > val it = () : unit open Queue; > type a queue = a list a list val ( a, b) insert = fn : a ( a list b) > a list b exn Empty = Empty : exn val ( a, b) empty = ([], []) : a list b list val a remove = fn : a list a list > a ( a list a list ) Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
76 Outline I Implementing a Theorem Prover 1 Overview Functional Programming Standard ML 2 Standard ML in Examples Evalutation and Bindings Operations and Functions Standard Data Types Polymorphism and Type Inference Miscellaneous 3 Cases and Pattern Matching Tuples Case Analysis 4 Data Types Simple Data Types Recursive Data Types Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
77 Outline II Implementing a Theorem Prover 5 Modules Structures Signatures Modules in Moscow ML 6 Implementing a Simple Theorem Prover Introduction Basic Data Structures Substitution and Unification 7 Summary Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
78 Overview Implementing a Theorem Prover Introduction Theorem Prover theorem prover implements a proof system used for proof checking and automated theorem proving Goals build your own theorem prover for propositional logic understanding the fundamental structure of a theorem prover Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
79 Data Types Implementing a Theorem Prover Basic Data Structures Data Types of a Theorem Prover formulas, terms and types axioms and theorems deduction rules proofs Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
80 Implementing a Theorem Prover Formulas, Terms and Types Basic Data Structures Propositional Logic each term is a formula each term has the type B Data Type Definition datatype Term = Variable of string Constant of bool Negation of Term Conjunction of Term Term Disjunction of Term Term Implication of Term Term; Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
81 Implementing a Theorem Prover Syntactical Operations on Terms Basic Data Structures Determining the Topmost Operator fun isvar (Variable x) = true isvar _ = false ; fun isconst (Constant b) = true isconst _ = false ; fun isneg (Negation t1) = true isneg _ = false ; fun iscon (Conjunction (t1, t2 )) = true iscon _ = false ; fun isdis (Disjunction (t1, t2 )) = true isdis _ = false ; fun isimp ( Implication (t1,t2 )) = true isimp _ = false ; Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
82 Implementing a Theorem Prover Syntactical Operations on Terms Basic Data Structures Composition combine several subterms with an operator to a new one Composition of Terms fun mkvar s1 = Variable s1; fun mkconst b1 = Constant b1; fun mkneg t1 = Negation t1; fun mkcon (t1,t2) = Conjunction(t1,t2 ); fun mkdis (t1,t2) = Disjunction(t1, t2 ); fun mkimp (t1,t2) = Implication (t1,t2 ); Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
83 Implementing a Theorem Prover Syntactical Operations on Terms Basic Data Structures Decomposition decompose a term Decomposition of Terms exception SyntaxError; fun destneg (Negation t1) = t1 destneg _ = raise SyntaxError ; fun destcon (Conjunction (t1,t2)) = (t1, t2) destcon _ = raise SyntaxError ; fun destdis (Disjunction (t1,t2 )) = (t1,t2) destdis _ = raise SyntaxError ; fun destimp (Implication (t1,t2 )) = (t1,t2) destimp _ = raise SyntaxError ; Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
84 Term Examples Implementing a Theorem Prover Basic Data Structures Example (Terms) t 1 = a b c; t 2 = true (x y) z; t 3 = ((a b) c) val t1 = Disjunction(Conjunction(Variable "a",variable "b" ), Negation(Variable "c") ); val t2 = Disjunction( Conjunction( Constant true, Conjunction (Variable "x",variable "y" )), Negation(Variable "z" )); val t3 = Negation(Conjunction( Disjunction(Variable "a",variable "b" ), Negation(Variable "c" ))); Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
85 Theorems Implementing a Theorem Prover Basic Data Structures Data Type Definition datatype Theorem = Theorem of Term list Term; Syntactical Operations fun assumptions (Theorem (assums,concl)) = assums; fun conclusion (Theorem (assums,concl)) = concl; fun mktheorem(assums,concl) = Theorem(assums,concl); fun desttheorem (Theorem (assums,concl)) = (assums,concl); Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
86 Rules Implementing a Theorem Prover Basic Data Structures Data Type Definition datatype Rule = Rule of Theorem list Theorem; Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
87 Application of Rules Implementing a Theorem Prover Basic Data Structures Application of Rules form a new theorem from several other theorems Application (Version 1) exception DeductionError; fun applyrule rule thms = let val Rule (prem,concl) = rule in if prem=thms then concl else raise DeductionError end; Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
88 Application of Rules Implementing a Theorem Prover Basic Data Structures Application of Rules premises and given theorems do not need to be identical premises only need to be in the given theorems Application (Version 2) fun mem x [] = false mem x (h::t) = (x=h) orelse (contains t x); fun sublist [] l2 = true sublist (h1:: t1) l2 = (contains l2 h1) andalso (sublist t1 l2 ); fun applyrule rule thms = let val Rule (prem,concl) = rule in if sublist prem thms then concl else raise DeductionError end; Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
89 Application of Rules Implementing a Theorem Prover Basic Data Structures Example (Rule Application) val axiom1 = Theorem( [], (Variable "a" )); val axiom2 = Theorem( [], Implication((Variable "a" ),( Variable "b" ))); val axiom3 = Theorem( [], Implication((Variable "b" ),( Variable "c" ))); val modusponens = Rule( [Theorem( [], Implication ((Variable "a" ),( Variable "b")) ), Theorem( [], (Variable "a") )], Theorem( [], (Variable "b") ) ); Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
90 Application of Rules Implementing a Theorem Prover Basic Data Structures Example (Rule Application) val thm1 = applyrule modusponens [axiom1,axiom2]; val thm2 = applyrule modusponens [thm1,axiom3]; Problem axioms and rules should work for arbitrary variables axiom scheme, rule scheme definition of substitution and unification needed Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
91 Support Functions Implementing a Theorem Prover Substitution and Unification Support Functions fun insert x l = if mem x l then l else x :: l ; fun assoc [] a = NONE assoc ((x,y ):: t ) a = if (x=a) then SOME y else assoc t a; fun occurs v (w as Variable _) = (v=w) occurs v (Constant b) = false occurs v (Negation t) = occurs v t occurs v (Conjunction (t1,t2 )) = occurs v t1 orelse occurs v t2 occurs v (Disjunction (t1,t2 )) = occurs v t1 orelse occurs v t2 occurs v ( Implication (t1,t2 )) = occurs v t1 orelse occurs v t2; Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
92 Substitution Implementing a Theorem Prover Substitution and Unification Substitution fun subst theta (v as Variable _) = (case assoc theta v of NONE => v SOME w => w) subst theta (Constant b) = Constant b subst theta (Negation t) = Negation(subst theta t) subst theta (Conjunction (t1, t2 )) = Conjunction(subst theta t1, subst theta t2) subst theta (Disjunction (t1, t2 )) = Disjunction(subst theta t1, subst theta t2) subst theta ( Implication (t1, t2 )) = Implication (subst theta t1, subst theta t2 ); Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
93 Substitution Implementing a Theorem Prover Substitution and Unification Example (Substitution) val theta1 = [( Variable "a",variable "b" ),( Variable "b",constant true )]; Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
94 Unification Implementing a Theorem Prover Substitution and Unification Definition (Matching) A term matches another if the latter can be obtained by instantiating the former. matches(m,n) θ.subst(θ,m) = N Definition (Unifier, Unifiability) A substitution is a unifier of two terms, if it makes them equal. unifier(θ,m,n) subst(θ,m) = subst(θ,n) Two terms are unifiable if they have a unifier. unifiable(m,n) θ.unifier(θ,m,n) Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
95 Unification Algorithm Implementing a Theorem Prover Substitution and Unification General Idea traverse two terms in exactly the same way eliminating as much common structure as possible things actually happen when a variable is encountered (in either term) when a variable is encoutered, make a binding with the corresponding subterm in the other term, and substitute through important: making a binding (x,m) where x occurs in M must be disallowed since the resulting substitution will not be a unifier Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
96 Unification Algorithm Implementing a Theorem Prover Substitution and Unification Unification exception UnificationException; fun unifyl [] [] theta = theta unifyl ((v as Variable _ ):: L) (M::R) theta = if v=m then unifyl L R theta else if occurs v M then raise UnificationException else unifyl (map (subst [(v,m)]) L) (map (subst [(v,m)]) R) (combinesubst [(v,m)] theta) unifyl L1 (L2 as (Variable _::_)) theta = unifyl L2 L1 theta... Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
97 Unification Algorithm Implementing a Theorem Prover Substitution and Unification Unification... unifyl (Negation tl :: L) (Negation tr :: R) theta = unifyl ( tl :: L) ( tr :: R) theta unifyl (Conjunction ( tl1, tl2 ):: L) (Conjunction (tr1, tr2 ):: R) theta = unifyl ( tl1 :: tl2 :: L) ( tr1 :: tr2 :: R) theta unifyl (Disjunction ( tl1, tl2 ):: L) (Disjunction ( tr1, tr2 ):: R) theta = unifyl ( tl1 :: tl2 :: L) ( tr1 :: tr2 :: R) theta unifyl ( Implication ( tl1, tl2 ):: L) ( Implication ( tr1, tr2 ):: R) theta = unifyl ( tl1 :: tl2 :: L) ( tr1 :: tr2 :: R) theta unifyl _ = raise UnificationException; fun unify M N = unifyl [M] [N] []; Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
98 Implementing a Theorem Prover Combining Substitutions Substitution and Unification Combining Substitutions fun combinesubst theta sigma = let val (dsigma,rsigma) = ListPair.unzip sigma val sigma1 = ListPair. zip(dsigma,(map (subst theta) rsigma)) val sigma2 = List. filter (op <>) sigma1 val theta1 = List. filter (fn (a,_) => not (mem a dsigma)) theta in theta1 end; Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
99 Outline I Summary 1 Overview Functional Programming Standard ML 2 Standard ML in Examples Evalutation and Bindings Operations and Functions Standard Data Types Polymorphism and Type Inference Miscellaneous 3 Cases and Pattern Matching Tuples Case Analysis 4 Data Types Simple Data Types Recursive Data Types Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
100 Outline II Summary 5 Modules Structures Signatures Modules in Moscow ML 6 Implementing a Simple Theorem Prover Introduction Basic Data Structures Substitution and Unification 7 Summary Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
101 Summary Summary Summary programming in Standard ML evaluation and bindings defining functions standard data types type inference case analysis and pattern matching data type definitions modules primitive theorem prover kernel terms theorems rules substitution unification Arnd Poetzsch-Heffter ( Software Technology Group Fachbereich Functional InformatikProgramming Technische Universität Kaiserslautern) Sommersemester / 101
Specification and Verification in Higher Order Logic
Specification and Verification in Higher Order Logic Prof. Dr. K. Madlener 13. April 2011 Prof. Dr. K. Madlener: Specification and Verification in Higher Order Logic 1 Chapter 1 Functional Programming:
Programming in Standard ML: Continued
Programming in Standard ML: Continued Specification and Verification with Higher-Order Logic Arnd Poetzsch-Heffter (Slides by Jens Brandt) Software Technology Group Fachbereich Informatik Technische Universität
A Brief Introduction to Standard ML
A Brief Introduction to Standard ML Specification and Verification with Higher-Order Logic Arnd Poetzsch-Heffter (Slides by Jens Brandt) Software Technology Group Fachbereich Informatik Technische Universität
Higher-Order Logic. Specification and Verification with Higher-Order Logic
Higher-Order Logic Specification and Verification with Higher-Order Logic Arnd Poetzsch-Heffter (Slides by Jens Brandt) Software Technology Group Fachbereich Informatik Technische Universität Kaiserslautern
Functional Programming and Modeling
Chapter 2 2. Functional Programming and Modeling 2.0 2. Functional Programming and Modeling 2.0 Overview of Chapter Functional Programming and Modeling 2. Functional Programming and Modeling 2.1 Overview
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
CSE 341 Section 5. Winter 2018
CSE 341 Section 5 Winter 2018 Midterm Review! Variable Bindings, Shadowing, Let Expressions Boolean, Comparison and Arithmetic Operations Equality Types Types, Datatypes, Type synonyms Tuples, Records
SML A F unctional Functional Language Language Lecture 19
SML A Functional Language Lecture 19 Introduction to SML SML is a functional programming language and acronym for Standard d Meta Language. SML has basic data objects as expressions, functions and list
Products and Records
Products and Records Michael P. Fourman February 2, 2010 1 Simple structured types Tuples Given a value v 1 of type t 1 and a value v 2 of type t 2, we can form a pair, (v 1, v 2 ), containing these values.
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
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
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
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:
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
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
CMSC 330, Fall 2013, Practice Problems 3
CMSC 330, Fall 2013, Practice Problems 3 1. OCaml and Functional Programming a. Define functional programming b. Define imperative programming c. Define higher-order functions d. Describe the relationship
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
A quick introduction to SML
A quick introduction to SML CMSC 15300 April 9, 2004 1 Introduction Standard ML (SML) is a functional language (or higherorder language) and we will use it in this course to illustrate some of the important
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
Begin at the beginning
Begin at the beginning 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 of
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
Computer Science CSC324 Wednesday February 13, Homework Assignment #3 Due: Thursday February 28, 2013, by 10 p.m.
Computer Science CSC324 Wednesday February 13, 2013 St. George Campus University of Toronto Homework Assignment #3 Due: Thursday February 28, 2013, by 10 p.m. Silent Policy A silent policy takes effect
Handout 2 August 25, 2008
CS 502: Compiling and Programming Systems Handout 2 August 25, 2008 Project The project you will implement will be a subset of Standard ML called Mini-ML. While Mini- ML shares strong syntactic and semantic
Datatype declarations
Datatype declarations datatype suit = HEARTS DIAMONDS CLUBS SPADES datatype a list = nil (* copy me NOT! *) op :: of a * a list datatype a heap = EHEAP HEAP of a * a heap * a heap type suit val HEARTS
Plan (next 4 weeks) 1. Fast forward. 2. Rewind. 3. Slow motion. Rapid introduction to what s in OCaml. Go over the pieces individually
Plan (next 4 weeks) 1. Fast forward Rapid introduction to what s in OCaml 2. Rewind 3. Slow motion Go over the pieces individually History, Variants Meta Language Designed by Robin Milner @ Edinburgh Language
LECTURE 16. Functional Programming
LECTURE 16 Functional Programming WHAT IS FUNCTIONAL PROGRAMMING? Functional programming defines the outputs of a program as a mathematical function of the inputs. Functional programming is a declarative
Functional Programming
Functional Programming Function evaluation is the basic concept for a programming paradigm that has been implemented in functional programming languages. The language ML ( Meta Language ) was originally
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
A First Look at ML. Chapter Five Modern Programming Languages, 2nd ed. 1
A First Look at ML Chapter Five Modern Programming Languages, 2nd ed. 1 ML Meta Language One of the more popular functional languages (which, admittedly, isn t saying much) Edinburgh, 1974, Robin Milner
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
Homework 3 COSE212, Fall 2018
Homework 3 COSE212, Fall 2018 Hakjoo Oh Due: 10/28, 24:00 Problem 1 (100pts) Let us design and implement a programming language called ML. ML is a small yet Turing-complete functional language that supports
Functional programming Primer I
Functional programming Primer I COS 320 Compiling Techniques Princeton University Spring 2016 Lennart Beringer 1 Characteristics of functional programming Primary notions: functions and expressions (not
CSCC24 Functional Programming Typing, Scope, Exceptions ML
CSCC24 Functional Programming Typing, Scope, Exceptions ML Carolyn MacLeod 1 winter 2012 1 Based on slides by Anya Tafliovich, with many thanks to Gerald Penn and Sheila McIlraith. motivation Consider
CSE-321 Programming Languages 2010 Midterm
Name: Hemos ID: CSE-321 Programming Languages 2010 Midterm Score Prob 1 Prob 2 Prob 3 Prob 4 Total Max 15 30 35 20 100 1 1 SML Programming [15 pts] Question 1. [5 pts] Give a tail recursive implementation
Data Types The ML Type System
7 Data Types 7.2.4 The ML Type System The following is an ML version of the tail-recursive Fibonacci function introduced Fibonacci function in ML in Section 6.6.1: EXAMPLE 7.96 1. fun fib (n) = 2. let
Lecture 2: The Basis of SML
Lecture 2: The Basis of SML Jean-Noël Monette Functional Programming 1 September 9, 2013 Based on notes by Pierre Flener, Sven-Olof Nyström Jean-Noël Monette (UU) Lecture 2: The Basis of SML 1 / 73 Today
Introduction to SML Getting Started
Introduction to SML Getting Started Michael R. Hansen mrh@imm.dtu.dk Informatics and Mathematical Modelling Technical University of Denmark c Michael R. Hansen, Fall 2004 p.1/15 Background Standard Meta
CS Lectures 2-3. Introduction to OCaml. Polyvios Pratikakis
CS 490.40 Lectures 2-3 Introduction to OCaml Polyvios Pratikakis Based on slides by Jeff Foster History ML: Meta Language 1973, University of Edinburg Used to program search tactics in LCF theorem prover
SMURF Language Reference Manual Serial MUsic Represented as Functions
SMURF Language Reference Manual Serial MUsic Represented as Functions Richard Townsend, Lianne Lairmore, Lindsay Neubauer, Van Bui, Kuangya Zhai {rt2515, lel2143, lan2135, vb2363, kz2219}@columbia.edu
L3 Programming September 19, OCaml Cheatsheet
OCaml Cheatsheet Note: this document comes from a previous course (by Sylvain Schimdt). The explanations of the OCaml syntax in this sheet are by no means intended to be complete or even sufficient; check
CSCI.6962/4962 Software Verification Fundamental Proof Methods in Computer Science (Arkoudas and Musser) Chapter p. 1/27
CSCI.6962/4962 Software Verification Fundamental Proof Methods in Computer Science (Arkoudas and Musser) Chapter 2.1-2.7 p. 1/27 CSCI.6962/4962 Software Verification Fundamental Proof Methods in Computer
CMSC 330, Fall 2013, Practice Problem 3 Solutions
CMSC 330, Fall 2013, Practice Problem 3 Solutions 1. OCaml and Functional Programming a. Define functional programming Programs are expression evaluations b. Define imperative programming Programs change
# 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
CSE 505. Lecture #9. October 1, Lambda Calculus. Recursion and Fixed-points. Typed Lambda Calculi. Least Fixed Point
Lambda Calculus CSE 505 Lecture #9 October 1, 2012 Expr ::= Var λ Var. Expr (Expr Expr) Key Concepts: Bound and Free Occurrences Substitution, Reduction Rules: α, β, η Confluence and Unique Normal Form
CPS 506 Comparative Programming Languages. Programming Language Paradigm
CPS 506 Comparative Programming Languages Functional Programming Language Paradigm Topics Introduction Mathematical Functions Fundamentals of Functional Programming Languages The First Functional Programming
Hard deadline: 3/28/15 1:00pm. Using software development tools like source control. Understanding the environment model and type inference.
CS 3110 Spring 2015 Problem Set 3 Version 0 (last modified March 12, 2015) Soft deadline: 3/26/15 11:59pm Hard deadline: 3/28/15 1:00pm Overview In this assignment you will implement several functions
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
OCaml. History, Variants. ML s holy trinity. Interacting with ML. Base type: Integers. Base type: Strings. *Notes from Sorin Lerner at UCSD*
OCaml 1. Introduction Rapid introduction to what s in OCaml 2. Focus on Features Individually as Needed as Semester Progresses *Notes from Sorin Lerner at UCSD* History, Variants Meta Language Designed
A general introduction to Functional Programming using Haskell
A general introduction to Functional Programming using Haskell Matteo Rossi Dipartimento di Elettronica e Informazione Politecnico di Milano rossi@elet.polimi.it 1 Functional programming in a nutshell
All the operations used in the expression are over integers. a takes a pair as argument. (a pair is also a tuple, or more specifically, a 2-tuple)
Weekly exercises in INF3110 week 41 6-10.10.2008 Exercise 1 Exercise 6.1 in Mitchell's book a) fun a(x,y) = x+2*y; val a = fn : int * int -> int All the operations used in the expression are over integers.
Principles of Functional Programming
15-150 Principles of Functional Programming Some Slides for Lecture 16 Modules March 20, 2018 Michael Erdmann Signatures & Structures A signature specifies an interface. A structure provides an implementation.
CS109A ML Notes for the Week of 1/16/96. Using ML. ML can be used as an interactive language. We. shall use a version running under UNIX, called
CS109A ML Notes for the Week of 1/16/96 Using ML ML can be used as an interactive language. We shall use a version running under UNIX, called SML/NJ or \Standard ML of New Jersey." You can get SML/NJ by
CSE-321 Programming Languages 2012 Midterm
Name: Hemos ID: CSE-321 Programming Languages 2012 Midterm Prob 1 Prob 2 Prob 3 Prob 4 Prob 5 Prob 6 Total Score Max 14 15 29 20 7 15 100 There are six problems on 24 pages in this exam. The maximum score
Mini-ML. CS 502 Lecture 2 8/28/08
Mini-ML CS 502 Lecture 2 8/28/08 ML This course focuses on compilation techniques for functional languages Programs expressed in Standard ML Mini-ML (the source language) is an expressive core subset of
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 =
Introduction to Objective Caml
Introduction to Objective Caml Stefan Wehr University of Freiburg. October 30, 2006 Motivation Simple Expressions and Types Functions Simple Pattern Matching Compound Datatypes I/O and Compilation Resources
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
Why OCaml? Introduction to Objective Caml. Features of OCaml. Applications written in OCaml. Stefan Wehr
Motivation Introduction to Objective Caml Why OCaml? Stefan Wehr University of Freiburg. October 30, 2006 Motivation Simple Expressions and Types I/O and Compilation Resources Convenient encoding of tree
Programming Languages
CSE 130 : Fall 2008 Programming Languages Lecture 2: A Crash Course in ML Ranjit Jhala UC San Diego News On webpage: Suggested HW #1, sample for Quiz #1 on Thu PA #1 (due next Fri 10/10) No make-up quizzes
If we have a call. Now consider fastmap, a version of map that uses futures: Now look at the call. That is, instead of
If we have a call (map slow-function long-list where slow-function executes slowly and long-list is a large data structure, we can expect to wait quite a while for computation of the result list to complete.
Chapter 15. Functional Programming Languages
Chapter 15 Functional Programming Languages Copyright 2009 Addison-Wesley. All rights reserved. 1-2 Chapter 15 Topics Introduction Mathematical Functions Fundamentals of Functional Programming Languages
Isabelle s meta-logic. p.1
Isabelle s meta-logic p.1 Basic constructs Implication = (==>) For separating premises and conclusion of theorems p.2 Basic constructs Implication = (==>) For separating premises and conclusion of theorems
Programming Languages
CSE 130: Spring 2010 Programming Languages Lecture 2: A Crash Course in ML Ranjit Jhala UC San Diego News On webpage: Suggested HW #1 PA #1 (due next Wed 4/9) Please post questions to WebCT Today: A crash
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
Types-2. Polymorphism
Types-2 Polymorphism Type reconstruction (type inference) for a simple PL Typing functions Coercion, conversion, reconstruction Rich area of programming language research as people try to provide safety
Note that pcall can be implemented using futures. That is, instead of. we can use
Note that pcall can be implemented using futures. That is, instead of (pcall F X Y Z) we can use ((future F) (future X) (future Y) (future Z)) In fact the latter version is actually more parallel execution
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
F28PL1 Programming Languages. Lecture 11: Standard ML 1
F28PL1 Programming Languages Lecture 11: Standard ML 1 Imperative languages digital computers are concrete realisations of von Neumann machines stored program memory associations between addresses and
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
15 150: Principles of Functional Programming. Exceptions
15 150: Principles of Functional Programming Exceptions Michael Erdmann Spring 2018 1 Topics Exceptions Referential transparency, revisited Examples to be discussed: Dealing with arithmetic errors Making
The type checker will complain that the two branches have different types, one is string and the other is int
1 Intro to ML 1.1 Basic types Need ; after expression - 42 = ; val it = 42 : int - 7+1; val it = 8 : int Can reference it - it+2; val it = 10 : int - if it > 100 then "big" else "small"; val it = "small"
Overview. A Compact Introduction to Isabelle/HOL. Tobias Nipkow. System Architecture. Overview of Isabelle/HOL
Overview A Compact Introduction to Isabelle/HOL Tobias Nipkow TU München 1. Introduction 2. Datatypes 3. Logic 4. Sets p.1 p.2 System Architecture Overview of Isabelle/HOL ProofGeneral Isabelle/HOL Isabelle
Programming Paradigms
PP 2017/18 Unit 12 Functions and Data Types in Haskell 1/45 Programming Paradigms Unit 12 Functions and Data Types in Haskell J. Gamper Free University of Bozen-Bolzano Faculty of Computer Science IDSE
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
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
Types and Programming Languages. Lecture 5. Extensions of simple types
Types and Programming Languages Lecture 5. Extensions of simple types Xiaojuan Cai cxj@sjtu.edu.cn BASICS Lab, Shanghai Jiao Tong University Fall, 2016 Coming soon Simply typed λ-calculus has enough structure
Tail Recursion: Factorial. Begin at the beginning. How does it execute? Tail recursion. Tail recursive factorial. Tail recursive factorial
Begin at the beginning Epressions (Synta) Compile-time Static Eec-time Dynamic Types Values (Semantics) 1. Programmer enters epression 2. ML checks if epression is well-typed Using a precise set of rules,
CMSC 330: Organization of Programming Languages. Formal Semantics of a Prog. Lang. Specifying Syntax, Semantics
Recall Architecture of Compilers, Interpreters CMSC 330: Organization of Programming Languages Source Scanner Parser Static Analyzer Operational Semantics Intermediate Representation Front End Back End
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 ::
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
COMP 105 Assignment: Hindley-Milner Type Inference
COMP 105 Assignment: Hindley-Milner Type Inference Due Monday, Novermber 21 at 11:59PM. In this assignment you will implement Hindley-Milner type inference, which represents the current ``best practice''
1.3. Conditional expressions To express case distinctions like
Introduction Much of the theory developed in the underlying course Logic II can be implemented in a proof assistant. In the present setting this is interesting, since we can then machine extract from a
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.
ITT8060: Advanced Programming (in F#)
based on slides by Michael R. Hansen ITT8060: Advanced Programming (in F#) Lecture 2: Identifiers, values, expressions, functions and types Juhan Ernits Department of Software Science, Tallinn University
Typed Racket: Racket with Static Types
Typed Racket: Racket with Static Types Version 5.0.2 Sam Tobin-Hochstadt November 6, 2010 Typed Racket is a family of languages, each of which enforce that programs written in the language obey a type
The Substitution Model
The Substitution Model Prof. Clarkson Fall 2017 Today s music: Substitute by The Who Review Previously in 3110: simple interpreter for expression language abstract syntax tree (AST) evaluation based on
Lecture Notes on Induction and Recursion
Lecture Notes on Induction and Recursion 15-317: Constructive Logic Frank Pfenning Lecture 7 September 19, 2017 1 Introduction At this point in the course we have developed a good formal understanding
COS 320. Compiling Techniques
Topic 5: Types COS 320 Compiling Techniques Princeton University Spring 2016 Lennart Beringer 1 Types: potential benefits (I) 2 For programmers: help to eliminate common programming mistakes, particularly
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)
Introduction to SML Basic Types, Tuples, Lists, Trees and Higher-Order Functions
Introduction to SML Basic Types, Tuples, Lists, Trees and Higher-Order Functions Michael R. Hansen mrh@imm.dtu.dk Informatics and Mathematical Modelling Technical University of Denmark c Michael R. Hansen,
CS3110 Spring 2016 Lecture 6: Modules
CS3110 Spring 2016 Lecture 6: Modules Modules are the O part of OCaml, influenced by objects in Java. We see the evolution: Classic ML, CambridgeML (CAML), and finally OCaml. David McQueen is writing the
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
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
Implementing nml: Hindley-Milner Type Inference
Implementing nml: Hindley-Milner Type Inference Due Friday, April 10 at 5:59PM. In this assignment you will implement Hindley-Milner type inference, which represents the current ``best practice'' for flexible
Redefinition of an identifier is OK, but this is redefinition not assignment; Thus
Redefinition of an identifier is OK, but this is redefinition not assignment; Thus val x = 100; val x = (x=100); is fine; there is no type error even though the first x is an integer and then it is a boolean.
Typed Scheme: Scheme with Static Types
Typed Scheme: Scheme with Static Types Version 4.1.1 Sam Tobin-Hochstadt October 5, 2008 Typed Scheme is a Scheme-like language, with a type system that supports common Scheme programming idioms. Explicit
Side note: Tail Recursion. Begin at the beginning. Side note: Tail Recursion. Base Types. Base Type: int. Base Type: int
Begin at the beginning Epressions (Synta) Compile-time Static Eec-time Dynamic Types Values (Semantics) 1. Programmer enters epression 2. ML checks if epression is well-typed Using a precise set of rules,
CS 457/557: Functional Languages
CS 457/557: Functional Languages Lists and Algebraic Datatypes Mark P Jones Portland State University 1 Why Lists? Lists are a heavily used data structure in many functional programs Special syntax is
CVO103: Programming Languages. Lecture 5 Design and Implementation of PLs (1) Expressions
CVO103: Programming Languages Lecture 5 Design and Implementation of PLs (1) Expressions Hakjoo Oh 2018 Spring Hakjoo Oh CVO103 2018 Spring, Lecture 5 April 3, 2018 1 / 23 Plan Part 1 (Preliminaries):
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