---

yaml
---
r: 36845
b: refs/heads/try2
c: af5cd34
h: refs/heads/master
i:
  36843: 4367c05
v: v3

Author: brson

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: eb8fd119c65c67f3b1b8268cc7341c22d39b7b61
 refs/heads/try: d324a424d8f84b1eb049b12cf34182bda91b0024
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 42ab33e5725eea7bfbfd9bc579c3c63a261b684f
+refs/heads/try2: af5cd341d3c6719c02cd4869dc27a7d47aa2c0d5
 refs/heads/incoming: d9317a174e434d4c99fc1a37fd7dc0d2f5328d37
 refs/heads/dist-snap: 22efa39382d41b084fde1719df7ae8ce5697d8c9
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try2/doc/tutorial.md

@@ -1586,6 +1586,36 @@ s.draw_borrowed();
 (&@~s).draw_borrowed();
 ~~~
 
+Implementations may also define _static_ methods,
+which don't have an explicit `self` argument.
+The `static` keyword distinguishes static methods from methods that have a `self`:
+
+~~~~ {.xfail-test}
+impl Circle {
+    fn area(&self) -> float { ... }
+    static fn new(area: float) -> Circle { ... }
+}
+~~~~
+
+> ***Note***: In the future the `static` keyword will be removed and static methods
+> will be distinguished solely by the presence or absence of the `self` argument.
+> In the current langugage instance methods may also be declared without an explicit
+> `self` argument, in which case `self` is an implicit reference.
+> That form of method is deprecated.
+
+Constructors are one common application for static methods, as in `new` above.
+To call a static method, you have to prefix it with the type name and a double colon:
+
+~~~~
+# use float::consts::pi;
+# use float::sqrt;
+struct Circle { radius: float }
+impl Circle {
+    static fn new(area: float) -> Circle { Circle { radius: sqrt(area / pi) } }
+}
+let c = Circle::new(42.5);
+~~~~
+
 We'll discuss implementations more in the context of [traits and
 generics](#generics).
 
@@ -2113,6 +2143,29 @@ second parameter of type `self`.
 In contrast, in the `impl`, `equals` takes a second parameter of
 type `int`, only using `self` as the name of the receiver.
 
+Traits can also define static methods which are called by prefixing
+the method name with the trait name.
+The compiler will use type inference to decide which implementation to call.
+
+~~~~
+# trait Shape { static fn new(area: float) -> self; }
+# use float::consts::pi;
+# use float::sqrt;
+struct Circle { radius: float }
+struct Square { length: float }
+
+impl Circle: Shape {
+    static fn new(area: float) -> Circle { Circle { radius: sqrt(area / pi) } }
+}
+impl Square: Shape {
+     static fn new(area: float) -> Square { Square { length: sqrt(area) } }
+}
+
+let area = 42.5;
+let c: Circle = Shape::new(area);
+let s: Square = Shape::new(area);
+~~~~
+
 ## Bounded type parameters and static method dispatch
 
 Traits give us a language for defining predicates on types, or
@@ -2238,32 +2291,6 @@ select the method to call at runtime.
 
 This usage of traits is similar to Java interfaces.
 
-## Static methods
-
-Traits can define _static_ methods, which don't have an implicit `self` argument.
-The `static` keyword distinguishes static methods from methods that have a `self`:
-
-~~~~
-trait Shape {
-    fn area(&self) -> float;
-    static fn new_shape(area: float) -> Shape;
-}
-~~~~
-
-Constructors are one application for static methods, as in `new_shape` above.
-To call a static method, you have to prefix it with the trait name and a double colon:
-
-~~~~
-# trait Shape { static fn new_shape(area: float) -> self; }
-# use float::consts::pi;
-# use float::sqrt;
-struct Circle { radius: float }
-impl Circle: Shape {
-    static fn new_shape(area: float) -> Circle { Circle { radius: sqrt(area / pi) } }
-}
-let s: Circle = Shape::new_shape(42.5);
-~~~~
-
 ## Trait inheritance
 
 We can write a trait declaration that _inherits_ from other traits, called _supertraits_.