CS 334
Programming Languages
Spring 2000

Lecture 5

Imperative features - references

Ref is a built-in constructor that creates references (i.e. addresses)

Example 

    - val p = ref 17   
    val p = ref 17 : int ref
Can get at value of reference by writing !p 
    - !p + 3;   
    val 20 : int
Also have assignment operator ":=" 
    - p := !p + 1;   
    () : unit   
    - !p;   
    val 18 : int
Other imperative commands:

(E1; E2; ...; En) - evaluate all expressions (for their side-effects), returning value of En

while E1 do E2 - evaluates E2 repeatedly until E1 is false (result of while always has type unit)

Writing Pascal programs in ML: 

    fun decrement(counter : int ref) = counter := !counter - 1;
   
    fun fact(n) = let 
                     val counter = ref n; 
                     val total = ref 1;   
                  in 
                     while !counter > 1 do   
                        (total := !total * !counter ;   
                         decrement counter);   
                     !total   
                  end;
There are restrictions on the types of references - e.g., can't have references to polymorphic objects (e.g., nil or polymorphic fcns). See discussion of non-expansive expressions in section 5.3.1. Essentially, only function definitions (or tuples of them) can have polymorphic type. Results of function applications or values of references can never be polymorphic.

Implementation issues

Efficiency:

Functional languages have tended not to run as fast as imperative: Why?

Use lists instead of arrays - linear time rather than constant to access elements

Passing around fcns can be expensive, local vbles must be retained for later execution. Therefore must allocate from heap rather than stack.

Recursion typically uses lot more space than iterative algorithms
New compilers detect "tail recursion" and transform to iteration.

Lack of destructive updating. If structure is changed, may have to make an entirely new copy (though minimize through sharing).
Results in generating lot of garbage so need garbage collection to go on in background.

"Listful style" - easy to write inefficient programs that pass lists around when single element would be sufficient (though optimization may reduce).

If lazy evaluation need to check whether parameter has been evaluated - can be quite expensive to support.
Need efficient method to do call by name - carry around instructions on how to evaluate parameter - don't evaluate until necessary.

 Program run with current implementation of Standard ML of New Jersey is estimated to run only 2 to 5 times slower than equivalent C program. (Uses continuations.)

Lazy would be slower.

What would happen if we designed an alternative architecture based on functional programming languages?

Concurrency

One of driving forces behind development of functional languages.

Because values cannot be updated, result not dependent on order of evaluation.

Therefore don't need explicit synchronization constructs.

If in distributed environment can make copies w/ no danger of copies becoming inconsistent.

If evaluate f(g(x),h(x)) can evaluate g(x) and h(x) simultaneously (w/ eager evaluation).

Two sorts of parallel architectures: data-driven and demand-driven.

Elts of these are being integrated into parallel computer designs.

Idea is programmer need not put parallel constructs into program and same program will run on single processor and multi-processor architectures.

Not quite there yet. Current efforts require hints from programmer to allocate parts of computation to different processors.

Summary

Functional programming requires alternative way of looking at algorithms.

Referential transparency supports reasoning about programs and execution on highly parallel architectures.

While lose assignment and control/sequencing commands, gain power to write own higher-order control structures (like listify, while, etc.)

Some cost in efficiency, but gains in programmer productivity since fewer details to worry about (higher-level language) and easier to reason about.

Languages like ML, Miranda, Haskell, Hope, etc. support implicit polymorphism resulting in greater reuse of code.

ML features not discussed:

ML currently being used to produce large systems. Language of choice in programming language research and implementation at CMU, Princeton, Williams, etc.

Computational biology: Human genome project at U. Pennsylvania

Lots of research into extensions. ML 2000 report.

Addition of object-oriented features?

Major elements of programming languages: Syntax, Semantics, Pragmatics

Syntax:

Readable, writable, easy to translate, unambiguous, ...

Formal Grammars:

Backus & Naur, Chomsky

First used in ALGOL 60 Report - formal description

Generative description of language.

Language is set of strings. (E.g. all legal ALGOL 60 programs)

Example

    <expression> ::=  <term> | <expression> <addop> <term>   
    <term>       ::=  <factor> | <term> <multop> <factor>   
    <factor>     ::=  <identifier> | <literal> | (<expression>)   
    <identifier> ::=  a | b | c | d   
    <literal>    ::=  <digit> | <digit> <literal>   
    <digit>      ::=  0 | 1 | 2 | ... | 9   
    <addop>      ::=  + | - | or   
    <multop>     ::=  * | / | div | mod | and

Generates: a + b * c + b - parse tree

Grammar gives precedence and which direction op's associate

Extended BNF handy:

item enclosed in square brackets is optional 

    <conditional> ::= if <expression> then <statement> [ else <statement> ]
item enclosed in curly brackets means zero or more occurrences 
    <literal>::= <digit> { <digit> }

Syntax diagrams - alternative to BNF,
Syntax diagrams are never recursive, use "loops" instead.

Problems with Ambiguity

Suppose given grammar:
	<statement> ::= <unconditional> | <conditional>

	<unconditional> ::= <assignment> | <for loop> | 

                              "{" { <statement> } "}"

	<conditional> ::= if (<expression>) <statement> |

                              if (<expression>)  <statement> else <statement>
How do you parse: 
  if (exp1) 
    if (exp2) 
       stat1;
   else 
      stat2;

Could be 

  1.   if (exp1) 
  {
    if (exp2) 
      stat1; 
    else 
      stat2;
  }
    or

  2.   if (exp1) 
  {
    if (exp2) 
      stat1;
  } 
  else 
    stat2;

I.e. What happens if exp1 is true and exp2 is false?

Ambiguous

Pascal, C, and Java rule: else attached to nearest then

To get second form, include "{,}".

MODULA-2 and ALGOL 68 require "end" to terminate conditional:

  1. if exp1 then if exp2 then stat1 else stat2 end end

  2. if exp1 then if exp2 then stat1 end else stat2 end

(Algol 68 actually uses fi instead of end)

Why isn't it a problem in ML?

Ambiguity in general is undecidable

Chomsky developed mathematical theory of programming languages:

BNF (or syntax diagrams) = context-free can be recognized by push-down automata

Not all aspects of programming language syntax are context-free.

Formal description of syntax allows:
  1. programmer to generate syntactically correct programs

  2. parser to recognize syntactically correct programs

Parser-generators (also lexical analysis)- LEX, YACC (available in C and many other languages, e.g., ML), Cornell Program Synthesizer Generator

Back to:

  • CS 334 home page
  • Kim Bruce's home page
  • CS Department home page
    • kim@cs.williams.edu