auto merge of #14601 : skade/rust/remove-notrust-tags, r=alexcrichton
Now that rustdoc understands proper language tags as the code not being Rust, we can tag everything properly. `norust` as a negative statement is a bad tag. This change tags examples in other languages by their language. Plain notations are marked as `text`. Console examples are marked as `console`. Also fix markdown.rs to not highlight non-rust code. Amends the documentation to reflect the new behaviour.
This commit is contained in:
bors
commit
63e9b8f105
19 changed files with 165 additions and 156 deletions
|
|
@ -255,7 +255,7 @@ Note: The Rust signatures should be wrapped in an `extern "ABI" { ... }` block.
|
|||
|
||||
You might see things like this in C APIs:
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~c
|
||||
typedef struct Window Window;
|
||||
Window* createWindow(int width, int height);
|
||||
~~~
|
||||
|
|
|
|||
|
|
@ -135,7 +135,7 @@ For simplicity, we do not plan to do so. Implementing automatic semicolon insert
|
|||
|
||||
**Short answer** set the RUST_LOG environment variable to the name of your source file, sans extension.
|
||||
|
||||
```notrust,sh
|
||||
```sh
|
||||
rustc hello.rs
|
||||
export RUST_LOG=hello
|
||||
./hello
|
||||
|
|
|
|||
|
|
@ -229,7 +229,7 @@ fn main() {
|
|||
|
||||
C code:
|
||||
|
||||
~~~~ {.notrust}
|
||||
~~~~c
|
||||
typedef void (*rust_callback)(int32_t);
|
||||
rust_callback cb;
|
||||
|
||||
|
|
@ -296,7 +296,7 @@ fn main() {
|
|||
|
||||
C code:
|
||||
|
||||
~~~~ {.notrust}
|
||||
~~~~c
|
||||
typedef void (*rust_callback)(int32_t);
|
||||
void* cb_target;
|
||||
rust_callback cb;
|
||||
|
|
|
|||
|
|
@ -218,7 +218,7 @@ fn example3() -> int {
|
|||
To make this clearer, consider this diagram showing the state of
|
||||
memory immediately before the re-assignment of `x`:
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~ {.text}
|
||||
Stack Exchange Heap
|
||||
|
||||
x +-------------+
|
||||
|
|
@ -232,7 +232,7 @@ memory immediately before the re-assignment of `x`:
|
|||
|
||||
Once the reassignment occurs, the memory will look like this:
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~ {.text}
|
||||
Stack Exchange Heap
|
||||
|
||||
x +-------------+ +---------+
|
||||
|
|
@ -329,7 +329,7 @@ to a pointer of type `&size` into the _interior of the enum_.
|
|||
To make this more clear, let's look at a diagram of memory layout in
|
||||
the case where `shape` points at a rectangle:
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~ {.text}
|
||||
Stack Memory
|
||||
|
||||
+-------+ +---------------+
|
||||
|
|
@ -354,7 +354,7 @@ to store that shape value would still be valid, _it would have a
|
|||
different type_! The following diagram shows what memory would look
|
||||
like if code overwrote `shape` with a circle:
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~ {.text}
|
||||
Stack Memory
|
||||
|
||||
+-------+ +---------------+
|
||||
|
|
|
|||
|
|
@ -31,7 +31,7 @@ fn main() {
|
|||
|
||||
And now I get an error:
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~text
|
||||
error: mismatched types: expected `&int` but found `<generic integer #0>` (expected &-ptr but found integral variable)
|
||||
~~~
|
||||
|
||||
|
|
@ -201,7 +201,7 @@ fn main() {
|
|||
|
||||
This prints:
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~text
|
||||
Cons(1, box Cons(2, box Cons(3, box Nil)))
|
||||
~~~
|
||||
|
||||
|
|
@ -347,7 +347,7 @@ fn main() {
|
|||
|
||||
It gives this error:
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~text
|
||||
test.rs:5:8: 5:10 error: cannot assign to `*x` because it is borrowed
|
||||
test.rs:5 *x -= 1;
|
||||
^~
|
||||
|
|
|
|||
|
|
@ -19,7 +19,7 @@ fn return_two_test() {
|
|||
To run these tests, compile with `rustc --test` and run the resulting
|
||||
binary:
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~console
|
||||
$ rustc --test foo.rs
|
||||
$ ./foo
|
||||
running 1 test
|
||||
|
|
@ -111,7 +111,7 @@ sequentially.
|
|||
|
||||
### Typical test run
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~console
|
||||
$ mytests
|
||||
|
||||
running 30 tests
|
||||
|
|
@ -125,7 +125,7 @@ result: ok. 28 passed; 0 failed; 2 ignored
|
|||
|
||||
### Test run with failures
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~console
|
||||
$ mytests
|
||||
|
||||
running 30 tests
|
||||
|
|
@ -139,7 +139,7 @@ result: FAILED. 27 passed; 1 failed; 2 ignored
|
|||
|
||||
### Running ignored tests
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~console
|
||||
$ mytests --ignored
|
||||
|
||||
running 2 tests
|
||||
|
|
@ -153,7 +153,7 @@ result: FAILED. 1 passed; 1 failed; 0 ignored
|
|||
|
||||
Using a plain string:
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~console
|
||||
$ mytests mytest23
|
||||
|
||||
running 1 tests
|
||||
|
|
@ -164,7 +164,7 @@ result: ok. 1 passed; 0 failed; 0 ignored
|
|||
|
||||
Using some regular expression features:
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~console
|
||||
$ mytests 'mytest[145]'
|
||||
|
||||
running 13 tests
|
||||
|
|
@ -247,7 +247,7 @@ Advice on writing benchmarks:
|
|||
To run benchmarks, pass the `--bench` flag to the compiled
|
||||
test-runner. Benchmarks are compiled-in but not executed by default.
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~console
|
||||
$ rustc mytests.rs -O --test
|
||||
$ mytests --bench
|
||||
|
||||
|
|
@ -283,7 +283,7 @@ fn bench_xor_1000_ints(b: &mut Bencher) {
|
|||
|
||||
gives the following results
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~console
|
||||
running 1 test
|
||||
test bench_xor_1000_ints ... bench: 0 ns/iter (+/- 0)
|
||||
|
||||
|
|
@ -323,7 +323,7 @@ overhead (e.g. `black_box(&huge_struct)`).
|
|||
Performing either of the above changes gives the following
|
||||
benchmarking results
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~console
|
||||
running 1 test
|
||||
test bench_xor_1000_ints ... bench: 375 ns/iter (+/- 148)
|
||||
|
||||
|
|
|
|||
|
|
@ -22,7 +22,7 @@ and is the feature from which many of Rust's powerful capabilities are derived.
|
|||
write, and ultimately release, memory.
|
||||
Let's start by looking at some C++ code:
|
||||
|
||||
```notrust
|
||||
```cpp
|
||||
int* dangling(void)
|
||||
{
|
||||
int i = 1234;
|
||||
|
|
@ -74,7 +74,7 @@ fn main() {
|
|||
|
||||
Save this program as `dangling.rs`. When you try to compile this program with `rustc dangling.rs`, you'll get an interesting (and long) error message:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
dangling.rs:3:12: 3:14 error: `i` does not live long enough
|
||||
dangling.rs:3 return &i;
|
||||
^~
|
||||
|
|
@ -155,7 +155,7 @@ You can roughly compare these two lines:
|
|||
let i = box 1234;
|
||||
```
|
||||
|
||||
```notrust
|
||||
```cpp
|
||||
// C++
|
||||
int *i = new int;
|
||||
*i = 1234;
|
||||
|
|
@ -254,7 +254,7 @@ fn main() {
|
|||
|
||||
This will result an error indicating that the value is no longer in scope:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
concurrency.rs:12:20: 12:27 error: use of moved value: 'numbers'
|
||||
concurrency.rs:12 println!("{}", numbers.get(0));
|
||||
^~~~~~~
|
||||
|
|
|
|||
|
|
@ -356,15 +356,15 @@ msgstr "上記条件を満たしていれば、以下のような手順でビル
|
|||
#: src/doc/tutorial.md:112
|
||||
#, fuzzy
|
||||
#| msgid ""
|
||||
#| "~~~~ {.notrust} $ curl -O http://static.rust-lang.org/dist/rust-nightly.tar."
|
||||
#| "~~~~console $ curl -O http://static.rust-lang.org/dist/rust-nightly.tar."
|
||||
#| "gz $ tar -xzf rust-nightly.tar.gz $ cd rust-nightly $ ./configure $ make && make "
|
||||
#| "install ~~~~"
|
||||
msgid ""
|
||||
"~~~~ {.notrust} $ curl -O http://static.rust-lang.org/dist/rust-nightly.tar.gz $ "
|
||||
"~~~~console $ curl -O http://static.rust-lang.org/dist/rust-nightly.tar.gz $ "
|
||||
"tar -xzf rust-nightly.tar.gz $ cd rust-nightly $ ./configure $ make && make install "
|
||||
"~~~~"
|
||||
msgstr ""
|
||||
"~~~~ {.notrust}\n"
|
||||
"~~~~console\n"
|
||||
"$ curl -O http://static.rust-lang.org/dist/rust-nightly.tar.gz\n"
|
||||
"$ tar -xzf rust-nightly.tar.gz $ cd rust-nightly $ ./configure\n"
|
||||
"$ make && make install\n"
|
||||
|
|
@ -4610,7 +4610,7 @@ msgstr ""
|
|||
#: src/doc/tutorial.md:2761 src/doc/tutorial.md:2793
|
||||
#, fuzzy
|
||||
#| msgid "~~~~ {.ignore} let foo = 10;"
|
||||
msgid "~~~ {.notrust} src/plants.rs src/plants/mod.rs"
|
||||
msgid "~~~text src/plants.rs src/plants/mod.rs"
|
||||
msgstr ""
|
||||
"~~~~ {.ignore}\n"
|
||||
"let foo = 10;"
|
||||
|
|
@ -4927,24 +4927,24 @@ msgstr ""
|
|||
#: src/doc/tutorial.md:3168
|
||||
#, fuzzy, no-wrap
|
||||
#| msgid ""
|
||||
#| "~~~~ {.notrust}\n"
|
||||
#| "> rustc --lib world.rs # compiles libworld-94839cbfe144198-1.0.so\n"
|
||||
#| "> rustc main.rs -L . # compiles main\n"
|
||||
#| "> ./main\n"
|
||||
#| "~~~~console\n"
|
||||
#| "$ rustc --lib world.rs # compiles libworld-94839cbfe144198-1.0.so\n"
|
||||
#| "$ rustc main.rs -L . # compiles main\n"
|
||||
#| "$ ./main\n"
|
||||
#| "\"hello world\"\n"
|
||||
#| "~~~~\n"
|
||||
msgid ""
|
||||
"~~~~ {.notrust}\n"
|
||||
"> rustc --lib world.rs # compiles libworld-<HASH>-0.42.so\n"
|
||||
"> rustc main.rs -L . # compiles main\n"
|
||||
"> ./main\n"
|
||||
"~~~~console\n"
|
||||
"$ rustc --crate-type=lib world.rs # compiles libworld-<HASH>-0.42.so\n"
|
||||
"$ rustc main.rs -L . # compiles main\n"
|
||||
"$ ./main\n"
|
||||
"\"hello world\"\n"
|
||||
"~~~~\n"
|
||||
msgstr ""
|
||||
"~~~~ {.notrust}\n"
|
||||
"> rustc --lib world.rs # libworld-94839cbfe144198-1.0.so が生成される\n"
|
||||
"> rustc main.rs -L . # main が生成される\n"
|
||||
"> ./main\n"
|
||||
"~~~~console\n"
|
||||
"$ rustc --lib world.rs # libworld-94839cbfe144198-1.0.so が生成される\n"
|
||||
"$ rustc main.rs -L . # main が生成される\n"
|
||||
"$ ./main\n"
|
||||
"\"hello world\"\n"
|
||||
"~~~~\n"
|
||||
|
||||
|
|
|
|||
|
|
@ -59,7 +59,7 @@ dialect of EBNF supported by common automated LL(k) parsing tools such as
|
|||
`llgen`, rather than the dialect given in ISO 14977. The dialect can be
|
||||
defined self-referentially as follows:
|
||||
|
||||
~~~~ {.notrust .ebnf .notation}
|
||||
~~~~ {.ebnf .notation}
|
||||
grammar : rule + ;
|
||||
rule : nonterminal ':' productionrule ';' ;
|
||||
productionrule : production [ '|' production ] * ;
|
||||
|
|
@ -153,7 +153,7 @@ Some productions are defined by exclusion of particular Unicode characters:
|
|||
|
||||
## Comments
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
comment : block_comment | line_comment ;
|
||||
block_comment : "/*" block_comment_body * '*' + '/' ;
|
||||
block_comment_body : [block_comment | character] * ;
|
||||
|
|
@ -174,7 +174,7 @@ Non-doc comments are interpreted as a form of whitespace.
|
|||
|
||||
## Whitespace
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
whitespace_char : '\x20' | '\x09' | '\x0a' | '\x0d' ;
|
||||
whitespace : [ whitespace_char | comment ] + ;
|
||||
~~~~
|
||||
|
|
@ -191,7 +191,7 @@ with any other legal whitespace element, such as a single space character.
|
|||
|
||||
## Tokens
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
simple_token : keyword | unop | binop ;
|
||||
token : simple_token | ident | literal | symbol | whitespace token ;
|
||||
~~~~
|
||||
|
|
@ -205,7 +205,7 @@ grammar as double-quoted strings. Other tokens have exact rules given.
|
|||
|
||||
The keywords are the following strings:
|
||||
|
||||
~~~~ {.notrust .keyword}
|
||||
~~~~ {.text .keyword}
|
||||
as
|
||||
box break
|
||||
continue crate
|
||||
|
|
@ -233,13 +233,13 @@ evaluates to, rather than referring to it by name or some other evaluation
|
|||
rule. A literal is a form of constant expression, so is evaluated (primarily)
|
||||
at compile time.
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
literal : string_lit | char_lit | num_lit ;
|
||||
~~~~
|
||||
|
||||
#### Character and string literals
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
char_lit : '\x27' char_body '\x27' ;
|
||||
string_lit : '"' string_body * '"' | 'r' raw_string ;
|
||||
|
||||
|
|
@ -321,7 +321,7 @@ r##"foo #"# bar"##; // foo #"# bar
|
|||
|
||||
#### Number literals
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
num_lit : nonzero_dec [ dec_digit | '_' ] * num_suffix ?
|
||||
| '0' [ [ dec_digit | '_' ] * num_suffix ?
|
||||
| 'b' [ '1' | '0' | '_' ] + int_suffix ?
|
||||
|
|
@ -419,7 +419,7 @@ The two values of the boolean type are written `true` and `false`.
|
|||
|
||||
### Symbols
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
symbol : "::" "->"
|
||||
| '#' | '[' | ']' | '(' | ')' | '{' | '}'
|
||||
| ',' | ';' ;
|
||||
|
|
@ -434,7 +434,7 @@ operators](#binary-operator-expressions), or [keywords](#keywords).
|
|||
|
||||
## Paths
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
expr_path : [ "::" ] ident [ "::" expr_path_tail ] + ;
|
||||
expr_path_tail : '<' type_expr [ ',' type_expr ] + '>'
|
||||
| expr_path ;
|
||||
|
|
@ -543,7 +543,7 @@ All of the above extensions are expressions with values.
|
|||
|
||||
## Macros
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
expr_macro_rules : "macro_rules" '!' ident '(' macro_rule * ')' ;
|
||||
macro_rule : '(' matcher * ')' "=>" '(' transcriber * ')' ';' ;
|
||||
matcher : '(' matcher * ')' | '[' matcher * ']'
|
||||
|
|
@ -687,7 +687,7 @@ each of which may have some number of [attributes](#attributes) attached to it.
|
|||
|
||||
## Items
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
item : mod_item | fn_item | type_item | struct_item | enum_item
|
||||
| static_item | trait_item | impl_item | extern_block ;
|
||||
~~~~
|
||||
|
|
@ -735,7 +735,7 @@ That is, Rust has no notion of type abstraction: there are no first-class "foral
|
|||
|
||||
### Modules
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
mod_item : "mod" ident ( ';' | '{' mod '}' );
|
||||
mod : [ view_item | item ] * ;
|
||||
~~~~
|
||||
|
|
@ -803,7 +803,7 @@ mod task {
|
|||
|
||||
#### View items
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
view_item : extern_crate_decl | use_decl ;
|
||||
~~~~
|
||||
|
||||
|
|
@ -816,7 +816,7 @@ There are several kinds of view item:
|
|||
|
||||
##### Extern crate declarations
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
extern_crate_decl : "extern" "crate" ident [ '(' link_attrs ')' ] ? [ '=' string_lit ] ? ;
|
||||
link_attrs : link_attr [ ',' link_attrs ] + ;
|
||||
link_attr : ident '=' literal ;
|
||||
|
|
@ -848,7 +848,7 @@ extern crate foo = "some/where/rust-foo#foo:1.0"; // a full crate ID for externa
|
|||
|
||||
##### Use declarations
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
use_decl : "pub" ? "use" [ ident '=' path
|
||||
| path_glob ] ;
|
||||
|
||||
|
|
@ -1274,7 +1274,7 @@ whereas `Dog` is simply called an enum variant.
|
|||
|
||||
### Static items
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
static_item : "static" ident ':' type '=' expr ';' ;
|
||||
~~~~
|
||||
|
||||
|
|
@ -1519,7 +1519,7 @@ impl Seq<bool> for u32 {
|
|||
|
||||
### External blocks
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
extern_block_item : "extern" '{' extern_block '}' ;
|
||||
extern_block : [ foreign_fn ] * ;
|
||||
~~~~
|
||||
|
|
@ -1741,7 +1741,7 @@ import public items from their destination, not private items.
|
|||
|
||||
## Attributes
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
attribute : '#' '!' ? '[' meta_item ']' ;
|
||||
meta_item : ident [ '=' literal
|
||||
| '(' meta_seq ')' ] ? ;
|
||||
|
|
@ -2383,7 +2383,7 @@ declaring a function-local item.
|
|||
|
||||
#### Slot declarations
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
let_decl : "let" pat [':' type ] ? [ init ] ? ';' ;
|
||||
init : [ '=' ] expr ;
|
||||
~~~~
|
||||
|
|
@ -2483,7 +2483,7 @@ values.
|
|||
|
||||
### Structure expressions
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
struct_expr : expr_path '{' ident ':' expr
|
||||
[ ',' ident ':' expr ] *
|
||||
[ ".." expr ] '}' |
|
||||
|
|
@ -2537,7 +2537,7 @@ Point3d {y: 0, z: 10, .. base};
|
|||
|
||||
### Block expressions
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
block_expr : '{' [ view_item ] *
|
||||
[ stmt ';' | item ] *
|
||||
[ expr ] '}' ;
|
||||
|
|
@ -2555,7 +2555,7 @@ of the block are that of the expression itself.
|
|||
|
||||
### Method-call expressions
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
method_call_expr : expr '.' ident paren_expr_list ;
|
||||
~~~~
|
||||
|
||||
|
|
@ -2566,7 +2566,7 @@ or dynamically dispatching if the left-hand-side expression is an indirect [obje
|
|||
|
||||
### Field expressions
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
field_expr : expr '.' ident ;
|
||||
~~~~
|
||||
|
||||
|
|
@ -2588,7 +2588,7 @@ it is automatically dereferenced to make the field access possible.
|
|||
|
||||
### Vector expressions
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
vec_expr : '[' "mut" ? vec_elems? ']' ;
|
||||
|
||||
vec_elems : [expr [',' expr]*] | [expr ',' ".." expr] ;
|
||||
|
|
@ -2610,7 +2610,7 @@ as a [literal](#literals) or a [static item](#static-items).
|
|||
|
||||
### Index expressions
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
idx_expr : expr '[' expr ']' ;
|
||||
~~~~
|
||||
|
||||
|
|
@ -2662,7 +2662,7 @@ before the expression they apply to.
|
|||
|
||||
### Binary operator expressions
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
binop_expr : expr binop expr ;
|
||||
~~~~
|
||||
|
||||
|
|
@ -2803,7 +2803,7 @@ Any such expression always has the [`unit`](#primitive-types) type.
|
|||
The precedence of Rust binary operators is ordered as follows, going
|
||||
from strong to weak:
|
||||
|
||||
~~~~ {.notrust .precedence}
|
||||
~~~~ {.text .precedence}
|
||||
* / %
|
||||
as
|
||||
+ -
|
||||
|
|
@ -2827,7 +2827,7 @@ An expression enclosed in parentheses evaluates to the result of the enclosed
|
|||
expression. Parentheses can be used to explicitly specify evaluation order
|
||||
within an expression.
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
paren_expr : '(' expr ')' ;
|
||||
~~~~
|
||||
|
||||
|
|
@ -2840,7 +2840,7 @@ let x = (2 + 3) * 4;
|
|||
|
||||
### Call expressions
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
expr_list : [ expr [ ',' expr ]* ] ? ;
|
||||
paren_expr_list : '(' expr_list ')' ;
|
||||
call_expr : expr paren_expr_list ;
|
||||
|
|
@ -2863,7 +2863,7 @@ let pi: Option<f32> = FromStr::from_str("3.14");
|
|||
|
||||
### Lambda expressions
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
ident_list : [ ident [ ',' ident ]* ] ? ;
|
||||
lambda_expr : '|' ident_list '|' expr ;
|
||||
~~~~
|
||||
|
|
@ -2906,7 +2906,7 @@ ten_times(|j| println!("hello, {}", j));
|
|||
|
||||
### While loops
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
while_expr : "while" expr '{' block '}' ;
|
||||
~~~~
|
||||
|
||||
|
|
@ -2930,7 +2930,7 @@ while i < 10 {
|
|||
|
||||
A `loop` expression denotes an infinite loop.
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
loop_expr : [ lifetime ':' ] "loop" '{' block '}';
|
||||
~~~~
|
||||
|
||||
|
|
@ -2941,7 +2941,7 @@ See [Break expressions](#break-expressions) and [Continue expressions](#continue
|
|||
|
||||
### Break expressions
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
break_expr : "break" [ lifetime ];
|
||||
~~~~
|
||||
|
||||
|
|
@ -2954,7 +2954,7 @@ but must enclose it.
|
|||
|
||||
### Continue expressions
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
continue_expr : "continue" [ lifetime ];
|
||||
~~~~
|
||||
|
||||
|
|
@ -2973,7 +2973,7 @@ A `continue` expression is only permitted in the body of a loop.
|
|||
|
||||
### For expressions
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
for_expr : "for" pat "in" expr '{' block '}' ;
|
||||
~~~~
|
||||
|
||||
|
|
@ -3007,7 +3007,7 @@ for i in range(0u, 256) {
|
|||
|
||||
### If expressions
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
if_expr : "if" expr '{' block '}'
|
||||
else_tail ? ;
|
||||
|
||||
|
|
@ -3028,7 +3028,7 @@ then any `else` block is executed.
|
|||
|
||||
### Match expressions
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
match_expr : "match" expr '{' match_arm * '}' ;
|
||||
|
||||
match_arm : attribute * match_pat "=>" [ expr "," | '{' block '}' ] ;
|
||||
|
|
@ -3219,7 +3219,7 @@ let message = match maybe_digit {
|
|||
|
||||
### Return expressions
|
||||
|
||||
~~~~ {.notrust .ebnf .gram}
|
||||
~~~~ {.ebnf .gram}
|
||||
return_expr : "return" expr ? ;
|
||||
~~~~
|
||||
|
||||
|
|
@ -3496,7 +3496,7 @@ x = bo(5,7);
|
|||
|
||||
### Closure types
|
||||
|
||||
~~~~ {.notrust .ebnf .notation}
|
||||
~~~~ {.ebnf .notation}
|
||||
closure_type := [ 'unsafe' ] [ '<' lifetime-list '>' ] '|' arg-list '|'
|
||||
[ ':' bound-list ] [ '->' type ]
|
||||
procedure_type := 'proc' [ '<' lifetime-list '>' ] '(' arg-list ')'
|
||||
|
|
@ -4107,7 +4107,7 @@ fn main() {
|
|||
|
||||
These four log levels correspond to levels 1-4, as controlled by `RUST_LOG`:
|
||||
|
||||
```notrust,bash
|
||||
```sh
|
||||
$ RUST_LOG=rust=3 ./rust
|
||||
This is an error log
|
||||
This is a warn log
|
||||
|
|
|
|||
|
|
@ -122,33 +122,41 @@ source code.
|
|||
|
||||
To test documentation, the `--test` argument is passed to rustdoc:
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~ {.sh}
|
||||
rustdoc --test crate.rs
|
||||
~~~
|
||||
|
||||
## Defining tests
|
||||
|
||||
Rust documentation currently uses the markdown format, and rustdoc treats all
|
||||
code blocks as testable-by-default. In order to not run a test over a block of
|
||||
code, the `ignore` string can be added to the three-backtick form of markdown
|
||||
code block.
|
||||
code blocks as testable-by-default unless they carry a language tag of another
|
||||
language. In order to not run a test over a block of code, the `ignore` string
|
||||
can be added to the three-backtick form of markdown code block.
|
||||
|
||||
~~~notrust
|
||||
~~~md
|
||||
```
|
||||
// This is a testable code block
|
||||
```
|
||||
|
||||
```rust{.example}
|
||||
// This is rust and also testable
|
||||
```
|
||||
|
||||
```ignore
|
||||
// This is not a testable code block
|
||||
```
|
||||
|
||||
// This is a testable code block (4-space indent)
|
||||
|
||||
```sh
|
||||
# this is shell code and not tested
|
||||
```
|
||||
~~~
|
||||
|
||||
You can specify that the test's execution should fail with the `should_fail`
|
||||
directive.
|
||||
|
||||
~~~notrust
|
||||
~~~md
|
||||
```should_fail
|
||||
// This code block is expected to generate a failure when run
|
||||
```
|
||||
|
|
@ -157,7 +165,7 @@ directive.
|
|||
You can specify that the code block should be compiled but not run with the
|
||||
`no_run` directive.
|
||||
|
||||
~~~notrust
|
||||
~~~md
|
||||
```no_run
|
||||
// This code will be compiled but not executed
|
||||
```
|
||||
|
|
@ -169,7 +177,7 @@ will not show up in the HTML documentation, but it will be used when
|
|||
testing the code block (NB. the space after the `#` is required, so
|
||||
that one can still write things like `#[deriving(Eq)]`).
|
||||
|
||||
~~~notrust
|
||||
~~~md
|
||||
```
|
||||
# /!\ The three following lines are comments, which are usually stripped off by
|
||||
# the doc-generating tool. In order to display them anyway in this particular
|
||||
|
|
@ -194,7 +202,7 @@ uses is build on crate `test`, which is also used when you compile crates with
|
|||
rustc's `--test` flag. Extra arguments can be passed to rustdoc's test harness
|
||||
with the `--test-args` flag.
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~console
|
||||
# Only run tests containing 'foo' in their name
|
||||
$ rustdoc --test lib.rs --test-args 'foo'
|
||||
|
||||
|
|
|
|||
|
|
@ -106,7 +106,7 @@ packages:
|
|||
If you've fulfilled those prerequisites, something along these lines
|
||||
should work.
|
||||
|
||||
~~~~ {.notrust}
|
||||
~~~~console
|
||||
$ curl -O http://static.rust-lang.org/dist/rust-nightly.tar.gz
|
||||
$ tar -xzf rust-nightly.tar.gz
|
||||
$ cd rust-nightly
|
||||
|
|
@ -151,7 +151,7 @@ error. If you introduce an error into the program (for example, by changing
|
|||
`println!` to some nonexistent macro), and then compile it, you'll see
|
||||
an error message like this:
|
||||
|
||||
~~~~ {.notrust}
|
||||
~~~~text
|
||||
hello.rs:2:5: 2:24 error: macro undefined: 'print_with_unicorns'
|
||||
hello.rs:2 print_with_unicorns!("hello?");
|
||||
^~~~~~~~~~~~~~~~~~~
|
||||
|
|
@ -1066,7 +1066,7 @@ being destroyed along with the owner. Since the `list` variable above is
|
|||
immutable, the whole list is immutable. The memory allocation itself is the
|
||||
box, while the owner holds onto a pointer to it:
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~text
|
||||
List box List box List box List box
|
||||
+--------------+ +--------------+ +--------------+ +----------+
|
||||
list -> | Cons | 1 | | -> | Cons | 2 | | -> | Cons | 3 | | -> | Nil |
|
||||
|
|
@ -2841,7 +2841,7 @@ mod animals {
|
|||
|
||||
The compiler will look for these files, in this order:
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~text
|
||||
src/plants.rs
|
||||
src/plants/mod.rs
|
||||
|
||||
|
|
@ -2872,7 +2872,7 @@ mod mammals {
|
|||
|
||||
...then the source files of `mod animals`'s submodules can either be in the same directory as the animals source file or in a subdirectory of its directory. If the animals file is `src/animals.rs`, `rustc` will look for:
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~text
|
||||
src/animals.rs
|
||||
src/fish.rs
|
||||
src/fish/mod.rs
|
||||
|
|
@ -2883,7 +2883,7 @@ src/animals.rs
|
|||
|
||||
If the animals file is `src/animals/mod.rs`, `rustc` will look for:
|
||||
|
||||
~~~ {.notrust}
|
||||
~~~text
|
||||
src/animals/mod.rs
|
||||
src/animals/fish.rs
|
||||
src/animals/fish/mod.rs
|
||||
|
|
@ -3244,10 +3244,10 @@ fn main() { println!("hello {}", world::explore()); }
|
|||
|
||||
Now compile and run like this (adjust to your platform if necessary):
|
||||
|
||||
~~~~ {.notrust}
|
||||
> rustc --crate-type=lib world.rs # compiles libworld-<HASH>-0.42.so
|
||||
> rustc main.rs -L . # compiles main
|
||||
> ./main
|
||||
~~~~console
|
||||
$ rustc --crate-type=lib world.rs # compiles libworld-<HASH>-0.42.so
|
||||
$ rustc main.rs -L . # compiles main
|
||||
$ ./main
|
||||
"hello world"
|
||||
~~~~
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue