---

yaml
---
r: 30723
b: refs/heads/incoming
c: 9902135
h: refs/heads/master
i:
  30721: a6d18b8
  30719: 6c92920
v: v3

Author: brson

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: d324a424d8f84b1eb049b12cf34182bda91b0024
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
-refs/heads/incoming: dd9b6c97b908d31643daddc7bc375069898e7d06
+refs/heads/incoming: 9902135bdd5c5ca3c3f04c39a4057c0d0244fc33
 refs/heads/dist-snap: 2f32a1581f522e524009138b33b1c7049ced668d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/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