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"
|
||||
~~~~
|
||||
|
||||
|
|
|
|||
|
|
@ -59,7 +59,7 @@ pub trait Zero: Add<Self, Self> {
|
|||
///
|
||||
/// # Laws
|
||||
///
|
||||
/// ~~~notrust
|
||||
/// ~~~text
|
||||
/// a + 0 = a ∀ a ∈ Self
|
||||
/// 0 + a = a ∀ a ∈ Self
|
||||
/// ~~~
|
||||
|
|
@ -123,7 +123,7 @@ pub trait One: Mul<Self, Self> {
|
|||
///
|
||||
/// # Laws
|
||||
///
|
||||
/// ~~~notrust
|
||||
/// ~~~text
|
||||
/// a * 1 = a ∀ a ∈ Self
|
||||
/// 1 * a = a ∀ a ∈ Self
|
||||
/// ~~~
|
||||
|
|
|
|||
|
|
@ -57,7 +57,7 @@ disabled except for `error!` (a log level of 1). Logging is controlled via the
|
|||
`RUST_LOG` environment variable. The value of this environment variable is a
|
||||
comma-separated list of logging directives. A logging directive is of the form:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
path::to::module=log_level
|
||||
```
|
||||
|
||||
|
|
@ -80,7 +80,7 @@ all modules is set to this value.
|
|||
|
||||
Some examples of valid values of `RUST_LOG` are:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
hello // turns on all logging for the 'hello' module
|
||||
info // turns on all info logging
|
||||
hello=debug // turns on debug logging for 'hello'
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ use super::{IndependentSample, Sample, Exp};
|
|||
///
|
||||
/// The density function of this distribution is
|
||||
///
|
||||
/// ```notrust
|
||||
/// ```text
|
||||
/// f(x) = x^(k - 1) * exp(-x / θ) / (Γ(k) * θ^k)
|
||||
/// ```
|
||||
///
|
||||
|
|
|
|||
|
|
@ -56,7 +56,7 @@ it is safe with respect to the in-scope loans.
|
|||
Throughout the docs we'll consider a simple subset of Rust in which
|
||||
you can only borrow from lvalues, defined like so:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
LV = x | LV.f | *LV
|
||||
```
|
||||
|
||||
|
|
@ -64,7 +64,7 @@ Here `x` represents some variable, `LV.f` is a field reference,
|
|||
and `*LV` is a pointer dereference. There is no auto-deref or other
|
||||
niceties. This means that if you have a type like:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
struct S { f: uint }
|
||||
```
|
||||
|
||||
|
|
@ -73,7 +73,7 @@ to an `LV` of `(*a).f`.
|
|||
|
||||
Here is the formal grammar for the types we'll consider:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
TY = () | S<'LT...> | Box<TY> | & 'LT MQ TY | @ MQ TY
|
||||
MQ = mut | imm | const
|
||||
```
|
||||
|
|
@ -81,7 +81,7 @@ MQ = mut | imm | const
|
|||
Most of these types should be pretty self explanatory. Here `S` is a
|
||||
struct name and we assume structs are declared like so:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
SD = struct S<'LT...> { (f: TY)... }
|
||||
```
|
||||
|
||||
|
|
@ -93,7 +93,7 @@ SD = struct S<'LT...> { (f: TY)... }
|
|||
|
||||
Now, imagine we had a program like this:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
struct Foo { f: uint, g: uint }
|
||||
...
|
||||
'a: {
|
||||
|
|
@ -118,7 +118,7 @@ the borrow, and (3) a set of restrictions. In the code, `Loan` is a
|
|||
struct defined in `middle::borrowck`. Formally, we define `LOAN` as
|
||||
follows:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
LOAN = (LV, LT, MQ, RESTRICTION*)
|
||||
RESTRICTION = (LV, ACTION*)
|
||||
ACTION = MUTATE | CLAIM | FREEZE
|
||||
|
|
@ -151,7 +151,7 @@ To give you a better feeling for what kind of restrictions derived
|
|||
from a loan, let's look at the loan `L` that would be issued as a
|
||||
result of the borrow `&mut (*x).f` in the example above:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
L = ((*x).f, 'a, mut, RS) where
|
||||
RS = [((*x).f, [MUTATE, CLAIM, FREEZE]),
|
||||
(*x, [MUTATE, CLAIM, FREEZE]),
|
||||
|
|
@ -214,7 +214,7 @@ conditions that it uses. For simplicity I will ignore const loans.
|
|||
I will present the rules in a modified form of standard inference
|
||||
rules, which looks as follows:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
PREDICATE(X, Y, Z) // Rule-Name
|
||||
Condition 1
|
||||
Condition 2
|
||||
|
|
@ -290,7 +290,7 @@ Let's begin with the rules for variables, which state that if a
|
|||
variable is declared as mutable, it may be borrowed any which way, but
|
||||
otherwise the variable must be borrowed as immutable or const:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
MUTABILITY(X, MQ) // M-Var-Mut
|
||||
DECL(X) = mut
|
||||
|
||||
|
|
@ -305,7 +305,7 @@ Fields and owned pointers inherit their mutability from
|
|||
their base expressions, so both of their rules basically
|
||||
delegate the check to the base expression `LV`:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
MUTABILITY(LV.f, MQ) // M-Field
|
||||
MUTABILITY(LV, MQ)
|
||||
|
||||
|
|
@ -319,7 +319,7 @@ MUTABILITY(*LV, MQ) // M-Deref-Unique
|
|||
Immutable pointer types like `&T` and `@T` can only
|
||||
be borrowed if MQ is immutable or const:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
MUTABILITY(*LV, MQ) // M-Deref-Borrowed-Imm
|
||||
TYPE(LV) = &Ty
|
||||
MQ == imm | const
|
||||
|
|
@ -333,7 +333,7 @@ MUTABILITY(*LV, MQ) // M-Deref-Managed-Imm
|
|||
|
||||
`&mut T` can be frozen, so it is acceptable to borrow it as either imm or mut:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
MUTABILITY(*LV, MQ) // M-Deref-Borrowed-Mut
|
||||
TYPE(LV) = &mut Ty
|
||||
```
|
||||
|
|
@ -352,7 +352,7 @@ Rust code corresponding to this predicate is the function
|
|||
Local variables are never aliasable as they are accessible only within
|
||||
the stack frame.
|
||||
|
||||
```notrust
|
||||
```text
|
||||
ALIASABLE(X, MQ) // M-Var-Mut
|
||||
```
|
||||
|
||||
|
|
@ -360,7 +360,7 @@ the stack frame.
|
|||
|
||||
Owned content is aliasable if it is found in an aliasable location:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
ALIASABLE(LV.f, MQ) // M-Field
|
||||
ALIASABLE(LV, MQ)
|
||||
|
||||
|
|
@ -373,7 +373,7 @@ ALIASABLE(*LV, MQ) // M-Deref-Unique
|
|||
Immutable pointer types like `&T` are aliasable, and hence can only be
|
||||
borrowed immutably:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
ALIASABLE(*LV, imm) // M-Deref-Borrowed-Imm
|
||||
TYPE(LV) = &Ty
|
||||
```
|
||||
|
|
@ -382,7 +382,7 @@ ALIASABLE(*LV, imm) // M-Deref-Borrowed-Imm
|
|||
|
||||
`&mut T` can be frozen, so it is acceptable to borrow it as either imm or mut:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
ALIASABLE(*LV, MQ) // M-Deref-Borrowed-Mut
|
||||
TYPE(LV) = &mut Ty
|
||||
```
|
||||
|
|
@ -405,13 +405,13 @@ guaranteed to exist, presuming that no mutations occur.
|
|||
|
||||
The scope of a local variable is the block where it is declared:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
SCOPE(X) = block where X is declared
|
||||
```
|
||||
|
||||
The scope of a field is the scope of the struct:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
SCOPE(LV.f) = SCOPE(LV)
|
||||
```
|
||||
|
||||
|
|
@ -419,7 +419,7 @@ The scope of a unique referent is the scope of the pointer, since
|
|||
(barring mutation or moves) the pointer will not be freed until
|
||||
the pointer itself `LV` goes out of scope:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
SCOPE(*LV) = SCOPE(LV) if LV has type Box<T>
|
||||
```
|
||||
|
||||
|
|
@ -427,7 +427,7 @@ The scope of a managed referent is also the scope of the pointer. This
|
|||
is a conservative approximation, since there may be other aliases for
|
||||
that same managed box that would cause it to live longer:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
SCOPE(*LV) = SCOPE(LV) if LV has type @T
|
||||
```
|
||||
|
||||
|
|
@ -435,7 +435,7 @@ The scope of a borrowed referent is the scope associated with the
|
|||
pointer. This is a conservative approximation, since the data that
|
||||
the pointer points at may actually live longer:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
SCOPE(*LV) = LT if LV has type &'LT T or &'LT mut T
|
||||
```
|
||||
|
||||
|
|
@ -444,7 +444,7 @@ the pointer points at may actually live longer:
|
|||
The rule for variables states that a variable can only be borrowed a
|
||||
lifetime `LT` that is a subregion of the variable's scope:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
LIFETIME(X, LT, MQ) // L-Local
|
||||
LT <= SCOPE(X)
|
||||
```
|
||||
|
|
@ -454,7 +454,7 @@ LIFETIME(X, LT, MQ) // L-Local
|
|||
The lifetime of a field or owned pointer is the same as the lifetime
|
||||
of its owner:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
LIFETIME(LV.f, LT, MQ) // L-Field
|
||||
LIFETIME(LV, LT, MQ)
|
||||
|
||||
|
|
@ -471,7 +471,7 @@ lifetime. Therefore, the borrow is valid so long as the lifetime `LT`
|
|||
of the borrow is shorter than the lifetime `LT'` of the pointer
|
||||
itself:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
LIFETIME(*LV, LT, MQ) // L-Deref-Borrowed
|
||||
TYPE(LV) = <' Ty OR <' mut Ty
|
||||
LT <= LT'
|
||||
|
|
@ -484,7 +484,7 @@ Managed pointers are valid so long as the data within them is
|
|||
when the user guarantees such a root will exist. For this to be true,
|
||||
three conditions must be met:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
LIFETIME(*LV, LT, MQ) // L-Deref-Managed-Imm-User-Root
|
||||
TYPE(LV) = @Ty
|
||||
LT <= SCOPE(LV) // (1)
|
||||
|
|
@ -518,7 +518,7 @@ borrow without crossing the exit from the scope `LT`.
|
|||
|
||||
The rule for compiler rooting is as follows:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
LIFETIME(*LV, LT, MQ) // L-Deref-Managed-Imm-Compiler-Root
|
||||
TYPE(LV) = @Ty
|
||||
LT <= innermost enclosing loop/func
|
||||
|
|
@ -542,7 +542,7 @@ for the lifetime of the loan".
|
|||
Note that there is an initial set of restrictions: these restrictions
|
||||
are computed based on the kind of borrow:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
&mut LV => RESTRICTIONS(LV, LT, MUTATE|CLAIM|FREEZE)
|
||||
&LV => RESTRICTIONS(LV, LT, MUTATE|CLAIM)
|
||||
&const LV => RESTRICTIONS(LV, LT, [])
|
||||
|
|
@ -559,7 +559,7 @@ moved out from under it, so no actions are forbidden.
|
|||
|
||||
The simplest case is a borrow of a local variable `X`:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
RESTRICTIONS(X, LT, ACTIONS) = (X, ACTIONS) // R-Variable
|
||||
```
|
||||
|
||||
|
|
@ -570,7 +570,7 @@ In such cases we just record the actions that are not permitted.
|
|||
Restricting a field is the same as restricting the owner of that
|
||||
field:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
RESTRICTIONS(LV.f, LT, ACTIONS) = RS, (LV.f, ACTIONS) // R-Field
|
||||
RESTRICTIONS(LV, LT, ACTIONS) = RS
|
||||
```
|
||||
|
|
@ -593,7 +593,7 @@ must prevent the owned pointer `LV` from being mutated, which means
|
|||
that we always add `MUTATE` and `CLAIM` to the restriction set imposed
|
||||
on `LV`:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
RESTRICTIONS(*LV, LT, ACTIONS) = RS, (*LV, ACTIONS) // R-Deref-Send-Pointer
|
||||
TYPE(LV) = Box<Ty>
|
||||
RESTRICTIONS(LV, LT, ACTIONS|MUTATE|CLAIM) = RS
|
||||
|
|
@ -610,7 +610,7 @@ restricting that path. Therefore, the rule for `&Ty` and `@Ty`
|
|||
pointers always returns an empty set of restrictions, and it only
|
||||
permits restricting `MUTATE` and `CLAIM` actions:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
RESTRICTIONS(*LV, LT, ACTIONS) = [] // R-Deref-Imm-Managed
|
||||
TYPE(LV) = @Ty
|
||||
ACTIONS subset of [MUTATE, CLAIM]
|
||||
|
|
@ -733,7 +733,7 @@ Because moves from a `&const` or `@const` lvalue are never legal, it
|
|||
is not necessary to add any restrictions at all to the final
|
||||
result.
|
||||
|
||||
```notrust
|
||||
```text
|
||||
RESTRICTIONS(*LV, LT, []) = [] // R-Deref-Freeze-Borrowed
|
||||
TYPE(LV) = &const Ty or @const Ty
|
||||
```
|
||||
|
|
@ -749,7 +749,7 @@ while the new claimant is live.
|
|||
|
||||
The rule for mutable borrowed pointers is as follows:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
RESTRICTIONS(*LV, LT, ACTIONS) = RS, (*LV, ACTIONS) // R-Deref-Mut-Borrowed
|
||||
TYPE(LV) = <' mut Ty
|
||||
LT <= LT' // (1)
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ There are several critical invariants which we maintain:
|
|||
> types lie in between. The bottom type is then the Null type.
|
||||
> So the tree looks like:
|
||||
>
|
||||
> ```notrust
|
||||
> ```text
|
||||
> Object
|
||||
> / \
|
||||
> String Other
|
||||
|
|
@ -106,7 +106,7 @@ Pictorally, what this does is to take two distinct variables with
|
|||
(hopefully not completely) distinct type ranges and produce one with
|
||||
the intersection.
|
||||
|
||||
```notrust
|
||||
```text
|
||||
B.ub B.ub
|
||||
/\ /
|
||||
A.ub / \ A.ub /
|
||||
|
|
@ -129,7 +129,7 @@ bounds in such a way that, whatever happens, we know that A <: B will hold.
|
|||
This can be achieved by ensuring that A.ub <: B.lb. In practice there
|
||||
are two ways to do that, depicted pictorally here:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
Before Option #1 Option #2
|
||||
|
||||
B.ub B.ub B.ub
|
||||
|
|
@ -164,7 +164,7 @@ course, it depends on the program.
|
|||
|
||||
The main case which fails today that I would like to support is:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
fn foo<T>(x: T, y: T) { ... }
|
||||
|
||||
fn bar() {
|
||||
|
|
|
|||
|
|
@ -168,7 +168,8 @@ pub fn render(w: &mut fmt::Formatter, s: &str, print_toc: bool) -> fmt::Result {
|
|||
slice::raw::buf_as_slice((*lang).data,
|
||||
(*lang).size as uint, |rlang| {
|
||||
let rlang = str::from_utf8(rlang).unwrap();
|
||||
if rlang.contains("notrust") {
|
||||
let (_,_,_,notrust) = parse_lang_string(rlang);
|
||||
if notrust {
|
||||
(my_opaque.dfltblk)(ob, &buf, lang,
|
||||
opaque as *mut libc::c_void);
|
||||
true
|
||||
|
|
|
|||
|
|
@ -85,7 +85,7 @@ function, but the `format!` macro is a syntax extension which allows it to
|
|||
leverage named parameters. Named parameters are listed at the end of the
|
||||
argument list and have the syntax:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
identifier '=' expression
|
||||
```
|
||||
|
||||
|
|
@ -110,7 +110,7 @@ Each argument's type is dictated by the format string. It is a requirement that
|
|||
every argument is only ever referred to by one type. For example, this is an
|
||||
invalid format string:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
{0:d} {0:s}
|
||||
```
|
||||
|
||||
|
|
@ -126,7 +126,7 @@ must have the type `uint`. Although a `uint` can be printed with `{:u}`, it is
|
|||
illegal to reference an argument as such. For example, this is another invalid
|
||||
format string:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
{:.*s} {0:u}
|
||||
```
|
||||
|
||||
|
|
@ -347,7 +347,7 @@ This example is the equivalent of `{0:s}` essentially.
|
|||
The select method is a switch over a `&str` parameter, and the parameter *must*
|
||||
be of the type `&str`. An example of the syntax is:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
{0, select, male{...} female{...} other{...}}
|
||||
```
|
||||
|
||||
|
|
@ -366,7 +366,7 @@ The plural method is a switch statement over a `uint` parameter, and the
|
|||
parameter *must* be a `uint`. A plural method in its full glory can be specified
|
||||
as:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
{0, plural, offset=1 =1{...} two{...} many{...} other{...}}
|
||||
```
|
||||
|
||||
|
|
@ -394,7 +394,7 @@ should not be too alien. Arguments are formatted with python-like syntax,
|
|||
meaning that arguments are surrounded by `{}` instead of the C-like `%`. The
|
||||
actual grammar for the formatting syntax is:
|
||||
|
||||
```notrust
|
||||
```text
|
||||
format_string := <text> [ format <text> ] *
|
||||
format := '{' [ argument ] [ ':' format_spec ] [ ',' function_spec ] '}'
|
||||
argument := integer | identifier
|
||||
|
|
|
|||
|
|
@ -102,7 +102,7 @@ above `PartialEq`, `A`, `B` and `C`.
|
|||
|
||||
When generating the `expr` for the `A` impl, the `SubstructureFields` is
|
||||
|
||||
~~~notrust
|
||||
~~~text
|
||||
Struct(~[FieldInfo {
|
||||
span: <span of x>
|
||||
name: Some(<ident of x>),
|
||||
|
|
@ -113,7 +113,7 @@ Struct(~[FieldInfo {
|
|||
|
||||
For the `B` impl, called with `B(a)` and `B(b)`,
|
||||
|
||||
~~~notrust
|
||||
~~~text
|
||||
Struct(~[FieldInfo {
|
||||
span: <span of `int`>,
|
||||
name: None,
|
||||
|
|
@ -127,7 +127,7 @@ Struct(~[FieldInfo {
|
|||
When generating the `expr` for a call with `self == C0(a)` and `other
|
||||
== C0(b)`, the SubstructureFields is
|
||||
|
||||
~~~notrust
|
||||
~~~text
|
||||
EnumMatching(0, <ast::Variant for C0>,
|
||||
~[FieldInfo {
|
||||
span: <span of int>
|
||||
|
|
@ -139,7 +139,7 @@ EnumMatching(0, <ast::Variant for C0>,
|
|||
|
||||
For `C1 {x}` and `C1 {x}`,
|
||||
|
||||
~~~notrust
|
||||
~~~text
|
||||
EnumMatching(1, <ast::Variant for C1>,
|
||||
~[FieldInfo {
|
||||
span: <span of x>
|
||||
|
|
@ -151,7 +151,7 @@ EnumMatching(1, <ast::Variant for C1>,
|
|||
|
||||
For `C0(a)` and `C1 {x}` ,
|
||||
|
||||
~~~notrust
|
||||
~~~text
|
||||
EnumNonMatching(~[(0, <ast::Variant for B0>,
|
||||
~[(<span of int>, None, <expr for &a>)]),
|
||||
(1, <ast::Variant for B1>,
|
||||
|
|
@ -165,7 +165,7 @@ EnumNonMatching(~[(0, <ast::Variant for B0>,
|
|||
|
||||
A static method on the above would result in,
|
||||
|
||||
~~~~notrust
|
||||
~~~text
|
||||
StaticStruct(<ast::StructDef of A>, Named(~[(<ident of x>, <span of x>)]))
|
||||
|
||||
StaticStruct(<ast::StructDef of B>, Unnamed(~[<span of x>]))
|
||||
|
|
@ -792,7 +792,7 @@ impl<'a> MethodDef<'a> {
|
|||
/**
|
||||
Creates the nested matches for an enum definition recursively, i.e.
|
||||
|
||||
~~~notrust
|
||||
~~~text
|
||||
match self {
|
||||
Variant1 => match other { Variant1 => matching, Variant2 => nonmatching, ... },
|
||||
Variant2 => match other { Variant1 => nonmatching, Variant2 => matching, ... },
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue