Abstract Syntax

1
Abstract Syntax
2
Language of l-expressions

• ltexpgt ltidentifiergt
• (lambda ( ltidentifiergt )ltexpgt)
• (ltexpgt ltexpgt)
• E.g., concrete syntax Scheme S-expressions
• ( lambda (x) ( f ( f x ) ) )

3
Abstract Syntax (vs Concrete Syntax)
lambda-exp
id
body
app-exp
rand
rator
var-exp
app-exp
rand
rator
id
var-exp
var-exp
id
id
4
Overview
Parse-expression
Concrete Syntax
Abstract Syntax
Unparse-expression
Interpreter
Results
5
Representing Abstract Syntax with Records

• (define-datatype expression expression?
• (var-exp
• (id symbol?))
• (lambda-exp
• (id symbol?)
• (body expression?))
• (app-exp
• (rator expression?)
• (rand expression?)))

6
Parse Concrete to Abstract Syntax

• (define parse-expression
• (lambda (datum)
• (cond
• ((symbol? datum) (var-exp datum))
• ((pair? datum)
• (if (eqv? (car datum) 'lambda)
• (lambda-exp (caadr datum)
• (parse-expression (caddr datum)))
• (app-exp
• (parse-expression (car datum))
• (parse-expression (cadr datum)))
• )
• )
• (else (eoplerror 'parse-expression
• "Invalid concrete syntax s"
  datum))
• )))

7
Example (Petite Scheme)

• gt (current-directory
• I\\tkprasad\\cs784\\EOPL-CODE\\interps")
• gt (load "chez-init.scm")
• gt (load "2-2-2.scm")
• gt (parse-expression 'x)
• (var-exp x)
• gt (parse-expression '(lambda (x) (f x)))
• (lambda-exp x (app-exp (var-exp f) (var-exp x)))
• gt (parse-expression 45)
• Error reported by parse-expression
• Invalid concrete syntax 45
• debuggte
• gt(unparse-expression
• '(lambda-exp x (app-exp
  
• (var-exp f) (var-exp x))))
• (lambda (x) (f x))

8
Example (PLT Scheme)
9
Unparse Abstract to Concrete Syntax

• (define unparse-expression
• (lambda (exp)
• (cases expression exp
• (var-exp (id) id)
• (lambda-exp (id body)
• (list 'lambda (list id)
• (unparse-expression body)) )
• (app-exp (rator rand)
• (list (unparse-expression rator)
• (unparse-expression rand)) )
• )))

10
Role of Induction and Recursion

• Define data structures (infinite values) by
  induction.
• Seed elements.
• Closure operations.
• Define functions (operations) by recursion.
• Boundary/Basis case.
• Composite/Recursive case.
• Prove properties using structural induction.
• Basis case.
• Inductive step.

11
Representing Environment
12
Alternative 1

• (define empty-env
• (lambda () '()))
• (define extend-env
• (lambda (syms vals env)
• (cons (list syms vals) env) ))
• (define apply-env
• (lambda (env sym)
• (if (null? env)
• (eoplerror 'apply-env "No binding for s"
  sym)
• (let ((syms (car (car env)))
• (vals (cadr (car env)))
• (env (cdr env)))
• (let ((pos (rib-find-position sym syms)))
• (if (number? pos)
• (list-ref vals pos)
• (apply-env env sym)))))
• ))

13
Alternative 2

• (define empty-env
• (lambda ()
• (lambda (sym)
• (eoplerror 'apply-env "No binding for s"
  sym)) )
• )
• (define extend-env
• (lambda (syms vals env)
• (lambda (sym)
• (let ((pos (list-find-position sym syms)))
• (if (number? pos)
• (list-ref vals pos)
• (apply-env env sym)))) )
• )
• (define apply-env
• (lambda (env sym)
• (env sym) )
• )

14
Alternative 3

• (define-datatype environment environment?
• (empty-env-record)
• (extended-env-record
• (syms (list-of symbol?))
• (vals (list-of scheme-value?))
• (env environment?)))
• (define scheme-value? (lambda (v) t))

15
(contd)

• (define empty-env
• (lambda ()
• (empty-env-record) ))
• (define extend-env
• (lambda (syms vals env)
• (extended-env-record syms vals env)))
• (define apply-env
• (lambda (env sym)
• (cases environment env
• (empty-env-record ()
• (eoplerror 'apply-env "No binding for
  s" sym))
• (extended-env-record (syms vals env)
• (let ((pos (list-find-position sym
  syms)))
• (if (number? pos)
• (list-ref vals pos)
• (apply-env env sym)))) )
• ))

16
Queue

• (define reset (lambda (q) (vector-ref q 0)))
• (define empty? (lambda (q) (vector-ref q 1)))
• (define enqueue (lambda (q) (vector-ref q 2)))
• (define dequeue (lambda (q) (vector-ref q 3)))
• (define Q (create-queue))
• ((enqueue Q) 55)
• ((empty? Q))
• ((dequeue Q))
• ((empty? Q))
• ((reset Q))
• ((dequeue Q))

17

• (define create-queue
• (lambda ()
• (let ((q-in '()) (q-out '()))
• (letrec
• ((reset-queue
• (lambda ()
• (set! q-in '()) (set! q-out '())) )
• (empty-queue?
• (lambda ()
• (and (null? q-in) (null? q-out))) )
• (enqueue
• (lambda (x)
• (set! q-in (cons x q-in))) )
• (dequeue
• (lambda ()
• (if (empty-queue?)
• (eoplerror 'dequeue "Not on an
  empty queue")
• (begin
• (if (null? q-out)