Skip to content

Commit 9b5f28e

Browse files
committed
---
yaml --- r: 149437 b: refs/heads/try2 c: b734699 h: refs/heads/master i: 149435: 901d783 v: v3
1 parent 86d45f9 commit 9b5f28e

File tree

138 files changed

+2437
-3202
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

138 files changed

+2437
-3202
lines changed

[refs]

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
55
refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
66
refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
77
refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
8-
refs/heads/try2: 56cf237ee24df51acc05634c962cd20a66477fa4
8+
refs/heads/try2: b734699df124e13bcb7054a892dad9dbd027c32f
99
refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
1010
refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
1111
refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/AUTHORS.txt

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,6 @@ Adrien Tétar <[email protected]>
77
Alan Andrade <[email protected]>
88
Aleksander Balicki <[email protected]>
99
Alex Crichton <[email protected]>
10-
Alex Lyon <[email protected]>
1110
Alex Rønne Petersen <[email protected]>
1211
Alexander Stavonin <[email protected]>
1312
Alexandros Tasos <[email protected]>

branches/try2/mk/crates.mk

Lines changed: 4 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -50,21 +50,21 @@
5050
################################################################################
5151

5252
TARGET_CRATES := std extra green rustuv native flate arena glob term semver \
53-
uuid serialize sync getopts collections num test time
53+
uuid serialize sync getopts collections num test
5454
HOST_CRATES := syntax rustc rustdoc fourcc
5555
CRATES := $(TARGET_CRATES) $(HOST_CRATES)
5656
TOOLS := compiletest rustdoc rustc
5757

5858
DEPS_std := native:rustrt native:compiler-rt
59-
DEPS_extra := std term sync serialize getopts collections time
59+
DEPS_extra := std term sync serialize getopts collections
6060
DEPS_green := std native:context_switch
6161
DEPS_rustuv := std native:uv native:uv_support
6262
DEPS_native := std
6363
DEPS_syntax := std term serialize collections
6464
DEPS_rustc := syntax native:rustllvm flate arena serialize sync getopts \
65-
collections time extra
65+
collections extra
6666
DEPS_rustdoc := rustc native:sundown serialize sync getopts collections \
67-
test time
67+
test
6868
DEPS_flate := std native:miniz
6969
DEPS_arena := std collections
7070
DEPS_glob := std
@@ -78,7 +78,6 @@ DEPS_collections := std serialize
7878
DEPS_fourcc := syntax std
7979
DEPS_num := std extra
8080
DEPS_test := std extra collections getopts serialize term
81-
DEPS_time := std serialize
8281

8382
TOOL_DEPS_compiletest := test green rustuv getopts
8483
TOOL_DEPS_rustdoc := rustdoc green rustuv

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

Lines changed: 4 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -22,14 +22,13 @@ let y: int = x.unwrap();
2222

2323
**Int to string, in non-base-10**
2424

25-
Use the `format!` syntax extension.
25+
Use [`ToStrRadix`](http://static.rust-lang.org/doc/master/std/num/trait.ToStrRadix.html).
2626

2727
~~~
28+
use std::num::ToStrRadix;
29+
2830
let x: int = 42;
29-
let y: ~str = format!("{:t}", x); // binary
30-
let y: ~str = format!("{:o}", x); // octal
31-
let y: ~str = format!("{:x}", x); // lowercase hexadecimal
32-
let y: ~str = format!("{:X}", x); // uppercase hexidecimal
31+
let y: ~str = x.to_str_radix(16);
3332
~~~
3433

3534
**String to int, in non-base-10**

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

Lines changed: 34 additions & 34 deletions
Original file line numberDiff line numberDiff line change
@@ -11,17 +11,17 @@ which both pattern-match on their input and both return early in one case,
1111
doing nothing otherwise:
1212

1313
~~~~
14-
# enum T { SpecialA(uint), SpecialB(uint) };
14+
# enum t { special_a(uint), special_b(uint) };
1515
# fn f() -> uint {
16-
# let input_1 = SpecialA(0);
17-
# let input_2 = SpecialA(0);
16+
# let input_1 = special_a(0);
17+
# let input_2 = special_a(0);
1818
match input_1 {
19-
SpecialA(x) => { return x; }
19+
special_a(x) => { return x; }
2020
_ => {}
2121
}
2222
// ...
2323
match input_2 {
24-
SpecialB(x) => { return x; }
24+
special_b(x) => { return x; }
2525
_ => {}
2626
}
2727
# return 0u;
@@ -37,22 +37,22 @@ lightweight custom syntax extensions, themselves defined using the
3737
the pattern in the above code:
3838

3939
~~~~
40-
# enum T { SpecialA(uint), SpecialB(uint) };
40+
# enum t { special_a(uint), special_b(uint) };
4141
# fn f() -> uint {
42-
# let input_1 = SpecialA(0);
43-
# let input_2 = SpecialA(0);
42+
# let input_1 = special_a(0);
43+
# let input_2 = special_a(0);
4444
macro_rules! early_return(
45-
($inp:expr $sp:ident) => ( // invoke it like `(input_5 SpecialE)`
45+
($inp:expr $sp:ident) => ( // invoke it like `(input_5 special_e)`
4646
match $inp {
4747
$sp(x) => { return x; }
4848
_ => {}
4949
}
5050
);
5151
)
5252
// ...
53-
early_return!(input_1 SpecialA);
53+
early_return!(input_1 special_a);
5454
// ...
55-
early_return!(input_2 SpecialB);
55+
early_return!(input_2 special_b);
5656
# return 0;
5757
# }
5858
~~~~
@@ -155,10 +155,10 @@ separator token (a comma-separated list could be written `$(...),*`), and `+`
155155
instead of `*` to mean "at least one".
156156

157157
~~~~
158-
# enum T { SpecialA(uint),SpecialB(uint),SpecialC(uint),SpecialD(uint)};
158+
# enum t { special_a(uint),special_b(uint),special_c(uint),special_d(uint)};
159159
# fn f() -> uint {
160-
# let input_1 = SpecialA(0);
161-
# let input_2 = SpecialA(0);
160+
# let input_1 = special_a(0);
161+
# let input_2 = special_a(0);
162162
macro_rules! early_return(
163163
($inp:expr, [ $($sp:ident)|+ ]) => (
164164
match $inp {
@@ -170,9 +170,9 @@ macro_rules! early_return(
170170
);
171171
)
172172
// ...
173-
early_return!(input_1, [SpecialA|SpecialC|SpecialD]);
173+
early_return!(input_1, [special_a|special_c|special_d]);
174174
// ...
175-
early_return!(input_2, [SpecialB]);
175+
early_return!(input_2, [special_b]);
176176
# return 0;
177177
# }
178178
~~~~
@@ -215,14 +215,14 @@ solves the problem.
215215
Now consider code like the following:
216216

217217
~~~~
218-
# enum T1 { Good1(T2, uint), Bad1};
219-
# struct T2 { body: T3 }
220-
# enum T3 { Good2(uint), Bad2};
221-
# fn f(x: T1) -> uint {
218+
# enum t1 { good_1(t2, uint), bad_1 };
219+
# struct t2 { body: t3 }
220+
# enum t3 { good_2(uint), bad_2};
221+
# fn f(x: t1) -> uint {
222222
match x {
223-
Good1(g1, val) => {
223+
good_1(g1, val) => {
224224
match g1.body {
225-
Good2(result) => {
225+
good_2(result) => {
226226
// complicated stuff goes here
227227
return result + val;
228228
},
@@ -261,13 +261,13 @@ macro_rules! biased_match (
261261
)
262262
)
263263
264-
# enum T1 { Good1(T2, uint), Bad1};
265-
# struct T2 { body: T3 }
266-
# enum T3 { Good2(uint), Bad2};
267-
# fn f(x: T1) -> uint {
268-
biased_match!((x) ~ (Good1(g1, val)) else { return 0 };
264+
# enum t1 { good_1(t2, uint), bad_1 };
265+
# struct t2 { body: t3 }
266+
# enum t3 { good_2(uint), bad_2};
267+
# fn f(x: t1) -> uint {
268+
biased_match!((x) ~ (good_1(g1, val)) else { return 0 };
269269
binds g1, val )
270-
biased_match!((g1.body) ~ (Good2(result) )
270+
biased_match!((g1.body) ~ (good_2(result) )
271271
else { fail!("Didn't get good_2") };
272272
binds result )
273273
// complicated stuff goes here
@@ -365,13 +365,13 @@ macro_rules! biased_match (
365365
)
366366
367367
368-
# enum T1 { Good1(T2, uint), Bad1};
369-
# struct T2 { body: T3 }
370-
# enum T3 { Good2(uint), Bad2};
371-
# fn f(x: T1) -> uint {
368+
# enum t1 { good_1(t2, uint), bad_1 };
369+
# struct t2 { body: t3 }
370+
# enum t3 { good_2(uint), bad_2};
371+
# fn f(x: t1) -> uint {
372372
biased_match!(
373-
(x) ~ (Good1(g1, val)) else { return 0 };
374-
(g1.body) ~ (Good2(result) ) else { fail!("Didn't get Good2") };
373+
(x) ~ (good_1(g1, val)) else { return 0 };
374+
(g1.body) ~ (good_2(result) ) else { fail!("Didn't get good_2") };
375375
binds val, result )
376376
// complicated stuff goes here
377377
return result + val;

branches/try2/src/doc/rust.md

Lines changed: 16 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -470,7 +470,7 @@ Two examples of paths with type arguments:
470470
# use std::hashmap::HashMap;
471471
# fn f() {
472472
# fn id<T>(t: T) -> T { t }
473-
type T = HashMap<int,~str>; // Type arguments used in a type expression
473+
type t = HashMap<int,~str>; // Type arguments used in a type expression
474474
let x = id::<int>(10); // Type arguments used in a call expression
475475
# }
476476
~~~~
@@ -701,7 +701,7 @@ An example of a module:
701701

702702
~~~~
703703
mod math {
704-
type Complex = (f64, f64);
704+
type complex = (f64, f64);
705705
fn sin(f: f64) -> f64 {
706706
...
707707
# fail!();
@@ -752,35 +752,35 @@ mod task {
752752
#### View items
753753

754754
~~~~ {.ebnf .gram}
755-
view_item : extern_crate_decl | use_decl ;
755+
view_item : extern_mod_decl | use_decl ;
756756
~~~~
757757

758758
A view item manages the namespace of a module.
759759
View items do not define new items, but rather, simply change other items' visibility.
760760
There are several kinds of view item:
761761

762-
* [`extern crate` declarations](#extern-crate-declarations)
762+
* [`extern crate` declarations](#extern-mod-declarations)
763763
* [`use` declarations](#use-declarations)
764764

765-
##### Extern crate declarations
765+
##### Extern mod declarations
766766

767767
~~~~ {.ebnf .gram}
768-
extern_crate_decl : "extern" "crate" ident [ '(' link_attrs ')' ] ? [ '=' string_lit ] ? ;
768+
extern_mod_decl : "extern" "mod" ident [ '(' link_attrs ')' ] ? [ '=' string_lit ] ? ;
769769
link_attrs : link_attr [ ',' link_attrs ] + ;
770770
link_attr : ident '=' literal ;
771771
~~~~
772772

773773
An _`extern crate` declaration_ specifies a dependency on an external crate.
774-
The external crate is then bound into the declaring scope as the `ident` provided
775-
in the `extern_crate_decl`.
774+
The external crate is then bound into the declaring scope
775+
as the `ident` provided in the `extern_mod_decl`.
776776

777777
The external crate is resolved to a specific `soname` at compile time, and a
778778
runtime linkage requirement to that `soname` is passed to the linker for
779779
loading at runtime. The `soname` is resolved at compile time by scanning the
780780
compiler's library path and matching the optional `crateid` provided as a string literal
781781
against the `crateid` attributes that were declared on the external crate when
782782
it was compiled. If no `crateid` is provided, a default `name` attribute is
783-
assumed, equal to the `ident` given in the `extern_crate_decl`.
783+
assumed, equal to the `ident` given in the `extern_mod_decl`.
784784

785785
Four examples of `extern crate` declarations:
786786

@@ -813,7 +813,7 @@ module item. These declarations may appear at the top of [modules](#modules) and
813813

814814
*Note*: Unlike in many languages,
815815
`use` declarations in Rust do *not* declare linkage dependency with external crates.
816-
Rather, [`extern crate` declarations](#extern-crate-declarations) declare linkage dependencies.
816+
Rather, [`extern crate` declarations](#extern-mod-declarations) declare linkage dependencies.
817817

818818
Use declarations support a number of convenient shortcuts:
819819

@@ -875,14 +875,14 @@ An example of what will and will not work for `use` items:
875875

876876
~~~~
877877
# #[allow(unused_imports)];
878-
use foo::extra::json; // good: foo is at the root of the crate
878+
use foo::extra; // good: foo is at the root of the crate
879879
use foo::baz::foobaz; // good: foo is at the root of the crate
880880
881881
mod foo {
882882
extern crate extra;
883883
884-
use foo::extra::json; // good: foo is at crate root
885-
// use extra::json::*; // bad: extra is not at the crate root
884+
use foo::extra::time; // good: foo is at crate root
885+
// use extra::*; // bad: extra is not at the crate root
886886
use self::baz::foobaz; // good: self refers to module 'foo'
887887
use foo::bar::foobar; // good: foo is at crate root
888888
@@ -2824,13 +2824,13 @@ provided by an implementation of `std::iter::Iterator`.
28242824
An example of a for loop over the contents of a vector:
28252825

28262826
~~~~
2827-
# type Foo = int;
2828-
# fn bar(f: Foo) { }
2827+
# type foo = int;
2828+
# fn bar(f: foo) { }
28292829
# let a = 0;
28302830
# let b = 0;
28312831
# let c = 0;
28322832
2833-
let v: &[Foo] = &[a, b, c];
2833+
let v: &[foo] = &[a, b, c];
28342834
28352835
for e in v.iter() {
28362836
bar(*e);

0 commit comments

Comments
 (0)