Introduction

Last week, we looked at how various programming language constructs could be implemented in a functional programming way.
We showed how the use of closures and message passing could be used to implement classes in Scheme.
We talked about applicative order evaluation (how functions typically defined in Scheme) versus normal order/lazy evaluation, and how we can use define-syntax to define new Scheme macros using the latter.
We talked about how lazy evaluation can be used to define streams (unbounded length lists whose elements are generated lazily).
We discussed about how lazy evaluation can be implemented efficiently using memo-ization.
We also discussed how Input/Output can be modeled using streams.
We now continue our discussion of I/O in functional programming languages.

Streams, Monads, Haskell

Streams formed the basis of the I/O system in early versions of Haskell.
Streams work well in the terminal, file input/output setting, but are less good for modeling graphics, or random access files.
To fix this Haskell, switched to using a more general concept known as a monad, a concept coming from category theory in mathematics.
Monads are essentially a clever use of higher-order functions, coupled with a bit of syntactic sugar, that allow the programmer to chain together a sequence of what Haskell calls actions (function calls) that have to happen in order. This sequence is thus a generalization of a stream.
As an example, consider a random number generator as often implemented in a programming language.
When we call a function like rand(), usually we set `X_0` as some initial seed value. We internally remember the previous returned number and the `n+1`st time rand() is called, we compute it as: `X_{n+1} = (a*X_n +b) mod M` for some fixed a, b, M.
This idiom isn't possible in a pure functional language, because we need to remember the previous `X_i`.
We can obtain a similar effect by passing the state to the function and having it return a new state along with the random number.
Let's take a look at how we can implement this idea in Haskell with and without monads.

Random Number Generation with and Without Monads

Here is code that takes a state of a random number generator and uses it to produce a tuple consisting of a list of two random integers and a new state of a random generator.

twoRandomInts :: StdGen -> ([Integer], StdGen)
  -- type signature: twoRandomInts is a function that takes an
  -- StdGen (the state of the RNG) and returns a tuple containing 
  -- a list of Integers and a new StdGen.
twoRandomInts gen = let
    (rand1, gen2) = random gen 
    (rand2, gen3) = random gen2
  in ([rand1, rand2], gen3)

main = let
  gen = mkStdGen 123  -- new RNG, seeded with 123 
  ints = fst (twoRandomInts gen) -- extract first element
in print ints

The drawback of code like the above is if we want to use generators in different places in our program we need to keep passing around the current state of the generator.

This is the code with Monads:

twoMoreRandomInts :: IO [Integer]
  -- twoMoreRandomInts returns a tuple of two Integers. It also
  -- implicitly accepts, and returns, the state of the IO monad.
twoMoreRandomInts = do
  rand1 <- randomIO 
  rand2 <- randomIO 
  return [rand1, rand2]
main = do
  moreInts <- twoMoreRandomInts
  print moreInts

Notice the type of twoMoreRandomInts has now become IO [Integer].
This identifies it as an IO action -- a function that, in addition to returning an explicit list of integers, invisibly accepts and returns the state of the IO monad (including the standard RNG).
Similarly, the type of randomIO is IO [Integer].
To thread the IO state from one action to the next, the bodies of twoMoreRandomInts and main use do notation rather than let.
A do block packages a sequence of actions together into a single, compound action (Haskell do not the same as Scheme do).

A Logic-based Language Paradigm...

So far this semester we have considered three language paradigms: procedural languages, object-oriented languages, and functional programming languages.
We are now going to look at one more language paradigm: logic programming.
Logic is tightly related to computer programs. For instance, AND, OR, NOT logic gates can be used to build up computer circuits. We have also briefly mentioned the formula-as-types interpretation.
We haven't really said what logic was though...
So we will talk a little bit about this before we talk about logic programming and then Prolog.

Logic and Logic Programs

The kind of logic used in logic programming is the first-order predicate calculus.
When we work in first-order logic, we usual work in a particular language.
Languages are assumed to come equipped with variables and for our purposes we will write these as: x,y,z,... or x₁, x₂,...
A language is specified by specifying its:
- Constants -- things like 0 or 1
- Functions -- these may be of different arity: S(x) := x+1, Plus(x,y), Times(x,y), ...
- Predicates -- P(x), Q(x,y), ... We imagine that predicates take inputs from some domain and return a true or false answer. For example equals(x,y) might take inputs which are natural numbers and returns true or false depending on whether x and y are equal.
A term in the language is either a constant, a variable, or built from other terms using functions of the language.
An atomic formula in the language is a predicate whose parameters have been filled in with terms.

More First-Order Logic

A first-order formula is either an atomic formula or built out of first-order formulas using AND(∧), OR (∨), NOT (¬), IMPLIES (→), EXISTS (∃x), FORALL (∀x).
For example, Even(x) := (∃y)( x = 2*y) is a first-order formula expressing x is an even number. Notice 2*y and x are terms, so x = 2*y is an atomic formula, so (∃y)( x = 2*y) is a formula.
In the above, the variable x would be called a free variable and the variable y is called bound.
Notice depending on the value of x, Even(x) may be either true or false.
Typically in mathematics, we start with a set of formulas (axioms) which we think are always true and we see what others facts we are able to derive from these formulas.
A formula derivable from our axioms is called a theorem.

Rules of Inference

So given a set of true formulas, what are the legal inferences we can make?
For example, if I know A is true, I can infer A ∨ B is true. Similarly, if I know A(t) holds, I can infer (∃y)A(y). Given A→B and B→ C, I can infer A→C.
These are examples of valid rules of inference. There is a finite list of inferences I (all of which are also valid), such that given a list of axioms A, and any statement T that follows from A, we can start from formulas in A and only apply inferences in I to get new formulas, and eventually reach the formula T.
A derivation of T from A using I would be called a proof.
A logic programming language is a notational system for writing logic statements together with specified algorithms for implementing inference rules.

Horn Clauses

A Horn clause is a statement of the form:
a₁ ∧ a₂ ∧ ... a_n → b b is called the head of the clause, and the rest of the clause is called the body. Each a_i in the body is called a premise.
Horn clauses are particularly simple formulas which are useful for creating a computer language.
A clause of the form →b is called a fact, and might just be written as b.
As an example of how Horn clauses might be useful in terms of expressiveness, consider the following axioms for the natural numbers:
1. natural(0).
2. natural(x) → natural(successor(x)).
To prove natural(successor(successor(0))), which in English we might view as saying "two is a natural number", we can use axiom (1) together with axiom (2) twice and modus ponens.

Prolog

We would like to use Horn clauses as a basis of a programming language.
Prolog, created by Alain Colmerauer and Phillipe Roussel in 1972, in fact does this.
The most recent Prolog standard has two parts: the core, ISO/IEC 13211-1 published in 1995, with corrections in 2007, 2012, and 2017; and the module system ISO/IEC 13211-2, published in 2000.
For this class, we will use SWI-Prolog which has been under development since 1987.
The motivating idea behind Prolog is that to write program we should make logical statements declaring what we know to be true about a problem, then we ask questions of our statements, and use theorem proving to answer these questions.
In Prolog we write our Horn Clauses backwards, and rather than use ← we use :- instead. For example:
```
loves(jane,X) :- flies(X).
loves(X,bob) :- movieStarring(bob).
```
Horn Clauses which have no premises are called facts and are written as predicates followed by a period. For example:
```
sky(blue).
chase(dogs, cats).
```

Resolution, and Unification

There are two aspects to derivations involving Horn clauses that provide the basic algorithmic component of Prolog: resolution and unification.

Given two Horn clauses:

A :- A₁, ..., A_m 

B :- B₁, ..., B_n

where B_i = A, a resolution inference on these two clauses yields:

B :- B₁, ... B_i-1, A₁, ..., A_m, B_i+1, ... B_n.

Unification was the process of pattern matching we used a couple slides back (and also did when talking about type inference) to match natural(successor(x)) and natural(successor(successor(0))) by setting x =successor(0).
Prolog tries to determine if something is true by scanning from the top down in the rules of a given Prolog program.
If it finds the questions unifies with a fact, then it says its true.
If it finds a rule that unifies with the question, then it tries to derive all of the premises of the rule. This is done by either checking if each premise unifies with a fact, or if a premise unifies with a rule -- in the latter case, it then uses resolution again. This process continues until all the premises are derived or no further derivation is possible. In the first case, the output is yes. In the second case, the output is no.
It might be the case that more than one rule could be used in a resolution step. Prolog then tries resolving each rule in turn. If it succeeds with one then it stops; otherwise, it pretends not to have used that rule and tries the next. This process is called backtracking.

Beginning in Prolog

From a terminal we can start SWI-Prolog using the command: swipl
When you start Prolog you should get a prompt like:
```
| ?-
```
To exit Prolog type Ctrl-d or type:
```
| ?- halt.
```
Notice the line above ends with a period. Prolog won't execute anything unless the line ends with a period. A carriage return without a period will just cause Prolog to go to the next line and receive more input. The period will cause Prolog to try to execute everything up to the period.
Usually, you will use an editor to write your Prolog code in a file say, filename.pl (some Prolog systems use the extension .pl, others use .P), and then load the file into Prolog by typing:
```
| ?-[filename].
```
You could also use | ?- consult(filename). It is sometimes useful when one is editing a program to reload it into Prolog and erase the instances of the clauses stored in Prolog's memory by earlier versions of the program. To do this use | ?-reconsult(filename).
If you use "filename.pl" in double quotes for the name of the file also works and let's you give the file extension.

Example Program

Here is a short Prolog program:

/* Jane's connections */
/* Comments in Prolog are just like in C or C++ */
bird(ostrich).
bird(penguin).
bird(seagull).
bird(eagle).
flies(W) :- bird(W),
            W \= ostrich,
            W \= penguin.
loves(jane,X) :- flies(X).
loves(penguin, jane).
loves(aadvark, jane).

Basic Syntax - Facts

A Prolog program such as the above can be viewed as a database of information.
Statements in Prolog come in two types: facts and rules.
We will sometimes say clause or rule to refer to both facts and rules.
A Prolog fact just asserts something is true of a predicate. For instance, bird(penguin). above is a fact representing the information that the bird predicate holds for the value penguin.
bird is a 1-ary predicate (so bird would sometimes be written as bird/1 to distinguish it from predicates of the same name but different arity). This just means it has only one slot to stick in values.
In Prolog predicates are allowed to come in any arity; however, 0-ary predicates are written as name, rather than name().
The 0-ary predicates true and fail are built-in and have the same meaning as #t and #f in Scheme.

Basic Syntax - Rules

A rule is a statement which relates the truth of a predicate to whether a bunch of goals can be satisfied.
For instance, the predicate flies is true of any value of the variable X for which simultaneously bird(X) holds, X is not an ostrich, and X is not a penguin.
In Prolog, symbols which begin with upper case letters are always assumed to be variables. That's how we know X is a variable.
The symbols ostrich, penguin, etc. above are called atoms. These can begin with upper case letters if put in quotes. i.e., "Ostrich". In general, a rule has the form
```
h :- g1, ..., gn.
```
Here h, g1, ...,gn are all predicates. We are only allowed one predicate before the :-, in this case, h, and it is called the head of the rule.
The remaining predicates are called the tail of the rule and individual predicates in the tail are called goals.
Notice for the rule with head flies(W) above we wrote each goal in the tail on a separate line. This is a standard convention when writing rules in Prolog with a large number of goals in the tail of a rule.

Querying a Program

Let's consider now how we could use the above program...
First, assume we have loaded this program into Prolog. We can then type at the prompt a list of goals that we want to see is true of our program. Such a list of goals is called a query. In the simplest case, we could type
```
| ?-bird(seagull).
```
and hit return. Prolog would respond yes. and give us a new prompt.
What Prolog did was search down through our table trying to match the goal bird(seagull) with a fact or with a head of a rule.
It gets to the third non-comment line of our program finds that bird(seagull) is a fact and therefore true and so return yes.
Suppose we had typed
```
| ?-bird(duck).
```
and hit return.
In this case Prolog, would go through its database of rules and facts (i.e., essentially, our program) and not be able to find any fact or head of a rule which matches it. So Prolog would respond no. and give us a new prompt. Thus, things that Prolog does not know about are deemed false. This is called the closed world assumption.

Queries With a Variable

We now consider two slightly more complicated queries. First,
```
| ?-bird(X), loves(X,jane).
```
This expresses are there any birds which love jane?
To respond to this query Prolog first tries to find an X such that bird(X). It goes through our program from the top down and the first match it finds is X=ostrich. It puts a pointer on the fact it just used.
Next Prolog tries to satisfy loves(ostrich,jane). There are no facts or heads of rules which match this predicate. So this goal fails and we do what is called a backtrack.
We try to resatisfy the goal bird(X) with a different value of X. So we continue searching our table for rules or facts which match bird(X) starting one beyond where our pointer bird(ostrich).
We then find bird(penguin) matches bird(X) where X=penguin. We now try to satisfy loves(penguin,jane). This matches with the last fact in our program, and so Prolog returns:
```
X=penguin
```
If we were to hit return at this point Prolog would print yes. and give a prompt.
If instead we typed ';' (which in Prolog means logical OR just as `,' means logical AND) and return, Prolog would try to find another solution to our query.

Streams and Monads - Prolog

Outline