---

yaml
---
r: 80698
b: refs/heads/try
c: a918497
h: refs/heads/master
v: v3

Author: huonw

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 4c6bf4872012c010f84dc7fa2cdfe87522533f89
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cbd1eefbd350797b783df119fed7956d7e1c74ad
-refs/heads/try: 645b83d712fdfd325c899e0bb2ca09d4b0f5f880
+refs/heads/try: a9184975da62769dfccbca73fb9bd554298a4d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/doc/rust.md

@@ -2459,12 +2459,25 @@ do k(3) |j| {
 ### For expressions
 
 ~~~~~~~~{.ebnf .gram}
-for_expr : "for" pat "in" expr '{' block '}' ;
+for_expr : "for" expr [ '|' ident_list '|' ] ? '{' block '}' ;
 ~~~~~~~~
 
-A `for` expression is a syntactic construct for looping
-over elements provided by an implementation of
-`std::iterator::Iterator`.
+A _for expression_ is similar to a [`do` expression](#do-expressions),
+in that it provides a special block-form of lambda expression,
+suited to passing the `block` function to a higher-order function implementing a loop.
+
+In contrast to a `do` expression, a `for` expression is designed to work
+with methods such as `each` and `times`, that require the body block to
+return a boolean. The `for` expression accommodates this by implicitly
+returning `true` at the end of each block, unless a `break` expression
+is evaluated.
+
+In addition, [`break`](#break-expressions) and [`loop`](#loop-expressions) expressions
+are rewritten inside `for` expressions in the same way that `return` expressions are,
+with a combination of local flag variables,
+and early boolean-valued returns from the `block` function,
+such that the meaning of `break` and `loop` is preserved in a primitive loop
+when rewritten as a `for` loop controlled by a higher order function.
 
 An example of a for loop over the contents of a vector:
 

branches/try/src/libextra/num/bigint.rs

@@ -503,7 +503,7 @@ impl Integer for BigUint {
 impl IntConvertible for BigUint {
     #[inline]
     fn to_int(&self) -> int {
-        self.to_int_opt().expect("BigUint conversion would overflow int")
+        num::min(self.to_uint(), int::max_value as uint) as int
     }
 
     #[inline]
@@ -615,43 +615,18 @@ impl BigUint {
     }
 
 
-    /// Converts this BigUint into a uint, failing if the conversion
-    /// would overflow.
+    /// Converts this big integer into a uint, returning the uint::max_value if
+    /// it's too large to fit in a uint.
     #[inline]
     pub fn to_uint(&self) -> uint {
-        self.to_uint_opt().expect("BigUint conversion would overflow uint")
-    }
-
-    /// Converts this BigUint into a uint, unless it would overflow.
-    #[inline]
-    pub fn to_uint_opt(&self) -> Option<uint> {
         match self.data.len() {
-            0 => Some(0),
-            1 => Some(self.data[0] as uint),
-            2 => Some(BigDigit::to_uint(self.data[1], self.data[0])),
-            _ => None
+            0 => 0,
+            1 => self.data[0] as uint,
+            2 => BigDigit::to_uint(self.data[1], self.data[0]),
+            _ => uint::max_value
         }
     }
 
-    // Converts this BigUint into an int, unless it would overflow.
-    pub fn to_int_opt(&self) -> Option<int> {
-        self.to_uint_opt().chain(|n| {
-            // If top bit of uint is set, it's too large to convert to
-            // int.
-            if (n >> (2*BigDigit::bits - 1) != 0) {
-                None
-            } else {
-                Some(n as int)
-            }
-        })
-    }
-
-    /// Converts this BigUint into a BigInt.
-    #[inline]
-    pub fn to_bigint(&self) -> BigInt {
-        BigInt::from_biguint(Plus, self.clone())
-    }
-
     #[inline]
     fn shl_unit(&self, n_unit: uint) -> BigUint {
         if n_unit == 0 || self.is_zero() { return (*self).clone(); }
@@ -1073,7 +1048,12 @@ impl Integer for BigInt {
 impl IntConvertible for BigInt {
     #[inline]
     fn to_int(&self) -> int {
-        self.to_int_opt().expect("BigInt conversion would overflow int")
+        match self.sign {
+            Plus  => num::min(self.to_uint(), int::max_value as uint) as int,
+            Zero  => 0,
+            Minus => num::min((-self).to_uint(),
+                               (int::max_value as uint) + 1) as int
+        }
     }
 
     #[inline]
@@ -1199,55 +1179,12 @@ impl BigInt {
             .map_move(|bu| BigInt::from_biguint(sign, bu));
     }
 
-    /// Converts this BigInt into a uint, failing if the conversion
-    /// would overflow.
     #[inline]
     pub fn to_uint(&self) -> uint {
-        self.to_uint_opt().expect("BigInt conversion would overflow uint")
-    }
-
-    /// Converts this BigInt into a uint, unless it would overflow.
-    #[inline]
-    pub fn to_uint_opt(&self) -> Option<uint> {
-        match self.sign {
-            Plus => self.data.to_uint_opt(),
-            Zero => Some(0),
-            Minus => None
-        }
-    }
-
-    /// Converts this BigInt into an int, unless it would overflow.
-    pub fn to_int_opt(&self) -> Option<int> {
-        match self.sign {
-            Plus  => self.data.to_int_opt(),
-            Zero  => Some(0),
-            Minus => self.data.to_uint_opt().chain(|n| {
-                let m: uint = 1 << (2*BigDigit::bits-1);
-                if (n > m) {
-                    None
-                } else if (n == m) {
-                    Some(int::min_value)
-                } else {
-                    Some(-(n as int))
-                }
-            })
-        }
-    }
-
-    /// Converts this BigInt into a BigUint, failing if BigInt is
-    /// negative.
-    #[inline]
-    pub fn to_biguint(&self) -> BigUint {
-        self.to_biguint_opt().expect("negative BigInt cannot convert to BigUint")
-    }
-
-    /// Converts this BigInt into a BigUint, if it's not negative.
-    #[inline]
-    pub fn to_biguint_opt(&self) -> Option<BigUint> {
         match self.sign {
-            Plus => Some(self.data.clone()),
-            Zero => Some(Zero::zero()),
-            Minus => None
+            Plus  => self.data.to_uint(),
+            Zero  => 0,
+            Minus => 0
         }
     }
 }
@@ -1448,9 +1385,9 @@ mod biguint_tests {
         check(~[ 0,  1], ((uint::max_value >> BigDigit::bits) + 1) as int);
         check(~[-1, -1 >> 1], int::max_value);
 
-        assert_eq!(BigUint::new(~[0, -1]).to_int_opt(), None);
-        assert_eq!(BigUint::new(~[0, 0, 1]).to_int_opt(), None);
-        assert_eq!(BigUint::new(~[0, 0, -1]).to_int_opt(), None);
+        assert_eq!(BigUint::new(~[0, -1]).to_int(), int::max_value);
+        assert_eq!(BigUint::new(~[0, 0, 1]).to_int(), int::max_value);
+        assert_eq!(BigUint::new(~[0, 0, -1]).to_int(), int::max_value);
     }
 
     #[test]
@@ -1468,19 +1405,8 @@ mod biguint_tests {
         check(~[ 0, -1], uint::max_value << BigDigit::bits);
         check(~[-1, -1], uint::max_value);
 
-        assert_eq!(BigUint::new(~[0, 0, 1]).to_uint_opt(), None);
-        assert_eq!(BigUint::new(~[0, 0, -1]).to_uint_opt(), None);
-    }
-
-    #[test]
-    fn test_convert_to_bigint() {
-        fn check(n: BigUint, ans: BigInt) {
-            assert_eq!(n.to_bigint(), ans);
-            assert_eq!(n.to_bigint().to_biguint(), n);
-        }
-        check(Zero::zero(), Zero::zero());
-        check(BigUint::new(~[1,2,3]),
-              BigInt::from_biguint(Plus, BigUint::new(~[1,2,3])));
+        assert_eq!(BigUint::new(~[0, 0, 1]).to_uint(), uint::max_value);
+        assert_eq!(BigUint::new(~[0, 0, -1]).to_uint(), uint::max_value);
     }
 
     static sum_triples: &'static [(&'static [BigDigit],
@@ -1867,21 +1793,22 @@ mod bigint_tests {
             Plus, BigUint::from_uint(int::max_value as uint)
         ), int::max_value);
 
-        assert_eq!(BigInt::from_biguint(
+        assert!(BigInt::from_biguint(
             Plus, BigUint::from_uint(int::max_value as uint + 1)
-        ).to_int_opt(), None);
-        assert_eq!(BigInt::from_biguint(
+        ).to_int() == int::max_value);
+        assert!(BigInt::from_biguint(
             Plus, BigUint::new(~[1, 2, 3])
-        ).to_int_opt(), None);
+        ).to_int() == int::max_value);
 
         check(BigInt::from_biguint(
-            Minus, BigUint::new(~[0, 1<<(BigDigit::bits-1)])
+            Minus, BigUint::from_uint(-int::min_value as uint)
         ), int::min_value);
-        assert_eq!(BigInt::from_biguint(
-            Minus, BigUint::new(~[1, 1<<(BigDigit::bits-1)])
-        ).to_int_opt(), None);
-        assert_eq!(BigInt::from_biguint(
-            Minus, BigUint::new(~[1, 2, 3])).to_int_opt(), None);
+        assert!(BigInt::from_biguint(
+            Minus, BigUint::from_uint(-int::min_value as uint + 1)
+        ).to_int() == int::min_value);
+        assert!(BigInt::from_biguint(
+            Minus, BigUint::new(~[1, 2, 3])
+        ).to_int() == int::min_value);
     }
 
     #[test]
@@ -1897,31 +1824,16 @@ mod bigint_tests {
         check(
             BigInt::from_biguint(Plus, BigUint::from_uint(uint::max_value)),
             uint::max_value);
-        assert_eq!(BigInt::from_biguint(
-            Plus, BigUint::new(~[1, 2, 3])).to_uint_opt(), None);
-
-        assert_eq!(BigInt::from_biguint(
-            Minus, BigUint::from_uint(uint::max_value)).to_uint_opt(), None);
-        assert_eq!(BigInt::from_biguint(
-            Minus, BigUint::new(~[1, 2, 3])).to_uint_opt(), None);
-    }
-
-    #[test]
-    fn test_convert_to_biguint() {
-        fn check(n: BigInt, ans_1: BigUint) {
-            assert_eq!(n.to_biguint(), ans_1);
-            assert_eq!(n.to_biguint().to_bigint(), n);
-        }
-        let zero: BigInt = Zero::zero();
-        let unsigned_zero: BigUint = Zero::zero();
-        let positive = BigInt::from_biguint(
-            Plus, BigUint::new(~[1,2,3]));
-        let negative = -positive;
-
-        check(zero, unsigned_zero);
-        check(positive, BigUint::new(~[1,2,3]));
-
-        assert_eq!(negative.to_biguint_opt(), None);
+        assert!(BigInt::from_biguint(
+            Plus, BigUint::new(~[1, 2, 3])
+        ).to_uint() == uint::max_value);
+
+        assert!(BigInt::from_biguint(
+            Minus, BigUint::from_uint(uint::max_value)
+        ).to_uint() == 0);
+        assert!(BigInt::from_biguint(
+            Minus, BigUint::new(~[1, 2, 3])
+        ).to_uint() == 0);
     }
 
     static sum_triples: &'static [(&'static [BigDigit],