---

yaml
---
r: 40958
b: refs/heads/dist-snap
c: 30fac74
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278
 refs/heads/incoming: e90142e536c150df0d9b4b2f11352152177509b5
-refs/heads/dist-snap: cbddd5ed3417dbdf6849a0ffb579cc2b0284d447
+refs/heads/dist-snap: 30fac74bf3c370173d9c2cf1e023a6128488f5db
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/doc/tutorial.md

@@ -128,7 +128,7 @@ we have a file `hello.rs` containing this program:
 
 ~~~~
 fn main() {
-    io::println("hello?");
+    core::io::println("hello?");
 }
 ~~~~
 
@@ -142,8 +142,8 @@ error. If you introduce an error into the program (for example, by changing
 an error message like this:
 
 ~~~~ {.notrust}
-hello.rs:2:4: 2:16 error: unresolved name: io::print_with_unicorns
-hello.rs:2     io::print_with_unicorns("hello?");
+hello.rs:2:4: 2:16 error: unresolved name: core::io::print_with_unicorns
+hello.rs:2     core::io::print_with_unicorns("hello?");
                ^~~~~~~~~~~~~~~~~~~~~~~
 ~~~~
 
@@ -180,20 +180,21 @@ JavaScript, C#, or PHP), Rust will feel familiar. Code is arranged
 in blocks delineated by curly braces; there are control structures
 for branching and looping, like the familiar `if` and `while`; function
 calls are written `myfunc(arg1, arg2)`; operators are written the same
-and mostly have the same precedence as in C; comments are again like C.
+and mostly have the same precedence as in C; comments are again like C;
+module names are separated with double-colon, `::`, as with C++.
 
 The main surface difference to be aware of is that the condition at
 the head of control structures like `if` and `while` do not require
 parentheses, while their bodies *must* be wrapped in
 braces. Single-statement, unbraced bodies are not allowed.
 
 ~~~~
-# fn recalibrate_universe() -> bool { true }
+# mod universe { fn recalibrate() -> bool { true } }
 fn main() {
     /* A simple loop */
     loop {
         // A tricky calculation
-        if recalibrate_universe() {
+        if universe::recalibrate() {
             return;
         }
     }
@@ -209,16 +210,11 @@ let hi = "hi";
 let mut count = 0;
 
 while count < 10 {
-    io::println(hi);
+    core::io::println(fmt!("count: %?", i));
     count += 1;
 }
 ~~~~
 
-The name of the function that prints a line of text, `io::println`, is
-qualified: it refers to the function named `println` that's defined in the
-module `io`. In Rust, a double colon separates parts of a
-qualified name. For more details, see the section on [crates](#crates).
-
 Although Rust can almost always infer the types of local variables, you
 can specify a variable's type by following it with a colon, then the type
 name. Constants, an the other hand, always require a type annotation.