**Int to string**
-Use [`ToStr`](../std/to_str/trait.ToStr.html).
+Use [`ToStr`](std/to_str/trait.ToStr.html).
~~~
let x: int = 42;
**String to int**
-Use [`FromStr`](../std/from_str/trait.FromStr.html), and its helper function,
-[`from_str`](../std/from_str/fn.from_str.html).
+Use [`FromStr`](std/from_str/trait.FromStr.html), and its helper function,
+[`from_str`](std/from_str/fn.from_str.html).
~~~
let x: Option<int> = from_str("42");
**String to int, in non-base-10**
-Use [`FromStrRadix`](../std/num/trait.FromStrRadix.html), and its helper
-function, [`from_str_radix`](../std/num/fn.from_str_radix.html).
+Use [`FromStrRadix`](std/num/trait.FromStrRadix.html), and its helper
+function, [`from_str_radix`](std/num/fn.from_str_radix.html).
~~~
use std::num;
**Vector of Bytes to String**
To return a Borrowed String Slice (&str) use the str helper function
-[`from_utf8`](../std/str/fn.from_utf8.html).
+[`from_utf8`](std/str/fn.from_utf8.html).
~~~
use std::str;
~~~
To return an Owned String use the str helper function
-[`from_utf8_owned`](../std/str/fn.from_utf8_owned.html).
+[`from_utf8_owned`](std/str/fn.from_utf8_owned.html).
~~~
use std::str;
let y: String = x.unwrap();
~~~
-To return a [`MaybeOwned`](../std/str/enum.MaybeOwned.html) use the str helper
-function [`from_utf8_lossy`](../std/str/fn.from_utf8_owned.html).
+To return a [`MaybeOwned`](std/str/type.MaybeOwned.html) use the str helper
+function [`from_utf8_lossy`](std/str/fn.from_utf8_owned.html).
This function also replaces non-valid utf-8 sequences with U+FFFD replacement
character.
## How do I read from a file?
Use
-[`File::open`](../std/io/fs/struct.File.html#method.open)
+[`File::open`](std/io/fs/struct.File.html#method.open)
to create a
-[`File`](../std/io/fs/struct.File.html)
+[`File`](std/io/fs/struct.File.html)
struct, which implements the
-[`Reader`](../std/io/trait.Reader.html)
+[`Reader`](std/io/trait.Reader.html)
trait.
~~~ {.ignore}
## How do I iterate over the lines in a file?
-Use the [`lines`](../std/io/trait.Buffer.html#method.lines) method on a [`BufferedReader`](../std/io/buffered/struct.BufferedReader.html).
+Use the [`lines`](std/io/trait.Buffer.html#method.lines) method on a
+[`BufferedReader`](std/io/struct.BufferedReader.html).
~~~
use std::io::BufferedReader;
## How do I search for a substring?
-Use the [`find_str`](../std/str/trait.StrSlice.html#tymethod.find_str) method.
+Use the [`find_str`](std/str/trait.StrSlice.html#tymethod.find_str) method.
~~~
let str = "Hello, this is some random string";
## How do I get the length of a vector?
-The [`Container`](../std/container/trait.Container.html) trait provides the `len` method.
+The [`Container`](std/container/trait.Container.html) trait provides the `len` method.
~~~
let u: Vec<u32> = vec![0, 1, 2];
## How do I iterate over a vector?
-Use the [`iter`](../std/vec/trait.ImmutableVector.html#tymethod.iter) method.
+Use the [`iter`](std/slice/trait.ImmutableVector.html#tymethod.iter) method.
~~~
let values: Vec<int> = vec![1, 2, 3, 4, 5];
}
~~~
-(See also [`mut_iter`](../std/vec/trait.MutableVector.html#tymethod.mut_iter)
+(See also [`mut_iter`](std/slice/trait.MutableVector.html#tymethod.mut_iter)
which yields `&mut int` and
-[`move_iter`](../std/vec/trait.OwnedVector.html#tymethod.move_iter) which yields
+[`move_iter`](std/slice/trait.OwnedVector.html#tymethod.move_iter) which yields
`int` while consuming the `values` vector.)
# Type system
* The extra library's [json] module. Enums and pattern matching
[sprocketnes]: https://github.com/pcwalton/sprocketnes
-[hash]: https://github.com/mozilla/rust/blob/master/src/libstd/hash.rs
+[hash]: https://github.com/mozilla/rust/blob/master/src/libstd/hash/mod.rs
[HashMap]: https://github.com/mozilla/rust/blob/master/src/libcollections/hashmap.rs
[json]: https://github.com/mozilla/rust/blob/master/src/libserialize/json.rs
can be combined to control the exact logging you want to see. For example, when
debugging linking in the compiler you might set
`RUST_LOG=rustc::metadata::creader,rustc::util::filesearch,rustc::back::rpath`
-For a full description see [the language reference][1].
+For a full description see [the logging crate][1].
-[1]:http://doc.rust-lang.org/doc/master/rust.html#logging-system
+[1]:log/index.html
The second of these two functions, `eh_personality`, is used by the failure
mechanisms of the compiler. This is often mapped to GCC's personality function
-(see the [libstd implementation](../std/rt/unwind/) for more information), but
-crates which do not trigger failure can be assured that this function is never
-called.
+(see the [libstd implementation](std/rt/unwind/index.html) for more
+information), but crates which do not trigger failure can be assured that this
+function is never called.
## Using libcore
With the above techniques, we've got a bare-metal executable running some Rust
code. There is a good deal of functionality provided by the standard library,
however, that is necessary to be productive in Rust. If the standard library is
-not sufficient, then [libcore](../core/) is designed to be used instead.
+not sufficient, then [libcore](../core/index.html) is designed to be used
+instead.
The core library has very few dependencies and is much more portable than the
standard library itself. Additionally, the core library has most of the
pub mod rc;
#[cfg(not(test))]
+#[doc(hidden)]
mod std {
pub use core::fmt;
pub use core::option;
// crate.
mod should_not_exist;
+#[doc(hidden)]
mod core {
pub use failure;
}
+#[doc(hidden)]
mod std {
pub use clone;
pub use cmp;
//! similar and complementary: they are often employed to indicate a
//! lack of a return value; and they are trivially converted between
//! each other, so `Result`s are often handled by first converting to
-//! `Option` with the [`ok`](enum.Result.html#method.ok) and
-//! [`err`](enum.Result.html#method.ok) methods.
+//! `Option` with the [`ok`](type.Result.html#method.ok) and
+//! [`err`](type.Result.html#method.ok) methods.
//!
//! Whereas `Option` only indicates the lack of a value, `Result` is
//! specifically for error reporting, and carries with it an error
needs_termination = true;
}
Some(&cnum) => {
+ let path = m.paths.get(&ast::DefId {
+ krate: cnum,
+ node: ast::CRATE_NODE_ID,
+ });
let loc = match *m.extern_locations.get(&cnum) {
render::Remote(ref s) => Some(s.to_string()),
render::Local => {
let loc = current_location_key.get().unwrap();
- Some(("../".repeat(loc.len())).to_string())
+ Some("../".repeat(loc.len()))
}
render::Unknown => None,
};
match loc {
- Some(s) => {
- try!(write!(f, "<a href='{}/primitive.{}.html'>",
- s, prim.to_url_str()));
+ Some(root) => {
+ try!(write!(f, "<a href='{}{}/primitive.{}.html'>",
+ root,
+ path.ref0().as_slice().head().unwrap(),
+ prim.to_url_str()));
needs_termination = true;
}
None => {}
if s.len() == 0 { return Ok(()); }
try!(write!(f, "<code> = </code>"));
if s.contains("\n") {
- write!(f, "<a href='{}'>[definition]</a>",
- item.href())
+ match item.href() {
+ Some(url) => {
+ write!(f, "<a href='{}'>[definition]</a>",
+ url)
+ }
+ None => Ok(()),
+ }
} else {
write!(f, "<code>{}</code>", s.as_slice())
}
}
try!(write!(w, "</ul>"));
try!(write!(w, r#"<script type="text/javascript" async
- src="{root_path}/implementors/{path}/\
- {ty}.{name}.js"></script>"#,
+ src="{root_path}/implementors/{path}/{ty}.{name}.js">
+ </script>"#,
root_path = Vec::from_elem(cx.current.len(), "..").connect("/"),
path = if ast_util::is_local(it.def_id) {
cx.current.connect("/")
}
}
+#[doc(hidden)]
pub trait HomingIO {
fn home<'r>(&'r mut self) -> &'r mut HomeHandle;
projects / rust.git / commitdiff