---

yaml
---
r: 139062
b: refs/heads/try2
c: 299995c
h: refs/heads/master
v: v3

Author: pcwalton

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: e78f2e2ac577f9c47cd58af52d3bcd496254545d
+refs/heads/try2: 299995c2b62c520708d450e4b7c6d360be0fd852
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/rust.md

@@ -214,7 +214,7 @@ false fn for
 if impl
 let loop
 match mod mut
-priv pub
+priv pub pure
 ref return
 self static struct super
 true trait type
@@ -936,6 +936,7 @@ Specifically, the following operations are considered unsafe:
 
   - Dereferencing a [raw pointer](#pointer-types).
   - Casting a [raw pointer](#pointer-types) to a safe pointer type.
+  - Breaking the [purity-checking rules](#pure-functions) in a `pure` function.
   - Calling an unsafe function.
 
 ##### Unsafe blocks
@@ -945,6 +946,42 @@ This facility exists because the static semantics of Rust are a necessary approx
 When a programmer has sufficient conviction that a sequence of unsafe operations is actually safe, they can encapsulate that sequence (taken as a whole) within an `unsafe` block. The compiler will consider uses of such code "safe", to the surrounding context.
 
 
+#### Pure functions
+
+A pure function declaration is identical to a function declaration, except that
+it is declared with the additional keyword `pure`. In addition, the typechecker
+checks the body of a pure function with a restricted set of typechecking rules.
+A pure function may only modify data owned by its own stack frame.
+So, a pure function may modify a local variable allocated on the stack, but not a mutable reference that it takes as an argument.
+A pure function may only call other pure functions, not general functions.
+
+An example of a pure function:
+
+~~~~
+pure fn lt_42(x: int) -> bool {
+    return (x < 42);
+}
+~~~~
+
+Pure functions may call other pure functions:
+
+~~~~{.xfail-test}
+pure fn pure_length<T>(ls: List<T>) -> uint { ... }
+
+pure fn nonempty_list<T>(ls: List<T>) -> bool { pure_length(ls) > 0u }
+~~~~
+
+These purity-checking rules approximate the concept of referential transparency:
+that a call-expression could be rewritten with the literal-expression of its return value, without changing the meaning of the program.
+Since they are an approximation, sometimes these rules are *too* restrictive.
+Rust allows programmers to violate these rules using [`unsafe` blocks](#unsafe-blocks), which we already saw.
+As with any `unsafe` block, those that violate static purity carry transfer the burden of safety-proof from the compiler to the programmer.
+Programmers should exercise caution when breaking such rules.
+
+For more details on purity, see [the borrowed pointer tutorial][borrow].
+
+[borrow]: tutorial-borrowed-ptr.html
+
 #### Diverging functions
 
 A special kind of function can be declared with a `!` character where the
@@ -1209,10 +1246,10 @@ For example:
 
 ~~~~
 trait Num {
-    static fn from_int(n: int) -> Self;
+    static pure fn from_int(n: int) -> Self;
 }
 impl Num for float {
-    static fn from_int(n: int) -> float { n as float }
+    static pure fn from_int(n: int) -> float { n as float }
 }
 let x: float = Num::from_int(42);
 ~~~~
@@ -2606,7 +2643,7 @@ Raw pointers (`*`)
 ### Function types
 
 The function type-constructor `fn` forms new function types. A function type
-consists of a set of function-type modifiers (`unsafe`, `extern`, etc.),
+consists of a set of function-type modifiers (`pure`, `unsafe`, `extern`, etc.),
 a sequence of input slots and an output slot.
 
 An example of a `fn` type:

branches/try2/doc/tutorial-borrowed-ptr.md

@@ -486,12 +486,12 @@ For example, we could write a subroutine like this:
 
 ~~~
 struct Point {x: float, y: float}
-fn get_x(p: &'r Point) -> &'r float { &p.x }
+fn get_x(p: &r/Point) -> &r/float { &p.x }
 ~~~
 
 Here, the function `get_x()` returns a pointer into the structure it
-was given. The type of the parameter (`&'r Point`) and return type
-(`&'r float`) both use a new syntactic form that we have not seen so
+was given. The type of the parameter (`&r/Point`) and return type
+(`&r/float`) both use a new syntactic form that we have not seen so
 far.  Here the identifier `r` names the lifetime of the pointer
 explicitly. So in effect, this function declares that it takes a
 pointer with lifetime `r` and returns a pointer with that same
@@ -572,8 +572,8 @@ function:
 #     Rectangle(Point, Size)  // upper-left, dimensions
 # }
 # fn compute_area(shape: &Shape) -> float { 0f }
-fn select<T>(shape: &'r Shape, threshold: float,
-             a: &'r T, b: &'r T) -> &'r T {
+fn select<T>(shape: &r/Shape, threshold: float,
+             a: &r/T, b: &r/T) -> &r/T {
     if compute_area(shape) > threshold {a} else {b}
 }
 ~~~
@@ -593,17 +593,17 @@ example:
 # }
 # fn compute_area(shape: &Shape) -> float { 0f }
 # fn select<T>(shape: &Shape, threshold: float,
-#              a: &'r T, b: &'r T) -> &'r T {
+#              a: &r/T, b: &r/T) -> &r/T {
 #     if compute_area(shape) > threshold {a} else {b}
 # }
-                                                     // -+ r
-fn select_based_on_unit_circle<T>(                   //  |-+ B
-    threshold: float, a: &'r T, b: &'r T) -> &'r T { //  | |
-                                                     //  | |
-    let shape = Circle(Point {x: 0., y: 0.}, 1.);    //  | |
-    select(&shape, threshold, a, b)                  //  | |
-}                                                    //  |-+
-                                                     // -+
+                                                  // -+ r
+fn select_based_on_unit_circle<T>(                //  |-+ B
+    threshold: float, a: &r/T, b: &r/T) -> &r/T { //  | |
+                                                  //  | |
+    let shape = Circle(Point {x: 0., y: 0.}, 1.); //  | |
+    select(&shape, threshold, a, b)               //  | |
+}                                                 //  |-+
+                                                  // -+
 ~~~
 
 In this call to `select()`, the lifetime of the first parameter shape
@@ -629,8 +629,8 @@ returned. Here is how the new `select()` might look:
 #     Rectangle(Point, Size)  // upper-left, dimensions
 # }
 # fn compute_area(shape: &Shape) -> float { 0f }
-fn select<T>(shape: &'tmp Shape, threshold: float,
-             a: &'r T, b: &'r T) -> &'r T {
+fn select<T>(shape: &tmp/Shape, threshold: float,
+             a: &r/T, b: &r/T) -> &r/T {
     if compute_area(shape) > threshold {a} else {b}
 }
 ~~~
@@ -649,7 +649,7 @@ concise to just omit the named lifetime for `shape` altogether:
 # }
 # fn compute_area(shape: &Shape) -> float { 0f }
 fn select<T>(shape: &Shape, threshold: float,
-             a: &'r T, b: &'r T) -> &'r T {
+             a: &r/T, b: &r/T) -> &r/T {
     if compute_area(shape) > threshold {a} else {b}
 }
 ~~~

branches/try2/src/etc/vim/after/ftplugin/rust.vim

@@ -1,5 +1,5 @@
-"Highlight the 100th text column
+"Highlight the 78th text column
 "Feature became available in v7.3
 if version >= 703
-    set colorcolumn=100
+    set colorcolumn=78
 endif

branches/try2/src/libcore/cell.rs

@@ -8,29 +8,18 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use cast::transmute;
 use option;
 use prelude::*;
 
 /// A dynamic, mutable location.
 ///
 /// Similar to a mutable option type, but friendlier.
 
+#[deriving_eq]
 pub struct Cell<T> {
     mut value: Option<T>
 }
 
-impl<T:cmp::Eq> cmp::Eq for Cell<T> {
-    pure fn eq(&self, other: &Cell<T>) -> bool {
-        unsafe {
-            let frozen_self: &Option<T> = transmute(&mut self.value);
-            let frozen_other: &Option<T> = transmute(&mut other.value);
-            frozen_self == frozen_other
-        }
-    }
-    pure fn ne(&self, other: &Cell<T>) -> bool { !self.eq(other) }
-}
-
 /// Creates a new full cell with the given value.
 pub fn Cell<T>(value: T) -> Cell<T> {
     Cell { value: Some(value) }

branches/try2/src/libcore/comm.rs

@@ -8,12 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use cast;
 use either::{Either, Left, Right};
 use kinds::Owned;
 use option;
 use option::{Option, Some, None, unwrap};
-use uint;
 use unstable;
 use vec;
 
@@ -285,12 +283,8 @@ impl<T: Owned> Peekable<T> for PortSet<T> {
 pure fn port_set_peek<T:Owned>(self: &PortSet<T>) -> bool {
     // It'd be nice to use self.port.each, but that version isn't
     // pure.
-    for uint::range(0, vec::uniq_len(&const self.ports)) |i| {
-        // XXX: Botch pending demuting.
-        unsafe {
-            let port: &Port<T> = cast::transmute(&mut self.ports[i]);
-            if port.peek() { return true }
-        }
+    for vec::each(self.ports) |p| {
+        if p.peek() { return true }
     }
     false
 }

branches/try2/src/libcore/container.rs

@@ -14,10 +14,10 @@ use option::Option;
 
 pub trait Container {
     /// Return the number of elements in the container
-    pure fn len(&const self) -> uint;
+    pure fn len(&self) -> uint;
 
     /// Return true if the container contains no elements
-    pure fn is_empty(&const self) -> bool;
+    pure fn is_empty(&self) -> bool;
 }
 
 pub trait Mutable: Container {

branches/try2/src/libcore/hashmap.rs

@@ -290,10 +290,10 @@ pub mod linear {
 
     impl<K:Hash + IterBytes + Eq,V> Container for LinearMap<K, V> {
         /// Return the number of elements in the map
-        pure fn len(&const self) -> uint { self.size }
+        pure fn len(&self) -> uint { self.size }
 
         /// Return true if the map contains no elements
-        pure fn is_empty(&const self) -> bool { self.len() == 0 }
+        pure fn is_empty(&self) -> bool { self.len() == 0 }
     }
 
     impl<K:Hash + IterBytes + Eq,V> Mutable for LinearMap<K, V> {
@@ -555,10 +555,10 @@ pub mod linear {
 
     impl<T:Hash + IterBytes + Eq> Container for LinearSet<T> {
         /// Return the number of elements in the set
-        pure fn len(&const self) -> uint { self.map.len() }
+        pure fn len(&self) -> uint { self.map.len() }
 
         /// Return true if the set contains no elements
-        pure fn is_empty(&const self) -> bool { self.map.is_empty() }
+        pure fn is_empty(&self) -> bool { self.map.is_empty() }
     }
 
     impl<T:Hash + IterBytes + Eq> Mutable for LinearSet<T> {

branches/try2/src/libcore/io.rs

@@ -593,7 +593,7 @@ pub struct BytesReader {
     mut pos: uint
 }
 
-impl Reader for BytesReader<'self> {
+impl Reader for BytesReader/&self {
     fn read(&self, bytes: &mut [u8], len: uint) -> uint {
         let count = uint::min(len, self.bytes.len() - self.pos);
 
@@ -1116,7 +1116,7 @@ pub struct BytesWriter {
 impl Writer for BytesWriter {
     fn write(&self, v: &[const u8]) {
         let v_len = v.len();
-        let bytes_len = vec::uniq_len(&const self.bytes);
+        let bytes_len = self.bytes.len();
 
         let count = uint::max(bytes_len, self.pos + v_len);
         vec::reserve(&mut self.bytes, count);
@@ -1131,7 +1131,7 @@ impl Writer for BytesWriter {
     }
     fn seek(&self, offset: int, whence: SeekStyle) {
         let pos = self.pos;
-        let len = vec::uniq_len(&const self.bytes);
+        let len = self.bytes.len();
         self.pos = seek_in_buf(offset, pos, len, whence);
     }
     fn tell(&self) -> uint { self.pos }

branches/try2/src/libcore/mutable.rs

@@ -46,7 +46,8 @@ pub fn unwrap<T>(m: Mut<T>) -> T {
 pub impl<T> Data<T> {
     fn borrow_mut<R>(&self, op: &fn(t: &mut T) -> R) -> R {
         match self.mode {
-            Immutable => fail!(~"currently immutable"),
+            Immutable => fail!(fmt!("%? currently immutable",
+                                   self.value)),
             ReadOnly | Mutable => {}
         }
 
@@ -61,7 +62,8 @@ pub impl<T> Data<T> {
 
     fn borrow_imm<R>(&self, op: &fn(t: &T) -> R) -> R {
         match self.mode {
-          Mutable => fail!(~"currently mutable"),
+          Mutable => fail!(fmt!("%? currently mutable",
+                               self.value)),
           ReadOnly | Immutable => {}
         }
 

branches/try2/src/libcore/option.rs

@@ -228,14 +228,14 @@ pub pure fn while_some<T>(x: Option<T>, blk: &fn(v: T) -> Option<T>) {
 }
 
 #[inline(always)]
-pub pure fn is_none<T>(opt: &const Option<T>) -> bool {
+pub pure fn is_none<T>(opt: &Option<T>) -> bool {
     //! Returns true if the option equals `none`
 
     match *opt { None => true, Some(_) => false }
 }
 
 #[inline(always)]
-pub pure fn is_some<T>(opt: &const Option<T>) -> bool {
+pub pure fn is_some<T>(opt: &Option<T>) -> bool {
     //! Returns true if the option contains some value
 
     !is_none(opt)
@@ -333,11 +333,11 @@ impl<T> MutableIter<T> for Option<T> {
 pub impl<T> Option<T> {
     /// Returns true if the option equals `none`
     #[inline(always)]
-    pure fn is_none(&const self) -> bool { is_none(self) }
+    pure fn is_none(&self) -> bool { is_none(self) }
 
     /// Returns true if the option contains some value
     #[inline(always)]
-    pure fn is_some(&const self) -> bool { is_some(self) }
+    pure fn is_some(&self) -> bool { is_some(self) }
 
     /**
      * Update an optional value by optionally running its content by reference

branches/try2/src/libcore/ptr.rs

@@ -223,20 +223,20 @@ pub unsafe fn array_each<T>(arr: **T, cb: &fn(*T)) {
 }
 
 pub trait Ptr<T> {
-    pure fn is_null(&const self) -> bool;
-    pure fn is_not_null(&const self) -> bool;
+    pure fn is_null(&self) -> bool;
+    pure fn is_not_null(&self) -> bool;
     pure fn offset(&self, count: uint) -> Self;
 }
 
 /// Extension methods for immutable pointers
 impl<T> Ptr<T> for *T {
     /// Returns true if the pointer is equal to the null pointer.
     #[inline(always)]
-    pure fn is_null(&const self) -> bool { is_null(*self) }
+    pure fn is_null(&self) -> bool { is_null(*self) }
 
     /// Returns true if the pointer is not equal to the null pointer.
     #[inline(always)]
-    pure fn is_not_null(&const self) -> bool { is_not_null(*self) }
+    pure fn is_not_null(&self) -> bool { is_not_null(*self) }
 
     /// Calculates the offset from a pointer.
     #[inline(always)]
@@ -247,11 +247,11 @@ impl<T> Ptr<T> for *T {
 impl<T> Ptr<T> for *mut T {
     /// Returns true if the pointer is equal to the null pointer.
     #[inline(always)]
-    pure fn is_null(&const self) -> bool { is_null(*self) }
+    pure fn is_null(&self) -> bool { is_null(*self) }
 
     /// Returns true if the pointer is not equal to the null pointer.
     #[inline(always)]
-    pure fn is_not_null(&const self) -> bool { is_not_null(*self) }
+    pure fn is_not_null(&self) -> bool { is_not_null(*self) }
 
     /// Calculates the offset from a mutable pointer.
     #[inline(always)]