---

yaml
---
r: 32763
b: refs/heads/dist-snap
c: 3b89dcb
h: refs/heads/master
i:
  32761: f392917
  32759: bd2df74
v: v3

Author: brson

[refs]

@@ -7,6 +7,6 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
 refs/heads/incoming: d9317a174e434d4c99fc1a37fd7dc0d2f5328d37
-refs/heads/dist-snap: 4081b40523c7059a742dc11193fea7356495c614
+refs/heads/dist-snap: 3b89dcbdf2de3f757556639cd7323c60d343c4d2
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/dist-snap/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.