CSC 270 - Survey of Programming Languages: Scheme (Racket)

Syntax and Semantics

Programming languages, like spoken languages, have a vocabulary and a grammar.
The vocabulary is the collection of "words" from which we compose "sentences."
- A sentence in a programming language is an expression or a program whose form is dictated by the grammar (or rules) of the programming language.
- Syntax is the term that we commonly use for the grammar.
- Semantics refers to the meaning that a sentence has.
Understanding the syntax and semantics of a programming language is important if we wish to know if a sentence is meaningful.

The Scheme Vocabulary

The basic vocabulary of Scheme consists of five different categories of words:

Beginner vocabulary of Scheme:

variable -->	< var > = 	x | area-of-disk | perimeter | ....
constant -->	< con > =	true | false
				'a | 'doll | 'sum | ...
				1 | -1 | 3/5 | 1.22 | ...
primitive -->	< prm > = + | - | ...

We also need the keyword which:
- Serve as punctuation in our expression
- Cannot be used as a variable.

The Scheme Grammar

Beginner Grammar of Scheme

definition -->  < def > = (define (< var > < var > ... < var >) < exp >))

expression --> < exp > =	 < var >
			| < con >
			|( < prm >  < exp > ... < exp > )
			|( < var > <exp > ... < exp > )	|(cond ( < exp > < exp < ) ... ( < exp > < exp > ))
			|(cond ( < exp > < exp > ) .. else < exp > ))

Expression examples

	Symbol	---> 'all 
	variable --->	x
	program application ---> (x x)

The following are not expressions (even if they look like expressions):

(f define)	- uses define like a variable
(cond x)	- cond without a pair of expressions
( )		- nothing in the parentheses

Grammatical Terminology

The components of compound statements have names of their own:

The second component of a program definition (after the keyword define) is the header ( a sequence of variables).
The third component of a program definition is the body, which is the expression component of a definition.

Some people think of a program definition in similar terms to a function definition, with a left side (the header) and a (the body) right side.

We often call the header's first component the function and the remaining of the components in the header the arguments.

A cond-expression consists of cond-lines and cond-clauses.

Cond-lines consists of questions (conditions) and answers (the value if the condition is true).

The Meaning of Scheme

Scheme programs consists of two types of items:
- A series of definitions (for programs and structure types) in the definitions window
- A series of interactions (where you use the definitions and invoke those programs) in the interactions windows
Values are either booleans, symbols or numbers, any of which can be calculated using expressions and the programs that we wrote.

Evaluating Scheme Values

Expressions in Scheme are evaluated in pre-order: first the operator (or program) name and then the operands (or arguments):
```
(+ 1 1)= 2
(- 2 1) = 1
(not true) = false
(eq? 'a 'b) = false 
(eq? 'a 'a) = true 
```

When we type:

(define (f x ...) 
  exp) 
and f, x, ... are variables and exp some (legal) expression. Then an application 
of a program is governed by the law:
(f  v ...) = exp 
where v ... is a sequence of values that is as long as the sequence 
x ... in the definition of f.

Example

define (poly x y) 
  (+ (expt 2 x) y))

becomes (poly 3 5)  = (+ (expt 2 3) 5))  = 2 3 + 5 = 8 + 5 = 13

Evaluating cond expressions

cond_false:

     when the first condition is false: 
       (cond 
         [false ...] 
         [exp1 exp2] 
         ...) 
       = (cond
           ; The first line disappeared. 
           [exp1 exp2] 
           ...)

then the first cond-line disappears;

cond_true:

     when the first condition is true: 
       (cond 
         [true exp] 
         ...) 
       = exp

the entire cond-expressions is replaced by the first answer;

cond_else:

     when the only line left is the else-line: 

       (cond 
         [else exp]) 
       = exp

the cond-expressions is replaced by the answer in the else-clause.

Evaluating cond expressions: an example

Consider the following evaluation:

(cond
  [false 1] 
  [true (+ 1 1)] 
  [else 3])

= (cond 
    [true (+ 1 1)] 
    [else 3]) 

= (+ 1 1)

= 2

Errors

There are three basic types of errors that appear in programs:
Syntax errors occur when syntax is not used correctly:
```
(define f (x) (x * x))
```
contains two separate syntax errors (where are they?)
Runtime errors occurs when the program tries to do something that the computer cannot do (e.g., division by 0)
Logic errors occur when a part of a program does something other than what the program expects.

Runtime Errors

The evaluation of

  (+ (* 20 2) (/ 1 (- 10 10)))

proceeds as follows:

 	=  (+ (* 20 2) (/ 1 (- 10 10)))
	= (+ 40 (/ 1 0)) 
= /: divide by zero

This is a message telling the programmer about the run-time error

In reality , we want our programs to catch potential runtime errors instead of letting them happen:

; my-divide : number -> number
(define (my-divide n) 
  (cond 
    [(= n 0) 'inf] 
    [else (/ 1 n)]))

Variable Definitions

In general, a variable definition is:
```
(define < var > < exp > )
```

Examples

(define Radius 5)
(define Area 
	(* (* Radius Radius) pi))

Structure Definitions

The syntax for a structure definition is:

(define-struct < var > ( < var > ... < var > )

The names in a define-struct definition must be chosen as if they were variables or program names, though none of them are variables or program names.
Here is a simple example:
```
  (define-struct point (x y z)) . 
```
Since point, x, y, and z are variables and the parentheses are placed properly, it is a proper definition of a structure. In contrast,
```
  (define-struct (point x y z))
```
and
```
  (define-struct point x y z)
```
are improper definitions because define-struct is not followed by a single variable name and a sequence of variables in parentheses.

[Back to the Notes Index]