CSE 305 Introduc0on to Programming Languages Lecture 13 Type System (1)

Transcription

1 CSE 305 Introduc0on to Programming Languages Lecture 13 Type System (1) SUNY- Buffalo Zhi Yang Courtesy of Professor Benjamin C. Pierce Courtesy of Dr. Chung- Chih Li

2 Declara0ons This lecture has majorly referred to on line material Type Systems for Programming Languages, by Benjamin C. Pierce. If you are interested in the official publica0on, please contact the author and Publisher MIT Press. This lecture is mainly focusing on teaching purpose and has nothing to do with any other commercial and academic ac0vi0es.

3 No0ce Board First, we will be pos0ng homework 6 during the weekend, and you can schedule your 0me accordingly. Second, homework5 is due on Monday(July 15, 2013) 11:59pm.

4 Our objec0ve The first objec0ve of our class, is to comprehend a new programming language within very short 5me period, and because you have this ability to shorten your learning curve, you are going to manipulate the language with an insight learning. The second objec0ve is to even engineer your own language!

5 eg: Egyp0an Number System; Complement Number Review what we ve learnt and see future eg: MIPS 2 nd Genera0on language: Assembly Code Number System eg: Gate system, Including different underline device 1 st Genera0on language: Machine Code Regular Expression eg: Abacus Basic Calcula0on System Type Checking eg: Fortran What s next? Lexer Compiler System 3 rd Genera0on Language: Macro func0on Parser Virtual Machine Macro func5on Push Down Automata Context- Free Grammar Lambda Calculus Theory

6 A family tree of languages <Fortran> Cobol <LISP> C BASIC Algol 60 Simula <C++> <Perl> <C#> PL/1 Algol 68 Pascal <Smalltalk> <Java> Modula 3 Dylan <ML> <Scheme> Ada <Ruby> <Python> <JavaScript> <Haskell> <Prolog>

7 Review Concept of Macro A macro (short for "macroinstruc0on", from Greek μακρο- 'long') in computer science is a rule or panern that specifies how a certain input sequence (open a sequence of characters) should be mapped to a replacement input sequence (also open a sequence of characters) according to a defined procedure. The mapping process that instan0ates (transforms) a macro use into a specific sequence is known as macro expansion.

8 What is the rela0on between a macro func0on and Type System Let s look at how microsop MSDN library talks about it. Most Microsop run- 0me library rou0nes are compiled or assembled func0ons, but some rou0nes are implemented as macros. When a header file declares both a func0on and a macro version of a rou0ne, the macro defini0on takes precedence, because it always appears aper the func0on declara0on. When you invoke a rou0ne that is implemented as both a func0on and a macro, you can force the compiler to use the func0on version in two ways: Enclose the rou5ne name in parentheses. #include <ctype.h> //use macro version of toupper a = (toupper)(a); define a = toupper(a); //force compiler to use func5on version of toupper

9 The other version "Undefine" the macro defini0on with the #undef direc0ve: #include <ctype.h> #undef toupper If you need to choose between a func0on and a macro implementa0on of a library rou0ne, consider the following trade- offs: Speed versus size. The main benefit of using macros is faster execu5on 5me. During preprocessing, a macro is expanded (replaced by its defini5on) inline each 5me it is used. A func5on defini5on occurs only once regardless of how many 5mes it is called. Macros may increase code size but do not have the overhead associated with func5on calls. Func0on evalua0on. A func0on evaluates to an address; a macro does not. Thus you cannot use a macro name in contexts requiring a pointer. For instance, you can declare a pointer to a func0on, but not a pointer to a macro.

10 Comparison Macro side effects. A macro may treat arguments incorrectly when the macro evaluates its arguments more than once. For instance, the touppermacro is defined as: #define toupper(c) ( (islower(c))? _toupper(c) : (c) ) In the following example, the toupper macro produces a side effect: #include <ctype.h> int a = 'm'; a = toupper(a++); The example code increments a when passing it to toupper. The macro evaluates the argument a++ twice, once to check case and again for the result, therefore increasing a by 2 instead of 1. As a result, the value operated on by islower differs from the value operated on by toupper. Type- checking. When you declare a func0on, the compiler can check the argument types. Because you cannot declare a macro, the compiler cannot check macro argument types, although it can check the number of arguments you pass to a macro.

11 Type System? A useful though rough dis0nc0on divides the world of programming languages into two parts: Untyped Programs simply execute flat out; there is no anempt to check consistency of shapes Typed some anempt is made, either at compile 0me or at run- 0me, to check shape- consistency.

12 A Brief History of Type

13 A Brief History of Type (Cont.) The earliest type system appears in Fortran.

14 Mathema0cal Preliminaries (Set & Rela0ons)

15 Review Untyped Lambda Basics

16 Formali0es This is an example of an induc5ve defini5on. Since induc0ve defini0ons are ubiquitous in the study of programming languages, it is worth pausing for a moment to examine this one in detail. Here is an alterna0ve defini0on of the same set, in a more concrete style.

17 Set Defini0on

18 Two Defini0ons are equal ~~~T = S

19 Explana0on

20 Constants

21 Size and depth of Term

22 Rela0on between constants and Size

23 Evalua0on

24 Evalua0on Process

25 Proper0es

26 Implementa0on

27 Implementa0on (Cont.)

28 Summary of Type Basics (1)

29 Summary of Type Basics (2)

30 Opera0onal Seman0cs

31 Programming in the Lambda- Calculus

32 Example

33 Grammars

34 Subs0tu0on

35 Solve Problem

36 Solve Problem (Cont.)

37 Opera0onal Seman0cs

38 Summary of Untyped Lambda Calculus

39 Implemen0ng the Lambda- Calculus

40 Defini0on of Terms

41 Shiping and Subs0tu0on

42 Evalua0on

43 A Concrete Realiza0on

44 Evalua0on

45 Typed Arithme0c Expressions

46 The Typing Rela0on

47 Proper0es of Typing and Reduc0on

48 Type Checking

49 Safety = Preserva0on + Progress

50 Implementa0on

51 Summary for boolean and numbers

52 that we shall be studying for the rest of the mily of typedguages lanthe simply typed lambda-calculus of Church [Chu40] and Curry [CF58]. course: the simply typed Simply Typed Lambda- Calculus e family of typed lanse: the simply typed 7.1 Syntax (for brevity, ar: ype mmar: Definition: The set of simple types over the atomic type (for brevity, we omit natural numbers) is generated by the following grammar: (types...) type of functions (types...) type typeof of booleans functions er 7 ::= (types...) type of functions type of booleans type of booleans ly of typed lan. for. e simply typed ly Typed The type constructor Chapter 7 bda-calculus rms (with a-terms (withbooleans booleans (for brevity, is right-associative: stands for. (terms...) (terms...) variable Definition: The abstract syntax of simply typed lambda-terms (with booleans variable abstraction and conditional) is defined by the following grammar: abstraction application ntroduces the most elementary member of the family of typed lan(forconstant brevity, true application we studying for the rest of the course: the simply typed : shall be constant false ::= [CF58]. (terms...) constant trueand Curry lus of Church [Chu40] conditional constant false (types...) variable Chapter 7 conditional type of functions tax Simply Typed Chapter 77 Chapter Lambda-Calculus Simply Typed Typed Simply Chapter 7 Simply Typed type of booleans Lambda-Calculus Lambda-Calculus his chapter introduces the most elementary member of the family of typed lanlambda-calculus uages that.we shall be studying for the rest of the course: the simply typed mbda-calculus of Church [Chu40] and Curry [CF58]. Simply Typed ms (with booleans.1 Syntax Lambda-Calculus er of the family of typed lanhe course: the simply typed ]. on: The set of simple types over the atomic type ral numbers) is langenerated by the following grammar: he family of typed urse: the simply typed (for brevity, This chapter introduces the most elementary member of the family of typed languages that we shall be studying for the rest of the course: the simply typed lambda-calculus of Church [Chu40] and Curry [CF58]. abstraction application constant true constant false conditional (types...) type of functions 7.1 Syntax This the most elementary member ofofthe (types...) Thischapter chapterintroduces introduces the most elementary member thefamily familyofoftyped typedlanlanofsimple booleans Definition:type The set of types over the atomic type (for brevity, type of functions we omit natural numbers) is generated by the following grammar: guages be studying for the guages that that we weshall shall be studying for therest restofofthe thecourse: course: the thesimply simplytyped typed type of booleans ::= (types...) is right-associative: stands. and structor type of functions lambda-calculus ofoffor Church lambda-calculus Church[Chu40] [Chu40] andcurry Curry[CF58]. [CF58]. stands for. type (for brevity, type of booleans 1.1 Definition: The set of simple types over the atomic type (for brevity, (terms...) ammar: is right-associative: stands for. The type constructor (with booleans er:lambda-terms omit numbers) generated the following grammar: on: Thenatural abstract syntax of is simply typedbylambda-terms booleans Definition:(with The abstract syntax of simply typed lambda-terms (with booleans variable (types...) and conditional) is defined by the following grammar: al) is defined by the following grammar: (terms...) ::= (terms...) type of functions 7.1 Syntax 7.1 Syntax ::= (types...) variable This chapter introduces the most elementary member of the family of typed lanabstraction variable type of booleans abstraction abstraction application (terms...) type ofthat functions guages we shall be studying for the rest of the course: the simply typed constant true application application s for types the atomic (for 7.1.1Definition: Definition: The Theset setofofsimple simple types over the atomictype type (forbrevity, brevity, constant variable typeover of booleans constant true lambda-calculus offalsechurch [Chu40] and Curry [CF58]. conditional constant false we weomit omitnatural naturalnumbers) numbers)isisgenerated generatedby bythe thefollowing followinggrammar: grammar: constant true da-terms (with booleans tomic type ing grammar: (for brevity,

53 Conven0on In the literature on type systems, two different presenta0on styles are commonly used: In implicitly typed (or, for historical reasons, Curry- style) systems, the pure (untyped) lambda- calculus is used as the term language. The typing rules define a rela0on between untyped terms and the types that classify them. In explicitly typed (or Church- style) systems, the term language itself is refined so that terms carry some type informa0on within them; for example, the bound variables in func0on abstrac0ons are always annotated with the type of the expected parameter. The type system relates typed terms and their types. To a large degree, the choice is a maner of taste, though explicitly typed systems generally pose fewer algorithmic problems for typecheckers. We will adopt an explicitly typed presenta0on throughout.

54 The Typing Rela0on (1) In order to assign a type to an abstraction like, we need to know what will happen later when it is applied to some argument. The annotation on the bound variable tells us that we may assume that the argument will be of type. In other words, the type of the result will be just the type of, where occurrences of in are assumed to denote terms of type. This intuition is captured by the following rule: (T-ABS) Since, in general, function abstractions can be nested, typing assertions actually have the form, pronounced term has type under the assumptions about the types of its free variables. Formally, the typing context is just a list of variables and their types, and the comma operator extends by concatenating a new binding on the right. To avoid confusion between the new binding and any bindings that may already appear in, we require that the name be chosen so that it does not already appear in dom. (As usual, this condition can always be satisfied by renaming the bound variable if necessary.) can thus be thought of as a finite function from variables to their types. Following this intuition, we will write dom for the set of variables bound by and for the type associated with in. So the rule for typing abstractions actually has the general form where the premise adds one more assumption to those in the conclusion. (T-ABS)

55 The Typing Rela0on (2) The typing rule for variables follows immediately from this discussion. A variable has whatever type we are currently assuming it to have: Next, we need a rule for application: (T-VAR) (T-APP) In English: If evaluates to a function mapping arguments in to results in (under the assumption that the terms represented by its free variables yield results of the types associated to them by ), and if evaluates to a result in, then the result of applying to will be a value of type. We have now given typing rules for each of the individual constructs in our simple language. To assign types to whole programs, we combine these rules into derivation trees. For example, here is a derivation tree showing that the term has type in the empty context: T-VAR T-ABS T-TRUE T-APP Exercise [Quick check]: Show (by exhibiting derivation trees) that the fol-

56 Syntax Summary for Simply Typed Lambda- Calculus : Simply typed lambda-calculus (typed) ::= (terms...) variable abstraction application ::= (values...) abstraction value ::= (types...) type of functions ::= (contexts...) empty context term variable binding Evaluation ( ) (E-BETA) (E-APP1) (E-APP2) Typing ( ) (T-VAR) (T-ABS) (T-APP)

57 Proper0es of Typing and Reduc0on (1) Theorem [Uniqueness of Types]: In a given typing context, a term (with free variables all in the domain of ) has at most one type. That is, if a term is typeable, then its type is unique. Moreover, there is just one derivation of this typing built from the inference rules that generate the typing relation. The proof of the uniqueness theorem is so direct that there is almost nothing to say. We present a few cases carefully just to illustrate the structure of proofs by induction on typing derivations. Proof: Suppose that and. We show, by induction on a derivation of, that. Case T-VAR: with By case (1) of the inversion lemma (7.4.1), the final rule in any derivation of must also be T-VAR, and. Case T-ABS: By case (2) of the inversion lemma, the final rule in any derivation of must also be T-ABS, and this derivation must have a subderivation with conclusion, with. By the induction hypothesis (on the subderivation with conclusion ( ), we obtain, from which is immediate. Case T-APP, T-TRUE, T-FALSE, T-IF: Similar.

58 Proper0es of Typing and Reduc0on (1) Typechecking Lemma [Inversion of the typing relation]: 1. If, then. 2. If, then and. 3. If, then there is some type such that and. 4. If, then. 5. If, then. 6. If, then

59 Typing and Subs0tu0on Lemma [Substitution]: If and, then Theorem [Preservation of types during evaluation]: If and, then Theorem [Progress]: Suppose is closed and stuck. If, then is a value.

60 Implementa0on

61 Base types Extensions (1) New syntactic forms ::=... (types...) base type Unit type New syntactic forms ::=... (terms...) constant ::=... (types...) Let binding New syntactic forms ::=... (terms...) let binding New evaluation rules ( ) (E-LETBETA) (E-LET) New typing rules ( ) (T-LET)

62 Extensions (2) Records and tuples New syntactic forms ::=... (terms...) record projection ::=... (values...) record value ::=... (types...) type of records New evaluation rules ( ) (E-RCDBETA) (E-PROJ) (E-RECORD) New typing rules ( ) for each (T-RCD) (T-PROJ) New abbreviations def def Exercise: In this presentation of records, the projection operation is used to

63 Extensions (3) Record patterns New syntactic forms ::= pat (untyped) variable pattern record pattern ::=... (terms...) pattern binding Matching rules: match (M-VAR) match for each match (M-RCD) New evaluation rules ( ) match (E-LETBETA) (E-LET) New abbreviations def

64 Extensions (4) Variants New syntactic forms ::=... (terms...) tagging case ::=... (types...) type of variants New evaluation rules ( ) (E-CASEBETA) (E-CASE) (E-TAG) New typing rules ( ) for each (T-VARIANT) for each (T-CASE)

65 General recursion New syntactic forms Extensions (5) ::=... (terms...) fixed point of New typing rules ( ) (T-FIX) New abbreviations def

66 Lists New syntactic forms Extensions (6) ::=... (terms...) empty list list constructor test for empty list head of a list tail of a list ::=... (values...) empty list list constructor ::=... (types...) type of lists New evaluation rules ( ) New typing rules ( ) (E-CONS1) (E-CONS2) (E-NULLBETAT) (E-NULLBETAF) (E-NULL) (E-HEADBETA) (E-HEAD) (E-TAILBETA) (E-TAIL) (T-NIL) (T-CONS) (T-NULL) (T-HEAD) (T-TAIL)

67 Lazy let bindings New syntactic forms Extensions (7) ::=... (terms...) lazy let binding New evaluation rules ( ) New typing rules ( ) (E-LLETBETA) (T-LLET) Lazy records New syntactic forms ::=... (terms...) lazy record ::=... (values...) lazy record value New evaluation rules ( ) New typing rules ( ) (E-LRCDBETA) (T-LRCD)

68 ML Download SML here Robin Milner Meta Language One of the most popular functional languages Edinburgh, 1974, Robin Milner s group There are a number of dialects with Lockwood Morris We are using Standard ML (SML) but we will just call it ML from the time being Turing Award 1991

69 SML/NJ Standard ML of New Jersey (abbreviated SML/NJ) is a compiler for the Standard ML '97 programming language with associated libraries, tools, and documenta0on. SML/NJ is free, open source sopware. hnp:// You are encourage to install SML/NJ on your computer, but we are going to use the one installed in our Unix server Timberlake, and all your work will be tested there. But you can write your code on any platform, just let me know what it is.

70 Standard ML of New Jersey *3; val it = 7 : int -1+2*3 = = ; val it = 7 : int - prompt Expression (; is not part of the expression.) ML replies with value and type = means that ML expects more input it needs ; to end the expression Variable it is a special variable bound to the value of the expression just typed

71 ML Basic (the building blocks) Constants Operators Defining Variables Tuples and Lists Defining Functions ML Types and Type Annotations

72 Mottoes of ML Type is the backbone of ML Recursion is the blood of ML Function is the flesh of ML Higher order is the soul of ML

73 - 1234; val it = 1234 : int ; val it = : real Integer constants: standard integers, Real constants: standard decimal notation int, real are the names of the types

74 - true; val it = true : bool - false; val it = false : bool Boolean constants true and false ML is case-sensitive: use true, not True or TRUE Type name: bool

75 - "fred"; val it = "fred" : string - "H"; val it = "H" : string - #"H"; val it = #"H" : char String constants: text inside double quotes Can use C-style escapes: \n, \t, \\, \", etc. Character constants: put # before a 1-character string Type names: string and char

76 - ~ * 4 div 5 mod 6; val it = ~1 : int - Operators Standard operators for integers ~ (tilde) for unary negation, e.g., ~1, negative 1 - for binary subtraction - ~ * 4.0 / 5.0; val it = ~1.4 : real - Same operators for reals, (use / for real division) Left associative, precedence is {+,-} < {*,/,div, mod} < {~}.

77 - "bibity" ^ "bobity" ^ "boo"; val it = "bibitybobityboo" : string - 2 < 3; val it = true : bool <= 1.0; val it = true : bool - #"d" > #"c"; val it = true : bool - "abce" >= "abd"; val it = false : bool String concatenation: ^ operator Ordering comparisons: <, >, <=, >=, apply to string, char, int and real Order on strings and characters is lexicographic

78 - 1 = 2; val it = false : bool - true <> false; val it = true : bool = 1.3; Error: operator and operand don't agree [equality type required] operator domain: ''Z * ''Z operand: real * real in expression: 1.3 = 1.3 Equality comparisons: = and <> Most types are equality testable: these are equality types Type real is not an equality type

79 - 1 < 2 orelse 3 > 4; val it = true : bool - 1 < 2 andalso not (3 < 4); val it = false : bool Boolean operators: andalso, orelse, not. And we can also use = for equivalence <> for exclusive or.

80 Precedence:: ~ not * / div mod + - ^ = <> < > <= >= Andalso orelse

81 - true orelse 1 div 0 = 0; val it = true : bool Note: andalso and orelse are short-circuiting operators. E.g., if the first operand of orelse is true, the second is not evaluated; likewise if the first operand of andalso is false Technically, they are not ML operators, but keywords Because all true ML operators evaluate all operands

82 - if 1 < 2 then #"x" else #"y ; val it = #"x" : char -if 1 > 2 then 34 else 56; val it = 56 : int - (if 1 < 2 then 34 else 56) + 1; val it = 35 : int Conditional expression (not statement) using if then else Similar to C's ternary operator: (1<2)? 'x' : 'y' Value of the expression is the value of the then part, if the test part is true, or the value of the else part otherwise There is no if then construct

83 What is the value and ML type for each of the following expressions? 1 * * 4 "abc" ^ "def" if (1 < 2) then 3.0 else < 2 orelse (1 div 0) = 0 Practice What is wrong? 10 / 5 #"a" = #"b" or 1 = = 1.0 if (1<2) then 3 else 4.0 If (1<2) then 3

84 - 1 * 2; val it = 2 : int * 2.0; val it = 2.0 : real * 2; Error: operator and operand don't agree [literal] operator domain: real * real operand: real * int in expression: 1.0 * 2 The * operator, and others like + and <, are overloaded to have one meaning on pairs of integers, and another on pairs of reals ML does not perform implicit type conversion

85 - real(123); val it = : real - floor(3.6); val it = 3 : int - floor 3.6; val it = 3 : int - str #"a"; val it = "a" : string Some Built-in conversion functions: 1. real (fn: int à real) 2. floor (fn: real à int) 3. ceil (fn: real à int) 4. round (fn: real à int) 5. trunc (fn: real à int) 6. ord (fn: char à int) 7. chr (fn: int à char) 8. str (fn: char à string)

86 Function Associativity Function application is left-associative So f a b means (f a) b, which means: first apply f to the single argument a; then take the value f returns, which should be another function; then apply that function to b f g h i j ((((f g) h) i) j) Note: This is different from function composition: f(g(h(i(j))))

87 - square 2+1; val it = 5 : int - square (2+1); val it = 9 : int Function application has higher precedence than any operator square 2+1; (square 2) + 1;

88 Practice What if anything is wrong with each of the following expressions? trunc 5 chr ord "a" str if 0 then 1 else 2 if true then 1 else 2.0 chr(trunc(97.0)) chr(trunc 97.0) chr trunc 97.0 trunc (fn: real à int) ord (fn: char à int) (fn: int à char) (fn: char à string)

89 Defining Variables - val x = 1+2*3; - val x = 7 : int - x; val it = 7 : int - val y = if x = 7 then 1.0 else 2.0; val y = 1.0 : real Val defines a new variable and bind it to a value. Variable names should consist of a letter, followed by zero or more letters, digits, and/or underscores.

90 - val fred = 23; val fred = 23 : int - fred; val it = 23 : int - val fred = true; val fred = true : bool - fred; val it = true : bool You can define a new variable with the same name as an old one, even using a different type. This is not the assignment. It defines a new variable but does not change the old one; it s a declaration. This example is not particularly useful ; - Same as type in: - val it = 1+2+3; Any part of the program that was using the first definition of fred, still is after the second definition is made.

91 Practice Suppose we make these ML declarations in the following order: val a = "123"; val b = "456"; val c = a ^ b ^ "789"; val a = 3 + 4; Then, what is the values and types of a, b, and c after the last expression above? a b c 7 "456" " "

92 Suppose we make these ML declarations: - val a = 3; Not an assignment - fun f x = x + a; - val a = 4; This is a way we define a function. (flesh) - fun g x = x + a; Then, what are the following results? - g 2; - f 2; 6 5

93 Garbage Collection Sometimes, for no apparent reason, we see GC # : (0 ms) A garbage collection has been performed.

94 Tuples and Lists Two most important structures in ML Tuples : (1,2,3) Lists: [1, 2, 3] Like a struct Like an array

95 Tuples 1. A tuple is like a record (struct) with no field names 2. Use parentheses to form tuples 3. Tuples can contain other tuples 4. To get i th element of a tuple x, use #i x - val barney = (1+2, 3.0*4.0, "brown"); val barney = (3,12.0,"brown") : int * real * string - val point1 = ("red", (300,200)); val point1 = ("red",(300,200)) : string * (int * int) - #2 barney; val it = 12.0 : real - #1 (#2 point1); val it = 300 : int

96 (1) is not a tuple of one - (1, 2); val it = (1,2) : int * int - (1); val it = 1 : int - #1 (1, 2); val it = 1 : int - #1 (1); Error: operator and operand don't agree [literal] operator domain: {1:'Y; 'Z} operand: int in expression: (fn {1=1,...} => 1) 1

97 Tuple Type Constructor ML gives the type of a tuple using * as a type constructor For example, int * bool is the type of pairs (x,y) where x is an int and y is a bool Note that parentheses have structural significance: Cartesian Products: int * (int * bool) (int * int) * bool int * int * bool A= {a, b} B={1, 2, 3} A B = {(a,1), (a,2), (a,3), (b,1), (b,2), (b,3)}

98 Lists Use square brackets to make lists Unlike tuples, all elements of a list must be of the same type - [1,2,3]; val it = [1,2,3] : int list - [1.0,2.0]; val it = [1.0,2.0] : real list - [true]; val it = [true] : bool list - [(1,2),(1,3)]; val it = [(1,2),(1,3)] : (int * int) list - [[1,2,3],[1,2]]; val it = [[1,2,3],[1,2]] : int list list Elements in a list must have the same type

99 - []; val it = [] : 'a list - nil; val it = [] : 'a list Empty list is [] or nil Note the unknown type of the empty list: 'a list Any variable name beginning with an apostrophe is a type variable; it stands for a type that is unknown 'a list means a list of elements with type unknown

100 The null test - null []; val it = true : bool - null [1,2,3]; val it = false : bool null tests whether a given list is empty You could also use an equality test, as in x = [] However, null x is preferred; (we will see why in a moment)

101 List Type Constructor ML gives the type of lists using list as a type constructor For example, int list is the type of lists of type int A list is not a tuple

102 - val it = [1,2,3,4,5,6] : int list operator concatenates lists Operands are two lists of the same type Equivalence, [1]@[2,3,4] or 1::[2,3,4] Note: 1@[2,3,4] is wrong

103 - val x = #"c"::[]; val x = [#"c"] : char list - val y = #"b"::x; val y = [#"b",#"c"] : char list - val z = #"a"::y; val z = [#"a",#"b",#"c"] : char list List-builder operator is :: (cons) Lisp It puts the new element on the front of the old list, the types must be agreed.

104 - val z = 1::2::3::[]; val z = [1,2,3] : int list - hd z; val it = 1 : int - tl z; val it = [2,3] : int list -tl(tl z); val it = [3] : int list -tl(tl(tl z)); val it = [] : int list The :: operator is right-associative hd : the first element tl : the tail; the whole list after the first element

105 Practice What are the values of the following expressions? #2(3,4,5) hd(1::2::nil) hd(tl(#2([1,2],[3,4]))) What is wrong with the following expressions? hd(tl(tl [1,2])) [1]::[2,3]

106 explode : converts a string to a list of characters implode : converts a list of characters to a string - explode "hello"; val it = [#"h",#"e",#"l",#"l",#"o"] : char list - implode [#"h",#"i"]; val it = "hi" : string - explode; val it = fn : string -> char list - implode; val it = fn : char list -> string - hd; val it = fn : 'a list -> 'a - tl; val it = fn : 'a list -> 'a list -

107 Moco Type is the backbone of ML Recursion is the blood of ML Function is the flesh of ML Higher order is the soul of ML ML is constructed based on types (backbone) ML carries information by recursion (blood) ML s outlook is made by function (flesh) ML exists because of its higher order computation (soul)

108 Defining Func0ons fun defines a new func0on and binds it to a variable. Func0on is a type, thus fun is a type constructor. Now, suppose we want to define a func5on that will take a string and return its first character. - fun firstchar s = hd (explode s); val firstchar = fn : string -> char - firstchar "abc"; val it = #"a" : char It is rarely necessary to declare any types, since ML infers them. ML can tell that s must be a string, since we used explode on it, and it can tell that the function result must be a char, since it is the hd of a char list

109 Function Definition Syntax in BNF <fun-def> ::= fun <function-name> <parameter> = <expression> ; <function-name> can be any legal ML name The simplest <parameter> is just a single variable name: the formal parameter of the function The <expression> is any ML expression; its value is the value the function returns This is a subset of ML function definition syntax; Func0on Type Constructor E.g., int -> real is the type of a function that takes an int parameter, the domain type) and produces a real result, the range (co-domain) type

110 All ML functions take exactly one parameter To pass more than one thing, you can pass a tuple - fun quot(a,b) = a div b; val quot = fn : int * int -> int - quot (6,2); val it = 3 : int - val pair = (6,2); val pair = (6,2) : int * int - quot pair; val it = 3 : int

111 Recursive factorial function Motto: Type is the backbone of ML Recursion is the blood of ML Function is the flesh of ML Higher order is the soul of ML - fun fact n = = if n = 0 then 1 = else n * fact(n-1); val fact = fn : int -> int - fact 5; val it = 120 : int

112 Recursive func0on to add up the elements of an int list - fun listsum x = = if null x then 0 = else hd x + listsum(tl x); val listsum = fn : int list -> int - listsum [1,2,3,4,5]; val it = 15 : int This function has used a common pattern: 1. base case for null x, 2. recursive call on tl x

113 Recursive func0on to compute the length of a list (This is predefined in ML) - fun length x = = if null x then 0 = else 1 + length (tl x); val length = fn : 'a list -> int - length [true,false,true]; val it = 3 : int - length [4.0,3.0,2.0,1.0]; val it = 4 : int Note type: this works on any type of list. It is polymorphic.

114 - fun badlength x = = if x=[] then 0 = else 1 + badlength (tl x); val badlength = fn : ''a list -> int - badlength [true,false,true]; val it = 3 : int - badlength [4.0,3.0,2.0,1.0]; Error: operator and operand don't agree [equality type required] two apostrophes, like ''a, are restricted to equality types, because we compared x for equality with the empty list. That s why null x is better than x=[]. It avoids unnecessary type restrictions.

115 Recursive function to reverse a list - fun reverse L = = if null L then nil = else reverse(tl [hd L]; val reverse = fn : 'a list -> 'a list - reverse [1,2,3]; val it = [3,2,1] : int list

116 ML Types and Type Annotations Primitive types: int, real, bool, char, and string Three type constructors: Tuple types using * List types using list Function types using ->

117 Constructor s precedence When combining constructors, list >> * >> -> int * bool list int * (bool list) int * bool list -> real (int * (bool list)) -> real Use parentheses as necessary for clarity

118 - fun prod(a,b) = a * b; val prod = fn : int * int -> int Why int, rather than real? ML s default type for * (and +, and ) is int * int -> int You can give an explicit type annotation to get real instead

119 - fun prod(a:real,b:real):real = a*b; val prod = fn : real * real -> real Type annotation is a colon followed by a type Can appear after any variable or expression These are all equivalent: fun prod(a,b):real = a * b; fun prod(a:real,b) = a * b; fun prod(a,b:real) = a * b; fun prod(a,b) = (a:real) * b; fun prod(a,b) = a * b:real; fun prod(a,b) = (a*b):real; fun prod((a,b):real * real) = a*b;