nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-02-19 18:34:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix internal linking in the tutorial

Browse Source
This commit is contained in:
Marijn Haverbeke 2012-01-19 15:30:31 +01:00
parent df02ca1df9
commit d54cc1cad4
1 changed files with 16 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
doc/tutorial.md
View File

@ -8,9 +8,7 @@ This is a tutorial for the Rust programming language. It assumes the
reader is familiar with the basic concepts of programming, and has reader is familiar with the basic concepts of programming, and has
programmed in one or more other languages before. The tutorial covers programmed in one or more other languages before. The tutorial covers
the whole language, though not with the depth and precision of the the whole language, though not with the depth and precision of the
[language reference][1]. [language reference](rust.html).
[1]: http://www.rust-lang.org/doc/rust.html
## Disclaimer ## Disclaimer
@ -106,7 +104,7 @@ live inside a function.
Rust programs can also be compiled as libraries, and included in other Rust programs can also be compiled as libraries, and included in other
programs. The `use std` directive that appears at the top of a lot of programs. The `use std` directive that appears at the top of a lot of
examples imports the [standard library][std]. This is described in more examples imports the [standard library][std]. This is described in more
detail [later on](mod.html). detail [later on](#modules-and-crates).
[std]: http://doc.rust-lang.org/doc/std/index/General.html [std]: http://doc.rust-lang.org/doc/std/index/General.html
@ -332,10 +330,9 @@ type monster_size = uint;
This will provide a synonym, `monster_size`, for unsigned integers. It This will provide a synonym, `monster_size`, for unsigned integers. It
will not actually create a new type—`monster_size` and `uint` can be will not actually create a new type—`monster_size` and `uint` can be
used interchangeably, and using one where the other is expected is not used interchangeably, and using one where the other is expected is not
a type error. Read about [single-variant enums][sve] further on if you a type error. Read about [single-variant enums](#single_variant_enum)
need to create a type name that's not just a synonym. further on if you need to create a type name that's not just a
synonym.
[sve]: data.html#single_variant_enum
## Literals ## Literals
@ -435,8 +432,6 @@ assert y == 4u;
## Attributes ## Attributes
<a name="conditional"></a>
Every definition can be annotated with attributes. Attributes are meta Every definition can be annotated with attributes. Attributes are meta
information that can serve a variety of purposes. One of those is information that can serve a variety of purposes. One of those is
conditional compilation: conditional compilation:
@ -457,12 +452,12 @@ Attributes are always wrapped in hash-braces (`#[attr]`). Inside the
braces, a small minilanguage is supported, whose interpretation braces, a small minilanguage is supported, whose interpretation
depends on the attribute that's being used. The simplest form is a depends on the attribute that's being used. The simplest form is a
plain name (as in `#[test]`, which is used by the [built-in test plain name (as in `#[test]`, which is used by the [built-in test
framework](test.html '')). A name-value pair can be provided using an `=` framework](#testing)). A name-value pair can be provided using an `=`
character followed by a literal (as in `#[license = "BSD"]`, which is character followed by a literal (as in `#[license = "BSD"]`, which is
a valid way to annotate a Rust program as being released under a a valid way to annotate a Rust program as being released under a
BSD-style license). Finally, you can have a name followed by a BSD-style license). Finally, you can have a name followed by a
comma-separated list of nested attributes, as in the `cfg` example comma-separated list of nested attributes, as in the `cfg` example
above, or in this [crate](mod.html) metadata declaration: above, or in this [crate](#modules-and-crates) metadata declaration:
~~~~ ~~~~
## ignore ## ignore
@ -662,7 +657,7 @@ moment.
## Failure ## Failure
The `fail` keyword causes the current [task][tasks] to fail. You use The `fail` keyword causes the current [task](#tasks) to fail. You use
it to indicate unexpected failure, much like you'd use `exit(1)` in a it to indicate unexpected failure, much like you'd use `exit(1)` in a
C program, except that in Rust, it is possible for other tasks to C program, except that in Rust, it is possible for other tasks to
handle the failure, allowing the program to continue running. handle the failure, allowing the program to continue running.
@ -671,8 +666,6 @@ handle the failure, allowing the program to continue running.
to access a vector out of bounds, or running a pattern match with no to access a vector out of bounds, or running a pattern match with no
matching clauses, both result in the equivalent of a `fail`. matching clauses, both result in the equivalent of a `fail`.
[tasks]: task.html
## Logging ## Logging
Rust has a built-in logging mechanism, using the `log` statement. Rust has a built-in logging mechanism, using the `log` statement.
@ -835,14 +828,12 @@ call_twice(bare_function);
### Unique closures ### Unique closures
<a name="unique"></a>
Unique closures, written `fn~` in analogy to the `~` pointer type (see Unique closures, written `fn~` in analogy to the `~` pointer type (see
next section), hold on to things that can safely be sent between next section), hold on to things that can safely be sent between
processes. They copy the values they close over, much like boxed processes. They copy the values they close over, much like boxed
closures, but they also 'own' them—meaning no other code can access closures, but they also 'own' them—meaning no other code can access
them. Unique closures mostly exist to for spawning new them. Unique closures mostly exist to for spawning new
[tasks](task.html). [tasks](#tasks).
### Shorthand syntax ### Shorthand syntax
@ -1151,8 +1142,6 @@ All pointer types can be dereferenced with the `*` unary operator.
### Shared boxes ### Shared boxes
<a name="shared-box"></a>
Shared boxes are pointers to heap-allocated, reference counted memory. Shared boxes are pointers to heap-allocated, reference counted memory.
A cycle collector ensures that circular references do not result in A cycle collector ensures that circular references do not result in
memory leaks. memory leaks.
@ -1174,8 +1163,6 @@ Shared boxes never cross task boundaries.
### Unique boxes ### Unique boxes
<a name="unique-box"></a>
In contrast to shared boxes, unique boxes are not reference counted. In contrast to shared boxes, unique boxes are not reference counted.
Instead, it is statically guaranteed that only a single owner of the Instead, it is statically guaranteed that only a single owner of the
box exists at any time. box exists at any time.
@ -1414,7 +1401,7 @@ records and tags *are* passed by pointer, but single-word values, like
integers and pointers, are simply passed by value. Most of the time, integers and pointers, are simply passed by value. Most of the time,
the programmer does not have to worry about this, as the compiler will the programmer does not have to worry about this, as the compiler will
simply pick the most efficient passing style. There is one exception, simply pick the most efficient passing style. There is one exception,
which will be described in the section on [generics](generic.html). which will be described in the section on [generics](#generics).
To explicitly set the passing-style for a parameter, you prefix the To explicitly set the passing-style for a parameter, you prefix the
argument name with a sigil. There are two special passing styles that argument name with a sigil. There are two special passing styles that
@ -1542,8 +1529,6 @@ without any sophistication).
## Kinds ## Kinds
<a name="kind"></a>
Perhaps surprisingly, the 'copy' (duplicate) operation is not defined Perhaps surprisingly, the 'copy' (duplicate) operation is not defined
for all Rust types. Resource types (types with destructors) can not be for all Rust types. Resource types (types with destructors) can not be
copied, and neither can any type whose copying would require copying a copied, and neither can any type whose copying would require copying a
@ -1724,7 +1709,7 @@ A set of basic library routines, mostly related to built-in datatypes
and the task system, are always implicitly linked and included in any and the task system, are always implicitly linked and included in any
Rust program, unless the `--no-core` compiler switch is given. Rust program, unless the `--no-core` compiler switch is given.
This library is document [here][core]. This library is documented [here][core].
[core]: http://doc.rust-lang.org/doc/core/index/General.html [core]: http://doc.rust-lang.org/doc/core/index/General.html
@ -2310,11 +2295,9 @@ supposed to point at, this is safe.
Rust supports a system of lightweight tasks, similar to what is found Rust supports a system of lightweight tasks, similar to what is found
in Erlang or other actor systems. Rust tasks communicate via messages in Erlang or other actor systems. Rust tasks communicate via messages
and do not share data. However, it is possible to send data without and do not share data. However, it is possible to send data without
copying it by making use of [unique boxes][uniques], which allow the copying it by making use of [unique boxes](#unique-boxes), which allow
sending task to release ownership of a value, so that the receiving the sending task to release ownership of a value, so that the
task can keep on using it. receiving task can keep on using it.
[uniques]: data.html#unique-box
NOTE: As Rust evolves, we expect the Task API to grow and change NOTE: As Rust evolves, we expect the Task API to grow and change
somewhat. The tutorial documents the API as it exists today. somewhat. The tutorial documents the API as it exists today.
@ -2333,7 +2316,7 @@ let child_task = task::spawn {||
~~~~ ~~~~
The argument to `task::spawn()` is a [unique The argument to `task::spawn()` is a [unique
closure](func.html#unique) of type `fn~()`, meaning that it takes no closure](#unique-closures) of type `fn~()`, meaning that it takes no
arguments and generates no return value. The effect of `task::spawn()` arguments and generates no return value. The effect of `task::spawn()`
is to fire up a child task that will execute the closure in parallel is to fire up a child task that will execute the closure in parallel
with the creator. The result is a task id, here stored into the with the creator. The result is a task id, here stored into the
@ -2553,4 +2536,4 @@ ignored.
A program compiled as a test runner will have the configuration flag A program compiled as a test runner will have the configuration flag
`test` defined, so that you can add code that won't be included in a `test` defined, so that you can add code that won't be included in a
normal compile with the `#[cfg(test)]` attribute (see [conditional normal compile with the `#[cfg(test)]` attribute (see [conditional
compilation](syntax.md#conditional)). compilation](#attributes)).