---

yaml
---
r: 210591
b: refs/heads/try
c: 5b0e197
h: refs/heads/master
i:
  210589: 71e3424
  210587: a75897f
  210583: fd6aa6e
  210575: 20d4d2d
  210559: a6b45e6
v: v3

Author: jooert

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 3e561f05c00cd180ec02db4ccab2840a4aba93d2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ba0e1cd8147d452c356aacb29fb87568ca26f111
-refs/heads/try: f697041b37e8c9c86dfe463262501ad61dd2d4a3
+refs/heads/try: 5b0e19794efe6d2d7f225df57505205627103f32
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try/src/doc/grammar.md

@@ -253,7 +253,7 @@ The two values of the boolean type are written `true` and `false`.
 ### Symbols
 
 ```antlr
-symbol : "::" | "->"
+symbol : "::" "->"
        | '#' | '[' | ']' | '(' | ')' | '{' | '}'
        | ',' | ';' ;
 ```
@@ -304,7 +304,7 @@ transcriber : '(' transcriber * ')' | '[' transcriber * ']'
 ## Items
 
 ```antlr
-item : vis ? mod_item | fn_item | type_item | struct_item | enum_item
+item : mod_item | fn_item | type_item | struct_item | enum_item
      | const_item | static_item | trait_item | impl_item | extern_block ;
 ```
 
@@ -322,7 +322,7 @@ mod : [ view_item | item ] * ;
 #### View items
 
 ```antlr
-view_item : extern_crate_decl | use_decl ';' ;
+view_item : extern_crate_decl | use_decl ;
 ```
 
 ##### Extern crate declarations
@@ -335,14 +335,14 @@ crate_name: ident | ( ident "as" ident )
 ##### Use declarations
 
 ```antlr
-use_decl : vis ? "use" [ path "as" ident
-                        | path_glob ] ;
+use_decl : "pub" ? "use" [ path "as" ident
+                          | path_glob ] ;
 
 path_glob : ident [ "::" [ path_glob
                           | '*' ] ] ?
           | '{' path_item [ ',' path_item ] * '}' ;
 
-path_item : ident | "self" ;
+path_item : ident | "mod" ;
 ```
 
 ### Functions
@@ -414,17 +414,16 @@ extern_block : [ foreign_fn ] * ;
 
 ## Visibility and Privacy
 
-```antlr
-vis : "pub" ;
-```
+**FIXME:** grammar?
+
 ### Re-exporting and Visibility
 
-See [Use declarations](#use-declarations).
+**FIXME:** grammar?
 
 ## Attributes
 
 ```antlr
-attribute : '#' '!' ? '[' meta_item ']' ;
+attribute : "#!" ? '[' meta_item ']' ;
 meta_item : ident [ '=' literal
                   | '(' meta_seq ')' ] ? ;
 meta_seq : meta_item [ ',' meta_seq ] ? ;
@@ -434,19 +433,26 @@ meta_seq : meta_item [ ',' meta_seq ] ? ;
 
 ## Statements
 
-```antlr
-stmt : decl_stmt | expr_stmt ;
-```
+**FIXME:** grammar?
 
 ### Declaration statements
 
-```antlr
-decl_stmt : item | let_decl ;
-```
+**FIXME:** grammar?
+
+A _declaration statement_ is one that introduces one or more *names* into the
+enclosing statement block. The declared names may denote new variables or new
+items.
 
 #### Item declarations
 
-See [Items](#items).
+**FIXME:** grammar?
+
+An _item declaration statement_ has a syntactic form identical to an
+[item](#items) declaration within a module. Declaring an item — a
+function, enumeration, structure, type, static, trait, implementation or module
+— locally within a statement block is simply a way of restricting its
+scope to a narrow region containing all of its uses; it is otherwise identical
+in meaning to declaring the item outside the statement block.
 
 #### Variable declarations
 
@@ -457,21 +463,11 @@ init : [ '=' ] expr ;
 
 ### Expression statements
 
-```antlr
-expr_stmt : expr ';' ;
-```
+**FIXME:** grammar?
 
 ## Expressions
 
-```antlr
-expr : literal | path | tuple_expr | unit_expr | struct_expr
-     | block_expr | method_call_expr | field_expr | array_expr
-     | idx_expr | range_expr | unop_expr | binop_expr
-     | paren_expr | call_expr | lambda_expr | while_expr
-     | loop_expr | break_expr | continue_expr | for_expr
-     | if_expr | match_expr | if_let_expr | while_let_expr
-     | return_expr ;
-```
+**FIXME:** grammar?
 
 #### Lvalues, rvalues and temporaries
 
@@ -483,23 +479,19 @@ expr : literal | path | tuple_expr | unit_expr | struct_expr
 
 ### Literal expressions
 
-See [Literals](#literals).
+**FIXME:** grammar?
 
 ### Path expressions
 
-See [Paths](#paths).
+**FIXME:** grammar?
 
 ### Tuple expressions
 
-```antlr
-tuple_expr : '(' [ expr [ ',' expr ] * | expr ',' ] ? ')' ;
-```
+**FIXME:** grammar?
 
 ### Unit expressions
 
-```antlr
-unit_expr : "()" ;
-```
+**FIXME:** grammar?
 
 ### Structure expressions
 
@@ -515,7 +507,8 @@ struct_expr : expr_path '{' ident ':' expr
 ### Block expressions
 
 ```antlr
-block_expr : '{' [ stmt ';' | item ] *
+block_expr : '{' [ view_item ] *
+                 [ stmt ';' | item ] *
                  [ expr ] '}' ;
 ```
 
@@ -536,7 +529,7 @@ field_expr : expr '.' ident ;
 ```antlr
 array_expr : '[' "mut" ? array_elems? ']' ;
 
-array_elems : [expr [',' expr]*] | [expr ';' expr] ;
+array_elems : [expr [',' expr]*] | [expr ',' ".." expr] ;
 ```
 
 ### Index expressions
@@ -556,60 +549,65 @@ range_expr : expr ".." expr |
 
 ### Unary operator expressions
 
-```antlr
-unop_expr : unop expr ;
-unop : '-' | '*' | '!' ;
-```
+**FIXME:** grammar?
 
 ### Binary operator expressions
 
 ```antlr
-binop_expr : expr binop expr | type_cast_expr
-           | assignment_expr | compound_assignment_expr ;
-binop : arith_op | bitwise_op | lazy_bool_op | comp_op
+binop_expr : expr binop expr ;
 ```
 
 #### Arithmetic operators
 
-```antlr
-arith_op : '+' | '-' | '*' | '/' | '%' ;
-```
+**FIXME:** grammar?
 
 #### Bitwise operators
 
-```antlr
-bitwise_op : '&' | '|' | '^' | "<<" | ">>" ;
-```
+**FIXME:** grammar?
 
 #### Lazy boolean operators
 
-```antlr
-lazy_bool_op : "&&" | "||" ;
-```
+**FIXME:** grammar?
 
 #### Comparison operators
 
-```antlr
-comp_op : "==" | "!=" | '<' | '>' | "<=" | ">=" ;
-```
+**FIXME:** grammar?
 
 #### Type cast expressions
 
-```antlr
-type_cast_expr : value "as" type ;
-```
+**FIXME:** grammar?
 
 #### Assignment expressions
 
-```antlr
-assignment_expr : expr '=' expr ;
-```
+**FIXME:** grammar?
 
 #### Compound assignment expressions
 
-```antlr
-compound_assignment_expr : expr [ arith_op | bitwise_op ] '=' expr ;
-```
+**FIXME:** grammar?
+
+#### Operator precedence
+
+The precedence of Rust binary operators is ordered as follows, going from
+strong to weak:
+
+```text
+* / %
+as
++ -
+<< >>
+&
+^
+|
+< > <= >=
+== !=
+&&
+||
+=
+```
+
+Operators at the same precedence level are evaluated left-to-right. [Unary
+operators](#unary-operator-expressions) have the same precedence level and it
+is stronger than any of the binary operators'.
 
 ### Grouped expressions
 

branches/try/src/doc/reference.md

@@ -653,10 +653,9 @@ There are several kinds of item:
 * [`use` declarations](#use-declarations)
 * [modules](#modules)
 * [functions](#functions)
-* [type aliases](#type-aliases)
+* [type definitions](#type-definitions)
 * [structures](#structures)
 * [enumerations](#enumerations)
-* [constant items](#constant-items)
 * [static items](#static-items)
 * [traits](#traits)
 * [implementations](#implementations)
@@ -673,16 +672,16 @@ which sub-item declarations may appear.
 
 ### Type Parameters
 
-All items except modules, constants and statics may be *parameterized* by type.
-Type parameters are given as a comma-separated list of identifiers enclosed in
-angle brackets (`<...>`), after the name of the item and before its definition.
-The type parameters of an item are considered "part of the name", not part of
-the type of the item. A referencing [path](#paths) must (in principle) provide
-type arguments as a list of comma-separated types enclosed within angle
-brackets, in order to refer to the type-parameterized item. In practice, the
-type-inference system can usually infer such argument types from context. There
-are no general type-parametric types, only type-parametric items. That is, Rust
-has no notion of type abstraction: there are no first-class "forall" types.
+All items except modules may be *parameterized* by type. Type parameters are
+given as a comma-separated list of identifiers enclosed in angle brackets
+(`<...>`), after the name of the item and before its definition. The type
+parameters of an item are considered "part of the name", not part of the type
+of the item. A referencing [path](#paths) must (in principle) provide type
+arguments as a list of comma-separated types enclosed within angle brackets, in
+order to refer to the type-parameterized item. In practice, the type-inference
+system can usually infer such argument types from context. There are no
+general type-parametric types, only type-parametric items. That is, Rust has
+no notion of type abstraction: there are no first-class "forall" types.
 
 ### Modules
 
@@ -744,7 +743,7 @@ mod thread {
 }
 ```
 
-#### Extern crate declarations
+##### Extern crate declarations
 
 An _`extern crate` declaration_ specifies a dependency on an external crate.
 The external crate is then bound into the declaring scope as the `ident`
@@ -768,7 +767,7 @@ extern crate std; // equivalent to: extern crate std as std;
 extern crate std as ruststd; // linking to 'std' under another name
 ```
 
-#### Use declarations
+##### Use declarations
 
 A _use declaration_ creates one or more local name bindings synonymous with
 some other [path](#paths). Usually a `use` declaration is used to shorten the
@@ -843,7 +842,7 @@ module declarations should be at the crate root if direct usage of the declared
 modules within `use` items is desired. It is also possible to use `self` and
 `super` at the beginning of a `use` item to refer to the current and direct
 parent modules respectively. All rules regarding accessing declared modules in
-`use` declarations apply to both module declarations and `extern crate`
+`use` declarations applies to both module declarations and `extern crate`
 declarations.
 
 An example of what will and will not work for `use` items:
@@ -2565,19 +2564,12 @@ array is mutable, the resulting [lvalue](#lvalues,-rvalues-and-temporaries) can
 be assigned to.
 
 Indices are zero-based, and may be of any integral type. Vector access is
-bounds-checked at compile-time for constant arrays being accessed with a constant index value.
-Otherwise a check will be performed at run-time that will put the thread in a _panicked state_ if it fails.
+bounds-checked at run-time. When the check fails, it will put the thread in a
+_panicked state_.
 
 ```{should-fail}
 ([1, 2, 3, 4])[0];
-
-let x = (["a", "b"])[10]; // compiler error: const index-expr is out of bounds
-
-let n = 10;
-let y = (["a", "b"])[n]; // panics
-
-let arr = ["a", "b"];
-arr[10]; // panics
+(["a", "b"])[10]; // panics
 ```
 
 ### Range expressions
@@ -3072,20 +3064,6 @@ of a condition expression it expects a refutable let statement. If the value of
 expression on the right hand side of the let statement matches the pattern, the corresponding
 block will execute, otherwise flow proceeds to the first `else` block that follows.
 
-```
-let dish = ("Ham", "Eggs");
-
-// this body will be skipped because the pattern is refuted
-if let ("Bacon", b) = dish {
-    println!("Bacon is served with {}", b);
-}
-
-// this body will execute
-if let ("Ham", b) = dish {
-    println!("Ham is served with {}", b);
-}
-```
-
 ### While let loops
 
 A `while let` loop is semantically identical to a `while` loop but in place of a

branches/try/src/doc/trpl/guessing-game.md

@@ -273,7 +273,7 @@ information’. Why throw it away? Well, for a basic program, we just want to
 print a generic error, as basically any issue means we can’t continue. The
 [`ok()` method][ok] returns a value which has another method defined on it:
 `expect()`. The [`expect()` method][expect] takes a value it’s called on, and
-if it isn’t a successful one, [`panic!`][panic]s with a message you
+if it isn’t a successful one, [`panic!`][panic]s with a message you passed you
 passed it. A `panic!` like this will cause our program to crash, displaying
 the message.