Programming)Languages)) and)Techniques) (CIS120))cis120/archive/15fa/lectures/lec17.pdf · valid...

Programming Languages and Techniques

(CIS120)

Lecture 17 October 12th , 2015

More Queue ManipulaEon

“Objects”

Announcements •  Homework 4: Queues

–  Due: Tomorrow, October 13th at 11:59 pm

•  Homework 5: GUI Library & Paint –  Available Soon –  Due: Thursday, October 22nd

CIS120

What happens when you run this funcEon on a (valid) queue containing 2 elements?

1. The value 2 is returned2. The value 0 is returned 3. StackOverflow4. Your program hangs

let f (q:'a queue) : int = let rec loop (qn:'a qnode option) : int = begin match qn with | None -> 0 | Some n -> 1 + loop qn end in loop q.head

CIS120

What happens when you run this funcEon on a (valid) queue containing 2 elements?

1. The value 2 is returned2. The value 0 is returned 3. StackOverflow4. Your program hangs

let f (q:'a queue) : int = let rec loop (qn:'a qnode option) (len:int) : int = begin match qn with | None -> len | Some n -> loop qn (len + 1) end in loop q.head 0

More queue iteraEon examples

to_list print

get_tail

to_list (using iteraEon)

•  Here, the state maintained across each iteraEon of the loop is the queue “index pointer” no and the (reversed) list of elements traversed.

•  The “exit case” post processes the list by reversing it.

(* Retrieve the list of values stored in the queue, ordered from head to tail. *)let to_list (q: 'a queue) : 'a list = let rec loop (no: 'a qnode option) (l:'a list) : 'a list = begin match no with | None -> List.rev l | Some n -> loop n.next (n.v::l) end in loop q.head []

print (using iteraEon)

•  Here, the only state needed is the queue “index pointer”.

let print (q:'a queue) (string_of_element:'a -> string) : unit = let rec loop (no: 'a qnode option) : unit = begin match no with | None -> () | Some n -> print_endline (string_of_element n.v); loop n.next end in print_endline "--- queue contents ---"; loop q.head; print_endline "--- end of queue -----"

Singly-‐linked Queue Processing •  General structure (schemaEcally) :

•  What is useful to put in the state? –  Accumulated informaEon about the queue (e.g. length so far) –  Link to previous node (so that it could be updated, for example)

(* Process a singly-linked queue. *)let queue_operation (q: 'a queue) : ’b = let rec loop (current: 'a qnode option) (s:'a state) : ‘b = begin match no with | None -> … (* iteration complete, produce result *)

| Some n -> … (* do something with n, create new loop state *) loop current.next new_s

end in loop q.head init

(* Determine whether the q satisfies the q invariant *)let valid (q: 'a queue) : bool = begin match (q.head,q.tail) with | (None,None) -> true | (Some n1,Some n2) -> begin match get_tail n1 with | Some n -> n2 == n (* tail is the last node *) | None -> false end | (_,_) -> false end

Either: (1) head and tail are both None (i.e. the queue is empty) or (2) head is Some n1, tail is Some n2 and -‐ n2 is reachable from n1 by following ‘next’ pointers -‐ n2.next is None

get_tail (using iteraEon)

•  This funcEon works even if the queue has cycles. –  It returns Some qn if qn is a “tail” reachable from hd (qn may be hd) –  It returns None if there is a cycle

•  The state is an index pointer and a list of all the nodes seen. –  contains_alias is a helper funcEon that checks to see whether n has an

alias in the list

(* get the tail (if any) from a queue *)let rec get_tail (hd: 'a qnode) : 'a qnode option = let rec loop (qn: 'a qnode) (seen: 'a qnode list) : 'a qnode option = begin match qn.next with | None -> Some qn | Some n -> if contains_alias n seen then None else loop n (qn::seen) end in loop hd []

General Guidelines •  Processing must maintain the queue invariants •  Update the head and tail references (if necessary) •  If changing the link structure:

–  SomeEmes useful to keep reference to the previous node (allows removal of the current node)

•  Drawing pictures of the queue heap structure is helpful

•  If iteraEng over the whole queue (e.g. to find an element) –  It is usually not useful to use helpers like “is_empty” or “contains”

because you will have to account for those cases during the traversal anyway!

“Objects” and Hidden State

EncapsulaEng State

CIS120

What number is printed by this program?

1. 12. 23. 34. 45. 56. other

let f = let x = 2 in fun (y : int) -> x + ylet x = 4;; print_int (f 1)

How did you answer this quesEon? 1.  SubsEtuEon model 2.  Abstract Stack Machine 3.  I just knew the answer 4.  I didn’t know, so I guessed

Answer: 3

An “incr” funcEon •  FuncEons with internal state

•  Drawbacks: –  No abstrac0on: There is only one counter in the world. If we want

another, we need another counter_state value and another incr funcEon.

–  No encapsula0on: Any other code can modify count, too.

type counter_state = { mutable count:int }

let ctr = { count = 0 }

(* each call to incr will produce the next integer *)let incr () : int = ctr.count <- ctr.count + 1; ctr.count

Using Hidden State •  Make a funcEon that creates a counter state and an incr

funcEon each Eme a counter is needed.

(* More useful: a counter generator: *)let mk_incr () : unit -> int = (* this ctr is private to the returned function *) let ctr = { count = 0 } in fun () -> ctr.count <- ctr.count + 1; ctr.count

(* make one counter *) let incr1 : unit -> int = mk_incr ()

(* make another counter *)let incr2 : unit -> int = mk_incr ()

CIS120

What number is printed by this program?

1. 12. 23. 34. other

Answer: 1

let mk_incr () : unit -> int = let ctr = { count = 0 } in fun () -> ctr.count <- ctr.count + 1; ctr.count

let incr1 = mk_incr () (* make one counter *) let incr2 = mk_incr () (* and another *)

let _ = incr1 () in print_int (incr2 ())

Running mk_incr

let mk_incr () : unit -> int = let ctr = {count = 0} in fun () -> ctr.count <- ctr.count + 1; ctr.count

let incr1 : unit -> int = mk_incr ()

Workspace Stack Heap

Running mk_incr

let mk_incr : unit -> unit -> int = fun () -> let ctr = {count = 0} in fun () -> ctr.count <- ctr.count + 1; ctr.count

Running mk_incr

let mk_incr : unit -> unit -> int = fun () -> let ctr = {count = 0} in fun () -> ctr.count <- ctr.count + 1; ctr.count

Running mk_incr

let mk_incr : unit -> unit -> int = let incr1 : unit -> int = mk_incr ()

fun () -> let ctr = {count = 0} in fun () -> ctr.count <- ctr.count + 1; ctr.count

Running mk_incr

let mk_incr : unit -> unit -> int = . let incr1 : unit -> int = mk_incr ()

Running mk_incr

mk_incr

Running mk_incr

mk_incr

Running mk_incr

let incr1 : unit -> int = ( ())

mk_incr

Running mk_incr

let incr1 : unit -> int = ( ())

mk_incr

Running mk_incr

let ctr = {count = 0} in fun () -> ctr.count <- ctr.count + 1; ctr.count

mk_incr

let incr1 : unit -> int = ( )

Running mk_incr

let ctr = {count = 0} in fun () -> ctr.count <- ctr.count + 1; ctr.count

mk_incr

Running mk_incr

let ctr = in fun () -> ctr.count <- ctr.count + 1; ctr.count

mk_incr

count 0

Running mk_incr

let ctr = in fun () -> ctr.count <- ctr.count + 1; ctr.count

mk_incr

count 0

Running mk_incr

fun () -> ctr.count <- ctr.count + 1; ctr.count

mk_incr

count 0ctr

Running mk_incr

mk_incr

count 0ctr

Local FuncEons Workspace Stack Heap

mk_incr

count 0ctr

NOTE: We need one refinement of the ASM model to handle local funcEons. Why? The funcEon menEons “ctr”, which is on the stack (but about to be popped off)…

…so we save a copy of the needed stack bindings with the funcEon itself. (This is someEmes called a closure…)

mk_incr

count 0ctr

mk_incr

count 0

mk_incr

count 0

mk_incr

count 0

DONE! Note how the count record is accessible only via the incr1 funcEon. This is the sense in which the state is “local” to incr1.

Now let’s run “incr1 ()” Workspace Stack Heap

mk_incr

count 0

incr1 () incr1

mk_incr

count 0

incr1 () incr1

mk_incr

count 0

( ()) incr1

mk_incr

count 0

( ()) incr1

Now let’s run “incr1 ()”

ctr.count <- ctr.count + 1;ctr.count

mk_incr

count 0

NOTE: Since the funcEon had some saved stack bindings, we add them to the stack at the same Eme that we put the code in the workspace.

ctr.count <- ctr.count + 1;ctr.count

mk_incr

count 0

.count <- ctr.count + 1;ctr.count

mk_incr

count 0

.count <- ctr.count + 1;ctr.count

mk_incr

count 0

.count <- .count + 1;ctr.count

mk_incr

count 0

.count <- .count + 1;ctr.count

mk_incr

count 0

.count <- 0 + 1;ctr.count

mk_incr

count 0

.count <- 0 + 1;ctr.count

mk_incr

count 0

.count <- 1;ctr.count

mk_incr

count 0

.count <- 1;ctr.count

mk_incr

count 0

();ctr.count

mk_incr

count 1

();ctr.count

mk_incr

count 1

ctr.count

mk_incr

count 1

ctr.count

mk_incr

count 1

.count

mk_incr

count 1

.count

mk_incr

count 1

mk_incr

count 1

mk_incr

count 1

mk_incr

count 1

Now Let’s run mk_incr again Workspace Stack Heap

mk_incr

count 1

let incr2 : unit -> int = mk_incr () incr1

…Eme passes…

Ajer creaEng incr2 Workspace Stack Heap

mk_incr

count 1

count 0

NOTE: the two different incr funcEons have separate local states because a new count record was created in each call to mk_incr.

One step further •  mk_incr shows us how to create different instance of local

state so that we can have several different counters. •  What if we want to bundle together several operaEons that

share the same local state? –  e.g. incr and decr operaEons that work on the same counter

A Counter Object

(* The type of counter objects *)type counter = { get : unit -> int; incr : unit -> unit; decr : unit -> unit; reset : unit -> unit;}

(* Create a fresh counter object with hidden state: *)let new_counter () : counter = let ctr = {count = 0} in { get = (fun () -> ctr.count) ; incr = (fun () -> ctr.count <- ctr.count + 1) ; decr = (fun () -> ctr.count <- ctr.count - 1) ; reset = (fun () -> ctr.count <- 0) ; }

let c1 = mk_counter ()Stack Heap

fun () -> let ctr = {count = 0} in { … }

new_counter

count 1 fun () -> ctr.count

fun () -> ctr.count <- ctr.count + 1

fun () -> ctr.count <- ctr.count – 1

fun () -> ctr.count <- 0

Using Counter Objects

(* a helper function to create a nice string for printing *)let ctr_string (s:string) (i:int) = s ^ ".ctr = " ^ (string_of_int i) ^ "\n" let c1 = new_counter ()let c2 = new_counter ()

;; print_string (ctr_string "c1" (c1.get ()));; c1.incr ();; c1.incr ();; print_string (ctr_string "c1" (c1.get ()));; c1.decr ();; print_string (ctr_string "c1" (c1.get ()));; c2.incr ();; print_string (ctr_string "c2" (c2.get ()));; c2.decr ();; print_string (ctr_string "c2" (c2.get ()))

Programming)Languages)) and)Techniques) (CIS120))cis120/archive/15fa/lectures/lec17.pdf · valid...

Documents

VALID 3 APRIL - 14 APRIL 2019 Member Savings Coupons · valid 3 april - 14 april 2019 valid 3 april - 14 april 2019 valid 3 april - 14 april 2019 valid 3 april - 14 april 2019 valid

Technician Class Home-Study Q&A Course …...Technician Class Home-Study Q&A Course Questions Valid 2018-2022 Gordon West, WB6NOA & The W5YI Group Scroll Down To Begin The Home Study

Passleader Valid 70-412 Braindumps With Premium Q&As (41-60)

Hanwha Q CELLS Installation Manual Solahart295BLK 2018-08 ... · INSTALLATION AND OPERATION MANUAL Solahart295BLK Valid for Australia and New Zealand Solahart

COUPONS - Microsoft · 2018-12-05 · valid 7 - 23 december 2018 valid 7 - 23 december 2018 valid 7 - 23 december 2018 valid 7 - 23 december 2018 valid 7 - 23 december 2018 valid

Chapter 1, Part III: Proofs - SNU · We can express the premises ... A valid argument takes the following form: S1 S2... Sn C. Valid Arguments ... integers pand qwhere q≠0 such

Microsoft Office 2003 - virgil.azwestern.eduvirgil.azwestern.edu/~cvb/CIS120/Book Notes/NP2010_IM_Chapter12.… · Web viewCreate some basic facts and rules using Prolog syntax.

Lieferanten Qualitätsleistungskennzahlen Gültig ab: Valid ...€¦ · 1 Q-KPI: Qualitätsleistungskennzahl / uality Key Performance Indicator. Lieferanten Qualitätsleistungskennzahlen

Microsoft Office 2003virgil.azwestern.edu/~cvb/CIS120/Book Notes/NP2010_IM_Chapter… · Web viewIf possible, demonstrate using Microsoft Office’s speech recognition software

Passleader Valid 70-412 Braindumps With Premium Q&As (21-40)

c120Feb1715edit.notebook February 17, 2015cisweb.bristolcc.edu/~pgrocer/audio_smartboard15/CIS120/... · 2015. 2. 18. · February 17, 2015 From the book: c120Feb1715edit.notebook

Passleader Valid 70-412 Braindumps With Premium Q&As (1-20)

OR F T OR P E RQ 1 Q 3 /202901 · FOR Q 1 – Q 3 2019/20 This report is a translation of the original report in German, which is solely valid. 4 from the direct and indirect ramifications

Programming)Languages) and)Techniques (CIS120)

CIS120: Access Handouts

VALID ROOT CERTIFICATE AUTHORITY CERTIFICATION …global.validcertificadora.com.br/ca-valid-root/cps-valid-root.pdf · valid root certificate authority certification practice statement

Microsoft Office 2003virgil.azwestern.edu/~cvb/CIS120/Book Notes/NP11_IM_Chapter11… · Web viewExplain the capabilities of various data management tools, such as commercial applications,

B Bass Clarinet ∫ For reference only. Not valid for performance....Chimes, Vibes, Marimba, Bells, Xylophone []! Y Y Y 44 AQ Q Q A mp Chimes l.v. l.v. Vibes & Marimba w/soft mallets

Title: Sep 67:57 PM (1 of 16)cisweb.bristolcc.edu/~pgrocer/audio_smartboardF16/CIS120/... · 2016-09-07 · HTML5intro.htm1 HTML51ist.htm1 HTML51inkpage.htm1 HTML5CSS1ist.htm1 HTML5headers.htm1

Envolvente Convexo - CIMAT · 2. for all ordered pairs (p,q) ⌅ P P with p not equal to q 3. do valid ⇥ true 4. for all points r ⌅ P not equal to p or q 5. do if r lies to the