---

yaml
---
r: 20527
b: refs/heads/snap-stage3
c: ac9cf98
h: refs/heads/master
i:
  20525: 0e635fe
  20523: 900f80a
  20519: ea63633
  20511: 09c86b5
v: v3

Author: catamorphism

[refs]

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

branches/snap-stage3/doc/tutorial.md

@@ -2504,22 +2504,33 @@ needed because it could also, for example, specify an implementation
 of `seq<int>`—the `of` clause *refers* to a type, rather than defining
 one.
 
-Note that functions do not explicitly have the type parameters that 
-are provided by the iface. It will cause a compile-time error if you
-include them in the iface or impl.
+The type parameters bound by an iface are in scope in each of the
+method declarations. So, re-declaring the type parameter
+`T` as an explicit type parameter for `len` -- in either the iface or
+the impl -- would be a compile-time error.
 
-## Use of the type `self` in interfaces
+## The `self` type in interfaces
 
-Interfaces may use `self` as a type where the implementation uses its
-own type. This defines an interface for testing equality of a type with
-itself:
+In an interface, `self` is a special type that you can think of as a
+type parameter. An implementation of the interface for any given type
+`T` replaces the `self` type parameter with `T`. The following
+interface describes types that support an equality operation:
 
 ~~~~
 iface eq {
   fn equals(other: self) -> bool;
 }
 ~~~~
 
+In an implementation for type `int`, the `equals` method takes an
+`int` argument:
+
+~~~~
+impl of eq for int {
+  fn equals(other: int) { other == self }
+}
+~~~~
+
 ## Casting to an interface type
 
 The above allows us to define functions that polymorphically act on