Com S 342 meeting -*- Outline -*-

* Statements (3.9)

** expression vs. statement-oriented

   Q: What are basic semantic actions of the languages we've seen?
      binding, calls, assignment

------------------------------------------
 EXPRESSION VS. STATEMENT-ORIENTED (3.9)

def: a language is *expression-oriented*
     if the basic semantic actions
     with side effects have values
     and can be used in expressions.

Examples: Scheme, 


def: a language is *statement-oriented*
     if the basic semantic actions with
     side effects do not have values
     and cannnot be used in expressions.

Examples: Pascal,

------------------------------------------
        ... Lisp, Haskell, ML, Java, C++, C, Algol 68

        ..., Ada, Eiffel, Basic, Fortran

        Q: What about Perl? C#? Python? Assembler?

        Q:  What kind of language is the defined language that we've
        seen so far?

** syntax

   interpreter in ch3-9.scm

------------------------------------------
	   PROGRAMS AND STATEMENTS

Example program:

var x, y; { x = 3; y = 4; print(+(x, y)) }

Examples of statements:

  x = E

  print(E)

  { x1 = E1; x2 = E2 }

  if E0
  { x1 = E1 }
  { x2 = E2 }

  while x do x = sub1(x)

  var x; x = 3

------------------------------------------

    Show grammar in the interpreter, plus ASTs

    (program
      (statement)
      a-program)

    (statement
      (identifier "=" expression)
      assign-statement)
    (statement
      ("print" "(" expression ")")
      print-statement)
    (statement
      ("{" (separated-list statement ";") "}")
      compound-statement)
    (statement
      ("if" expression statement statement)
      if-statement)
    (statement
      ("while" expression "do" statement)
      while-statement)
    (statement
      ("var" (separated-list identifier ",") ";" statement)
      block-statement)

(define-datatype
  program
  program?
  (a-program (stmt statement?)))

(define-datatype
  statement
  statement?
  (assign-statement
   (id symbol?)
   (exp expression?))
  (print-statement
   (exp expression?))
  (compound-statement
   (stmts (list-of statement?)))
  (if-statement
   (exp expression?)
   (true-stmt statement?)
   (false-stmt statement?))
  (while-statement
   (exp expression?)
   (stmt statement?))
  (block-statement
   (ids (list-of symbol?))
   (body statement?)))

** semantics

*** domains

   Q: do we need to change any of the domains?
      no

   Q: Do we still need to distinguish denoted from expressed values?
      yes, to support assignment

*** values?

    Q: Do statements have values?
       no, that's the point    

    Q: So if a statement has no value,
       how do we get information out of the program?
       by printing

*** interpreter

    Q: How should the interpreter be organized?  What procedures do we need?
         execute-program, execute-statement, eval-expression

    (see ch3-9.scm for details)

    write or show the following

(deftype execute-program (-> (program) void))
(define execute-program 
  (lambda (pgm)
    (cases program pgm
      (a-program (statement)
        (execute-statement statement (init-env))))))

(deftype execute-statement (-> (statement environment) void))
(define execute-statement
  (lambda (stmt env)
    (cases statement stmt
      (assign-statement (id exp)
        (setref!
          (apply-env-ref env id)
          (eval-expression exp env)))
      (print-statement (exp)
        (write (expressed->printable (eval-expression exp env)))
        (newline))
      (compound-statement (stmts)
        (for-each
          (lambda (stmt)
            (execute-statement stmt env))
          stmts))
      (if-statement (exp true-stmt false-stmt)
        (if (true-value? (eval-expression exp env))
          (execute-statement true-stmt env)
          (execute-statement false-stmt env)))
      (while-statement (exp stmt)
        (let loop ()
          (if (true-value? (eval-expression exp env))
            (begin
              (execute-statement stmt env)
              (loop)))))
      (block-statement (ids stmt)
        (execute-statement stmt
          (extend-env ids (map (lambda (id) (number->expressed 0)) ids) env)))
      )))

** variations

*** assert

    Q: Why can't users implement assert themselves?
       can't give good error messages easily:
                values vs. expressions,
                line numbers
    
    permits testing

    (statement
      ("assert" expression)
      assert-statement)


*** loops

    add syntax and semantics for do-until loops

    (statement
      ("do" statement "until" "(" expression ")")
      do-until-statement)

    for loops is another good exercise

*** expression changes
**** after-then expressions (like begin)

    change syntax and eval-expression for that

    (expression
      ("after" (separated-list statement ";") "value" expression)
      after-value-exp)

**** bodies can be like implicit begin-expressions

    change for that in let, letrec and procedures

**** simplify expressions

    Q: Are there any expression we can omit now?