Introduction

Last week we were discussing control flow in programming languages.
We spent a fair bit of time on expression evaluation.
Then we discussed unstructured versus structured control flow.
We discussed multi-level breaks and continuations.
We said that assembly code/machine code usually supports notions of branching on condition to a label or jumping to a label and we can model these as unstructured control flow using goto's.
We went over sequencing, selection via if/else, switch/case, and enumeration-controlled iteration.
For the latter three, we gave example of pseudo-assembly/machine code that might be generated by a compiler trying to simulate those operations.
We note many languages support enumerated-controlled iteration over data structures using an iterator mechanism. For example,
```
BinTree<Integer> myTree = ...
...
for (Integer i : myTree) {
   System.out.println(i);
}
```
this kind of "for each instance loop" could be written more directly using underlying iterators as:
```
for (Iterator<Integer> it = myTree.iterator(); it.hasNext();) {
   Integer i = it.next();
   System.out.println(i);
}
```
We begin today by talking about logically controlled loops.

Logically Controlled Loops

Recall a logically controlled loop is one where the loop is executed until some Boolean condition changes value.
One question about such a loop is where to do the boolean test.
By far the most common approach in most programming languages is to have the test at the start of the loop. For example, in Algol-W we have the syntax (Java, C, C++, Python, etc all have variants of this):
```
while condition do statement
```
Here we could imagine statement to be some kind of compound statement, delimited by begin..end, {}, or extra indentation.
Another possible place to test the condition is at the end of the loop (a post-test loop). For example, in Pascal/Modula you can code block like:
```
repeat
   readln(line)
until line[1] = '$'
```
instead of
```
readln(line);
while line[1] <> '$' do
   readln(line);
```
The Java/C/C++ etc equivalent of repeat until is the do{/*stuff*/} while(condition); block.
Besides these two cases, using breaks when can also have the test be in the middle of a bloc. For example in C:
```
for (;;) {
   line = read_line(stdin);
   if (all_blanks(line)) break;
   consume_line(line);
}
```

Recursion

Unlike the control flow operations, recursion requires no special syntax as long as the language provides some notion of subroutine.
Some languages with this though like Fortran 77 and earlier versions of Fortran, don't support recursion.
Most modern languages support both mechanisms, with functional languages tending to give preference to recursion and imperative languages tending to give preference to iteration.
Recursion and iteration provide equally powerful means of computing functions: any iteration can be rewritten using recursion and vice versa.

Iteration/Recursion Equivalence Example

Suppose we want to compute `sum_{1 <= i <= 10} f(i)` for some function f in C. Iteratively, we could use the following code:

typedef int (*int_func) (int);
int summation(int_func f, int low, int high) {
   /* assume low <= high */
   int total = 0;
   int i;
   for (i = low; i <= high; i++) {
      total += f(i); // (C will automatically dereference 
      // a function pointer when we attempt to call it.)
   }
   return total;
}

Using recursion we could write this as:

typedef int (*int_func) (int);
int summation(int_func f, int low, int high) {
    /* assume low <= high */
    if (low == high) return f(low);
    else return f(low) + summation(f, low+1, high);
}

Implementing Recursion Efficiently

One drawback of the recursive solution just given, is that every recursive sub-call gets its own stack frame, so it is highly space inefficient and also has a time overhead for setting up these stack frames.
Optimizing compilers for functional languages, often use various tricks to detect if one can avoid unnecessary stack frame creation.
One situation where this is possible is if the sub-call is tail-recursive.
A tail-recursive function is one in which additional computation never follows a recursive call: the return value is simply whatever the recursive call returns.
This means we can replace the current stack frame with the sub-call stack frame, reusing space, rather than need to remember both.

Scheme Tail Recursion Example

Below is a Scheme function definition equivalent to our C program of two slides ago:

(define summation 
    (lambda (f low high)
       (if (= low high)
          (f low)                             ; then part
          (+ (f low) 
             (summation f (+ low 1) high))))) ; else part

We can modify this by adding a subtotal parameter to make it tail-recursive:

(define summation-with-subtotal
   (lambda (f low high subtotal)
      (if (= low high)
         (+ subtotal (f low))
         (summation-with-subtotal f (+ low 1) high (+ subtotal (f low))))))

A call (summation f 5 10) could be emulated as (summation-with-subtotal f 5 10 0)

Using summation-with-subtotal, we could define the original function as:

(define summation
    (lambda (f low high)
        (summation-with-total f low high 0)))

Quiz

Types

In the denotational semantics (one common approach to saying what the meaning of a program is), the term domain means a set of values.
A type is a domain, and the meaning of an expression is a value from the domain that represents the expression's type.
Types are important because:
1. They provide an implicit context for many operations. For example, if b and c are each int's then we know b + c will be an int; whereas, if they were String's b+c would be a String in Java. This implicit context can be used by the compiler rather than needing us to spell out the output type of the operation explicitly. In the int case, knowing the output type also allows us to predict the output size.
2. Types limit the set of operations that may be performed in a semantically valid program. They catch errors like taking the cosine of a variable that is an array, because we know cosine takes as argument a float.
3. If types are explicitly written in the source code they often make a program easier to understand.
4. If types are known at compile time they can be used to help optimize the output code.

Type Systems

Informally, a type system consists of
1. a mechanism to define types and associate them with certain language constructs,
2. a set of rules for type equivalence, type compatibility, and type inference.
Language constructs that must have types are those that have values or that can refer to objects that have values.
For example, constants, variables, record fields, parameters, sometimes subroutines, literal constants (17, 3.14, "foo"), and more complicated expressions build from these.
Given two values type equivalence is the problem of determining if they are of the same type using the type systems rules.
Given a value of some type, type compatibility is the problem of determining whether the type can be used in a given type context. For example, if s is a String can I use it as an argument to a function that requires an Object for that argument?
Type inference is the task of determining the type of an expression based on the types of the surrounding context.

Type Checking and Related Concepts

Type checking is the process of ensuring that a program obeys the language's type compatibility rules.
A violation is called a type clash.
A strongly-typed language is one that prohibits the application of any operation to any object that is not intended to support that operation
A statically typed language is one that is strongly typed and where the type checking can be performed at compile time.

Polymorphism

Polymorphisms refers to code that is designed to work with multiple kinds of types.
Subtype Polymorphism refers to code designed to work with values of some specific type and any of its subtypes. For example, we could have a method that takes a Object argument because we want the values going into that argument have a toString method. We could then supply a Integer value to that argument as integer is a subclass/subtype of Object.
Parametric polymorphism refer to code that takes a type (or set of types) as a parameter, either explicitly or implicitly. For example, in generics in Java such as List<T> illustrate a kind of parametric polymorphism.

Finish Control Flow - Types

Outline