XVed*font: 7x12  # The default size - rather small for some.
XVed*font: 9x15  # A bigger size, which you may like better.

You can also change the font of a particular window by doing

<enter> window font font.

The POP2000 Language

Typographic conventions used in these Lectures

All expressions and other constructs of the POP2000 language which occur in these lectures are set in a typewriter font, An example of typewriter font is: Definition pi = 3.14159 End; .

Typewriter fonts are characterised by being fixed-width (every letter occupies the same amount of space on the page). In the HTML browser which has been constructed to let you view these lectures from within UMASS POP2000, POP2000 expressions will appear in red, since the VED editor always uses a single fixed-width font and provides no means of distinguishing text by using a different font, only by making variants on a given font.

Where it is important to make an expression of the language stand out, it will be placed indented as a line or lines of text separated from the English commentary. For example:

    Definition pi = 3.14159 End;

Grammatical constructs are specified using a bold version of the typewriter font. For example, we specify one form of the POP2000 define statement by

    Definition  variable = expression End;

Here, because variable is in a bold font it means that you can write any POP2000 variable in place of it; likewise because expression is in a bold font it means that you can write any POP2000 expression in place of it. So, the previous statement:

    Definition pi =  3.14159 End;

    Definition  variable =   expression End;

Simple values in POP2000

POP2000 operates on the usual simple data-objects, that is to say data-objects that can best be thought of as having no internal structure.

integers: These are of arbitrary precision that is they are only limited in size by the total amount of memory you have!

rationals: POP2000 can and will compute with fractions. If you divide one integer by another you will get a rational. You should usually avoid rational computations, unless you are doing symbolic algebra!

reals: These are represented by floating point numbers.

booleans: These are the values of the constants false and true.

23   is an integer
3.4  is a real
3/4  is a rational

Variables in POP2000

A POP2000 variable is either

• a sequence of letters (a..z A..Z) or digits (0..9) or an underscore _ beginning with a letter.
• Or is is one of a restricted set of sign sequences (+ - * / ...)

For example the following are variables:

        x y x_23 +  ->

Warning - POP2000 gives some variables initial values, for example +, *, / . It is not a good idea to use these variables for your own purposes (except as variables local to a function).

Definition creates a new variable, gives it a value

Variables usually have values. We say that a variable is bound to a value when it is associated with the value. POP2000 has a statement which creates a new variable and binds it to the value of an expression

    Definition  variable =   expression End;

For example:

    Definition pi=  3.14159 End;

binds the variable pi to have the value 3.14159

Expressions in POP2000

• A variable is a primitive expression.
• A constant is a primitive expression.
• If expr₁ and expr₂ are expressions, then so are the combinations :

      expr expr1 expr2 ...exprn
      expr1 +  expr2
      expr1 -  expr2
      expr1 *  expr2
      expr1 /  expr2
  

  Every combination is understood to be a function applied to an argument or arguments [see note on the Lambda calculus]. In the case of the form

      expr expr1 expr2 ...exprn
  

  The expression expr is the function while expr₁ expr₂ ...expr_n are the arguments.

  In the case of the forms:

      expr1 +  expr2
      expr1 -  expr2
      expr1 *  expr2
      expr1 /  expr2
  

  the operators + - * / are the functions, each with two arguments expr₁, expr₂.
• If expr is an expression then so is

      (expr1)
  

  This parenthesised form is used to resolve ambiguity. For example 2*3+4 could mean (2*3)+4 or 2*(3+4). In the absence of parentheses, an operator precedence and associativity rule is used by the POP2000 compiler. This treats multiplication as more binding than addition, so that 2*3+4 is interpreted as 2*3+4. All operators are less binding than direct function application, so that sin x + y is interpreted as (sin x) + y, that is apply the function sin to the variable x and then add the result to the variable y. The arithmetical operators are left associated, so that, for example, x-y-z means (x-y)-z and not x - (y-z). This, of course, is consistent with normal mathematical usage.

     3+4

is an expression, whose function is '+' and whose arguments are 3 and 4.

When POP2000 evaluates an expression of this form, it evaluates the function and arguments, and then applies the function to the arguments. Evaluating the above expression we get

7

5 - 4

means "the result of subtracting 4 from 5".

A more complicated example is:

3+(4*5)

Here we evaluate 4*5 to get 20, and then add 3 to get 23.

So what are functions in POP2000?

Well, actually functions are pieces of machine code (in effect subroutines for those who have taken CMPSCI 201). So the value of the variable '+' is a piece of code for doing addition.

[Note you can actually redefine POP2000 standard functions. This is NOT recommended for novices, for you may lose important capabilities]

Making your very own function

A POP2000 function is specified by the syntax

    \  formals.  body

here formals a sequence of variables, and body is an expression. The entire construct is itself an expression. The particular syntax has been chosen to correspond as closely as possible with the Lambda Calculus notation of Church, who used the Greek letter "lambda", which, alas, is not available in the standard fonts used for computer programs.

Note that this is not an application of the function lambda, but is what is called a "special form" in POP2000.

For example

(\x. x*x)

is the function which squares its argument. So

( (\x. x*x) 3)

evaluates to 9.

The rule for evaluation of a lambda-function applied to arguments is to (a) evaluate all the arguments, and (b) strip off the 'lambda' and substitute the values of each argument for the corresponding formals, (c) evaluate the body of the lambda with the values substituted.

   ( (\x.  x*x) 3+4)

Evaluate the argument

( (\x. x*x) 7)

Strip and substitute for corresponding formals (x=7) :

7*7

Evaluate body

49

This may seem a funny way of defining functions - in Pascal we would give the corresponding function a name, like "square". In POP2000, this is easily done

Definition square = \x. x*x End;

POP2000 responds:

<Compiled function: square>

and now we can use it

    square 4;

POP2000 responds:

    16

An example of a lambda expression with more than one argument is

    \ x y. x + 2*y

And an example of its use is:

    (\ x y. x + 2*y) (4 + 3) 5;

Evaluate the arguments

    (\ x y. x + 2*y) 7 5)

Strip and substitute, x=7, y=5:

    7 + 2*5

and evaluate

    7+10

     17

The Debugger

This is accessed by hitting the "Debugger" button on the POP2000 Control Panel. It is operated by a panel which contains the following buttons:

Generate Debug Code:

This is normally true, so that POP2000 generates code for the debugger by default. Turn it off to create smaller, faster programs.

Stop at All Breakpoints:

This is normally false. When set true, POP2000 will stop after it evaluates every compound expression such as (+ x 2). It will print out "frames" for the top n functions you are currently executing, where n is set by the "Number of Frames" slider.

Number of Frames:

This slider determines how many function-frames you will see.

Go To Next Breakpoint:

Execution continues until the next (automatically generated) breakpoint. Breakpoints occur after an expression has been evaluated.

Skip Current Function:

The execution of the current function will be completed without stopping at any breakpoints.

Help:

Prints out help information about the debugger.

The function load loads a file of POP2000 code.

The function application (load `file`) will load any file as POP2000 program.

A comparision with the Scheme Language

    (+ 3 (* 4 5))

is a Scheme expression equivalent to 3+4*5 in POP2000. This syntax stresses the conceptual uniformity of functional languages, but at the price of making code have a form that is unfamiliar to users.

A note on the Lambda Calculus