Error ExampleError Example- 65/4; - 65/4; ! Toplevel input: ! Toplevel input: ! 65/4; ! 65/4; ! ^^ ! ^^ ! Type clash: expression of type ! Type clash: expression of type ! int ! int ! cannot have type ! cannot have type ! real ! real

Currying ExampleCurrying Example• Difference with left binding functionsDifference with left binding functions

– exp x y-1 exp x y-1 (exp x y) -1 (exp x y) -1– exp x (y-1)exp x (y-1)

- fun exp x y = if (y=0) then 1 else x * (exp x (y-1)); - fun exp x y = if (y=0) then 1 else x * (exp x (y-1)); > val exp = fn : int -> int -> int > val exp = fn : int -> int -> int

Type ExamplesType Examples• fun cast (n:int) = n;fun cast (n:int) = n;• fun cast n = n : int;fun cast n = n : int;• fun cast n = n+”abc”;fun cast n = n+”abc”;• fun cast (n:int) = n+”abc”;fun cast (n:int) = n+”abc”;

Polymorphic FunctionsPolymorphic Functions- fun id x = x; - fun id x = x; > val id = fn : 'a -> 'a > val id = fn : 'a -> 'a

- fun cond c x y = if c then x else y; - fun cond c x y = if c then x else y; > val cond = fn : bool -> 'a -> 'a -> 'a > val cond = fn : bool -> 'a -> 'a -> 'a

the Let Functionthe Let Function- fun prodSum x y = (x+y) * (x+y); - fun prodSum x y = (x+y) * (x+y); > val prodSum = fn : int -> int -> int > val prodSum = fn : int -> int -> int

- fun prodSum x y = - fun prodSum x y = let let val sumXY = x + y val sumXY = x + y in in sumXY * sumXY sumXY * sumXY

end ;end ; > val prodSum = fn : int -> int -> int > val prodSum = fn : int -> int -> int

Tuple ExtractionTuple Extraction- let - let

val (u,v) = incBoth (3,5) val (u,v) = incBoth (3,5) in in

u u end; end; > val it = 4 : int > val it = 4 : int

The Map FunctionThe Map Function- fun map f inpList = - fun map f inpList =

case inpList of case inpList of [] => [] [] => []

| (h::t) => (f h) :: (map f t) | (h::t) => (f h) :: (map f t) ; ;

> val map = fn : ('a -> 'b) -> 'a list -> > val map = fn : ('a -> 'b) -> 'a list -> 'b list 'b list

The Filter FunctionThe Filter Function- fun filter condition inpList = - fun filter condition inpList =

case inpList of case inpList of [] => [] [] => []

| (h::t) => | (h::t) => if (condition h) if (condition h) then h :: (filter condition t) then h :: (filter condition t) else filter condition t else filter condition t

; ; > val filter = fn : ('a -> bool) -> 'a list -> 'a > val filter = fn : ('a -> bool) -> 'a list -> 'a

list list

Programming in MLProgramming in ML

By Drew WyborskiBy Drew Wyborski

Data Type/OperatorsData Type/Operators• Operators and types similar to Operators and types similar to

C++/JavaC++/Java– int, string, bool and real remain the sameint, string, bool and real remain the same– Operators have slight differencesOperators have slight differences

• Additional Boolean types are included Additional Boolean types are included showing the rational/logical basisshowing the rational/logical basis– andalso & orelseandalso & orelse

SyntaxSyntax• Input is placed into user’s implementationInput is placed into user’s implementation• Machine responds with result of expressionMachine responds with result of expression• Specified layout for entry and outputSpecified layout for entry and output

– 3 + 4;3 + 4;– val it = 7 : intval it = 7 : int

• If an If an errorerror is made in entry, the machine is made in entry, the machine responds with an appropriate errorresponds with an appropriate error

• The unit data typeThe unit data type

DefinitionsDefinitions• Global constantsGlobal constants

– val PI = 3.4;val PI = 3.4;– Help increase readabilityHelp increase readability

• FunctionsFunctions– fun succ n = n+1;fun succ n = n+1;– val succ = fn : int val succ = fn : int int int– Differences in calling compared to imperativeDifferences in calling compared to imperative

• ExtensionsExtensions– if…then…else functionsif…then…else functions– Multiple input/output functionsMultiple input/output functions

CurryingCurrying• An extension of function writingAn extension of function writing• Special ability of functional languageSpecial ability of functional language• Left bindingLeft binding• Partial evaluation (aka “currying”)Partial evaluation (aka “currying”)• ExampleExample

““Side-effect Free” Side-effect Free” ProgrammingProgramming• The interaction of functions in MLThe interaction of functions in ML• The use of referential-transparency occurs through The use of referential-transparency occurs through

the elimination of some imperative-type features:the elimination of some imperative-type features:– Global variablesGlobal variables– AssignmentsAssignments– Value-result parametersValue-result parameters– PointersPointers

• Advantages in readability and modification in small Advantages in readability and modification in small components or functionscomponents or functions

• Victims of elimination of side-effectsVictims of elimination of side-effects

Exceptions to Referential Exceptions to Referential TransparencyTransparency• Input/Output devicesInput/Output devices

– Something outside the program is changedSomething outside the program is changed– The functions have type that returns unitThe functions have type that returns unit

• Functions because the result must be Functions because the result must be expressed outside the interpreterexpressed outside the interpreter

• The print functionThe print functionprint “Hello there \n”;print “Hello there \n”;Hello thereHello there> value it = ( ) : unit> value it = ( ) : unit

Basic Syntactical NotesBasic Syntactical Notes• There is the option for expression There is the option for expression

sequencingsequencing• The use of sequencing leads to the The use of sequencing leads to the

loss of previous expressions unless loss of previous expressions unless they have the rare side-effect (most they have the rare side-effect (most likely “print”)likely “print”)

• Comments are important as in any Comments are important as in any other languageother language– Denoted through the use of (* … *)Denoted through the use of (* … *)

Type InferenceType Inference• Strength of ML that helps offset loss of Strength of ML that helps offset loss of

imperative functionsimperative functions• Ability to declare or not declare data Ability to declare or not declare data

typetype– Encouraged to do so for documentationEncouraged to do so for documentation– Similar notation to what we’ve already seenSimilar notation to what we’ve already seen– Allow us to make the implementer operate Allow us to make the implementer operate

correctlycorrectly– Help to clear up possible Help to clear up possible error messageserror messages

PolymorphismPolymorphism• ML exhibits a strong amount of ML exhibits a strong amount of

polymorphismpolymorphism– Exists in function calls and data typingExists in function calls and data typing– Gives us the ability to openly code for many Gives us the ability to openly code for many

different data typesdifferent data types– Can create data variablesCan create data variables

• Some Some common polymorphic functionscommon polymorphic functions• Different notationDifferent notation associated with associated with

polymorphic functionspolymorphic functions

Higher-Order FunctionsHigher-Order Functions• Used to compact functions togetherUsed to compact functions together• Useful to extend an already defined Useful to extend an already defined

functionfunction• Helps add levels of abstractionHelps add levels of abstraction• Another example of the Another example of the

polymorphism present in MLpolymorphism present in ML

Function ExtensionFunction Extension• We are able to define some “local variables” We are able to define some “local variables”

through the use of the let functionthrough the use of the let function– This allows us to temporarily assign a value of This allows us to temporarily assign a value of

something to be used later in the expressionsomething to be used later in the expression– It is only good for the part of the statement It is only good for the part of the statement

enclosed in let expressionenclosed in let expression– Cannot use the let expression to try and mimic Cannot use the let expression to try and mimic

imperative assignment statementsimperative assignment statements• We can also use functions in this statementWe can also use functions in this statement

Function ExtensionFunction Extension• There are some good guidelines that are There are some good guidelines that are

almost universal in writing longer almost universal in writing longer functions in ML:functions in ML:– Name the function and parameters on line 1Name the function and parameters on line 1– Indent the body of the function like you Indent the body of the function like you

would in Java or C++would in Java or C++– Include the terminating end; portion on its Include the terminating end; portion on its

own line at the endown line at the end

TuplesTuples• Consist of pieces of data grouped Consist of pieces of data grouped

together in parenthesistogether in parenthesis– (3,4) or (“abc”,1) or (true,”abc”,87.4)(3,4) or (“abc”,1) or (true,”abc”,87.4)

• We can use tuples across functions We can use tuples across functions just like any other data typejust like any other data type

• To extract individual pieces of data To extract individual pieces of data from the tuple we utilize the let from the tuple we utilize the let functionfunction

RecordsRecords• Similar to tuples except with names Similar to tuples except with names

for the componentsfor the components• Enclosed in a set of brackets with Enclosed in a set of brackets with

field=value components inside for field=value components inside for definitiondefinition

• They are then accessed through the They are then accessed through the use of the # function and then the use of the # function and then the field namefield name

ListsLists• Lists are created through the construction of Lists are created through the construction of

data values between brackets of the same data values between brackets of the same typetype– [1,2,3] or [“ab”,”cd”,”ef”][1,2,3] or [“ab”,”cd”,”ef”]

• Things can be appended using ::Things can be appended using ::– 5 :: [1,2,3] 5 :: [1,2,3] [5,1,2,3] : int list [5,1,2,3] : int list

• Concatenation is done using the @ symbolConcatenation is done using the @ symbol– [1,2,3] @ [4,5,6] [1,2,3] @ [4,5,6] [1,2,3,4,5,6] : int list [1,2,3,4,5,6] : int list

• When using functions with lists we use the When using functions with lists we use the case operatorcase operator– This provides us with operations for an empty list This provides us with operations for an empty list

as well as one with data in itas well as one with data in it– We split the list into the head value and the tail to We split the list into the head value and the tail to

use for recursion so we can process the full listuse for recursion so we can process the full list

List IterationList Iteration• Can be used to replace the for loop Can be used to replace the for loop

function from imperative languagesfunction from imperative languages• The map functionThe map function

– Iterates down the list by applying the specified Iterates down the list by applying the specified function to the headfunction to the head

– The tail then recurses on itself using map againThe tail then recurses on itself using map again– ExampleExample

• The filter functionThe filter function– Eliminates the values that don’t match the Eliminates the values that don’t match the

input functioninput function– Operates the same way as map except Operates the same way as map except

eliminates those without a positive bool value eliminates those without a positive bool value from the given functionfrom the given function

– ExampleExample

User-defined TypesUser-defined Types• Enumerated TypesEnumerated Types

– datatype Food = Burger | Chicken | Hot Dog;datatype Food = Burger | Chicken | Hot Dog;• Custom data typesCustom data typesdatatype Statsdatatype Stats

Rebounds of intRebounds of int| Point of int| Point of int| Fouls of int;| Fouls of int;– val StatsThisGame = [Rebounds 4, Point 12, Fouls 3, val StatsThisGame = [Rebounds 4, Point 12, Fouls 3,

Rebounds];Rebounds];• Can be applied over many ways and used in Can be applied over many ways and used in

functions for various purposesfunctions for various purposes