imperative programming chapter 6 n.
Skip this Video
Loading SlideShow in 5 Seconds..
Imperative Programming Chapter 6 PowerPoint Presentation
Download Presentation
Imperative Programming Chapter 6

Loading in 2 Seconds...

play fullscreen
1 / 41

Imperative Programming Chapter 6 - PowerPoint PPT Presentation

  • Uploaded on

Imperative Programming Chapter 6. Local State. Real world software like: Banks Course grading system Are state systems. i.e. they change along time : for example: current balance and current grade. What is Imperative Programming?.

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about 'Imperative Programming Chapter 6' - jatin

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
local state
Local State

Real world software like:

  • Banks
  • Course grading system

Are state systems. i.e. they change along time: for example: current balance and current grade.

what is imperative programming
What is Imperative Programming?

“In computer science, imperative programming is a programming paradigm that describes computation in terms of statements that change a program state (Wikipedia)”

Not better the FP! Just different

the imperative programming model
The Imperative Programming Model
  • Imperative programming is characterized by:
    • Understanding variables as storage places (addresses)
    • Mutation operations
    • Operational semantics
mutation in racket
Mutation in Racket
  • Variable assignment: set!
  • Box type
  • Mutable data types (we will not use Racket’s built in, but create our own)
variable assignment
Variable Assignment

Modification of value of a defined variable

> (define my-list (list 1 2 3))

> my-list

’(1 2 3)

> (set! my-list (list 1 2 4))

> my-list

’(1 2 4)

> (set! a 4)

. . set!: assignment disallowed;

cannot set variable before its definition

the box type
The Box Type

Values are references (or pointers) for values that can be changed during computation.

  • Constructor: box
  • Selector: unbox
  • Mutator: set-box!
box examples 1
Box Examples (1)

(define a (box 7))

> (* 6 (unbox a))


> a


> (set-box! a (+ (unbox a) 3))

> (* 6 (unbox a))


box example 2
Box Example (2):

> (definecirc-l (list (box 1) (box 2) (box 3)))

> circ-l

'(#&1 #&2 #&3)

> (unbox (car circ-l))


> (unbox (cadr circ-l))


> (unbox (caddr circ-l))


> (set-box! (caddr circ-l) circ-l)

> circ-l

#0='(#&1 #&2 #&#0#)

> (unbox (caddr circ-l))

#0='(#&1 #&2 #&#0#)

> (eq? circ-l (unbox (caddr circ-l)))


the box type1
The Box type

The Box type: Type constructor: BOX(T )

procedure type name

Value constructor: box [T → BOX(T )]

Selector: unbox [BOX(T ) → T]

Mutator: set-box! [BOX(T ) → Void]

Identifier: box? [T → Boolean]

Value equality: equal? [T1 ∗ T2 → Boolean]

Identity equality: eq? [T1 ∗ T2 → Boolean]

side effects
Side Effects
  • Side effects are "non-functional"There existence does not agree with the FP paradigm
  • set! and set-box! are side effects procedure
  • We have already seen two kinds of side effect procedures: define and the display procedure.
  • Side effects procedures are applied for the sake of their side effects, and not for their returned value, void
  • In imperative programming, it is meaningful to use sequences of expressions
state based modeling
State based modeling
  • Defining objects with a modifiable private fields (local variables), and a set of accessors (selectors and mutators) that have controlled access to the object's private fields.
  • All objects may have access to shared (static) variables.
bank account withdrawal example
Bank Account Withdrawal Example

;; Signature: withdraw(amount)

;; Purpose: Withdraw ’amount’ from a private ’balance’.

;; Type: [Number -> Number]

;; Post-condition: result = if balance@pre >= amount

;; then balance@pre - amount

;; else balance

(define withdraw

(let ((balance 100))

(lambda (amount)

(if (>= balance amount)

(begin (set!


(- balance amount))


(begin (display "Insufficient funds")




> withdraw


> (withdraw 25)


> (withdraw 25)


> (withdraw 60)

Insufficient funds


> (withdraw 15)


(define withdraw

(let ((balance 100))

(lambda (amount)

(if (>= balance amount)

(begin (set!






(begin (display

"Insufficient funds")



full bank account example
Full Bank Account Example

;; Signature: make-account(balance)

;; Type: [Number -> [Symbol -> [Number -> Number]]]

(define make-account

(λ (balance)

(let ((balance balance))


((get-balance (λ (amount) balance))

(set-balance! (λ (amount) (set! balance amount)))

(withdraw (λ (amount)

(if (>= balance amount)

(begin (set-balance! (- balance amount))


(begin (display "Insufficient funds")



(deposit (λ (amount)

(set-balance! (+ balance amount))


(dispatch (λ (m)

(cond ((eq? m ’balance) get-balance)

((eq? m ’withdraw) withdraw)

((eq? m ’deposit) deposit)

(else (error


"Unknown request: ~s" m))))))



> (define acc (make-account 100))

> acc


> ((acc ’withdraw) 50)


> ((acc ’withdraw) 60)

Insufficient funds


> ((acc ’withdraw) 30)


> ((acc ’withdraw) 60)

Insufficient funds


> (define acc2 (make-account 100))

> ((acc2 ’withdraw) 30)


> ((acc ’withdraw) 30)

Insufficient funds


mutable adts pair
Mutable ADTs : Pair

; Type: [T1*T2 -> [Symbol -> Procedure]]

; The dispatch procedure returns procedures with different arities

; (Currying could help here).

(define mpair

(λ (x y)

(letrec ((get-x (λ () x))

(get-y (λ () y))

(set-x! (λ (v)

(set! x v)))

(set-y! (λ (v)

(set! y v)))


(lambda (m)

(cond ((eq? m 'car) get-x)

((eq? m 'cdr) get-y)

((eq? m 'set-car!) set-x!)

((eq? m 'set-cdr!) set-y!)

(else (error


"Undefined operation ~s"



mutable adts pair1
Mutable ADTs : Pair

(define mutable-car

(λ (z)

((z ’car))))

(define mutable-cdr

(λ (z)

((z ’cdr))))

(define set-car!

(lambda (z new-value)

((z ’set-car!) new-value)))

(define set-cdr!

(lambda (z new-value)

((z ’set-cdr!) new-value)))

mutable adts pair2
Mutable ADTs : Pair

> (define p1 (mpair 1 2))

> (mutable-car p1)


> (mutable-cdr p1)


> (set-car! p1 3)

> (mutable-car p1)


> (set-cdr! p1 4)

> (mutable-cdr p1)


> (mutable-cdr (set-cdr! p1 5))

. . procedure application: expected procedure, given: #<void>; arguments were: ’cdr

lazy pair
Lazy Pair

(define lazy-mpair

(λ (x y)

(let ((x (box x))

(y (box y)))

(λ (sel)

(sel x y)))))

(define lazy-mcar

(λ (z)

(z (λ (x y)

(unbox x)))))

(define lazy-mcdr

(λ (z)

(z (λ (x y)

(unbox y)))))

(define lazy-set-car!

(λ (z new-value)

(z (λ (x y)




(define lazy-set-cdr!

(λ (z new-value)

(z (λ (x y)




lazy pair1
Lazy Pair

> (define p2 (lazy-mpair 1 2))

> (lazy-mcar p2)


> (lazy-mcdr p2)


> (lazy-set-car! p2 3)

> (lazy-mcar p2)


value equality vs identity equality
Value Equality vs. Identity Equality

Since we have states, we can check state equality or identity.

  • equal? – State (value) equality
  • eq? – Object equality
value equality vs identity equality1
Value Equality vs. Identity Equality

> (define x (list (box 'a) (box 'b)))

> (define y (list (car x) (box 'c) (box 'd)))

> (define z (list (box 'a) (box 'c) (box 'd)) )

> (define w y)

> (eq? y w) ; identity


> (eq? y z)


> (equal? y z) ; value equality


> (equal? (car z) (car x))


> (eq? (car z) (car x))


evaluation of letrec
Evaluation of letrec

Recall the problem we had:

(define fact

(lambda (n)

(let ((iter

(lambda (c p)


(= c 0)



(- c 1)

(* c p))))))

(iter n 1))))

Recursion call will not work

evaluation of letrec1
Evaluation of letrec

Here’s a solution using imperative programming:

(define fact

(lambda (n)

(let ((iter‘unassigned))


(lambda (c p)


(= c 0)



(- c 1)

(* c p)))))

(iter n 1))))

Now iter is in the scope

evaluation of letrec2
Evaluation of letrec
  • Now we unveil the secret of letrec…
  • Its semantics cannot be explained in FP

(let ((f1 ’unassigned) ... (fn ’unassigned))

(set! f1 lambda-exp1)


(set! fn lambda-expn)

e1 ... em))

extending the environment model
Extending the Environment Model
  • The substitution model cannot support mutation
  • Semantics ofset-binding!(x,val,<f1,...,fn>) :
extending the environment model1
Extending the Environment Model
  • Add set! Special operator:

env−eval[(set! x e),env] =


  • Add Box type
extending the interpreter analyzer data structures
Extending the Interpreter & Analyzer:Data Structures

(define set-binding-in-env!

(lambda (envvarval)

(letrec ((defined-in-env

(lambda (varenv)

(if (empty-env? env)


(let ((b (get-value-of-variable

(first-frame env)


(if (eq? b '_not-found)

(defined-in-envvar (enclosing-envenv))

(first-boxed-frame env)))))))

(let ((boxed-frame (defined-in-envvarenv)))

(if (empty? boxed-frame)

(error 'set! "variable not found")

(let ((frame (unbox boxed-frame)))



(change-frame (make-binding varval) frame))))))))

Recursive call

Creates a new frame by adding a new binding

extending the interpreter analyzer data structures1
Extending the Interpreter & Analyzer: Data Structures

(define change-frame

(lambda (binding frame)

(let ((bvar (binding-variable binding))

(bval (binding-value binding)))

(change-sub frame bvarbval))))

(define change-sub

(lambda (sub var value)

(let ((vars (get-variables sub))

(values (get-values sub)))

(if (member varvars)


(cons varvars)

(cons value values))



"substitution is not defined on variable")))))

extending the interpreter analyzer data structures2
Extending the Interpreter & Analyzer: Data Structures

(define make-the-global-environment

(lambda ()

(let* ((primitive-procedures

(list (list 'car car) (list 'cdrcdr)


(list 'box box)

(list 'unboxunbox)

(list 'box? box?)

(list 'set-box! set-box!)...

extending the interpreter analyzer asp
Extending the Interpreter & Analyzer:ASP

(define letrec->let

(lambda (exp)

(letrec ((make-body

(lambda (varsvals)

(if (null? vars)

(letrec-body exp)



(car vars)

(car vals))





(lambda (vars)


(lambda (var)

(list var ’unassigned))


(let* ((vars (letrec-variables exp))

(vals (letrec-initial-values exp))



(make-bindings vars)

(make-body varsvals))))))

(define make-sequence

(lambda (exp1 exp2)

(cons exp1 exp2)))

(define make-assignment

(lambda (variable value)

(attach-tag (list variable value) 'set!)))

Recursive call

extending the interpreter env eval
Extending the Interpreter: env-eval

(define eval-special-form

(lambda (exp env)



((assignment? exp)

(eval-assignment exp env)))))

(define eval-assignment

(lambda (exp env)



(assignment-variable exp)

(env-eval (assignment-value exp) env))


extending the analyzer
Extending the Analyzer

(define analyze-assignment

(lambda (exp)

(let ((var (assignment-variable exp))

(val (analyze (assignment-value exp))))

(lambda (env)

(set-binding-in-env! envvar (valenv))


type checking
Type Checking
  • (set! x e) is well typed if e is well typed
  • Typing rule for set! :

For every: type assignment TA,

expression e, and

type expression S:

If Tenv|- e:S,

Tenv|- x:S,

Then Tenv |- (set! x e):Void

type checking1
Type Checking
  • Axiom for box

For every type environment Tenv and type expression S:

Tenv|- box:[S -> BOX(S)]

Tenv|- unbox:[BOX(S) -> S]

Tenv|- set-box!:[BOX(S)*S -> Void]

Tenv|- box?:[S -> Boolean]

Tenv|- equal?:[BOX(S)*BOX(S) -> Boolean]

Tenv|- eq?:[BOX(S)*BOX(S) -> Boolean]

course summary 1 3
Course summary 1/3

General concepts:

  • semantics, types
  • syntax, CFG(BNF),
  • operational semantics, static analysis, renaming, substitution, interpretation(evaluation)
  • polymorphic types, type safety
course summary 2 3
Course summary 2/3

functional programming model

  • function definition and application
  • special forms
  • derived expressions, ASP
  • apply-procedure, environments, analysis
  • high-order procedures
  • variable binding, lexical scoping (dynamic scoping)
  • static type inference
  • pattern matching
course summary 3 3
Course summary 3/3

logic programming model

  • axioms and queries
  • proof trees, unification, pruning

imperative programming

  • mutable data types
  • state based execution of assignments
  • local state encapsulation


CPS, ADTs, Currying , Sequences, lazy lists