Skip to content

Commit 3a00d93

Browse files
committed
---
yaml --- r: 151309 b: refs/heads/try2 c: 2be738a h: refs/heads/master i: 151307: 079e0c7 v: v3
1 parent 0c6cac1 commit 3a00d93

File tree

34 files changed

+1166
-186
lines changed

34 files changed

+1166
-186
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: f62c753b8f7879607204bcf77491cc81baf9c2dc
8+
refs/heads/try2: 2be738ae36600e562fcfc9ed938e183875cd72ad
99
refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
1010
refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
1111
refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/README.md

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,7 @@ documentation.
2020
## Building from Source
2121

2222
1. Make sure you have installed the dependencies:
23-
* `g++` 4.4 or `clang++` 3.x
23+
* `g++` 4.7 or `clang++` 3.x
2424
* `python` 2.6 or later (but not 3.x)
2525
* `perl` 5.0 or later
2626
* GNU `make` 3.81 or later

branches/try2/mk/crates.mk

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -51,7 +51,7 @@
5151

5252
TARGET_CRATES := libc std green rustuv native flate arena glob term semver \
5353
uuid serialize sync getopts collections num test time rand \
54-
workcache url log regex
54+
workcache url log regex graphviz
5555
HOST_CRATES := syntax rustc rustdoc fourcc hexfloat regex_macros
5656
CRATES := $(TARGET_CRATES) $(HOST_CRATES)
5757
TOOLS := compiletest rustdoc rustc
@@ -67,6 +67,7 @@ DEPS_rustdoc := rustc native:sundown serialize sync getopts collections \
6767
test time
6868
DEPS_flate := std native:miniz
6969
DEPS_arena := std collections
70+
DEPS_graphviz := std
7071
DEPS_glob := std
7172
DEPS_serialize := std collections log
7273
DEPS_term := std collections

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

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -186,7 +186,7 @@ enum List<T> {
186186
Nil,
187187
Cons(T, ~List<T>),
188188
}
189-
189+
190190
fn main() {
191191
let list: List<int> = Cons(1, ~Cons(2, ~Cons(3, ~Nil)));
192192
println!("{:?}", list);
@@ -251,7 +251,7 @@ struct.
251251

252252
> **Note**: the `@` form of managed pointers is deprecated and behind a
253253
> feature gate (it requires a `#![feature(managed_pointers)]` attribute on
254-
> the crate root; remember the semicolon!). There are replacements, currently
254+
> the crate root). There are replacements, currently
255255
> there is `std::rc::Rc` and `std::gc::Gc` for shared ownership via reference
256256
> counting and garbage collection respectively.
257257
@@ -266,7 +266,7 @@ struct Point {
266266
x: int,
267267
y: int,
268268
}
269-
269+
270270
fn main() {
271271
let a = ~Point { x: 10, y: 20 };
272272
let b = a;
@@ -297,7 +297,7 @@ struct Point {
297297
x: int,
298298
y: int,
299299
}
300-
300+
301301
fn main() {
302302
let a = @Point { x: 10, y: 20 };
303303
let b = a;
@@ -361,7 +361,7 @@ So how is this hard? Well, because we're ignoring ownership, the compiler needs
361361
to take great care to make sure that everything is safe. Despite their complete
362362
safety, a reference's representation at runtime is the same as that of
363363
an ordinary pointer in a C program. They introduce zero overhead. The compiler
364-
does all safety checks at compile time.
364+
does all safety checks at compile time.
365365

366366
This theory is called 'region pointers,' and involve a concept called
367367
'lifetimes'. Here's the simple explanation: would you expect this code to
@@ -477,7 +477,7 @@ fn main() {
477477
You may think that this gives us terrible performance: return a value and then
478478
immediately box it up?!?! Isn't that the worst of both worlds? Rust is smarter
479479
than that. There is no copy in this code. `main` allocates enough room for the
480-
`@int`, passes a pointer to that memory into `foo` as `x`, and then `foo` writes
480+
`@int`, passes a pointer to that memory into `foo` as `x`, and then `foo` writes
481481
the value straight into that pointer. This writes the return value directly into
482482
the allocated box.
483483

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

Lines changed: 3 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -48,13 +48,7 @@ concurrency at this writing:
4848
* [`std::task`] - All code relating to tasks and task scheduling,
4949
* [`std::comm`] - The message passing interface,
5050
* [`sync::DuplexStream`] - An extension of `pipes::stream` that allows both sending and receiving,
51-
* [`sync::SyncSender`] - An extension of `pipes::stream` that provides synchronous message sending,
52-
* [`sync::SyncReceiver`] - An extension of `pipes::stream` that acknowledges each message received,
53-
* [`sync::rendezvous`] - Creates a stream whose channel, upon sending a message, blocks until the
54-
message is received.
5551
* [`sync::Arc`] - The Arc (atomically reference counted) type, for safely sharing immutable data,
56-
* [`sync::RWArc`] - A dual-mode Arc protected by a reader-writer lock,
57-
* [`sync::MutexArc`] - An Arc with mutable data protected by a blocking mutex,
5852
* [`sync::Semaphore`] - A counting, blocking, bounded-waiting semaphore,
5953
* [`sync::Mutex`] - A blocking, bounded-waiting, mutual exclusion lock with an associated
6054
FIFO condition variable,
@@ -70,13 +64,8 @@ concurrency at this writing:
7064
[`std::task`]: std/task/index.html
7165
[`std::comm`]: std/comm/index.html
7266
[`sync::DuplexStream`]: sync/struct.DuplexStream.html
73-
[`sync::SyncSender`]: sync/struct.SyncSender.html
74-
[`sync::SyncReceiver`]: sync/struct.SyncReceiver.html
75-
[`sync::rendezvous`]: sync/fn.rendezvous.html
7667
[`sync::Arc`]: sync/struct.Arc.html
77-
[`sync::RWArc`]: sync/struct.RWArc.html
78-
[`sync::MutexArc`]: sync/struct.MutexArc.html
79-
[`sync::Semaphore`]: sync/struct.Semaphore.html
68+
[`sync::Semaphore`]: sync/raw/struct.Semaphore.html
8069
[`sync::Mutex`]: sync/struct.Mutex.html
8170
[`sync::RWLock`]: sync/struct.RWLock.html
8271
[`sync::Barrier`]: sync/struct.Barrier.html
@@ -101,6 +90,8 @@ fn print_message() { println!("I am running in a different task!"); }
10190
spawn(print_message);
10291
10392
// Print something more profound in a different task using a lambda expression
93+
// This uses the proc() keyword to assign to spawn a function with no name
94+
// That function will call println!(...) as requested
10495
spawn(proc() println!("I am also running in a different task!") );
10596
~~~~
10697

branches/try2/src/doc/tutorial.md

Lines changed: 83 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -90,7 +90,7 @@ supported build environments that are most likely to work.
9090
To build from source you will also need the following prerequisite
9191
packages:
9292

93-
* g++ 4.4 or clang++ 3.x
93+
* g++ 4.7 or clang++ 3.x
9494
* python 2.6 or later (but not 3.x)
9595
* perl 5.0 or later
9696
* gnu make 3.81 or later
@@ -1720,38 +1720,103 @@ environment (sometimes referred to as "capturing" variables in their
17201720
environment). For example, you couldn't write the following:
17211721
17221722
~~~~ {.ignore}
1723-
let foo = 10;
1723+
let x = 3;
17241724
1725-
fn bar() -> int {
1726-
return foo; // `bar` cannot refer to `foo`
1727-
}
1725+
// `fun` cannot refer to `x`
1726+
fn fun() -> () { println!("{}", x); }
17281727
~~~~
17291728
1730-
Rust also supports _closures_, functions that can access variables in
1731-
the enclosing scope.
1729+
A _closure_ does support accessing the enclosing scope; below we will create
1730+
2 _closures_ (nameless functions). Compare how `||` replaces `()` and how
1731+
they try to access `x`:
17321732
1733-
~~~~
1734-
fn call_closure_with_ten(b: |int|) { b(10); }
1733+
~~~~ {.ignore}
1734+
let x = 3;
17351735
1736-
let captured_var = 20;
1737-
let closure = |arg| println!("captured_var={}, arg={}", captured_var, arg);
1736+
// `fun` is an invalid definition
1737+
fn fun () -> () { println!("{}", x) } // cannot capture from enclosing scope
1738+
let closure = || -> () { println!("{}", x) }; // can capture from enclosing scope
17381739
1739-
call_closure_with_ten(closure);
1740+
// `fun_arg` is an invalid definition
1741+
fn fun_arg (arg: int) -> () { println!("{}", arg + x) } // cannot capture
1742+
let closure_arg = |arg: int| -> () { println!("{}", arg + x) }; // can capture
1743+
// ^
1744+
// Requires a type because the implementation needs to know which `+` to use.
1745+
// In the future, the implementation may not need the help.
1746+
1747+
fun(); // Still won't work
1748+
closure(); // Prints: 3
1749+
1750+
fun_arg(7); // Still won't work
1751+
closure_arg(7); // Prints: 10
17401752
~~~~
17411753
17421754
Closures begin with the argument list between vertical bars and are followed by
17431755
a single expression. Remember that a block, `{ <expr1>; <expr2>; ... }`, is
17441756
considered a single expression: it evaluates to the result of the last
17451757
expression it contains if that expression is not followed by a semicolon,
1746-
otherwise the block evaluates to `()`.
1758+
otherwise the block evaluates to `()`, the unit value.
1759+
1760+
In general, return types and all argument types must be specified
1761+
explicitly for function definitions. (As previously mentioned in the
1762+
[Functions section](#functions), omitting the return type from a
1763+
function declaration is synonymous with an explicit declaration of
1764+
return type unit, `()`.)
1765+
1766+
~~~~ {.ignore}
1767+
fn fun (x: int) { println!("{}", x) } // this is same as saying `-> ()`
1768+
fn square(x: int) -> uint { (x * x) as uint } // other return types are explicit
1769+
1770+
// Error: mismatched types: expected `()` but found `uint`
1771+
fn badfun(x: int) { (x * x) as uint }
1772+
~~~~
1773+
1774+
On the other hand, the compiler can usually infer both the argument
1775+
and return types for a closure expression; therefore they are often
1776+
omitted, since both a human reader and the compiler can deduce the
1777+
types from the immediate context. This is in contrast to function
1778+
declarations, which require types to be specified and are not subject
1779+
to type inference. Compare:
17471780
1748-
The types of the arguments are generally omitted, as is the return type,
1749-
because the compiler can almost always infer them. In the rare case where the
1750-
compiler needs assistance, though, the arguments and return types may be
1751-
annotated.
1781+
~~~~ {.ignore}
1782+
// `fun` as a function declaration cannot infer the type of `x`, so it must be provided
1783+
fn fun (x: int) { println!("{}", x) }
1784+
let closure = |x | { println!("{}", x) }; // infers `x: int`, return type `()`
1785+
1786+
// For closures, omitting a return type is *not* synonymous with `-> ()`
1787+
let add_3 = |y | { 3i + y }; // infers `y: int`, return type `int`.
1788+
1789+
fun(10); // Prints 10
1790+
closure(20); // Prints 20
1791+
closure(add_3(30)); // Prints 33
17521792
1793+
fun("String"); // Error: mismatched types
1794+
1795+
// Error: mismatched types
1796+
// inference already assigned `closure` the type `|int| -> ()`
1797+
closure("String");
17531798
~~~~
1754-
let square = |x: int| -> uint { (x * x) as uint };
1799+
1800+
In cases where the compiler needs assistance, the arguments and return
1801+
types may be annotated on closures, using the same notation as shown
1802+
earlier. In the example below, since different types provide an
1803+
implementation for the operator `*`, the argument type for the `x`
1804+
parameter must be explicitly provided.
1805+
1806+
~~~~{.ignore}
1807+
// Error: the type of `x` must be known to be used with `x * x`
1808+
let square = |x | -> uint { (x * x) as uint };
1809+
~~~~
1810+
1811+
In the corrected version, the argument type is explicitly annotated,
1812+
while the return type can still be inferred.
1813+
1814+
~~~~
1815+
let square_explicit = |x: int| -> uint { (x * x) as uint };
1816+
let square_infer = |x: int| { (x * x) as uint };
1817+
1818+
println!("{}", square_explicit(20)); // 400
1819+
println!("{}", square_infer(-20)); // 400
17551820
~~~~
17561821
17571822
There are several forms of closure, each with its own role. The most

branches/try2/src/etc/emacs/README.md

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -12,11 +12,12 @@ To install manually, check out this repository and add this to your
1212

1313
```lisp
1414
(add-to-list 'load-path "/path/to/rust-mode/")
15-
(require 'rust-mode)
15+
(autoload 'rust-mode "rust-mode" nil t)
16+
(add-to-list 'auto-mode-alist '("\\.rs\\'" . rust-mode))
1617
```
1718

18-
`rust-mode` will automatically be associated with `.rs` files. To enable it
19-
explicitly, do <kbd>M-x rust-mode</kbd>.
19+
This associates `rust-mode` with `.rs` files. To enable it explicitly, do
20+
<kbd>M-x rust-mode</kbd>.
2021

2122
### `package.el` installation via Marmalade or MELPA
2223

0 commit comments

Comments
 (0)