@@ -90,7 +90,7 @@ supported build environments that are most likely to work.
9090To build from source you will also need the following prerequisite
9191packages:
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
@@ -468,19 +468,16 @@ Unlike in C, there is no "falling through" between arms: only one arm
468468executes, and it doesn't have to explicitly ` break ` out of the
469469construct when it is finished.
470470
471- A ` match ` arm consists of a * pattern* , then an arrow ` => ` , followed by
472- an * action* (expression). Literals are valid patterns and match only
473- their own value. A single arm may match multiple different patterns by
474- combining them with the pipe operator (` | ` ), so long as every pattern
475- binds the same set of variables. Ranges of numeric literal patterns
476- can be expressed with two dots, as in ` M..N ` . The underscore (` _ ` ) is
477- a wildcard pattern that matches any single value. (` .. ` ) is a different
478- wildcard that can match one or more fields in an ` enum ` variant.
479-
480- The patterns in a match arm are followed by a fat arrow, ` => ` , then an
481- expression to evaluate. Each case is separated by commas. It's often
482- convenient to use a block expression for each case, in which case the
483- commas are optional.
471+ A ` match ` arm consists of a * pattern* , then a fat arrow ` => ` , followed
472+ by an * action* (expression). Each case is separated by commas. It is
473+ often convenient to use a block expression for each case, in which case
474+ the commas are optional as shown below. Literals are valid patterns and
475+ match only their own value. A single arm may match multiple different
476+ patterns by combining them with the pipe operator (` | ` ), so long as every
477+ pattern binds the same set of variables. Ranges of numeric literal
478+ patterns can be expressed with two dots, as in ` M..N ` . The underscore
479+ (` _ ` ) is a wildcard pattern that matches any single value. (` .. ` ) is a
480+ different wildcard that can match one or more fields in an ` enum ` variant.
484481
485482~~~
486483# let my_number = 1;
@@ -1416,7 +1413,7 @@ contains a point, but allocated in a different location:
14161413
14171414~~~
14181415# struct Point { x: f64, y: f64 }
1419- let on_the_stack : Point = Point { x: 3.0, y: 4.0 };
1416+ let on_the_stack : Point = Point { x: 3.0, y: 4.0 };
14201417let owned_box : ~ Point = ~ Point { x: 7.0, y: 9.0 };
14211418~~~
14221419
@@ -1720,38 +1717,103 @@ environment (sometimes referred to as "capturing" variables in their
17201717environment). For example, you couldn't write the following:
17211718
17221719~~~~ {.ignore}
1723- let foo = 10 ;
1720+ let x = 3 ;
17241721
1725- fn bar() -> int {
1726- return foo; // `bar` cannot refer to `foo`
1727- }
1722+ // `fun` cannot refer to `x`
1723+ fn fun() -> () { println!("{}", x); }
17281724~~~~
17291725
1730- Rust also supports _closures_, functions that can access variables in
1731- the enclosing scope.
1726+ A _closure_ does support accessing the enclosing scope; below we will create
1727+ 2 _closures_ (nameless functions). Compare how `||` replaces `()` and how
1728+ they try to access `x`:
17321729
1733- ~~~~
1734- fn call_closure_with_ten(b: |int|) { b(10); }
1730+ ~~~~ {.ignore}
1731+ let x = 3;
17351732
1736- let captured_var = 20;
1737- let closure = |arg| println!("captured_var={}, arg={}", captured_var, arg);
1733+ // `fun` is an invalid definition
1734+ fn fun () -> () { println!("{}", x) } // cannot capture from enclosing scope
1735+ let closure = || -> () { println!("{}", x) }; // can capture from enclosing scope
17381736
1739- call_closure_with_ten(closure);
1737+ // `fun_arg` is an invalid definition
1738+ fn fun_arg (arg: int) -> () { println!("{}", arg + x) } // cannot capture
1739+ let closure_arg = |arg: int| -> () { println!("{}", arg + x) }; // can capture
1740+ // ^
1741+ // Requires a type because the implementation needs to know which `+` to use.
1742+ // In the future, the implementation may not need the help.
1743+
1744+ fun(); // Still won't work
1745+ closure(); // Prints: 3
1746+
1747+ fun_arg(7); // Still won't work
1748+ closure_arg(7); // Prints: 10
17401749~~~~
17411750
17421751Closures begin with the argument list between vertical bars and are followed by
17431752a single expression. Remember that a block, `{ <expr1>; <expr2>; ... }`, is
17441753considered a single expression: it evaluates to the result of the last
17451754expression it contains if that expression is not followed by a semicolon,
1746- otherwise the block evaluates to `()`.
1755+ otherwise the block evaluates to `()`, the unit value.
1756+
1757+ In general, return types and all argument types must be specified
1758+ explicitly for function definitions. (As previously mentioned in the
1759+ [Functions section](#functions), omitting the return type from a
1760+ function declaration is synonymous with an explicit declaration of
1761+ return type unit, `()`.)
17471762
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.
1763+ ~~~~ {.ignore}
1764+ fn fun (x: int) { println!("{}", x) } // this is same as saying `-> ()`
1765+ fn square(x: int) -> uint { (x * x) as uint } // other return types are explicit
17521766
1767+ // Error: mismatched types: expected `()` but found `uint`
1768+ fn badfun(x: int) { (x * x) as uint }
17531769~~~~
1754- let square = |x: int| -> uint { (x * x) as uint };
1770+
1771+ On the other hand, the compiler can usually infer both the argument
1772+ and return types for a closure expression; therefore they are often
1773+ omitted, since both a human reader and the compiler can deduce the
1774+ types from the immediate context. This is in contrast to function
1775+ declarations, which require types to be specified and are not subject
1776+ to type inference. Compare:
1777+
1778+ ~~~~ {.ignore}
1779+ // `fun` as a function declaration cannot infer the type of `x`, so it must be provided
1780+ fn fun (x: int) { println!("{}", x) }
1781+ let closure = |x | { println!("{}", x) }; // infers `x: int`, return type `()`
1782+
1783+ // For closures, omitting a return type is *not* synonymous with `-> ()`
1784+ let add_3 = |y | { 3i + y }; // infers `y: int`, return type `int`.
1785+
1786+ fun(10); // Prints 10
1787+ closure(20); // Prints 20
1788+ closure(add_3(30)); // Prints 33
1789+
1790+ fun("String"); // Error: mismatched types
1791+
1792+ // Error: mismatched types
1793+ // inference already assigned `closure` the type `|int| -> ()`
1794+ closure("String");
1795+ ~~~~
1796+
1797+ In cases where the compiler needs assistance, the arguments and return
1798+ types may be annotated on closures, using the same notation as shown
1799+ earlier. In the example below, since different types provide an
1800+ implementation for the operator `*`, the argument type for the `x`
1801+ parameter must be explicitly provided.
1802+
1803+ ~~~~{.ignore}
1804+ // Error: the type of `x` must be known to be used with `x * x`
1805+ let square = |x | -> uint { (x * x) as uint };
1806+ ~~~~
1807+
1808+ In the corrected version, the argument type is explicitly annotated,
1809+ while the return type can still be inferred.
1810+
1811+ ~~~~
1812+ let square_explicit = |x: int| -> uint { (x * x) as uint };
1813+ let square_infer = |x: int| { (x * x) as uint };
1814+
1815+ println!("{}", square_explicit(20)); // 400
1816+ println!("{}", square_infer(-20)); // 400
17551817~~~~
17561818
17571819There are several forms of closure, each with its own role. The most
@@ -2522,11 +2584,18 @@ for `Eq` and can be used with the equality operators, and that a value
25222584of type ` ABC ` can be randomly generated and converted to a string:
25232585
25242586~~~
2587+ extern crate rand;
2588+
25252589#[deriving(Eq)]
25262590struct Circle { radius: f64 }
25272591
2528- #[deriving(Clone , Show)]
2592+ #[deriving(Rand , Show)]
25292593enum ABC { A, B, C }
2594+
2595+ fn main() {
2596+ // Use the Show trait to print "A, B, C."
2597+ println!("{}, {}, {}", A, B, C);
2598+ }
25302599~~~
25312600
25322601The full list of derivable traits is ` Eq ` , ` TotalEq ` , ` Ord ` ,
0 commit comments