docs: Stop using notrust
Now that rustdoc understands proper language tags as the code not being Rust, we can tag everything properly. 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.
This commit is contained in:
Florian Gilcher
parent
b981add9ee
commit
20fb7c62d4
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