functional programming element of functional programming
TRANSCRIPT
Functional Programming
Element of Functional Programming
Functional Programming
Functional Programming began as computing with expressions.
The following are examples:
2 An integer constantX A variablelog n Function log applied to n2+3 Function + applied to 2 and 3
Functional Programming
Expressions can also include conditionals and function definitions.
Example: The value of following condition expression is the maximum of x and y:
if (x > y) then x else y
Functional Programming
For concreteness, specific ML examples will be written in a typewriter-like font;
For example:
Computing with expressions will be introduced by designing a little language of expressions.
2 + 2; val it = 4 : int
A LITTLE LANGUAGE OF EXPRESSIONS
Basic Values Constants: Names for Basic Values Operations Expressions Convenient Extensions Local Declarations
A LITTLE LANGUAGE OF EXPRESSIONS
Expressions are formed by giving names to values and to operations on them
The little language manipulates just one type of value: geometric objects called quilts.
Example : Quilt
What is Quilt?
Little Quilt
Little Quilt manipulates geometric objects with
Height Width Texture
Basic Values
Given two primitive objects in the language are the square pieces:
Each quilt has A fixed direction or orientation A height A width A texture
Operations
Quilt can be turned and can be sewn together
turn turn turn turn
sew
Rules
1. A quilt is one of the primitive pieces, or
2. It is formed by turning a guilt clockwise 90, or
3. It is formed by sewing a quilt to the right of another quilt of equal height
4. Nothing else is a quilt
Quilts and the operations on them are specified by the following rules:
Constants: Names for Basic Values
The first step in construction a language to specify quilts is to give names to the primitive pieces and to the operations on quilts
Name “a”
Name “b”
Operation called• turn• sew
Expressions
The syntax of expressions mirrors the definition of quilts:
Complex expressions are built up from simpler ones,
<exp> ::= a | b | turn(<exp>) | sew(<exp>,<exp>)
Expressions
Sew(turn(turn(b)),a)
No expression quilt
1 b
2 turn(b)
3 turn(turn(b))
4 a
5 sew(turn(turn(b)),a)
Convenient Extensions
Expressions will now be extended by allowing functions from quilts to quilts.
It would be convenient to give names to the operations.
Once defined, functions like unturn and pile can used as if they were built inFun unturn(x) = turn(turn(turn(x)))Fun pile(x,y) = unturn(sew(turn(y),turn(x)))
Local Declarations
Let-expressions or let-bindings allow declarations to appear within expressions.
Let-expression FormLet <declaration> in <expression> end
For examplelet fun unturn(x) = turn(turn(turn(x))) fun pile(x,y) = unturn(sew(turn(y),turn(x)))in pile(unturn(b),turn(b))end
User-Defined Names for Values
The final extension is convenient for writing large expressions in terms of simpler ones.
A value declaration form:
Gives a name to a value
val <name> = <expression>
Value declarations are used together with let-bindings.
An expression of the formlet val x=E1 in E2 end
let val bnw = unturn(b)in pile(bnw,turn(b))end
RewritePile(unturn(b),turn(b))
Review: Design of Little Quilt
The language Little Quilt was defined by starting with values and operations.
The values are quilts, built up from two square pieces;
The operations are for turning and sewing quilts. The language began with the name a and b for the
square pieces and The names turn and sew for the operations
Specification of a quilt
Let fun unturn(x) = turn(turn(turn(x))) fun pile(x,y) = unturn(sew(turn(y),turn(x))) val aa = pile(a,turn(turn(a))) val bb = pile(unturn(b),turn(b)) val p = sew(bb,aa) val q = sew(aa,bb)In pile(p,q)end
Summary of Little Quilt
<exp> ::= a | b <exp> ::= turn(<exp>) | sew(<exp>,<exp>)<exp> ::= let <declarations> in <exp> end<decs> ::= <dec> | <dec> <decs><dec> ::= fun <name> (<formals>) = <exp><formals> ::= <name> | <name>, <formals><exp> ::= <name> (<actuals>)<actuals> ::= <exp> | <exp>, <actuals><dec> ::= val <name> = <exp><exp> ::= <name>
TYPEs:Values and Operations
A types consists of a set of elements called values together with a set of functions called operations.
We will consider methods for defining structured values such as products, lists, and functions.
The syntax of type expressions
<type-exp> ::= <type-name> | <type-exp> <type-exp> | <type-exp> *<type-exp> | <type-exp> list
Structured value
Structured values such as lists can be used as freely in functional languages as basic values like integers and strings
Value in a function language take advantage of the underlying machine, but are not tied to it.
Operations for Constructing and Inspecting Values
The structuring methods will be presented by specifying a set of values together with a set of operations.
Concentrate on operations for constructing and inspecting the elements of the set.
For example• To Extend a list by adding a new first element• To test whether a list is empty
Operations for Constructing and Inspecting Values
Basic Types Operations on Basic Values Products of Types Operations on Pairs List of Elements Operations on Lists
Basic Types
A type is basic if its values are atomic If the values are treated as whole elements,
with no internal structure.
For exampleThe boolean values in the set {true,false}
Operations on Basic Values
Basic values have no internal structure, so the only operation defined for all basic types is a comparison for equality;
For example
The equality 2 = 2 is true,
The inequality 2!=2 is false
Operations on Basic Values
Technically, an operation is a function The equality test on integers is a function
from pairs of integers to boolean.The type
int*int bool
Products of Types
The product A*B of two types A and B consists of ordered pairs written as
For Example(1,“one”) is a pair consisting of int:1 and string: “one”
(a,b) ; where a is a value of type A and b is a value of type B
Products of Types
A product of n types A*A*A*…*A consists of tuples written as(a1, a2 , a3 ,…, an ) ; where ai is a value of type A1
Operations on Pairs
A pair is constructed from a and b by writing (a,b) Associated with pairs are operations called
projection functions to extract the first and second elements from a pair. The first element of the pair (a,b) is a The second element is b
Projection functions can be readily defined:fun first(x,y) = xfun second(x,y) = y
Lists of Elements
A list is a finite-length sequence of elements.
For Example
int list ; consists of all lists of integers.
The type A list consists of all lists of elements, where each element belongs to type A
Lists of Elements
List elements will be written between brackets [ and ]
List elements will be separated by commas The empty list is written equivalently as [ ]
For Example[1, 2, 3] is a list of three integers[“red”, “white”, “blue”] is a list of three strings
Operations on Lists
Lists-manipulation programs must be prepared to construct and inspect lists of any length.
The following operations on list are from ML:null(x) True is x is the empty listhd(x) The first or head element of list x.tl(x) The tail or rest of the list.a::x Construct a list with head a and tail x
Operations on Lists
For ExampleGiven x is [1, 2, 3] Null(x) false Hd(x) 1 Tl(x) [2, 3]From the following equalities: [1, 2, 3] = 1::[2, 3] = 1::2::[3] = 1::2::3::[]
Functions from a Domain to a Range
The type A B is the set of all functions from A to B
For ExampleIf Q is the set of quilt then function turn from quilts to quilts is Q Q function sew form pairs of quits to quilts is Q*Q Q
Functions from a Domain to a Range
A function f in A B is total
A function f in A B is partial
If it associates an element of B with each element of AA is called the domain and B is called the range of f.
It is possible for there to be no element of B associated with an element of A
Function Application
The set A B is application which takes a function f in A B and an element a in A and yields and element b of B.
For Example A function is applied in ML; f a is the
application of f to a.
APPOACHES TO EXPRESSION EVALUATION
The rules for expression are base on the structure of expressions
E1 + E2
1. Evaluate the subexpressions E1 and 2. Evaluate the subexpressions E2 and3. Add two values
Innermost Evaluation
Evaluate the expression represented by <actual-parameter>
Substitute the result for the formal in the function body
Evaluate the body Return its value as the answer
<name> <actual-parameter>
Selection Evaluate
<condition> is an expression that evaluates to either true or false.
True : <expression1> is evaluated False : <expression2> is evaluated
If <condition> then <expression1> else <expression2>
Evaluation of Recursive Functions
The actual parameters are evaluated and substituted into the function body.
Length(X) ((cond (null X) 0 (+ 1 (length(cdrX)))))
Length([“hello”, “world”]) = 1 + length([“world”]) = 1 + 1 + length([]) = 1 + 1 + 0 = 2
Othermost Evaluation
Substitute the actual for the formal in the function body
Evaluate the body Return its value as the answer.
Example Function
Fun f(x) = if x > 100 then x-10 else f(f(x+11))
Innermost Evaluate
F(100) = if 100>100 then 100-10 else f(f(100+11)) = f(f(100+11)) = f(f(111)) = f( if 111> 100 then 111-10 else f(f(111+11)) ) = f(111-10) = f(101) = if 101>100 then 101-10 else f(f(101+11)) = 101 – 10 = 91
Outermost Evaluate
F(100) = if 100>100 then 100-10 else f(f(100+11))
= f(f(100+11))
= if f(111> 100) then
f(111+11)-10 else f(f(f(100+11)+11)) )
F(100+11) = if 100+11> 100 then
100+11-10 else f(f(100+11+11))
= if 111>100 then
100+11-10 else f(f(100+11+11))
= 100+11-10 = 111-10 = 101
LEXICAL SCOPE
Renaming is made precide by introducing a notion of local or “bound” variables;bound occurrences of variables can be renamed without changing the meaning of a program
fun successor(x) = x + 1fun successor(n) = n + 1
Val Bindings
Binding occurrence or simply binding of x All occurrences of x in E2 are said to be
within the scope of this binding Occurrences of x in E1 are not in the scope
of this binding of x
let val x=E1 in E2 end
let val x=2 in x+x end
Fun Bindings
This binding of the formal parameter x is visible only to the occurrences of x in E1
This binding of the function name f is visible to all occurrences of f in both E1 and E2
let fun f(x)=E1 in E2 end
let fun f(x)=x+1 in 2*f(x) end