Schedule of Classes

This lectures introduces the technical underpinnings of the language Standard ML as well as some elementary constructs. In particular, it discusses the functional programming paradigm, the characteristics of strongly typed languages, and interpreter-based execution.

The algebraic concept of inductive data structure is available in ML as the datatype mechanism. This provides a way to represent data in a natural fashion. We define datatypes for a variety of data structures and show how to write functions for them. We see that the structure of a datatype definition naturally leads to clausal function definitions, a convenient way to work with them based on pattern matching. We discuss at length ML's predefined support for lists and introduce the programming concept of polymorphism.

We take a closer look at how ML manages declarations. Declarations evaluate to environments, which collects a set of bindings of variables to values which can be used in subsequent declarations or expressions. We introduce the mechanisms provided in ML for local declarations and expand on the rules of scope, which explain how references to identifiers are resolved. This is somewhat tricky for recursive function declarations. We also discuss tail recursion, a form of recursion that is somewhat like the use of loops in imperative programming. This form of recursion is often especially efficient and easy to analyze. Accumulator arguments play an important role in tail recursion.

We discuss the separation between specification and implementation in the context of code reuse. The specification describes the functionalities of an abstract data type, with its syntactic aspects expressed as a module interface. The implementation consists of specific code that realizes these functionalities, code whose details are invisible to the user of a module. We also introduce advanced concepts such as parametric modules. The discussion is concretized by examining the specific module system of ML, in particular the concepts of signature, structure, functor and ascription.

One very useful application of higher-order functions is as a way to control the execution of a program: continuations act as "functional accumulators." The basic idea of the technique is to implement a function f by defining a tail-recursive function f' that takes an additional argument, the continuation. This continuation is a function; it encapsulates the computation that should be done on the result of f. In the base case, instead of returning a result, we call the continuation. In the recursive case we augment the given continuation with whatever computation should be done on the result.

Exceptions are another way to control execution programmatically. We see that exceptions can be used not only to signal error conditions, but also in backtracking search procedures or other patterns of control where a computation needs to be partially undone. Exceptions are the first type of effect that we encounter; they may cause an evaluation to be interrupted or aborted.

Data streams (as in YouTube for example) are a prominent computational instance of a co-inductive data structure. We discuss how to support them in a programming language through the concept of lazy evaluation: functions in ML are evaluated eagerly, meaning that the arguments are reduced before the function is applied. An alternative is for function applications and constructors to be evaluated in a lazy manner, meaning expressions are evaluated only when their values are needed in a further computation. In an eager language such as ML, lazy evaluation can be simulated by relying on the on the fact that functions are values to "suspend" the computation. This style of evaluation is essential when working with potentially infinite data structures, such as streams, which arise naturally in many applications. Then, streams are lazy lists whose values are determined by suspended computations that generate the next element of the stream only when forced to do so

The programming techniques used so far in the course have, for the most part, been "purely functional". Some problems, however, are more naturally addressed by keeping track of the "state" of an internal machine. Typically this requires the use of mutable storage. ML supports mutable cells, or references, that store values of a fixed type. The value in a mutable cell can be initialized, read, and changed (mutated), and these operations result in effects that change the store. Programming with references is often carried out with the help of imperative techniques. Imperative functions are used primarily for the way they change storage, rather than for their return values References allow us to create data structures that are ephemeral, i.e., that change over time. Their main advantage is the ability to maintain state as a shared resource among many routines. Another advantage in some cases is the ability to write code that is more time-efficient than purely functional code. On the other hand, they are conceptually complex and therefore error-prone: our routines may accidentally and irreversibly change the contents of a data structure; variables may be aliases for each other. As a result it is much more difficult to prove the correctness of code involving ephemeral data structures.

We continue with streams, and complete our implementation by introducing a memoizing delay function. Memoization ensures that a suspended expression is evaluated at most once. When a suspension is forced for the first time, its value is stored in a reference cell and simply returned when the suspension is forced again. The implementation that we present makes a subtle and elegant use of a "self-modifying" code technique with circular references

Regular expressions - and their underlying finite-state automata - are useful in many different applications, and are central to text processing languages and tools such as awk, Perl, emacs and grep. Regular expression pattern matching has a number of simple and elegant implementation in ML. Regular expressions are the key ingredient of lexical analysis, a pre-processing step carried out by many application to recognize legitimate words. Examples include compiling programming languages, processing natural languages, or manipulating HTML pages to extract structure. As an example, we study a lexical analyzer for a simple language of arithmetic expressions.

In this lecture we rely on context-free grammars to parse programs. We look at the two main parsing techniques, shift-reduce and recursive descent. Shift-reduce parsing uses a stack to delay application of rewrite rules, enabling operator precedence to be enforced. Recursive descent parsing is another style that uses recursion in a way that mirrors the grammar productions. Although parser generator tools exist for restricted classes of grammars, a direct implementation can allow greater flexibility and better error handling. We present an example of a shift-reduce parser for a grammar of arithmetic expressions

We implement the evaluation semantics into an evaluator, and put it together with lexical analysis and parsing. The result is an interpreter that evaluates arithmetic expressions directly, rather than by constructing an explicit translation of the code into an intermediate language, and then into machine language, as a compiler does. Our first example uses the basic grammar of arithmetic expressions, interpreting them in terms of operations over the rational numbers. We then extend this simple language to include conditional statements, variable bindings, function definitions, and recursive functions

Networked applications are an especially important case of distributed systems. We explore a few of the main concepts by showing how to write a simple web server.