References and Mutable Data Structures

Transcription

1 References and Mutable Data Structures Principles of Programming Languages CSE Syntax 2 Semantics 3 Version: :44: /11/29 Compiled at 09:37 on 2018/11/13 Programming Languages References CSE / 20 References in Flatte Syntax Syntax E... ref E Creation of boxed value! E Dereference of a boxed value E := E Assignment E ; E Sequence Programming Languages References CSE / 20

2 Syntax Examples use of references in Flatte(5) ref Create a new location, initialized with let val r = ref 22 in let val p = 11 +! in p - 3 end end let val r = ref 33 in r := 11 +! r ; (! r)/4 end r Get a location r initialized to 22; get its value and add 11 to it; finally subtract 3 from this value. Get a location r initialized to 22; get its value, add 11 to it, and assign it back to r; divide the value at r by 4. Programming Languages References CSE / 20 Store Semantics We will use an abstract structure, called store, that associates locations with values. Each expression that creates or modifies locations will change the store. Each expression that uses values at some locations will access the store. Major change: Since any expression may now contain ref e or! e, the big-step semantics that was of the form e v will now be of the form µ e µ v where µ and µ represent stores. Programming Languages References CSE / 20

3 Semantics Big-Step Semantics Ref: Deref: Assign: Seq: Env µ e 1 µ v 1, l dom(µ ), µ = µ [l v 1 ] Env µ ref e 1 µ l Env µ e 1 µ l Env µ!e 1 µ µ (l) Env µ e 1 µ l, Env µ e 2 µ v Env µ (e 1 := e 2 ) µ [l v] v Env µ e 1 µ v 1, Env µ e 2 µ v 2 Env µ (e 1 ; e 2 ) µ v 2 Note the threading of stores through the premises of rules, which capture the order of evaluation of the component expressions. Programming Languages References CSE / 20 Semantics Semantics of Ref and Deref Ref: Deref: Env µ e 1 µ v 1, l dom(µ ), µ = µ [l v 1 ] Env µ Ref(e 1 ) µ l Env µ e 1 µ l Env µ!(e 1 ) µ µ (l) When locations are created, the initial value is first evaluated (v 1 ). A store µ[l v] is a store that is same as µ, except that it has value v at location l. In a dereference expression of the form! e, the inner expression e is completely evaluated to a location before the dereference operation is done. Programming Languages References CSE / 20

4 Semantics of Assignment Semantics Assign: Env µ e 1 µ l, Env µ e 2 µ v Env µ (e 1 ; e 2 ) µ [l v] unit In an assignment of the form e 1 := e 2, e 1 is first completely evaluated, then e 2 is evaluated, and the assignment is finally made. In languages such as C, assignment expressions can be cascaded, as in x=y=z=1. The value of an assignment expression then is the value of its rhs. The value of an assignment expression is a special value, called unit We can read unit as similar to void in C/Java, as a constant whose value itself is not meaningful. In Flatte, we have adopted the SML/OCAML-style semantics. Programming Languages References CSE / 20 Semantics of Sequence Semantics Env µ e Seq: 1 µ v 1, Env µ e 2 µ v 2 Env µ (e 1 ; e 2 ) µ v 2 In a sequence expression of the form e 1 ; e 2, e 1 is first completely evaluated. Once e 1 is evaluated to a value, that value is discarded, and the sequence simply results in e 2. Note that, if e 1 were an assignment, its value would be unit, so nothing of meaning is lost when its value is discarded. Programming Languages References CSE / 20

5 Semantics Impact of Mutability 1 When we introduce mutable structures, it can has significant effect on the rest of the language as well. Every expression now has the potential to change the store. This changes all semantic rules: Old: New: Env e 1 v 1 Env e 2 v 2 Env e 1 +e 2 v 1 + v 2 Add Env µ e 1 µ v 1 Env µ e 2 µ v 2 Env µ e 1 +e 2 µ v 1 + v 2 Add Programming Languages References CSE / 20 Semantics Impact of Mutability 2 Old rules for let: Env e 1 v 1 Env {x : v 1 } e 2 v 2 Env let x = e 1 in e 2 v 2 Let With mutable structures, this becomes: Env µ e 1 µ v 1 Env {x : v 1 } µ e 2 µ v 2 Env µ let x = e 1 in e 2 µ v 2 Let Programming Languages References CSE / 20

6 When mutable data structures are used, the order in which subexpressions are evaluated becomes important. In imperative language, which primarily support mutable structures, the direct effect of an expression, i.e., its value, is often less important than its indirect (side) effect, i.e., its effect on the store. As a result, an imperative program is seen as a collection of commands with some way of specifying the order in which the commands are carried out. Control flow constructs are elements of the language that are used to specify this order. Programming Languages References CSE / 20 Examples of Constructs Sequence: Order commands in a sequence and perform them one after another. Example: e 1 ; e 2 : evaluate e 1, throw the result away, then evaluate e 2 in the modified store. While: Repeatedly evaluate a command as long as a boolean condition holds. Iteration (e.g. for): Repeatedly evaluate a command for a sequence of values. Programming Languages References CSE / 20

7 Semantics of while In a language with while, the statement can be dynamically unrolled. For example: Env µ e 1 µ true Env µ (e 2 ; while(e 1, e 2 )) µ v Env µ while(e 1, e 2 ) µ v While Other loop constructs (e.g. do...while) can be treated similarly. In older languages (such as C), iteration constructs such as for were also seen similarly. More modern languages (including Java) have iterators which can be used to loop over collections of objects. Programming Languages References CSE / 20 Iterators in C++ Iterable classes have begin and end member functions that return members of the iterator class. ++ operator moves the iterator to the next element. Example: void Program::typecheck() { initialize_typechecker(); list<classentity*>::iterator i; for(i=classes_->begin(); i!= classes_->end(); i++) { (*i)->typecheck(); } } Programming Languages References CSE / 20

8 Iterators in Java Iterable objects have an iterator method that returns an Iterator object. next() method of an iterator object returns an element of the base iterable object. // Assume "set" is a collection of Integers Iterator<Integer> iter = set.iterator(); while (iter.hasnext()) { Integer obj = iter.next();... } Modern Java makes iteration appear even simpler: for (Integer obj : set) {... } Programming Languages References CSE / 20 Why are iterators different? Iterators imply two classes (types of values): 1 the collection that contains elements to be iterated over (iterable) 2 the object/structure used to iterate over the elements of the above set (iterator). Iterator values need to remember both the internal state of the base iterable values, as well as the state of the iteration itself. This sets up a complex transfer of control between the consumer, a for loop, and the producer, the iterator: When the for loop is needs the next element, it calls next(), transferring control to the iterator. When next() is called, the iterator computes the next element, suspends itself, and transfers control back to the for loop. Programming Languages References CSE / 20

9 Iterators in Python Generators are used to implement iteration in Python Example: a generator that gives sequence of values starting at n: def fromnumber(n): while (True): yield n n = n + 1 Generator objects are then used in an iterative computation. For example: for i in fromnumber(10): if (i < 20): print i else: break prints integers from 10 to 19. Programming Languages References CSE / 20 Coroutines The yield statement of Python is similar to return... but it saves the context such that the next call to the same function will resume from where it left off. Thus control can switch back and forth between the consuming for loop and the generating function. Sets of functions that transfer control between each other in this manner are called coroutines. Coroutines are generally used to implement producer-consumer patterns. Programming Languages References CSE / 20

10 Continuations A Continuation is a general concept used to model complex control flow, including function/procedure calls, coroutines, iterators, exceptions, and even goto statements. Informally, a continuation is a representation of what to do next. At a low level, a continuation is code + the environment in which the code should be executed. A continuation can be represented by a function closure or an object closure. Programming Languages References CSE / 20 Event-Driven Programs Traditional ( batch ) programs are invoked via a main method, take input from command line or files, write output to console or files and terminate. Event-driven, or reactive programs take input from the environment, write output, and go back to listen to more events. The response to an event is a continuation: what to do when the event is received. The continuation may contain data about shared/private execution history (and may be implemented as object or function closure). Conversion to Continuation Passing Style (aka CPS conversion) can be used to derive event-driven programs from batch-style programs. Programming Languages References CSE / 20