10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration,...
-
Upload
wendy-parsons -
Category
Documents
-
view
219 -
download
2
Transcript of 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration,...
![Page 1: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/1.jpg)
04/20/23 COSC-3308-01, Lecture 5 1
Programming Language Concepts, COSC-3308-01Lecture 5
Iteration, Recursion, Exceptions, Type Notation, and Design Methodology
![Page 2: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/2.jpg)
04/20/23 COSC-3308-01, Lecture 5 2
Reminder of the Last Lecture Computing with procedures
lexical scoping closures procedures as values procedure call
Introduction of properties of the abstract machine last call optimization full syntax to kernel syntax
![Page 3: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/3.jpg)
04/20/23 COSC-3308-01, Lecture 5 3
Overview
Last Call Optimization Recursion versus Iteration Tupled Recursion Exceptions Type Notation
Constructing programs by following the type Design methodology (standalone applications)
![Page 4: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/4.jpg)
04/20/23 COSC-3308-01, Lecture 5 4
Recursion: Summary
Iterative computations run in constant space
This concept is also called last call optimization no space needed for last call in procedure body
![Page 5: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/5.jpg)
04/20/23 COSC-3308-01, Lecture 5 5
Power Function: Inductive Definition We know (from school or university)
1 , if n is zero
xn =
x xn-1 , n>0
![Page 6: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/6.jpg)
04/20/23 COSC-3308-01, Lecture 5 6
Recursive Function
fun {Pow X N}
if N==0 then 1
else X*{Pow X N-1}
end
end
Is this function using last call optimization (a.k.a. tail-recursive)? not an iterative function uses stack space in order of N
![Page 7: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/7.jpg)
04/20/23 COSC-3308-01, Lecture 5 7
How Does Pow Compute?
Consider {Pow 5 3}, schematically:{Pow 5 3} =
5*{Pow 5 2} =
5*(5*{Pow 5 1}) =
5*(5*(5*{Pow 5 0}))) =
5*(5*(5*1))) =
5*(5*5) =
5*25 =
125
![Page 8: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/8.jpg)
04/20/23 COSC-3308-01, Lecture 5 8
Better Idea for Pow
Take advantage of fact that multiplication can be reordered (that is, a*(b*c)=c*(a*b))
{Pow 5 3}* 1 =
{Pow 5 2}* (5*1) = {Pow 5 2}* 5 =
{Pow 5 1}* (5*5) = {Pow 5 1}* 25 =
{Pow 5 0}* (5*25) = {Pow 5 0}* 125 =
1*125
= 125 Technique: accumulator for intermediate result
![Page 9: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/9.jpg)
04/20/23 COSC-3308-01, Lecture 5 9
Using Accumulators
Accumulator stores intermediate result Finding an accumulator amounts to finding a
state invariant A state invariant is a property (predicate) that is valid
on all states State invariant must hold initially A recursive call transforms one valid state into another Final result must be obtainable from state invariant.
![Page 10: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/10.jpg)
04/20/23 COSC-3308-01, Lecture 5 10
So What Is the State for Pow
{Pow 5 3}* 1 (5, 3, 1)
{Pow 5 2}* (5*1) (5, 2, 5)
{Pow 5 1}* (5*5) (5, 1, 25)
{Pow 5 0}* (5*25) (5, 0, 125)
Technique: accumulator for intermediate result
![Page 11: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/11.jpg)
04/20/23 COSC-3308-01, Lecture 5 11
The PowAcc Function
fun {PowAcc X N Acc}
if N==0 then Acc
else {PowAcc X N-1 X*Acc}
end
end
Initial call is {PowAcc X N 1}
{PowerAcc X N 1} = X^N
{PowerAcc X N Acc} = X^N * Acc{PowerAcc X N-1 X*Acc} = X^(N-1)*(X*Acc)
![Page 12: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/12.jpg)
04/20/23 COSC-3308-01, Lecture 5 12
Pow: Complete Picture (PowA)declarelocal fun {PowAcc X N Acc} if N==0 then Acc else {PowAcc X N-1 X*Acc} end endin fun {PowA X N} {PowAcc X N 1} endend X and N are integers, because they are operands in
operations with 1.
![Page 13: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/13.jpg)
04/20/23 COSC-3308-01, Lecture 5 13
Pow: Complete Picture (PowA)declarePowAlocal PowAccin PowAcc = fun {$ X N Acc} if N==0 then Acc else {PowAcc X N-1 X*Acc} end end PowA = fun {$ X N} {PowAcc X N 1} endend
![Page 14: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/14.jpg)
04/20/23 COSC-3308-01, Lecture 5 14
Is PowA() a Correct Function?
Actually, … no, because it doesn’t cover the whole domain of integers …
the call {PowA 2 ~4} will lead to an infinite loop
![Page 15: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/15.jpg)
04/20/23 COSC-3308-01, Lecture 5 15
Characteristics of PowA It has a tight scope, since PowAcc is visible only
to PowA no other program could accidently use PowAcc PowAcc belongs to PowA
Tight scope is important to conserve namespace and avoid clash of identifiers.
Possible only very recently in… C++ “namespace” (took some twenty years) Java “inner classes” (took a major language
revision)
![Page 16: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/16.jpg)
04/20/23 COSC-3308-01, Lecture 5 16
Reverse
Reversing a list
How to reverse the elements of a list
{Reverse [a b c d]}
returns
[d c b a]
![Page 17: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/17.jpg)
04/20/23 COSC-3308-01, Lecture 5 17
Reversing a List Reverse of nil is nil
Reverse of X|Xr is Z, wherereverse of Xr is Yr, and
append Yr and [X] to get Z
{Rev [a b c d]}=
{Rev a|[b c d]}={Append {Rev [b c d]} [a]}
{Rev b|[c d]}={Append {Rev [c d]} [b]}
{Rev c|[d]}={Append {Rev [d]} [c]}
{Rev d|nil}={Append {Rev nil} [d]}
=[d c b a]
=[d c b a]
=[d c b]
=[d c]
=[d]nil
![Page 18: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/18.jpg)
04/20/23 COSC-3308-01, Lecture 5 18
Question
What is correct
{Append {Reverse Xr} X}
or
{Append {Reverse Xr} [X]}
![Page 19: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/19.jpg)
04/20/23 COSC-3308-01, Lecture 5 19
Naive Reverse Function
fun {NRev Xs}
case Xs of
nil then nil
[] X|Xr then {Append {NRev Xr} [X]}
end
end
![Page 20: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/20.jpg)
04/20/23 COSC-3308-01, Lecture 5 20
Question What is the problem with the naive reverse? Possible answers
not tail recursive Append is costly:
there are O{|L1|} calls
fun {Append L1 L2} case L1 of nil then L2 [] H|T then H|{Append T L2} endend
![Page 21: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/21.jpg)
04/20/23 COSC-3308-01, Lecture 5 21
Cost of Naive Reverse Suppose a recursive call {NRev Xs}
where {Length Xs}=n assume cost of {NRev Xs} is c(n)
number of function calls then c(0) = 0
c(n) = c({Append {NRev Xr} [X]}) + c(n-1)
= (n-1) + c(n-1)
= (n-1) + (n-2) + c(n-2) =…= n-1 + (n-2) + … + 1
this yields: c(n) =
For a list of length n, NRev uses approx. O(n2) calls!
2
)1( nn
![Page 22: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/22.jpg)
04/20/23 COSC-3308-01, Lecture 5 22
Doing Better for Reverse
Use an accumulator to capture currently reversed list
Some abbreviations {IR Xs} for {IterRev Xs} Xs ++ Ys for {Append Xs Ys}
![Page 23: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/23.jpg)
04/20/23 COSC-3308-01, Lecture 5 23
Computing NRev
{NRev [a b c]} =
{NRev [b c]}++[a] =
({NRev [c]}++[b])++[a] =
(({NRev nil}++[c])++[b])++[a] =
((nil++[c])++[b])++[a] =
([c]++[b])++[a] =
[c b]++[a] =
[c b a]
![Page 24: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/24.jpg)
04/20/23 COSC-3308-01, Lecture 5 24
Computing IterRev (IR)
{IR [a b c] nil} =
{IR [b c] a|nil} =
{IR [c] b|a|nil} =
{IR nil c|b|a|nil} =
[c b a]
The general pattern:{IR X|Xr Rs} {IR Xr X|Rs}
![Page 25: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/25.jpg)
04/20/23 COSC-3308-01, Lecture 5 25
Why is Iteration Possible?
{Append {Append RL [a]} [b]}
= {Append RL {Append [a] [b]}}
Associative Property
{Append {Append RL [a]} Acc}
= {Append RL {Append [a] Acc}}
= {Append RL a|Acc}
More Generally
![Page 26: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/26.jpg)
04/20/23 COSC-3308-01, Lecture 5 26
IterRev Intermediate Step
fun {IterRev Xs Ys}
case Xs of
nil then Ys
[] X|Xr then {IterRev Xr X|Ys}
end
end
Is tail recursive now
![Page 27: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/27.jpg)
04/20/23 COSC-3308-01, Lecture 5 27
IterRev Properly Embedded
local fun {IterRev Xs Ys} case Xs of nil then Ys [] X|Xr then {IterRev Xr X|Ys} end endin fun {Rev Xs} {IterRev Xs nil} endend
![Page 28: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/28.jpg)
04/20/23 COSC-3308-01, Lecture 5 28
State Invariant for IterRev
Unroll the iteration a number of times, we get:
{IterRev [x1 … xn] W}
=
{IterRev [xi+1 … xn] [xi … x1]++W}
![Page 29: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/29.jpg)
04/20/23 COSC-3308-01, Lecture 5 29
Reasoning for IterRev and Rev Correctness:
{Rev Xs} is {IterRev Xs nil} Using the state invariant, we have:
{IterRev [x1 … xn] nil}=
= {IterRev nil [xn … x1]}
= [xn … x1]
Thus: {Rev [x1 … xn]}=[xn … x1]
Complexity: The number of calls for {IterRev L nil}, where
list L has N elements, is c(N)=N
![Page 30: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/30.jpg)
04/20/23 COSC-3308-01, Lecture 5 30
Summary So Far
Use accumulators yields iterative computation find state invariant
Loop = Tail Recursion and is a special case of general recursion.
Exploit both kinds of knowledge on how programs execute (abstract machine) on application/problem domain
![Page 31: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/31.jpg)
04/20/23 COSC-3308-01, Lecture 5 31
Tupled Recursion
Functions with multiple results
![Page 32: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/32.jpg)
04/20/23 COSC-3308-01, Lecture 5 32
Computing Averagefun {SumList Ls} case Ls of nil then 0 [] X|Xs then X+{SumList Xs} endend
fun {Length Ls} case Ls of nil then 0 [] X|Xs then 1+{Length Xs} endend
fun {Average Ls} {SumList Ls} div {Length Ls} end
What is the Problem?
![Page 33: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/33.jpg)
04/20/23 COSC-3308-01, Lecture 5 33
Problem?
Traverse the same list multiple times.
Solution: compute multiple results in a single traversal!
![Page 34: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/34.jpg)
04/20/23 COSC-3308-01, Lecture 5 34
Tupling - Computing Two Resultsfun {CPair Ls} {Sum Ls}#{Length Ls} end
fun {CPair Ls} case Ls of nil then 0#0 [] X|Xs then case {CPair Xs}
of S#L then (X+S)#(1+L) end end
end
![Page 35: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/35.jpg)
04/20/23 COSC-3308-01, Lecture 5 35
Using Tupled Recursion
fun {Average Ls}
{Sum Ls} div {Length Ls}
end
fun {Average Ls}
case {CPair Ls} of S#L then S div L end
end Note: Division by zero should also be considered.
![Page 36: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/36.jpg)
04/20/23 COSC-3308-01, Lecture 5 36
Exceptions An error is a difference between the actual behavior
of a program and its desired behavior. Type of errors:
Internal: invoking an operation with an illegal type or illegal value
External: opening a nonexisting file We want detect these errors and handle them,
without stoping the program execution. The execution is transferred to the exception
handler, and pass the exception handler a value that describes the error.
![Page 37: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/37.jpg)
04/20/23 COSC-3308-01, Lecture 5 37
Exceptions handling An Oz program is made up of interacting
“components” organized in hierarchical fashion. The mechanism causes a “jump” from inside the
component to its boundary. This jump should be a single operation. The mechanism should be able, in a single operation,
to exit from arbitrarily many levels of nested contexts. A context is an entry on the semantic stack, i.e., an
instruction that has to be executed later. Nested contexts are created by procedure calls and
sequential compositions.
![Page 38: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/38.jpg)
04/20/23 COSC-3308-01, Lecture 5 38
Exceptions handling
![Page 39: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/39.jpg)
04/20/23 COSC-3308-01, Lecture 5 39
Exceptions (Example)fun {Eval E} if {IsNumber E} then E else case E of plus(X Y) then {Eval X}+{Eval Y} [] times(X Y) then {Eval X}*{Eval Y} else raise illFormedExpression(E) end end endendtry {Browse {Eval plus(plus(5 5) 10)}} {Browse {Eval times(6 11)}} {Browse {Eval minus(7 10)}}catch illFormedExpression(E) then {Browse '*** Illegal expression '#E#' ***'}end
![Page 40: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/40.jpg)
04/20/23 COSC-3308-01, Lecture 5 40
Exceptions (Example)
![Page 41: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/41.jpg)
04/20/23 COSC-3308-01, Lecture 5 41
Exceptions. try and raise try: creates an exception-catching context together with
an exception handler. raise: jumps to the boundary of the innermost
exception-catching context and invokes the exception handler there.
try <s> catch <x> then <s>1 end: if <s> does not raise an exception, then execute <s>. if <s> raises an exception, i.e., by executing a raise
statement, then the (still ongoing) execution of <s> is aborted. All information related to <s> is popped from the semantic stack. Control is transferred to <s>1, passing it a reference to the
exception in <x>.
![Page 42: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/42.jpg)
04/20/23 COSC-3308-01, Lecture 5 42
Exceptions. Full Syntax A try statement can specify a finally clause which is
always executed, whether the statement raises an exception or not.
try <s>1 finally <s>2 end is equivalent to: try <s>1 catch X then <s>2
raise X end end <s>2
where an identifier X is chosen that is not free in <s>2
![Page 43: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/43.jpg)
04/20/23 COSC-3308-01, Lecture 5 43
Exceptions. Full Syntax (Example 1)declare One Two
fun {One} 1 end
fun {Two} 2 end
try
{Browse a}
{One}={Two}
finally
{Browse b}
end
declare One Two
fun {One} 1 end
fun {Two} 2 end
try
{Browse a}
{One}={Two}
catch X then
{Browse b}
raise X end
end
{Browse b}
![Page 44: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/44.jpg)
04/20/23 COSC-3308-01, Lecture 5 44
How we catch that exception anyway?declare One Twofun {One} 1 endfun {Two} 2 endtry try {Browse a} {One}={Two} catch X then {Browse b} raise X end endcatch X then {Browse 'We caught the failure'}end{Browse b}General idea: transform sequence of catch-s into nested catch-s.
![Page 45: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/45.jpg)
04/20/23 COSC-3308-01, Lecture 5 45
Exceptions. Full Syntax (Example 2) It is possible to combine both catching the
exception and executing a finally statement. try
{ProcessFile F}
catch X then
{Browse '*** Exception '#X#
' when processing file ***'} finally {CloseFile F} end
It is similar with two nested try statements!
![Page 46: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/46.jpg)
04/20/23 COSC-3308-01, Lecture 5 46
System Exceptions Raised by Mozart system failure: attempt to perform an inconsistent
bind operation in the store (called also “unification failure”);
error: run-time error inside a program, like type or domain errors;
system: run-time condition in the environment of the Mozart operation system process, like failure to open a connection between two Mozart processes.
![Page 47: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/47.jpg)
04/20/23 COSC-3308-01, Lecture 5 47
System Exceptions (Example)
functorimport Browserdefine fun {One} 1 end fun {Two} 2 end try {One}={Two} catch failure(...) then {Browser.browse 'We caught the failure'} endend
![Page 48: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/48.jpg)
04/20/23 COSC-3308-01, Lecture 5 48
Type Notation
Constructing programs by following the type
![Page 49: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/49.jpg)
04/20/23 COSC-3308-01, Lecture 5 49
Dynamic Typing
Oz/Scheme uses dynamic typing, while Java uses static typing.
In dynamic typing, each value can be of arbitrary type that is only checked at runtime.
Advantage of dynamic types no need to declare data types in advance more flexible
Disadvantage errors detected late at runtime less readable code
![Page 50: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/50.jpg)
04/20/23 COSC-3308-01, Lecture 5 50
Type Notation
Every value has a type which can be captured by:
e :: type
Type information helps program development/documentation.
Many functions are designed based on the type of the input arguments.
![Page 51: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/51.jpg)
04/20/23 COSC-3308-01, Lecture 5 51
Constructing Programs by Following the Type Programs so far take lists, hence they have a
form that corresponds to the list type:
List T ::= nil T '|' List T
case Xs of nil then expr1 % base case[] X|Xr then expr2 % recursive callend
![Page 52: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/52.jpg)
04/20/23 COSC-3308-01, Lecture 5 52
Constructing Programs by Following the Type This helps us when the type gets complicated Nested lists are lists whose elements can be lists Exercise: “Find the number of elements of a nested list” Example: Xs= [[1 2] 4 nil [[5] 10]] {NoElements Xs} = ? {NoElements Xs} = 5
declareXs1=[[1 2] 4 nil]{Browse Xs1}Xs2=[[1 2] 4]|nil{Browse Xs2}
[[1 2] 4 nil]
[[[1 2] 4]]
![Page 53: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/53.jpg)
04/20/23 COSC-3308-01, Lecture 5 53
Constructing Programs by Following the Type Nested lists NList T ::= nil
NList T '|' NList T T '|' NList T (T is neither nil nor a cons)
case Xs of nil then expr1 % base case[] X|Xr andthen {IsList X} then expr2 % recursive calls for X and Xr[] X|Xr then
expr3 % recursive call for Xr end
![Page 54: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/54.jpg)
04/20/23 COSC-3308-01, Lecture 5 54
Constructing Programs by Following the Type
Nested lists Examples:
[[1 2] 3] is a nested list. {NoElements [[1 2] 3]}={NoElements [1 2]} +
{NoElements [3]}=… [1 2 3] is not a nested list (so, the number of elements
coincides with standard Oz function Length). {NoElements [1 2 3]}=1+{NoElements [2 3]}=…
fun {IsList L}L == nil orelse {Label L}=='|' andthen {Width L}==2
end
![Page 55: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/55.jpg)
04/20/23 COSC-3308-01, Lecture 5 55
Constructing Programs by Following the Type Nested lists: fun {NoElements NList T}:Int fun {NoElements Xs}
case Xs of nil then 0 % base case[] X|Xr andthen {IsList X} then
{NoElements X} + {NoElements Xr} [] X|Xr then 1 + {NoElements Xr}end
end Question: What happens if the two case patterns X|Xr are switched?
![Page 56: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/56.jpg)
04/20/23 COSC-3308-01, Lecture 5 56
Summary so far
Type Notation Constructing programs by following the type
![Page 57: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/57.jpg)
04/20/23 COSC-3308-01, Lecture 5 57
Design methodology
Standalone applications
![Page 58: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/58.jpg)
04/20/23 COSC-3308-01, Lecture 5 58
Design methodology
“Programming in the large” Written by more than one person, over a long
period of time “Programming in the small”
Written by one person, over a short period of time
![Page 59: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/59.jpg)
04/20/23 COSC-3308-01, Lecture 5 59
Design methodology. Recommendations Informal specification: inputs, outputs, relation
between them Examples: mention particular cases Exploration: determine the programming technique;
split the problem into smaller problems Structure and coding: determine the program’s
structure; group related operations into one module Testing and reasoning: test cases/formal semantics Judging the quality: Is the design correct, efficient,
maintainable, extensible, simple?
![Page 60: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/60.jpg)
04/20/23 COSC-3308-01, Lecture 5 60
Software components Split the program into logical units (also called
modules, components) A logical unit has:
An interface = the visible part of the logical unit. It is a record that groups together related languages entities: procedures, classes, objects, etc.
An implementation = a set of languages entities that are accessible by the interface operations but hidden from the outside.
![Page 61: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/61.jpg)
04/20/23 COSC-3308-01, Lecture 5 61
Modules and module specifications A module specification (software
component, functor) is a template that creates a module (component instance) each time it is instantiated.
In Oz, a functor is a function whose arguments are the modules it needs and whose result is a new module. Actually, the functor takes module interfaces as
arguments, creates a new module, and returns that module’s interface!
![Page 62: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/62.jpg)
04/20/23 COSC-3308-01, Lecture 5 62
Modules and module specifications A software component is a unit of
independent deployment, and has no persistent state.
Functors are a kind of software component. A module is a component instance; it is the
result of installing a functor in a particular module environment.
The module environment consists of a set of modules, each of which may have an execution state.
![Page 63: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/63.jpg)
04/20/23 COSC-3308-01, Lecture 5 63
Functors
A functor has three parts: an import part = what other modules it needs an export part = the module interface a define part = the module implementation
including initialization code. Functors in the Mozart system are
compilation units. That is, the system has support for handling functors in files, both as: source code (i.e., human-readable text, .oz) object code (i.e., compiled form, .ozf).
![Page 64: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/64.jpg)
04/20/23 COSC-3308-01, Lecture 5 64
Standalone applications (1) It can be run without the interactive interface. It has a main functor, evaluated when the
program starts. It imports the modules it needs, which causes
other functors to be evaluated. Evaluating (or “installing”) a functor creates a
new module: The modules it needs are identified. The initialization code is executed. The module is loaded the first time it is needed during
execution.
![Page 65: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/65.jpg)
04/20/23 COSC-3308-01, Lecture 5 65
Standalone applications (2)
This technique is called dynamic linking, as opposed to static linking, in which the modules are already loaded when execution starts.
At any time, the set of currently installed modules is called the module environment.
Any functor can be compiled to make a standalone program.
So, no export part is necessary and the initialization part defines the program’s effect.
![Page 66: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/66.jpg)
04/20/23 COSC-3308-01, Lecture 5 66
Functors. Example (GenericFunctor.oz)functorexport generic:Genericdefine fun {Generic Op InitVal N} if N == 0 then InitVal else {Op N {Generic Op InitVal (N-1)}} end endend The compiled functor GenericFunctor.ozf is created:
ozc –c GenericFunctor.oz
![Page 67: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/67.jpg)
04/20/23 COSC-3308-01, Lecture 5 67
Functors. Example (GenericFact.oz)functorimport GenericFunctor Browserdefine fun {Mul X Y} X*Y end fun {FactUsingGeneric N} {GenericFunctor.generic Mul 1 N} end {Browser.browse {FactUsingGeneric 5}}end The executable functor GenericFact.exe is created:
ozc –x GenericFact.oz
![Page 68: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/68.jpg)
04/20/23 COSC-3308-01, Lecture 5 68
Functors. Interactive Exampledeclare
[GF]={Module.link ['GenericFunctor.ozf']}fun {Add X Y} X+Y endfun {GenGaussSum N} {GF.generic Add 0 N} end{Browse {GenGaussSum 5}}
The function Module.link is defined in the system module Module.
It takes a list of functors, load them from the file system, links them together (i.e., evaluates them together, so that each module sees its
imported modules), and returns a corresponding list of modules.
![Page 69: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/69.jpg)
04/20/23 COSC-3308-01, Lecture 5 69
Summary
Last Call Optimization Recursion versus Iteration Tupled Recursion Exceptions Type Notation
Constructing programs by following the type Design methodology (standalone
applications)
![Page 70: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/70.jpg)
04/20/23 COSC-3308-01, Lecture 5 70
Reading suggestions
From [van Roy,Haridi; 2004] Chapter 2, Sections 2.4, 2.5, 2.6, 2.7 Exercises 2.9.4-2.9.12 Chapter 3, Sections 3.2-3.9 Exercises 3.10.6-3.10.17
![Page 71: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/71.jpg)
04/20/23 COSC-3308-01, Lecture 5 71
Coming up next
Higher-Order Programming and Abstract Data Types Chapter 3, Sections 3.2-3.9
![Page 72: 10/22/2015COSC-3308-01, Lecture 51 Programming Language Concepts, COSC-3308-01 Lecture 5 Iteration, Recursion, Exceptions, Type Notation, and Design Methodology.](https://reader030.fdocuments.net/reader030/viewer/2022032414/56649ee45503460f94bf3085/html5/thumbnails/72.jpg)
04/20/23 COSC-3308-01, Lecture 5 72
Thank you for your attention!
Questions?