OpenE2K/rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

doc: "import" -> "use"

Browse Source
This commit is contained in:
Patrick Walton 2012-09-05 12:39:16 -07:00
parent f686896f60
commit 10c533861b
3 changed files with 68 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

67
doc/rust.md
View File

@ -203,7 +203,7 @@ grammar as double-quoted strings. Other tokens have exact rules given.
The keywords in [crate files](#crate-files) are the following strings: The keywords in [crate files](#crate-files) are the following strings:
~~~~~~~~ {.keyword} ~~~~~~~~ {.keyword}
import export use mod export use mod
~~~~~~~~ ~~~~~~~~
The keywords in [source files](#source-files) are the following strings: The keywords in [source files](#source-files) are the following strings:
@ -215,7 +215,7 @@ check const copy
drop drop
else enum export extern else enum export extern
fail false fn for fail false fn for
if impl import if impl
let log loop let log loop
match mod mut match mod mut
pure pure
@ -447,7 +447,7 @@ expression context, the final namespace qualifier is omitted.
Two examples of paths with type arguments: Two examples of paths with type arguments:
~~~~ ~~~~
# import std::map; # use std::map;
# fn f() { # fn f() {
# fn id<T:copy>(t: T) -> T { t } # fn id<T:copy>(t: T) -> T { t }
type t = map::hashmap<int,~str>; // Type arguments used in a type expression type t = map::hashmap<int,~str>; // Type arguments used in a type expression
@ -619,8 +619,8 @@ or a *configuration* in Mesa.] A crate file describes:
and copyright. These are used for linking, versioning and distributing and copyright. These are used for linking, versioning and distributing
crates. crates.
* The source-file and directory modules that make up the crate. * The source-file and directory modules that make up the crate.
* Any `use`, `import` or `export` [view items](#view-items) that apply to the * Any `use`, `extern mod` or `export` [view items](#view-items) that apply to
anonymous module at the top-level of the crate's module tree. the anonymous module at the top-level of the crate's module tree.
An example of a crate file: An example of a crate file:
@ -636,7 +636,7 @@ An example of a crate file:
author = "Jane Doe" ]; author = "Jane Doe" ];
// Import a module. // Import a module.
use std (ver = "1.0"); extern mod std (ver = "1.0");
// Define some modules. // Define some modules.
#[path = "foo.rs"] #[path = "foo.rs"]
@ -767,28 +767,28 @@ mod math {
#### View items #### View items
~~~~~~~~ {.ebnf .gram} ~~~~~~~~ {.ebnf .gram}
view_item : use_decl | import_decl | export_decl ; view_item : extern_mod_decl | use_decl | export_decl ;
~~~~~~~~ ~~~~~~~~
A view item manages the namespace of a module; it does not define new items A view item manages the namespace of a module; it does not define new items
but simply changes the visibility of other items. There are several kinds of but simply changes the visibility of other items. There are several kinds of
view item: view item:
* [extern mod declarations](#extern-mod-declarations)
* [use declarations](#use-declarations) * [use declarations](#use-declarations)
* [import declarations](#import-declarations)
* [export declarations](#export-declarations) * [export declarations](#export-declarations)
##### Use declarations ##### Extern mod declarations
~~~~~~~~ {.ebnf .gram} ~~~~~~~~ {.ebnf .gram}
use_decl : "use" ident [ '(' link_attrs ')' ] ? ; extern_mod_decl : "extern" "mod" ident [ '(' link_attrs ')' ] ? ;
link_attrs : link_attr [ ',' link_attrs ] + ; link_attrs : link_attr [ ',' link_attrs ] + ;
link_attr : ident '=' literal ; link_attr : ident '=' literal ;
~~~~~~~~ ~~~~~~~~
A _use declaration_ specifies a dependency on an external crate. The external An _extern mod declaration_ specifies a dependency on an external crate. The
crate is then imported into the declaring scope as the `ident` provided in the external crate is then imported into the declaring scope as the `ident`
`use_decl`. provided in the `extern_mod_decl`.
The external crate is resolved to a specific `soname` at compile time, and a The external crate is resolved to a specific `soname` at compile time, and a
runtime linkage requirement to that `soname` is passed to the linker for runtime linkage requirement to that `soname` is passed to the linker for
@ -798,51 +798,52 @@ compiler's library path and matching the `link_attrs` provided in the
crate when it was compiled. If no `link_attrs` are provided, a default `name` crate when it was compiled. If no `link_attrs` are provided, a default `name`
attribute is assumed, equal to the `ident` given in the `use_decl`. attribute is assumed, equal to the `ident` given in the `use_decl`.
Two examples of `use` declarations: Two examples of `extern mod` declarations:
~~~~~~~~{.xfail-test} ~~~~~~~~{.xfail-test}
use pcre (uuid = "54aba0f8-a7b1-4beb-92f1-4cf625264841"); extern mod pcre (uuid = "54aba0f8-a7b1-4beb-92f1-4cf625264841");
use std; // equivalent to: use std ( name = "std" ); extern mod std; // equivalent to: extern mod std ( name = "std" );
use ruststd (name = "std"); // linking to 'std' under another name extern mod ruststd (name = "std"); // linking to 'std' under another name
~~~~~~~~ ~~~~~~~~
##### Import declarations ##### Use declarations
~~~~~~~~ {.ebnf .gram} ~~~~~~~~ {.ebnf .gram}
import_decl : "import" ident [ '=' path use_decl : "use" ident [ '=' path
| "::" path_glob ] ; | "::" path_glob ] ;
path_glob : ident [ "::" path_glob ] ? path_glob : ident [ "::" path_glob ] ?
| '*' | '*'
| '{' ident [ ',' ident ] * '}' | '{' ident [ ',' ident ] * '}'
~~~~~~~~ ~~~~~~~~
An _import declaration_ creates one or more local name bindings synonymous A _use declaration_ creates one or more local name bindings synonymous
with some other [path](#paths). Usually an import declaration is used to with some other [path](#paths). Usually an use declaration is used to
shorten the path required to refer to a module item. shorten the path required to refer to a module item.
*Note*: unlike many languages, Rust's `import` declarations do *not* declare *Note*: unlike many languages, Rust's `use` declarations do *not* declare
linkage-dependency with external crates. Linkage dependencies are linkage-dependency with external crates. Linkage dependencies are
independently declared with [`use` declarations](#use-declarations). independently declared with
[`extern mod` declarations](#extern-mod-declarations).
Imports support a number of "convenience" notations: Imports support a number of "convenience" notations:
* Importing as a different name than the imported name, using the * Importing as a different name than the imported name, using the
syntax `import x = p::q::r;`. syntax `use x = p::q::r;`.
* Importing a list of paths differing only in final element, using * Importing a list of paths differing only in final element, using
the glob-like brace syntax `import a::b::{c,d,e,f};` the glob-like brace syntax `use a::b::{c,d,e,f};`
* Importing all paths matching a given prefix, using the glob-like * Importing all paths matching a given prefix, using the glob-like
asterisk syntax `import a::b::*;` asterisk syntax `use a::b::*;`
An example of imports: An example of imports:
~~~~ ~~~~
import foo = core::info; use foo = core::info;
import core::float::sin; use core::float::sin;
import core::str::{slice, to_upper}; use core::str::{slice, to_upper};
import core::option::Some; use core::option::Some;
fn main() { fn main() {
// Equivalent to 'log(core::info, core::float::sin(1.0));' // Equivalent to 'log(core::info, core::float::sin(1.0));'
@ -1053,7 +1054,7 @@ verify the semantics of the pure functions they write.
An example of a pure function that uses an unchecked block: An example of a pure function that uses an unchecked block:
~~~~ ~~~~
# import std::list::*; # use std::list::*;
fn pure_foldl<T, U: copy>(ls: List<T>, u: U, f: fn(&&T, &&U) -> U) -> U { fn pure_foldl<T, U: copy>(ls: List<T>, u: U, f: fn(&&T, &&U) -> U) -> U {
match ls { match ls {
@ -1347,7 +1348,7 @@ Rust functions, with the exception that they may not have a body and are
instead terminated by a semi-colon. instead terminated by a semi-colon.
~~~ ~~~
# import libc::{c_char, FILE}; # use libc::{c_char, FILE};
# #[nolink] # #[nolink]
extern mod c { extern mod c {

8
doc/tutorial-ffi.md
View File

@ -13,8 +13,8 @@ hexadecimal string and prints to standard output. If you have the
OpenSSL libraries installed, it should 'just work'. OpenSSL libraries installed, it should 'just work'.
~~~~ {.xfail-test} ~~~~ {.xfail-test}
use std; extern mod std;
import libc::c_uint; use libc::c_uint;
extern mod crypto { extern mod crypto {
fn SHA1(src: *u8, sz: c_uint, out: *u8) -> *u8; fn SHA1(src: *u8, sz: c_uint, out: *u8) -> *u8;
@ -208,8 +208,8 @@ This program uses the POSIX function `gettimeofday` to get a
microsecond-resolution timer. microsecond-resolution timer.
~~~~ ~~~~
use std; extern mod std;
import libc::c_ulonglong; use libc::c_ulonglong;
type timeval = {mut tv_sec: c_ulonglong, type timeval = {mut tv_sec: c_ulonglong,
mut tv_usec: c_ulonglong}; mut tv_usec: c_ulonglong};

60
doc/tutorial.md
View File

@ -1222,7 +1222,7 @@ most vector functionality is provided by methods, so let's have a
brief look at a few common ones. brief look at a few common ones.
~~~ ~~~
# import io::println; # use io::println;
# enum crayon { # enum crayon {
# almond, antique_brass, apricot, # almond, antique_brass, apricot,
# aquamarine, asparagus, atomic_tangerine, # aquamarine, asparagus, atomic_tangerine,
@ -1276,7 +1276,7 @@ Rust also supports _closures_, functions that can access variables in
the enclosing scope. the enclosing scope.
~~~~ ~~~~
# import println = io::println; # use println = io::println;
fn call_closure_with_ten(b: fn(int)) { b(10); } fn call_closure_with_ten(b: fn(int)) { b(10); }
let captured_var = 20; let captured_var = 20;
@ -1434,7 +1434,7 @@ takes a final closure argument.
`do` is often used for task spawning. `do` is often used for task spawning.
~~~~ ~~~~
import task::spawn; use task::spawn;
do spawn() || { do spawn() || {
debug!("I'm a task, whatever"); debug!("I'm a task, whatever");
@ -1446,7 +1446,7 @@ argument lists back to back. Wouldn't it be great if they weren't
there? there?
~~~~ ~~~~
# import task::spawn; # use task::spawn;
do spawn { do spawn {
debug!("Kablam!"); debug!("Kablam!");
} }
@ -1479,8 +1479,8 @@ fn each(v: ~[int], op: fn(int) -> bool) {
And using this function to iterate over a vector: And using this function to iterate over a vector:
~~~~ ~~~~
# import each = vec::each; # use each = vec::each;
# import println = io::println; # use println = io::println;
each(~[2, 4, 8, 5, 16], |n| { each(~[2, 4, 8, 5, 16], |n| {
if n % 2 != 0 { if n % 2 != 0 {
println(~"found odd number!"); println(~"found odd number!");
@ -1496,8 +1496,8 @@ out of the loop, you just write `break`. To skip ahead
to the next iteration, write `again`. to the next iteration, write `again`.
~~~~ ~~~~
# import each = vec::each; # use each = vec::each;
# import println = io::println; # use println = io::println;
for each(~[2, 4, 8, 5, 16]) |n| { for each(~[2, 4, 8, 5, 16]) |n| {
if n % 2 != 0 { if n % 2 != 0 {
println(~"found odd number!"); println(~"found odd number!");
@ -1512,7 +1512,7 @@ normally allowed in closures, in a block that appears as the body of a
function, not just the loop body. function, not just the loop body.
~~~~ ~~~~
# import each = vec::each; # use each = vec::each;
fn contains(v: ~[int], elt: int) -> bool { fn contains(v: ~[int], elt: int) -> bool {
for each(v) |x| { for each(v) |x| {
if (x == elt) { return true; } if (x == elt) { return true; }
@ -1760,22 +1760,22 @@ that path is several modules deep). Rust allows you to import
identifiers at the top of a file, module, or block. identifiers at the top of a file, module, or block.
~~~~ ~~~~
use std; extern mod std;
import io::println; use io::println;
fn main() { fn main() {
println(~"that was easy"); println(~"that was easy");
} }
~~~~ ~~~~
It is also possible to import just the name of a module (`import It is also possible to import just the name of a module (`use
std::list;`, then use `list::find`), to import all identifiers exported std::list;`, then use `list::find`), to import all identifiers exported
by a given module (`import io::*`), or to import a specific set by a given module (`use io::*`), or to import a specific set
of identifiers (`import math::{min, max, pi}`). of identifiers (`use math::{min, max, pi}`).
You can rename an identifier when importing using the `=` operator: You can rename an identifier when importing using the `=` operator:
~~~~ ~~~~
import prnt = io::println; use prnt = io::println;
~~~~ ~~~~
## Exporting ## Exporting
@ -1836,14 +1836,14 @@ fn main() {
} }
~~~~ ~~~~
An `import` directive will only import into the namespaces for which An `use` directive will only import into the namespaces for which
identifiers are actually found. Consider this example: identifiers are actually found. Consider this example:
~~~~ ~~~~
type bar = uint; type bar = uint;
mod foo { fn bar() {} } mod foo { fn bar() {} }
mod baz { mod baz {
import foo::bar; use foo::bar;
const x: bar = 20u; const x: bar = 20u;
} }
~~~~ ~~~~
@ -2089,8 +2089,8 @@ Spawning a task is done using the various spawn functions in the
module `task`. Let's begin with the simplest one, `task::spawn()`: module `task`. Let's begin with the simplest one, `task::spawn()`:
~~~~ ~~~~
import task::spawn; use task::spawn;
import io::println; use io::println;
let some_value = 22; let some_value = 22;
@ -2116,8 +2116,8 @@ receiving messages. The easiest way to create a pipe is to use
computations in parallel. We might write something like: computations in parallel. We might write something like:
~~~~ ~~~~
import task::spawn; use task::spawn;
import pipes::{stream, Port, Chan}; use pipes::{stream, Port, Chan};
let (chan, port) = stream(); let (chan, port) = stream();
@ -2137,7 +2137,7 @@ Let's walk through this code line-by-line. The first line creates a
stream for sending and receiving integers: stream for sending and receiving integers:
~~~~ {.ignore} ~~~~ {.ignore}
# import pipes::stream; # use pipes::stream;
let (chan, port) = stream(); let (chan, port) = stream();
~~~~ ~~~~
@ -2146,8 +2146,8 @@ once it is complete. The channel will be used by the child to send a
message to the port. The next statement actually spawns the child: message to the port. The next statement actually spawns the child:
~~~~ ~~~~
# import task::{spawn}; # use task::{spawn};
# import comm::{Port, Chan}; # use comm::{Port, Chan};
# fn some_expensive_computation() -> int { 42 } # fn some_expensive_computation() -> int { 42 }
# let port = Port(); # let port = Port();
# let chan = port.chan(); # let chan = port.chan();
@ -2167,7 +2167,7 @@ some other expensive computation and then waiting for the child's result
to arrive on the port: to arrive on the port:
~~~~ ~~~~
# import pipes::{stream, Port, Chan}; # use pipes::{stream, Port, Chan};
# fn some_other_expensive_computation() {} # fn some_other_expensive_computation() {}
# let (chan, port) = stream::<int>(); # let (chan, port) = stream::<int>();
# chan.send(0); # chan.send(0);
@ -2188,8 +2188,8 @@ the string in response. The child terminates when `0` is received.
Here is the function that implements the child task: Here is the function that implements the child task:
~~~~ ~~~~
# import std::comm::DuplexStream; # use std::comm::DuplexStream;
# import pipes::{Port, Chan}; # use pipes::{Port, Chan};
fn stringifier(channel: DuplexStream<~str, uint>) { fn stringifier(channel: DuplexStream<~str, uint>) {
let mut value: uint; let mut value: uint;
loop { loop {
@ -2211,9 +2211,9 @@ response itself is simply the strified version of the received value,
Here is the code for the parent task: Here is the code for the parent task:
~~~~ ~~~~
# import std::comm::DuplexStream; # use std::comm::DuplexStream;
# import pipes::{Port, Chan}; # use pipes::{Port, Chan};
# import task::spawn; # use task::spawn;
# fn stringifier(channel: DuplexStream<~str, uint>) { # fn stringifier(channel: DuplexStream<~str, uint>) {
# let mut value: uint; # let mut value: uint;
# loop { # loop {