---

yaml
---
r: 22015
b: refs/heads/snap-stage3
c: 9902135
h: refs/heads/master
i:
  22013: aa4b997
  22011: fef3a52
  22007: 0380cc4
  21999: 8fb21a3
  21983: 4fdac0e
  21951: 1e3c60b
  21887: ba28000
  21759: 96ba8da
  21503: a413077
v: v3

Author: brson

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: e430a699f2c60890d9b86069fd0c68a70ece7120
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: dd9b6c97b908d31643daddc7bc375069898e7d06
+refs/heads/snap-stage3: 9902135bdd5c5ca3c3f04c39a4057c0d0244fc33
 refs/heads/try: ffbe0e0e00374358b789b0037bcb3a577cd218be
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/doc/tutorial.md

@@ -1712,6 +1712,29 @@ method declarations. So, re-declaring the type parameter
 `T` as an explicit type parameter for `len` -- in either the trait or
 the impl -- would be a compile-time error.
 
+Within a trait definition, `self` is a special type that you can think
+of as a type parameter. An implementation of the trait for any given
+type `T` replaces the `self` type parameter with `T`. Simply, in a
+trait, `self` is a type, and in an impl, `self` is a value. The
+following trait describes types that support an equality operation:
+
+~~~~
+// In a trait, `self` refers to the type implementing the trait
+trait Eq {
+  fn equals(other: &self) -> bool;
+}
+
+// In an impl, self refers to the value of the receiver
+impl int: Eq {
+  fn equals(other: &int) -> bool { *other == self }
+}
+~~~~
+
+Notice that in the trait definition, `equals` takes a `self` type
+argument, whereas, in the impl, `equals` takes an `int` type argument,
+and uses `self` as the name of the receiver (analogous to the `this` pointer
+in C++).
+
 ## Bounded type parameters and static method dispatch
 
 Traits give us a language for talking about the abstract capabilities
@@ -1753,7 +1776,7 @@ the preferred way to use traits polymorphically.
 
 This usage of traits is similar to Haskell type classes.
 
-## Casting to a trait type and dynamic dispatch
+## Casting to a trait type and dynamic method dispatch
 
 The above allows us to define functions that polymorphically act on
 values of a single unknown type that conforms to a given trait.
@@ -1836,31 +1859,6 @@ method to call.
 
 This usage of traits is similar to Java interfaces.
 
-## The `self` type
-
-In a trait, `self` is a special type that you can think of as a
-type parameter. An implementation of the trait for any given type
-`T` replaces the `self` type parameter with `T`. Simply, in a trait,
-`self` is a type, and in an impl, `self` is a value. The following
-trait describes types that support an equality operation:
-
-~~~~
-// In a trait, `self` refers to the type implementing the trait
-trait Eq {
-  fn equals(&&other: self) -> bool;
-}
-
-// In an impl, self refers to the value of the receiver
-impl int: Eq {
-  fn equals(&&other: int) -> bool { other == self }
-}
-~~~~
-
-Notice that in the trait definition, `equals` takes a `self` type
-argument, whereas, in the impl, `equals` takes an `int` type argument,
-and uses `self` as the name of the receiver (analogous to the `this` pointer
-in C++).
-
 # Modules and crates
 
 The Rust namespace is divided into modules. Each source file starts