X-Git-Url: http://lambda.jimpryor.net/git/gitweb.cgi?a=blobdiff_plain;f=week9.mdwn;h=b38293d12c420b86c54225848b8d70fe7af8a7b0;hb=c73028930c6693a228c5a55a287f51d40bc72179;hp=145833d54ffe6ba2d3c369ab1975fbfc4a7cce3c;hpb=b9707741b7a76175e4870be85a7b7147f237c584;p=lambda.git diff --git a/week9.mdwn b/week9.mdwn index 145833d5..b38293d1 100644 --- a/week9.mdwn +++ b/week9.mdwn @@ -100,7 +100,9 @@ Scheme is similar. There are various sorts of reference cells available in Schem (set-box! ycell 3) (+ x (unbox ycell))) -When dealing with explicit-style mutation, there's a difference between the types and values of `ycell` and `!ycell` (or `(unbox ycell)`). The former has the type `int ref`: the variable `ycell` is assigned a reference cell that contains an `int`. The latter has the type `int`, and has whatever value is now stored in the relevant reference cell. In an implicit-style framework though, we only have the resources to refer to the contents of the relevant reference cell. `y` in fragment [G] or the C snippet above has the type `int`, and only ever evaluates to `int` values. +(C has explicit-style mutable variables, too, which it calls *pointers*. But simple variables in C are already mutable, in the implicit style.) + +When dealing with explicit-style mutation, there's a difference between the types and values of `ycell` and `!ycell` (or in Scheme, `(unbox ycell)`). The former has the type `int ref`: the variable `ycell` is assigned a reference cell that contains an `int`. The latter has the type `int`, and has whatever value is now stored in the relevant reference cell. In an implicit-style framework though, we only have the resources to refer to the contents of the relevant reference cell. `y` in fragment [G] or the C snippet above has the type `int`, and only ever evaluates to `int` values. ##Controlling order## @@ -236,6 +238,14 @@ The core idea to referential transparency is that when the same value is supplie Notice that the two invocations of `f 1` yield different results, even though the same value is being supplied as an argument to the same function. +Similarly, functions like these: + + let f cell = !cell;; + + let g cell = cell := !cell + 1; !cell;; + +may return different results each time they're invoked, even if they're always supplied one and the same reference cell as argument. + Computer scientists also associate referential transparency with a kind of substitution principle, illustrated here: let x = 1 @@ -515,6 +525,9 @@ To get the whole process started, the complex computation so defined will need t Notice: h, p have same value (1), but f (h, p) and f (h, h) differ +Fine and Pryor on "coordinated contents" (see, e.g., [Hyper-Evaluativity](http://www.jimpryor.net/research/papers/Hyper-Evaluativity.txt)) + + ##Five grades of mutation involvement## -- FIXME -- @@ -578,7 +591,29 @@ To get the whole process started, the complex computation so defined will need t We use the `None`/`Some factorial` option type here just as a way to ensure that the contents of `fact_cell` are of the same type both at the start and the end of the block. +##Offsite Reading## + +* [[!wikipedia Declarative programming]] +* [[!wikipedia Functional programming]] +* [[!wikipedia Purely functional]] +* [[!wikipedia Side effect (computer science) desc="Side effects"]] +* [[!wikipedia Referential transparency (computer science)]] +* [[!wikipedia Imperative programming]] +* [[!wikipedia Reference (computer science) desc="References"]] +* [[!wikipedia Pointer (computing) desc="Pointers"]] +* [Pointers in OCaml](http://caml.inria.fr/resources/doc/guides/pointers.html) +