---

yaml
---
r: 24101
b: refs/heads/master
c: 3b89dcb
h: refs/heads/master
i:
  24099: a9316fa
v: v3

Author: brson

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 4081b40523c7059a742dc11193fea7356495c614
+refs/heads/master: 3b89dcbdf2de3f757556639cd7323c60d343c4d2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
 refs/heads/try: ffbe0e0e00374358b789b0037bcb3a577cd218be

trunk/doc/tutorial.md

@@ -408,34 +408,30 @@ error. Read about [single-variant enums](#single_variant_enum)
 further on if you need to create a type name that's not just a
 synonym.
 
-## Numeric literals
+## Literals
 
 Integers can be written in decimal (`144`), hexadecimal (`0x90`), and
-binary (`0b10010000`) base.
+binary (`0b10010000`) base. Each integral type has a corresponding literal
+suffix that can be used to indicate the type of a literal: `i` for `int`,
+`u` for `uint`, and `i8` for the `i8` type, etc.
 
-If you write an integer literal without a suffix (`3`, `-500`, etc.),
-the Rust compiler will try to infer its type based on type annotations
-and function signatures in the surrounding program. In the absence of any type
-annotations at all, Rust will assume that an unsuffixed integer literal has
-type `int`. It's also possible to avoid any type ambiguity by writing integer
-literals with a suffix. For example:
+In the absense 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 assume that an unsuffixed integer literal has type
+`int`.
 
 ~~~~
-let x = 50;
-log(error, x); // x is an int
-let y = 100u;
-log(error, y); // y is an uint
+let a = 1;       // a is an int
+let b = 10i;     // b is an int, due to the 'i' suffix
+let c = 100u;    // c as a uint
+let d = 1000i32; // d is an i32
 ~~~~
 
-Note that, in Rust, no implicit conversion between integer types
-happens. If you are adding one to a variable of type `uint`, saying
-`+= 1u8` will give you a type error.
-
 Floating point numbers are written `0.0`, `1e6`, or `2.1e-4`. Without
-a suffix, the literal is assumed to be of type `float`. Suffixes `f` (32-bit)
-and `l` (64-bit) can be used to create literals of a specific type.
-
-## Other literals
+a suffix, the literal is assumed to be of type `float`. Suffixes `f32`
+(32-bit) and `f64` (64-bit) can be used to create literals of a
+specific type.
 
 The nil literal is written just like the type: `()`. The keywords
 `true` and `false` produce the boolean literals.