---

yaml
---
r: 152947
b: refs/heads/try2
c: ca7fb82
h: refs/heads/master
i:
  152945: 61d5ea9
  152943: e273e08
v: v3

Author: alexcrichton

[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: ff94f867d29a90ab59060c10a62f65994776a8c4
+refs/heads/try2: ca7fb82e0b9fb47e4addcee7b993993e7ce27fde
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/doc/guide-unsafe.md

@@ -267,12 +267,12 @@ impl<T: Send> Drop for Unique<T> {
 // A comparison between the built-in `Box` and this reimplementation
 fn main() {
     {
-        let mut x = box 5i;
+        let mut x = box 5;
         *x = 10;
     } // `x` is freed here
 
     {
-        let mut y = Unique::new(5i);
+        let mut y = Unique::new(5);
         *y.borrow_mut() = 10;
     } // `y` is freed here
 }
@@ -678,7 +678,7 @@ unsafe fn deallocate(ptr: *mut u8, _size: uint, _align: uint) {
 
 #[start]
 fn main(argc: int, argv: *const *const u8) -> int {
-    let x = box 1i;
+    let x = box 1;
 
     0
 }

branches/try2/src/doc/intro.md

@@ -133,7 +133,7 @@ Check it out:
 ```
 
 fn dangling() -> Box<int> {
-    let i = box 1234i;
+    let i = box 1234;
     return i;
 }
 
@@ -143,16 +143,16 @@ fn add_one() -> int {
 }
 ```
 
-Now instead of a stack allocated `1234i`,
-we have a heap allocated `box 1234i`.
+Now instead of a stack allocated `1234`,
+we have a heap allocated `box 1234`.
 Whereas `&` borrows a pointer to existing memory,
 creating an owned box allocates memory on the heap and places a value in it,
 giving you the sole pointer to that memory.
 You can roughly compare these two lines:
 
 ```
 // Rust
-let i = box 1234i;
+let i = box 1234;
 ```
 
 ```cpp

branches/try2/src/doc/rust.md

@@ -442,14 +442,17 @@ of integer literal suffix:
 The type of an _unsuffixed_ integer literal is determined by type inference.
 If an integer type can be _uniquely_ determined from the surrounding program
 context, the unsuffixed integer literal has that type.  If the program context
-underconstrains the type, it is considered a static type error;
-if the program context overconstrains the type,
-it is also considered a static type error.
+underconstrains the type, the unsuffixed integer literal's type is `int`; if
+the program context overconstrains the type, it is considered a static type
+error.
 
 Examples of integer literals of various forms:
 
 ~~~~
-123i;                              // type int
+123; 0xff00;                       // type determined by program context
+                                   // defaults to int in absence of type
+                                   // information
+
 123u;                              // type uint
 123_u;                             // type uint
 0xff_u8;                           // type u8
@@ -466,19 +469,17 @@ A _floating-point literal_ has one of two forms:
   second decimal literal.
 * A single _decimal literal_ followed by an _exponent_.
 
-By default, a floating-point literal has a generic type,
-and, like integer literals, the type must be uniquely determined
-from the context.
-A floating-point literal may be followed (immediately, without any
+By default, a floating-point literal has a generic type, but will fall back to
+`f64`. A floating-point literal may be followed (immediately, without any
 spaces) by a _floating-point suffix_, which changes the type of the literal.
 There are two floating-point suffixes: `f32`, and `f64` (the 32-bit and 64-bit
 floating point types).
 
 Examples of floating-point literals of various forms:
 
 ~~~~
-123.0f64;                          // type f64
-0.1f64;                            // type f64
+123.0;                             // type f64
+0.1;                               // type f64
 0.1f32;                            // type f32
 12E+99_f64;                        // type f64
 ~~~~
@@ -2699,9 +2700,9 @@ must be a constant expression that can be evaluated at compile time, such
 as a [literal](#literals) or a [static item](#static-items).
 
 ~~~~
-[1i, 2, 3, 4];
+[1, 2, 3, 4];
 ["a", "b", "c", "d"];
-[0i, ..128];             // vector with 128 zeros
+[0, ..128];             // vector with 128 zeros
 [0u8, 0u8, 0u8, 0u8];
 ~~~~
 
@@ -2880,7 +2881,7 @@ equals sign (`=`) and an [rvalue](#lvalues-rvalues-and-temporaries) expression.
 Evaluating an assignment expression [either copies or moves](#moved-and-copied-types) its right-hand operand to its left-hand operand.
 
 ~~~~
-# let mut x = 0i;
+# let mut x = 0;
 # let y = 0;
 
 x = y;
@@ -2931,7 +2932,7 @@ paren_expr : '(' expr ')' ;
 An example of a parenthesized expression:
 
 ~~~~
-let x: int = (2 + 3) * 4;
+let x = (2 + 3) * 4;
 ~~~~
 
 
@@ -3015,7 +3016,7 @@ conditional expression evaluates to `false`, the `while` expression completes.
 An example:
 
 ~~~~
-let mut i = 0u;
+let mut i = 0;
 
 while i < 10 {
     println!("hello");
@@ -3261,7 +3262,7 @@ Patterns can also dereference pointers by using the `&`,
 on `x: &int` are equivalent:
 
 ~~~~
-# let x = &3i;
+# let x = &3;
 let y = match *x { 0 => "zero", _ => "some" };
 let z = match x { &0 => "zero", _ => "some" };
 
@@ -3284,7 +3285,7 @@ A range of values may be specified with `..`.
 For example:
 
 ~~~~
-# let x = 2i;
+# let x = 2;
 
 let message = match x {
   0 | 1  => "not many",

branches/try2/src/doc/tutorial.md

@@ -262,7 +262,7 @@ write function, variable, and module names with lowercase letters, using
 underscores where they help readability, while writing types in camel case.
 
 ~~~
-let my_variable = 100i;
+let my_variable = 100;
 type MyType = int;     // primitive types are _not_ camel case
 ~~~
 
@@ -276,7 +276,7 @@ write a piece of code like this:
 
 ~~~~
 # let item = "salad";
-let price: f64;
+let price;
 if item == "salad" {
     price = 3.50;
 } else if item == "muffin" {
@@ -290,7 +290,7 @@ But, in Rust, you don't have to repeat the name `price`:
 
 ~~~~
 # let item = "salad";
-let price: f64 =
+let price =
     if item == "salad" {
         3.50
     } else if item == "muffin" {
@@ -337,10 +337,11 @@ suffix that can be used to indicate the type of a literal: `i` for `int`,
 In the absence of an integer literal suffix, Rust will infer the
 integer type based on type annotations and function signatures in the
 surrounding program. In the absence of any type information at all,
-Rust will report an error and request that the type be specified explicitly.
+Rust will assume that an unsuffixed integer literal has type
+`int`.
 
 ~~~~
-let a: int = 1;  // `a` is an `int`
+let a = 1;       // `a` is an `int`
 let b = 10i;     // `b` is an `int`, due to the `i` suffix
 let c = 100u;    // `c` is a `uint`
 let d = 1000i32; // `d` is an `i32`
@@ -474,7 +475,7 @@ against each pattern in order until one matches. The matching pattern
 executes its corresponding arm.
 
 ~~~~
-let my_number = 1i;
+let my_number = 1;
 match my_number {
   0     => println!("zero"),
   1 | 2 => println!("one or two"),
@@ -500,7 +501,7 @@ matches any single value. (`..`) is a different wildcard that can match
 one or more fields in an `enum` variant.
 
 ~~~
-# let my_number = 1i;
+# let my_number = 1;
 match my_number {
   0 => { println!("zero") }
   _ => { println!("something else") }
@@ -583,7 +584,7 @@ keyword `break` aborts the loop, and `continue` aborts the current
 iteration and continues with the next.
 
 ~~~~
-let mut cake_amount = 8i;
+let mut cake_amount = 8;
 while cake_amount > 0 {
     cake_amount -= 1;
 }
@@ -943,7 +944,7 @@ The `box` operator performs memory allocation on the heap:
 ~~~~
 {
     // an integer allocated on the heap
-    let y = box 10i;
+    let y = box 10;
 }
 // the destructor frees the heap memory as soon as `y` goes out of scope
 ~~~~
@@ -1164,7 +1165,7 @@ let z = x;
 The mutability of a value may be changed by moving it to a new owner:
 
 ~~~~
-let r = box 13i;
+let r = box 13;
 let mut s = r; // box becomes mutable
 *s += 1;
 let t = s; // box becomes immutable
@@ -1284,9 +1285,9 @@ Using the generic `List<T>` works much like before, thanks to type inference:
 #     Cons(value, box xs)
 # }
 let mut xs = Nil; // Unknown type! This is a `List<T>`, but `T` can be anything.
-xs = prepend(xs, 10i); // Here the compiler infers `xs`'s type as `List<int>`.
-xs = prepend(xs, 15i);
-xs = prepend(xs, 20i);
+xs = prepend(xs, 10); // Here the compiler infers `xs`'s type as `List<int>`.
+xs = prepend(xs, 15);
+xs = prepend(xs, 20);
 ~~~
 
 The code sample above demonstrates type inference making most type annotations optional. It is
@@ -1409,12 +1410,12 @@ Beyond the properties granted by the size, an owned box behaves as a regular
 value by inheriting the mutability and lifetime of the owner:
 
 ~~~~
-let x = 5i; // immutable
-let mut y = 5i; // mutable
+let x = 5; // immutable
+let mut y = 5; // mutable
 y += 2;
 
-let x = box 5i; // immutable
-let mut y = box 5i; // mutable
+let x = box 5; // immutable
+let mut y = box 5; // mutable
 *y += 2; // the `*` operator is needed to access the contained value
 ~~~~
 
@@ -1506,7 +1507,7 @@ freezing enforced statically at compile-time. An example of a non-`Freeze` type
 is [`RefCell<T>`][refcell].
 
 ~~~~
-let mut x = 5i;
+let mut x = 5;
 {
     let y = &x; // `x` is now frozen. It cannot be modified or re-assigned.
 }
@@ -1522,8 +1523,8 @@ Rust uses the unary star operator (`*`) to access the contents of a
 box or pointer, similarly to C.
 
 ~~~
-let owned = box 10i;
-let borrowed = &20i;
+let owned = box 10;
+let borrowed = &20;
 
 let sum = *owned + *borrowed;
 ~~~
@@ -1533,9 +1534,9 @@ assignments. Such an assignment modifies the value that the pointer
 points to.
 
 ~~~
-let mut owned = box 10i;
+let mut owned = box 10;
 
-let mut value = 20i;
+let mut value = 20;
 let borrowed = &mut value;
 
 *owned = *borrowed + 100;
@@ -1653,12 +1654,12 @@ Unicode code points, so they cannot be freely mutated without the ability to
 alter the length.
 
 ~~~
-let mut xs = [1i, 2i, 3i];
+let mut xs = [1, 2, 3];
 let view = xs.mut_slice(0, 2);
 view[0] = 5;
 
 // The type of a mutable slice is written as `&mut [T]`
-let ys: &mut [int] = &mut [1i, 2i, 3i];
+let ys: &mut [int] = &mut [1, 2, 3];
 ~~~
 
 Square brackets denote indexing into a slice or fixed-size vector:

branches/try2/src/liballoc/arc.rs

@@ -376,14 +376,14 @@ mod tests {
 
     #[test]
     fn test_live() {
-        let x = Arc::new(5i);
+        let x = Arc::new(5);
         let y = x.downgrade();
         assert!(y.upgrade().is_some());
     }
 
     #[test]
     fn test_dead() {
-        let x = Arc::new(5i);
+        let x = Arc::new(5);
         let y = x.downgrade();
         drop(x);
         assert!(y.upgrade().is_none());

branches/try2/src/liballoc/heap.rs

@@ -329,7 +329,7 @@ mod bench {
     #[bench]
     fn alloc_owned_small(b: &mut Bencher) {
         b.iter(|| {
-            box 10i
+            box 10
         })
     }
 }

branches/try2/src/libcollections/hash/mod.rs

@@ -342,12 +342,12 @@ mod tests {
         assert_eq!(hasher.hash(& &[1u8, 2u8, 3u8]), 9);
 
         unsafe {
-            let ptr: *const int = mem::transmute(5i);
+            let ptr: *const int = mem::transmute(5);
             assert_eq!(hasher.hash(&ptr), 5);
         }
 
         unsafe {
-            let ptr: *mut int = mem::transmute(5i);
+            let ptr: *mut int = mem::transmute(5);
             assert_eq!(hasher.hash(&ptr), 5);
         }
     }