Skip to content

Removing '15.3 Do syntax' in tutorial since it is deprecated. #12367

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
wants to merge 1 commit into from
Closed
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
57 changes: 18 additions & 39 deletions src/doc/tutorial.md
Original file line number Diff line number Diff line change
Expand Up @@ -1750,6 +1750,24 @@ closures, but they also own them: that is, no other code can access
them. Owned closures are used in concurrent code, particularly
for spawning [tasks][tasks].

Closures can be used to spawn tasks.
A practical example of this pattern is found when using the `spawn` function,
which starts a new task.

~~~~
use std::task::spawn;

// proc is the closure which will be spawned.
spawn(proc() {
debug!("I'm a new task")
});
~~~~

> ***Note:*** If you want to see the output of `debug!` statements, you will need to turn on
> `debug!` logging. To enable `debug!` logging, set the RUST_LOG environment
> variable to the name of your crate, which, for a file named `foo.rs`, will be
> `foo` (e.g., with bash, `export RUST_LOG=foo`).

## Closure compatibility

Rust closures have a convenient subtyping property: you can pass any kind of
Expand All @@ -1771,45 +1789,6 @@ call_twice(function);
> in small ways. At the moment they can be unsound in some
> scenarios, particularly with non-copyable types.

## Do syntax

The `do` expression makes it easier to call functions that take procedures
as arguments.

Consider this function that takes a procedure:

~~~~
fn call_it(op: proc(v: int)) {
op(10)
}
~~~~

As a caller, if we use a closure to provide the final operator
argument, we can write it in a way that has a pleasant, block-like
structure.

~~~~
# fn call_it(op: proc(v: int)) { }
call_it(proc(n) {
println!("{}", n);
});
~~~~

A practical example of this pattern is found when using the `spawn` function,
which starts a new task.

~~~~
use std::task::spawn;
spawn(proc() {
debug!("I'm a new task")
});
~~~~

If you want to see the output of `debug!` statements, you will need to turn on
`debug!` logging. To enable `debug!` logging, set the RUST_LOG environment
variable to the name of your crate, which, for a file named `foo.rs`, will be
`foo` (e.g., with bash, `export RUST_LOG=foo`).

# Methods

Methods are like functions except that they always begin with a special argument,
Expand Down