---

yaml
---
r: 149438
b: refs/heads/try2
c: 698042d
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: b734699df124e13bcb7054a892dad9dbd027c32f
+refs/heads/try2: 698042de238644341b798238bd5a61ea2f3c0f20
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/AUTHORS.txt

@@ -7,6 +7,7 @@ Adrien Tétar <[email protected]>
 Alan Andrade <[email protected]>
 Aleksander Balicki <[email protected]>
 Alex Crichton <[email protected]>
+Alex Lyon <[email protected]>
 Alex Rønne Petersen <[email protected]>
 Alexander Stavonin <[email protected]>
 Alexandros Tasos <[email protected]>

branches/try2/mk/crates.mk

@@ -50,21 +50,21 @@
 ################################################################################
 
 TARGET_CRATES := std extra green rustuv native flate arena glob term semver \
-                 uuid serialize sync getopts collections num test
+                 uuid serialize sync getopts collections num test time
 HOST_CRATES := syntax rustc rustdoc fourcc
 CRATES := $(TARGET_CRATES) $(HOST_CRATES)
 TOOLS := compiletest rustdoc rustc
 
 DEPS_std := native:rustrt native:compiler-rt
-DEPS_extra := std term sync serialize getopts collections
+DEPS_extra := std term sync serialize getopts collections time
 DEPS_green := std native:context_switch
 DEPS_rustuv := std native:uv native:uv_support
 DEPS_native := std
 DEPS_syntax := std term serialize collections
 DEPS_rustc := syntax native:rustllvm flate arena serialize sync getopts \
-              collections extra
+              collections time extra
 DEPS_rustdoc := rustc native:sundown serialize sync getopts collections \
-                test
+                test time
 DEPS_flate := std native:miniz
 DEPS_arena := std collections
 DEPS_glob := std
@@ -78,6 +78,7 @@ DEPS_collections := std serialize
 DEPS_fourcc := syntax std
 DEPS_num := std extra
 DEPS_test := std extra collections getopts serialize term
+DEPS_time := std serialize
 
 TOOL_DEPS_compiletest := test green rustuv getopts
 TOOL_DEPS_rustdoc := rustdoc green rustuv

branches/try2/src/doc/complement-cheatsheet.md

@@ -22,13 +22,14 @@ let y: int = x.unwrap();
 
 **Int to string, in non-base-10**
 
-Use [`ToStrRadix`](http://static.rust-lang.org/doc/master/std/num/trait.ToStrRadix.html).
+Use the `format!` syntax extension.
 
 ~~~
-use std::num::ToStrRadix;
-
 let x: int = 42;
-let y: ~str = x.to_str_radix(16);
+let y: ~str = format!("{:t}", x);   // binary
+let y: ~str = format!("{:o}", x);   // octal
+let y: ~str = format!("{:x}", x);   // lowercase hexadecimal
+let y: ~str = format!("{:X}", x);   // uppercase hexidecimal
 ~~~
 
 **String to int, in non-base-10**

branches/try2/src/doc/guide-macros.md

@@ -11,17 +11,17 @@ which both pattern-match on their input and both return early in one case,
 doing nothing otherwise:
 
 ~~~~
-# enum t { special_a(uint), special_b(uint) };
+# enum T { SpecialA(uint), SpecialB(uint) };
 # fn f() -> uint {
-# let input_1 = special_a(0);
-# let input_2 = special_a(0);
+# let input_1 = SpecialA(0);
+# let input_2 = SpecialA(0);
 match input_1 {
-    special_a(x) => { return x; }
+    SpecialA(x) => { return x; }
     _ => {}
 }
 // ...
 match input_2 {
-    special_b(x) => { return x; }
+    SpecialB(x) => { return x; }
     _ => {}
 }
 # return 0u;
@@ -37,22 +37,22 @@ lightweight custom syntax extensions, themselves defined using the
 the pattern in the above code:
 
 ~~~~
-# enum t { special_a(uint), special_b(uint) };
+# enum T { SpecialA(uint), SpecialB(uint) };
 # fn f() -> uint {
-# let input_1 = special_a(0);
-# let input_2 = special_a(0);
+# let input_1 = SpecialA(0);
+# let input_2 = SpecialA(0);
 macro_rules! early_return(
-    ($inp:expr $sp:ident) => ( // invoke it like `(input_5 special_e)`
+    ($inp:expr $sp:ident) => ( // invoke it like `(input_5 SpecialE)`
         match $inp {
             $sp(x) => { return x; }
             _ => {}
         }
     );
 )
 // ...
-early_return!(input_1 special_a);
+early_return!(input_1 SpecialA);
 // ...
-early_return!(input_2 special_b);
+early_return!(input_2 SpecialB);
 # return 0;
 # }
 ~~~~
@@ -155,10 +155,10 @@ separator token (a comma-separated list could be written `$(...),*`), and `+`
 instead of `*` to mean "at least one".
 
 ~~~~
-# enum t { special_a(uint),special_b(uint),special_c(uint),special_d(uint)};
+# enum T { SpecialA(uint),SpecialB(uint),SpecialC(uint),SpecialD(uint)};
 # fn f() -> uint {
-# let input_1 = special_a(0);
-# let input_2 = special_a(0);
+# let input_1 = SpecialA(0);
+# let input_2 = SpecialA(0);
 macro_rules! early_return(
     ($inp:expr, [ $($sp:ident)|+ ]) => (
         match $inp {
@@ -170,9 +170,9 @@ macro_rules! early_return(
     );
 )
 // ...
-early_return!(input_1, [special_a|special_c|special_d]);
+early_return!(input_1, [SpecialA|SpecialC|SpecialD]);
 // ...
-early_return!(input_2, [special_b]);
+early_return!(input_2, [SpecialB]);
 # return 0;
 # }
 ~~~~
@@ -215,14 +215,14 @@ solves the problem.
 Now consider code like the following:
 
 ~~~~
-# enum t1 { good_1(t2, uint), bad_1 };
-# struct t2 { body: t3 }
-# enum t3 { good_2(uint), bad_2};
-# fn f(x: t1) -> uint {
+# enum T1 { Good1(T2, uint), Bad1};
+# struct T2 { body: T3 }
+# enum T3 { Good2(uint), Bad2};
+# fn f(x: T1) -> uint {
 match x {
-    good_1(g1, val) => {
+    Good1(g1, val) => {
         match g1.body {
-            good_2(result) => {
+            Good2(result) => {
                 // complicated stuff goes here
                 return result + val;
             },
@@ -261,13 +261,13 @@ macro_rules! biased_match (
     )
 )
 
-# enum t1 { good_1(t2, uint), bad_1 };
-# struct t2 { body: t3 }
-# enum t3 { good_2(uint), bad_2};
-# fn f(x: t1) -> uint {
-biased_match!((x)       ~ (good_1(g1, val)) else { return 0 };
+# enum T1 { Good1(T2, uint), Bad1};
+# struct T2 { body: T3 }
+# enum T3 { Good2(uint), Bad2};
+# fn f(x: T1) -> uint {
+biased_match!((x)       ~ (Good1(g1, val)) else { return 0 };
               binds g1, val )
-biased_match!((g1.body) ~ (good_2(result) )
+biased_match!((g1.body) ~ (Good2(result) )
                   else { fail!("Didn't get good_2") };
               binds result )
 // complicated stuff goes here
@@ -365,13 +365,13 @@ macro_rules! biased_match (
 )
 
 
-# enum t1 { good_1(t2, uint), bad_1 };
-# struct t2 { body: t3 }
-# enum t3 { good_2(uint), bad_2};
-# fn f(x: t1) -> uint {
+# enum T1 { Good1(T2, uint), Bad1};
+# struct T2 { body: T3 }
+# enum T3 { Good2(uint), Bad2};
+# fn f(x: T1) -> uint {
 biased_match!(
-    (x)       ~ (good_1(g1, val)) else { return 0 };
-    (g1.body) ~ (good_2(result) ) else { fail!("Didn't get good_2") };
+    (x)       ~ (Good1(g1, val)) else { return 0 };
+    (g1.body) ~ (Good2(result) ) else { fail!("Didn't get Good2") };
     binds val, result )
 // complicated stuff goes here
 return result + val;

branches/try2/src/doc/rust.md

@@ -470,7 +470,7 @@ Two examples of paths with type arguments:
 # use std::hashmap::HashMap;
 # fn f() {
 # fn id<T>(t: T) -> T { t }
-type t = HashMap<int,~str>;  // Type arguments used in a type expression
+type T = HashMap<int,~str>;  // Type arguments used in a type expression
 let x = id::<int>(10);         // Type arguments used in a call expression
 # }
 ~~~~
@@ -701,7 +701,7 @@ An example of a module:
 
 ~~~~
 mod math {
-    type complex = (f64, f64);
+    type Complex = (f64, f64);
     fn sin(f: f64) -> f64 {
         ...
 # fail!();
@@ -752,35 +752,35 @@ mod task {
 #### View items
 
 ~~~~ {.ebnf .gram}
-view_item : extern_mod_decl | use_decl ;
+view_item : extern_crate_decl | use_decl ;
 ~~~~
 
 A view item manages the namespace of a module.
 View items do not define new items, but rather, simply change other items' visibility.
 There are several kinds of view item:
 
- * [`extern crate` declarations](#extern-mod-declarations)
+ * [`extern crate` declarations](#extern-crate-declarations)
  * [`use` declarations](#use-declarations)
 
-##### Extern mod declarations
+##### Extern crate declarations
 
 ~~~~ {.ebnf .gram}
-extern_mod_decl : "extern" "mod" ident [ '(' link_attrs ')' ] ? [ '=' string_lit ] ? ;
+extern_crate_decl : "extern" "crate" ident [ '(' link_attrs ')' ] ? [ '=' string_lit ] ? ;
 link_attrs : link_attr [ ',' link_attrs ] + ;
 link_attr : ident '=' literal ;
 ~~~~
 
 An _`extern crate` declaration_ specifies a dependency on an external crate.
-The external crate is then bound into the declaring scope
-as the `ident` provided in the `extern_mod_decl`.
+The external crate is then bound into the declaring scope as the `ident` provided
+in the `extern_crate_decl`.
 
 The external crate is resolved to a specific `soname` at compile time, and a
 runtime linkage requirement to that `soname` is passed to the linker for
 loading at runtime.  The `soname` is resolved at compile time by scanning the
 compiler's library path and matching the optional `crateid` provided as a string literal
 against the `crateid` attributes that were declared on the external crate when
 it was compiled.  If no `crateid` is provided, a default `name` attribute is
-assumed, equal to the `ident` given in the `extern_mod_decl`.
+assumed, equal to the `ident` given in the `extern_crate_decl`.
 
 Four examples of `extern crate` declarations:
 
@@ -813,7 +813,7 @@ module item. These declarations may appear at the top of [modules](#modules) and
 
 *Note*: Unlike in many languages,
 `use` declarations in Rust do *not* declare linkage dependency with external crates.
-Rather, [`extern crate` declarations](#extern-mod-declarations) declare linkage dependencies.
+Rather, [`extern crate` declarations](#extern-crate-declarations) declare linkage dependencies.
 
 Use declarations support a number of convenient shortcuts:
 
@@ -875,14 +875,14 @@ An example of what will and will not work for `use` items:
 
 ~~~~
 # #[allow(unused_imports)];
-use foo::extra;          // good: foo is at the root of the crate
+use foo::extra::json;    // good: foo is at the root of the crate
 use foo::baz::foobaz;    // good: foo is at the root of the crate
 
 mod foo {
     extern crate extra;
 
-    use foo::extra::time;  // good: foo is at crate root
-//  use extra::*;          // bad:  extra is not at the crate root
+    use foo::extra::json;  // good: foo is at crate root
+//  use extra::json::*;    // bad:  extra is not at the crate root
     use self::baz::foobaz; // good: self refers to module 'foo'
     use foo::bar::foobar;  // good: foo is at crate root
 
@@ -2824,13 +2824,13 @@ provided by an implementation of `std::iter::Iterator`.
 An example of a for loop over the contents of a vector:
 
 ~~~~
-# type foo = int;
-# fn bar(f: foo) { }
+# type Foo = int;
+# fn bar(f: Foo) { }
 # let a = 0;
 # let b = 0;
 # let c = 0;
 
-let v: &[foo] = &[a, b, c];
+let v: &[Foo] = &[a, b, c];
 
 for e in v.iter() {
     bar(*e);