From 9d80dad9d8e5a3cda408a40e8b1809e6c1302dc6 Mon Sep 17 00:00:00 2001 From: Andrew Brinker Date: Mon, 31 Aug 2015 20:45:04 -0400 Subject: [PATCH 01/94] Added FAQ --- _config.yml | 2 + _layouts/faq.html | 98 +++++ css/style.css | 208 ++++++++++ faq.md | 963 ++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 1271 insertions(+) create mode 100644 _layouts/faq.html create mode 100644 faq.md diff --git a/_config.yml b/_config.yml index d4bacfa14..116722f6b 100644 --- a/_config.yml +++ b/_config.yml @@ -1,2 +1,4 @@ name: The Rust Programming Language markdown: redcarpet +redcarpet: + extensions: ["tables"] diff --git a/_layouts/faq.html b/_layouts/faq.html new file mode 100644 index 000000000..51c232db8 --- /dev/null +++ b/_layouts/faq.html @@ -0,0 +1,98 @@ +--- +layout: default +--- + + + +
+ {{ content }} +
+

Copyright © 2011-2015 The Rust Project Developers.
+ Licensed under the Apache License, Version 2.0 or the MIT license, at your option.
+ This file may not be copied, modified, or distributed except according to those terms.

+
+
+ + + + + diff --git a/css/style.css b/css/style.css index ace966057..d5f0772c7 100644 --- a/css/style.css +++ b/css/style.css @@ -383,3 +383,211 @@ ul.laundry-list { text-align: right; margin: 5px 10px 0 0; } + +.faq { + font-size: 16px; + line-height: 1.5em; + border-top: 1px solid #dedede; + margin-top: 2rem; + margin-bottom: 8rem; + padding-top: 4rem; + padding-right: 4rem; +} + + .faq p, + .faq ul, + .faq ol, + .faq blockquote, + .faq pre { + margin: 0 0 1rem 6rem; + font-family: "Source Serif Pro"; + } + + .faq ul, + .faq ol { + padding: 0; + } + + .faq ul { + counter-reset: uli; + } + + .faq ul > li { + list-style: none; + position: relative; + } + + .faq ul > li:before { + content: counter(uli); + counter-increment: uli; + color: #999; + position: absolute; + top: 0; + left: -1.5em; + width: 1em; + font-family: "Fira Sans"; + text-align: right; + } + + .faq ol { + counter-reset: oli; + } + + .faq ol > li { + list-style: none; + position: relative; + } + + .faq ol > li:before { + content: counter(oli); + counter-increment: oli; + color: #999; + position: absolute; + top: 0; + left: -1.5em; + width: 1em; + font-family: "Fira Sans"; + text-align: right; + } + + .faq blockquote { + border-left: .25em solid #dedede; + padding-left: 2rem; + } + + .faq blockquote p { + margin: 0; + } + + .faq h1 { + font-size: 2.5em; + line-height: 1.5em; + margin: 0 0 1rem 6rem; + font-weight: 400; + position: relative; + } + + .faq h1::before { + content: "Draft"; + position: absolute; + top: 1.25rem; + left: -6rem; + font-size: 1.5rem; + line-height: 1em; + display: inline-block; + font-weight: 400; + color: hsla(50, 90%, 30%, 1); + text-align: center; + background-color: hsla(50, 90%, 80%, 1); + border-bottom: 3px solid hsla(50, 90%, 50%, 1); + padding: .55em .5em .2em; + border-radius: .25em; + } + + .faq h2 { + font-size: 2em; + line-height: 1.5em; + margin: 3rem 0 1rem; + font-weight: 400; + border-top: 4px solid #dedede; + padding-top: 1rem; + } + + .faq h2 a { + color: #333; + text-decoration: none; + } + + .faq h3 { + font-size: 1.5em; + line-height: 1.3em; + font-weight: 500; + margin: 3rem 0 1rem; + } + + .faq h2 + h3 { + margin-top: 2rem; + } + + .faq h4 { + font-size: 1em; + line-height: 1.5em; + font-weight: 500; + margin: 2rem 0 .25rem; + } + + .faq li { + margin: 0; + padding: 0; + } + + .faq pre { + margin-top: 2rem; + margin-bottom: 2rem; + } + + .faq code { + display: inline-block; + padding: .1em .2em 0; + line-height: 1em; + background-color: #f7f7f7; + border-radius: .15em; + font-weight: 400; + font-family: Consolas, "Andale Mono WT", "Andale Mono", "Lucida Console", "Lucida Sans Typewriter", "DejaVu Sans Mono", "Bitstream Vera Sans Mono", "Liberation Mono", "Nimbus Mono L", Monaco, "Courier New", Courier, monospace; + } + + .faq pre code { + font-size: 1em; + line-height: 1.5em; + } + + .faq .copyright { + font-size: .8em; + color: #999; + border-top: 1px solid #dedede; + margin-top: 6rem; + padding-top: 2rem; + } + +#toc { + margin-top: 2rem; + padding: 2rem; + background-color: #f7f7f7; + border-radius: .25em; + border: 1px solid #ccc; +} + + #toc h2 { + font-family: "Fira Sans"; + border: 0; + margin: 0 -2rem 2rem; + padding: 0 2rem 1rem; + font-size: 2rem; + line-height: 1.5em; + border-bottom: 1px solid #ccc; + } + + #toc ol { + counter-reset: tos; + margin: 0; + padding: 0; + -webkit-columns: 150px 3; + -moz-columns: 150px 3; + columns: 150px 3; + } + + #toc li { + margin-left: 1em; + } + + #toc li::before { + content: counter(tos); + counter-increment: tos; + } + +.todo { + background-color: #FFCC00; + padding: 1em 1em .75em; + border-radius: .25em; + font-family: "Fira Sans"; +} diff --git a/faq.md b/faq.md new file mode 100644 index 000000000..01914ab5e --- /dev/null +++ b/faq.md @@ -0,0 +1,963 @@ +--- +layout: faq +title: Frequently Asked Questions · The Rust Programming Language +--- + +# Frequently Asked Questions + +This document exists to answer some common questions about the Rust programming language. It is not a complete guide to the language, nor is it a tool for teaching the language. Rather, it exists as a reference to answer oft-repeated questions people in the Rust community encounter, and to clarify some of the design and history of the language. + +If there is some common or important question you feel is wrongly left unanswered here, feel free to [help us fix it](https://github.com/rust-lang/rust-www/blob/master/CONTRIBUTING.md). + +
+ +## Performance + +#### How fast is Rust? + +As always, this question is difficult to answer. There's still a lot of work to do on speed, and depending on what you're benchmarking, Rust has variable performance. + +That said, it is an explicit goal of Rust to be as fast as C++ for most things. Language decisions are made with performance in mind, and we want Rust to be as fast as possible. Given that Rust is built on top of LLVM, any performance improvements in it also help Rust become faster. + +#### Is Rust garbage collected? + +No. A language that requires a GC is a language that opts into a larger, more complex runtime than Rust cares for. Rust is usable on bare metal with no extra runtime. Additionally, garbage collection is frequently a source of non-deterministic behavior. Rust provides the tools to make using a GC possible and even pleasant, but it should not be a requirement for implementing the language. + +#### Why is my program compiled with `cargo build` slow? + +Did you compile with the `--release` flag? The Rust language uses a lot of optimizations in release mode that make the language competitive with C and C++, but you need to explicitly ask for them, as they also result in longer compilation times that may be undesirable during development. + +#### Why is Rust compilation slow? + +It's a combination of factors. Both the type inference and safety-related checks are fairly complex. They make life easier for the programmer, but they require some time to run. Add in the optimizations, and Rust's compilation is slower than a simpler language that doesn't provide Rust's safety guarantees. + +But all is not lost. The Rust compiler has evolved significantly over a number of years, and a lot of good work is being done to make it work faster. So expect improvements in compilation speed over time. + +#### Why is Rust's HashMap so slow? + +Rust's default hashing algorithm is cryptographically secure, which means it's great if you need something that can't be easily guessed at, but you pay for that with slower performance relative to a non-cryptographically secure algorithm. + +Even so, it's [actually not](https://www.reddit.com/r/rust/comments/3hw9zf/rust_hasher_comparisons/cub4oh6) too bad. As you can see from [these benchmark comparisons](http://cglab.ca/~abeinges/blah/hash-rs/) of different hashing implementations in Rust, Rust's SipHash implementation (the default) is a solid choice for a wide variety of purposes. + +#### Can I run benchmarks using test::Bencher on the beta or stable channel? + +Sadly, no. The `test` feature, which is necessary for testing and benchmarking in Rust, is restricted to the nightly channel. + +#### Does Rust do tail-call optimization? + +In general, tail-call optimization is not guaranteed: see [here](https://mail.mozilla.org/pipermail/rust-dev/2013-April/003557.html) for a detailed explanation with references. There was a [proposed extension](https://github.com/rust-lang/rfcs/pull/81) that would allow tail-call elimination in certain contexts, but it is currently postponed. The compiler is still free to optimize tail-calls [when it pleases](http://llvm.org/docs/CodeGenerator.html#sibling-call-optimization), however. + +#### Does Rust have a runtime? + +Rust has a [very small and limited runtime](https://github.com/Kimundi/lazy-static.rs) providing a heap, unwinding and backtrace support, and stack guards. This runtime is comparable to the [C runtime](http://www.embecosm.com/appnotes/ean9/html/ch05s02.html), and allows for the calling of Rust functions from C without setup. + +## Concurrency + +#### Can I use globals across threads without `unsafe`? + +No, even if the type implements `Sync`. + +Types which are `Sync` are thread-safe when multiple shared references to them are used concurrently. Types which are not `Sync` are not thread-safe, and thus when used in a global require `unsafe` to use. + +That being said, having multiple aliasing `&mut T`s is never allowed. Due to the nature of globals the borrow checker cannot possibly ensure that a `static` obeys the borrowing rules, so taking a mutable reference to a `static` is always unsafe. + +## Error Handling + +#### Why doesn't Rust have exceptions? + +The design issues of exception handling in programming language have been covered at length elsewhere. Exceptions complicate understanding of control-flow, they express validity/invalidity with a system outside of the type system, they interoperate poorly with multithreaded code (a major focus of Rust), the list goes on. + +Rust instead opted for a type-based approach to error handling, which is [covered at length in the book](https://doc.rust-lang.org/nightly/book/error-handling.html#the-limits-of-combinators) (the improved chapter is only on nightly at the moment, but will be on stable soon. Everything it covers works on stable). This fits more nicely with Rust's control flow, concurrency, and everything else. + +#### What's the deal with `unwrap()` everywhere? + +`unwrap()` is a function that gets the value out of an `Option` or `Result` and panics if its not there. It is useful both for causing catastrophic failure in certain cases, but it more useful for quick prototypes where you don't want to handle an error yet, or blog posts where error handling would distract from the main point. `unwrap()` shouldn't be your default way to handle errors, but it is a useful tool to have when you need it. + +#### Why do I get an error when I try to run example code that uses the `try!` macro? + +It's probably an issue with return types. The [`try!` macro](https://doc.rust-lang.org/stable/std/macro.try!.html) either extracts the value from a `Result`, or returns early with the error `Result` is carrying. This means that try only works for functions that return `Result` themselves, where the second type implements `From::from(err)`. + +#### Is there an easier way to do error handling than having `Result`s everywhere? + +If you're looking for a way to avoid handling `Result`s in other people's code, there's always `unwrap()`, but it's probably not what you actually want. `Result` is an indicator that some computation may or may not complete. The fact that some languages allow you to ignore failure cases is an anti-feature. Forcing you to handle them is one of the ways that Rust encourages safety. So, if you really don't want to handle error, use `unwrap()`, but you should probably just handle the error for real. + +## Numerics + +#### Should I default to using `f32` or `f64`? + +The choice of which to use is dependent on the focus of the program. + +If you're interested in the greatest degree of precision with your floating point numbers, then `f64` is the preferred choice. If you're more interested in keeping the size of the value small, then `f32` is better. + +All things being equal, `f64` is likely a better default. + +#### Why can't I compare floats? + +You can! Floats implement the `PartialOrd` trait, which means that `>`, `<`, `<=`, and `>=` are defined for them. But they do _not_ implement the `Ord` trait, because (thanks to `NaN`) there is no total ordering for floating point numbers. + +So you can do all the normal comparison operations you would expect, but you can't use the `cmp` function. + +#### Why can't I use `f32` or `f64` as `HashMap` keys? + +In order to be used as a key in a `HashMap`, a type must implement the `Eq` and `Hash` traits. `f32` and `f64` implement `PartialEq`, but not `Eq`, because both types include `NaN` (stands for "not a number"). `NaN` values are not equal to any float, and are not equal to each other, so there is no total ordering over floating point types in Rust. This means that `f32` and `f64` can't be used as keys in a HashMap. + +#### How can I convert between numeric types? + +There are three ways: the `as` keyword, which does simple casting for primitive types, the `Into` and `From` traits, which are implemented for a number of type conversions (and which you can implement for your own types), and `transmute`, which is an unsafe function that tells the compiler to treat the bits of one type as those of another type. + +## Syntax + +#### Why curly braces? Why can't everything be like Haskell/Python? + +Flexibility, simplicity, and correctness. Curly braces allow for more flexible syntax for the programmer, a simpler parser in the compiler, and help reduce the possibility of logic mistakes caused by incorrect indentation, like Apple's classic [goto fail](https://gotofail.com/) bug. + +#### I can leave out parentheses on if conditions, why do I have to put brackets around single line blocks? Why is the C style not allowed? + +A single line block may not always be a single line block. Forgetting to add in the brackets when you add a line to an `if` block can be the cause of some serious programming errors (just look at Apple's ["goto fail"](https://gotofail.com/) bug). In the interest of safety, Rust makes you use the blocks every time. + +#### Why is there no literal syntax for dictionaries? + +Dictionaries (or `HashMap`s in Rust parlance) aren't a primitive data type, and so they don't get literal syntax. If you want to make a `HashMap`, use `HashMap::new()`. + +#### When should I use an implicit return? + +You should use an implicit return everywhere it can be used. Unless you're writing an early return (before the end of a function, where typing `return` is mandatory), it should be implicit. + +#### Why aren't function signatures inferred? + +- Mechanically, it simplifies the inference algorithm; inference only requires looking at one function at a time. +- The same simplification goes double for human readers. A reader does not need an IDE running an inference algorithm across an entire crate to be able to guess at a function's argument types; it's always explicit and nearby. + +#### Why does `match` have to be exhaustive? + +`match` being exhaustive has some useful properties. First, if every possibility is covered by the `match`, adding further variants to the `enum` in the future will prompt a compilation failure, rather than runtime panic. Second, it makes cost explicit. In general, the only safe way to have a non-exhaustive `match` would be to panic the thread if nothing is matched, though it could fall through if the type of the `match` expression is `()`. This sort of hidden cost and special casing is against the language's philosophy. It's easy to ignore all unspecified cases by using the `_` wildcard: + +```rust +match val.do_something() { + Cat(a) => { /* ... */ } + _ => { /* ... */ } +} +``` + +## Lifetimes + +#### Why lifetimes? + +Lifetimes are Rust's answer to garbage collection. They are a way of ensuring memory safety without paying hefty performance costs. They are based on a variety of academic work, which can be found in the [Rust book](https://doc.rust-lang.org/stable/book/academic-research.html#type-system). + +#### Why is the lifetime syntax the way it is? + +The `'a` syntax comes from the ML family of programming languages, where `'a` is used to indicate a generic type parameter. For Rust, the syntax had to be something that was unambiguous, noticable, and fit nicely in a type right alonside traits and references. Alternative syntaxes have been discussed, but this seemed to work just fine. + +#### When is `Rc` useful? + +This is covered in the [official documentation for `Rc`](https://doc.rust-lang.org/stable/std/rc/). In short, `Rc` and its thread-safe cousin `Arc` are useful to express shared ownership of an immutable value, and have the system automatically deallocate the associated memory when no one has access to it. + +#### How do I return a borrow to something I created from a function? + +You need to ensure that the borrowed-to item will outlive the function. This can be done in two ways: by binding the output lifetime to some input lifetime, or by declaring the output lifetime as static. The first option is significantly better than the second. + +Here is an example of the each: + +```rust +// The first method +fn example1<'a>(s: &'a str) -> &'a str { + // Do something... +} + +// The second method +fn example2<'a>(s: &'a str) -> &'static str { + // Do something else... +} +``` + +The problem with declaring the lifetime as `static` is that it's rarely what you actually mean, and is instead a way of escaping the lifetime system. References with a `static` lifetime outlive everything else, and this means that they can be used in ways that would otherwise be invalid with the first method. + +#### How do I return a closure from a function? + +To return a closure from a function, it must be what's called a "move closure", meaning that the closure is declared with the `move` keyword. As [explained in the Rust book](https://doc.rust-lang.org/book/closures.html#move-closures), this gives the closure its own stack frame, so it is not dependent on its parent stack frame. Otherwise, returning a closure would be unsafe, as it would allow access to variables that are no longer defined (put another way, it would allow reading potentially invalid memory). + +#### When are lifetimes required to be defined? + +Lifetimes can often be elided, as explained in the ["Lifetime elision" section](https://doc.rust-lang.org/book/lifetimes.html#lifetime-elision) of the Rust book. "Elided lifetimes" are those lifetimes with are implicit in any code containing references. They are automatically inserted by the compiler with the three following rules: + +- Each elided lifetime in a function’s arguments becomes a distinct lifetime parameter. +- If there is exactly one input lifetime, elided or not, that lifetime is assigned to all elided lifetimes in the return values of that function. +- If there are multiple input lifetimes, but one of them is &self or &mut self, the lifetime of self is assigned to all elided output lifetimes. + +If these rules would result in incorrect code elsewhere, then the Rust compiler will provide errors, and you will need to define the relevant lifetimes to correct that error. + +#### How can Rust guarantee "no null pointers"? + +Data values in the language can only be constructed through a fixed set of initializer forms. Each of those forms requires that its inputs already be initialized. A liveness analysis ensures that local variables are initialized before use. + +## Ownership + +#### How can I implement a graph or other data structure that contains cycles? + +There are two major options: + +- You can implement it using `Weak` or `Rc` to allow shared ownership of nodes, +although this approach pays the cost of memory management. +- You can implement it using `unsafe` code using raw pointers. This will be +more efficient, but bypasses Rust's safety guarantees. + +#### How can I define a struct that contains a pointer to one of its own fields? + +At the moment, you can't without `unsafe`. If you have a struct with a pointer to one of its own fields, the Rust compiler has no way to know if the pointed-to field will be destroyed before or after the containing struct, and so it can't guarantee that the pointer into the field won't potentially point to invalid memory. + +#### What does it mean to "consume a value"? + +"Consuming a value" means taking ownership of a value and then dropping it. When this is done, the value can't be used elsewhere. + +#### What is the difference between consuming and moving/taking ownership? + +Consuming means that the value has been dropped, and is no longer defined. With just a move, the value is still alive, but ownership has been transferred to a new owner, meaning the old owner can no longer modify it or lend out references. + +#### Why when I pass a struct to a function the compiler says it's been moved and I can't use it anymore, when the same doesn't happen for integers? + +If a type implements the `Copy` trait, then it will be copied when passed to a function. All numeric types in Rust implement `Copy`, but function types do not, so they are moved instead. This means that the function can no longer be used elsewhere, unless it is moved back out of the function via the return. + +#### How do you deal with a "Use of moved value" error? + +This error means that the value you're trying to use has been moved to a new owner. The first thing to check is whether the move in question was necessary. If it moved into a function, it may be possible to rewrite the function to use a reference, rather than moving. It may also be possible to implement `Copy` (for implicit copying, rather than moving) or `Clone` (explicit copying) for the type in question. If none of these are possible, you may want to return ownership of the value when the function is done, thus eliminating this error. + +#### What are the rules for using `self`, `&self`, or `&mut self` in a method declaration? + +If a method needs to consume the struct, declare it with `self` as the first parameter, if it only needs a reference use `&self`, and if it needs to mutate the struct without consuming it use `&mut self`. + +#### How can I understand the borrow checker? + +There is a certain desire to act as if the borrow checker is some mysterious zen master, doling out knocks on the head whenever its koans are misunderstood. The reality is a little different. In fact, the borrow checker is simply applying a couple simple rules, which can be found in the Rust book's [section on borrowing](https://doc.rust-lang.org/stable/book/references-and-borrowing.html#the-rules): + +> First, any borrow must last for a scope no greater than that of the owner. Second, you may have one or the other of these two kinds of borrows, but not both at the same time: +> +> - one or more references (&T) to a resource. +> - exactly one mutable reference (&mut T) + +Understanding these rules and understanding [lifetimes](https://doc.rust-lang.org/stable/book/lifetimes.html) is all you need to do to understand the borrow checker. + +#### How do deref coercions work? + +[Deref coercions](https://doc.rust-lang.org/book/deref-coercions.html) exist to make using Rust more ergonomic, and are implemented via the [`Deref`](https://doc.rust-lang.org/stable/std/ops/trait.Deref.html) trait, which looks like this: + +```rust +pub trait Deref { + type Target: ?Sized; + fn deref(&'a self) -> &'a Self::Target; +} +``` + +A Deref implementation indicates that the implementing type may be converted into `Target` by a call to the `deref` function, which takes an immutable reference of a certain lifetime to the calling struct, and returns a reference of the same lifetime to the target. + +You can see a [full list of `Deref` implementations](https://doc.rust-lang.org/stable/std/ops/trait.Deref.html#implementors) for the standard library in the documentation. + +## Stability + +#### Can I use unstable features in the beta or stable channel? + +No, you cannot. Rust works hard to provide strong guarantees about the stability of the APIs provided on the beta and stable channels. When something is unstable, it means that we can't provide those guarantees for it yet, and don't want people relying on it staying the same. This gives us the opportunity to try changes in the wild on the nightly channel, while still maintaining strong guarantees for people seeking stability. + +Things stabilize all the time, and the beta and stable channels update every six weeks, so if you're waiting for a feature to be available without using the nightly channel, it should hopefully happen quickly. + +## Strings + +#### How can I convert a `String` or `Vec` to a slice (`&str` and `&[T]`)? + +Using Deref coercions! `Strings` and `Vec`s will automatically coerce to their respective slices when referenced. + +#### How can I convert from `&str` to `String` or the other way around? + +`String`s are automatically converted into `&str` when you take a reference of them. For example, the following code works: + +```rust +fn say_hello(name: &str) { + println!("Hello {}!", name); +} + +fn main() { + let s = "Jane Doe".to_owned(); + say_hello(&s); +} +``` + +The `to_owned()` is how you convert from a `&str` into a `String`. This is necessary because string literals in Rust are of type `&str`. In this particular example, making `s` into a `String` isn't actually necessary, and the code could be rewritten as: + +```rust +fn say_hello(name: &str) { + println!("Hello {}!", name); +} + +fn main() { + let s = "Jane Doe"; + say_hello(s); +} +``` + +#### How do I split a `String` into lines? + +The [`lines()`](https://doc.rust-lang.org/stable/std/string/struct.String.html#method.lines) function for `String`s provides an iterator over the lines of a string, which can then be `collect()`ed into a container of lines like so: + +```rust +let s = "This\nis\na\ntest"; +let v: Vec<&str> = s.lines().collect(); +``` + +#### What are the differences between the different string types? + +`String` is an owned string type, while `&str` is a string slice. For a more detailed explanation, [check out the Rust book](https://doc.rust-lang.org/stable/book/). + +#### How do I do O(1) character access in a `String`? + +You don't, not without converting the `String` into something else. If you do that, it comes with some serious caveats. Strings in Rust are all UTF-8 encoded, and O(1) access to characters is impossible in UTF-8. If you index by bytes as you normally would in ASCII strings you'll get a UTF-8 codepoint, which may or may not be an actual character. + +If you are absolutely certain your string is in fact ASCII, you can get O(1) access by indexing the underlying buffer like so: + +```rust +let s = "This is a test."; +let bytes = s.into_bytes(); +let c = bytes[2]; // 'i' character +``` + +But remember that this operation is almost certainly wrong most of the time. + +#### Why are strings UTF-8 by default? + +The `str` type is UTF-8 because we observe more text in the wild in this encoding – particularly in network transmissions, which are endian-agnostic – and we think it's best that the default treatment of I/O not involve having to recode codepoints in each direction. + +This does mean that indexed access to a Unicode codepoint inside a `str` value is an O(n) operation. On the one hand, this is clearly undesirable; on the other hand, this problem is full of trade-offs and we'd like to point a few important qualifications: + +Scanning a `str` for ASCII-range codepoints can still be done safely octet-at-a-time. If you use `.as_bytes()`, pulling out a `u8` costs only `O(1)` and produces a value that can be cast and compared to an ASCII-range `char`. So if you're (say) line-breaking on `'\n'`, octet-based treatment still works. UTF8 was well-designed this way. + +Most "character oriented" operations on text only work under very restricted language assumptions sets such as "ASCII-range codepoints only". Outside ASCII-range, you tend to have to use a complex (non-constant-time) algorithm for determining linguistic-unit (glyph, word, paragraph) boundaries anyways. We recommend using an "honest" linguistically-aware, Unicode-approved algorithm. + +The `char` type is UCS4. If you honestly need to do a codepoint-at-a-time algorithm, it's trivial to write a `type wstr = [char]`, and unpack a `str` into it in a single pass, then work with the `wstr`. In other words: the fact that the language is not "decoding to UCS4 by default" shouldn't stop you from decoding (or re-encoding any other way) if you need to work with that encoding. + +## Collections + +#### Can I implement data structures like vectors and linked lists efficiently in Rust? + +If your reason for implementing these data structures is to use them for other programs, there's no need, as all the common data structures are provided with the standard library. + +If, however, your reason is simply to learn, then you will likely need to dip into unsafe code. While these data structures _can_ be implemented entirely in safe Rust, the performance is likely to be worse than they would be with the use of unsafe code. The simple reason for this is that data structures like vectors and link lists rely on pointer and memory operations that are disallowed by safe Rust. + +For example, a doubly-linked list requires that there be two mutable references to each node, but this violates Rust's mutable reference aliasing rules. You can solve this using `Weak`, but the performance will be poorer than you likely want. + +#### How can I join a `Vec` (or an array) of strings into a single string? + +Whether the strings are owned strings (`String`) or string slices (`&str`), you can accomplish this with a fold, like so: + +```rust +fn main() { + // For vector of `&str` + let v1 = vec!["This ", "is ", "a ", "sentence."]; + let s1 = v1.iter.fold(String::new(), |acc, s| acc.push_str(s)); + println!("{}", s1); // >> This is a sentence. + + // For vector of `String` + let v2 = vec![ + "This ".to_owned(), + "is ".to_owned(), + "another ".to_owned(), + "sentence.".to_owned() + ]; + let s2 = v2.iter.fold(String::new(), |acc, &s| acc.push_str(s)); + println!("{}", s2); // >> This is another sentence. +} +``` + +#### How can I iterate over a `Vec` without moving/consuming it? + +The easiest way is by using `Vec`'s `IntoIterator` implementation, like so: + +```rust +let v = vec![1,2,3,4,5]; +for item in &v { + print!("{} ", item); +} +println!("\nLength: {}", v.len()); +``` + +The way Rust `for` loops work, they actually call `into_iter()` (which is defined in the `IntoIterator` trait) for whatever you are trying to iterate over. `IntoIterator` is implemented for `&'a Vec` and `&'a mut Vec`, meaning you can iterate over a vector without consuming it just be using `&v` or `&mut v` (for some vector `v`). + +#### How do you write a linked list in Rust? + +You probably don't need to. The Rust standard library provides a doubly-linked list for free. But if you're looking to do it just for personal edification, there are three ways of doing it: + +- Write it as a classic algebraic data-type (also called a "cons list"). This is easiest, but the performance characteristics aren't good at all +- Write it using `Weak` or `Rc` to allow shared ownership of nodes. This can work, but is also a pain. If you're using `Rc`, you need some way to break cycles, otherwise no memory will ever be freed. +- Use `unsafe`. This is the most performant, but also the toughest, because you can't rely on Rust's safety guarantees. + +#### Why do I need to type the array size in the array declaration? + +You don't necessarily have to. If you're declaring an array directly, the size is inferred based on the number of elements. But if you're declaring a function that takes an array, the compiler has to know how big that array will be. + +One thing to note is that currently Rust doesn't offer generics over arrays of different size. This is being worked on, but isn't available currently. If you'd like to accept a contiguous container of a variable number of values, use a Vec or slice (depending on whether you need ownership). + +## Documentation + +#### Where do I report issues in the Rust documentation? + +You can report issues in the Rust documentation on the Rust compiler [issue tracker](https://github.com/rust-lang/rust/issues). Make sure to read the [contributing guidelines](https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md) first. + +#### How do I view rustdoc documentation for a library my project depends on? + +When you use `cargo doc` to generate documentation for your own project, it also generates docs for the active dependency versions. These are put into the `target/doc` directory of your project. Use `cargo doc --open` to open the docs after building them, or just open up `target/doc/index.html` yourself after building the docs. + +## Input / Output + +#### How do I read a file into a `String`? + +Using the `read_to_string()` method, which is defined on the `Read` trait in `std::io`. + +```rust +fn main() { + let mut f = try!(File::open("foo.txt")); + let mut s = String::new(); + try!(f.read_to_string(&mut s)); // `s` contains the contents of "foo.txt" +} +``` + +#### How do I read file input efficiently? + +The [`File` type](https://doc.rust-lang.org/stable/std/fs/struct.File.html) implements the `Read` trait, which has a variety of functions for reading and writing data, including `read()`, `read_to_end()`, `bytes()`, `chars()`, and `take()`. Each of these functions reads in a certain amount of input from a given file. `read()` reads input until the provided buffer is full. `read_to_end()` reads the entire buffer into a vector, allocating as much space as is needed. `bytes()` and `chars()` allow you to iterate over the bytes and characters of the file, respectively. Finally, `take()` allows you to read up to an arbitrary number of bytes from the file. Collectively, these should allow you to efficiently read in any data you need. + +#### How do I get command line arguments in Rust? + +The easiest way is to use `std::env::Args`, which provides an iterator over the input arguments. + +If you're looking for something more powerful, the [getopt](https://doc.rust-lang.org/getopts/getopts/index.html) and [docopt](https://github.com/docopt/docopt.rs) crates are both solid options. + +## Libraries + +#### How can I make an HTTP request? + +[Hyper](https://github.com/hyperium/hyper) is the most popular, but there are [a number of others as well](https://crates.io/search?q=http). + +#### How can I write a GUI application in Rust? + +There are a variety of ways to write GUI applications in Rust. Just check out [this list of GUI frameworks](https://github.com/kud1ing/awesome-rust#gui). + +#### How can I parse JSON/XML? + +[Serde](https://github.com/serde-rs/serde) is the recommended library for serialization and deserialization of Rust data to and from a number of different formats. + +#### Is there a standard 2D+ dimensional vector and shape crate? + +Not yet! Want to write one? + +#### How do I write an OpenGL app in Rust? + +[Glium](https://github.com/tomaka/glium) is the major library for OpenGL programming in Rust. [GLFW](https://github.com/bjz/glfw-rs) is also a solid option. + +#### Can I write a video game in Rust? + +Yes you can! The major game programming library for Rust is [Piston](http://www.piston.rs/), and there's a whole [community for game programming in Rust](https://www.reddit.com/r/rust_gamedev/) as well. + +## Project + +#### What is this project's goal? + +To design and implement a safe, concurrent, practical, static systems language. + +Rust exists because other languages at this level of abstraction and efficiency are unsatisfactory. In particular: + +1. There is too little attention paid to safety. +2. They have poor concurrency support. +3. There is a lack of practical affordances. + +Rust exists as alternative language that provides both efficient code and a comfortable level of abstraction, while improving on all three of these points. + +#### Is this project controlled by Mozilla? + +No. Rust started as Graydon Hoare's part-time side project in 2006 and remained so for over 3 years. Mozilla got involved in 2009 once the language was mature enough to run basic tests and demonstrate its core concepts. Though it remains sponsored by Mozilla, Rust is developed by a diverse community of enthusiasts from many different places around the world. + +#### What are explicit non-goals of Rust? + +1. To employ any particularly cutting-edge technologies. Old, established techniques are better. +2. To prize expressiveness, minimalism or elegance above other goals. These are desirable but subordinate goals. +3. To cover the complete feature-set of C++, or any other language. It should provide majority-case features. +4. To be 100% static, 100% safe, 100% reflective, or too dogmatic in any other sense. Trade-offs exist. +5. To run on "every possible platform". It must eventually work without unnecessary compromises on widely-used hardware and software platforms. + +#### Who is using Rust? + +There are a number of companies using Rust, including: + +- [OpenDNS](https://labs.opendns.com/2013/10/04/zeromq-helping-us-block-malicious-domains/) +- [Skylight](https://www.skylight.io/) +- [Wit.ai](https://github.com/wit-ai/witd) +- [Codius](https://codius.org/blog/codius-rust/) +- [MaidSafe](http://maidsafe.net/) +- [Terminal.com](https://www.terminal.com/) + +#### In which projects is Mozilla using Rust? + +The main project is [Servo](https://github.com/servo/servo), an experimental browser engine Mozilla is working on. They are also working to integrate Rust components into Firefox. + +#### What examples are there of large Rust projects? + +The two biggest open source Rust projects right now are [Servo](https://github.com/servo/servo) and the [Rust compiler](https://github.com/rust-lang/rust) itself. + +#### What projects are good examples of idiomatic Rust code? + +TODO: Write this answer. + +#### How can I try Rust easily? + +The easiest way to try Rust is through the [Playground](https://play.rust-lang.org/), an online app for writing and running Rust code. If you want to try it on your system, [install it](https://www.rust-lang.org/install.html) and go through the ["Learn Rust"](https://doc.rust-lang.org/stable/book/learn-rust.html) section of the book. + +#### How do I get help with Rust issues? + +There are several ways. You can: + +- Post in [/r/rust](https://www.reddit.com/r/rust), the official Rust subreddit +- Post in [users.rust-lang.org](https://users.rust-lang.org/), the official Rust forum +- Ask in the official [Rust IRC channel](https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust) (#rust on irc.mozilla.org) + +#### Why has Rust changed so much over time? + +Rust started with a goal of creating a safe but usable systems programming language. In pursuit of this goal it explored a lot of ideas, some of which it kept (lifetimes, traits) others which it discarded (the typestate system). Also, in the run up to 1.0 a lot of the standard library was rewritten. Some of this was out of a desire to improve the old versions of the APIs. Some of it was out of a desire for improved Windows support. + +#### What IDE should I use? + +There are a couple developing options: [RustDT](https://github.com/RustDT/RustDT) is a Rust plugin for Eclipse, while [SolidOak](https://github.com/oakes/SolidOak) is a from-scratch Rust IDE. Both are solid options for a Rust IDE. + +## Modules and Crates + +#### What is the relationship between a module and a crate? + +- A crate is a top-level compilation unit that corresponds to a single loadable object. +- A module is a (possibly nested) unit of name-management inside a crate. +- A crate contains an implicit, un-named top-level module. +- Recursive definitions can span modules, but not crates. +- Crates do not have global names, only a set of non-unique metadata tags. +- There is no global inter-crate namespace; all name management occurs within a crate. +- Using another crate binds the root of its namespace into the user's namespace. + +#### Why do I have to declare module files with mod at the top level of the crate, instead of just `use`ing them? + +There are two ways to declare modules in Rust, inline or in another file. Here is an example of each: + +```rust +// In main.rs +mod hello { + pub fn f() { + println!("hello!"); + } +} + +fn main() { + hello::f(); +} +``` + +```rust +// In main.rs +mod hello; + +fn main() { + hello::f(); +} + +// In hello.rs +pub fn f() { + println!("hello!"); +} +``` + +In the first example, the module is defined in the same file it's used. In the second example, the module declaration in the main file tells the compiler to look for either `hello.rs` or `hello/mod.rs`, and to load that file. + +A `use`ing declaration just tells the compiler to bring everything from a particular module into the current module. Without a `mod` declaration first, the compiler doesn't know if the `use`d module exists, and so can't import its contents into the current module. + +#### How do I configure Cargo to use a proxy? + +As explained on the Cargo [configuration documentation](http://doc.crates.io/config.html), you can set Cargo to use a proxy by setting the "proxy" variable under `[http]` in the configuration file. + +#### Why can't the compiler find the method implementation even through I'm already `use`ing the crate? + +For methods defined on a trait, you have to explicitly import the trait declaration. This means it's not enough to import a module where a struct implements the trait, you must also important the module containing the trait itself. + +#### Why can't the compiler infer `use` declarations for me? + +It probably could, but you also don't want it to. While in many cases it is likely that the compiler could determine the correct module to import by simply looking for where a given identifier is defined, this may not be the case in general. Any decision rule in `rustc` for choosing between competing options would likely cause surprise and confusion, and not solve much of a problem. + +For example, the compiler could say that in the case of competing identifier definitions the definition from the earliest imported module is chosen. So if both module `foo` and module `bar` define the identifier `baz`, but `foo` is the first registered module, the compiler would insert `use foo::baz;`. + +```rust +mod foo; +mod bar; + +// use foo::baz // to be inserted by the compiler. + +fn main() { + baz(); +} +``` + +If you know this is going to happen, perhaps it saves a small number of keystrokes, but it also greatly increases the possibility for surprising error messages when you actually meant for `baz()` to be `bar::baz()`, and it decreases the readability of the code by making the meaning of a function call dependent on module declaration. These are not tradeoffs we are willing to make. + +#### How do I package and archive crates from [http://crates.io](http://crates.io)? + +TODO: Write this answer. + +#### How do I do dynamic Rust library loading? + +Importing dynamic libraries in Rust is done using [`std::dynamic_lib`](https://doc.rust-lang.org/std/dynamic_lib/index.html). Note that this entire module is currently marked unstable, and that a number of things may change in the current implementation. + +#### Why doesn't [http://crates.io](http://crates.io) have namespaces? + +Quoting the [official explanation](https://internals.rust-lang.org/t/crates-io-package-policies/1041) of [http://crates.io](http://crates.io)'s design: + +> In the first month with crates.io, a number of people have asked us about the possibility of introducing [namespaced packages](https://github.com/rust-lang/crates.io/issues/58).

+> +> While namespaced packages allow multiple authors to use a single, generic name, they add complexity to how packages are referenced in Rust code and in human communication about packages. At first glance, they allow multiple authors to claim names like `http`, but that simply means that people will need to refer to those packages as `wycats' http` or `reem's http`, offering little benefit over package names like `wycats-http` or `reem-http`.

+> +> When we looked at package ecosystems without namespacing, we found that people tended to go with more creative names (like `nokogiri` instead of "tenderlove's libxml2"). These creative names tend to be short and memorable, in part because of the lack of any hierarchy. They make it easier to communicate concisely and unambiguously about packages. They create exciting brands. And we've seen the success of several 10,000+ package ecosystems like NPM and RubyGems whose communities are prospering within a single namespace.

+> +> In short, we don't think the Cargo ecosystem would be better off if Piston chose a name like `bvssvni/game-engine` (allowing other users to choose `wycats/game-engine`) instead of simply `piston`.

+> +> Because namespaces are strictly more complicated in a number of ways,and because they can be added compatibly in the future should they become necessary, we're going to stick with a single shared namespace. + +#### Why are so many Rust answers on StackOverflow wrong? + +The Rust language has been around for a number of years, and only reached version 1.0 in May of 2015. In the time before then the language changed significantly, and a number of StackOverflow answers were given at the time of older versions of the language. + +Over time more and more answers will be offered for the current version, this improving this issue as the proportion of out-of-date answers is reduced. + +## Generics + +#### What is "monomorphisation"? + +Monomorphisation is the process by which Rust generates specific instances of a generic function based on the types of the various calls to that function. This is used to provide static dispatch for generic functions. For functions using trait objects for generics, dynamic dispatch is used instead, with calls to the function going through a vtable to identify specific function calls for the provided type implementing the given trait. + +#### What's the different between a function and a closure that doesn't capture any variables? + +Functions are a built-in primitive of the language, while closures are essentially syntactic sugar for one of three traits: `Fn`, `FnMut`, and `FnOnce`. When you make a closure, the Rust compiler automatically creates a struct implementing the appropriate trait of those three and containing the captured environment variables as members, and makes it so the the struct can be called as a function. + +The big difference between these traits is how they take the `self` parameter. `Fn` takes `&self`, `FnMut` takes `&mut self`, and `FnOnce` takes `self`. + +#### What are higher-kinded types, why should I want them, and why doesn't Rust have them? + +Let's go through these one by one: + +First, higher-kinded types are types that take other types as parameters. Type constructors, like `Vec` are examples. What support for higher-kinded types means is that you can use these type constructors wherever you can use types, such as in a trait `impl`. + +Next, the lack of higher-kinded types makes expression of certain ideas far more tedious than it would otherwise be. For example, implementing a `Functor` trait (a math-y term for something which can be mapped over, obeying certain rules) without higher-kinded types is a pain. With higher-kinded types, it's as simple as (note: theoretical syntax, this does not actually work, and has no guarantee to be how higher-kinded types look when and if they're implemented): + +```rust +trait Functor { + fn fmap B>(&self, f: F) -> Self; +} +``` + +The part that Rust currently can't do is that `Self` above is a type constructor parameterized by another type constructor. This is what support for higher-kinded types lets you express. + +Finally, Rust doesn't currently have them simply because they haven't been a priority. There is nothing inherent to the language that stops us from implementing higher-kinded types, it just hasn't been done yet. There is an open RFC for implementing them, but no real proposal exists yet. If one comes around, it will definitely be considered. + +(Credit to anasaziwochi for his [useful explanation](https://www.reddit.com/r/rust/comments/2av5tv/why_does_rust_not_have_a_functor_trait/ciz6iwm) of higher-kinded types in Rust.) + +#### What do named type parameters in generic types mean? + +These are called [associated types](https://doc.rust-lang.org/stable/book/associated-types.html), and they allow for the expression of trait bounds that can't be expressed with a simple `where` clause. In essence, for a generic type with some type parameters, it is often unecessary to include those type parameters in a function taking that generic type as a parameter. The function shouldn't have to care about being generic over the types which make up the generic type (say, the node and edge types in a graph), but only about being generic over the type itself. + +#### Does Rust have type reflection? + +Rust does have limited type reflection through the `Reflect` and `Any` traits. `Reflect` is a marker trait (meaning it has no functions associated with it) that indicates a function expects a type which can be reflected over. It is implemented for all types. `Any` is automatically implemented for any type that is both `Reflect` and `'static`, and is used for basic dynamic typing, as in the following example: + +```rust +use std::any::Any; +fn foo(x: &T) { + let any: &Any = x; + if any.is::() { println!("u32"); } +} +``` + +Note that the above could be equivalently written as: + +```rust +#![feature(reflect_marker)] +use std::marker::Reflect; +use std::any::Any; +fn foo(x: &T) { + let any: &Any = x; + if any.is::() { println!("u32"); } +} +``` + +#### Can I override operators? Which ones and how? + +You can provide custom implementations for a variety of operators using their associated traits: `Add` for `+`, `Mult` for `*`. It looks like this: + +```rust +struct Foo; + +impl Add for Foo { + type Output = Foo; + fn add(self, rhs: Foo) -> Self::Output { + println!("Adding!"); + self + } +} +``` + +The following operators can be overloaded: + +| Operation | Trait | +|:--------------------|:-----------| +| `+` | `Add` | +| `binary -` | `Sub` | +| `*` | `Mul` | +| `/` | `Div` | +| `unary -` | `Neg` | +| `%` | `Rem` | +| `&` | `BitAnd` | +| | | `BitOr` | +| `^` | `BitXor` | +| `!` | `Not` | +| `<<` | `Shl` | +| `>>` | `Shr` | +| `*` | `Deref` | +| `mut *` | `DerefMut` | +| `[]` | `Index` | +| `mut []` | `IndexMut` | + +#### Why the split between `Eq`/`PartialEq` and `Ord`/`PartialOrd`? + +There are some types in Rust that have a partial ordering, or partial equality, but no total ordering or total equality. The floating point types `f32` and `f64` are examples of this. Because a floating point value may be `NaN`, and because `NaN`s aren't equal to any other floating point type, nor less than or greater to any other floating point type, nor equal to each other, these types _can't_ implement `Eq` and `Ord`, although they _can_ implement `PartialEq` and `PartialOrd`. + +## Debugging + +#### How do I debug Rust programs? + +Rust programs can be debugged using gdb or lldb, same as C and C++. In fact, every Rust installation comes with rust-gdb and rust-lldb, wrappers over gdb and lldb with Rust pretty-printing enabled. + +#### `rustc` said a panic occurred in standard library code. How do I locate the mistake in my code? + +This error is usually caused by `unwrap()`ing a `None` or `Err`. Enabling backtraces by setting the environment variable `RUST_BACKTRACE=1` helps with getting more information. Compiling in debug mode (the default for `cargo build` is also helpful). Using a debugger like the provided `rust-gdb` or `rust-lldb` is also helpful. + +## Low-Level + +#### How do I `memcpy` bytes? + +To copy potentially overlapping bytes, use `std::ptr::copy`. To copy nonoverlapping bytes, use `std::ptr::cpy_nonoverlapping`. Both of these functions are `unsafe`, as both can be used to subvert the language's safety guarantees. Use caution when using them. + +#### Can Rust reasonably function without the standard library? + +Absolutely. Rust programs can be set to not load the standard library using the `#![no_std]` attribute. With this attribute set, you can continue to use the Rust core, which is nothing but the platform-agnostic primitives. As such, it doesn't include IO, concurrency, heap allocation, etc. Note however that `libcore` has not been stabilized. + +#### Can I write an operating system in Rust? + +Yes! In fact there are several projects underway doing just that, including [reenix](https://github.com/scialex/reenix) and [RustOS](https://github.com/ryanra/RustOS). + +#### How can I read or write numeric types like `i32` or `f64` in big-endian or little-endian format in a file or other byte stream? + +You should check out the [byteorder crate](http://burntsushi.net/rustdoc/byteorder/), which provides utilities for exactly that. + +#### Does Rust specify data layout? + +No. In the general case, `enum` and `struct` layout is undefined. This allows the compiler to potentially do optimizations like re-using padding for the discriminant, compacting variants of nested `enum`s, reordering fields to remove padding, etc. `enums` which carry no data ("C-like") are eligible to have a defined representation. Such `enums` are easily distinguished in that they are simply a list of names that carry no data: + +```rust +enum CLike { + A, + B = 32, + C = 34, + D +} +``` + +The `repr` attribute can be applied to such `enums` to give them the same representation as a primitive. This allows using Rust `enum`s in FFI where C `enum`s are also used, for most use cases. The attribute can also be applied to `struct`s to get the same layout as a C `struct` would. + +## Cross-Platform + +#### How do I build a Windows binary that doesn't display the console window? + +TODO: Write this answer. + +#### How I make the console-less binary not crash on panic!? + +TODO: Write this answer. + +#### What's the idiomatic way to express platform-specific behavior in Rust? + +Platform-specific behavior can be expressed using [conditional compilation attributes](https://doc.rust-lang.org/reference.html#conditional-compilation) such as `target_os`, `target_family`, `target_endian`, etc. + +#### Can Rust be used for Android/iOS programming? + +Yes it can! There are already examples of using Rust for both [Android](https://github.com/tomaka/android-rs-glue) and [iOS](https://www.bignerdranch.com/blog/building-an-ios-app-in-rust-part-1/). It does require a bit of work to set up, but Rust functions fine on both platforms. + +#### Can I run my Rust program in a web browser? + +There [are efforts](https://www.bignerdranch.com/blog/building-an-ios-app-in-rust-part-1/) to make Rust run in the web browser using Emscripten. Given that Rust is implemented on top of LLVM, this should be possible, but Rust currently runs on a special patched version of LLVM, and so it is tougher than it would otherwise be. This will likely improve over time. + +#### How do I cross-compile in Rust? + +Cross compilation is possible in Rust, but it requires a bit of work to set up, which is covered here: https://github.com/japaric/ruststrap/blob/master/1-how-to-cross-compile.md + +## Design Patterns + +#### Is Rust object oriented? + +It is multi-paradigm. Not everything is shoe-horned into a single abstraction. Many things you can do in OO languages you can do in Rust, but not everything, and not always using the same abstraction you're accustomed to. + +#### How do I handle configuration of a struct with optional parameters? + +The easiest way is to use the `Option` type in whatever function you're using to construct instances of the struct (usually `new()`). Another way is to use the builder pattern, where only certain functions instantiating member variables must be called before the construction of the built type. + +#### How do I do global variables in Rust? + +Globals in Rust can be done using `const` declarations for compile-time computed global constants, while `static` can be used for mutable globals. Note that modifying a `static` variable requires the use of `unsafe`, as it allows for data races, one of the things guaranteed not to happen in safe Rust. + +#### How can I set compile-time constants that are defined procedurally (equivalent to constexpr in C++)? + +Rust currently has limited support for compile time constants. You can define primitives using `const` declarations (similar to `static`, but immutable). You can also define some compile-time constants using compiler plugins. The closest thing you have to full Compile-Time Function Evaluation (CTFE) is the [`lazy-static`](https://github.com/rust-lang-nursery/lazy-static.rs) crate, which lazily evaluates constants (guaranteed to be evaluated once) at runtime, rather than evaluating them at compile time. CTFE is open for consideration in the future, it simply hasn't been a priority thus far. + +#### Can I run initialization code that happens before main? + +Rust has no concept of "life before `main`". The closest you'll see can be done through the ["lazy_static"](https://github.com/Kimundi/lazy-static.rs) crate, which simulates a "before main" by lazily initializing static variables at their first usage. + +#### How do I map OO concepts to Rust? + +Trying to directly map object oriented programming concepts to Rust is unlikely to be fruitful. Rust has its own features and its own way of doing things, and you are better off learning how to use them than you are trying to simulate another style the language wasn't designed for. + +#### Why doesn't Rust have inheritance? + +There are two meanings for the word "inheritance": _subtyping_, and _interface sharing_. Both purposes are already handled by traits. + +For the first, subtyping exists for polymorphism, which traits already provide. + +For the second, interface sharing is handled via trait methods, which define a collection of related functions that must be implemented for any implementation of the trait. + +Rust has consistently worked to avoid having features with overlapping purposes, preferring to keep features orthogonal. For this reason, and given that the two major purposes are already handled by traits, Rust has opted not to include inheritance. + +#### Does Rust allow non-constant-expression values for globals? + +No. Globals can not have a non-constant-expression constructor and cannot have a destructor at all. This is an opinion of the language. Static constructors are undesirable because they can slow down program startup. Life before main is often considered a misfeature, never to be used. Rust helps this along by just not having the feature. + +See the [C++ FQA](http://yosefk.com/c++fqa/ctors.html#fqa-10.12) about the "static initialization order fiasco", and [Eric Lippert's blog](http://ericlippert.com/2013/02/06/static-constructors-part-one/) for the challenges in C#, which also has this feature. + +A nice replacement is the [lazy-static](https://github.com/rust-lang-nursery/lazy-static.rs) library by Marvin Löbel. + +## Macros + +#### Can I write a macro to generate identifiers? + +Not currently. Rust macros are so-called hygienic macros, not the unlimited compile-time syntax editing you see in C. Macro invocations can only appear in places where they are explicitly supported: items, methods declarations, statements, expressions, and patterns. Here, "method declarations" means a blank space where a method can be put. They can't be used to complete a partial method declaration. By the same logic, they can't be used to complete a partial variable declaration. + +## Other Languages + +### C + +#### How can I implement something like `struct X { static int X; };` in Rust? + +Rust does not have `static` fields as shown in the code snippet above. Instead, you can declare a `static` variable in a given module, which is kept private to that module. + +#### How can I convert a C-style enum to an integer, or vice-versa? + +Converting a C-style enum to an integer to an integer can be done with a simple `as` expression, like `e as i64` (where `e` is some enum). + +Converting in the other direction is a little tougher, as Rust can't statically ensure that the conversion is valid. As such, it requires `unsafe` via `unsafe::reinterpret_cast()`. + +#### Why does Rust not have an ABI like C does, and why do I have to annotate things with extern? + +Committing to an ABI is a big thing, and can limit potentially advantageous language changes in the future. Given that Rust only hit 1.0 in May of 2015, it is still too early to make a commitment as big as a stable ABI. This does not mean that one won't happen in the future, though. + +#### Can Rust code call C code? + +Yes. Calling C code from Rust is simple and exactly as efficient as calling C code from C. + +#### Can C code call Rust code? + +Yes. The Rust code has to be exposed via an `extern` declaration, which makes it C-ABI compatible. Such a function can be passed to C code as a function pointer or, if given the `#[no_mangle]` attribute to disable symbol mangling, can be called directly from C code. + +### C++ + +#### I already write perfect C++. What does Rust give me? + +Modern C++ has made a lot of strides to being a safe and comfortable programming language, but it's not perfect, and it's still very easy to do things unsafely. This is something the C++ core developers are working to overcome, but C++ is limited by a long history that predates a lot of the ideas they are now trying to implement. + +Rust was designed from day one to be a safe systems programming language, which means it's not limited by historic design decisions that make getting safety right in C++ so complicated. In C++, safety is achieved by careful personal discipline, and is very easy to get wrong. In Rust, safety is the default. + +#### How do I do the equivalent of C++ template specialization in Rust? + +Rust doesn't currently have an equivalent to template specialization, but it is [being worked on](https://github.com/rust-lang/rfcs/pull/1210) and will hopefully be added soon. + +#### How does Rust's ownership system related to move semantics in C++? + +In C++, moving vs copying was added on late with C++11. With Rust the concept of moving vs copying has been around from the beginning. In C++ something can be moved into a function or out of a function using r-value references and either `std::move` or `std::forward`. In Rust, moves happen for anything that does not implement the `Copy` trait (which will cause the value of the type to be copied, rather than moved). This means that moves are the default operation, and that copies must be opted into explicitly. + +One thing to note, however is that moves are often not necessary or desirable in Rust. If the function you're writing does not require ownership of the value being passed in, it should probably be borrowed (mutably or immutable, as necessary) rather than moved or copied. + +It's also useful to note that functions can explicitly require that an input parameter be copied like so: + +```rust +fn must_copy(t: T) { + // Do something in here... +} +``` + +#### How can I interoperate with C++ from Rust, or with Rust from C++? + +The simplest way is to interoperate through C. Both Rust and C++ provide a [foreign function interface](https://doc.rust-lang.org/book/ffi.html) for C, and can use that to communicate between each other. If writing C bindings is too tedious, you can always use [rust-bindgen](https://github.com/crabtw/rust-bindgen) to help automatically generate workable C bindings. + +#### Does Rust have C++-style constructors? + +No. Functions can serve the same purpose as constructors without adding any language complexity. + +#### Does Rust have copy constructors? + +Not exactly. Types which implement `Copy` will do a standard C-like "shallow copy" with no extra work (similar to "plain old data" in C++). It is impossible to implement `Copy` types that require custom copy behavior. Instead, in Rust "copy constructors" are created by implementing the `Clone` trait, and explicitly calling the `clone` method. Making user-defined copy operators explicit surfaces the underlying complexity, forcing the developer to opt-in to potentially expensive operations. + +#### Does Rust have move constructors? + +No. Values of all types are moved via `memcpy`. This makes writing generic unsafe code much simpler since assignment, passing and returning are known to never have a side effect like unwinding. + +### Swift + +#### Why does Rust not have the ? and ! like in Swift? + +In Swift, `?` is used to indicate an optional value. This is already done by `Option` in Rust, and so `?` is not needed. Similarly, `!` is used to "unwrap" an optional value in Swift, which is done by the `unwrap()` function in Rust. In both cases, Rust opted for slightly longer names which more clearly indicate intent. Also, in Rust the `!` symbol already indicates logical negation and macro calls, and does not need a third meaning. + +### Go + +#### How are Go and Rust similar, and how are they different? + +Rust and Go have substantially different design goals, and so differ substantially. The following differences are not the only ones (which are too numerous to list), but are a few of the more important ones: + +- Rust is lower level than Go, comparable with C, C++, D, and Nim. It provides access to memory management primitives that do not exist in Go (which has a garbage collector) +- Rust's focus is on ensuring safety and efficiency while also providing high-level affordances, while Go's is on being a small, simple language which compiles quickly and can work nicely with a variety of tools. +- Rust has strong support for generics, which Go does not +- Rust has strong influences from the world of functional programming, including a type system which draws from Haskell's typeclasses. Go has a simpler type system, using interfaces for basic generic programming + +Rust is probably not the best choice in every situation. If you're considering using either Rust or Go for a project it's probably best to try out both languages a bit and make an informed decision rather than base your decision on a small comparison of the two. + +#### `gofmt` is great. Where's `rustfmt`? + +`rustfmt` is [right here](https://github.com/nrc/rustfmt/), and is being actively developed to make reading Rust code as easy and predictable as possible. + +### Haskell + +#### How do Rust traits compare to Haskell typeclasses? + +Rust traits are similar to Haskell typeclasses, but are currently not as powerful. Rust traits cannot express functional dependencies or type families, nor does Rust have full support for higher-kinded types. Some of these may be added in the future, but are not provided currently. + +## Licensing + +#### Why a dual MIT/ASL2 License? + +The Apache license includes important protection against patent aggression, but it is not compatible with the GPL, version 2. To avoid problems using Rust with GPL2, it is alternately MIT licensed. + +#### Why a BSD-style permissive license rather than MPL or tri-license? + +This is partly due to preference of the original developer (Graydon), and partly due to the fact that languages tend to have a wider audience and more diverse set of possible embeddings and end-uses than products such as web browsers. We'd like to appeal to as many of those potential contributors as possible. + +## Naming + +#### Why is the language called Rust? + +As [stated by Graydon Hoare](https://www.reddit.com/r/rust/comments/27jvdt/internet_archaeology_the_definitive_endall_source/), original developer of the Rust language, the name "Rust" comes from his personal interest in fungi, and because it evoked the feeling he was looking for in a programming language name. But truly, as Graydon himself put it: + +> <graydon> IOW I don't have a really good explanation. it seemed like a good name. (also a substring of "trust", "frustrating", "rustic" and ... "thrust"?)
+> <graydon> I think I named it after fungi. rusts are amazing creatures. + From abc63c5850afd7604320e65747c96beaeb618e04 Mon Sep 17 00:00:00 2001 From: Eric Findlay Date: Tue, 13 Oct 2015 11:37:51 +0900 Subject: [PATCH 02/94] Copied over documentation page from doc tree and edited roughly --- documentation.md | 148 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 148 insertions(+) create mode 100644 documentation.md diff --git a/documentation.md b/documentation.md new file mode 100644 index 000000000..40815f748 --- /dev/null +++ b/documentation.md @@ -0,0 +1,148 @@ +--- +layout: default +title: Documentation +--- + +# Rust Documentation + +- [Getting Started][getting_started] +- [The Standard Library][standard_library] +- [Community & Getting Help][community_and_help] +- [Specification][specification] +- [Tools][tools] +- [FAQs][faqs] +- [The Error index][error_index] +- [Community Translations][translations] + +Welcome to the Rust documentation! You can use the section headings +above to jump to any particular section. + +[getting_started]: #getting_started +[standard_library]: #standard_library +[community_and_help]: #community_and_help +[specification]: #specification +[tools]: #tools +[faqs]: #faqs +[error_index]: #error_index +[translations]: #translations + +# Getting Started + +If you haven't seen Rust at all yet, the first thing you should read +is the introduction to [The Rust Programming Language][rust]. It'll +give you a good idea of what Rust is like. + +The book provides a lengthy explanation of Rust, its syntax, and its +concepts. Upon completing the book, you'll be an intermediate Rust +developer, and will have a good grasp of the fundamental ideas behind +Rust. + +[Rust By Example][rust_by_example] was originally a community +resource, but was then donated to the Rust project. As the name +implies, it teaches you Rust through a series of small examples. + +[rust_by_example]: ["http://rustbyexample.com/"] + +# The Standard Library + +We have [API documentation][TODO] for the entire standard library. There's a +list of crates on the left with more specific sections, or you can use +the search bar at the top to search for something if you know its +name. + +[TODO]: [TODO] + +# Community & Getting Help + +If you need help with something, or just want to talk about Rust with +others, there are a few places you can do that: + +The Rust IRC channels on [irc.mozilla.org][mozilla_irc] are the +fastest way to get help. + +\#rust is the general discussion channel, and you'll find people +willing to help you with any questions you may have. + +There are also three specialty channels: +\#rust-gamedev" and #rust-osdev are for game development and operating +system development, respectively. There's also #rust-internals, which +is for discussion of the development of Rust itself. + +You can also get help on [Stack Overflow][stack_overflow]. Searching +for your problem might reveal someone who has asked it before! + +There is an active [subreddit][reddit] with lots of discussion and +news about Rust. + +There is also a [user forum][user_forum], for all user-oriented +discussion, and a [developer forum][developer_forum], where the +development of Rust itself is discussed. + +[irc_mozilla]: "irc://irc.mozilla.org/" + +# Specification + +Rust does not have an exact specification, but an effort to describe as much of +the language in as much detail as possible is in [the reference][reference]. + +[reference]: reference.html + +# Tools +Rust is still a young language, so there isn't a ton of tooling yet, +but the tools we have are really nice. + +[Cargo][cargo] is Rust's package manager, and its website contains +lots of good documentation. + +[cargo]: https://crates.io + +[Rustdoc][rustdoc] is used to generate documentation for Rust code. + +[rustdoc]: "book/documentation.html" + +# FAQs + +There are questions that are asked quite often, so we've made FAQs for +them: + +- [Language Design FAQ][language_design_faq] +- [Language FAQ][language_faq] +- [Project FAQ][project_faq] +- [How to submit a bug report][bug_report] + +[language_design_faq]: "complement-design-faq.html" +[language_faq]: "complement-lang-faq.html" +[project_faq]: "complement-project-faq.html" +[bug_report]: "https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#bug-reports" + +# The Error Index + +If you encounter an error while compiling your code you may be able to +look it up in the [Rust Compiler Error Index][error_index]. + +[error_index]: "https://doc.rust-lang.org/error-index.html" + +# Community Translations + +Several projects have been started to translate the documentation into other +languages: + + +- [Russian][russian_translation] +- [Korean][korean_translation] +- [Chinese][chinese_translation] +- [Spanish][spanish_translation] + +[russian_translation]: https://github.com/kgv/rust_book_ru +[korean_translation]: https://github.com/rust-kr/doc.rust-kr.org +[chinese_translation]: https://github.com/KaiserY/rust-book-chinese +[spanish_translation]: https://github.com/goyox86/elpr + +Copyright © 2011-2015 The Rust Project Developers. Licensed under the +[Apache License, Version 2.0][apache_license] or the [MIT +license][mit_license], at your option. This file may not be copied, +modified, or distributed except according to those terms. + +[apache_license]: http://www.apache.org/licenses/LICENSE-2.0 +[mit_license]: http://opensource.org/licenses/MIT + From b0173500f76a757555eda5a8166aafc3489668aa Mon Sep 17 00:00:00 2001 From: Eric Findlay Date: Tue, 13 Oct 2015 11:49:27 +0900 Subject: [PATCH 03/94] Added two temporary files that hold links from rust depo to old documentation landing page --- links_nightly | 165 ++ links_stable | 4777 +++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 4942 insertions(+) create mode 100644 links_nightly create mode 100644 links_stable diff --git a/links_nightly b/links_nightly new file mode 100644 index 000000000..d41914eaf --- /dev/null +++ b/links_nightly @@ -0,0 +1,165 @@ +RELEASES.md:132:[`Any`]: http://doc.rust-lang.org/nightly/std/any/trait.Any.html +RELEASES.md:133:[`AtomicPtr`]: http://doc.rust-lang.org/nightly/std/sync/atomic/struct.AtomicPtr.html +RELEASES.md:134:[`Borrow`]: http://doc.rust-lang.org/nightly/std/borrow/trait.Borrow.html +RELEASES.md:135:[`CStr`]: http://doc.rust-lang.org/nightly/std/ffi/struct.CStr.html +RELEASES.md:136:[`CString`]: http://doc.rust-lang.org/nightly/std/ffi/struct.CString.html +RELEASES.md:137:[`Debug`]: http://doc.rust-lang.org/nightly/std/fmt/trait.Debug.html +RELEASES.md:138:[`DerefMut`]: http://doc.rust-lang.org/nightly/std/ops/trait.DerefMut.html +RELEASES.md:139:[`Deref`]: http://doc.rust-lang.org/nightly/std/ops/trait.Deref.html +RELEASES.md:140:[`Div`]: http://doc.rust-lang.org/nightly/std/ops/trait.Div.html +RELEASES.md:141:[`Duration`]: http://doc.rust-lang.org/nightly/std/time/struct.Duration.html +RELEASES.md:142:[`Error`]: http://doc.rust-lang.org/nightly/std/error/trait.Error.html +RELEASES.md:143:[`File`]: http://doc.rust-lang.org/nightly/std/fs/struct.File.html +RELEASES.md:144:[`Hash`]: http://doc.rust-lang.org/nightly/std/hash/trait.Hash.html +RELEASES.md:145:[`Hasher`]: http://doc.rust-lang.org/nightly/std/hash/trait.Hasher.html +RELEASES.md:146:[`Send`]: http://doc.rust-lang.org/nightly/std/marker/trait.Send.html +RELEASES.md:147:[`SliceConcatExt`]: http://doc.rust-lang.org/nightly/std/slice/trait.SliceConcatExt.html +RELEASES.md:148:[`Stdin`]: http://doc.rust-lang.org/nightly/std/io/struct.Stdin.html +RELEASES.md:149:[`ToOwned`]: http://doc.rust-lang.org/nightly/std/borrow/trait.ToOwned.html +RELEASES.md:150:[`Wrapping`]: http://doc.rust-lang.org/nightly/std/num/struct.Wrapping.html +RELEASES.md:151:[`connect`]: http://doc.rust-lang.org/nightly/std/slice/trait.SliceConcatExt.html#method.connect +RELEASES.md:152:[`downcast_mut`]: http://doc.rust-lang.org/nightly/std/error/trait.Error.html#method.downcast_mut +RELEASES.md:153:[`downcast_ref`]: http://doc.rust-lang.org/nightly/std/error/trait.Error.html#method.downcast_ref +RELEASES.md:154:[`downcast`]: http://doc.rust-lang.org/nightly/std/error/trait.Error.html#method.downcast +RELEASES.md:155:[`hash_slice`]: http://doc.rust-lang.org/nightly/std/hash/trait.Hash.html#method.hash_slice +RELEASES.md:156:[`id`]: http://doc.rust-lang.org/nightly/std/process/struct.Child.html#method.id +RELEASES.md:157:[`is`]: http://doc.rust-lang.org/nightly/std/error/trait.Error.html#method.is +RELEASES.md:158:[`join`]: http://doc.rust-lang.org/nightly/std/slice/trait.SliceConcatExt.html#method.join +RELEASES.md:159:[`read_to_end`]: http://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.read_to_end +RELEASES.md:166:[dst1]: http://doc.rust-lang.org/nightly/std/mem/fn.size_of_val.html +RELEASES.md:167:[dst2]: http://doc.rust-lang.org/nightly/std/mem/fn.align_of_val.html +RELEASES.md:173:[hs]: http://doc.rust-lang.org/nightly/std/hash/trait.Hash.html#method.hash_slice +RELEASES.md:174:[ie]: http://doc.rust-lang.org/nightly/std/io/struct.Error.html +RELEASES.md:175:[iec]: http://doc.rust-lang.org/nightly/std/io/struct.Error.html#method.cause +RELEASES.md:176:[iegm]: http://doc.rust-lang.org/nightly/std/io/struct.Error.html#method.get_mut +RELEASES.md:177:[iegr]: http://doc.rust-lang.org/nightly/std/io/struct.Error.html#method.get_ref +RELEASES.md:178:[ieii]: http://doc.rust-lang.org/nightly/std/io/struct.Error.html#method.into_inner +RELEASES.md:187:[nom]: http://doc.rust-lang.org/nightly/nomicon/ +RELEASES.md:188:[pc]: http://doc.rust-lang.org/nightly/std/process/struct.Child.html +RELEASES.md:192:[sc]: http://doc.rust-lang.org/nightly/std/primitive.str.html#method.contains +RELEASES.md:194:[sew]: http://doc.rust-lang.org/nightly/std/primitive.str.html#method.ends_with +RELEASES.md:195:[sf]: http://doc.rust-lang.org/nightly/std/primitive.str.html#method.find +RELEASES.md:197:[srf]: http://doc.rust-lang.org/nightly/std/primitive.str.html#method.rfind +RELEASES.md:198:[ss]: http://doc.rust-lang.org/nightly/std/primitive.str.html#method.split +RELEASES.md:199:[ssw]: http://doc.rust-lang.org/nightly/std/primitive.str.html#method.starts_with +RELEASES.md:311:[`Extend`]: https://doc.rust-lang.org/nightly/std/iter/trait.Extend.html +RELEASES.md:313:[`iter::once`]: https://doc.rust-lang.org/nightly/std/iter/fn.once.html +RELEASES.md:314:[`iter::empty`]: https://doc.rust-lang.org/nightly/std/iter/fn.empty.html +RELEASES.md:315:[`matches`]: https://doc.rust-lang.org/nightly/std/primitive.str.html#method.matches +RELEASES.md:316:[`rmatches`]: https://doc.rust-lang.org/nightly/std/primitive.str.html#method.rmatches +RELEASES.md:317:[`Cell`]: https://doc.rust-lang.org/nightly/std/cell/struct.Cell.html +RELEASES.md:318:[`RefCell`]: https://doc.rust-lang.org/nightly/std/cell/struct.RefCell.html +RELEASES.md:319:[`wrapping_add`]: https://doc.rust-lang.org/nightly/std/primitive.i8.html#method.wrapping_add +RELEASES.md:320:[`wrapping_sub`]: https://doc.rust-lang.org/nightly/std/primitive.i8.html#method.wrapping_sub +RELEASES.md:321:[`wrapping_mul`]: https://doc.rust-lang.org/nightly/std/primitive.i8.html#method.wrapping_mul +RELEASES.md:322:[`wrapping_div`]: https://doc.rust-lang.org/nightly/std/primitive.i8.html#method.wrapping_div +RELEASES.md:323:[`wrapping_rem`]: https://doc.rust-lang.org/nightly/std/primitive.i8.html#method.wrapping_rem +RELEASES.md:324:[`wrapping_neg`]: https://doc.rust-lang.org/nightly/std/primitive.i8.html#method.wrapping_neg +RELEASES.md:325:[`wrapping_shl`]: https://doc.rust-lang.org/nightly/std/primitive.i8.html#method.wrapping_shl +RELEASES.md:326:[`wrapping_shr`]: https://doc.rust-lang.org/nightly/std/primitive.i8.html#method.wrapping_shr +RELEASES.md:327:[`Wrapping`]: https://doc.rust-lang.org/nightly/std/num/struct.Wrapping.html +RELEASES.md:328:[`fmt::Formatter`]: https://doc.rust-lang.org/nightly/std/fmt/struct.Formatter.html +RELEASES.md:329:[`fmt::Write`]: https://doc.rust-lang.org/nightly/std/fmt/trait.Write.html +RELEASES.md:330:[`io::Write`]: https://doc.rust-lang.org/nightly/std/io/trait.Write.html +RELEASES.md:331:[`debug_struct`]: https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html#method.debug_struct +RELEASES.md:332:[`debug_tuple`]: https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html#method.debug_tuple +RELEASES.md:333:[`debug_list`]: https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html#method.debug_list +RELEASES.md:334:[`debug_set`]: https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html#method.debug_set +RELEASES.md:335:[`debug_map`]: https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html#method.debug_map +RELEASES.md:336:[`Debug`]: https://doc.rust-lang.org/nightly/std/fmt/trait.Debug.html +RELEASES.md:337:[strup]: https://doc.rust-lang.org/nightly/std/primitive.str.html#method.to_uppercase +RELEASES.md:338:[strlow]: https://doc.rust-lang.org/nightly/std/primitive.str.html#method.to_lowercase +RELEASES.md:339:[`to_uppercase`]: https://doc.rust-lang.org/nightly/std/primitive.char.html#method.to_uppercase +RELEASES.md:340:[`to_lowercase`]: https://doc.rust-lang.org/nightly/std/primitive.char.html#method.to_lowercase +RELEASES.md:341:[`PoisonError`]: https://doc.rust-lang.org/nightly/std/sync/struct.PoisonError.html +RELEASES.md:342:[`RwLock`]: https://doc.rust-lang.org/nightly/std/sync/struct.RwLock.html +RELEASES.md:343:[`Mutex`]: https://doc.rust-lang.org/nightly/std/sync/struct.Mutex.html +RELEASES.md:344:[`FromRawFd`]: https://doc.rust-lang.org/nightly/std/os/unix/io/trait.FromRawFd.html +RELEASES.md:345:[`AsRawFd`]: https://doc.rust-lang.org/nightly/std/os/unix/io/trait.AsRawFd.html +RELEASES.md:346:[`Stdio`]: https://doc.rust-lang.org/nightly/std/process/struct.Stdio.html +RELEASES.md:347:[`ChildStdin`]: https://doc.rust-lang.org/nightly/std/process/struct.ChildStdin.html +RELEASES.md:348:[`ChildStdout`]: https://doc.rust-lang.org/nightly/std/process/struct.ChildStdout.html +RELEASES.md:349:[`ChildStderr`]: https://doc.rust-lang.org/nightly/std/process/struct.ChildStderr.html +RELEASES.md:350:[`io::ErrorKind`]: https://doc.rust-lang.org/nightly/std/io/enum.ErrorKind.html +RELEASES.md:352:[`DerefMut`]: https://doc.rust-lang.org/nightly/std/ops/trait.DerefMut.html +RELEASES.md:353:[`mem::align_of`]: https://doc.rust-lang.org/nightly/std/mem/fn.align_of.html +RELEASES.md:355:[`mem::min_align_of`]: https://doc.rust-lang.org/nightly/std/mem/fn.min_align_of.html +RELEASES.md:446:[`str::split_whitespace`]: https://doc.rust-lang.org/nightly/std/primitive.str.html#method.split_whitespace +RELEASES.md:447:[`FromRawFd`]: https://doc.rust-lang.org/nightly/std/os/unix/io/trait.FromRawFd.html +RELEASES.md:448:[`AsRawFd`]: https://doc.rust-lang.org/nightly/std/os/unix/io/trait.AsRawFd.html +RELEASES.md:449:[`std::os::unix::symlink`]: https://doc.rust-lang.org/nightly/std/os/unix/fs/fn.symlink.html +RELEASES.md:450:[`IntoIterator`]: https://doc.rust-lang.org/nightly/std/iter/trait.IntoIterator.html +RELEASES.md:451:[`From`]: https://doc.rust-lang.org/nightly/std/convert/trait.From.html +RELEASES.md:467:[`Cloned`]: https://doc.rust-lang.org/nightly/std/iter/struct.Cloned.html +RELEASES.md:468:[`Incoming`]: https://doc.rust-lang.org/nightly/std/net/struct.Incoming.html +RELEASES.md:471:[`BinaryHeap`]: https://doc.rust-lang.org/nightly/std/collections/struct.BinaryHeap.html +RELEASES.md:473:[`split_off`]: https://doc.rust-lang.org/nightly/collections/linked_list/struct.LinkedList.html#method.split_off +configure:674: nightly ) +configure:681: err "release channel must be 'dev', 'nightly', 'beta' or 'stable'" +mk/main.mk:28:# This is the normal semver version string, e.g. "0.12.0", "0.12.0-nightly" +mk/main.mk:30:# This is the string used in dist artifact file names, e.g. "0.12.0", "nightly" +mk/main.mk:43:ifeq ($(CFG_RELEASE_CHANNEL),nightly) +mk/main.mk:44:CFG_RELEASE=$(CFG_RELEASE_NUM)-nightly +mk/main.mk:45:# When building nightly distributables just reuse the same "nightly" name +mk/main.mk:49:CFG_PACKAGE_VERS=nightly +src/doc/nomicon/vec.md:5:project will only work on nightly (as of Rust 1.2.0). With the exception of the +src/doc/trpl/README.md:33:[nr]: nightly-rust.html +src/doc/trpl/SUMMARY.md:60:* [Nightly Rust](nightly-rust.md) +src/doc/trpl/documentation.md:79:[rc-new]: https://doc.rust-lang.org/nightly/std/rc/struct.Rc.html#method.new +src/doc/trpl/nightly-rust.md:3:Rust provides three distribution channels for Rust: nightly, beta, and stable. +src/doc/trpl/nightly-rust.md:4:Unstable features are only available on nightly Rust. For more details on this +src/doc/trpl/nightly-rust.md:9:To install nightly Rust, you can use `rustup.sh`: +src/doc/trpl/nightly-rust.md:12:$ curl -s https://static.rust-lang.org/rustup.sh | sh -s -- --channel=nightly +src/doc/trpl/nightly-rust.md:21:$ sh rustup.sh --channel=nightly +src/doc/trpl/nightly-rust.md:29:[win32]: https://static.rust-lang.org/dist/rust-nightly-i686-pc-windows-gnu.msi +src/doc/trpl/nightly-rust.md:30:[win64]: https://static.rust-lang.org/dist/rust-nightly-x86_64-pc-windows-gnu.msi +src/doc/trpl/nightly-rust.md:80:rustc 1.0.0-nightly (f11f3e7ba 2015-01-04) (built 2015-01-06) +src/doc/trpl/release-channels.md:15:New nightly releases are created once a day. Every six weeks, the latest +src/doc/trpl/release-channels.md:16:nightly release is promoted to ‘Beta’. At that point, it will only receive +src/doc/trpl/release-channels.md:21:nightly goes to beta, beta goes to stable. When `1.x` is released, at +src/doc/trpl/release-channels.md:22:the same time, `1.(x + 1)-beta` is released, and the nightly becomes the +src/doc/trpl/release-channels.md:23:first version of `1.(x + 2)-nightly`. +src/doc/trpl/release-channels.md:30:However, depending on your interest in Rust, you may choose to use nightly +src/doc/trpl/release-channels.md:31:instead. The basic tradeoff is this: in the nightly channel, you can use +src/doc/trpl/release-channels.md:33:and so any new nightly release may break your code. If you use the stable +src/doc/trpl/release-channels.md:43:Additionally, testing against nightly can catch regressions even sooner, and so +src/doc/trpl/release-channels.md:54: - nightly +src/doc/trpl/release-channels.md:60: - rust: nightly +src/doc/trpl/release-channels.md:66:breaks on nightly, it won’t fail your build. A similar configuration is +src/liballoc/lib.rs:71: html_root_url = "https://doc.rust-lang.org/nightly/", +src/libarena/lib.rs:31: html_root_url = "https://doc.rust-lang.org/nightly/")] +src/libcollections/lib.rs:27: html_root_url = "https://doc.rust-lang.org/nightly/", +src/libcore/lib.rs:60: html_root_url = "https://doc.rust-lang.org/nightly/", +src/libflate/lib.rs:26: html_root_url = "https://doc.rust-lang.org/nightly/")] +src/libfmt_macros/lib.rs:26: html_root_url = "https://doc.rust-lang.org/nightly/", +src/libgetopts/lib.rs:90: html_root_url = "https://doc.rust-lang.org/nightly/", +src/libgraphviz/lib.rs:286: html_root_url = "https://doc.rust-lang.org/nightly/")] +src/liblibc/lib.rs:23: html_root_url = "https://doc.rust-lang.org/nightly/", +src/liblog/lib.rs:169: html_root_url = "https://doc.rust-lang.org/nightly/", +src/librand/lib.rs:25: html_root_url = "https://doc.rust-lang.org/nightly/", +src/librbml/lib.rs:123: html_root_url = "https://doc.rust-lang.org/nightly/", +src/librustc/diagnostics.rs:305:available on a nightly compiler. Rust currently does not support more general +src/librustc/lib.rs:26: html_root_url = "https://doc.rust-lang.org/nightly/")] +src/librustc/middle/check_const.rs:724: evaluation is available on a nightly \ +src/librustc_back/lib.rs:33: html_root_url = "https://doc.rust-lang.org/nightly/")] +src/librustc_borrowck/lib.rs:20: html_root_url = "https://doc.rust-lang.org/nightly/")] +src/librustc_data_structures/lib.rs:28: html_root_url = "https://doc.rust-lang.org/nightly/")] +src/librustc_driver/lib.rs:26: html_root_url = "https://doc.rust-lang.org/nightly/")] +src/librustc_front/lib.rs:26: html_root_url = "http://doc.rust-lang.org/nightly/")] +src/librustc_lint/lib.rs:31: html_root_url = "https://doc.rust-lang.org/nightly/")] +src/librustc_llvm/lib.rs:26: html_root_url = "https://doc.rust-lang.org/nightly/")] +src/librustc_privacy/lib.rs:20: html_root_url = "https://doc.rust-lang.org/nightly/")] +src/librustc_resolve/lib.rs:20: html_root_url = "https://doc.rust-lang.org/nightly/")] +src/librustc_trans/lib.rs:26: html_root_url = "https://doc.rust-lang.org/nightly/")] +src/librustc_typeck/check/mod.rs:1603: // NOTE: @jroesch this is hack that appears to be fixed on nightly, will monitor if +src/librustc_typeck/diagnostics.rs:1425:[book-le]: https://doc.rust-lang.org/nightly/book/lifetimes.html#lifetime-elision +src/librustc_typeck/lib.rs:74: html_root_url = "https://doc.rust-lang.org/nightly/")] +src/librustc_unicode/lib.rs:31: html_root_url = "https://doc.rust-lang.org/nightly/", +src/librustdoc/html/static/playpen.js:38: channel = '&version=nightly'; +src/librustdoc/lib.rs:20: html_root_url = "https://doc.rust-lang.org/nightly/", +src/libserialize/lib.rs:28: html_root_url = "https://doc.rust-lang.org/nightly/", +src/libstd/lib.rs:196: html_root_url = "https://doc.rust-lang.org/nightly/", +src/libsyntax/feature_gate.rs:1105: /// Allow features to me activated, as on nightly. +src/libsyntax/lib.rs:26: html_root_url = "https://doc.rust-lang.org/nightly/")] +src/libterm/lib.rs:55: html_root_url = "https://doc.rust-lang.org/nightly/", +src/libtest/lib.rs:35: html_root_url = "https://doc.rust-lang.org/nightly/")] diff --git a/links_stable b/links_stable new file mode 100644 index 000000000..fb51cd3ae --- /dev/null +++ b/links_stable @@ -0,0 +1,4777 @@ +RELEASES.md:90: [`join`] method (note that both of these are on the *unstable* +RELEASES.md:92: available to stable code anyway). +RELEASES.md:418:* The [`Cloned`] iterator, which was accidentally left unstable for +RELEASES.md:484:* The vast majority of the standard library is now `#[stable]`. It is +RELEASES.md:485: no longer possible to use unstable features with a stable build of +RELEASES.md:487:* Many popular crates on [crates.io] now work on the stable release +RELEASES.md:559:* The new path and IO modules are complete and `#[stable]`. This +RELEASES.md:565: is now stable. +RELEASES.md:648: so use of unstable libraries now requires a `#![feature(...)]` +RELEASES.md:746: been declared 'stable'. Those interfaces are unlikely to change +RELEASES.md:809: * `macro_rules!` [has been declared stable][mac]. Though it is a +RELEASES.md:1558: `std::unstable::simd`. +RELEASES.md:1619: * std: More complete atomic types in `unstable::atomics`. +RELEASES.md:1743: * std: Various atomic types added to `unstable::atomic`. +configure:678: dev | beta | stable) +configure:681: err "release channel must be 'dev', 'nightly', 'beta' or 'stable'" +configure:710:# A magic value that allows the compiler to use unstable features +configure:713:# warnings-as-errors and unstable features default to warnings. The +configure:715:# deterrent from users just turning on unstable features on the stable +mk/main.mk:27:ifeq ($(CFG_RELEASE_CHANNEL),stable) +mk/main.mk:347:CFG_INFO := $(info cfg: disabling unstable features (CFG_DISABLE_UNSTABLE_FEATURES)) +mk/main.mk:350:# Subvert unstable feature lints to do the self-build +src/compiletest/runtest.rs:270: "-Zunstable-options".to_owned(), +src/doc/nomicon/borrow-splitting.md:287:All of these are completely safe and work on stable Rust! This ultimately +src/doc/nomicon/destructors.md:20:**There is no stable way to prevent this behavior in Rust 1.0.** +src/doc/nomicon/hrtb.md:67:(Where `Fn(a, b, c) -> d` is itself just sugar for the unstable *real* `Fn` +src/doc/nomicon/unbounded-lifetimes.md:36:these are unstable due to their awkward nature and questionable utility. +src/doc/nomicon/unwinding.md:29:killed in the name of heavy-weight OS threads. Still, on stable Rust as of 1.0 +src/doc/nomicon/unwinding.md:34:There is an unstable API called `catch_panic` that enables catching a panic +src/doc/nomicon/vec-alloc.md:16:All of the `heap` API is totally unstable under the `heap_api` feature, though. +src/doc/nomicon/vec-layout.md:27:`*mut T` when we have a raw pointer to an allocation we own. Unique is unstable, +src/doc/nomicon/vec-layout.md:39:one in stable Rust: +src/doc/nomicon/vec-layout.md:75:unstable and unlikely to be stabilized soon. As such we're just going to +src/doc/nomicon/vec-layout.md:94:stable code. However we will be designing the rest of the code around enabling +src/doc/nomicon/vec-layout.md:96:putting `null` inside of it is Undefined Behaviour. Our stable Unique doesn't +src/doc/nomicon/vec.md:4:Because all the best tools for writing unsafe code are unstable, this +src/doc/nomicon/vec.md:6:allocator API, much of the unstable code we'll use is expected to be stabilized +src/doc/nomicon/vec.md:9:However we will generally try to avoid unstable code where possible. In +src/doc/nomicon/vec.md:11:bit nicer or efficient because intrinsics are permanently unstable. Although +src/doc/reference.md:519: for compiler plugins is considered highly unstable. +src/doc/reference.md:1186:be stable. +src/doc/reference.md:2114:The set of language items is currently considered unstable. A complete +src/doc/reference.md:2170:quality" or "almost production ready", but may not be stable enough to be +src/doc/reference.md:2189: are still unstable. +src/doc/reference.md:2192: completely unstable. +src/doc/reference.md:2226: are inherently unstable and no promise about them is made. +src/doc/reference.md:2229: lang items are inherently unstable and no promise about them +src/doc/reference.md:2261: `extern crate std`. This typically requires use of the unstable APIs +src/doc/reference.md:2295: crate. Stability markers are also attributes: `#[stable]`, +src/doc/reference.md:2296: `#[unstable]`, and `#[deprecated]` are the three levels. +src/doc/reference.md:2310: and should be seen as unstable. This attribute is used to +src/doc/reference.md:2337:* `allow_internal_unstable` - Allows `macro_rules!` macros to be tagged with the +src/doc/reference.md:2338: `#[allow_internal_unstable]` attribute, designed +src/doc/reference.md:2340: `#[unstable]`/feature-gated functionality +src/doc/rust.css:351:.unstable-feature { +src/doc/style/errors/ergonomics.md:60:[the `result` module documentation](https://doc.rust-lang.org/stable/std/result/index.html#the-try-macro) +src/doc/style/errors/signaling.md:97:[`Result` type](https://doc.rust-lang.org/stable/std/result/index.html) +src/doc/style/features/functions-and-methods/input.md:127:(From the [Read trait](https://doc.rust-lang.org/stable/std/io/trait.Read.html#tymethod.read).) +src/doc/style/ownership/builders.md:35:[`std::process::Command`](https://doc.rust-lang.org/stable/std/process/struct.Command.html) +src/doc/trpl/README.md:25:* [Nightly Rust][nr] - Cutting-edge features that aren’t in stable builds yet. +src/doc/trpl/benchmark-tests.md:32:Note the `test` feature gate, which enables this unstable feature. +src/doc/trpl/box-syntax-and-patterns.md:3:Currently the only stable way to create a `Box` is via the `Box::new` method. +src/doc/trpl/box-syntax-and-patterns.md:4:Also it is not possible in stable Rust to destructure a `Box` in a match +src/doc/trpl/box-syntax-and-patterns.md:5:pattern. The unstable `box` keyword can be used to both create and destructure +src/doc/trpl/intrinsics.md:3:> **Note**: intrinsics will forever have an unstable interface, it is +src/doc/trpl/intrinsics.md:4:> recommended to use the stable interfaces of libcore rather than intrinsics +src/doc/trpl/lang-items.md:4:> and lang items themselves have an unstable interface. It is recommended to use +src/doc/trpl/macros.md:418:they are unstable and require feature gates. +src/doc/trpl/macros.md:770:macros, this is significantly more work, the interfaces are much less stable, +src/doc/trpl/nightly-rust.md:3:Rust provides three distribution channels for Rust: nightly, beta, and stable. +src/doc/trpl/nightly-rust.md:4:Unstable features are only available on nightly Rust. For more details on this +src/doc/trpl/no-stdlib.md:81:> **Note**: the core library's structure is unstable, and it is recommended to +src/doc/trpl/release-channels.md:21:nightly goes to beta, beta goes to stable. When `1.x` is released, at +src/doc/trpl/release-channels.md:28:stable release channel. These releases are intended for a general audience. +src/doc/trpl/release-channels.md:32:unstable, new Rust features. However, unstable features are subject to change, +src/doc/trpl/release-channels.md:33:and so any new nightly release may break your code. If you use the stable +src/doc/trpl/release-channels.md:39:What about beta? We encourage all Rust users who use the stable release channel +src/doc/trpl/release-channels.md:56: - stable +src/etc/featureck.py:14:# * That no features are both stable and unstable. +src/etc/featureck.py:17:# * That features that exist in both lang and lib and are stable +src/etc/featureck.py:94: if "[unstable(" in line: +src/etc/featureck.py:95: level = "unstable" +src/etc/featureck.py:96: elif "[stable(" in line: +src/etc/featureck.py:97: level = "stable" +src/etc/featureck.py:104: # `#[unstable(feature = "foo", since = "1.0.0")]` +src/etc/featureck.py:106: p = re.compile('(unstable|stable).*feature *= *"(\w*)"') +src/etc/featureck.py:111: if re.compile("\[ *stable").search(line) is not None: +src/etc/featureck.py:154:# name, lang, lib, status, stable since +src/etc/featureck.py:162: status = "unstable" +src/etc/featureck.py:163: stable_since = None +src/etc/featureck.py:166: status = "stable" +src/etc/featureck.py:167: if status == "stable": +src/etc/featureck.py:168: stable_since = f[1] +src/etc/featureck.py:170: language_feature_stats[name] = (name, lang, lib, status, stable_since) +src/etc/featureck.py:178: status = "unstable" +src/etc/featureck.py:179: stable_since = None +src/etc/featureck.py:181: is_stable = lib_features_and_level.get((name, "stable")) is not None +src/etc/featureck.py:182: is_unstable = lib_features_and_level.get((name, "unstable")) is not None +src/etc/featureck.py:184: if is_stable and is_unstable: +src/etc/featureck.py:185: print("error: feature '%s' is both stable and unstable" % (name)) +src/etc/featureck.py:188: if is_stable: +src/etc/featureck.py:189: status = "stable" +src/etc/featureck.py:190: stable_since = lib_features_and_level[(name, "stable")][0] +src/etc/featureck.py:191: elif is_unstable: +src/etc/featureck.py:192: status = "unstable" +src/etc/featureck.py:194: lib_feature_stats[name] = (name, lang, lib, status, stable_since) +src/etc/featureck.py:206: lang_stable_since = language_feature_stats[name][4] +src/etc/featureck.py:207: lib_stable_since = lib_feature_stats[name][4] +src/etc/featureck.py:214: if lang_stable_since != lib_stable_since: +src/etc/featureck.py:215: print("error: feature '%s' has lang stable since %s " + +src/etc/featureck.py:216: "but lib stable since %s" % (name, lang_stable_since, lib_stable_since)) +src/etc/featureck.py:219: merged_stats[name] = (name, True, True, lang_status, lang_stable_since) +src/liballoc/arc.rs:11:#![stable(feature = "rust1", since = "1.0.0")] +src/liballoc/arc.rs:123:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/arc.rs:140:#[stable(feature = "arc_weak", since = "1.4.0")] +src/liballoc/arc.rs:152:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/arc.rs:184: #[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/arc.rs:214: #[stable(feature = "arc_unique", since = "1.4.0")] +src/liballoc/arc.rs:248: #[stable(feature = "arc_weak", since = "1.4.0")] +src/liballoc/arc.rs:275: #[unstable(feature = "arc_counts", reason = "not clearly useful, and racy", +src/liballoc/arc.rs:283: #[unstable(feature = "arc_counts", reason = "not clearly useful, and racy", +src/liballoc/arc.rs:317:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/arc.rs:366:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/arc.rs:377: #[unstable(feature = "arc_make_unique", reason = "renamed to Arc::make_mut", +src/liballoc/arc.rs:409: #[stable(feature = "arc_unique", since = "1.4.0")] +src/liballoc/arc.rs:481: #[stable(feature = "arc_unique", since = "1.4.0")] +src/liballoc/arc.rs:526:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/arc.rs:615: #[stable(feature = "arc_weak", since = "1.4.0")] +src/liballoc/arc.rs:645:#[stable(feature = "arc_weak", since = "1.4.0")] +src/liballoc/arc.rs:679:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/arc.rs:733:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/arc.rs:769:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/arc.rs:856:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/arc.rs:862:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/arc.rs:865:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/arc.rs:872:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/arc.rs:879:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/arc.rs:886:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/arc.rs:888: #[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/arc.rs:894:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/arc.rs:1152:#[stable(since = "1.5.0", feature = "smart_ptr_as_ref")] +src/liballoc/boxed.rs:54:#![stable(feature = "rust1", since = "1.0.0")] +src/liballoc/boxed.rs:87:#[unstable(feature = "box_heap", +src/liballoc/boxed.rs:94:#[unstable(feature = "box_heap", +src/liballoc/boxed.rs:106:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/boxed.rs:128:#[unstable(feature = "placement_in", +src/liballoc/boxed.rs:212: #[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/boxed.rs:232: #[stable(feature = "box_raw", since = "1.4.0")] +src/liballoc/boxed.rs:253: #[stable(feature = "box_raw", since = "1.4.0")] +src/liballoc/boxed.rs:260:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/boxed.rs:262: #[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/boxed.rs:268:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/boxed.rs:270: #[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/boxed.rs:276:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/boxed.rs:310:#[stable(feature = "box_slice_clone", since = "1.3.0")] +src/liballoc/boxed.rs:322:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/boxed.rs:333:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/boxed.rs:356:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/boxed.rs:363:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/boxed.rs:366:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/boxed.rs:375: #[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/boxed.rs:395: #[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/boxed.rs:405:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/boxed.rs:412:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/boxed.rs:419:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/boxed.rs:429:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/boxed.rs:438:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/boxed.rs:445:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/boxed.rs:455:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/boxed.rs:461:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/boxed.rs:503:#[unstable(feature = "fnbox", reason = "Newly introduced", issue = "0")] +src/liballoc/boxed.rs:538:#[stable(feature = "box_slice_clone", since = "1.3.0")] +src/liballoc/boxed.rs:598:#[stable(since = "1.5.0", feature = "smart_ptr_as_ref")] +src/liballoc/boxed.rs:603:#[stable(since = "1.5.0", feature = "smart_ptr_as_ref")] +src/liballoc/heap.rs:11:#![unstable(feature = "heap_api", +src/liballoc/lib.rs:65:#![unstable(feature = "alloc", +src/liballoc/lib.rs:142:#[unstable(feature = "oom", reason = "not a scrutinized interface", +src/liballoc/rc.rs:151:#![stable(feature = "rust1", since = "1.0.0")] +src/liballoc/rc.rs:183:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/rc.rs:205: #[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/rc.rs:242: #[stable(feature = "rc_unique", since = "1.4.0")] +src/liballoc/rc.rs:263: #[unstable(feature = "rc_would_unwrap", +src/liballoc/rc.rs:283: #[stable(feature = "rc_weak", since = "1.4.0")] +src/liballoc/rc.rs:291: #[unstable(feature = "rc_counts", reason = "not clearly useful", +src/liballoc/rc.rs:299: #[unstable(feature = "rc_counts", reason = "not clearly useful", +src/liballoc/rc.rs:320: #[unstable(feature = "rc_counts", reason = "uniqueness has unclear meaning", +src/liballoc/rc.rs:344: #[stable(feature = "rc_unique", since = "1.4.0")] +src/liballoc/rc.rs:357: #[unstable(feature = "rc_make_unique", reason = "renamed to Rc::make_mut", +src/liballoc/rc.rs:390: #[stable(feature = "rc_unique", since = "1.4.0")] +src/liballoc/rc.rs:417:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/rc.rs:427:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/rc.rs:479:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/rc.rs:503:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/rc.rs:515: #[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/rc.rs:521:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/rc.rs:560:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/rc.rs:563:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/rc.rs:656:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/rc.rs:677:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/rc.rs:684:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/rc.rs:691:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/rc.rs:698:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/rc.rs:712:#[stable(feature = "rc_weak", since = "1.4.0")] +src/liballoc/rc.rs:743: #[stable(feature = "rc_weak", since = "1.4.0")] +src/liballoc/rc.rs:754:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/rc.rs:799:#[stable(feature = "rc_weak", since = "1.4.0")] +src/liballoc/rc.rs:822:#[stable(feature = "rust1", since = "1.0.0")] +src/liballoc/rc.rs:1121:#[stable(since = "1.5.0", feature = "smart_ptr_as_ref")] +src/liballoc_jemalloc/lib.rs:17:#![unstable(feature = "alloc_jemalloc", +src/liballoc_system/lib.rs:17:#![unstable(feature = "alloc_system", +src/libarena/lib.rs:25:#![unstable(feature = "rustc_private", issue = "27812")] +src/libbacktrace/dwarf.c:947:/* Sort the line vector by PC. We want a stable sort here to maintain +src/libcollections/binary_heap.rs:152:#![stable(feature = "rust1", since = "1.0.0")] +src/libcollections/binary_heap.rs:170:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/binary_heap.rs:175:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/binary_heap.rs:186:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/binary_heap.rs:192:#[stable(feature = "binaryheap_debug", since = "1.4.0")] +src/libcollections/binary_heap.rs:209: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/binary_heap.rs:224: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/binary_heap.rs:240: #[unstable(feature = "binary_heap_extras", +src/libcollections/binary_heap.rs:269: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/binary_heap.rs:289: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/binary_heap.rs:304: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/binary_heap.rs:327: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/binary_heap.rs:348: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/binary_heap.rs:354: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/binary_heap.rs:374: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/binary_heap.rs:399: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/binary_heap.rs:424: #[unstable(feature = "binary_heap_extras", +src/libcollections/binary_heap.rs:458: #[unstable(feature = "binary_heap_extras", +src/libcollections/binary_heap.rs:489: #[unstable(feature = "binary_heap_extras", +src/libcollections/binary_heap.rs:511: #[unstable(feature = "binary_heap_extras", +src/libcollections/binary_heap.rs:570: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/binary_heap.rs:574: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/binary_heap.rs:581: #[unstable(feature = "drain", +src/libcollections/binary_heap.rs:590: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/binary_heap.rs:662:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/binary_heap.rs:668:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/binary_heap.rs:675:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/binary_heap.rs:686:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/binary_heap.rs:692:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/binary_heap.rs:696:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/binary_heap.rs:701:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/binary_heap.rs:712:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/binary_heap.rs:718:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/binary_heap.rs:722:#[unstable(feature = "drain", reason = "recent addition", issue = "27711")] +src/libcollections/binary_heap.rs:727:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/binary_heap.rs:738:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/binary_heap.rs:744:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/binary_heap.rs:747:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/binary_heap.rs:754:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/binary_heap.rs:782:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/binary_heap.rs:792:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/binary_heap.rs:806:#[stable(feature = "extend_ref", since = "1.2.0")] +src/libcollections/borrow.rs:13:#![stable(feature = "rust1", since = "1.0.0")] +src/libcollections/borrow.rs:29:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/borrow.rs:42:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/borrow.rs:44: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/borrow.rs:48: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/borrow.rs:52:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/borrow.rs:85:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/borrow.rs:88: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/borrow.rs:92: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/borrow.rs:96:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/borrow.rs:125: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/borrow.rs:151: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/borrow.rs:160:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/borrow.rs:172:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/borrow.rs:175:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/borrow.rs:183:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/borrow.rs:193:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/borrow.rs:202:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/borrow.rs:215:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/borrow.rs:228:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/borrow.rs:238:#[unstable(feature = "into_cow", reason = "may be replaced by `convert::Into`", +src/libcollections/borrow.rs:245:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/borrow.rs:252:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:69:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:85:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:91:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:97:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:103:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:109:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:125:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:128: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:132: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:137:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:144:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:151: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:161: #[unstable(feature = "btree_b", +src/libcollections/btree/map.rs:187: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:218: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:250: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:273: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:334: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:443: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:472:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:506:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:516:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:863:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:872:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:882:#[stable(feature = "extend_ref", since = "1.2.0")] +src/libcollections/btree/map.rs:889:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:898:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:900: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:906:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:914:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:917:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:925:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:933:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:940:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:1055:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:1062:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:1066:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:1069:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:1076:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:1080:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:1083:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:1090:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:1094:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:1100:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:1107:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:1111:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:1118:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:1125:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:1129:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:1154: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:1164: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:1178: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:1186: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:1192: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:1198: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:1205: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:1212: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:1238: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:1271: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:1298: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:1320: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:1340: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:1355: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/map.rs:1512: #[unstable(feature = "btree_range", +src/libcollections/btree/map.rs:1546: #[unstable(feature = "btree_range", +src/libcollections/btree/map.rs:1574: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/node.rs:68: // be more stable in the face of representation changes. +src/libcollections/btree/node.rs:77: // should be more stable in the face of representation changes. +src/libcollections/btree/node.rs:452:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:36:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:42:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:48:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:59:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:66:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:73:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:80:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:96: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:104: #[unstable(feature = "btree_b", +src/libcollections/btree/set.rs:131: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:160: #[unstable(feature = "btree_range", +src/libcollections/btree/set.rs:194: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:217: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:241: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:263: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:280: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:295: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:310: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:330: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:340: #[unstable(feature = "set_recovery", issue = "28050")] +src/libcollections/btree/set.rs:362: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:383: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:428: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:447: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:454: #[unstable(feature = "set_recovery", issue = "28050")] +src/libcollections/btree/set.rs:477: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:487: #[unstable(feature = "set_recovery", issue = "28050")] +src/libcollections/btree/set.rs:493:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:502:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:527:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:537:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:547:#[stable(feature = "extend_ref", since = "1.2.0")] +src/libcollections/btree/set.rs:554:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:556: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:562:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:585:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:608:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:631:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:654:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:664:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:671:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:675:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:679:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:686:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:690:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:721:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:741:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:761:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/btree/set.rs:787:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/enum_set.rs:16:#![unstable(feature = "enumset", +src/libcollections/enum_set.rs:49:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/enum_set.rs:250:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/enum_set.rs:268:#[stable(feature = "extend_ref", since = "1.2.0")] +src/libcollections/fmt.rs:475:#![stable(feature = "rust1", since = "1.0.0")] +src/libcollections/fmt.rs:503:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/lib.rs:21:#![unstable(feature = "collections", +src/libcollections/lib.rs:104:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/lib.rs:109:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/lib.rs:120:#[unstable(feature = "collections_bound", issue = "27787")] +src/libcollections/linked_list.rs:22:#![stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:33:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:57:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:65:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:77:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:87:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:230:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:233: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:240: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:271: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:298: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:305: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:331: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:358: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:385: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:406: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:433: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:454: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:483: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:508: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:534: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:551: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:570: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:600: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:656:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:670:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:692:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:709:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:712:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:735:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:752:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:803: #[unstable(feature = "linked_list_extras", +src/libcollections/linked_list.rs:828: #[unstable(feature = "linked_list_extras", +src/libcollections/linked_list.rs:841:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:854:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:862:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:871:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:883:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:902:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:909:#[stable(feature = "extend_ref", since = "1.2.0")] +src/libcollections/linked_list.rs:916:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:929:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:932:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:939:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:947:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:954:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/linked_list.rs:961:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/macros.rs:43:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/macros.rs:80:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/range.rs:11:#![unstable(feature = "collections_range", reason = "was just added", +src/libcollections/slice.rs:82:#![stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:162:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:172: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:186: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:203: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:210: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:217: #[unstable(feature = "slice_splits", reason = "new API", issue = "27742")] +src/libcollections/slice.rs:224: #[unstable(feature = "slice_splits", reason = "new API", issue = "27742")] +src/libcollections/slice.rs:231: #[unstable(feature = "slice_splits", reason = "new API", issue = "27742")] +src/libcollections/slice.rs:239: #[unstable(feature = "slice_splits", reason = "new API", issue = "27742")] +src/libcollections/slice.rs:256: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:263: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:279: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:287: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:295: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:302: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:315: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:328: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:352: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:367: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:374: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:381: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:406: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:432: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:446: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:470: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:510: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:530: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:538: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:562: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:574: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:600: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:613: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:629: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:645: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:661: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:688: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:724: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:742: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:751: /// This sort is `O(n log n)` worst-case and stable, but allocates +src/libcollections/slice.rs:765: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:790: #[unstable(feature = "clone_from_slice", issue = "27750")] +src/libcollections/slice.rs:796: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:804: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:815:#[unstable(feature = "slice_concat_ext", +src/libcollections/slice.rs:820: #[unstable(feature = "slice_concat_ext", +src/libcollections/slice.rs:833: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:844: #[stable(feature = "rename_connect_to_join", since = "1.3.0")] +src/libcollections/slice.rs:855: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:892:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:897:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/slice.rs:902:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/str.rs:16:#![stable(feature = "rust1", since = "1.0.0")] +src/libcollections/str.rs:109:#[unstable(feature = "str_utf16", issue = "27714")] +src/libcollections/str.rs:114:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/str.rs:137:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/str.rs:143:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/str.rs:156:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/str.rs:166: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/str.rs:180: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/str.rs:211: #[unstable(feature = "str_char", +src/libcollections/str.rs:229: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/str.rs:247: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/str.rs:271: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/str.rs:280: #[unstable(feature = "str_slice_mut", reason = "recently added", +src/libcollections/str.rs:332: #[unstable(feature = "str_char", +src/libcollections/str.rs:392: #[unstable(feature = "str_char", +src/libcollections/str.rs:419: #[unstable(feature = "str_char", +src/libcollections/str.rs:449: #[unstable(feature = "str_char", +src/libcollections/str.rs:485: #[unstable(feature = "str_char", +src/libcollections/str.rs:517: #[stable(feature = "str_split_at", since = "1.4.0")] +src/libcollections/str.rs:524: #[stable(feature = "str_split_at", since = "1.4.0")] +src/libcollections/str.rs:550: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/str.rs:566: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/str.rs:581: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/str.rs:598: #[stable(feature = "split_whitespace", since = "1.1.0")] +src/libcollections/str.rs:625: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/str.rs:653: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/str.rs:662: #[unstable(feature = "str_utf16", +src/libcollections/str.rs:678: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/str.rs:690: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/str.rs:702: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/str.rs:748: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/str.rs:790: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/str.rs:874: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/str.rs:920: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/str.rs:960: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/str.rs:996: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/str.rs:1045: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/str.rs:1090: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/str.rs:1124: #[stable(feature = "str_matches", since = "1.2.0")] +src/libcollections/str.rs:1155: #[stable(feature = "str_matches", since = "1.2.0")] +src/libcollections/str.rs:1195: #[unstable(feature = "str_match_indices", +src/libcollections/str.rs:1234: #[unstable(feature = "str_match_indices", +src/libcollections/str.rs:1251: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/str.rs:1264: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/str.rs:1277: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/str.rs:1305: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/str.rs:1327: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/str.rs:1355: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/str.rs:1380: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/str.rs:1405: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/str.rs:1426: #[stable(feature = "unicode_case_mapping", since = "1.2.0")] +src/libcollections/str.rs:1470: #[stable(feature = "unicode_case_mapping", since = "1.2.0")] +src/libcollections/str.rs:1478: #[unstable(feature = "str_escape", +src/libcollections/str.rs:1486: #[unstable(feature = "str_escape", +src/libcollections/str.rs:1494: #[stable(feature = "box_str", since = "1.4.0")] +src/libcollections/string.rs:13:#![stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:34:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:40:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:48:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:61: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:78: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:151: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:203: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:337: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:357: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:374: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:409: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:424: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:431: #[unstable(feature = "convert", +src/libcollections/string.rs:448: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:463: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:484: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:509: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:526: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:543: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:575: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:595: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:614: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:650: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:678: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:715: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:729: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:743: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:756: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:787: #[unstable(feature = "drain", +src/libcollections/string.rs:818: #[stable(feature = "box_str", since = "1.4.0")] +src/libcollections/string.rs:827: #[unstable(feature = "box_str2", +src/libcollections/string.rs:839: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:843: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:847:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:854:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:861:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:872:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:881:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:890:#[stable(feature = "extend_string", since = "1.4.0")] +src/libcollections/string.rs:899:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:911:#[stable(feature = "extend_ref", since = "1.2.0")] +src/libcollections/string.rs:918:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:927:#[stable(feature = "extend_string", since = "1.4.0")] +src/libcollections/string.rs:955:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:965: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:973: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:989:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:997:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:1005:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:1008: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:1014:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:1022:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:1030:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:1038:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:1049:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:1058:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:1067:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:1076:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:1086:#[stable(feature = "derefmut_for_string", since = "1.2.0")] +src/libcollections/string.rs:1093:#[stable(feature = "derefmut_for_string", since = "1.2.0")] +src/libcollections/string.rs:1100:#[stable(feature = "derefmut_for_string", since = "1.2.0")] +src/libcollections/string.rs:1107:#[stable(feature = "derefmut_for_string", since = "1.2.0")] +src/libcollections/string.rs:1115:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:1125:#[stable(feature = "derefmut_for_string", since = "1.2.0")] +src/libcollections/string.rs:1134:#[unstable(feature = "str_parse_error", reason = "may want to be replaced with \ +src/libcollections/string.rs:1140:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:1170:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:1173: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:1177:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:1189:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:1197:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:1205:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:1224:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:1232:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:1240:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:1247:#[unstable(feature = "into_cow", reason = "may be replaced by `convert::Into`", +src/libcollections/string.rs:1256:#[unstable(feature = "into_cow", reason = "may be replaced by `convert::Into`", +src/libcollections/string.rs:1265:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/string.rs:1281:#[unstable(feature = "drain", reason = "recently added", issue = "27711")] +src/libcollections/string.rs:1296:#[unstable(feature = "drain", reason = "recently added", issue = "27711")] +src/libcollections/string.rs:1310:#[unstable(feature = "drain", reason = "recently added", issue = "27711")] +src/libcollections/string.rs:1324:#[unstable(feature = "drain", reason = "recently added", issue = "27711")] +src/libcollections/vec.rs:60:#![stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:186:/// a Vec. The contents of a Vec wouldn't have a stable address if it were +src/libcollections/vec.rs:227:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:248: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:280: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:330: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:349: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:369: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:393: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:412: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:422: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:444: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:461: #[unstable(feature = "convert", +src/libcollections/vec.rs:472: #[unstable(feature = "convert", +src/libcollections/vec.rs:494: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:520: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:543: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:580: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:614: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:648: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:671: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:699: #[stable(feature = "append", since = "1.4.0")] +src/libcollections/vec.rs:737: #[unstable(feature = "drain", +src/libcollections/vec.rs:786: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:800: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:814: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:837: #[stable(feature = "split_off", since = "1.4.0")] +src/libcollections/vec.rs:878: #[unstable(feature = "vec_resize", +src/libcollections/vec.rs:929: #[unstable(feature = "vec_push_all", +src/libcollections/vec.rs:965: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1056:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1067:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1095:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1103:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1114:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1124:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1133:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1142:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1151:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1161:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1169:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1177:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1185:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1194:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1207:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1218:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1246:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1282:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1292:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1302:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1332:#[stable(feature = "extend_ref", since = "1.2.0")] +src/libcollections/vec.rs:1367:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1375:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1378:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1386:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1408:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1410: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1416:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1423:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1430:#[stable(feature = "vec_as_mut", since = "1.5.0")] +src/libcollections/vec.rs:1437:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1444:#[stable(feature = "vec_as_mut", since = "1.5.0")] +src/libcollections/vec.rs:1451:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1463:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1474:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1498:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1508:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1550:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1574:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1577:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1588:#[unstable(feature = "drain", reason = "recently added", issue = "27711")] +src/libcollections/vec.rs:1602:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1620:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1632:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec.rs:1654:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:19:#![stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:45:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:58:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:65:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:73:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:210: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:216: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:242: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:269: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:298: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:321: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:344: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:365: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:398: #[unstable(feature = "deque_extras", +src/libcollections/vec_deque.rs:480: #[unstable(feature = "deque_extras", +src/libcollections/vec_deque.rs:504: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:530: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:542: #[unstable(feature = "deque_extras", +src/libcollections/vec_deque.rs:563: #[unstable(feature = "deque_extras", +src/libcollections/vec_deque.rs:597: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:612: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:631: #[unstable(feature = "drain", +src/libcollections/vec_deque.rs:652: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:673: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:697: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:717: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:741: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:763: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:786: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:812: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:840: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:881: #[unstable(feature = "deque_extras", +src/libcollections/vec_deque.rs:919: #[unstable(feature = "deque_extras", +src/libcollections/vec_deque.rs:952: #[unstable(feature = "deque_extras", +src/libcollections/vec_deque.rs:1161: #[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:1331: #[stable(feature = "split_off", since = "1.4.0")] +src/libcollections/vec_deque.rs:1392: #[stable(feature = "append", since = "1.4.0")] +src/libcollections/vec_deque.rs:1416: #[stable(feature = "vec_deque_retain", since = "1.4.0")] +src/libcollections/vec_deque.rs:1454: #[unstable(feature = "deque_extras", +src/libcollections/vec_deque.rs:1484:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:1502:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:1523:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:1535:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:1539:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:1546:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:1571:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:1587:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:1592:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:1597:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:1613:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:1621:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:1625:#[unstable(feature = "drain", +src/libcollections/vec_deque.rs:1632:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:1641:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:1657:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:1665:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:1668:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:1676:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:1679:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:1686:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:1694:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:1704:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:1714:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:1722:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:1733:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:1747:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:1757:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:1767:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollections/vec_deque.rs:1776:#[stable(feature = "extend_ref", since = "1.2.0")] +src/libcollections/vec_deque.rs:1783:#[stable(feature = "rust1", since = "1.0.0")] +src/libcollectionstest/slice.rs:470: // only sort on the first element, so an unstable sort +src/libcollectionstest/slice.rs:478: // stable. +src/libcore/any.rs:71:#![stable(feature = "rust1", since = "1.0.0")] +src/libcore/any.rs:91:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/any.rs:94: #[unstable(feature = "get_type_id", +src/libcore/any.rs:108:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/any.rs:118:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/any.rs:127: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/any.rs:142: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/any.rs:160: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/any.rs:179: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/any.rs:186: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/any.rs:193: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/any.rs:214:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/any.rs:222: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/array.rs:17:#![unstable(feature = "fixed_size_array", +src/libcore/array.rs:83: #[stable(feature = "array_borrow", since = "1.4.0")] +src/libcore/array.rs:90: #[stable(feature = "array_borrow", since = "1.4.0")] +src/libcore/array.rs:97: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/array.rs:104: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/array.rs:111: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/array.rs:118: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/array.rs:128: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/array.rs:146: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/array.rs:149: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/array.rs:173: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/array.rs:196: #[stable(since = "1.4.0", feature = "array_default")] +src/libcore/array.rs:205: #[stable(since = "1.4.0", feature = "array_default")] +src/libcore/borrow.rs:13:#![stable(feature = "rust1", since = "1.0.0")] +src/libcore/borrow.rs:37:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/borrow.rs:58: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/borrow.rs:65:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/borrow.rs:82: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/borrow.rs:86:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/borrow.rs:91:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/borrow.rs:96:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/borrow.rs:101:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/borrow.rs:106:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cell.rs:143:#![stable(feature = "rust1", since = "1.0.0")] +src/libcore/cell.rs:156:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cell.rs:171: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cell.rs:191: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cell.rs:208: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cell.rs:233: #[unstable(feature = "as_unsafe_cell", issue = "27708")] +src/libcore/cell.rs:239:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cell.rs:242:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cell.rs:250:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cell.rs:252: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cell.rs:259:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cell.rs:267:#[stable(feature = "cell_eq", since = "1.2.0")] +src/libcore/cell.rs:273:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cell.rs:281:#[unstable(feature = "borrow_state", issue = "27733")] +src/libcore/cell.rs:307: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cell.rs:327: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cell.rs:343: #[unstable(feature = "borrow_state", issue = "27733")] +src/libcore/cell.rs:388: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cell.rs:434: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cell.rs:452: #[unstable(feature = "as_unsafe_cell", issue = "27708")] +src/libcore/cell.rs:458:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cell.rs:461:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cell.rs:469:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cell.rs:471: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cell.rs:478:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cell.rs:486:#[stable(feature = "cell_eq", since = "1.2.0")] +src/libcore/cell.rs:531:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cell.rs:539:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cell.rs:558: #[unstable(feature = "cell_extras", +src/libcore/cell.rs:589: #[unstable(feature = "cell_extras", reason = "recently added", +src/libcore/cell.rs:621: #[unstable(feature = "cell_extras", reason = "recently added", +src/libcore/cell.rs:659: #[unstable(feature = "cell_extras", reason = "recently added", +src/libcore/cell.rs:697: #[unstable(feature = "cell_extras", reason = "recently added", +src/libcore/cell.rs:740:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cell.rs:748:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cell.rs:758:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cell.rs:791:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cell.rs:812: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cell.rs:835: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cell.rs:854: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/char.rs:16:#![stable(feature = "core_char", since = "1.2.0")] +src/libcore/char.rs:67:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/char.rs:81:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/char.rs:94:#[unstable(feature = "char_from_unchecked", reason = "recently added API", +src/libcore/char.rs:121:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/char.rs:142:#[unstable(feature = "core_char_ext", +src/libcore/char.rs:143: reason = "the stable interface is `impl char` in later crate", +src/libcore/char.rs:232:#[unstable(feature = "char_internals", +src/libcore/char.rs:267:#[unstable(feature = "char_internals", +src/libcore/char.rs:291:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/char.rs:307:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/char.rs:366:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/char.rs:379:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/clone.rs:22:#![stable(feature = "rust1", since = "1.0.0")] +src/libcore/clone.rs:27:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/clone.rs:38: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/clone.rs:47: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/clone.rs:53:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/clone.rs:62: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:18:#![stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:47:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:51: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:56: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:72:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:83: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:104:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:107: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:110: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:113: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:154: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:176:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:192: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:196:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:199:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:202: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:208:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:211: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:235:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:260: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:277: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:298: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:318: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:339: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:361:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:379:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:394: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:404: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:418: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:427: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:450: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:458: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:470: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:486: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:498: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:504: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:516: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:523: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:538: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:543: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:548: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:555: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:570: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:575: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:578: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp.rs:586: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp_macros.rs:21: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/cmp_macros.rs:39: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/convert.rs:22:#![stable(feature = "rust1", since = "1.0.0")] +src/libcore/convert.rs:48:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/convert.rs:51: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/convert.rs:56:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/convert.rs:59: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/convert.rs:78:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/convert.rs:81: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/convert.rs:97:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/convert.rs:100: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/convert.rs:109:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/convert.rs:117:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/convert.rs:133:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/convert.rs:149:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/convert.rs:157:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/convert.rs:166:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/convert.rs:173:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/convert.rs:180:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/default.rs:79:#![stable(feature = "rust1", since = "1.0.0")] +src/libcore/default.rs:95:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/default.rs:125: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/default.rs:131: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/default.rs:134: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/builders.rs:57:#[stable(feature = "debug_builders", since = "1.2.0")] +src/libcore/fmt/builders.rs:77: #[stable(feature = "debug_builders", since = "1.2.0")] +src/libcore/fmt/builders.rs:100: #[stable(feature = "debug_builders", since = "1.2.0")] +src/libcore/fmt/builders.rs:123:#[stable(feature = "debug_builders", since = "1.2.0")] +src/libcore/fmt/builders.rs:141: #[stable(feature = "debug_builders", since = "1.2.0")] +src/libcore/fmt/builders.rs:163: #[stable(feature = "debug_builders", since = "1.2.0")] +src/libcore/fmt/builders.rs:182: #[unstable(feature = "debug_builder_formatter", reason = "recently added", +src/libcore/fmt/builders.rs:237:#[stable(feature = "debug_builders", since = "1.2.0")] +src/libcore/fmt/builders.rs:255: #[stable(feature = "debug_builders", since = "1.2.0")] +src/libcore/fmt/builders.rs:262: #[stable(feature = "debug_builders", since = "1.2.0")] +src/libcore/fmt/builders.rs:274: #[stable(feature = "debug_builders", since = "1.2.0")] +src/libcore/fmt/builders.rs:285:#[stable(feature = "debug_builders", since = "1.2.0")] +src/libcore/fmt/builders.rs:303: #[stable(feature = "debug_builders", since = "1.2.0")] +src/libcore/fmt/builders.rs:310: #[stable(feature = "debug_builders", since = "1.2.0")] +src/libcore/fmt/builders.rs:322: #[stable(feature = "debug_builders", since = "1.2.0")] +src/libcore/fmt/builders.rs:333:#[stable(feature = "debug_builders", since = "1.2.0")] +src/libcore/fmt/builders.rs:351: #[stable(feature = "debug_builders", since = "1.2.0")] +src/libcore/fmt/builders.rs:378: #[stable(feature = "debug_builders", since = "1.2.0")] +src/libcore/fmt/builders.rs:391: #[stable(feature = "debug_builders", since = "1.2.0")] +src/libcore/fmt/mod.rs:13:#![stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:36:#[unstable(feature = "fmt_internals", reason = "internal to format_args!", +src/libcore/fmt/mod.rs:43:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:52:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:65:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:77: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:90: #[stable(feature = "fmt_write_char", since = "1.1.0")] +src/libcore/fmt/mod.rs:101: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:124:#[stable(feature = "fmt_write_blanket_impl", since = "1.4.0")] +src/libcore/fmt/mod.rs:142:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:165:#[unstable(feature = "fmt_internals", reason = "internal to format_args!", +src/libcore/fmt/mod.rs:186: #[unstable(feature = "fmt_internals", reason = "internal to format_args!", +src/libcore/fmt/mod.rs:199: #[unstable(feature = "fmt_internals", reason = "internal to format_args!", +src/libcore/fmt/mod.rs:223: #[unstable(feature = "fmt_internals", reason = "internal to format_args!", +src/libcore/fmt/mod.rs:241: #[unstable(feature = "fmt_internals", reason = "internal to format_args!", +src/libcore/fmt/mod.rs:263:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:277:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:284:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:376:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:383: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:423:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:426: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:470:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:473: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:517:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:520: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:565:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:568: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:613:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:616: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:658:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:661: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:701:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:704: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:744:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:747: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:759:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:855: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:930: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:1085: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:1091: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:1097: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:1101: #[unstable(feature = "fmt_flags", reason = "method was just created", +src/libcore/fmt/mod.rs:1106: #[unstable(feature = "fmt_flags", reason = "method was just created", +src/libcore/fmt/mod.rs:1111: #[unstable(feature = "fmt_flags", reason = "method was just created", +src/libcore/fmt/mod.rs:1116: #[unstable(feature = "fmt_flags", reason = "method was just created", +src/libcore/fmt/mod.rs:1121: #[unstable(feature = "fmt_flags", reason = "method was just created", +src/libcore/fmt/mod.rs:1126: #[unstable(feature = "fmt_flags", reason = "method was just created", +src/libcore/fmt/mod.rs:1131: #[unstable(feature = "fmt_flags", reason = "method was just created", +src/libcore/fmt/mod.rs:1136: #[unstable(feature = "fmt_flags", reason = "method was just created", +src/libcore/fmt/mod.rs:1167: #[stable(feature = "debug_builders", since = "1.2.0")] +src/libcore/fmt/mod.rs:1195: #[stable(feature = "debug_builders", since = "1.2.0")] +src/libcore/fmt/mod.rs:1220: #[stable(feature = "debug_builders", since = "1.2.0")] +src/libcore/fmt/mod.rs:1245: #[stable(feature = "debug_builders", since = "1.2.0")] +src/libcore/fmt/mod.rs:1270: #[stable(feature = "debug_builders", since = "1.2.0")] +src/libcore/fmt/mod.rs:1277:#[stable(since = "1.2.0", feature = "formatter_write")] +src/libcore/fmt/mod.rs:1292:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:1304: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:1308: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:1318:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:1325:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:1332:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:1353:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:1360:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:1371:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:1385:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:1413:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:1422:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:1431:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:1489: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:1496: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:1503: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:1510: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:1522:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:1526:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:1538: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:1563:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:1570:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:1582:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:1589:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:1601:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/mod.rs:1608:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/num.rs:143:#[unstable(feature = "fmt_radix", +src/libcore/fmt/num.rs:173:#[unstable(feature = "fmt_radix", +src/libcore/fmt/num.rs:189:#[unstable(feature = "fmt_radix", +src/libcore/fmt/num.rs:198: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/num.rs:204: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/num.rs:215: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/fmt/num.rs:226: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/hash/mod.rs:71:#![stable(feature = "rust1", since = "1.0.0")] +src/libcore/hash/mod.rs:95:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/hash/mod.rs:98: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/hash/mod.rs:102: #[stable(feature = "hash_slice", since = "1.3.0")] +src/libcore/hash/mod.rs:113:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/hash/mod.rs:116: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/hash/mod.rs:120: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/hash/mod.rs:125: #[stable(feature = "hasher_write", since = "1.3.0")] +src/libcore/hash/mod.rs:131: #[stable(feature = "hasher_write", since = "1.3.0")] +src/libcore/hash/mod.rs:137: #[stable(feature = "hasher_write", since = "1.3.0")] +src/libcore/hash/mod.rs:143: #[stable(feature = "hasher_write", since = "1.3.0")] +src/libcore/hash/mod.rs:149: #[stable(feature = "hasher_write", since = "1.3.0")] +src/libcore/hash/mod.rs:159: #[stable(feature = "hasher_write", since = "1.3.0")] +src/libcore/hash/mod.rs:165: #[stable(feature = "hasher_write", since = "1.3.0")] +src/libcore/hash/mod.rs:171: #[stable(feature = "hasher_write", since = "1.3.0")] +src/libcore/hash/mod.rs:177: #[stable(feature = "hasher_write", since = "1.3.0")] +src/libcore/hash/mod.rs:183: #[stable(feature = "hasher_write", since = "1.3.0")] +src/libcore/hash/mod.rs:199: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/hash/mod.rs:229: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/hash/mod.rs:236: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/hash/mod.rs:243: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/hash/mod.rs:253: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/hash/mod.rs:260: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/hash/mod.rs:285: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/hash/mod.rs:294: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/hash/mod.rs:301: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/hash/mod.rs:308: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/hash/mod.rs:315: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/hash/sip.rs:31:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/hash/sip.rs:107: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/hash/sip.rs:114: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/hash/sip.rs:142:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/hash/sip.rs:213:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/hash/sip.rs:231:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/intrinsics.rs:42:#![unstable(feature = "core_intrinsics", +src/libcore/intrinsics.rs:253: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/intrinsics.rs:334: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/intrinsics.rs:364: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/intrinsics.rs:369: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:57:#![stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:84:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:89: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:94: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:109: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:133: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:148: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:166: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:190: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:226: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:246: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:266: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:286: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:322: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:345: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:365: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:386: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:406: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:425: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:451: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:473: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:508: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:530: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:551: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:565: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:581: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:613: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:636: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:662: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:687: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:722: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:750: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:780: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:803: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:829: #[unstable(feature = "iter_cmp", +src/libcore/iter.rs:859: #[unstable(feature = "iter_cmp", +src/libcore/iter.rs:887: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:905: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:949: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:967: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:984: #[unstable(feature = "iter_arith", reason = "bounds recently changed", +src/libcore/iter.rs:1007: #[unstable(feature="iter_arith", reason = "bounds recently changed", +src/libcore/iter.rs:1018: #[unstable(feature = "iter_order", reason = "needs review and revision", issue = "27737")] +src/libcore/iter.rs:1041: #[unstable(feature = "iter_order", reason = "needs review and revision", issue = "27737")] +src/libcore/iter.rs:1064: #[unstable(feature = "iter_order", reason = "needs review and revision", issue = "27737")] +src/libcore/iter.rs:1083: #[unstable(feature = "iter_order", reason = "needs review and revision", issue = "27737")] +src/libcore/iter.rs:1102: #[unstable(feature = "iter_order", reason = "needs review and revision", issue = "27737")] +src/libcore/iter.rs:1129: #[unstable(feature = "iter_order", reason = "needs review and revision", issue = "27737")] +src/libcore/iter.rs:1156: #[unstable(feature = "iter_order", reason = "needs review and revision", issue = "27737")] +src/libcore/iter.rs:1183: #[unstable(feature = "iter_order", reason = "needs review and revision", issue = "27737")] +src/libcore/iter.rs:1240:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1248:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1275: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1283:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1286: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1290: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1294: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1298:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1309:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1312: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1321:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1325: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1329:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1341:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1344: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1357:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1362:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1364:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1368:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1371:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1375:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1382:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1387:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1397:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1404:#[stable(feature = "iter_cloned", since = "1.1.0")] +src/libcore/iter.rs:1411:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1426:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1435:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1443:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1449:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1475:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1505:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1589:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1613:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1619:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1651:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1678:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1685:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1700:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1712:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1719:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1740:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1757:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1764:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1787:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1805:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1811:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1854:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1872:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1878:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1925:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1928:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1933: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1953:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1961:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1987:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:1995:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:2027:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:2033:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:2095:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:2101:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:2107:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:2150:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:2156:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:2164:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:2187:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:2196:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:2229:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:2258:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:2264:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:2318:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:2332:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:2338:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:2356:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:2372:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:2387:#[unstable(feature = "step_trait", +src/libcore/iter.rs:2500:#[unstable(feature = "step_by", reason = "recent addition", +src/libcore/iter.rs:2520: #[unstable(feature = "step_by", reason = "recent addition", +src/libcore/iter.rs:2555: #[unstable(feature = "step_by", reason = "recent addition", +src/libcore/iter.rs:2565:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:2587:#[unstable(feature = "range_inclusive", +src/libcore/iter.rs:2597:#[unstable(feature = "range_inclusive", +src/libcore/iter.rs:2609:#[unstable(feature = "range_inclusive", +src/libcore/iter.rs:2643:#[unstable(feature = "range_inclusive", +src/libcore/iter.rs:2666:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:2705: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:2710:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:2740:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:2756:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:2772:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:2777:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:2787:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:2795:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/iter.rs:2801:#[stable(feature = "iter_empty", since = "1.2.0")] +src/libcore/iter.rs:2804:#[stable(feature = "iter_empty", since = "1.2.0")] +src/libcore/iter.rs:2817:#[stable(feature = "iter_empty", since = "1.2.0")] +src/libcore/iter.rs:2824:#[stable(feature = "iter_empty", since = "1.2.0")] +src/libcore/iter.rs:2833:#[stable(feature = "iter_empty", since = "1.2.0")] +src/libcore/iter.rs:2842:#[stable(feature = "iter_empty", since = "1.2.0")] +src/libcore/iter.rs:2850:#[stable(feature = "iter_empty", since = "1.2.0")] +src/libcore/iter.rs:2857:#[stable(feature = "iter_once", since = "1.2.0")] +src/libcore/iter.rs:2862:#[stable(feature = "iter_once", since = "1.2.0")] +src/libcore/iter.rs:2875:#[stable(feature = "iter_once", since = "1.2.0")] +src/libcore/iter.rs:2882:#[stable(feature = "iter_once", since = "1.2.0")] +src/libcore/iter.rs:2890:#[stable(feature = "iter_once", since = "1.2.0")] +src/libcore/iter.rs:2903:#[unstable(feature = "iter_order", reason = "needs review and revision", +src/libcore/lib.rs:23://! *It is not recommended to use the core library*. The stable +src/libcore/lib.rs:27://! intended to be stable. +src/libcore/lib.rs:52:#![unstable(feature = "core", +src/libcore/lib.rs:69:#![feature(allow_internal_unstable)] +src/libcore/macros.rs:13:#[allow_internal_unstable] +src/libcore/macros.rs:56:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/macros.rs:83:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/macros.rs:127:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/macros.rs:191:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/macros.rs:241:#[unstable(feature = "core", +src/libcore/macros.rs:304:#[unstable(feature = "core", +src/libcore/marker.rs:17:#![stable(feature = "rust1", since = "1.0.0")] +src/libcore/marker.rs:26:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/marker.rs:39:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/marker.rs:48:#[unstable(feature = "unsize", issue = "27732")] +src/libcore/marker.rs:153:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/marker.rs:200:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/marker.rs:355:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/marker.rs:399:#[unstable(feature = "reflect_marker", +src/libcore/mem.rs:16:#![stable(feature = "rust1", since = "1.0.0")] +src/libcore/mem.rs:22:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/mem.rs:112:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/mem.rs:127:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/mem.rs:142:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/mem.rs:159:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/mem.rs:175:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/mem.rs:193:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/mem.rs:208:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/mem.rs:232:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/mem.rs:250:#[unstable(feature = "filling_drop", issue = "5016")] +src/libcore/mem.rs:338:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/mem.rs:360:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/mem.rs:426:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/mem.rs:510:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/mem.rs:533:#[unstable(feature = "filling_drop", issue = "5016")] +src/libcore/mem.rs:536:#[unstable(feature = "filling_drop", issue = "5016")] +src/libcore/mem.rs:539:#[unstable(feature = "filling_drop", issue = "5016")] +src/libcore/mem.rs:544:#[unstable(feature = "filling_drop", issue = "5016")] +src/libcore/mem.rs:548:#[unstable(feature = "filling_drop", issue = "5016")] +src/libcore/mem.rs:575:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/nonzero.rs:12:#![unstable(feature = "nonzero", +src/libcore/num/bignum.rs:25:#![unstable(feature = "core_private_bignum", +src/libcore/num/dec2flt/mod.rs:91:#![unstable(feature = "dec2flt", +src/libcore/num/dec2flt/mod.rs:113: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/dec2flt/mod.rs:154:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/dec2flt/mod.rs:166: #[unstable(feature = "int_error_internals", +src/libcore/num/dec2flt/mod.rs:179:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/diy_float.rs:16:#![unstable(feature = "core_private_diy_float", +src/libcore/num/f32.rs:16:#![stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f32.rs:25:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f32.rs:29:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f32.rs:32:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f32.rs:36:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f32.rs:41:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f32.rs:44:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f32.rs:47:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f32.rs:50:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f32.rs:53:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f32.rs:57:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f32.rs:60:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f32.rs:64:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f32.rs:67:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f32.rs:70:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f32.rs:75:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f32.rs:80: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f32.rs:84: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f32.rs:88: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f32.rs:92: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f32.rs:96: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f32.rs:100: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f32.rs:104: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f32.rs:108: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f32.rs:112: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f32.rs:116: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f32.rs:120: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f32.rs:124: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f32.rs:128: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f32.rs:132: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f32.rs:136: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f32.rs:140: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f64.rs:16:#![stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f64.rs:25:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f64.rs:29:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f64.rs:32:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f64.rs:36:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f64.rs:41:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f64.rs:44:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f64.rs:47:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f64.rs:50:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f64.rs:53:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f64.rs:57:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f64.rs:60:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f64.rs:64:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f64.rs:67:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f64.rs:70:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f64.rs:75:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f64.rs:80: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f64.rs:84: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f64.rs:88: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f64.rs:92: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f64.rs:96: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f64.rs:100: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f64.rs:104: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f64.rs:108: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f64.rs:112: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f64.rs:116: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f64.rs:120: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f64.rs:124: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f64.rs:128: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f64.rs:132: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f64.rs:136: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/f64.rs:140: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/flt2dec/mod.rs:129:#![unstable(feature = "flt2dec", +src/libcore/num/i16.rs:15:#![stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/i32.rs:15:#![stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/i64.rs:15:#![stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/i8.rs:15:#![stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/int_macros.rs:17:#[unstable(feature = "num_bits_bytes", +src/libcore/num/int_macros.rs:24:#[unstable(feature = "num_bits_bytes", +src/libcore/num/int_macros.rs:32:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/int_macros.rs:38:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/isize.rs:15:#![stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:13:#![stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:41:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:43:pub struct Wrapping(#[stable(feature = "rust1", since = "1.0.0")] pub T); +src/libcore/num/mod.rs:57:#[unstable(feature = "zero_one", +src/libcore/num/mod.rs:69:#[unstable(feature = "zero_one", +src/libcore/num/mod.rs:123: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:130: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:145: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:159: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:172: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:188: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:204: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:221: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:239: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:255: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:277: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:299: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:321: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:343: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:358: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:373: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:388: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:404: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:417: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:429: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:441: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:451: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:461: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:478: #[stable(feature = "num_wrapping", since = "1.2.0")] +src/libcore/num/mod.rs:491: #[stable(feature = "num_wrapping", since = "1.2.0")] +src/libcore/num/mod.rs:505: #[stable(feature = "num_wrapping", since = "1.2.0")] +src/libcore/num/mod.rs:514: #[stable(feature = "num_wrapping", since = "1.2.0")] +src/libcore/num/mod.rs:523: #[stable(feature = "num_wrapping", since = "1.2.0")] +src/libcore/num/mod.rs:538: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:570: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:588: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:600: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:606: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:673: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:678: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:695: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:709: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:724: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:740: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:756: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:786: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:806: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:824: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:846: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:868: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:890: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:912: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:927: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:942: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:957: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:973: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:984: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:996: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:1008: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:1018: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:1028: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:1045: #[stable(feature = "num_wrapping", since = "1.2.0")] +src/libcore/num/mod.rs:1058: #[stable(feature = "num_wrapping", since = "1.2.0")] +src/libcore/num/mod.rs:1072: #[stable(feature = "num_wrapping", since = "1.2.0")] +src/libcore/num/mod.rs:1081: #[stable(feature = "num_wrapping", since = "1.2.0")] +src/libcore/num/mod.rs:1090: #[stable(feature = "num_wrapping", since = "1.2.0")] +src/libcore/num/mod.rs:1103: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:1132: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:1141: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:1152: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:1241:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:1244: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:1248: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:1252: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:1256: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:1260: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:1266:#[unstable(feature = "core_float", +src/libcore/num/mod.rs:1267: reason = "stable interface is via `impl f{32,64}` in later crates", +src/libcore/num/mod.rs:1332: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:1439:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/mod.rs:1451: #[unstable(feature = "int_error_internals", +src/libcore/num/mod.rs:1466:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/u16.rs:15:#![stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/u32.rs:15:#![stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/u64.rs:15:#![stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/u8.rs:15:#![stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/uint_macros.rs:15:#[unstable(feature = "num_bits_bytes", +src/libcore/num/uint_macros.rs:20:#[unstable(feature = "num_bits_bytes", +src/libcore/num/uint_macros.rs:26:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/uint_macros.rs:29:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/usize.rs:15:#![stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/wrapping.rs:12:#![unstable(feature = "wrapping", reason = "may be removed or relocated", +src/libcore/num/wrapping.rs:49: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/wrapping.rs:59: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/wrapping.rs:92: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/wrapping.rs:102: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/wrapping.rs:112: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/wrapping.rs:122: #[stable(feature = "wrapping_div", since = "1.3.0")] +src/libcore/num/wrapping.rs:132: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/wrapping.rs:142: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/wrapping.rs:152: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/num/wrapping.rs:162: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:68:#![stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:95:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:98: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:106: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:122: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:132: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:142: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:181:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:184: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:188: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:194: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:235:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:238: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:242: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:248: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:289:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:292: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:296: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:302: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:343:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:346: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:350: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:358: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:374: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:415:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:418: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:422: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:430: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:447: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:462:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:484:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:528:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:531: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:535: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:543: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:545: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:549: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:598:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:601: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:605: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:611: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:652:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:655: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:659: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:665: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:706:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:709: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:713: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:719: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:760:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:763: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:767: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:773: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:814:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:817: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:821: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:827: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:886:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:889: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:893: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:959:#[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] +src/libcore/ops.rs:968: #[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] +src/libcore/ops.rs:1008:#[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] +src/libcore/ops.rs:1017: #[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] +src/libcore/ops.rs:1057:#[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] +src/libcore/ops.rs:1066: #[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] +src/libcore/ops.rs:1106:#[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] +src/libcore/ops.rs:1115: #[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] +src/libcore/ops.rs:1155:#[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] +src/libcore/ops.rs:1164: #[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] +src/libcore/ops.rs:1204:#[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] +src/libcore/ops.rs:1213: #[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] +src/libcore/ops.rs:1253:#[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] +src/libcore/ops.rs:1262: #[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] +src/libcore/ops.rs:1302:#[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] +src/libcore/ops.rs:1311: #[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] +src/libcore/ops.rs:1351:#[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] +src/libcore/ops.rs:1360: #[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] +src/libcore/ops.rs:1419:#[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] +src/libcore/ops.rs:1428: #[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] +src/libcore/ops.rs:1488:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:1491: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:1495: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:1535:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:1538: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:1545:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:1548:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:1558:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:1561: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:1564: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:1568:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:1578:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:1581: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:1585:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:1595:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:1598: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:1602:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:1642:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:1645: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:1649: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:1653:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:1660:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:1707:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:1710: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:1714:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:1721:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:1731:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:1741:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ops.rs:1802:#[unstable(feature = "coerce_unsized", issue = "27732")] +src/libcore/ops.rs:1848:#[unstable(feature = "placement_new_protocol", issue = "27779")] +src/libcore/ops.rs:1879:#[unstable(feature = "placement_new_protocol", issue = "27779")] +src/libcore/ops.rs:1890:#[unstable(feature = "placement_new_protocol", issue = "27779")] +src/libcore/ops.rs:1927:#[unstable(feature = "placement_new_protocol", issue = "27779")] +src/libcore/ops.rs:1941:#[unstable(feature = "placement_new_protocol", issue = "27779")] +src/libcore/option.rs:144:#![stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:166:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:169: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:172: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:197: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:217: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:243: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:264: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:289: #[unstable(feature = "as_slice", +src/libcore/option.rs:329: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:361: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:378: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:396: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:422: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:443: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:466: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:487: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:508: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:532: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:553: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:584: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:609: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:639: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:661: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:687: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:694: #[unstable(feature = "as_slice", reason = "unsure of the utility here", +src/libcore/option.rs:711: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:741: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:754:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:757: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:761:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:785:#[stable(since = "1.4.0", feature = "option_iter")] +src/libcore/option.rs:795:#[stable(since = "1.4.0", feature = "option_iter")] +src/libcore/option.rs:841:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:844:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:854:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:860:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:863:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:871:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:874:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:884:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:890:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:895:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:898:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:908:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:914:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:921:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/option.rs:941: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/panicking.rs:32:#![unstable(feature = "core_panic", +src/libcore/prelude/mod.rs:13:#![stable(feature = "core_prelude", since = "1.4.0")] +src/libcore/prelude/v1.rs:17:#![stable(feature = "core_prelude", since = "1.4.0")] +src/libcore/ptr.rs:17:#![stable(feature = "rust1", since = "1.0.0")] +src/libcore/ptr.rs:34:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ptr.rs:37:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ptr.rs:40:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ptr.rs:54:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ptr.rs:68:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ptr.rs:79:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ptr.rs:102:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ptr.rs:120:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ptr.rs:130:#[unstable(feature = "filling_drop", +src/libcore/ptr.rs:155:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ptr.rs:160:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ptr.rs:164: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ptr.rs:179: #[unstable(feature = "ptr_as_ref", +src/libcore/ptr.rs:202: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ptr.rs:209:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ptr.rs:213: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ptr.rs:228: #[unstable(feature = "ptr_as_ref", +src/libcore/ptr.rs:250: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ptr.rs:263: #[unstable(feature = "ptr_as_ref", +src/libcore/ptr.rs:278:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ptr.rs:284:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ptr.rs:287:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ptr.rs:293:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ptr.rs:296:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ptr.rs:304:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ptr.rs:315: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ptr.rs:323: #[stable(feature = "fnptr_impls", since = "1.4.0")] +src/libcore/ptr.rs:331: #[stable(feature = "fnptr_impls", since = "1.4.0")] +src/libcore/ptr.rs:334: #[stable(feature = "fnptr_impls", since = "1.4.0")] +src/libcore/ptr.rs:342: #[stable(feature = "fnptr_impls", since = "1.4.0")] +src/libcore/ptr.rs:350: #[stable(feature = "fnptr_impls", since = "1.4.0")] +src/libcore/ptr.rs:357: #[stable(feature = "fnptr_impls", since = "1.4.0")] +src/libcore/ptr.rs:364: #[stable(feature = "fnptr_impls", since = "1.4.0")] +src/libcore/ptr.rs:397:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ptr.rs:411:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ptr.rs:431:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ptr.rs:445:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/ptr.rs:473:#[unstable(feature = "unique", reason = "needs an RFC to flesh out design", +src/libcore/ptr.rs:489:#[unstable(feature = "unique", issue = "27730")] +src/libcore/ptr.rs:496:#[unstable(feature = "unique", issue = "27730")] +src/libcore/ptr.rs:499:#[unstable(feature = "unique", issue = "27730")] +src/libcore/ptr.rs:517:#[unstable(feature = "unique", issue= "27730")] +src/libcore/ptr.rs:527:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/raw.rs:12:#![unstable(feature = "raw", issue = "27751")] +src/libcore/result.rs:230:#![stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:246:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:249: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:253: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:261:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:279: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:299: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:323: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:346: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:371: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:398: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:408: #[unstable(feature = "as_slice", reason = "unsure of the utility here", +src/libcore/result.rs:440: #[unstable(feature = "as_slice", +src/libcore/result.rs:479: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:505: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:529: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:550: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:581: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:605: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:635: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:659: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:681: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:701: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:710:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:731: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:751: #[stable(feature = "result_expect", since = "1.4.0")] +src/libcore/result.rs:760:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:781: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:795:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:819:#[stable(since = "1.4.0", feature = "result_iter")] +src/libcore/result.rs:829:#[stable(since = "1.4.0", feature = "result_iter")] +src/libcore/result.rs:844:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:847:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:860:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:866:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:874:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:877:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:890:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:896:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:900:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:903:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:916:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:922:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/result.rs:929:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/simd.rs:24:#![unstable(feature = "core_simd", +src/libcore/simd_old.rs:36:#![unstable(feature = "core_simd", +src/libcore/slice.rs:15:#![stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:66:#[unstable(feature = "core_slice_ext", +src/libcore/slice.rs:67: reason = "stable interface provided by `impl [T]` in later crates", +src/libcore/slice.rs:547:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:557:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:566:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:582:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:591:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:600:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:610:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:624:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:631:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:639:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:652:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:654: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:662:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:672:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:690: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:737: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:788:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:803: #[stable(feature = "iter_to_slice", since = "1.4.0")] +src/libcore/slice.rs:825:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:828:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:834:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:851: #[stable(feature = "iter_to_slice", since = "1.4.0")] +src/libcore/slice.rs:873:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:886:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:894:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:905:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:933:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:959:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:978:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:1013:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:1070:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:1078:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:1085:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:1093:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:1100: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:1125:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:1132:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:1142:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:1196:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:1210:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:1218:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:1225:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:1235:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:1296:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:1312:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:1318:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:1324:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:1388:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:1406:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:1414:#[unstable(feature = "ref_slice", issue = "27774")] +src/libcore/slice.rs:1422:#[unstable(feature = "ref_slice", issue = "27774")] +src/libcore/slice.rs:1462:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:1474:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:1484:#[unstable(feature = "slice_bytes", reason = "needs review", +src/libcore/slice.rs:1526:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:1556:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:1559:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/slice.rs:1580:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:15:#![stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:40:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:43: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:66: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:70:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:108:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:111:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:128:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:158: #[unstable(feature = "utf8_error", reason = "method just added", +src/libcore/str/mod.rs:237:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:273:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:278:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:293:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:323:#[unstable(feature = "str_internals", issue = "0")] +src/libcore/str/mod.rs:387:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:411:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:429: #[stable(feature = "iter_to_slice", since = "1.4.0")] +src/libcore/str/mod.rs:438:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:444:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:468:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:488: #[stable(feature = "iter_to_slice", since = "1.4.0")] +src/libcore/str/mod.rs:499:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:503:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:533:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:541:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:787: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:801: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:847: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:885: #[unstable(feature = "str_match_indices", +src/libcore/str/mod.rs:927: #[stable(feature = "str_matches", since = "1.2.0")] +src/libcore/str/mod.rs:934:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:938:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:953:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:962:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:997:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:1013:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:1157:#[unstable(feature = "str_char", +src/libcore/str/mod.rs:1187: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:1204: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:1214: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:1217: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:1251: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:1269: #[stable(feature = "derefmut_for_string", since = "1.2.0")] +src/libcore/str/mod.rs:1291: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:1308: #[stable(feature = "derefmut_for_string", since = "1.2.0")] +src/libcore/str/mod.rs:1327: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:1343: #[stable(feature = "derefmut_for_string", since = "1.2.0")] +src/libcore/str/mod.rs:1357: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:1367: #[stable(feature = "derefmut_for_string", since = "1.2.0")] +src/libcore/str/mod.rs:1379:#[unstable(feature = "core_str_ext", +src/libcore/str/mod.rs:1380: reason = "stable interface provided by `impl str` in later crates", +src/libcore/str/mod.rs:1797:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:1830:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/mod.rs:1832: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/str/pattern.rs:16:#![unstable(feature = "pattern", +src/libcore/sync/atomic.rs:71:#![stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:84:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:99:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:114:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:129:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:153:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:157: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:162: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:167: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:171: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:175: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:180:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:183:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:186:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:204: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:227: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:251: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:273: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:302: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:335: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:368: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:400: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:432: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:440:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:452: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:475: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:499: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:518: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:545: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:562: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:579: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:595: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:611: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:627: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:633:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:645: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:668: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:692: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:712: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:739: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:756: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:773: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:789: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:805: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:821: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:839: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:863: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:891: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:913: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:940: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:1085:#[stable(feature = "rust1", since = "1.0.0")] +src/libcore/sync/atomic.rs:1100: #[stable(feature = "atomic_debug", since = "1.3.0")] +src/libcore/sync/atomic.rs:1111:#[stable(feature = "atomic_debug", since = "1.3.0")] +src/libcore/sync/mod.rs:13:#![stable(feature = "rust1", since = "1.0.0")] +src/libcore/tuple.rs:30:#![stable(feature = "rust1", since = "1.0.0")] +src/libcore/tuple.rs:52: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/tuple.rs:59: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/tuple.rs:71: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/tuple.rs:74: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/tuple.rs:98: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/tuple.rs:106: #[stable(feature = "rust1", since = "1.0.0")] +src/libcore/tuple.rs:108: #[stable(feature = "rust1", since = "1.0.0")] +src/libcoretest/num/flt2dec/mod.rs:166:trait TestableFloat : DecodableFloat + fmt::Display { +src/libcoretest/num/flt2dec/mod.rs:172:impl TestableFloat for f32 { +src/libcoretest/num/flt2dec/mod.rs:176:impl TestableFloat for f64 { +src/libcoretest/num/flt2dec/mod.rs:181: where T: TestableFloat, +src/libcoretest/num/flt2dec/mod.rs:185: let v: T = TestableFloat::ldexpi(x, e); +src/libflate/lib.rs:20:#![unstable(feature = "rustc_private", issue = "27812")] +src/libfmt_macros/lib.rs:20:#![unstable(feature = "rustc_private", issue = "27812")] +src/libgetopts/lib.rs:82:#![unstable(feature = "rustc_private", +src/libgraphviz/lib.rs:279:#![unstable(feature = "rustc_private", issue = "27812")] +src/liblibc/lib.rs:16: unstable(feature = "libc", reason = "use `libc` from crates.io", +src/liblog/lib.rs:161:#![unstable(feature = "rustc_private", +src/librand/lib.rs:29:#![unstable(feature = "rand", +src/librand/reseeding.rs:114:#[stable(feature = "rust1", since = "1.0.0")] +src/librand/reseeding.rs:116: #[stable(feature = "rust1", since = "1.0.0")] +src/librbml/lib.rs:117:#![unstable(feature = "rustc_private", issue = "27812")] +src/librbml/lib.rs:965: // we should never try to move the stable positions, however. +src/librbml/lib.rs:1102: /// Returns the current position while marking it stable, i.e. +src/librbml/lib.rs:1104: pub fn mark_stable_position(&mut self) -> u64 { +src/librustc/diagnostics.rs:2033:#[stable] // error: stability attributes may not be used outside of the +src/librustc/front/map/mod.rs:408: /// regard should be expected to be highly unstable. +src/librustc/lib.rs:15://! This API is completely unstable and subject to change. +src/librustc/lib.rs:20:#![unstable(feature = "rustc_private", issue = "27812")] +src/librustc/lint/builtin.rs:82: "stable features found in #[feature] directive" +src/librustc/metadata/creader.rs:522: allow_internal_unstable: false, +src/librustc/metadata/encoder.rs:97: let position = rbml_w.mark_stable_position(); +src/librustc/metadata/encoder.rs:890: xref_positions[id as usize] = rbml_w.mark_stable_position() as u32; +src/librustc/metadata/macro_import.rs:163: def.allow_internal_unstable = attr::contains_name(&def.attrs, +src/librustc/metadata/macro_import.rs:164: "allow_internal_unstable"); +src/librustc/metadata/tyencode.rs:62: // type abbreviations needs a stable position +src/librustc/metadata/tyencode.rs:63: let pos = w.mark_stable_position(); +src/librustc/metadata/tyencode.rs:168: let end = w.mark_stable_position(); +src/librustc/metadata/tyencode.rs:182: // other won't have to `mark_stable_position` +src/librustc/middle/check_const.rs:42:use syntax::feature_gate::UnstableFeatures; +src/librustc/middle/check_const.rs:221: // this doesn't come from a macro that has #[allow_internal_unstable] +src/librustc/middle/check_const.rs:222: !self.tcx.sess.codemap().span_allows_unstable(expr.span) +src/librustc/middle/check_const.rs:226: &format!("const fns are an unstable feature")); +src/librustc/middle/check_const.rs:717: if let UnstableFeatures::Disallow = v.tcx.sess.opts.unstable_features { +src/librustc/middle/const_eval.rs:263: #[stable(feature = "rust1", since = "1.0.0")] +src/librustc/middle/stability.rs:79: // Check if deprecated_since < stable_since. If it is, +src/librustc/middle/stability.rs:81: let deprecated_predates_stable = match (stab.deprecated_since.as_ref(), +src/librustc/middle/stability.rs:111: if deprecated_predates_stable { +src/librustc/middle/stability.rs:119: // Don't inherit #[stable(feature = "rust1", since = "1.0.0")] +src/librustc/middle/stability.rs:150: if tag == "unstable" || tag == "stable" || tag == "deprecated" { +src/librustc/middle/stability.rs:260:/// Cross-references the feature names of unstable APIs with enabled +src/librustc/middle/stability.rs:263:pub fn check_unstable_api_usage(tcx: &ty::ctxt) +src/librustc/middle/stability.rs:291: // Only the cross-crate scenario matters when checking unstable APIs +src/librustc/middle/stability.rs:296: Some(&Stability { level: attr::Unstable, ref feature, ref reason, issue, .. }) => { +src/librustc/middle/stability.rs:297: self.used_features.insert(feature.clone(), attr::Unstable); +src/librustc/middle/stability.rs:301: Some(ref r) => format!("use of unstable library feature '{}': {}", +src/librustc/middle/stability.rs:303: None => format!("use of unstable library feature '{}'", &feature) +src/librustc/middle/stability.rs:391: // individually as it's possible to have a stable trait with unstable +src/librustc/middle/stability.rs:548: tcx.sess.codemap().span_allows_unstable(span) +src/librustc/middle/stability.rs:612:pub fn check_unused_or_stable_features(sess: &Session, +src/librustc/middle/stability.rs:619: let stable_msg = "this feature is stable. attribute no longer needed"; +src/librustc/middle/stability.rs:621: for &span in &sess.features.borrow().declared_stable_lang_features { +src/librustc/middle/stability.rs:625: stable_msg.to_string()); +src/librustc/middle/stability.rs:635: stable_msg.to_string()); +src/librustc/plugin/registry.rs:98: NormalTT(ext, _, allow_internal_unstable) => { +src/librustc/plugin/registry.rs:99: NormalTT(ext, Some(self.krate_span), allow_internal_unstable) +src/librustc/plugin/registry.rs:101: IdentTT(ext, _, allow_internal_unstable) => { +src/librustc/plugin/registry.rs:102: IdentTT(ext, Some(self.krate_span), allow_internal_unstable) +src/librustc/session/config.rs:33:use syntax::feature_gate::UnstableFeatures; +src/librustc/session/config.rs:116: /// Indicates how the compiler should treat unstable features +src/librustc/session/config.rs:117: pub unstable_features: UnstableFeatures +src/librustc/session/config.rs:223: unstable_features: UnstableFeatures::Disallow, +src/librustc/session/config.rs:583: unstable_options: bool = (false, parse_bool, +src/librustc/session/config.rs:584: "Adds unstable command line options to rustc interface"), +src/librustc/session/config.rs:678:/// Returns the "short" subset of the stable rustc command line options. +src/librustc/session/config.rs:681: .filter(|g|g.is_stable()) +src/librustc/session/config.rs:686:/// Returns all of the stable rustc command line options. +src/librustc/session/config.rs:689: .filter(|g|g.is_stable()) +src/librustc/session/config.rs:695:pub enum OptionStability { Stable, Unstable } +src/librustc/session/config.rs:704: pub fn is_stable(&self) -> bool { +src/librustc/session/config.rs:708: fn stable(g: getopts::OptGroup) -> RustcOptGroup { +src/librustc/session/config.rs:712: fn unstable(g: getopts::OptGroup) -> RustcOptGroup { +src/librustc/session/config.rs:713: RustcOptGroup { opt_group: g, stability: OptionStability::Unstable } +src/librustc/session/config.rs:721:// *unstable* options, i.e. options that are only enabled when the +src/librustc/session/config.rs:722:// user also passes the `-Z unstable-options` debugging flag. +src/librustc/session/config.rs:734: fn stable(g: getopts::OptGroup) -> R { RustcOptGroup::stable(g) } +src/librustc/session/config.rs:735: fn unstable(g: getopts::OptGroup) -> R { RustcOptGroup::unstable(g) } +src/librustc/session/config.rs:737: // FIXME (pnkfelix): We default to stable since the current set of +src/librustc/session/config.rs:738: // options is defacto stable. However, it would be good to revise the +src/librustc/session/config.rs:739: // code so that a stable option is the thing that takes extra effort +src/librustc/session/config.rs:742: pub fn opt(a: S, b: S, c: S, d: S) -> R { stable(getopts::optopt(a, b, c, d)) } +src/librustc/session/config.rs:743: pub fn multi(a: S, b: S, c: S, d: S) -> R { stable(getopts::optmulti(a, b, c, d)) } +src/librustc/session/config.rs:744: pub fn flag(a: S, b: S, c: S) -> R { stable(getopts::optflag(a, b, c)) } +src/librustc/session/config.rs:745: pub fn flagopt(a: S, b: S, c: S, d: S) -> R { stable(getopts::optflagopt(a, b, c, d)) } +src/librustc/session/config.rs:746: pub fn flagmulti(a: S, b: S, c: S) -> R { stable(getopts::optflagmulti(a, b, c)) } +src/librustc/session/config.rs:749: pub fn opt_u(a: S, b: S, c: S, d: S) -> R { unstable(getopts::optopt(a, b, c, d)) } +src/librustc/session/config.rs:750: pub fn multi_u(a: S, b: S, c: S, d: S) -> R { unstable(getopts::optmulti(a, b, c, d)) } +src/librustc/session/config.rs:751: pub fn flag_u(a: S, b: S, c: S) -> R { unstable(getopts::optflag(a, b, c)) } +src/librustc/session/config.rs:752: pub fn flagopt_u(a: S, b: S, c: S, d: S) -> R { unstable(getopts::optflagopt(a, b, c, d)) } +src/librustc/session/config.rs:753: pub fn flagmulti_u(a: S, b: S, c: S) -> R { unstable(getopts::optflagmulti(a, b, c)) } +src/librustc/session/config.rs:758:/// part of the stable long-term interface for rustc. +src/librustc/session/config.rs:807:/// each option, such as whether the option is part of the stable +src/librustc/session/config.rs:829: "Present the input source, unstable (and less-pretty) variants; +src/librustc/session/config.rs:1057: unstable_features: get_unstable_features_setting(), +src/librustc/session/config.rs:1062:pub fn get_unstable_features_setting() -> UnstableFeatures { +src/librustc/session/config.rs:1063: // Whether this is a feature-staged build, i.e. on the beta or stable channel +src/librustc/session/config.rs:1064: let disable_unstable_features = option_env!("CFG_DISABLE_UNSTABLE_FEATURES").is_some(); +src/librustc/session/config.rs:1066: // subverting the unstable features lints +src/librustc/session/config.rs:1070: match (disable_unstable_features, bootstrap_secret_key, bootstrap_provided_key) { +src/librustc/session/config.rs:1071: (_, Some(ref s), Some(ref p)) if s == p => UnstableFeatures::Cheat, +src/librustc/session/config.rs:1072: (true, _, _) => UnstableFeatures::Disallow, +src/librustc/session/config.rs:1073: (false, _, _) => UnstableFeatures::Allow +src/librustc/session/mod.rs:289: pub fn unstable_options(&self) -> bool { +src/librustc/session/mod.rs:290: self.opts.debugging_opts.unstable_options +src/librustc_back/lib.rs:27:#![unstable(feature = "rustc_private", issue = "27812")] +src/librustc_back/svh.rs:161: // hash leads to unstable SVH, because ident.name is just an index +src/librustc_bitflags/lib.rs:21:#![unstable(feature = "rustc_private", issue = "27812")] +src/librustc_borrowck/borrowck/mod.rs:105: stable_paths: 0, +src/librustc_borrowck/borrowck/mod.rs:120: println!("stable paths : {}", +src/librustc_borrowck/borrowck/mod.rs:121: make_stat(&bccx, bccx.stats.stable_paths)); +src/librustc_borrowck/borrowck/mod.rs:257: stable_paths: 0, +src/librustc_borrowck/borrowck/mod.rs:300: stable_paths: usize, +src/librustc_borrowck/diagnostics.rs:280:https://doc.rust-lang.org/stable/book/references-and-borrowing.html for more +src/librustc_borrowck/lib.rs:14:#![unstable(feature = "rustc_private", issue = "27812")] +src/librustc_data_structures/lib.rs:17://! This API is completely unstable and subject to change. +src/librustc_data_structures/lib.rs:22:#![unstable(feature = "rustc_private", issue = "27812")] +src/librustc_driver/driver.rs:562: sess.opts.unstable_features); +src/librustc_driver/driver.rs:606: sess.opts.unstable_features); +src/librustc_driver/driver.rs:773: stability::check_unstable_api_usage(tcx)); +src/librustc_driver/driver.rs:776: stability::check_unused_or_stable_features( +src/librustc_driver/lib.rs:15://! This API is completely unstable and subject to change. +src/librustc_driver/lib.rs:20:#![unstable(feature = "rustc_private", issue = "27812")] +src/librustc_driver/lib.rs:139: if sess.unstable_options() { +src/librustc_driver/lib.rs:344: let pretty = if sess.opts.debugging_opts.unstable_options { +src/librustc_driver/lib.rs:346: // stable pretty-print variants only +src/librustc_driver/lib.rs:352: if pretty.is_none() && sess.unstable_options() { +src/librustc_driver/lib.rs:354: // extended with unstable pretty-print variants +src/librustc_driver/lib.rs:515:fn usage(verbose: bool, include_unstable_options: bool) { +src/librustc_driver/lib.rs:522: .filter(|x| include_unstable_options || x.is_stable()) +src/librustc_driver/lib.rs:688: // user did not write `-v` nor `-Z unstable-options`, so do not +src/librustc_driver/lib.rs:694: fn allows_unstable_options(matches: &getopts::Matches) -> bool { +src/librustc_driver/lib.rs:696: r.iter().any(|x| *x == "unstable-options") +src/librustc_driver/lib.rs:704: if !allows_unstable_options(&m) { +src/librustc_driver/lib.rs:705: // If -Z unstable-options was not specified, verify that +src/librustc_driver/lib.rs:706: // no unstable options were present. +src/librustc_driver/lib.rs:707: for opt in config::rustc_optgroups().into_iter().filter(|x| !x.is_stable()) { +src/librustc_driver/lib.rs:714: early_error(diagnostic::Auto, &format!("use of unstable option '{}' \ +src/librustc_driver/lib.rs:715: requires -Z unstable-options", +src/librustc_driver/lib.rs:727: // the stable options. +src/librustc_driver/lib.rs:729: Ok(ref m) if allows_unstable_options(m) => { +src/librustc_driver/lib.rs:730: // If -Z unstable-options was specified, redo parsing with the +src/librustc_driver/lib.rs:731: // unstable options to ensure that unstable options are defined +src/librustc_driver/lib.rs:737: // redo option parsing, including unstable options this time, +src/librustc_driver/lib.rs:739: // unstable ones. +src/librustc_driver/lib.rs:745: usage(matches.opt_present("verbose"), allows_unstable_options(&matches)); +src/librustc_driver/test.rs:39:use syntax::feature_gate::UnstableFeatures; +src/librustc_driver/test.rs:110: options.unstable_features = UnstableFeatures::Allow; +src/librustc_front/attr.rs:353: Unstable, +src/librustc_front/attr.rs:376: if tag != "deprecated" && tag != "unstable" && tag != "stable" { +src/librustc_front/attr.rs:442: // Unstable tags don't require a version +src/librustc_front/attr.rs:443: if since == None && tag != "unstable" { +src/librustc_front/attr.rs:447: if tag == "unstable" || tag == "stable" { +src/librustc_front/attr.rs:453: "unstable" => Unstable, +src/librustc_front/attr.rs:454: "stable" => Stable, +src/librustc_front/attr.rs:485: either stable or unstable attribute"); +src/librustc_front/attr.rs:488: } else if stab.as_ref().map_or(false, |s| s.level == Unstable && s.issue.is_none()) { +src/librustc_front/attr.rs:489: // non-deprecated unstable items need to point to issues. +src/librustc_front/attr.rs:491: "non-deprecated unstable items need to point \ +src/librustc_front/hir.rs:347: pub allow_internal_unstable: bool, +src/librustc_front/lib.rs:15://! This API is completely unstable and subject to change. +src/librustc_front/lib.rs:20:#![unstable(feature = "rustc_private", issue = "27812")] +src/librustc_front/lowering.rs:581: allow_internal_unstable: m.allow_internal_unstable, +src/librustc_lint/builtin.rs:701: attr::Unstable => attr::Unstable, +src/librustc_lint/builtin.rs:1192:pub struct UnstableFeatures; +src/librustc_lint/builtin.rs:1197: "enabling unstable features (deprecated. do not use)" +src/librustc_lint/builtin.rs:1200:impl LintPass for UnstableFeatures { +src/librustc_lint/builtin.rs:1206:impl LateLintPass for UnstableFeatures { +src/librustc_lint/builtin.rs:1211: ctx.span_lint(UNSTABLE_FEATURES, item.span, "unstable feature"); +src/librustc_lint/lib.rs:20://! This API is completely unstable and subject to change. +src/librustc_lint/lib.rs:25:#![unstable(feature = "rustc_private", issue = "27812")] +src/librustc_lint/lib.rs:127: UnstableFeatures, +src/librustc_lint/types.rs:397: /// Check if the given type is "ffi-safe" (has a stable, well-defined +src/librustc_lint/types.rs:505: // Primitive types with a stable representation. +src/librustc_llvm/lib.rs:20:#![unstable(feature = "rustc_private", issue = "27812")] +src/librustc_platform_intrinsics/lib.rs:13:#![unstable(feature = "rustc_private", issue = "27812")] +src/librustc_privacy/lib.rs:14:#![unstable(feature = "rustc_private", issue = "27812")] +src/librustc_resolve/lib.rs:14:#![unstable(feature = "rustc_private", issue = "27812")] +src/librustc_trans/back/link.rs:110: * - The hash shown in the filename needs to be predictable and stable for +src/librustc_trans/lib.rs:15://! This API is completely unstable and subject to change. +src/librustc_trans/lib.rs:20:#![unstable(feature = "rustc_private", issue = "27812")] +src/librustc_trans/trans/datum.rs:707: /// This function is private to datums because it leaves memory in an unstable state, where the +src/librustc_trans/trans/debuginfo/doc.rs:171://! This algorithm also provides a stable ID for types that are defined in one +src/librustc_typeck/astconv.rs:850: parenthetical notation is only stable when used with `Fn`-family traits"); +src/librustc_typeck/check/mod.rs:201: ExpectCastableToType(Ty<'tcx>), +src/librustc_typeck/check/mod.rs:209: // Disregard "castable to" expectations because they +src/librustc_typeck/check/mod.rs:212: // "castable to u8" constraint to 22, it will pick the +src/librustc_typeck/check/mod.rs:215: // "castable to" expectation is not the tightest thing +src/librustc_typeck/check/mod.rs:3493: check_expr_with_expectation(fcx, e, ExpectCastableToType(t_cast)); +src/librustc_typeck/check/mod.rs:3863: ExpectCastableToType(t) => { +src/librustc_typeck/check/mod.rs:3864: ExpectCastableToType( +src/librustc_typeck/check/mod.rs:3881: ExpectCastableToType(ty) | +src/librustc_typeck/check/writeback.rs:131: "overloaded augmented assignments are not stable"); +src/librustc_typeck/diagnostics.rs:2981: // https://doc.rust-lang.org/stable/std/ops/trait.Shl.html +src/librustc_typeck/diagnostics.rs:3365:// E0215, // angle-bracket notation is not stable with `Fn` +src/librustc_typeck/diagnostics.rs:3366:// E0216, // parenthetical notation is only stable with `Fn` +src/librustc_typeck/lib.rs:62:This API is completely unstable and subject to change. +src/librustc_typeck/lib.rs:68:#![unstable(feature = "rustc_private", issue = "27812")] +src/librustc_unicode/char.rs:30:#![stable(feature = "rust1", since = "1.0.0")] +src/librustc_unicode/char.rs:37:// stable reexports +src/librustc_unicode/char.rs:40:// unstable reexports +src/librustc_unicode/char.rs:46:#[stable(feature = "rust1", since = "1.0.0")] +src/librustc_unicode/char.rs:49:#[stable(feature = "rust1", since = "1.0.0")] +src/librustc_unicode/char.rs:58:#[stable(feature = "rust1", since = "1.0.0")] +src/librustc_unicode/char.rs:61:#[stable(feature = "rust1", since = "1.0.0")] +src/librustc_unicode/char.rs:110:#[stable(feature = "rust1", since = "1.0.0")] +src/librustc_unicode/char.rs:166: #[stable(feature = "rust1", since = "1.0.0")] +src/librustc_unicode/char.rs:230: #[stable(feature = "rust1", since = "1.0.0")] +src/librustc_unicode/char.rs:263: #[stable(feature = "rust1", since = "1.0.0")] +src/librustc_unicode/char.rs:310: #[stable(feature = "rust1", since = "1.0.0")] +src/librustc_unicode/char.rs:359: #[stable(feature = "rust1", since = "1.0.0")] +src/librustc_unicode/char.rs:379: #[stable(feature = "rust1", since = "1.0.0")] +src/librustc_unicode/char.rs:415: #[unstable(feature = "unicode", +src/librustc_unicode/char.rs:455: #[unstable(feature = "unicode", +src/librustc_unicode/char.rs:481: #[stable(feature = "rust1", since = "1.0.0")] +src/librustc_unicode/char.rs:497: #[unstable(feature = "unicode", +src/librustc_unicode/char.rs:509: #[unstable(feature = "unicode", +src/librustc_unicode/char.rs:541: #[stable(feature = "rust1", since = "1.0.0")] +src/librustc_unicode/char.rs:577: #[stable(feature = "rust1", since = "1.0.0")] +src/librustc_unicode/char.rs:607: #[stable(feature = "rust1", since = "1.0.0")] +src/librustc_unicode/char.rs:651: #[stable(feature = "rust1", since = "1.0.0")] +src/librustc_unicode/char.rs:674: #[stable(feature = "rust1", since = "1.0.0")] +src/librustc_unicode/char.rs:712: #[stable(feature = "rust1", since = "1.0.0")] +src/librustc_unicode/char.rs:753: #[stable(feature = "rust1", since = "1.0.0")] +src/librustc_unicode/char.rs:816: #[stable(feature = "rust1", since = "1.0.0")] +src/librustc_unicode/char.rs:824:#[unstable(feature = "decode_utf16", reason = "recently exposed", issue = "27830")] +src/librustc_unicode/char.rs:875:#[unstable(feature = "decode_utf16", reason = "recently exposed", issue = "27830")] +src/librustc_unicode/char.rs:884:#[unstable(feature = "decode_utf16", reason = "recently exposed", issue = "27830")] +src/librustc_unicode/char.rs:934:#[unstable(feature = "decode_utf16", reason = "recently added", issue = "27830")] +src/librustc_unicode/lib.rs:26:#![unstable(feature = "unicode", issue = "27783")] +src/librustc_unicode/u_str.rs:24:#[stable(feature = "split_whitespace", since = "1.1.0")] +src/librustc_unicode/u_str.rs:124:#[unstable(feature = "decode_utf16", reason = "not exposed in std", issue = "27830")] +src/librustc_unicode/u_str.rs:133:#[unstable(feature = "decode_utf16", reason = "not exposed in std", issue = "27830")] +src/librustc_unicode/u_str.rs:157:#[unstable(feature = "decode_utf16", reason = "not exposed in std", issue = "27830")] +src/librustc_unicode/u_str.rs:202:#[unstable(feature = "decode_utf16", reason = "not exposed in std", issue = "27830")] +src/librustdoc/clean/mod.rs:58:/// A stable identifier to the particular version of JSON output. +src/librustdoc/clean/mod.rs:327: attr::Unstable => "unstable".to_string(), +src/librustdoc/core.rs:25:use syntax::feature_gate::UnstableFeatures; +src/librustdoc/core.rs:112: unstable_features: UnstableFeatures::Allow, +src/librustdoc/html/markdown.rs:393:pub fn find_testable_code(doc: &str, tests: &mut ::test::Collector) { +src/librustdoc/html/render.rs:1611: (Some(attr::Unstable), Some(attr::Stable)) => return Ordering::Greater, +src/librustdoc/html/render.rs:1612: (Some(attr::Stable), Some(attr::Unstable)) => return Ordering::Less, +src/librustdoc/html/render.rs:1727: } else if stab.level == attr::Unstable { +src/librustdoc/html/render.rs:1728: let unstable_extra = if show_reason { +src/librustdoc/html/render.rs:1743: format!("Unstable{}{}", unstable_extra, Markdown(&reason)) +src/librustdoc/html/static/main.css:512:em.stab.unstable { background: #FFF5D6; border-color: #FFC600; } +src/librustdoc/html/static/main.css:534:.module-item.unstable { +src/librustdoc/lib.rs:14:#![unstable(feature = "rustdoc", issue = "27812")] +src/librustdoc/markdown.rs:26:use html::markdown::{Markdown, MarkdownWithToc, find_testable_code, reset_headers}; +src/librustdoc/markdown.rs:152: find_testable_code(&input_str, &mut collector); +src/librustdoc/test.rs:27:use rustc::session::config::{get_unstable_features_setting, OutputType}; +src/librustdoc/test.rs:65: unstable_features: get_unstable_features_setting(), +src/librustdoc/test.rs:185: unstable_features: get_unstable_features_setting(), +src/librustdoc/test.rs:430: markdown::find_testable_code(doc, &mut *self); +src/libserialize/lib.rs:20:#![unstable(feature = "rustc_private", +src/libstd/ascii.rs:13:#![stable(feature = "rust1", since = "1.0.0")] +src/libstd/ascii.rs:21:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ascii.rs:24: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ascii.rs:40: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ascii.rs:59: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ascii.rs:78: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ascii.rs:100: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ascii.rs:120: #[unstable(feature = "ascii", issue = "27809")] +src/libstd/ascii.rs:140: #[unstable(feature = "ascii", issue = "27809")] +src/libstd/ascii.rs:144:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ascii.rs:185:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ascii.rs:228:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ascii.rs:247:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ascii.rs:286:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ascii.rs:317:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ascii.rs:340:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ascii.rs:346:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ascii.rs:352:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:308:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:516: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:530: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:556: #[unstable(feature = "hashmap_hasher", reason = "hasher stuff is unclear", +src/libstd/collections/hash/map.rs:587: #[unstable(feature = "hashmap_hasher", reason = "hasher stuff is unclear", +src/libstd/collections/hash/map.rs:612: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:632: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:744: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:838: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:863: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:888: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:916: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:940: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:961: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:977: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1002: #[unstable(feature = "drain", +src/libstd/collections/hash/map.rs:1027: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1049: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1072: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1097: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1120: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1149: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1220:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1225:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1234:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1244:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1259:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1274:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1280:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1286:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1301:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1316:#[unstable(feature = "drain", +src/libstd/collections/hash/map.rs:1324:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1330:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1338:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1341: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1345: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1358:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1370:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1382:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1416:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1423:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1428:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1435:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1440:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1447:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1452:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1459:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1464:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1471:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1476:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1483:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1489: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1499: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1512: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1518: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1525: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1531: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1539: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1548: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1561:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1575:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/map.rs:1586:#[stable(feature = "hash_extend_copy", since = "1.4.0")] +src/libstd/collections/hash/map.rs:1601:#[unstable(feature = "hashmap_hasher", +src/libstd/collections/hash/map.rs:1609:#[unstable(feature = "hashmap_hasher", +src/libstd/collections/hash/map.rs:1622:#[unstable(feature = "hashmap_hasher", +src/libstd/collections/hash/map.rs:1633:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:111:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:126: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:141: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:168: #[unstable(feature = "hashmap_hasher", reason = "hasher stuff is unclear", +src/libstd/collections/hash/set.rs:195: #[unstable(feature = "hashmap_hasher", reason = "hasher stuff is unclear", +src/libstd/collections/hash/set.rs:214: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:234: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:255: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:276: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:303: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:331: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:354: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:379: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:396: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:411: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:416: #[unstable(feature = "drain", +src/libstd/collections/hash/set.rs:438: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:456: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:468: #[unstable(feature = "set_recovery", issue = "28050")] +src/libstd/collections/hash/set.rs:492: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:513: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:538: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:557: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:562: #[unstable(feature = "set_recovery", issue = "28050")] +src/libstd/collections/hash/set.rs:585: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:597: #[unstable(feature = "set_recovery", issue = "28050")] +src/libstd/collections/hash/set.rs:605:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:616:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:621:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:631:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:645:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:657:#[stable(feature = "hash_extend_copy", since = "1.4.0")] +src/libstd/collections/hash/set.rs:667:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:672: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:678:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:710:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:742:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:774:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:807:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:813:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:819:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:825:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:834:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:843:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:849:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:854:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:866:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:905:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:912:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:917:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:924:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:929:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:936:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:947:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:976:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:1005:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/set.rs:1019:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/hash/state.rs:11:#![unstable(feature = "hashmap_hasher", reason = "hasher stuff is unclear", +src/libstd/collections/mod.rs:363:#![stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/mod.rs:377:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/mod.rs:383:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/collections/mod.rs:391:#[unstable(feature = "hashmap_hasher", reason = "module was recently added", +src/libstd/dynamic_lib.rs:15:#![unstable(feature = "dynamic_lib", +src/libstd/env.rs:17:#![stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:48:#[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:66:#[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:77:#[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:84:#[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:111:#[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:134:#[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:140:#[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:151:#[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:175:#[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:201:#[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:213:#[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:217: #[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:223: #[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:227:#[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:239:#[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:272:#[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:307:#[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:321:#[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:344:#[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:349:#[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:359:#[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:386:#[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:395:#[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:402:#[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:431:#[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:459:#[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:487:#[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:496:#[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:503:#[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:529:#[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:551:#[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:556:#[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:565:#[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:570:#[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:577:#[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:583:#[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:597: #[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:606: #[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:624: #[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:634: #[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:645: #[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:656: #[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:666: #[stable(feature = "env", since = "1.0.0")] +src/libstd/env.rs:676: #[stable(feature = "env", since = "1.0.0")] +src/libstd/error.rs:37:#![stable(feature = "rust1", since = "1.0.0")] +src/libstd/error.rs:64:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/error.rs:71: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/error.rs:75: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/error.rs:80: #[unstable(feature = "error_type_id", +src/libstd/error.rs:88:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/error.rs:95:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/error.rs:102:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/error.rs:122:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/error.rs:129:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/error.rs:134:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/error.rs:141:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/error.rs:148:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/error.rs:155:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/error.rs:162:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/error.rs:172: #[stable(feature = "error_downcast", since = "1.3.0")] +src/libstd/error.rs:187: #[stable(feature = "error_downcast", since = "1.3.0")] +src/libstd/error.rs:205: #[stable(feature = "error_downcast", since = "1.3.0")] +src/libstd/error.rs:224: #[stable(feature = "error_downcast", since = "1.3.0")] +src/libstd/error.rs:231: #[stable(feature = "error_downcast", since = "1.3.0")] +src/libstd/error.rs:238: #[stable(feature = "error_downcast", since = "1.3.0")] +src/libstd/error.rs:247: #[stable(feature = "error_downcast", since = "1.3.0")] +src/libstd/error.rs:254: #[stable(feature = "error_downcast", since = "1.3.0")] +src/libstd/error.rs:261: #[stable(feature = "error_downcast", since = "1.3.0")] +src/libstd/error.rs:270: #[stable(feature = "error_downcast", since = "1.3.0")] +src/libstd/error.rs:291: #[stable(feature = "error_downcast", since = "1.3.0")] +src/libstd/error.rs:305: #[stable(feature = "error_downcast", since = "1.3.0")] +src/libstd/ffi/c_str.rs:65:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/c_str.rs:139:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/c_str.rs:151:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/c_str.rs:182: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/c_str.rs:200: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/c_str.rs:211: #[unstable(feature = "cstr_memory2", reason = "recently added", +src/libstd/ffi/c_str.rs:223: #[stable(feature = "cstr_memory", since = "1.4.0")] +src/libstd/ffi/c_str.rs:238: #[unstable(feature = "cstr_memory2", reason = "recently added", +src/libstd/ffi/c_str.rs:253: #[stable(feature = "cstr_memory", since = "1.4.0")] +src/libstd/ffi/c_str.rs:262: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/c_str.rs:269: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/c_str.rs:275:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/c_str.rs:284:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/c_str.rs:291:#[stable(feature = "cstr_debug", since = "1.3.0")] +src/libstd/ffi/c_str.rs:302:#[stable(feature = "cstr_borrow", since = "1.3.0")] +src/libstd/ffi/c_str.rs:310: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/c_str.rs:315: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/c_str.rs:319:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/c_str.rs:324:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/c_str.rs:331:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/c_str.rs:377: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/c_str.rs:388: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/c_str.rs:405: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/c_str.rs:419: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/c_str.rs:433: #[stable(feature = "cstr_to_str", since = "1.4.0")] +src/libstd/ffi/c_str.rs:453: #[stable(feature = "cstr_to_str", since = "1.4.0")] +src/libstd/ffi/c_str.rs:459:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/c_str.rs:465:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/c_str.rs:467:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/c_str.rs:473:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/c_str.rs:480:#[stable(feature = "cstr_borrow", since = "1.3.0")] +src/libstd/ffi/mod.rs:13:#![stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/mod.rs:15:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/mod.rs:18:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:47:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:53:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:60: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:74: #[unstable(feature = "convert", reason = "recently added", issue = "27704")] +src/libstd/ffi/os_str.rs:91: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:99: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:105: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:111:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:118:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:125:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:135:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:145:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:152:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:159:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:166:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:173:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:176:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:192:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:200:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:208:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:218: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:230: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:238: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:244: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:258: #[unstable(feature = "convert", reason = "recently added", issue = "27704")] +src/libstd/ffi/os_str.rs:274: #[unstable(feature = "convert", reason = "recently added", issue = "27704")] +src/libstd/ffi/os_str.rs:288:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:295:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:302:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:309:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:312:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:328:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:339:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:345:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:353:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:360:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:365:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:371:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:378:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:385:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/ffi/os_str.rs:392:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:18:#![stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:52:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:62:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:76:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:84:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:88:#[unstable(feature = "fs_walk", +src/libstd/fs.rs:137:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:147:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:151:#[stable(feature = "file_type", since = "1.1.0")] +src/libstd/fs.rs:158:#[unstable(feature = "dir_builder", reason = "recently added API", +src/libstd/fs.rs:185: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:207: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:231: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:260: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:288: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:306: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:332:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:341:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:348:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:354:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:360:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:367:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:386: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:403: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:420: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:437: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:454: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:471: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:495: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:512: #[stable(feature = "file_type", since = "1.1.0")] +src/libstd/fs.rs:531: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:548: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:565: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:582: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:608: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:636: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:644: #[stable(feature = "file_type", since = "1.1.0")] +src/libstd/fs.rs:648: #[stable(feature = "file_type", since = "1.1.0")] +src/libstd/fs.rs:652: #[stable(feature = "file_type", since = "1.1.0")] +src/libstd/fs.rs:670:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:679:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:708: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:721: #[stable(feature = "dir_entry_ext", since = "1.1.0")] +src/libstd/fs.rs:736: #[stable(feature = "dir_entry_ext", since = "1.1.0")] +src/libstd/fs.rs:743: #[stable(feature = "dir_entry_ext", since = "1.1.0")] +src/libstd/fs.rs:775:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:803:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:821:#[stable(feature = "symlink_metadata", since = "1.1.0")] +src/libstd/fs.rs:847:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:881:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:901:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:927:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:950:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:957:#[unstable(feature = "fs_canonicalize", reason = "recently added API", +src/libstd/fs.rs:980:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:1005:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:1027:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:1052:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:1103:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/fs.rs:1116:#[unstable(feature = "fs_walk", +src/libstd/fs.rs:1130:#[unstable(feature = "fs_walk", issue = "27707")] +src/libstd/fs.rs:1160:#[unstable(feature = "path_ext", +src/libstd/fs.rs:1162: change and some methods may be removed. For stable code, \ +src/libstd/fs.rs:1254:#[stable(feature = "set_permissions", since = "1.1.0")] +src/libstd/fs.rs:1260:#[unstable(feature = "dir_builder", reason = "recently added API", +src/libstd/io/buffered.rs:46:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/buffered.rs:69: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/buffered.rs:90: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/buffered.rs:118: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/buffered.rs:139: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/buffered.rs:160: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/buffered.rs:164:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/buffered.rs:182:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/buffered.rs:199:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/buffered.rs:209:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/buffered.rs:298:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/buffered.rs:329:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/buffered.rs:343: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/buffered.rs:361: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/buffered.rs:405: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/buffered.rs:423: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/buffered.rs:441: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/buffered.rs:450:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/buffered.rs:468:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/buffered.rs:478:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/buffered.rs:526: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/buffered.rs:559: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/buffered.rs:563:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/buffered.rs:568:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/buffered.rs:575:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/buffered.rs:630:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/buffered.rs:650: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/buffered.rs:671: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/buffered.rs:692: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/buffered.rs:715: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/buffered.rs:737: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/buffered.rs:745:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/buffered.rs:762:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/cursor.rs:77:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/cursor.rs:96: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/cursor.rs:114: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/cursor.rs:130: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/cursor.rs:149: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/cursor.rs:171: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/cursor.rs:191: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/cursor.rs:195:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/cursor.rs:214:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/cursor.rs:223:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/cursor.rs:232:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/cursor.rs:243:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/error.rs:51:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/error.rs:61:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/error.rs:82:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/error.rs:85: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/error.rs:88: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/error.rs:91: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/error.rs:94: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/error.rs:97: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/error.rs:100: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/error.rs:104: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/error.rs:108: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/error.rs:111: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/error.rs:114: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/error.rs:118: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/error.rs:121: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/error.rs:131: #[stable(feature = "io_invalid_data", since = "1.2.0")] +src/libstd/io/error.rs:134: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/error.rs:142: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/error.rs:147: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/error.rs:150: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/error.rs:159: #[unstable(feature = "read_exact", reason = "recently added", issue = "27585")] +src/libstd/io/error.rs:163: #[unstable(feature = "io_error_internals", +src/libstd/io/error.rs:190: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/error.rs:211: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/error.rs:217: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/error.rs:227: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/error.rs:239: #[stable(feature = "io_error_inner", since = "1.3.0")] +src/libstd/io/error.rs:252: #[stable(feature = "io_error_inner", since = "1.3.0")] +src/libstd/io/error.rs:264: #[stable(feature = "io_error_inner", since = "1.3.0")] +src/libstd/io/error.rs:273: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/error.rs:293:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/error.rs:306:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/impls.rs:23:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/impls.rs:45:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/impls.rs:63:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/impls.rs:68:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/impls.rs:87:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/impls.rs:109:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/impls.rs:127:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/impls.rs:132:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/impls.rs:154:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/impls.rs:177:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/impls.rs:186:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/impls.rs:210:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:242:#![stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:410:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:460: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:502: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:540: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:602: #[unstable(feature = "read_exact", reason = "recently added", issue = "27585")] +src/libstd/io/mod.rs:654: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:684: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:721: #[unstable(feature = "io", reason = "the semantics of a partial read/write \ +src/libstd/io/mod.rs:759: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:793: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:829: #[unstable(feature = "io", reason = "the semantics of a partial read/write \ +src/libstd/io/mod.rs:868:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:908: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:934: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:961: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:1013: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:1062: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:1092: #[unstable(feature = "io", reason = "the semantics of a partial read/write \ +src/libstd/io/mod.rs:1129:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:1143: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:1149:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:1152: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:1160: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:1168: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:1251:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:1296: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:1318: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:1359: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:1407: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:1440: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:1465: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:1477:#[unstable(feature = "io", reason = "awaiting stability of Write::broadcast", +src/libstd/io/mod.rs:1484:#[unstable(feature = "io", reason = "awaiting stability of Write::broadcast", +src/libstd/io/mod.rs:1505:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:1512:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:1531:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:1537:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:1546: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:1550:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:1565:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:1587:#[unstable(feature = "io", reason = "awaiting stability of Read::tee", +src/libstd/io/mod.rs:1594:#[unstable(feature = "io", reason = "awaiting stability of Read::tee", +src/libstd/io/mod.rs:1611:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:1616:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:1636:#[unstable(feature = "io", reason = "awaiting stability of Read::chars", +src/libstd/io/mod.rs:1645:#[unstable(feature = "io", reason = "awaiting stability of Read::chars", +src/libstd/io/mod.rs:1656:#[unstable(feature = "io", reason = "awaiting stability of Read::chars", +src/libstd/io/mod.rs:1689:#[unstable(feature = "io", reason = "awaiting stability of Read::chars", +src/libstd/io/mod.rs:1706:#[unstable(feature = "io", reason = "awaiting stability of Read::chars", +src/libstd/io/mod.rs:1726:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:1732:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:1757:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/mod.rs:1762:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/prelude.rs:21:#![stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/stdio.rs:144:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/stdio.rs:153:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/stdio.rs:194:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/stdio.rs:226: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/stdio.rs:257: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/stdio.rs:263:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/stdio.rs:279:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/stdio.rs:289:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/stdio.rs:318:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/stdio.rs:330:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/stdio.rs:371:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/stdio.rs:394: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/stdio.rs:400:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/stdio.rs:415:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/stdio.rs:428:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/stdio.rs:437:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/stdio.rs:474:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/stdio.rs:496: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/stdio.rs:502:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/stdio.rs:517:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/stdio.rs:535:#[unstable(feature = "set_stdio", +src/libstd/io/stdio.rs:559:#[unstable(feature = "set_stdio", +src/libstd/io/stdio.rs:574:#[unstable(feature = "print", +src/libstd/io/util.rs:45:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/util.rs:69:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/util.rs:90:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/util.rs:93:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/util.rs:97:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/util.rs:109:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/util.rs:116:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/util.rs:119:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/util.rs:135:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/util.rs:142:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/io/util.rs:145:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/lib.rs:190:#![stable(feature = "rust1", since = "1.0.0")] +src/libstd/lib.rs:203:#![feature(allow_internal_unstable)] +src/libstd/lib.rs:280:// Make std testable by not duplicating lang items and other globals. See #2912 +src/libstd/lib.rs:390:// unstable module so we can get our build working. +src/libstd/lib.rs:392:#[unstable(feature = "rand", issue = "0")] +src/libstd/macros.rs:37:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/macros.rs:38:#[allow_internal_unstable] +src/libstd/macros.rs:95:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/macros.rs:96:#[allow_internal_unstable] +src/libstd/macros.rs:117:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/macros.rs:153:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/macros.rs:199:#[unstable(feature = "mpsc_select", issue = "27800")] +src/libstd/net/addr.rs:29:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/addr.rs:32: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/addr.rs:35: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/addr.rs:41:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/addr.rs:46:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/addr.rs:51: #[unstable(feature = "ip_addr", reason = "recent addition", issue = "27801")] +src/libstd/net/addr.rs:60: #[unstable(feature = "ip_addr", reason = "recent addition", issue = "27801")] +src/libstd/net/addr.rs:69: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/addr.rs:80: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/addr.rs:93: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/addr.rs:101: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/addr.rs:108: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/addr.rs:124: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/addr.rs:132: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/addr.rs:137: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/addr.rs:142: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/addr.rs:171:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/addr.rs:181:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/addr.rs:188:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/addr.rs:195:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/addr.rs:202:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/addr.rs:209:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/addr.rs:213:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/addr.rs:218:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/addr.rs:225:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/addr.rs:234:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/addr.rs:236:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/addr.rs:239:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/addr.rs:245:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/addr.rs:307:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/addr.rs:311: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/addr.rs:325: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/addr.rs:329:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/addr.rs:337:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/addr.rs:345:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/addr.rs:353:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/addr.rs:365:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/addr.rs:374:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/addr.rs:401:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/addr.rs:422:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/ip.rs:11:#![unstable(feature = "ip", reason = "extra functionality has not been \ +src/libstd/net/ip.rs:13: be stable", +src/libstd/net/ip.rs:26:#[unstable(feature = "ip_addr", reason = "recent addition", issue = "27801")] +src/libstd/net/ip.rs:37:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/ip.rs:44:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/ip.rs:65: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/ip.rs:78: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/ip.rs:163: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/ip.rs:173: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/ip.rs:181:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/ip.rs:191:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/ip.rs:199:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/ip.rs:206:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/ip.rs:211:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/ip.rs:218:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/ip.rs:221:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/ip.rs:228:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/ip.rs:235:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/ip.rs:251:#[stable(feature = "ip_u32", since = "1.1.0")] +src/libstd/net/ip.rs:259:#[stable(feature = "ip_u32", since = "1.1.0")] +src/libstd/net/ip.rs:270: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/ip.rs:282: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/ip.rs:380: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/ip.rs:392:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/ip.rs:462:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/ip.rs:469:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/ip.rs:474:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/ip.rs:481:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/ip.rs:484:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/ip.rs:491:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/ip.rs:498:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/mod.rs:13:#![stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/mod.rs:35:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/mod.rs:39: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/mod.rs:43: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/mod.rs:48: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/mod.rs:85:#[unstable(feature = "lookup_host", reason = "unsure about the returned \ +src/libstd/net/mod.rs:91:#[unstable(feature = "lookup_host", reason = "unsure about the returned \ +src/libstd/net/mod.rs:119:#[unstable(feature = "lookup_host", reason = "unsure about the returned \ +src/libstd/net/mod.rs:132:#[unstable(feature = "lookup_addr", reason = "recent addition", +src/libstd/net/parser.rs:296:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/parser.rs:307:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/parser.rs:318:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/parser.rs:329:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/parser.rs:341:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/parser.rs:345:#[stable(feature = "addr_parse_error_error", since = "1.4.0")] +src/libstd/net/parser.rs:352:#[stable(feature = "addr_parse_error_error", since = "1.4.0")] +src/libstd/net/tcp.rs:41:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/tcp.rs:74:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/tcp.rs:81:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/tcp.rs:90: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/tcp.rs:96: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/tcp.rs:102: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/tcp.rs:112: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/tcp.rs:123: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/tcp.rs:139: #[stable(feature = "socket_timeout", since = "1.4.0")] +src/libstd/net/tcp.rs:155: #[stable(feature = "socket_timeout", since = "1.4.0")] +src/libstd/net/tcp.rs:167: #[stable(feature = "socket_timeout", since = "1.4.0")] +src/libstd/net/tcp.rs:179: #[stable(feature = "socket_timeout", since = "1.4.0")] +src/libstd/net/tcp.rs:185:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/tcp.rs:192:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/tcp.rs:197:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/tcp.rs:204:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/tcp.rs:240: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/tcp.rs:246: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/tcp.rs:256: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/tcp.rs:266: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/tcp.rs:276: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/tcp.rs:282:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/udp.rs:44:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/udp.rs:52: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/udp.rs:59: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/udp.rs:69: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/udp.rs:80: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/udp.rs:90: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/net/udp.rs:106: #[stable(feature = "socket_timeout", since = "1.4.0")] +src/libstd/net/udp.rs:122: #[stable(feature = "socket_timeout", since = "1.4.0")] +src/libstd/net/udp.rs:130: #[stable(feature = "socket_timeout", since = "1.4.0")] +src/libstd/net/udp.rs:138: #[stable(feature = "socket_timeout", since = "1.4.0")] +src/libstd/num/f32.rs:15:#![stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:123:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:126: #[unstable(feature = "float_from_str_radix", reason = "recently moved API", +src/libstd/num/f32.rs:145: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:166: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:186: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:211: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:229: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:256: #[unstable(feature = "float_extras", reason = "signature is undecided", +src/libstd/num/f32.rs:272: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:305: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:327: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:342: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:361: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:382: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:402: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:421: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:440: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:460: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:476: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:492: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:506: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:533: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:557: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:581: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:601: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:630: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:646: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:664: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:689: #[unstable(feature = "float_extras", reason = "desirability is unclear", +src/libstd/num/f32.rs:707: #[unstable(feature = "float_extras", reason = "desirability is unclear", +src/libstd/num/f32.rs:723: #[unstable(feature = "float_extras", +src/libstd/num/f32.rs:752: #[unstable(feature = "float_extras", +src/libstd/num/f32.rs:778: #[unstable(feature = "float_extras", +src/libstd/num/f32.rs:796: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:812: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:835: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:853: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:873: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:890: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:913: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:935: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:955: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:975: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:994: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:1026: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:1047: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:1064: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:1083: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:1104: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:1125: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:1146: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:1164: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:1185: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f32.rs:1206: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:15:#![stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:80:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:83: #[unstable(feature = "float_from_str_radix", reason = "recently moved API", +src/libstd/num/f64.rs:102: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:123: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:143: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:168: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:186: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:211: #[unstable(feature = "float_extras", reason = "signature is undecided", +src/libstd/num/f64.rs:225: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:240: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:256: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:271: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:288: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:309: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:329: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:349: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:353: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:374: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:378: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:397: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:411: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:425: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:437: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:456: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:478: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:494: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:512: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:533: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:547: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:563: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:580: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:595: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:609: #[unstable(feature = "float_extras", +src/libstd/num/f64.rs:636: #[unstable(feature = "float_extras", +src/libstd/num/f64.rs:660: #[unstable(feature = "float_extras", +src/libstd/num/f64.rs:678: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:694: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:715: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:731: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:749: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:766: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:783: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:799: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:819: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:839: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:856: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:888: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:909: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:926: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:945: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:966: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:987: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:1008: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:1024: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:1043: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/f64.rs:1064: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/num/mod.rs:16:#![stable(feature = "rust1", since = "1.0.0")] +src/libstd/os/android/mod.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/mod.rs:18: #![stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:23: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:25: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:28: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:30: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:32: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:34: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:36: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:38: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:42: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:44: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:46: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:48: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:50: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:52: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:54: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:56: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:58: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:60: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:62: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:64: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:66: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:68: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:70: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:72: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:74: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:76: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:78: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:80: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:92: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:94: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:97: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:99: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:101: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:103: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:105: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:107: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:111: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:113: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:115: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:117: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:119: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:121: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:123: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:125: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:127: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:129: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:131: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:133: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:135: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:137: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:139: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:141: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:143: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:145: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:147: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/android/raw.rs:149: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/bitrig/mod.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/bitrig/mod.rs:18: #![stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/bitrig/raw.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/bitrig/raw.rs:18:#[stable(feature = "raw_ext", since = "1.1.0")] pub type blkcnt_t = i64; +src/libstd/os/bitrig/raw.rs:19:#[stable(feature = "raw_ext", since = "1.1.0")] pub type blksize_t = u32; +src/libstd/os/bitrig/raw.rs:20:#[stable(feature = "raw_ext", since = "1.1.0")] pub type dev_t = i32; +src/libstd/os/bitrig/raw.rs:21:#[stable(feature = "raw_ext", since = "1.1.0")] pub type fflags_t = u32; +src/libstd/os/bitrig/raw.rs:22:#[stable(feature = "raw_ext", since = "1.1.0")] pub type ino_t = u64; +src/libstd/os/bitrig/raw.rs:23:#[stable(feature = "raw_ext", since = "1.1.0")] pub type mode_t = u32; +src/libstd/os/bitrig/raw.rs:24:#[stable(feature = "raw_ext", since = "1.1.0")] pub type nlink_t = u32; +src/libstd/os/bitrig/raw.rs:25:#[stable(feature = "raw_ext", since = "1.1.0")] pub type off_t = i64; +src/libstd/os/bitrig/raw.rs:26:#[stable(feature = "raw_ext", since = "1.1.0")] pub type time_t = i64; +src/libstd/os/bitrig/raw.rs:29:#[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/bitrig/raw.rs:31: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/bitrig/raw.rs:33: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/bitrig/raw.rs:35: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/bitrig/raw.rs:37: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/bitrig/raw.rs:39: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/bitrig/raw.rs:41: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/bitrig/raw.rs:43: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/bitrig/raw.rs:45: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/bitrig/raw.rs:47: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/bitrig/raw.rs:49: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/bitrig/raw.rs:51: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/bitrig/raw.rs:53: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/bitrig/raw.rs:55: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/bitrig/raw.rs:57: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/bitrig/raw.rs:59: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/bitrig/raw.rs:61: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/bitrig/raw.rs:63: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/bitrig/raw.rs:65: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/bitrig/raw.rs:67: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/bitrig/raw.rs:69: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/dragonfly/mod.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/dragonfly/mod.rs:18: #![stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/dragonfly/raw.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/dragonfly/raw.rs:18:#[stable(feature = "raw_ext", since = "1.1.0")] pub type blkcnt_t = i64; +src/libstd/os/dragonfly/raw.rs:19:#[stable(feature = "raw_ext", since = "1.1.0")] pub type blksize_t = u32; +src/libstd/os/dragonfly/raw.rs:20:#[stable(feature = "raw_ext", since = "1.1.0")] pub type dev_t = u32; +src/libstd/os/dragonfly/raw.rs:21:#[stable(feature = "raw_ext", since = "1.1.0")] pub type fflags_t = u32; +src/libstd/os/dragonfly/raw.rs:22:#[stable(feature = "raw_ext", since = "1.1.0")] pub type ino_t = u64; +src/libstd/os/dragonfly/raw.rs:23:#[stable(feature = "raw_ext", since = "1.1.0")] pub type mode_t = u16; +src/libstd/os/dragonfly/raw.rs:24:#[stable(feature = "raw_ext", since = "1.1.0")] pub type nlink_t = u16; +src/libstd/os/dragonfly/raw.rs:25:#[stable(feature = "raw_ext", since = "1.1.0")] pub type off_t = i64; +src/libstd/os/dragonfly/raw.rs:26:#[stable(feature = "raw_ext", since = "1.1.0")] pub type time_t = i64; +src/libstd/os/dragonfly/raw.rs:29:#[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/dragonfly/raw.rs:31: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/dragonfly/raw.rs:33: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/dragonfly/raw.rs:35: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/dragonfly/raw.rs:37: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/dragonfly/raw.rs:39: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/dragonfly/raw.rs:41: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/dragonfly/raw.rs:43: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/dragonfly/raw.rs:45: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/dragonfly/raw.rs:47: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/dragonfly/raw.rs:49: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/dragonfly/raw.rs:51: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/dragonfly/raw.rs:53: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/dragonfly/raw.rs:55: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/dragonfly/raw.rs:57: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/dragonfly/raw.rs:59: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/dragonfly/raw.rs:61: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/dragonfly/raw.rs:63: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/dragonfly/raw.rs:65: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/dragonfly/raw.rs:67: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/dragonfly/raw.rs:69: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/dragonfly/raw.rs:71: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/dragonfly/raw.rs:73: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/mod.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/mod.rs:18: #![stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:15:#[stable(feature = "raw_ext", since = "1.1.0")] pub type off_t = i64; +src/libstd/os/freebsd/raw.rs:16:#[stable(feature = "raw_ext", since = "1.1.0")] pub type dev_t = u32; +src/libstd/os/freebsd/raw.rs:17:#[stable(feature = "raw_ext", since = "1.1.0")] pub type ino_t = u32; +src/libstd/os/freebsd/raw.rs:18:#[stable(feature = "raw_ext", since = "1.1.0")] pub type mode_t = u16; +src/libstd/os/freebsd/raw.rs:19:#[stable(feature = "raw_ext", since = "1.1.0")] pub type nlink_t = u16; +src/libstd/os/freebsd/raw.rs:20:#[stable(feature = "raw_ext", since = "1.1.0")] pub type blksize_t = u32; +src/libstd/os/freebsd/raw.rs:21:#[stable(feature = "raw_ext", since = "1.1.0")] pub type blkcnt_t = i64; +src/libstd/os/freebsd/raw.rs:22:#[stable(feature = "raw_ext", since = "1.1.0")] pub type fflags_t = u32; +src/libstd/os/freebsd/raw.rs:33: #[stable(feature = "raw_ext", since = "1.1.0")] pub type time_t = i32; +src/libstd/os/freebsd/raw.rs:36: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:38: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:40: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:42: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:44: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:46: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:48: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:50: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:52: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:54: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:56: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:58: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:60: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:62: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:64: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:66: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:68: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:70: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:72: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:74: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:76: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:78: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:80: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:91: #[stable(feature = "raw_ext", since = "1.1.0")] pub type time_t = i64; +src/libstd/os/freebsd/raw.rs:94: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:96: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:98: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:100: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:102: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:104: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:106: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:108: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:110: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:112: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:114: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:116: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:118: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:120: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:122: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:124: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:126: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:128: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:130: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:132: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:134: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/freebsd/raw.rs:136: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/ios/mod.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/ios/mod.rs:18: #![stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/ios/raw.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/ios/raw.rs:18:#[stable(feature = "raw_ext", since = "1.1.0")] pub type blkcnt_t = i64; +src/libstd/os/ios/raw.rs:19:#[stable(feature = "raw_ext", since = "1.1.0")] pub type blksize_t = i32; +src/libstd/os/ios/raw.rs:20:#[stable(feature = "raw_ext", since = "1.1.0")] pub type dev_t = i32; +src/libstd/os/ios/raw.rs:21:#[stable(feature = "raw_ext", since = "1.1.0")] pub type ino_t = u64; +src/libstd/os/ios/raw.rs:22:#[stable(feature = "raw_ext", since = "1.1.0")] pub type mode_t = u16; +src/libstd/os/ios/raw.rs:23:#[stable(feature = "raw_ext", since = "1.1.0")] pub type nlink_t = u16; +src/libstd/os/ios/raw.rs:24:#[stable(feature = "raw_ext", since = "1.1.0")] pub type off_t = i64; +src/libstd/os/ios/raw.rs:25:#[stable(feature = "raw_ext", since = "1.1.0")] pub type time_t = c_long; +src/libstd/os/ios/raw.rs:28:#[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/ios/raw.rs:30: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/ios/raw.rs:32: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/ios/raw.rs:34: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/ios/raw.rs:36: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/ios/raw.rs:38: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/ios/raw.rs:40: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/ios/raw.rs:42: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/ios/raw.rs:44: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/ios/raw.rs:46: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/ios/raw.rs:48: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/ios/raw.rs:50: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/ios/raw.rs:52: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/ios/raw.rs:54: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/ios/raw.rs:56: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/ios/raw.rs:58: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/ios/raw.rs:60: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/ios/raw.rs:62: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/ios/raw.rs:64: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/ios/raw.rs:66: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/ios/raw.rs:68: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/ios/raw.rs:70: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/ios/raw.rs:72: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/mod.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/mod.rs:18: #![stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:15:#[stable(feature = "raw_ext", since = "1.1.0")] pub type dev_t = u64; +src/libstd/os/linux/raw.rs:16:#[stable(feature = "raw_ext", since = "1.1.0")] pub type mode_t = u32; +src/libstd/os/linux/raw.rs:30: #[stable(feature = "raw_ext", since = "1.1.0")] pub type blkcnt_t = i32; +src/libstd/os/linux/raw.rs:31: #[stable(feature = "raw_ext", since = "1.1.0")] pub type blksize_t = i32; +src/libstd/os/linux/raw.rs:32: #[stable(feature = "raw_ext", since = "1.1.0")] pub type ino_t = u32; +src/libstd/os/linux/raw.rs:33: #[stable(feature = "raw_ext", since = "1.1.0")] pub type nlink_t = u32; +src/libstd/os/linux/raw.rs:34: #[stable(feature = "raw_ext", since = "1.1.0")] pub type off_t = i32; +src/libstd/os/linux/raw.rs:35: #[stable(feature = "raw_ext", since = "1.1.0")] pub type time_t = i32; +src/libstd/os/linux/raw.rs:38: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:40: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:42: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:44: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:46: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:48: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:50: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:52: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:54: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:56: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:58: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:60: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:62: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:64: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:66: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:68: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:70: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:72: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:74: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:76: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:78: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:90: #[stable(feature = "raw_ext", since = "1.1.0")] pub type blkcnt_t = i32; +src/libstd/os/linux/raw.rs:91: #[stable(feature = "raw_ext", since = "1.1.0")] pub type blksize_t = i32; +src/libstd/os/linux/raw.rs:92: #[stable(feature = "raw_ext", since = "1.1.0")] pub type ino_t = u32; +src/libstd/os/linux/raw.rs:93: #[stable(feature = "raw_ext", since = "1.1.0")] pub type nlink_t = u32; +src/libstd/os/linux/raw.rs:94: #[stable(feature = "raw_ext", since = "1.1.0")] pub type off_t = i32; +src/libstd/os/linux/raw.rs:95: #[stable(feature = "raw_ext", since = "1.1.0")] pub type time_t = i32; +src/libstd/os/linux/raw.rs:98: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:100: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:102: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:104: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:106: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:108: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:110: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:112: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:114: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:116: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:118: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:120: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:122: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:124: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:126: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:128: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:130: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:132: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:134: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:136: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:138: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:149: #[stable(feature = "raw_ext", since = "1.1.0")] pub type blkcnt_t = i64; +src/libstd/os/linux/raw.rs:150: #[stable(feature = "raw_ext", since = "1.1.0")] pub type blksize_t = i32; +src/libstd/os/linux/raw.rs:151: #[stable(feature = "raw_ext", since = "1.1.0")] pub type ino_t = u64; +src/libstd/os/linux/raw.rs:152: #[stable(feature = "raw_ext", since = "1.1.0")] pub type nlink_t = u32; +src/libstd/os/linux/raw.rs:153: #[stable(feature = "raw_ext", since = "1.1.0")] pub type off_t = i64; +src/libstd/os/linux/raw.rs:154: #[stable(feature = "raw_ext", since = "1.1.0")] pub type time_t = i64; +src/libstd/os/linux/raw.rs:157: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:159: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:161: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:163: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:165: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:167: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:169: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:171: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:173: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:175: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:177: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:179: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:181: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:183: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:185: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:187: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:189: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:191: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:193: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:195: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:206: #[stable(feature = "raw_ext", since = "1.1.0")] pub type blkcnt_t = i64; +src/libstd/os/linux/raw.rs:207: #[stable(feature = "raw_ext", since = "1.1.0")] pub type blksize_t = i64; +src/libstd/os/linux/raw.rs:208: #[stable(feature = "raw_ext", since = "1.1.0")] pub type ino_t = u64; +src/libstd/os/linux/raw.rs:209: #[stable(feature = "raw_ext", since = "1.1.0")] pub type nlink_t = u64; +src/libstd/os/linux/raw.rs:210: #[stable(feature = "raw_ext", since = "1.1.0")] pub type off_t = i64; +src/libstd/os/linux/raw.rs:211: #[stable(feature = "raw_ext", since = "1.1.0")] pub type time_t = i64; +src/libstd/os/linux/raw.rs:214: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:216: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:218: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:220: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:222: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:224: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:226: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:228: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:230: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:232: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:234: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:236: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:238: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:240: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:242: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:244: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:246: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:248: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/linux/raw.rs:250: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/macos/mod.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/macos/mod.rs:18: #![stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/macos/raw.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/macos/raw.rs:18:#[stable(feature = "raw_ext", since = "1.1.0")] pub type blkcnt_t = i64; +src/libstd/os/macos/raw.rs:19:#[stable(feature = "raw_ext", since = "1.1.0")] pub type blksize_t = i32; +src/libstd/os/macos/raw.rs:20:#[stable(feature = "raw_ext", since = "1.1.0")] pub type dev_t = i32; +src/libstd/os/macos/raw.rs:21:#[stable(feature = "raw_ext", since = "1.1.0")] pub type ino_t = u64; +src/libstd/os/macos/raw.rs:22:#[stable(feature = "raw_ext", since = "1.1.0")] pub type mode_t = u16; +src/libstd/os/macos/raw.rs:23:#[stable(feature = "raw_ext", since = "1.1.0")] pub type nlink_t = u16; +src/libstd/os/macos/raw.rs:24:#[stable(feature = "raw_ext", since = "1.1.0")] pub type off_t = i64; +src/libstd/os/macos/raw.rs:25:#[stable(feature = "raw_ext", since = "1.1.0")] pub type time_t = c_long; +src/libstd/os/macos/raw.rs:28:#[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/macos/raw.rs:30: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/macos/raw.rs:32: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/macos/raw.rs:34: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/macos/raw.rs:36: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/macos/raw.rs:38: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/macos/raw.rs:40: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/macos/raw.rs:42: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/macos/raw.rs:44: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/macos/raw.rs:46: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/macos/raw.rs:48: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/macos/raw.rs:50: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/macos/raw.rs:52: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/macos/raw.rs:54: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/macos/raw.rs:56: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/macos/raw.rs:58: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/macos/raw.rs:60: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/macos/raw.rs:62: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/macos/raw.rs:64: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/macos/raw.rs:66: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/macos/raw.rs:68: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/macos/raw.rs:70: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/macos/raw.rs:72: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/mod.rs:13:#![stable(feature = "os", since = "1.0.0")] +src/libstd/os/nacl/mod.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/mod.rs:18: #![stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:15:#[stable(feature = "raw_ext", since = "1.1.0")] pub type dev_t = u64; +src/libstd/os/nacl/raw.rs:16:#[stable(feature = "raw_ext", since = "1.1.0")] pub type mode_t = u32; +src/libstd/os/nacl/raw.rs:29: #[stable(feature = "raw_ext", since = "1.1.0")] pub type blkcnt_t = i32; +src/libstd/os/nacl/raw.rs:30: #[stable(feature = "raw_ext", since = "1.1.0")] pub type blksize_t = i32; +src/libstd/os/nacl/raw.rs:31: #[stable(feature = "raw_ext", since = "1.1.0")] pub type ino_t = u32; +src/libstd/os/nacl/raw.rs:32: #[stable(feature = "raw_ext", since = "1.1.0")] pub type nlink_t = u32; +src/libstd/os/nacl/raw.rs:33: #[stable(feature = "raw_ext", since = "1.1.0")] pub type off_t = i32; +src/libstd/os/nacl/raw.rs:34: #[stable(feature = "raw_ext", since = "1.1.0")] pub type time_t = i32; +src/libstd/os/nacl/raw.rs:37: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:39: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:41: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:43: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:45: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:47: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:49: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:51: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:53: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:55: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:57: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:59: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:61: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:63: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:65: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:67: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:69: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:71: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:73: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:75: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:77: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:89: #[stable(feature = "raw_ext", since = "1.1.0")] pub type blkcnt_t = i32; +src/libstd/os/nacl/raw.rs:90: #[stable(feature = "raw_ext", since = "1.1.0")] pub type blksize_t = i32; +src/libstd/os/nacl/raw.rs:91: #[stable(feature = "raw_ext", since = "1.1.0")] pub type ino_t = u32; +src/libstd/os/nacl/raw.rs:92: #[stable(feature = "raw_ext", since = "1.1.0")] pub type nlink_t = u32; +src/libstd/os/nacl/raw.rs:93: #[stable(feature = "raw_ext", since = "1.1.0")] pub type off_t = i32; +src/libstd/os/nacl/raw.rs:94: #[stable(feature = "raw_ext", since = "1.1.0")] pub type time_t = i32; +src/libstd/os/nacl/raw.rs:97: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:99: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:101: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:103: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:105: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:107: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:109: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:111: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:113: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:115: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:117: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:119: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:121: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:123: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:125: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:127: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:129: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:131: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:133: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:135: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:137: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:148: #[stable(feature = "raw_ext", since = "1.1.0")] pub type blkcnt_t = i64; +src/libstd/os/nacl/raw.rs:149: #[stable(feature = "raw_ext", since = "1.1.0")] pub type blksize_t = i32; +src/libstd/os/nacl/raw.rs:150: #[stable(feature = "raw_ext", since = "1.1.0")] pub type ino_t = u64; +src/libstd/os/nacl/raw.rs:151: #[stable(feature = "raw_ext", since = "1.1.0")] pub type nlink_t = u32; +src/libstd/os/nacl/raw.rs:152: #[stable(feature = "raw_ext", since = "1.1.0")] pub type off_t = i64; +src/libstd/os/nacl/raw.rs:153: #[stable(feature = "raw_ext", since = "1.1.0")] pub type time_t = i64; +src/libstd/os/nacl/raw.rs:156: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:158: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:160: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:162: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:164: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:166: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:168: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:170: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:172: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:174: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:176: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:178: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:180: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:182: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:184: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:186: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:188: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:190: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:192: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:194: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:205: #[stable(feature = "raw_ext", since = "1.1.0")] pub type blkcnt_t = i64; +src/libstd/os/nacl/raw.rs:206: #[stable(feature = "raw_ext", since = "1.1.0")] pub type blksize_t = i64; +src/libstd/os/nacl/raw.rs:207: #[stable(feature = "raw_ext", since = "1.1.0")] pub type ino_t = u64; +src/libstd/os/nacl/raw.rs:208: #[stable(feature = "raw_ext", since = "1.1.0")] pub type nlink_t = u64; +src/libstd/os/nacl/raw.rs:209: #[stable(feature = "raw_ext", since = "1.1.0")] pub type off_t = i64; +src/libstd/os/nacl/raw.rs:210: #[stable(feature = "raw_ext", since = "1.1.0")] pub type time_t = i64; +src/libstd/os/nacl/raw.rs:213: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:215: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:217: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:219: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:221: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:223: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:225: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:227: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:229: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:231: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:233: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:235: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:237: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:239: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:241: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:243: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:245: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:247: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/nacl/raw.rs:249: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/netbsd/mod.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/netbsd/mod.rs:18: #![stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/netbsd/raw.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/netbsd/raw.rs:18:#[stable(feature = "raw_ext", since = "1.1.0")] pub type blkcnt_t = i64; +src/libstd/os/netbsd/raw.rs:19:#[stable(feature = "raw_ext", since = "1.1.0")] pub type blksize_t = u32; +src/libstd/os/netbsd/raw.rs:20:#[stable(feature = "raw_ext", since = "1.1.0")] pub type dev_t = u64; +src/libstd/os/netbsd/raw.rs:21:#[stable(feature = "raw_ext", since = "1.1.0")] pub type fflags_t = u32; +src/libstd/os/netbsd/raw.rs:22:#[stable(feature = "raw_ext", since = "1.1.0")] pub type ino_t = u64; +src/libstd/os/netbsd/raw.rs:23:#[stable(feature = "raw_ext", since = "1.1.0")] pub type mode_t = u32; +src/libstd/os/netbsd/raw.rs:24:#[stable(feature = "raw_ext", since = "1.1.0")] pub type nlink_t = u32; +src/libstd/os/netbsd/raw.rs:25:#[stable(feature = "raw_ext", since = "1.1.0")] pub type off_t = i64; +src/libstd/os/netbsd/raw.rs:26:#[stable(feature = "raw_ext", since = "1.1.0")] pub type time_t = i64; +src/libstd/os/netbsd/raw.rs:29:#[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/netbsd/raw.rs:31: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/netbsd/raw.rs:33: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/netbsd/raw.rs:35: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/netbsd/raw.rs:37: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/netbsd/raw.rs:39: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/netbsd/raw.rs:41: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/netbsd/raw.rs:43: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/netbsd/raw.rs:45: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/netbsd/raw.rs:47: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/netbsd/raw.rs:49: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/netbsd/raw.rs:51: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/netbsd/raw.rs:53: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/netbsd/raw.rs:55: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/netbsd/raw.rs:57: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/netbsd/raw.rs:59: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/netbsd/raw.rs:61: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/netbsd/raw.rs:63: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/netbsd/raw.rs:65: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/netbsd/raw.rs:67: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/netbsd/raw.rs:69: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/openbsd/mod.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/openbsd/mod.rs:18: #![stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/openbsd/raw.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/openbsd/raw.rs:18:#[stable(feature = "raw_ext", since = "1.1.0")] pub type blkcnt_t = i64; +src/libstd/os/openbsd/raw.rs:19:#[stable(feature = "raw_ext", since = "1.1.0")] pub type blksize_t = u32; +src/libstd/os/openbsd/raw.rs:20:#[stable(feature = "raw_ext", since = "1.1.0")] pub type dev_t = i32; +src/libstd/os/openbsd/raw.rs:21:#[stable(feature = "raw_ext", since = "1.1.0")] pub type fflags_t = u32; +src/libstd/os/openbsd/raw.rs:22:#[stable(feature = "raw_ext", since = "1.1.0")] pub type ino_t = u64; +src/libstd/os/openbsd/raw.rs:23:#[stable(feature = "raw_ext", since = "1.1.0")] pub type mode_t = u32; +src/libstd/os/openbsd/raw.rs:24:#[stable(feature = "raw_ext", since = "1.1.0")] pub type nlink_t = u32; +src/libstd/os/openbsd/raw.rs:25:#[stable(feature = "raw_ext", since = "1.1.0")] pub type off_t = i64; +src/libstd/os/openbsd/raw.rs:26:#[stable(feature = "raw_ext", since = "1.1.0")] pub type time_t = i64; +src/libstd/os/openbsd/raw.rs:29:#[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/openbsd/raw.rs:31: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/openbsd/raw.rs:33: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/openbsd/raw.rs:35: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/openbsd/raw.rs:37: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/openbsd/raw.rs:39: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/openbsd/raw.rs:41: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/openbsd/raw.rs:43: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/openbsd/raw.rs:45: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/openbsd/raw.rs:47: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/openbsd/raw.rs:49: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/openbsd/raw.rs:51: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/openbsd/raw.rs:53: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/openbsd/raw.rs:55: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/openbsd/raw.rs:57: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/openbsd/raw.rs:59: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/openbsd/raw.rs:61: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/openbsd/raw.rs:63: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/openbsd/raw.rs:65: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/openbsd/raw.rs:67: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/openbsd/raw.rs:69: #[stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/os/raw.rs:13:#![stable(feature = "raw_os", since = "1.1.0")] +src/libstd/os/raw.rs:16:#[stable(feature = "raw_os", since = "1.1.0")] pub type c_char = u8; +src/libstd/os/raw.rs:18:#[stable(feature = "raw_os", since = "1.1.0")] pub type c_char = i8; +src/libstd/os/raw.rs:19:#[stable(feature = "raw_os", since = "1.1.0")] pub type c_schar = i8; +src/libstd/os/raw.rs:20:#[stable(feature = "raw_os", since = "1.1.0")] pub type c_uchar = u8; +src/libstd/os/raw.rs:21:#[stable(feature = "raw_os", since = "1.1.0")] pub type c_short = i16; +src/libstd/os/raw.rs:22:#[stable(feature = "raw_os", since = "1.1.0")] pub type c_ushort = u16; +src/libstd/os/raw.rs:23:#[stable(feature = "raw_os", since = "1.1.0")] pub type c_int = i32; +src/libstd/os/raw.rs:24:#[stable(feature = "raw_os", since = "1.1.0")] pub type c_uint = u32; +src/libstd/os/raw.rs:26:#[stable(feature = "raw_os", since = "1.1.0")] pub type c_long = i32; +src/libstd/os/raw.rs:28:#[stable(feature = "raw_os", since = "1.1.0")] pub type c_ulong = u32; +src/libstd/os/raw.rs:30:#[stable(feature = "raw_os", since = "1.1.0")] pub type c_long = i64; +src/libstd/os/raw.rs:32:#[stable(feature = "raw_os", since = "1.1.0")] pub type c_ulong = u64; +src/libstd/os/raw.rs:33:#[stable(feature = "raw_os", since = "1.1.0")] pub type c_longlong = i64; +src/libstd/os/raw.rs:34:#[stable(feature = "raw_os", since = "1.1.0")] pub type c_ulonglong = u64; +src/libstd/os/raw.rs:35:#[stable(feature = "raw_os", since = "1.1.0")] pub type c_float = f32; +src/libstd/os/raw.rs:36:#[stable(feature = "raw_os", since = "1.1.0")] pub type c_double = f64; +src/libstd/os/raw.rs:50:#[stable(feature = "raw_os", since = "1.1.0")] +src/libstd/os/raw.rs:52: #[unstable(feature = "c_void_variant", reason = "should not have to exist", +src/libstd/os/raw.rs:55: #[unstable(feature = "c_void_variant", reason = "should not have to exist", +src/libstd/path.rs:99:#![stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:263:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:266: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:270: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:274: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:278: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:282: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:286: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:314: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:352:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:358:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:446:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:458: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:464: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:470:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:477:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:484:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:496:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:501: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:505: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:509: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:513: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:517: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:523: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:535:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:559:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:580:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:643: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:732: #[unstable(feature = "path_components_peek", issue = "27727")] +src/libstd/path.rs:738:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:745:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:754: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:760:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:767:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:774:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:783:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:790:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:841:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:886:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:893:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:896:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:903:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:934:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:945: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:951: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:965: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1006: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1035: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1054: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1077: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1083:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1090:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1097:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1104:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1113:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1122:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1129:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1138:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1145:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1152:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1159:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1165:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1172:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1175:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1182:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1189:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1196:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1226:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1264: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1279: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1296: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1313: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1328: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1349: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1364: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1374: #[unstable(feature = "path_prefix", +src/libstd/path.rs:1397: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1419: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1447: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1459: #[unstable(feature = "path_relative_from", reason = "see #23284", +src/libstd/path.rs:1485: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1507: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1534: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1557: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1573: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1596: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1619: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1645: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1671: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1688: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1694:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1701:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1709:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1714:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1721:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1728:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1735:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1738:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1745:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1752:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1757:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1762:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1767:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1772:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/path.rs:1777:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/prelude/mod.rs:112://! An unstable extension to slices that shouldn't have to exist. +src/libstd/prelude/mod.rs:127:#![stable(feature = "rust1", since = "1.0.0")] +src/libstd/prelude/v1.rs:13:#![stable(feature = "rust1", since = "1.0.0")] +src/libstd/prelude/v1.rs:16:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/prelude/v1.rs:18:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/prelude/v1.rs:22:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/prelude/v1.rs:26:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/prelude/v1.rs:28:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/prelude/v1.rs:30:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/prelude/v1.rs:32:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/prelude/v1.rs:34:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/prelude/v1.rs:36:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/prelude/v1.rs:38:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/prelude/v1.rs:40:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/prelude/v1.rs:42:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/prelude/v1.rs:44:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/prelude/v1.rs:46:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/prelude/v1.rs:48:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/prelude/v1.rs:50:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/process.rs:13:#![stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:50:#[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:58: #[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:62: #[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:66: #[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:79:#[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:84:#[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:104:#[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:109:#[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:125:#[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:130:#[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:161:#[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:182: #[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:193: #[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:200: #[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:210: #[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:219: #[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:226: #[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:233: #[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:240: #[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:247: #[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:254: #[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:290: #[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:313: #[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:334: #[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:340:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/process.rs:391:#[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:394: #[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:397: #[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:400: #[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:405:#[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:418: #[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:422: #[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:427: #[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:439:#[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:445: #[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:455: #[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:465:#[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:475: #[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:508: #[stable(feature = "process_id", since = "1.3.0")] +src/libstd/process.rs:521: #[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:542: #[stable(feature = "process", since = "1.0.0")] +src/libstd/process.rs:583:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/rand/mod.rs:58:#![unstable(feature = "rand", issue = "0")] +src/libstd/rt.rs:15://! backtrace support. The APIs in this module are highly unstable, +src/libstd/rt.rs:19:#![unstable(feature = "rt", +src/libstd/sync/barrier.rs:32:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/barrier.rs:56: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/barrier.rs:77: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/barrier.rs:104: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/condvar.rs:24:#[unstable(feature = "wait_timeout", reason = "newly added", issue = "27772")] +src/libstd/sync/condvar.rs:29: #[unstable(feature = "wait_timeout", reason = "newly added", issue = "27772")] +src/libstd/sync/condvar.rs:75:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/condvar.rs:92:#[unstable(feature = "static_condvar", +src/libstd/sync/condvar.rs:101:#[unstable(feature = "static_condvar", +src/libstd/sync/condvar.rs:109: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/condvar.rs:145: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/condvar.rs:169: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/condvar.rs:192: #[unstable(feature = "wait_timeout", reason = "waiting for Duration", +src/libstd/sync/condvar.rs:209: #[unstable(feature = "wait_timeout_with", +src/libstd/sync/condvar.rs:231: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/condvar.rs:241: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/condvar.rs:245:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/condvar.rs:254: #[unstable(feature = "static_condvar", +src/libstd/sync/condvar.rs:268: #[unstable(feature = "static_condvar", +src/libstd/sync/condvar.rs:290: #[unstable(feature = "static_condvar", +src/libstd/sync/condvar.rs:308: #[unstable(feature = "static_condvar", +src/libstd/sync/condvar.rs:335: #[unstable(feature = "static_condvar", +src/libstd/sync/condvar.rs:383: #[unstable(feature = "static_condvar", +src/libstd/sync/condvar.rs:391: #[unstable(feature = "static_condvar", +src/libstd/sync/condvar.rs:402: #[unstable(feature = "static_condvar", +src/libstd/sync/mod.rs:18:#![stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mod.rs:116:#![stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mod.rs:291:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mod.rs:303:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mod.rs:311:#[stable(feature = "receiver_into_iter", since = "1.1.0")] +src/libstd/sync/mpsc/mod.rs:318:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mod.rs:329:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mod.rs:343:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mod.rs:345:pub struct SendError(#[stable(feature = "rust1", since = "1.0.0")] pub T); +src/libstd/sync/mpsc/mod.rs:352:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mod.rs:358:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mod.rs:362: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mod.rs:367: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mod.rs:373:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mod.rs:382: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mod.rs:387: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mod.rs:445:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mod.rs:485:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mod.rs:529: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mod.rs:576:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mod.rs:621:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mod.rs:656: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mod.rs:670: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mod.rs:676:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mod.rs:684:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mod.rs:708: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mod.rs:811: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mod.rs:850: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mod.rs:942:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mod.rs:949:#[stable(feature = "receiver_into_iter", since = "1.1.0")] +src/libstd/sync/mpsc/mod.rs:962:#[stable(feature = "receiver_into_iter", since = "1.1.0")] +src/libstd/sync/mpsc/mod.rs:972:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mod.rs:984:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mod.rs:991:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mod.rs:998:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mod.rs:1009:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mod.rs:1019:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mod.rs:1033:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mod.rs:1052:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mod.rs:1059:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mod.rs:1071:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mod.rs:1085:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/mpsc_queue.rs:136:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mpsc/select.rs:51:#![unstable(feature = "mpsc_select", +src/libstd/sync/mutex.rs:113:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mutex.rs:153:#[unstable(feature = "static_mutex", +src/libstd/sync/mutex.rs:167:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mutex.rs:180:#[unstable(feature = "static_mutex", +src/libstd/sync/mutex.rs:187: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mutex.rs:208: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mutex.rs:227: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mutex.rs:242: #[stable(feature = "sync_poison", since = "1.2.0")] +src/libstd/sync/mutex.rs:248:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mutex.rs:258:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mutex.rs:275:#[unstable(feature = "static_mutex", +src/libstd/sync/mutex.rs:333:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mutex.rs:342:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/mutex.rs:349:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/once.rs:36:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/once.rs:44:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/once.rs:49: #[stable(feature = "once_new", since = "1.2.0")] +src/libstd/sync/once.rs:71: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/rwlock.rs:66:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/rwlock.rs:100:#[unstable(feature = "static_rwlock", +src/libstd/sync/rwlock.rs:109:#[unstable(feature = "static_rwlock", +src/libstd/sync/rwlock.rs:117:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/rwlock.rs:128:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/rwlock.rs:147: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/rwlock.rs:172: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/rwlock.rs:196: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/rwlock.rs:220: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/rwlock.rs:244: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/rwlock.rs:259: #[stable(feature = "sync_poison", since = "1.2.0")] +src/libstd/sync/rwlock.rs:265:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/rwlock.rs:272:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/rwlock.rs:289:#[unstable(feature = "static_rwlock", +src/libstd/sync/rwlock.rs:383:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/rwlock.rs:390:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/rwlock.rs:397:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/rwlock.rs:404:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/rwlock.rs:411:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sync/semaphore.rs:11:#![unstable(feature = "semaphore", +src/libstd/sync/semaphore.rs:105:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/common/poison.rs:62:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/common/poison.rs:69:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/common/poison.rs:73: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/common/poison.rs:77: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/common/poison.rs:88:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/common/poison.rs:96:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/common/poison.rs:99:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/common/poison.rs:106:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/common/poison.rs:121: #[stable(feature = "sync_poison", since = "1.2.0")] +src/libstd/sys/common/poison.rs:128: #[stable(feature = "sync_poison", since = "1.2.0")] +src/libstd/sys/common/poison.rs:133: #[stable(feature = "sync_poison", since = "1.2.0")] +src/libstd/sys/common/poison.rs:138: #[stable(feature = "sync_poison", since = "1.2.0")] +src/libstd/sys/common/poison.rs:148:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/common/poison.rs:158:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/common/remutex.rs:11:#![unstable(feature = "reentrant_mutex", reason = "new API", +src/libstd/sys/common/thread_local.rs:58:#![unstable(feature = "thread_local_internals", issue = "0")] +src/libstd/sys/unix/condvar.rs:54: // stable time. pthread_cond_timedwait uses system time, but we want to +src/libstd/sys/unix/condvar.rs:55: // report timeout based on stable time. +src/libstd/sys/unix/condvar.rs:57: let stable_now = time::SteadyTime::now(); +src/libstd/sys/unix/condvar.rs:85: &time::SteadyTime::now() - &stable_now < dur +src/libstd/sys/unix/ext/ffi.rs:13:#![stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/unix/ext/ffi.rs:22:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/unix/ext/ffi.rs:25: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/unix/ext/ffi.rs:29: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/unix/ext/ffi.rs:33:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/unix/ext/ffi.rs:44:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/unix/ext/ffi.rs:46: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/unix/ext/ffi.rs:50: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/unix/ext/ffi.rs:54:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/unix/ext/fs.rs:13:#![stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/unix/ext/fs.rs:25:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] +src/libstd/sys/unix/ext/fs.rs:27:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] +src/libstd/sys/unix/ext/fs.rs:29:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] +src/libstd/sys/unix/ext/fs.rs:31:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] +src/libstd/sys/unix/ext/fs.rs:33:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] +src/libstd/sys/unix/ext/fs.rs:35:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] +src/libstd/sys/unix/ext/fs.rs:37:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] +src/libstd/sys/unix/ext/fs.rs:39:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] +src/libstd/sys/unix/ext/fs.rs:41:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] +src/libstd/sys/unix/ext/fs.rs:43:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] +src/libstd/sys/unix/ext/fs.rs:45:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] +src/libstd/sys/unix/ext/fs.rs:47:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] +src/libstd/sys/unix/ext/fs.rs:49:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] +src/libstd/sys/unix/ext/fs.rs:51:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] +src/libstd/sys/unix/ext/fs.rs:53:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] +src/libstd/sys/unix/ext/fs.rs:55:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] +src/libstd/sys/unix/ext/fs.rs:57:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] +src/libstd/sys/unix/ext/fs.rs:59:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] +src/libstd/sys/unix/ext/fs.rs:61:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] +src/libstd/sys/unix/ext/fs.rs:65:#[stable(feature = "fs_ext", since = "1.1.0")] +src/libstd/sys/unix/ext/fs.rs:69: #[stable(feature = "fs_ext", since = "1.1.0")] +src/libstd/sys/unix/ext/fs.rs:73: #[stable(feature = "fs_ext", since = "1.1.0")] +src/libstd/sys/unix/ext/fs.rs:78: #[stable(feature = "fs_ext", since = "1.1.0")] +src/libstd/sys/unix/ext/fs.rs:82:#[stable(feature = "fs_ext", since = "1.1.0")] +src/libstd/sys/unix/ext/fs.rs:96:#[stable(feature = "fs_ext", since = "1.1.0")] +src/libstd/sys/unix/ext/fs.rs:102: #[stable(feature = "fs_ext", since = "1.1.0")] +src/libstd/sys/unix/ext/fs.rs:106:#[stable(feature = "fs_ext", since = "1.1.0")] +src/libstd/sys/unix/ext/fs.rs:120:#[stable(feature = "metadata_ext", since = "1.1.0")] +src/libstd/sys/unix/ext/fs.rs:122: #[stable(feature = "metadata_ext", since = "1.1.0")] +src/libstd/sys/unix/ext/fs.rs:124: #[stable(feature = "metadata_ext", since = "1.1.0")] +src/libstd/sys/unix/ext/fs.rs:126: #[stable(feature = "metadata_ext", since = "1.1.0")] +src/libstd/sys/unix/ext/fs.rs:128: #[stable(feature = "metadata_ext", since = "1.1.0")] +src/libstd/sys/unix/ext/fs.rs:130: #[stable(feature = "metadata_ext", since = "1.1.0")] +src/libstd/sys/unix/ext/fs.rs:132: #[stable(feature = "metadata_ext", since = "1.1.0")] +src/libstd/sys/unix/ext/fs.rs:134: #[stable(feature = "metadata_ext", since = "1.1.0")] +src/libstd/sys/unix/ext/fs.rs:136: #[stable(feature = "metadata_ext", since = "1.1.0")] +src/libstd/sys/unix/ext/fs.rs:138: #[stable(feature = "metadata_ext", since = "1.1.0")] +src/libstd/sys/unix/ext/fs.rs:140: #[stable(feature = "metadata_ext", since = "1.1.0")] +src/libstd/sys/unix/ext/fs.rs:142: #[stable(feature = "metadata_ext", since = "1.1.0")] +src/libstd/sys/unix/ext/fs.rs:144: #[stable(feature = "metadata_ext", since = "1.1.0")] +src/libstd/sys/unix/ext/fs.rs:146: #[stable(feature = "metadata_ext", since = "1.1.0")] +src/libstd/sys/unix/ext/fs.rs:148: #[stable(feature = "metadata_ext", since = "1.1.0")] +src/libstd/sys/unix/ext/fs.rs:150: #[stable(feature = "metadata_ext", since = "1.1.0")] +src/libstd/sys/unix/ext/fs.rs:152: #[stable(feature = "metadata_ext", since = "1.1.0")] +src/libstd/sys/unix/ext/fs.rs:181:#[unstable(feature = "file_type_ext", reason = "recently added API", +src/libstd/sys/unix/ext/fs.rs:194:#[unstable(feature = "file_type_ext", reason = "recently added API", +src/libstd/sys/unix/ext/fs.rs:204:#[stable(feature = "dir_entry_ext", since = "1.1.0")] +src/libstd/sys/unix/ext/fs.rs:208: #[stable(feature = "dir_entry_ext", since = "1.1.0")] +src/libstd/sys/unix/ext/fs.rs:239:#[stable(feature = "symlink", since = "1.1.0")] +src/libstd/sys/unix/ext/fs.rs:245:#[unstable(feature = "dir_builder", reason = "recently added API", +src/libstd/sys/unix/ext/io.rs:13:#![stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/unix/ext/io.rs:22:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/unix/ext/io.rs:31:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/unix/ext/io.rs:38: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/unix/ext/io.rs:44:#[stable(feature = "from_raw_os", since = "1.1.0")] +src/libstd/sys/unix/ext/io.rs:58: #[stable(feature = "from_raw_os", since = "1.1.0")] +src/libstd/sys/unix/ext/io.rs:64:#[stable(feature = "into_raw_os", since = "1.4.0")] +src/libstd/sys/unix/ext/io.rs:71: #[stable(feature = "into_raw_os", since = "1.4.0")] +src/libstd/sys/unix/ext/io.rs:75:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/unix/ext/io.rs:81:#[stable(feature = "from_raw_os", since = "1.1.0")] +src/libstd/sys/unix/ext/io.rs:87:#[stable(feature = "into_raw_os", since = "1.4.0")] +src/libstd/sys/unix/ext/io.rs:94:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/unix/ext/io.rs:98:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/unix/ext/io.rs:102:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/unix/ext/io.rs:107:#[stable(feature = "from_raw_os", since = "1.1.0")] +src/libstd/sys/unix/ext/io.rs:114:#[stable(feature = "from_raw_os", since = "1.1.0")] +src/libstd/sys/unix/ext/io.rs:121:#[stable(feature = "from_raw_os", since = "1.1.0")] +src/libstd/sys/unix/ext/io.rs:129:#[stable(feature = "into_raw_os", since = "1.4.0")] +src/libstd/sys/unix/ext/io.rs:135:#[stable(feature = "into_raw_os", since = "1.4.0")] +src/libstd/sys/unix/ext/io.rs:141:#[stable(feature = "into_raw_os", since = "1.4.0")] +src/libstd/sys/unix/ext/mod.rs:30:#![stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/unix/ext/mod.rs:41:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/unix/ext/mod.rs:45: #[doc(no_inline)] #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/unix/ext/mod.rs:51: #[doc(no_inline)] #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/unix/ext/process.rs:13:#![stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/unix/ext/process.rs:22:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/unix/ext/process.rs:27: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/unix/ext/process.rs:32: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/unix/ext/process.rs:44: #[unstable(feature = "process_session_leader", reason = "recently added", +src/libstd/sys/unix/ext/process.rs:49:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/unix/ext/process.rs:68:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/unix/ext/process.rs:71: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/unix/ext/process.rs:75:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/unix/ext/process.rs:85:#[stable(feature = "process_extensions", since = "1.2.0")] +src/libstd/sys/unix/ext/process.rs:92:#[stable(feature = "process_extensions", since = "1.2.0")] +src/libstd/sys/unix/ext/process.rs:99:#[stable(feature = "process_extensions", since = "1.2.0")] +src/libstd/sys/unix/ext/process.rs:106:#[stable(feature = "process_extensions", since = "1.2.0")] +src/libstd/sys/unix/ext/raw.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/sys/unix/ext/raw.rs:15:#[stable(feature = "raw_ext", since = "1.1.0")] pub type uid_t = u32; +src/libstd/sys/unix/ext/raw.rs:16:#[stable(feature = "raw_ext", since = "1.1.0")] pub type gid_t = u32; +src/libstd/sys/unix/ext/raw.rs:17:#[stable(feature = "raw_ext", since = "1.1.0")] pub type pid_t = i32; +src/libstd/sys/unix/fs.rs:81:#[stable(feature = "metadata_ext", since = "1.1.0")] +src/libstd/sys/unix/fs.rs:89: #[stable(feature = "metadata_ext", since = "1.1.0")] +src/libstd/sys/unix/fs.rs:93:#[stable(feature = "metadata_ext", since = "1.1.0")] +src/libstd/sys/windows/ext/ffi.rs:13:#![stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/windows/ext/ffi.rs:23:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/windows/ext/ffi.rs:30: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/windows/ext/ffi.rs:34:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/windows/ext/ffi.rs:42:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/windows/ext/ffi.rs:49: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/windows/ext/ffi.rs:53:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/windows/ext/fs.rs:13:#![stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/windows/ext/fs.rs:22:#[unstable(feature = "open_options_ext", +src/libstd/sys/windows/ext/fs.rs:69:#[stable(feature = "metadata_ext", since = "1.1.0")] +src/libstd/sys/windows/ext/fs.rs:75: #[stable(feature = "metadata_ext", since = "1.1.0")] +src/libstd/sys/windows/ext/fs.rs:82: #[stable(feature = "metadata_ext", since = "1.1.0")] +src/libstd/sys/windows/ext/fs.rs:89: #[stable(feature = "metadata_ext", since = "1.1.0")] +src/libstd/sys/windows/ext/fs.rs:96: #[stable(feature = "metadata_ext", since = "1.1.0")] +src/libstd/sys/windows/ext/fs.rs:103: #[stable(feature = "metadata_ext", since = "1.1.0")] +src/libstd/sys/windows/ext/fs.rs:107:#[stable(feature = "metadata_ext", since = "1.1.0")] +src/libstd/sys/windows/ext/fs.rs:131:#[stable(feature = "symlink", since = "1.1.0")] +src/libstd/sys/windows/ext/fs.rs:152:#[stable(feature = "symlink", since = "1.1.0")] +src/libstd/sys/windows/ext/io.rs:11:#![stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/windows/ext/io.rs:20:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/windows/ext/io.rs:24:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/windows/ext/io.rs:28:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/windows/ext/io.rs:31: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/windows/ext/io.rs:36:#[stable(feature = "from_raw_os", since = "1.1.0")] +src/libstd/sys/windows/ext/io.rs:49: #[stable(feature = "from_raw_os", since = "1.1.0")] +src/libstd/sys/windows/ext/io.rs:55:#[stable(feature = "into_raw_os", since = "1.4.0")] +src/libstd/sys/windows/ext/io.rs:62: #[stable(feature = "into_raw_os", since = "1.4.0")] +src/libstd/sys/windows/ext/io.rs:66:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/windows/ext/io.rs:73:#[stable(feature = "from_raw_os", since = "1.1.0")] +src/libstd/sys/windows/ext/io.rs:81:#[stable(feature = "into_raw_os", since = "1.4.0")] +src/libstd/sys/windows/ext/io.rs:89:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/windows/ext/io.rs:92: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/windows/ext/io.rs:97:#[stable(feature = "from_raw_os", since = "1.1.0")] +src/libstd/sys/windows/ext/io.rs:109: #[stable(feature = "from_raw_os", since = "1.1.0")] +src/libstd/sys/windows/ext/io.rs:115:#[stable(feature = "into_raw_os", since = "1.4.0")] +src/libstd/sys/windows/ext/io.rs:122: #[stable(feature = "into_raw_os", since = "1.4.0")] +src/libstd/sys/windows/ext/io.rs:126:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/windows/ext/io.rs:132:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/windows/ext/io.rs:138:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/windows/ext/io.rs:145:#[stable(feature = "from_raw_os", since = "1.1.0")] +src/libstd/sys/windows/ext/io.rs:152:#[stable(feature = "from_raw_os", since = "1.1.0")] +src/libstd/sys/windows/ext/io.rs:159:#[stable(feature = "from_raw_os", since = "1.1.0")] +src/libstd/sys/windows/ext/io.rs:167:#[stable(feature = "into_raw_os", since = "1.4.0")] +src/libstd/sys/windows/ext/io.rs:174:#[stable(feature = "into_raw_os", since = "1.4.0")] +src/libstd/sys/windows/ext/io.rs:181:#[stable(feature = "into_raw_os", since = "1.4.0")] +src/libstd/sys/windows/ext/mod.rs:17:#![stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/windows/ext/mod.rs:28:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/windows/ext/mod.rs:34: #[doc(no_inline)] #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/sys/windows/ext/process.rs:13:#![stable(feature = "process_extensions", since = "1.2.0")] +src/libstd/sys/windows/ext/process.rs:20:#[stable(feature = "process_extensions", since = "1.2.0")] +src/libstd/sys/windows/ext/process.rs:28:#[stable(feature = "process_extensions", since = "1.2.0")] +src/libstd/sys/windows/ext/process.rs:41:#[stable(feature = "process_extensions", since = "1.2.0")] +src/libstd/sys/windows/ext/process.rs:48:#[stable(feature = "process_extensions", since = "1.2.0")] +src/libstd/sys/windows/ext/process.rs:55:#[stable(feature = "process_extensions", since = "1.2.0")] +src/libstd/sys/windows/ext/raw.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] +src/libstd/sys/windows/ext/raw.rs:17:#[stable(feature = "raw_ext", since = "1.1.0")] pub type HANDLE = *mut c_void; +src/libstd/sys/windows/ext/raw.rs:19:#[stable(feature = "raw_ext", since = "1.1.0")] pub type SOCKET = u32; +src/libstd/sys/windows/ext/raw.rs:21:#[stable(feature = "raw_ext", since = "1.1.0")] pub type SOCKET = u64; +src/libstd/thread/local.rs:13:#![unstable(feature = "thread_local_internals", issue = "0")] +src/libstd/thread/local.rs:62:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/thread/local.rs:103:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/thread/local.rs:104:#[allow_internal_unstable] +src/libstd/thread/local.rs:124:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/thread/local.rs:125:#[allow_internal_unstable] +src/libstd/thread/local.rs:139:#[unstable(feature = "thread_local_internals", +src/libstd/thread/local.rs:143:#[allow_internal_unstable] +src/libstd/thread/local.rs:156:#[unstable(feature = "thread_local_state", +src/libstd/thread/local.rs:189: #[unstable(feature = "thread_local_internals", +src/libstd/thread/local.rs:210: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/thread/local.rs:253: #[unstable(feature = "thread_local_state", +src/libstd/thread/mod.rs:161:#![stable(feature = "rust1", since = "1.0.0")] +src/libstd/thread/mod.rs:184:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/thread/mod.rs:187:#[unstable(feature = "scoped_tls", +src/libstd/thread/mod.rs:202:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/thread/mod.rs:213: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/thread/mod.rs:223: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/thread/mod.rs:230: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/thread/mod.rs:248: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/thread/mod.rs:314:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/thread/mod.rs:322:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/thread/mod.rs:330:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/thread/mod.rs:337:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/thread/mod.rs:380:#[unstable(feature = "catch_panic", reason = "recent API addition", +src/libstd/thread/mod.rs:399:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/thread/mod.rs:415:#[stable(feature = "thread_sleep", since = "1.4.0")] +src/libstd/thread/mod.rs:445:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/thread/mod.rs:465:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/thread/mod.rs:485:#[stable(feature = "park_timeout", since = "1.4.0")] +src/libstd/thread/mod.rs:508:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/thread/mod.rs:529: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/thread/mod.rs:539: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/thread/mod.rs:545:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/thread/mod.rs:564:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/thread/mod.rs:607:#[stable(feature = "rust1", since = "1.0.0")] +src/libstd/thread/mod.rs:612: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/thread/mod.rs:621: #[stable(feature = "rust1", since = "1.0.0")] +src/libstd/thread/scoped_tls.rs:43:#![unstable(feature = "thread_local_internals", issue = "0")] +src/libstd/thread/scoped_tls.rs:55:#[unstable(feature = "scoped_tls", +src/libstd/thread/scoped_tls.rs:69:#[allow_internal_unstable] +src/libstd/thread/scoped_tls.rs:82:#[unstable(feature = "thread_local_internals", +src/libstd/thread/scoped_tls.rs:85:#[allow_internal_unstable] +src/libstd/thread/scoped_tls.rs:97:#[unstable(feature = "thread_local_internals", +src/libstd/thread/scoped_tls.rs:100:#[allow_internal_unstable] +src/libstd/thread/scoped_tls.rs:118:#[unstable(feature = "scoped_tls", +src/libstd/time/duration.rs:42:#[stable(feature = "duration", since = "1.3.0")] +src/libstd/time/duration.rs:55: #[stable(feature = "duration", since = "1.3.0")] +src/libstd/time/duration.rs:64: #[unstable(feature = "duration_span", +src/libstd/time/duration.rs:76: #[stable(feature = "duration", since = "1.3.0")] +src/libstd/time/duration.rs:82: #[stable(feature = "duration", since = "1.3.0")] +src/libstd/time/duration.rs:93: #[stable(feature = "duration", since = "1.3.0")] +src/libstd/time/duration.rs:101: #[stable(feature = "duration", since = "1.3.0")] +src/libstd/time/mod.rs:13:#![stable(feature = "time", since = "1.3.0")] +src/libsyntax/ast.rs:1897: pub allow_internal_unstable: bool, +src/libsyntax/attr.rs:402: Unstable, +src/libsyntax/attr.rs:425: if tag != "deprecated" && tag != "unstable" && tag != "stable" { +src/libsyntax/attr.rs:491: // Unstable tags don't require a version +src/libsyntax/attr.rs:492: if since == None && tag != "unstable" { +src/libsyntax/attr.rs:496: if tag == "unstable" || tag == "stable" { +src/libsyntax/attr.rs:502: "unstable" => Unstable, +src/libsyntax/attr.rs:503: "stable" => Stable, +src/libsyntax/attr.rs:534: either stable or unstable attribute"); +src/libsyntax/attr.rs:537: } else if stab.as_ref().map_or(false, |s| s.level == Unstable && s.issue.is_none()) { +src/libsyntax/attr.rs:538: // non-deprecated unstable items need to point to issues. +src/libsyntax/attr.rs:540: "non-deprecated unstable items need to point \ +src/libsyntax/codemap.rs:298: /// Whether the macro is allowed to use #[unstable]/feature-gated +src/libsyntax/codemap.rs:301: pub allow_internal_unstable: bool, +src/libsyntax/codemap.rs:1004: /// Check if a span is "internal" to a macro in which #[unstable] +src/libsyntax/codemap.rs:1006: /// `#[allow_internal_unstable]`). +src/libsyntax/codemap.rs:1007: pub fn span_allows_unstable(&self, span: Span) -> bool { +src/libsyntax/codemap.rs:1008: debug!("span_allows_unstable(span = {:?})", span); +src/libsyntax/codemap.rs:1009: let mut allows_unstable = false; +src/libsyntax/codemap.rs:1013: debug!("span_allows_unstable: expninfo = {:?}", expninfo); +src/libsyntax/codemap.rs:1021: debug!("span_allows_unstable: span: {:?} call_site: {:?} callee: {:?}", +src/libsyntax/codemap.rs:1025: debug!("span_allows_unstable: from this expansion? {}, allows unstable? {}", +src/libsyntax/codemap.rs:1027: info.callee.allow_internal_unstable); +src/libsyntax/codemap.rs:1029: allows_unstable = info.callee.allow_internal_unstable; +src/libsyntax/codemap.rs:1043: debug!("span_allows_unstable? {}", allows_unstable); +src/libsyntax/codemap.rs:1044: allows_unstable +src/libsyntax/ext/asm.rs:219: allow_internal_unstable: false, +src/libsyntax/ext/base.rs:424: /// directly use `#[unstable]` things (true == yes). +src/libsyntax/ext/base.rs:466: // format_args uses `unstable` things internally. +src/libsyntax/ext/base.rs:596: #[unstable(feature = "rustc_private")] +src/libsyntax/ext/deriving/generic/mod.rs:1451: allow_internal_unstable: false, +src/libsyntax/ext/deriving/show.rs:71: // We want to make sure we have the expn_id set so that we can use unstable methods +src/libsyntax/ext/expand.rs:58: allow_internal_unstable: true, +src/libsyntax/ext/expand.rs:65: // Sets the expn_id so that we can use unstable methods. +src/libsyntax/ext/expand.rs:66: fn allow_unstable(fld: &mut MacroExpander, span: Span) -> Span { +src/libsyntax/ext/expand.rs:137: // We feed in the `expr_span` because codemap's span_allows_unstable +src/libsyntax/ext/expand.rs:138: // allows the call_site span to inherit the `allow_internal_unstable` +src/libsyntax/ext/expand.rs:140: let span_unstable = allow_unstable(fld, expr_span); +src/libsyntax/ext/expand.rs:141: let path = mk_core_path(fld, span_unstable, p); +src/libsyntax/ext/expand.rs:143: let expr_span_unstable = allow_unstable(fld, span); +src/libsyntax/ext/expand.rs:144: fld.cx.expr_call(expr_span_unstable, path, args) +src/libsyntax/ext/expand.rs:538: NormalTT(ref expandfun, exp_span, allow_internal_unstable) => { +src/libsyntax/ext/expand.rs:544: allow_internal_unstable: allow_internal_unstable, +src/libsyntax/ext/expand.rs:702: NormalTT(ref expander, tt_span, allow_internal_unstable) => { +src/libsyntax/ext/expand.rs:716: allow_internal_unstable: allow_internal_unstable, +src/libsyntax/ext/expand.rs:723: IdentTT(ref expander, tt_span, allow_internal_unstable) => { +src/libsyntax/ext/expand.rs:735: allow_internal_unstable: allow_internal_unstable, +src/libsyntax/ext/expand.rs:756: // unstable (this is orthogonal to whether +src/libsyntax/ext/expand.rs:758: allow_internal_unstable: false, +src/libsyntax/ext/expand.rs:763: let allow_internal_unstable = attr::contains_name(&attrs, +src/libsyntax/ext/expand.rs:764: "allow_internal_unstable"); +src/libsyntax/ext/expand.rs:766: // ensure any #[allow_internal_unstable]s are +src/libsyntax/ext/expand.rs:769: if allow_internal_unstable && !fld.cx.ecfg.enable_allow_internal_unstable() { +src/libsyntax/ext/expand.rs:772: "allow_internal_unstable", +src/libsyntax/ext/expand.rs:787: allow_internal_unstable: allow_internal_unstable, +src/libsyntax/ext/expand.rs:1074: NormalTT(ref expander, tt_span, allow_internal_unstable) => { +src/libsyntax/ext/expand.rs:1080: allow_internal_unstable: allow_internal_unstable, +src/libsyntax/ext/expand.rs:1288: allow_internal_unstable: true, +src/libsyntax/ext/expand.rs:1338: allow_internal_unstable: true, +src/libsyntax/ext/expand.rs:1576: fn enable_allow_internal_unstable = allow_internal_unstable, +src/libsyntax/ext/format.rs:40: /// The macro's call site. References to unstable formatting internals must +src/libsyntax/ext/tt/macro_rules.rs:306: NormalTT(exp, Some(def.span), def.allow_internal_unstable) +src/libsyntax/feature_gate.rs:23://! becomes stable. +src/libsyntax/feature_gate.rs:47:// stable (active). +src/libsyntax/feature_gate.rs:149: // Allows the use of #[allow_internal_unstable]. This is an +src/libsyntax/feature_gate.rs:153: ("allow_internal_unstable", "1.0.0", None, Active), +src/libsyntax/feature_gate.rs:294: and will never be stable")), +src/libsyntax/feature_gate.rs:298: and will never be stable")), +src/libsyntax/feature_gate.rs:302: and will never be stable")), +src/libsyntax/feature_gate.rs:306: and will never be stable")), +src/libsyntax/feature_gate.rs:308: ("allow_internal_unstable", Normal, Gated("allow_internal_unstable", +src/libsyntax/feature_gate.rs:340: "unsafe_no_drop_flag has unstable semantics \ +src/libsyntax/feature_gate.rs:352: ("stable", Whitelisted, Ungated), +src/libsyntax/feature_gate.rs:353: ("unstable", Whitelisted, Ungated), +src/libsyntax/feature_gate.rs:461: pub allow_internal_unstable: bool, +src/libsyntax/feature_gate.rs:469: /// spans of #![feature] attrs for stable language features. for error reporting +src/libsyntax/feature_gate.rs:470: pub declared_stable_lang_features: Vec, +src/libsyntax/feature_gate.rs:493: allow_internal_unstable: false, +src/libsyntax/feature_gate.rs:501: declared_stable_lang_features: Vec::new(), +src/libsyntax/feature_gate.rs:645: // #23973: do not suggest `#![feature(...)]` if we are in beta/stable +src/libsyntax/feature_gate.rs:653: "inline assembly is not stable enough for use and is subject to change"; +src/libsyntax/feature_gate.rs:656: "`log_syntax!` is not stable enough for use and is subject to change"; +src/libsyntax/feature_gate.rs:659: "`concat_idents` is not stable enough for use and is subject to change"; +src/libsyntax/feature_gate.rs:662: "`trace_macros` is not stable enough for use and is subject to change"; +src/libsyntax/feature_gate.rs:664: "allow_internal_unstable side-steps feature gating and stability checks"; +src/libsyntax/feature_gate.rs:667: "`#[derive]` for custom traits is not stable enough for use and is subject to change"; +src/libsyntax/feature_gate.rs:734: if !self.context.cm.span_allows_unstable(span) { +src/libsyntax/feature_gate.rs:742: if !self.context.cm.span_allows_unstable(attr.span) { +src/libsyntax/feature_gate.rs:824: "empty structs with braces are unstable"); +src/libsyntax/feature_gate.rs:878: "empty structs with braces are unstable"); +src/libsyntax/feature_gate.rs:908: "empty structs with braces are unstable"); +src/libsyntax/feature_gate.rs:925: self.gate_feature("const_fn", span, "const fn is unstable"); +src/libsyntax/feature_gate.rs:961: self.gate_feature("const_fn", ti.span, "const fn is unstable"); +src/libsyntax/feature_gate.rs:966: "associated type defaults are unstable"); +src/libsyntax/feature_gate.rs:982: self.gate_feature("const_fn", ii.span, "const fn is unstable"); +src/libsyntax/feature_gate.rs:1063: allow_internal_unstable: cx.has_feature("allow_internal_unstable"), +src/libsyntax/feature_gate.rs:1071: declared_stable_lang_features: accepted_features, +src/libsyntax/feature_gate.rs:1091: unstable: UnstableFeatures) -> Features +src/libsyntax/feature_gate.rs:1093: maybe_stage_features(span_handler, krate, unstable); +src/libsyntax/feature_gate.rs:1101:pub enum UnstableFeatures { +src/libsyntax/feature_gate.rs:1102: /// Hard errors for unstable features are active, as on +src/libsyntax/feature_gate.rs:1103: /// beta/stable channels. +src/libsyntax/feature_gate.rs:1109: /// because the build turns on warnings-as-errors and uses lots of unstable +src/libsyntax/feature_gate.rs:1115: unstable: UnstableFeatures) { +src/libsyntax/feature_gate.rs:1116: let allow_features = match unstable { +src/libsyntax/feature_gate.rs:1117: UnstableFeatures::Allow => true, +src/libsyntax/feature_gate.rs:1118: UnstableFeatures::Disallow => false, +src/libsyntax/feature_gate.rs:1119: UnstableFeatures::Cheat => true +src/libsyntax/lib.rs:15://! This API is completely unstable and subject to change. +src/libsyntax/lib.rs:20:#![unstable(feature = "rustc_private", issue = "27812")] +src/libsyntax/ptr.rs:114:#[stable(feature = "rust1", since = "1.0.0")] +src/libsyntax/std_inject.rs:24:/// The expanded code uses the unstable `#[prelude_import]` attribute. +src/libsyntax/std_inject.rs:31: allow_internal_unstable: true, +src/libsyntax/test.rs:303: allow_internal_unstable: false, +src/libsyntax/test.rs:328:/// The expanded code calls some unstable functions in the test crate. +src/libsyntax/test.rs:335: allow_internal_unstable: true, +src/libsyntax/util/small_vector.rs:68: // FIXME: Could be replaced with `slice::ref_slice(v)` when it is stable. +src/libsyntax/util/small_vector.rs:132: #[unstable(feature = "rustc_private")] +src/libterm/lib.rs:47:#![unstable(feature = "rustc_private", +src/libtest/lib.rs:29:#![unstable(feature = "test", issue = "27812")] +src/libtest/lib.rs:1171: // stable median. +src/rt/miniz.c:31: 5/15/11 v1.09 - Initial stable release. +src/test/auxiliary/const_fn_lib.rs:16:pub const fn foo() -> usize { 22 } //~ ERROR const fn is unstable +src/test/auxiliary/inherited_stability.rs:12:#![unstable(feature = "test_feature", issue = "0")] +src/test/auxiliary/inherited_stability.rs:16:pub fn unstable() {} +src/test/auxiliary/inherited_stability.rs:18:#[stable(feature = "rust1", since = "1.0.0")] +src/test/auxiliary/inherited_stability.rs:19:pub fn stable() {} +src/test/auxiliary/inherited_stability.rs:21:#[stable(feature = "rust1", since = "1.0.0")] +src/test/auxiliary/inherited_stability.rs:22:pub mod stable_mod { +src/test/auxiliary/inherited_stability.rs:23: pub fn unstable() {} +src/test/auxiliary/inherited_stability.rs:25: #[stable(feature = "rust1", since = "1.0.0")] +src/test/auxiliary/inherited_stability.rs:26: pub fn stable() {} +src/test/auxiliary/inherited_stability.rs:29:#[unstable(feature = "test_feature", issue = "0")] +src/test/auxiliary/inherited_stability.rs:30:pub mod unstable_mod { +src/test/auxiliary/inherited_stability.rs:31: #[stable(feature = "test_feature", since = "1.0.0")] +src/test/auxiliary/inherited_stability.rs:35: pub fn unstable() {} +src/test/auxiliary/inherited_stability.rs:38:#[stable(feature = "rust1", since = "1.0.0")] +src/test/auxiliary/inherited_stability.rs:40: fn unstable(&self); +src/test/auxiliary/inherited_stability.rs:42: #[stable(feature = "rust1", since = "1.0.0")] +src/test/auxiliary/inherited_stability.rs:43: fn stable(&self); +src/test/auxiliary/inherited_stability.rs:47: fn unstable(&self) {} +src/test/auxiliary/inherited_stability.rs:48: fn stable(&self) {} +src/test/auxiliary/inherited_stability.rs:51:pub enum Unstable { +src/test/auxiliary/inherited_stability.rs:52: UnstableVariant, +src/test/auxiliary/inherited_stability.rs:53: #[stable(feature = "rust1", since = "1.0.0")] +src/test/auxiliary/internal_unstable.rs:11:#![feature(staged_api, allow_internal_unstable)] +src/test/auxiliary/internal_unstable.rs:13:#![stable(feature = "stable", since = "1.0.0")] +src/test/auxiliary/internal_unstable.rs:15:#[unstable(feature = "function", issue = "0")] +src/test/auxiliary/internal_unstable.rs:16:pub fn unstable() {} +src/test/auxiliary/internal_unstable.rs:19:#[stable(feature = "stable", since = "1.0.0")] +src/test/auxiliary/internal_unstable.rs:21: #[unstable(feature = "struct_field", issue = "0")] +src/test/auxiliary/internal_unstable.rs:26: #[unstable(feature = "method", issue = "0")] +src/test/auxiliary/internal_unstable.rs:30:#[stable(feature = "stable", since = "1.0.0")] +src/test/auxiliary/internal_unstable.rs:32: #[unstable(feature = "struct2_field", issue = "0")] +src/test/auxiliary/internal_unstable.rs:36:#[allow_internal_unstable] +src/test/auxiliary/internal_unstable.rs:38:macro_rules! call_unstable_allow { +src/test/auxiliary/internal_unstable.rs:39: () => { $crate::unstable() } +src/test/auxiliary/internal_unstable.rs:42:#[allow_internal_unstable] +src/test/auxiliary/internal_unstable.rs:44:macro_rules! construct_unstable_allow { +src/test/auxiliary/internal_unstable.rs:50:#[allow_internal_unstable] +src/test/auxiliary/internal_unstable.rs:56:#[allow_internal_unstable] +src/test/auxiliary/internal_unstable.rs:62:#[allow_internal_unstable] +src/test/auxiliary/internal_unstable.rs:69:macro_rules! call_unstable_noallow { +src/test/auxiliary/internal_unstable.rs:70: () => { $crate::unstable() } +src/test/auxiliary/internal_unstable.rs:74:macro_rules! construct_unstable_noallow { +src/test/auxiliary/lint_output_format.rs:15:#![unstable(feature = "test_feature", issue = "0")] +src/test/auxiliary/lint_output_format.rs:17:#[stable(feature = "test_feature", since = "1.0.0")] +src/test/auxiliary/lint_output_format.rs:23:#[unstable(feature = "test_feature", issue = "0")] +src/test/auxiliary/lint_output_format.rs:28:#[unstable(feature = "test_feature", issue = "0")] +src/test/auxiliary/lint_stability.rs:14:#![stable(feature = "lint_stability", since = "1.0.0")] +src/test/auxiliary/lint_stability.rs:16:#[stable(feature = "test_feature", since = "1.0.0")] +src/test/auxiliary/lint_stability.rs:19:#[stable(feature = "test_feature", since = "1.0.0")] +src/test/auxiliary/lint_stability.rs:23:#[unstable(feature = "test_feature", issue = "0")] +src/test/auxiliary/lint_stability.rs:25:pub fn deprecated_unstable() {} +src/test/auxiliary/lint_stability.rs:26:#[unstable(feature = "test_feature", issue = "0")] +src/test/auxiliary/lint_stability.rs:28:pub fn deprecated_unstable_text() {} +src/test/auxiliary/lint_stability.rs:30:#[unstable(feature = "test_feature", issue = "0")] +src/test/auxiliary/lint_stability.rs:31:pub fn unstable() {} +src/test/auxiliary/lint_stability.rs:32:#[unstable(feature = "test_feature", reason = "text", issue = "0")] +src/test/auxiliary/lint_stability.rs:33:pub fn unstable_text() {} +src/test/auxiliary/lint_stability.rs:35:#[stable(feature = "rust1", since = "1.0.0")] +src/test/auxiliary/lint_stability.rs:36:pub fn stable() {} +src/test/auxiliary/lint_stability.rs:37:#[stable(feature = "rust1", since = "1.0.0", reason = "text")] +src/test/auxiliary/lint_stability.rs:38:pub fn stable_text() {} +src/test/auxiliary/lint_stability.rs:40:#[stable(feature = "rust1", since = "1.0.0")] +src/test/auxiliary/lint_stability.rs:44: #[stable(feature = "test_feature", since = "1.0.0")] +src/test/auxiliary/lint_stability.rs:47: #[stable(feature = "test_feature", since = "1.0.0")] +src/test/auxiliary/lint_stability.rs:51: #[unstable(feature = "test_feature", issue = "0")] +src/test/auxiliary/lint_stability.rs:53: pub fn method_deprecated_unstable(&self) {} +src/test/auxiliary/lint_stability.rs:54: #[unstable(feature = "test_feature", issue = "0")] +src/test/auxiliary/lint_stability.rs:56: pub fn method_deprecated_unstable_text(&self) {} +src/test/auxiliary/lint_stability.rs:58: #[unstable(feature = "test_feature", issue = "0")] +src/test/auxiliary/lint_stability.rs:59: pub fn method_unstable(&self) {} +src/test/auxiliary/lint_stability.rs:60: #[unstable(feature = "test_feature", reason = "text", issue = "0")] +src/test/auxiliary/lint_stability.rs:61: pub fn method_unstable_text(&self) {} +src/test/auxiliary/lint_stability.rs:63: #[stable(feature = "rust1", since = "1.0.0")] +src/test/auxiliary/lint_stability.rs:64: pub fn method_stable(&self) {} +src/test/auxiliary/lint_stability.rs:65: #[stable(feature = "rust1", since = "1.0.0", reason = "text")] +src/test/auxiliary/lint_stability.rs:66: pub fn method_stable_text(&self) {} +src/test/auxiliary/lint_stability.rs:69:#[stable(feature = "test_feature", since = "1.0.0")] +src/test/auxiliary/lint_stability.rs:71: #[stable(feature = "test_feature", since = "1.0.0")] +src/test/auxiliary/lint_stability.rs:74: #[stable(feature = "test_feature", since = "1.0.0")] +src/test/auxiliary/lint_stability.rs:78: #[unstable(feature = "test_feature", issue = "0")] +src/test/auxiliary/lint_stability.rs:80: fn trait_deprecated_unstable(&self) {} +src/test/auxiliary/lint_stability.rs:81: #[unstable(feature = "test_feature", issue = "0")] +src/test/auxiliary/lint_stability.rs:83: fn trait_deprecated_unstable_text(&self) {} +src/test/auxiliary/lint_stability.rs:85: #[unstable(feature = "test_feature", issue = "0")] +src/test/auxiliary/lint_stability.rs:86: fn trait_unstable(&self) {} +src/test/auxiliary/lint_stability.rs:87: #[unstable(feature = "test_feature", reason = "text", issue = "0")] +src/test/auxiliary/lint_stability.rs:88: fn trait_unstable_text(&self) {} +src/test/auxiliary/lint_stability.rs:90: #[stable(feature = "rust1", since = "1.0.0")] +src/test/auxiliary/lint_stability.rs:91: fn trait_stable(&self) {} +src/test/auxiliary/lint_stability.rs:92: #[stable(feature = "rust1", since = "1.0.0", reason = "text")] +src/test/auxiliary/lint_stability.rs:93: fn trait_stable_text(&self) {} +src/test/auxiliary/lint_stability.rs:98:#[unstable(feature = "test_feature", issue = "0")] +src/test/auxiliary/lint_stability.rs:99:pub trait UnstableTrait { fn dummy(&self) { } } +src/test/auxiliary/lint_stability.rs:101:#[stable(feature = "test_feature", since = "1.0.0")] +src/test/auxiliary/lint_stability.rs:104: #[stable(feature = "test_feature", since = "1.0.0")] pub i: isize +src/test/auxiliary/lint_stability.rs:106:#[unstable(feature = "test_feature", issue = "0")] +src/test/auxiliary/lint_stability.rs:108:pub struct DeprecatedUnstableStruct { +src/test/auxiliary/lint_stability.rs:109: #[stable(feature = "test_feature", since = "1.0.0")] pub i: isize +src/test/auxiliary/lint_stability.rs:111:#[unstable(feature = "test_feature", issue = "0")] +src/test/auxiliary/lint_stability.rs:112:pub struct UnstableStruct { +src/test/auxiliary/lint_stability.rs:113: #[stable(feature = "test_feature", since = "1.0.0")] pub i: isize +src/test/auxiliary/lint_stability.rs:115:#[stable(feature = "rust1", since = "1.0.0")] +src/test/auxiliary/lint_stability.rs:117: #[stable(feature = "test_feature", since = "1.0.0")] pub i: isize +src/test/auxiliary/lint_stability.rs:120:#[stable(feature = "test_feature", since = "1.0.0")] +src/test/auxiliary/lint_stability.rs:123:#[unstable(feature = "test_feature", issue = "0")] +src/test/auxiliary/lint_stability.rs:125:pub struct DeprecatedUnstableUnitStruct; +src/test/auxiliary/lint_stability.rs:126:#[unstable(feature = "test_feature", issue = "0")] +src/test/auxiliary/lint_stability.rs:127:pub struct UnstableUnitStruct; +src/test/auxiliary/lint_stability.rs:128:#[stable(feature = "rust1", since = "1.0.0")] +src/test/auxiliary/lint_stability.rs:131:#[stable(feature = "test_feature", since = "1.0.0")] +src/test/auxiliary/lint_stability.rs:133: #[stable(feature = "test_feature", since = "1.0.0")] +src/test/auxiliary/lint_stability.rs:136: #[unstable(feature = "test_feature", issue = "0")] +src/test/auxiliary/lint_stability.rs:138: DeprecatedUnstableVariant, +src/test/auxiliary/lint_stability.rs:139: #[unstable(feature = "test_feature", issue = "0")] +src/test/auxiliary/lint_stability.rs:140: UnstableVariant, +src/test/auxiliary/lint_stability.rs:142: #[stable(feature = "rust1", since = "1.0.0")] +src/test/auxiliary/lint_stability.rs:146:#[stable(feature = "test_feature", since = "1.0.0")] +src/test/auxiliary/lint_stability.rs:148:pub struct DeprecatedTupleStruct(#[stable(feature = "rust1", since = "1.0.0")] pub isize); +src/test/auxiliary/lint_stability.rs:149:#[unstable(feature = "test_feature", issue = "0")] +src/test/auxiliary/lint_stability.rs:151:pub struct DeprecatedUnstableTupleStruct(#[stable(feature = "rust1", since = "1.0.0")] pub isize); +src/test/auxiliary/lint_stability.rs:152:#[unstable(feature = "test_feature", issue = "0")] +src/test/auxiliary/lint_stability.rs:153:pub struct UnstableTupleStruct(#[stable(feature = "rust1", since = "1.0.0")] pub isize); +src/test/auxiliary/lint_stability.rs:154:#[stable(feature = "rust1", since = "1.0.0")] +src/test/auxiliary/lint_stability.rs:155:pub struct StableTupleStruct(#[stable(feature = "rust1", since = "1.0.0")] pub isize); +src/test/auxiliary/lint_stability_fields.rs:13:#![stable(feature = "rust1", since = "1.0.0")] +src/test/auxiliary/lint_stability_fields.rs:15:#[stable(feature = "rust1", since = "1.0.0")] +src/test/auxiliary/lint_stability_fields.rs:17: #[stable(feature = "rust1", since = "1.0.0")] +src/test/auxiliary/lint_stability_fields.rs:18: pub inherit: u8, // it's a lie (stable doesn't inherit) +src/test/auxiliary/lint_stability_fields.rs:19: #[unstable(feature = "test_feature", issue = "0")] +src/test/auxiliary/lint_stability_fields.rs:22: #[unstable(feature = "test_feature", issue = "0")] +src/test/auxiliary/lint_stability_fields.rs:26:#[stable(feature = "rust1", since = "1.0.0")] +src/test/auxiliary/lint_stability_fields.rs:27:pub struct Stable2(#[stable(feature = "rust1", since = "1.0.0")] pub u8, +src/test/auxiliary/lint_stability_fields.rs:28: #[unstable(feature = "test_feature", issue = "0")] pub u8, +src/test/auxiliary/lint_stability_fields.rs:29: #[unstable(feature = "test_feature", issue = "0")] +src/test/auxiliary/lint_stability_fields.rs:32:#[unstable(feature = "test_feature", issue = "0")] +src/test/auxiliary/lint_stability_fields.rs:33:pub struct Unstable { +src/test/auxiliary/lint_stability_fields.rs:35: #[stable(feature = "rust1", since = "1.0.0")] +src/test/auxiliary/lint_stability_fields.rs:38: #[unstable(feature = "test_feature", issue = "0")] +src/test/auxiliary/lint_stability_fields.rs:42:#[unstable(feature = "test_feature", issue = "0")] +src/test/auxiliary/lint_stability_fields.rs:43:pub struct Unstable2(pub u8, +src/test/auxiliary/lint_stability_fields.rs:44: #[stable(feature = "rust1", since = "1.0.0")] pub u8, +src/test/auxiliary/lint_stability_fields.rs:45: #[unstable(feature = "test_feature", issue = "0")] +src/test/auxiliary/lint_stability_fields.rs:48:#[unstable(feature = "test_feature", issue = "0")] +src/test/auxiliary/lint_stability_fields.rs:52: #[stable(feature = "rust1", since = "1.0.0")] +src/test/auxiliary/lint_stability_fields.rs:54: #[unstable(feature = "test_feature", issue = "0")] +src/test/auxiliary/lint_stability_fields.rs:58:#[unstable(feature = "test_feature", issue = "0")] +src/test/auxiliary/lint_stability_fields.rs:61: #[stable(feature = "rust1", since = "1.0.0")] pub u8, +src/test/auxiliary/lint_stability_fields.rs:62: #[unstable(feature = "test_feature", issue = "0")] pub u8); +src/test/auxiliary/stability_attribute_issue.rs:13:#![stable(feature = "foo", since = "1.2.0")] +src/test/auxiliary/stability_attribute_issue.rs:16:#[unstable(feature = "foo", issue = "1")] +src/test/auxiliary/stability_attribute_issue.rs:17:pub fn unstable() {} +src/test/auxiliary/stability_attribute_issue.rs:19:#[unstable(feature = "foo", reason = "message", issue = "2")] +src/test/auxiliary/stability_attribute_issue.rs:20:pub fn unstable_msg() {} +src/test/auxiliary/stability_cfg1.rs:12:#![cfg_attr(not(foo), stable(feature = "test_feature", since = "1.0.0"))] +src/test/auxiliary/stability_cfg2.rs:13:#![cfg_attr(foo, unstable(feature = "test_feature", issue = "0"))] +src/test/auxiliary/stability_cfg2.rs:14:#![cfg_attr(not(foo), stable(feature = "test_feature", since = "1.0.0"))] +src/test/compile-fail-fulldeps/qquote.rs:31: allow_internal_unstable: false, +src/test/compile-fail/asm-gated.rs:13: asm!(""); //~ ERROR inline assembly is not stable enough +src/test/compile-fail/asm-gated2.rs:13: println!("{}", asm!("")); //~ ERROR inline assembly is not stable +src/test/compile-fail/augmented-assignments-feature-gate-cross.rs:23: //~^ error: overloaded augmented assignments are not stable +src/test/compile-fail/augmented-assignments-feature-gate.rs:24: //~^ error: overloaded augmented assignments are not stable +src/test/compile-fail/augmented-assignments-trait.rs:12://~^ error: use of unstable library feature 'op_assign_traits' +src/test/compile-fail/augmented-assignments-trait.rs:17: //~^ error: use of unstable library feature 'op_assign_traits' +src/test/compile-fail/augmented-assignments-trait.rs:19: //~^ error: use of unstable library feature 'op_assign_traits' +src/test/compile-fail/concat_idents-gate.rs:15: let a = concat_idents!(X, Y_1); //~ ERROR `concat_idents` is not stable +src/test/compile-fail/concat_idents-gate.rs:16: let b = concat_idents!(X, Y_2); //~ ERROR `concat_idents` is not stable +src/test/compile-fail/concat_idents-gate2.rs:15: assert_eq!(10, concat_idents!(X, Y_1)); //~ ERROR `concat_idents` is not stable +src/test/compile-fail/concat_idents-gate2.rs:16: assert_eq!(20, concat_idents!(X, Y_2)); //~ ERROR `concat_idents` is not stable +src/test/compile-fail/const-fn-stability-calls.rs:19:static FOO: usize = foo(); //~ ERROR const fns are an unstable feature +src/test/compile-fail/const-fn-stability-calls.rs:20:const BAR: usize = foo(); //~ ERROR const fns are an unstable feature +src/test/compile-fail/const-fn-stability-calls.rs:29: BAZ: usize = foo() //~ ERROR const fns are an unstable feature +src/test/compile-fail/const-fn-stability.rs:13:const fn foo() -> usize { 0 } //~ ERROR const fn is unstable +src/test/compile-fail/const-fn-stability.rs:16: const fn foo() -> u32; //~ ERROR const fn is unstable +src/test/compile-fail/const-fn-stability.rs:17: const fn bar() -> u32 { 0 } //~ ERROR const fn is unstable +src/test/compile-fail/const-fn-stability.rs:21: const fn baz() -> u32 { 0 } //~ ERROR const fn is unstable +src/test/compile-fail/const-fn-stability.rs:25: const fn foo() -> u32 { 0 } //~ ERROR const fn is unstable +src/test/compile-fail/deriving-meta-unknown-trait.rs:12://~^ ERROR `#[derive]` for custom traits is not stable enough for use and is subject to change +src/test/compile-fail/empty-struct-with-braces-3.rs:13:struct Empty {} //~ ERROR empty structs with braces are unstable +src/test/compile-fail/empty-struct-with-braces-3.rs:16: let e = Empty {}; //~ ERROR empty structs with braces are unstable +src/test/compile-fail/empty-struct-with-braces-3.rs:19: Empty {} => {} //~ ERROR empty structs with braces are unstable +src/test/compile-fail/enable-unstable-lib-feature.rs:11:// Test that enabling an unstable feature disables warnings +src/test/compile-fail/enable-unstable-lib-feature.rs:18:// Shouldn't generate a warning about unstable features +src/test/compile-fail/feature-gate-allow-internal-unstable-nested-macro.rs:14: #[allow_internal_unstable] +src/test/compile-fail/feature-gate-allow-internal-unstable-nested-macro.rs:15: macro_rules! baz { //~ ERROR allow_internal_unstable side-steps +src/test/compile-fail/feature-gate-allow-internal-unstable.rs:11:#[allow_internal_unstable] //~ ERROR allow_internal_unstable side-steps +src/test/compile-fail/feature-gate-assoc-type-defaults.rs:12: type Bar = u8; //~ ERROR associated type defaults are unstable +src/test/compile-fail/feature-gate-feature-gate.rs:11:#![forbid(unstable_features)] +src/test/compile-fail/feature-gate-feature-gate.rs:12:#![feature(intrinsics)] //~ ERROR unstable feature +src/test/compile-fail/feature-gate-rustc-attrs.rs:15:#[rustc_variance] //~ ERROR the `#[rustc_variance]` attribute is just used for rustc unit tests and will never be stable +src/test/compile-fail/feature-gate-rustc-attrs.rs:16:#[rustc_error] //~ ERROR the `#[rustc_error]` attribute is just used for rustc unit tests and will never be stable +src/test/compile-fail/feature-gate-rustc-attrs.rs:17:#[rustc_move_fragments] //~ ERROR the `#[rustc_move_fragments]` attribute is just used for rustc unit tests and will never be stable +src/test/compile-fail/gated-concat_idents.rs:12: concat_idents!(a, b); //~ ERROR `concat_idents` is not stable enough +src/test/compile-fail/gated-thread-local.rs:15:// is given permission to expand into this unstable attribute even +src/test/compile-fail/gated-trace_macros.rs:13: trace_macros!(true); //~ ERROR: `trace_macros` is not stable +src/test/compile-fail/internal-unstable-noallow.rs:11:// this has to be separate to internal-unstable.rs because these tests +src/test/compile-fail/internal-unstable-noallow.rs:16:// aux-build:internal_unstable.rs +src/test/compile-fail/internal-unstable-noallow.rs:17:// error-pattern:use of unstable library feature 'function' +src/test/compile-fail/internal-unstable-noallow.rs:18:// error-pattern:use of unstable library feature 'struct_field' +src/test/compile-fail/internal-unstable-noallow.rs:19:// error-pattern:use of unstable library feature 'method' +src/test/compile-fail/internal-unstable-noallow.rs:20:// error-pattern:use of unstable library feature 'struct2_field' +src/test/compile-fail/internal-unstable-noallow.rs:23:extern crate internal_unstable; +src/test/compile-fail/internal-unstable-noallow.rs:26: call_unstable_noallow!(); +src/test/compile-fail/internal-unstable-noallow.rs:28: construct_unstable_noallow!(0); +src/test/compile-fail/internal-unstable-noallow.rs:30: |x: internal_unstable::Foo| { call_method_noallow!(x) }; +src/test/compile-fail/internal-unstable-noallow.rs:32: |x: internal_unstable::Bar| { access_field_noallow!(x) }; +src/test/compile-fail/internal-unstable-thread-local.rs:11:// aux-build:internal_unstable.rs +src/test/compile-fail/internal-unstable-thread-local.rs:15:extern crate internal_unstable; +src/test/compile-fail/internal-unstable-thread-local.rs:19:thread_local!(static BAR: () = internal_unstable::unstable()); //~ ERROR use of unstable +src/test/compile-fail/internal-unstable.rs:11:// aux-build:internal_unstable.rs +src/test/compile-fail/internal-unstable.rs:13:#![feature(allow_internal_unstable)] +src/test/compile-fail/internal-unstable.rs:16:extern crate internal_unstable; +src/test/compile-fail/internal-unstable.rs:22: internal_unstable::unstable(); //~ ERROR use of unstable +src/test/compile-fail/internal-unstable.rs:26:#[allow_internal_unstable] +src/test/compile-fail/internal-unstable.rs:30: internal_unstable::unstable()); +src/test/compile-fail/internal-unstable.rs:31: internal_unstable::unstable(); +src/test/compile-fail/internal-unstable.rs:37: call_unstable_allow!(); +src/test/compile-fail/internal-unstable.rs:38: construct_unstable_allow!(0); +src/test/compile-fail/internal-unstable.rs:39: |x: internal_unstable::Foo| { call_method_allow!(x) }; +src/test/compile-fail/internal-unstable.rs:40: |x: internal_unstable::Bar| { access_field_allow!(x) }; +src/test/compile-fail/internal-unstable.rs:43: pass_through_allow!(internal_unstable::unstable()); //~ ERROR use of unstable +src/test/compile-fail/internal-unstable.rs:45: pass_through_noallow!(internal_unstable::unstable()); //~ ERROR use of unstable +src/test/compile-fail/internal-unstable.rs:49: println!("{:?}", internal_unstable::unstable()); //~ ERROR use of unstable +src/test/compile-fail/internal-unstable.rs:51: bar!(internal_unstable::unstable()); //~ ERROR use of unstable +src/test/compile-fail/issue-17337.rs:18: #[unstable(feature = "test_feature")] +src/test/compile-fail/issue-28075.rs:11:// Unstable entities should be caught in import lists +src/test/compile-fail/issue-28075.rs:19:use lint_stability::{unstable, deprecated}; //~ ERROR use of unstable library feature 'test_feature' +src/test/compile-fail/issue-28075.rs:22:use lint_stability::unstable::{self as u}; //~ ERROR use of unstable library feature 'test_feature' +src/test/compile-fail/issue-28388-3.rs:17:use lint_stability::UnstableStruct::{}; //~ ERROR use of unstable library feature 'test_feature' +src/test/compile-fail/lint-output-format.rs:16:extern crate lint_output_format; //~ ERROR use of unstable library feature +src/test/compile-fail/lint-output-format.rs:17:use lint_output_format::{foo, bar}; //~ ERROR use of unstable library feature +src/test/compile-fail/lint-output-format.rs:22: let _y = bar(); //~ ERROR use of unstable library feature +src/test/compile-fail/lint-stability-fields.rs:25: override1: 2, //~ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:28: //~^^ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:32: let _ = x.override1; //~ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:35: //~^^ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:39: override1: _, //~ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:42: //~^^ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:50: let _ = x.1; //~ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:53: //~^^ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:56: _, //~ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:59: //~^^ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:65: let x = Unstable { //~ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:66: inherit: 1, //~ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:70: //~^^ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:73: let _ = x.inherit; //~ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:77: //~^^ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:79: let Unstable { //~ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:80: inherit: _, //~ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:84: //~^^ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:87: let Unstable //~ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:92: let x = Unstable2(1, 2, 3); //~ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:94: let _ = x.0; //~ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:98: //~^^ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:100: let Unstable2 //~ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:101: (_, //~ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:105: //~^^ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:107: let Unstable2 //~ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:114: //~^^ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:117: //~^^ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:122: //~^^ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:127: //~^^ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:132: //~^^ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:136: //~^^ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:139: //~^^ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:143: //~^ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:149: //~^^ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:155: //~^^ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:159: //~^^ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:164: //~^^ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:168: //~^^ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:171: //~^^ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:176: //~^^ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:180: //~^^ ERROR use of unstable +src/test/compile-fail/lint-stability-fields.rs:187: #[stable(feature = "rust1", since = "1.0.0")] +src/test/compile-fail/lint-stability-fields.rs:190: #[unstable(feature = "test_feature", issue = "0")] +src/test/compile-fail/lint-stability-fields.rs:193: #[unstable(feature = "test_feature", issue = "0")] +src/test/compile-fail/lint-stability-fields.rs:197: #[stable(feature = "rust1", since = "1.0.0")] +src/test/compile-fail/lint-stability-fields.rs:199: #[stable(feature = "rust1", since = "1.0.0")] u8, +src/test/compile-fail/lint-stability-fields.rs:200: #[unstable(feature = "test_feature", issue = "0")] +src/test/compile-fail/lint-stability-fields.rs:203: #[unstable(feature = "test_feature", issue = "0")] +src/test/compile-fail/lint-stability-fields.rs:204: struct Unstable { +src/test/compile-fail/lint-stability-fields.rs:206: #[stable(feature = "rust1", since = "1.0.0")] +src/test/compile-fail/lint-stability-fields.rs:209: #[unstable(feature = "test_feature", issue = "0")] +src/test/compile-fail/lint-stability-fields.rs:213: #[unstable(feature = "test_feature", issue = "0")] +src/test/compile-fail/lint-stability-fields.rs:214: struct Unstable2(u8, +src/test/compile-fail/lint-stability-fields.rs:215: #[stable(feature = "rust1", since = "1.0.0")] u8, +src/test/compile-fail/lint-stability-fields.rs:216: #[unstable(feature = "test_feature", issue = "0")] +src/test/compile-fail/lint-stability-fields.rs:219: #[unstable(feature = "test_feature", issue = "0")] +src/test/compile-fail/lint-stability-fields.rs:223: #[stable(feature = "rust1", since = "1.0.0")] +src/test/compile-fail/lint-stability-fields.rs:225: #[unstable(feature = "test_feature", issue = "0")] +src/test/compile-fail/lint-stability-fields.rs:229: #[unstable(feature = "test_feature", issue = "0")] +src/test/compile-fail/lint-stability-fields.rs:232: #[stable(feature = "rust1", since = "1.0.0")] u8, +src/test/compile-fail/lint-stability-fields.rs:233: #[unstable(feature = "test_feature", issue = "0")] u8); +src/test/compile-fail/lint-stability-fields.rs:273: let x = Unstable { +src/test/compile-fail/lint-stability-fields.rs:285: let Unstable { +src/test/compile-fail/lint-stability-fields.rs:292: let Unstable +src/test/compile-fail/lint-stability-fields.rs:297: let x = Unstable2(1, 2, 3); +src/test/compile-fail/lint-stability-fields.rs:304: let Unstable2 +src/test/compile-fail/lint-stability-fields.rs:310: let Unstable2 +src/test/compile-fail/lint-stability.rs:26: extern crate stability_cfg2; //~ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:52: deprecated_unstable(); //~ ERROR use of deprecated item +src/test/compile-fail/lint-stability.rs:53: //~^ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:54: foo.method_deprecated_unstable(); //~ ERROR use of deprecated item +src/test/compile-fail/lint-stability.rs:55: //~^ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:56: Foo::method_deprecated_unstable(&foo); //~ ERROR use of deprecated item +src/test/compile-fail/lint-stability.rs:57: //~^ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:58: ::method_deprecated_unstable(&foo); //~ ERROR use of deprecated item +src/test/compile-fail/lint-stability.rs:59: //~^ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:60: foo.trait_deprecated_unstable(); //~ ERROR use of deprecated item +src/test/compile-fail/lint-stability.rs:61: //~^ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:62: Trait::trait_deprecated_unstable(&foo); //~ ERROR use of deprecated item +src/test/compile-fail/lint-stability.rs:63: //~^ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:64: ::trait_deprecated_unstable(&foo); //~ ERROR use of deprecated item +src/test/compile-fail/lint-stability.rs:65: //~^ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:66: ::trait_deprecated_unstable(&foo); //~ ERROR use of deprecated item +src/test/compile-fail/lint-stability.rs:67: //~^ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:69: deprecated_unstable_text(); //~ ERROR use of deprecated item: text +src/test/compile-fail/lint-stability.rs:70: //~^ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:71: foo.method_deprecated_unstable_text(); //~ ERROR use of deprecated item: text +src/test/compile-fail/lint-stability.rs:72: //~^ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:73: Foo::method_deprecated_unstable_text(&foo); //~ ERROR use of deprecated item: text +src/test/compile-fail/lint-stability.rs:74: //~^ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:75: ::method_deprecated_unstable_text(&foo); //~ ERROR use of deprecated item: text +src/test/compile-fail/lint-stability.rs:76: //~^ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:77: foo.trait_deprecated_unstable_text(); //~ ERROR use of deprecated item: text +src/test/compile-fail/lint-stability.rs:78: //~^ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:79: Trait::trait_deprecated_unstable_text(&foo); //~ ERROR use of deprecated item: text +src/test/compile-fail/lint-stability.rs:80: //~^ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:81: ::trait_deprecated_unstable_text(&foo); //~ ERROR use of deprecated item: text +src/test/compile-fail/lint-stability.rs:82: //~^ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:83: ::trait_deprecated_unstable_text(&foo); //~ ERROR use of deprecated item: text +src/test/compile-fail/lint-stability.rs:84: //~^ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:86: unstable(); //~ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:87: foo.method_unstable(); //~ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:88: Foo::method_unstable(&foo); //~ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:89: ::method_unstable(&foo); //~ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:90: foo.trait_unstable(); //~ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:91: Trait::trait_unstable(&foo); //~ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:92: ::trait_unstable(&foo); //~ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:93: ::trait_unstable(&foo); //~ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:95: unstable_text(); +src/test/compile-fail/lint-stability.rs:96: //~^ ERROR use of unstable library feature 'test_feature': text +src/test/compile-fail/lint-stability.rs:97: foo.method_unstable_text(); +src/test/compile-fail/lint-stability.rs:98: //~^ ERROR use of unstable library feature 'test_feature': text +src/test/compile-fail/lint-stability.rs:99: Foo::method_unstable_text(&foo); +src/test/compile-fail/lint-stability.rs:100: //~^ ERROR use of unstable library feature 'test_feature': text +src/test/compile-fail/lint-stability.rs:101: ::method_unstable_text(&foo); +src/test/compile-fail/lint-stability.rs:102: //~^ ERROR use of unstable library feature 'test_feature': text +src/test/compile-fail/lint-stability.rs:103: foo.trait_unstable_text(); +src/test/compile-fail/lint-stability.rs:104: //~^ ERROR use of unstable library feature 'test_feature': text +src/test/compile-fail/lint-stability.rs:105: Trait::trait_unstable_text(&foo); +src/test/compile-fail/lint-stability.rs:106: //~^ ERROR use of unstable library feature 'test_feature': text +src/test/compile-fail/lint-stability.rs:107: ::trait_unstable_text(&foo); +src/test/compile-fail/lint-stability.rs:108: //~^ ERROR use of unstable library feature 'test_feature': text +src/test/compile-fail/lint-stability.rs:109: ::trait_unstable_text(&foo); +src/test/compile-fail/lint-stability.rs:110: //~^ ERROR use of unstable library feature 'test_feature': text +src/test/compile-fail/lint-stability.rs:112: stable(); +src/test/compile-fail/lint-stability.rs:113: foo.method_stable(); +src/test/compile-fail/lint-stability.rs:114: Foo::method_stable(&foo); +src/test/compile-fail/lint-stability.rs:115: ::method_stable(&foo); +src/test/compile-fail/lint-stability.rs:116: foo.trait_stable(); +src/test/compile-fail/lint-stability.rs:117: Trait::trait_stable(&foo); +src/test/compile-fail/lint-stability.rs:118: ::trait_stable(&foo); +src/test/compile-fail/lint-stability.rs:119: ::trait_stable(&foo); +src/test/compile-fail/lint-stability.rs:121: stable_text(); +src/test/compile-fail/lint-stability.rs:122: foo.method_stable_text(); +src/test/compile-fail/lint-stability.rs:123: Foo::method_stable_text(&foo); +src/test/compile-fail/lint-stability.rs:124: ::method_stable_text(&foo); +src/test/compile-fail/lint-stability.rs:125: foo.trait_stable_text(); +src/test/compile-fail/lint-stability.rs:126: Trait::trait_stable_text(&foo); +src/test/compile-fail/lint-stability.rs:127: ::trait_stable_text(&foo); +src/test/compile-fail/lint-stability.rs:128: ::trait_stable_text(&foo); +src/test/compile-fail/lint-stability.rs:131: let _ = DeprecatedUnstableStruct { +src/test/compile-fail/lint-stability.rs:133: //~^^ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:136: let _ = UnstableStruct { i: 0 }; //~ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:140: let _ = DeprecatedUnstableUnitStruct; //~ ERROR use of deprecated item +src/test/compile-fail/lint-stability.rs:141: //~^ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:142: let _ = UnstableUnitStruct; //~ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:146: let _ = Enum::DeprecatedUnstableVariant; //~ ERROR use of deprecated item +src/test/compile-fail/lint-stability.rs:147: //~^ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:148: let _ = Enum::UnstableVariant; //~ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:152: let _ = DeprecatedUnstableTupleStruct (1); //~ ERROR use of deprecated item +src/test/compile-fail/lint-stability.rs:153: //~^ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:154: let _ = UnstableTupleStruct (1); //~ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:163: macro_test_arg!(deprecated_unstable_text()); //~ ERROR use of deprecated item: text +src/test/compile-fail/lint-stability.rs:164: //~^ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:177: foo.trait_deprecated_unstable(); //~ ERROR use of deprecated item +src/test/compile-fail/lint-stability.rs:178: //~^ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:179: Trait::trait_deprecated_unstable(&foo); //~ ERROR use of deprecated item +src/test/compile-fail/lint-stability.rs:180: //~^ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:181: ::trait_deprecated_unstable(&foo); //~ ERROR use of deprecated item +src/test/compile-fail/lint-stability.rs:182: //~^ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:183: ::trait_deprecated_unstable(&foo); //~ ERROR use of deprecated item +src/test/compile-fail/lint-stability.rs:184: //~^ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:185: foo.trait_deprecated_unstable_text(); //~ ERROR use of deprecated item: text +src/test/compile-fail/lint-stability.rs:186: //~^ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:187: Trait::trait_deprecated_unstable_text(&foo); //~ ERROR use of deprecated item: text +src/test/compile-fail/lint-stability.rs:188: //~^ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:189: ::trait_deprecated_unstable_text(&foo); //~ ERROR use of deprecated item: text +src/test/compile-fail/lint-stability.rs:190: //~^ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:191: ::trait_deprecated_unstable_text(&foo); //~ ERROR use of deprecated item: text +src/test/compile-fail/lint-stability.rs:192: //~^ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:193: foo.trait_unstable(); //~ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:194: Trait::trait_unstable(&foo); //~ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:195: ::trait_unstable(&foo); //~ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:196: ::trait_unstable(&foo); //~ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:197: foo.trait_unstable_text(); +src/test/compile-fail/lint-stability.rs:198: //~^ ERROR use of unstable library feature 'test_feature': text +src/test/compile-fail/lint-stability.rs:199: Trait::trait_unstable_text(&foo); +src/test/compile-fail/lint-stability.rs:200: //~^ ERROR use of unstable library feature 'test_feature': text +src/test/compile-fail/lint-stability.rs:201: ::trait_unstable_text(&foo); +src/test/compile-fail/lint-stability.rs:202: //~^ ERROR use of unstable library feature 'test_feature': text +src/test/compile-fail/lint-stability.rs:203: ::trait_unstable_text(&foo); +src/test/compile-fail/lint-stability.rs:204: //~^ ERROR use of unstable library feature 'test_feature': text +src/test/compile-fail/lint-stability.rs:205: foo.trait_stable(); +src/test/compile-fail/lint-stability.rs:206: Trait::trait_stable(&foo); +src/test/compile-fail/lint-stability.rs:207: ::trait_stable(&foo); +src/test/compile-fail/lint-stability.rs:208: ::trait_stable(&foo); +src/test/compile-fail/lint-stability.rs:214: foo.trait_deprecated_unstable(); //~ ERROR use of deprecated item +src/test/compile-fail/lint-stability.rs:215: //~^ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:216: foo.trait_deprecated_unstable_text(); //~ ERROR use of deprecated item: text +src/test/compile-fail/lint-stability.rs:217: //~^ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:218: foo.trait_unstable(); //~ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:219: foo.trait_unstable_text(); +src/test/compile-fail/lint-stability.rs:220: //~^ ERROR use of unstable library feature 'test_feature': text +src/test/compile-fail/lint-stability.rs:221: foo.trait_stable(); +src/test/compile-fail/lint-stability.rs:226: impl UnstableTrait for S { } //~ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:228: trait LocalTrait : UnstableTrait { } //~ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:231: fn trait_stable(&self) {} +src/test/compile-fail/lint-stability.rs:232: fn trait_unstable(&self) {} //~ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:237: extern crate inherited_stability; //~ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:238: use self::inherited_stability::*; //~ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:241: unstable(); //~ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:242: stable(); +src/test/compile-fail/lint-stability.rs:244: stable_mod::unstable(); //~ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:245: stable_mod::stable(); +src/test/compile-fail/lint-stability.rs:247: unstable_mod::deprecated(); //~ ERROR use of deprecated item +src/test/compile-fail/lint-stability.rs:248: unstable_mod::unstable(); //~ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:250: let _ = Unstable::UnstableVariant; //~ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:251: let _ = Unstable::StableVariant; +src/test/compile-fail/lint-stability.rs:254: x.unstable(); //~ ERROR use of unstable library feature +src/test/compile-fail/lint-stability.rs:255: x.stable(); +src/test/compile-fail/lint-stability.rs:260: #[unstable(feature = "test_feature", issue = "0")] +src/test/compile-fail/lint-stability.rs:263: #[unstable(feature = "test_feature", issue = "0")] +src/test/compile-fail/lint-stability.rs:267: #[unstable(feature = "test_feature", issue = "0")] +src/test/compile-fail/lint-stability.rs:268: pub fn unstable() {} +src/test/compile-fail/lint-stability.rs:269: #[unstable(feature = "test_feature", reason = "text", issue = "0")] +src/test/compile-fail/lint-stability.rs:270: pub fn unstable_text() {} +src/test/compile-fail/lint-stability.rs:272: #[stable(feature = "rust1", since = "1.0.0")] +src/test/compile-fail/lint-stability.rs:273: pub fn stable() {} +src/test/compile-fail/lint-stability.rs:274: #[stable(feature = "rust1", since = "1.0.0", reason = "text")] +src/test/compile-fail/lint-stability.rs:275: pub fn stable_text() {} +src/test/compile-fail/lint-stability.rs:277: #[stable(feature = "rust1", since = "1.0.0")] +src/test/compile-fail/lint-stability.rs:281: #[unstable(feature = "test_feature", issue = "0")] +src/test/compile-fail/lint-stability.rs:284: #[unstable(feature = "test_feature", issue = "0")] +src/test/compile-fail/lint-stability.rs:288: #[unstable(feature = "test_feature", issue = "0")] +src/test/compile-fail/lint-stability.rs:289: pub fn method_unstable(&self) {} +src/test/compile-fail/lint-stability.rs:290: #[unstable(feature = "test_feature", reason = "text", issue = "0")] +src/test/compile-fail/lint-stability.rs:291: pub fn method_unstable_text(&self) {} +src/test/compile-fail/lint-stability.rs:293: #[stable(feature = "rust1", since = "1.0.0")] +src/test/compile-fail/lint-stability.rs:294: pub fn method_stable(&self) {} +src/test/compile-fail/lint-stability.rs:295: #[stable(feature = "rust1", since = "1.0.0", reason = "text")] +src/test/compile-fail/lint-stability.rs:296: pub fn method_stable_text(&self) {} +src/test/compile-fail/lint-stability.rs:300: #[unstable(feature = "test_feature", issue = "0")] +src/test/compile-fail/lint-stability.rs:303: #[unstable(feature = "test_feature", issue = "0")] +src/test/compile-fail/lint-stability.rs:307: #[unstable(feature = "test_feature", issue = "0")] +src/test/compile-fail/lint-stability.rs:308: fn trait_unstable(&self) {} +src/test/compile-fail/lint-stability.rs:309: #[unstable(feature = "test_feature", reason = "text", issue = "0")] +src/test/compile-fail/lint-stability.rs:310: fn trait_unstable_text(&self) {} +src/test/compile-fail/lint-stability.rs:312: #[stable(feature = "rust1", since = "1.0.0")] +src/test/compile-fail/lint-stability.rs:313: fn trait_stable(&self) {} +src/test/compile-fail/lint-stability.rs:314: #[stable(feature = "rust1", since = "1.0.0", reason = "text")] +src/test/compile-fail/lint-stability.rs:315: fn trait_stable_text(&self) {} +src/test/compile-fail/lint-stability.rs:320: #[unstable(feature = "test_feature", issue = "0")] +src/test/compile-fail/lint-stability.rs:323: #[stable(feature = "test_feature", since = "1.0.0")] i: isize +src/test/compile-fail/lint-stability.rs:325: #[unstable(feature = "test_feature", issue = "0")] +src/test/compile-fail/lint-stability.rs:326: pub struct UnstableStruct { +src/test/compile-fail/lint-stability.rs:327: #[stable(feature = "test_feature", since = "1.0.0")] i: isize +src/test/compile-fail/lint-stability.rs:329: #[stable(feature = "rust1", since = "1.0.0")] +src/test/compile-fail/lint-stability.rs:331: #[stable(feature = "test_feature", since = "1.0.0")] i: isize +src/test/compile-fail/lint-stability.rs:334: #[unstable(feature = "test_feature", issue = "0")] +src/test/compile-fail/lint-stability.rs:337: #[unstable(feature = "test_feature", issue = "0")] +src/test/compile-fail/lint-stability.rs:338: pub struct UnstableUnitStruct; +src/test/compile-fail/lint-stability.rs:339: #[stable(feature = "rust1", since = "1.0.0")] +src/test/compile-fail/lint-stability.rs:343: #[unstable(feature = "test_feature", issue = "0")] +src/test/compile-fail/lint-stability.rs:346: #[unstable(feature = "test_feature", issue = "0")] +src/test/compile-fail/lint-stability.rs:347: UnstableVariant, +src/test/compile-fail/lint-stability.rs:349: #[stable(feature = "rust1", since = "1.0.0")] +src/test/compile-fail/lint-stability.rs:353: #[unstable(feature = "test_feature", issue = "0")] +src/test/compile-fail/lint-stability.rs:356: #[unstable(feature = "test_feature", issue = "0")] +src/test/compile-fail/lint-stability.rs:357: pub struct UnstableTupleStruct(isize); +src/test/compile-fail/lint-stability.rs:358: #[stable(feature = "rust1", since = "1.0.0")] +src/test/compile-fail/lint-stability.rs:387: unstable(); +src/test/compile-fail/lint-stability.rs:388: foo.method_unstable(); +src/test/compile-fail/lint-stability.rs:389: Foo::method_unstable(&foo); +src/test/compile-fail/lint-stability.rs:390: ::method_unstable(&foo); +src/test/compile-fail/lint-stability.rs:391: foo.trait_unstable(); +src/test/compile-fail/lint-stability.rs:392: Trait::trait_unstable(&foo); +src/test/compile-fail/lint-stability.rs:393: ::trait_unstable(&foo); +src/test/compile-fail/lint-stability.rs:394: ::trait_unstable(&foo); +src/test/compile-fail/lint-stability.rs:396: unstable_text(); +src/test/compile-fail/lint-stability.rs:397: foo.method_unstable_text(); +src/test/compile-fail/lint-stability.rs:398: Foo::method_unstable_text(&foo); +src/test/compile-fail/lint-stability.rs:399: ::method_unstable_text(&foo); +src/test/compile-fail/lint-stability.rs:400: foo.trait_unstable_text(); +src/test/compile-fail/lint-stability.rs:401: Trait::trait_unstable_text(&foo); +src/test/compile-fail/lint-stability.rs:402: ::trait_unstable_text(&foo); +src/test/compile-fail/lint-stability.rs:403: ::trait_unstable_text(&foo); +src/test/compile-fail/lint-stability.rs:405: stable(); +src/test/compile-fail/lint-stability.rs:406: foo.method_stable(); +src/test/compile-fail/lint-stability.rs:407: Foo::method_stable(&foo); +src/test/compile-fail/lint-stability.rs:408: ::method_stable(&foo); +src/test/compile-fail/lint-stability.rs:409: foo.trait_stable(); +src/test/compile-fail/lint-stability.rs:410: Trait::trait_stable(&foo); +src/test/compile-fail/lint-stability.rs:411: ::trait_stable(&foo); +src/test/compile-fail/lint-stability.rs:412: ::trait_stable(&foo); +src/test/compile-fail/lint-stability.rs:414: stable_text(); +src/test/compile-fail/lint-stability.rs:415: foo.method_stable_text(); +src/test/compile-fail/lint-stability.rs:416: Foo::method_stable_text(&foo); +src/test/compile-fail/lint-stability.rs:417: ::method_stable_text(&foo); +src/test/compile-fail/lint-stability.rs:418: foo.trait_stable_text(); +src/test/compile-fail/lint-stability.rs:419: Trait::trait_stable_text(&foo); +src/test/compile-fail/lint-stability.rs:420: ::trait_stable_text(&foo); +src/test/compile-fail/lint-stability.rs:421: ::trait_stable_text(&foo); +src/test/compile-fail/lint-stability.rs:427: let _ = UnstableStruct { i: 0 }; +src/test/compile-fail/lint-stability.rs:431: let _ = UnstableUnitStruct; +src/test/compile-fail/lint-stability.rs:435: let _ = Enum::UnstableVariant; +src/test/compile-fail/lint-stability.rs:439: let _ = UnstableTupleStruct (1); +src/test/compile-fail/lint-stability.rs:452: foo.trait_unstable(); +src/test/compile-fail/lint-stability.rs:453: Trait::trait_unstable(&foo); +src/test/compile-fail/lint-stability.rs:454: ::trait_unstable(&foo); +src/test/compile-fail/lint-stability.rs:455: ::trait_unstable(&foo); +src/test/compile-fail/lint-stability.rs:456: foo.trait_unstable_text(); +src/test/compile-fail/lint-stability.rs:457: Trait::trait_unstable_text(&foo); +src/test/compile-fail/lint-stability.rs:458: ::trait_unstable_text(&foo); +src/test/compile-fail/lint-stability.rs:459: ::trait_unstable_text(&foo); +src/test/compile-fail/lint-stability.rs:460: foo.trait_stable(); +src/test/compile-fail/lint-stability.rs:461: Trait::trait_stable(&foo); +src/test/compile-fail/lint-stability.rs:462: ::trait_stable(&foo); +src/test/compile-fail/lint-stability.rs:463: ::trait_stable(&foo); +src/test/compile-fail/lint-stability.rs:469: foo.trait_unstable(); +src/test/compile-fail/lint-stability.rs:470: foo.trait_unstable_text(); +src/test/compile-fail/lint-stability.rs:471: foo.trait_stable(); +src/test/compile-fail/lint-stability.rs:474: #[unstable(feature = "test_feature", issue = "0")] +src/test/compile-fail/lint-stability.rs:482: #[unstable(feature = "test_feature", issue = "0")] +src/test/compile-fail/lint-stability.rs:490: #[unstable(feature = "test_feature", issue = "0")] +src/test/compile-fail/log-syntax-gate.rs:12: log_syntax!() //~ ERROR `log_syntax!` is not stable enough +src/test/compile-fail/log-syntax-gate2.rs:12: println!("{}", log_syntax!()); //~ ERROR `log_syntax!` is not stable +src/test/compile-fail/missing-stability.rs:22:#[unstable(feature = "foo", issue = "0")] +src/test/compile-fail/missing-stability.rs:24: // #[unstable] is inherited +src/test/compile-fail/missing-stability.rs:28:#[stable(feature = "bar", since="1.0.0")] +src/test/compile-fail/missing-stability.rs:30: // #[stable] is not inherited +src/test/compile-fail/stability-attribute-issue.rs:19: unstable(); //~ ERROR use of unstable library feature 'foo' (see issue #1) +src/test/compile-fail/stability-attribute-issue.rs:20: unstable_msg(); //~ ERROR use of unstable library feature 'foo': message (see issue #2) +src/test/compile-fail/stability-attribute-non-staged.rs:11:#[unstable] //~ ERROR: stability attributes may not be used +src/test/compile-fail/stability-attribute-non-staged.rs:12:#[stable] //~ ERROR: stability attributes may not be used +src/test/compile-fail/stability-attribute-sanity.rs:17: #[stable(feature = "a", since = "a", reason)] //~ ERROR incorrect meta item +src/test/compile-fail/stability-attribute-sanity.rs:20: #[stable(feature = "a", since, reason = "a")] //~ ERROR incorrect meta item +src/test/compile-fail/stability-attribute-sanity.rs:23: #[stable(feature, since = "a", reason = "a")] //~ ERROR incorrect meta item +src/test/compile-fail/stability-attribute-sanity.rs:26: #[stable(feature = "a", since = "a", reason(b))] //~ ERROR incorrect meta item +src/test/compile-fail/stability-attribute-sanity.rs:29: #[stable(feature = "a", since(b), reason = "a")] //~ ERROR incorrect meta item +src/test/compile-fail/stability-attribute-sanity.rs:32: #[stable(feature(b), since = "a", reason = "a")] //~ ERROR incorrect meta item +src/test/compile-fail/stability-attribute-sanity.rs:37: #[unstable] //~ ERROR incorrect stability attribute type +src/test/compile-fail/stability-attribute-sanity.rs:40: #[unstable = "a"] //~ ERROR incorrect stability attribute type +src/test/compile-fail/stability-attribute-sanity.rs:43: #[stable] //~ ERROR incorrect stability attribute type +src/test/compile-fail/stability-attribute-sanity.rs:46: #[stable = "a"] //~ ERROR incorrect stability attribute type +src/test/compile-fail/stability-attribute-sanity.rs:49: #[stable(feature = "a", since = "b")] +src/test/compile-fail/stability-attribute-sanity.rs:53: #[stable(feature = "a", since = "b")] +src/test/compile-fail/stability-attribute-sanity.rs:59: #[unstable(since = "a", issue = "0")] //~ ERROR missing 'feature' +src/test/compile-fail/stability-attribute-sanity.rs:62: #[unstable(feature = "a")] +src/test/compile-fail/stability-attribute-sanity.rs:65: #[stable(since = "a")] //~ ERROR missing 'feature' +src/test/compile-fail/stability-attribute-sanity.rs:70: #[stable(feature = "a")] //~ ERROR missing 'since' +src/test/compile-fail/stability-attribute-sanity.rs:73: #[stable(feature = "a", since = "b")] +src/test/compile-fail/stability-attribute-sanity.rs:78:#[unstable(feature = "a", since = "b", issue = "0")] +src/test/compile-fail/stability-attribute-sanity.rs:79:#[stable(feature = "a", since = "b")] +src/test/compile-fail/stability-attribute-sanity.rs:82:#[unstable(feature = "a", since = "b", issue = "0")] +src/test/compile-fail/stability-attribute-sanity.rs:83:#[unstable(feature = "a", since = "b", issue = "0")] +src/test/compile-fail/stability-attribute-sanity.rs:86:#[stable(feature = "a", since = "b")] +src/test/compile-fail/stability-attribute-sanity.rs:87:#[stable(feature = "a", since = "b")] +src/test/compile-fail/stability-attribute-sanity.rs:90:#[stable(feature = "a", since = "b")] +src/test/compile-fail/stability-attribute-sanity.rs:97:fn deprecated_without_unstable_or_stable() { } //~ ERROR deprecated attribute must be paired +src/test/compile-fail/stable-features.rs:11:// Testing that the stable_features lint catches use of stable +src/test/compile-fail/stable-features.rs:14:#![deny(stable_features)] +src/test/compile-fail/stable-features.rs:15:#![feature(test_accepted_feature)] //~ ERROR this feature is stable +src/test/compile-fail/stable-features.rs:16:#![feature(rust1)] //~ ERROR this feature is stable +src/test/compile-fail/trace_macros-gate.rs:14: trace_macros!(); //~ ERROR `trace_macros` is not stable +src/test/compile-fail/trace_macros-gate.rs:15: trace_macros!(1); //~ ERROR `trace_macros` is not stable +src/test/compile-fail/trace_macros-gate.rs:16: trace_macros!(ident); //~ ERROR `trace_macros` is not stable +src/test/compile-fail/trace_macros-gate.rs:17: trace_macros!(for); //~ ERROR `trace_macros` is not stable +src/test/compile-fail/trace_macros-gate.rs:18: trace_macros!(true,); //~ ERROR `trace_macros` is not stable +src/test/compile-fail/trace_macros-gate.rs:19: trace_macros!(false 1); //~ ERROR `trace_macros` is not stable +src/test/compile-fail/trace_macros-gate2.rs:19: expando!(true); //~ ERROR `trace_macros` is not stable +src/test/compile-fail/trace_macros-gate3.rs:14: println!("arg: {}", trace_macros!()); //~ ERROR `trace_macros` is not stable +src/test/compile-fail/trace_macros-gate3.rs:15: println!("arg: {}", trace_macros!(1)); //~ ERROR `trace_macros` is not stable +src/test/compile-fail/trace_macros-gate3.rs:16: println!("arg: {}", trace_macros!(ident)); //~ ERROR `trace_macros` is not stable +src/test/compile-fail/trace_macros-gate3.rs:17: println!("arg: {}", trace_macros!(for)); //~ ERROR `trace_macros` is not stable +src/test/compile-fail/trace_macros-gate3.rs:18: println!("arg: {}", trace_macros!(true,)); //~ ERROR `trace_macros` is not stable +src/test/compile-fail/trace_macros-gate3.rs:19: println!("arg: {}", trace_macros!(false 1)); //~ ERROR `trace_macros` is not stable +src/test/compile-fail/unboxed-closure-feature-gate.rs:24: //~^ ERROR parenthetical notation is only stable when used with `Fn`-family +src/test/compile-fail/unsafe_no_drop_flag-gate.rs:14://~^ ERROR unsafe_no_drop_flag has unstable semantics and may be removed +src/test/parse-fail/issue-20711-2.rs:18: #[stable(feature = "rust1", since = "1.0.0")] +src/test/parse-fail/issue-20711.rs:16: #[stable(feature = "rust1", since = "1.0.0")] +src/test/run-fail-fulldeps/qquote.rs:35: allow_internal_unstable: false, +src/test/run-make/allow-warnings-cmdline-stability/bar.rs:14:#![unstable(feature = "test_feature", issue = "0")] +src/test/run-make/graphviz-flowgraph/Makefile:16:LASTBLOCKNUM_$(1) := $(shell $(RUSTC_LIB) -Z unstable-options --pretty=expanded,identified $(1) \ +src/test/run-make/graphviz-flowgraph/Makefile:31: $(RUSTC_LIB) -Z unstable-options --unpretty flowgraph,unlabelled=$(LASTBLOCKNUM_$<) $< -o $@.tmp +src/test/run-make/pretty-expanded-hygiene/Makefile:6: $(RUSTC) -o $(TMPDIR)/input.out -Z unstable-options \ +src/test/run-make/pretty-expanded/Makefile:4: $(RUSTC) -o $(TMPDIR)/input.expanded.rs -Z unstable-options \ +src/test/run-make/pretty-print-path-suffix/Makefile:4: $(RUSTC) -o $(TMPDIR)/foo.out -Z unstable-options --unpretty hir=foo input.rs +src/test/run-make/pretty-print-path-suffix/Makefile:5: $(RUSTC) -o $(TMPDIR)/nest_foo.out -Z unstable-options --unpretty hir=nest::foo input.rs +src/test/run-make/pretty-print-path-suffix/Makefile:6: $(RUSTC) -o $(TMPDIR)/foo_method.out -Z unstable-options --unpretty hir=foo_method input.rs +src/test/run-make/pretty-print-to-file/Makefile:4: $(RUSTC) -o $(TMPDIR)/input.out --pretty=normal -Z unstable-options input.rs +src/test/run-pass-fulldeps/qquote.rs:32: allow_internal_unstable: false, +src/test/run-pass/dropck_tarena_sound_drop.rs:19:#![allow(unstable)] +src/test/run-pass/issue-20823.rs:14:#![deny(unstable)] +src/test/run-pass/minmax-stability-issue-23687.rs:58: assert_stable(&presorted); +src/test/run-pass/minmax-stability-issue-23687.rs:62: assert_stable(&presorted); +src/test/run-pass/minmax-stability-issue-23687.rs:65: fn assert_stable(presorted: &[T]) { +src/test/rustdoc/issue-27759.rs:15:// @has issue_27759/unstable/index.html +src/test/rustdoc/issue-27759.rs:18:#[unstable(feature="test", issue="27759")] +src/test/rustdoc/issue-27759.rs:19:pub mod unstable { +src/test/rustdoc/issue-27759.rs:20: // @has issue_27759/unstable/fn.issue.html +src/test/rustdoc/issue-27759.rs:23: #[unstable(feature="test_function", issue="1234567890")] From 8d9b230cf6c1e29508530c9f94e74545400def54 Mon Sep 17 00:00:00 2001 From: Eric Findlay Date: Tue, 13 Oct 2015 12:39:30 +0900 Subject: [PATCH 04/94] Deleted links_nightly and links_stable and added links --- links | 35 + links_nightly | 165 -- links_stable | 4777 ------------------------------------------------- 3 files changed, 35 insertions(+), 4942 deletions(-) create mode 100644 links delete mode 100644 links_nightly delete mode 100644 links_stable diff --git a/links b/links new file mode 100644 index 000000000..dbfccc91c --- /dev/null +++ b/links @@ -0,0 +1,35 @@ +CONTRIBUTING.md:133:Documentation improvements are very welcome. The source of `doc.rust-lang.org` +CONTRIBUTING.md:238:[gsearchdocs]: https://www.google.de/search?q=site:doc.rust-lang.org+your+query+here +src/doc/not_found.md:51: search.value = op.join(' ') + " site:doc.rust-lang.org"; +src/doc/trpl/documentation.md:557: html_root_url = "https://doc.rust-lang.org/")] +src/liballoc/lib.rs:71: html_root_url = "https://doc.rust-lang.org/nightly/", +src/libarena/lib.rs:31: html_root_url = "https://doc.rust-lang.org/nightly/")] +src/libcollections/lib.rs:27: html_root_url = "https://doc.rust-lang.org/nightly/", +src/libcore/lib.rs:60: html_root_url = "https://doc.rust-lang.org/nightly/", +src/libflate/lib.rs:26: html_root_url = "https://doc.rust-lang.org/nightly/")] +src/libfmt_macros/lib.rs:26: html_root_url = "https://doc.rust-lang.org/nightly/", +src/libgetopts/lib.rs:90: html_root_url = "https://doc.rust-lang.org/nightly/", +src/libgraphviz/lib.rs:286: html_root_url = "https://doc.rust-lang.org/nightly/")] +src/liblibc/lib.rs:23: html_root_url = "https://doc.rust-lang.org/nightly/", +src/liblog/lib.rs:169: html_root_url = "https://doc.rust-lang.org/nightly/", +src/librand/lib.rs:25: html_root_url = "https://doc.rust-lang.org/nightly/", +src/librbml/lib.rs:123: html_root_url = "https://doc.rust-lang.org/nightly/", +src/librustc/lib.rs:26: html_root_url = "https://doc.rust-lang.org/nightly/")] +src/librustc_back/lib.rs:33: html_root_url = "https://doc.rust-lang.org/nightly/")] +src/librustc_borrowck/lib.rs:20: html_root_url = "https://doc.rust-lang.org/nightly/")] +src/librustc_data_structures/lib.rs:28: html_root_url = "https://doc.rust-lang.org/nightly/")] +src/librustc_driver/lib.rs:26: html_root_url = "https://doc.rust-lang.org/nightly/")] +src/librustc_front/lib.rs:26: html_root_url = "http://doc.rust-lang.org/nightly/")] +src/librustc_lint/lib.rs:31: html_root_url = "https://doc.rust-lang.org/nightly/")] +src/librustc_llvm/lib.rs:26: html_root_url = "https://doc.rust-lang.org/nightly/")] +src/librustc_privacy/lib.rs:20: html_root_url = "https://doc.rust-lang.org/nightly/")] +src/librustc_resolve/lib.rs:20: html_root_url = "https://doc.rust-lang.org/nightly/")] +src/librustc_trans/lib.rs:26: html_root_url = "https://doc.rust-lang.org/nightly/")] +src/librustc_typeck/lib.rs:74: html_root_url = "https://doc.rust-lang.org/nightly/")] +src/librustc_unicode/lib.rs:31: html_root_url = "https://doc.rust-lang.org/nightly/", +src/librustdoc/lib.rs:20: html_root_url = "https://doc.rust-lang.org/nightly/", +src/libserialize/lib.rs:28: html_root_url = "https://doc.rust-lang.org/nightly/", +src/libstd/lib.rs:196: html_root_url = "https://doc.rust-lang.org/nightly/", +src/libsyntax/lib.rs:26: html_root_url = "https://doc.rust-lang.org/nightly/")] +src/libterm/lib.rs:55: html_root_url = "https://doc.rust-lang.org/nightly/", +src/libtest/lib.rs:35: html_root_url = "https://doc.rust-lang.org/nightly/")] diff --git a/links_nightly b/links_nightly deleted file mode 100644 index d41914eaf..000000000 --- a/links_nightly +++ /dev/null @@ -1,165 +0,0 @@ -RELEASES.md:132:[`Any`]: http://doc.rust-lang.org/nightly/std/any/trait.Any.html -RELEASES.md:133:[`AtomicPtr`]: http://doc.rust-lang.org/nightly/std/sync/atomic/struct.AtomicPtr.html -RELEASES.md:134:[`Borrow`]: http://doc.rust-lang.org/nightly/std/borrow/trait.Borrow.html -RELEASES.md:135:[`CStr`]: http://doc.rust-lang.org/nightly/std/ffi/struct.CStr.html -RELEASES.md:136:[`CString`]: http://doc.rust-lang.org/nightly/std/ffi/struct.CString.html -RELEASES.md:137:[`Debug`]: http://doc.rust-lang.org/nightly/std/fmt/trait.Debug.html -RELEASES.md:138:[`DerefMut`]: http://doc.rust-lang.org/nightly/std/ops/trait.DerefMut.html -RELEASES.md:139:[`Deref`]: http://doc.rust-lang.org/nightly/std/ops/trait.Deref.html -RELEASES.md:140:[`Div`]: http://doc.rust-lang.org/nightly/std/ops/trait.Div.html -RELEASES.md:141:[`Duration`]: http://doc.rust-lang.org/nightly/std/time/struct.Duration.html -RELEASES.md:142:[`Error`]: http://doc.rust-lang.org/nightly/std/error/trait.Error.html -RELEASES.md:143:[`File`]: http://doc.rust-lang.org/nightly/std/fs/struct.File.html -RELEASES.md:144:[`Hash`]: http://doc.rust-lang.org/nightly/std/hash/trait.Hash.html -RELEASES.md:145:[`Hasher`]: http://doc.rust-lang.org/nightly/std/hash/trait.Hasher.html -RELEASES.md:146:[`Send`]: http://doc.rust-lang.org/nightly/std/marker/trait.Send.html -RELEASES.md:147:[`SliceConcatExt`]: http://doc.rust-lang.org/nightly/std/slice/trait.SliceConcatExt.html -RELEASES.md:148:[`Stdin`]: http://doc.rust-lang.org/nightly/std/io/struct.Stdin.html -RELEASES.md:149:[`ToOwned`]: http://doc.rust-lang.org/nightly/std/borrow/trait.ToOwned.html -RELEASES.md:150:[`Wrapping`]: http://doc.rust-lang.org/nightly/std/num/struct.Wrapping.html -RELEASES.md:151:[`connect`]: http://doc.rust-lang.org/nightly/std/slice/trait.SliceConcatExt.html#method.connect -RELEASES.md:152:[`downcast_mut`]: http://doc.rust-lang.org/nightly/std/error/trait.Error.html#method.downcast_mut -RELEASES.md:153:[`downcast_ref`]: http://doc.rust-lang.org/nightly/std/error/trait.Error.html#method.downcast_ref -RELEASES.md:154:[`downcast`]: http://doc.rust-lang.org/nightly/std/error/trait.Error.html#method.downcast -RELEASES.md:155:[`hash_slice`]: http://doc.rust-lang.org/nightly/std/hash/trait.Hash.html#method.hash_slice -RELEASES.md:156:[`id`]: http://doc.rust-lang.org/nightly/std/process/struct.Child.html#method.id -RELEASES.md:157:[`is`]: http://doc.rust-lang.org/nightly/std/error/trait.Error.html#method.is -RELEASES.md:158:[`join`]: http://doc.rust-lang.org/nightly/std/slice/trait.SliceConcatExt.html#method.join -RELEASES.md:159:[`read_to_end`]: http://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.read_to_end -RELEASES.md:166:[dst1]: http://doc.rust-lang.org/nightly/std/mem/fn.size_of_val.html -RELEASES.md:167:[dst2]: http://doc.rust-lang.org/nightly/std/mem/fn.align_of_val.html -RELEASES.md:173:[hs]: http://doc.rust-lang.org/nightly/std/hash/trait.Hash.html#method.hash_slice -RELEASES.md:174:[ie]: http://doc.rust-lang.org/nightly/std/io/struct.Error.html -RELEASES.md:175:[iec]: http://doc.rust-lang.org/nightly/std/io/struct.Error.html#method.cause -RELEASES.md:176:[iegm]: http://doc.rust-lang.org/nightly/std/io/struct.Error.html#method.get_mut -RELEASES.md:177:[iegr]: http://doc.rust-lang.org/nightly/std/io/struct.Error.html#method.get_ref -RELEASES.md:178:[ieii]: http://doc.rust-lang.org/nightly/std/io/struct.Error.html#method.into_inner -RELEASES.md:187:[nom]: http://doc.rust-lang.org/nightly/nomicon/ -RELEASES.md:188:[pc]: http://doc.rust-lang.org/nightly/std/process/struct.Child.html -RELEASES.md:192:[sc]: http://doc.rust-lang.org/nightly/std/primitive.str.html#method.contains -RELEASES.md:194:[sew]: http://doc.rust-lang.org/nightly/std/primitive.str.html#method.ends_with -RELEASES.md:195:[sf]: http://doc.rust-lang.org/nightly/std/primitive.str.html#method.find -RELEASES.md:197:[srf]: http://doc.rust-lang.org/nightly/std/primitive.str.html#method.rfind -RELEASES.md:198:[ss]: http://doc.rust-lang.org/nightly/std/primitive.str.html#method.split -RELEASES.md:199:[ssw]: http://doc.rust-lang.org/nightly/std/primitive.str.html#method.starts_with -RELEASES.md:311:[`Extend`]: https://doc.rust-lang.org/nightly/std/iter/trait.Extend.html -RELEASES.md:313:[`iter::once`]: https://doc.rust-lang.org/nightly/std/iter/fn.once.html -RELEASES.md:314:[`iter::empty`]: https://doc.rust-lang.org/nightly/std/iter/fn.empty.html -RELEASES.md:315:[`matches`]: https://doc.rust-lang.org/nightly/std/primitive.str.html#method.matches -RELEASES.md:316:[`rmatches`]: https://doc.rust-lang.org/nightly/std/primitive.str.html#method.rmatches -RELEASES.md:317:[`Cell`]: https://doc.rust-lang.org/nightly/std/cell/struct.Cell.html -RELEASES.md:318:[`RefCell`]: https://doc.rust-lang.org/nightly/std/cell/struct.RefCell.html -RELEASES.md:319:[`wrapping_add`]: https://doc.rust-lang.org/nightly/std/primitive.i8.html#method.wrapping_add -RELEASES.md:320:[`wrapping_sub`]: https://doc.rust-lang.org/nightly/std/primitive.i8.html#method.wrapping_sub -RELEASES.md:321:[`wrapping_mul`]: https://doc.rust-lang.org/nightly/std/primitive.i8.html#method.wrapping_mul -RELEASES.md:322:[`wrapping_div`]: https://doc.rust-lang.org/nightly/std/primitive.i8.html#method.wrapping_div -RELEASES.md:323:[`wrapping_rem`]: https://doc.rust-lang.org/nightly/std/primitive.i8.html#method.wrapping_rem -RELEASES.md:324:[`wrapping_neg`]: https://doc.rust-lang.org/nightly/std/primitive.i8.html#method.wrapping_neg -RELEASES.md:325:[`wrapping_shl`]: https://doc.rust-lang.org/nightly/std/primitive.i8.html#method.wrapping_shl -RELEASES.md:326:[`wrapping_shr`]: https://doc.rust-lang.org/nightly/std/primitive.i8.html#method.wrapping_shr -RELEASES.md:327:[`Wrapping`]: https://doc.rust-lang.org/nightly/std/num/struct.Wrapping.html -RELEASES.md:328:[`fmt::Formatter`]: https://doc.rust-lang.org/nightly/std/fmt/struct.Formatter.html -RELEASES.md:329:[`fmt::Write`]: https://doc.rust-lang.org/nightly/std/fmt/trait.Write.html -RELEASES.md:330:[`io::Write`]: https://doc.rust-lang.org/nightly/std/io/trait.Write.html -RELEASES.md:331:[`debug_struct`]: https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html#method.debug_struct -RELEASES.md:332:[`debug_tuple`]: https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html#method.debug_tuple -RELEASES.md:333:[`debug_list`]: https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html#method.debug_list -RELEASES.md:334:[`debug_set`]: https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html#method.debug_set -RELEASES.md:335:[`debug_map`]: https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html#method.debug_map -RELEASES.md:336:[`Debug`]: https://doc.rust-lang.org/nightly/std/fmt/trait.Debug.html -RELEASES.md:337:[strup]: https://doc.rust-lang.org/nightly/std/primitive.str.html#method.to_uppercase -RELEASES.md:338:[strlow]: https://doc.rust-lang.org/nightly/std/primitive.str.html#method.to_lowercase -RELEASES.md:339:[`to_uppercase`]: https://doc.rust-lang.org/nightly/std/primitive.char.html#method.to_uppercase -RELEASES.md:340:[`to_lowercase`]: https://doc.rust-lang.org/nightly/std/primitive.char.html#method.to_lowercase -RELEASES.md:341:[`PoisonError`]: https://doc.rust-lang.org/nightly/std/sync/struct.PoisonError.html -RELEASES.md:342:[`RwLock`]: https://doc.rust-lang.org/nightly/std/sync/struct.RwLock.html -RELEASES.md:343:[`Mutex`]: https://doc.rust-lang.org/nightly/std/sync/struct.Mutex.html -RELEASES.md:344:[`FromRawFd`]: https://doc.rust-lang.org/nightly/std/os/unix/io/trait.FromRawFd.html -RELEASES.md:345:[`AsRawFd`]: https://doc.rust-lang.org/nightly/std/os/unix/io/trait.AsRawFd.html -RELEASES.md:346:[`Stdio`]: https://doc.rust-lang.org/nightly/std/process/struct.Stdio.html -RELEASES.md:347:[`ChildStdin`]: https://doc.rust-lang.org/nightly/std/process/struct.ChildStdin.html -RELEASES.md:348:[`ChildStdout`]: https://doc.rust-lang.org/nightly/std/process/struct.ChildStdout.html -RELEASES.md:349:[`ChildStderr`]: https://doc.rust-lang.org/nightly/std/process/struct.ChildStderr.html -RELEASES.md:350:[`io::ErrorKind`]: https://doc.rust-lang.org/nightly/std/io/enum.ErrorKind.html -RELEASES.md:352:[`DerefMut`]: https://doc.rust-lang.org/nightly/std/ops/trait.DerefMut.html -RELEASES.md:353:[`mem::align_of`]: https://doc.rust-lang.org/nightly/std/mem/fn.align_of.html -RELEASES.md:355:[`mem::min_align_of`]: https://doc.rust-lang.org/nightly/std/mem/fn.min_align_of.html -RELEASES.md:446:[`str::split_whitespace`]: https://doc.rust-lang.org/nightly/std/primitive.str.html#method.split_whitespace -RELEASES.md:447:[`FromRawFd`]: https://doc.rust-lang.org/nightly/std/os/unix/io/trait.FromRawFd.html -RELEASES.md:448:[`AsRawFd`]: https://doc.rust-lang.org/nightly/std/os/unix/io/trait.AsRawFd.html -RELEASES.md:449:[`std::os::unix::symlink`]: https://doc.rust-lang.org/nightly/std/os/unix/fs/fn.symlink.html -RELEASES.md:450:[`IntoIterator`]: https://doc.rust-lang.org/nightly/std/iter/trait.IntoIterator.html -RELEASES.md:451:[`From`]: https://doc.rust-lang.org/nightly/std/convert/trait.From.html -RELEASES.md:467:[`Cloned`]: https://doc.rust-lang.org/nightly/std/iter/struct.Cloned.html -RELEASES.md:468:[`Incoming`]: https://doc.rust-lang.org/nightly/std/net/struct.Incoming.html -RELEASES.md:471:[`BinaryHeap`]: https://doc.rust-lang.org/nightly/std/collections/struct.BinaryHeap.html -RELEASES.md:473:[`split_off`]: https://doc.rust-lang.org/nightly/collections/linked_list/struct.LinkedList.html#method.split_off -configure:674: nightly ) -configure:681: err "release channel must be 'dev', 'nightly', 'beta' or 'stable'" -mk/main.mk:28:# This is the normal semver version string, e.g. "0.12.0", "0.12.0-nightly" -mk/main.mk:30:# This is the string used in dist artifact file names, e.g. "0.12.0", "nightly" -mk/main.mk:43:ifeq ($(CFG_RELEASE_CHANNEL),nightly) -mk/main.mk:44:CFG_RELEASE=$(CFG_RELEASE_NUM)-nightly -mk/main.mk:45:# When building nightly distributables just reuse the same "nightly" name -mk/main.mk:49:CFG_PACKAGE_VERS=nightly -src/doc/nomicon/vec.md:5:project will only work on nightly (as of Rust 1.2.0). With the exception of the -src/doc/trpl/README.md:33:[nr]: nightly-rust.html -src/doc/trpl/SUMMARY.md:60:* [Nightly Rust](nightly-rust.md) -src/doc/trpl/documentation.md:79:[rc-new]: https://doc.rust-lang.org/nightly/std/rc/struct.Rc.html#method.new -src/doc/trpl/nightly-rust.md:3:Rust provides three distribution channels for Rust: nightly, beta, and stable. -src/doc/trpl/nightly-rust.md:4:Unstable features are only available on nightly Rust. For more details on this -src/doc/trpl/nightly-rust.md:9:To install nightly Rust, you can use `rustup.sh`: -src/doc/trpl/nightly-rust.md:12:$ curl -s https://static.rust-lang.org/rustup.sh | sh -s -- --channel=nightly -src/doc/trpl/nightly-rust.md:21:$ sh rustup.sh --channel=nightly -src/doc/trpl/nightly-rust.md:29:[win32]: https://static.rust-lang.org/dist/rust-nightly-i686-pc-windows-gnu.msi -src/doc/trpl/nightly-rust.md:30:[win64]: https://static.rust-lang.org/dist/rust-nightly-x86_64-pc-windows-gnu.msi -src/doc/trpl/nightly-rust.md:80:rustc 1.0.0-nightly (f11f3e7ba 2015-01-04) (built 2015-01-06) -src/doc/trpl/release-channels.md:15:New nightly releases are created once a day. Every six weeks, the latest -src/doc/trpl/release-channels.md:16:nightly release is promoted to ‘Beta’. At that point, it will only receive -src/doc/trpl/release-channels.md:21:nightly goes to beta, beta goes to stable. When `1.x` is released, at -src/doc/trpl/release-channels.md:22:the same time, `1.(x + 1)-beta` is released, and the nightly becomes the -src/doc/trpl/release-channels.md:23:first version of `1.(x + 2)-nightly`. -src/doc/trpl/release-channels.md:30:However, depending on your interest in Rust, you may choose to use nightly -src/doc/trpl/release-channels.md:31:instead. The basic tradeoff is this: in the nightly channel, you can use -src/doc/trpl/release-channels.md:33:and so any new nightly release may break your code. If you use the stable -src/doc/trpl/release-channels.md:43:Additionally, testing against nightly can catch regressions even sooner, and so -src/doc/trpl/release-channels.md:54: - nightly -src/doc/trpl/release-channels.md:60: - rust: nightly -src/doc/trpl/release-channels.md:66:breaks on nightly, it won’t fail your build. A similar configuration is -src/liballoc/lib.rs:71: html_root_url = "https://doc.rust-lang.org/nightly/", -src/libarena/lib.rs:31: html_root_url = "https://doc.rust-lang.org/nightly/")] -src/libcollections/lib.rs:27: html_root_url = "https://doc.rust-lang.org/nightly/", -src/libcore/lib.rs:60: html_root_url = "https://doc.rust-lang.org/nightly/", -src/libflate/lib.rs:26: html_root_url = "https://doc.rust-lang.org/nightly/")] -src/libfmt_macros/lib.rs:26: html_root_url = "https://doc.rust-lang.org/nightly/", -src/libgetopts/lib.rs:90: html_root_url = "https://doc.rust-lang.org/nightly/", -src/libgraphviz/lib.rs:286: html_root_url = "https://doc.rust-lang.org/nightly/")] -src/liblibc/lib.rs:23: html_root_url = "https://doc.rust-lang.org/nightly/", -src/liblog/lib.rs:169: html_root_url = "https://doc.rust-lang.org/nightly/", -src/librand/lib.rs:25: html_root_url = "https://doc.rust-lang.org/nightly/", -src/librbml/lib.rs:123: html_root_url = "https://doc.rust-lang.org/nightly/", -src/librustc/diagnostics.rs:305:available on a nightly compiler. Rust currently does not support more general -src/librustc/lib.rs:26: html_root_url = "https://doc.rust-lang.org/nightly/")] -src/librustc/middle/check_const.rs:724: evaluation is available on a nightly \ -src/librustc_back/lib.rs:33: html_root_url = "https://doc.rust-lang.org/nightly/")] -src/librustc_borrowck/lib.rs:20: html_root_url = "https://doc.rust-lang.org/nightly/")] -src/librustc_data_structures/lib.rs:28: html_root_url = "https://doc.rust-lang.org/nightly/")] -src/librustc_driver/lib.rs:26: html_root_url = "https://doc.rust-lang.org/nightly/")] -src/librustc_front/lib.rs:26: html_root_url = "http://doc.rust-lang.org/nightly/")] -src/librustc_lint/lib.rs:31: html_root_url = "https://doc.rust-lang.org/nightly/")] -src/librustc_llvm/lib.rs:26: html_root_url = "https://doc.rust-lang.org/nightly/")] -src/librustc_privacy/lib.rs:20: html_root_url = "https://doc.rust-lang.org/nightly/")] -src/librustc_resolve/lib.rs:20: html_root_url = "https://doc.rust-lang.org/nightly/")] -src/librustc_trans/lib.rs:26: html_root_url = "https://doc.rust-lang.org/nightly/")] -src/librustc_typeck/check/mod.rs:1603: // NOTE: @jroesch this is hack that appears to be fixed on nightly, will monitor if -src/librustc_typeck/diagnostics.rs:1425:[book-le]: https://doc.rust-lang.org/nightly/book/lifetimes.html#lifetime-elision -src/librustc_typeck/lib.rs:74: html_root_url = "https://doc.rust-lang.org/nightly/")] -src/librustc_unicode/lib.rs:31: html_root_url = "https://doc.rust-lang.org/nightly/", -src/librustdoc/html/static/playpen.js:38: channel = '&version=nightly'; -src/librustdoc/lib.rs:20: html_root_url = "https://doc.rust-lang.org/nightly/", -src/libserialize/lib.rs:28: html_root_url = "https://doc.rust-lang.org/nightly/", -src/libstd/lib.rs:196: html_root_url = "https://doc.rust-lang.org/nightly/", -src/libsyntax/feature_gate.rs:1105: /// Allow features to me activated, as on nightly. -src/libsyntax/lib.rs:26: html_root_url = "https://doc.rust-lang.org/nightly/")] -src/libterm/lib.rs:55: html_root_url = "https://doc.rust-lang.org/nightly/", -src/libtest/lib.rs:35: html_root_url = "https://doc.rust-lang.org/nightly/")] diff --git a/links_stable b/links_stable deleted file mode 100644 index fb51cd3ae..000000000 --- a/links_stable +++ /dev/null @@ -1,4777 +0,0 @@ -RELEASES.md:90: [`join`] method (note that both of these are on the *unstable* -RELEASES.md:92: available to stable code anyway). -RELEASES.md:418:* The [`Cloned`] iterator, which was accidentally left unstable for -RELEASES.md:484:* The vast majority of the standard library is now `#[stable]`. It is -RELEASES.md:485: no longer possible to use unstable features with a stable build of -RELEASES.md:487:* Many popular crates on [crates.io] now work on the stable release -RELEASES.md:559:* The new path and IO modules are complete and `#[stable]`. This -RELEASES.md:565: is now stable. -RELEASES.md:648: so use of unstable libraries now requires a `#![feature(...)]` -RELEASES.md:746: been declared 'stable'. Those interfaces are unlikely to change -RELEASES.md:809: * `macro_rules!` [has been declared stable][mac]. Though it is a -RELEASES.md:1558: `std::unstable::simd`. -RELEASES.md:1619: * std: More complete atomic types in `unstable::atomics`. -RELEASES.md:1743: * std: Various atomic types added to `unstable::atomic`. -configure:678: dev | beta | stable) -configure:681: err "release channel must be 'dev', 'nightly', 'beta' or 'stable'" -configure:710:# A magic value that allows the compiler to use unstable features -configure:713:# warnings-as-errors and unstable features default to warnings. The -configure:715:# deterrent from users just turning on unstable features on the stable -mk/main.mk:27:ifeq ($(CFG_RELEASE_CHANNEL),stable) -mk/main.mk:347:CFG_INFO := $(info cfg: disabling unstable features (CFG_DISABLE_UNSTABLE_FEATURES)) -mk/main.mk:350:# Subvert unstable feature lints to do the self-build -src/compiletest/runtest.rs:270: "-Zunstable-options".to_owned(), -src/doc/nomicon/borrow-splitting.md:287:All of these are completely safe and work on stable Rust! This ultimately -src/doc/nomicon/destructors.md:20:**There is no stable way to prevent this behavior in Rust 1.0.** -src/doc/nomicon/hrtb.md:67:(Where `Fn(a, b, c) -> d` is itself just sugar for the unstable *real* `Fn` -src/doc/nomicon/unbounded-lifetimes.md:36:these are unstable due to their awkward nature and questionable utility. -src/doc/nomicon/unwinding.md:29:killed in the name of heavy-weight OS threads. Still, on stable Rust as of 1.0 -src/doc/nomicon/unwinding.md:34:There is an unstable API called `catch_panic` that enables catching a panic -src/doc/nomicon/vec-alloc.md:16:All of the `heap` API is totally unstable under the `heap_api` feature, though. -src/doc/nomicon/vec-layout.md:27:`*mut T` when we have a raw pointer to an allocation we own. Unique is unstable, -src/doc/nomicon/vec-layout.md:39:one in stable Rust: -src/doc/nomicon/vec-layout.md:75:unstable and unlikely to be stabilized soon. As such we're just going to -src/doc/nomicon/vec-layout.md:94:stable code. However we will be designing the rest of the code around enabling -src/doc/nomicon/vec-layout.md:96:putting `null` inside of it is Undefined Behaviour. Our stable Unique doesn't -src/doc/nomicon/vec.md:4:Because all the best tools for writing unsafe code are unstable, this -src/doc/nomicon/vec.md:6:allocator API, much of the unstable code we'll use is expected to be stabilized -src/doc/nomicon/vec.md:9:However we will generally try to avoid unstable code where possible. In -src/doc/nomicon/vec.md:11:bit nicer or efficient because intrinsics are permanently unstable. Although -src/doc/reference.md:519: for compiler plugins is considered highly unstable. -src/doc/reference.md:1186:be stable. -src/doc/reference.md:2114:The set of language items is currently considered unstable. A complete -src/doc/reference.md:2170:quality" or "almost production ready", but may not be stable enough to be -src/doc/reference.md:2189: are still unstable. -src/doc/reference.md:2192: completely unstable. -src/doc/reference.md:2226: are inherently unstable and no promise about them is made. -src/doc/reference.md:2229: lang items are inherently unstable and no promise about them -src/doc/reference.md:2261: `extern crate std`. This typically requires use of the unstable APIs -src/doc/reference.md:2295: crate. Stability markers are also attributes: `#[stable]`, -src/doc/reference.md:2296: `#[unstable]`, and `#[deprecated]` are the three levels. -src/doc/reference.md:2310: and should be seen as unstable. This attribute is used to -src/doc/reference.md:2337:* `allow_internal_unstable` - Allows `macro_rules!` macros to be tagged with the -src/doc/reference.md:2338: `#[allow_internal_unstable]` attribute, designed -src/doc/reference.md:2340: `#[unstable]`/feature-gated functionality -src/doc/rust.css:351:.unstable-feature { -src/doc/style/errors/ergonomics.md:60:[the `result` module documentation](https://doc.rust-lang.org/stable/std/result/index.html#the-try-macro) -src/doc/style/errors/signaling.md:97:[`Result` type](https://doc.rust-lang.org/stable/std/result/index.html) -src/doc/style/features/functions-and-methods/input.md:127:(From the [Read trait](https://doc.rust-lang.org/stable/std/io/trait.Read.html#tymethod.read).) -src/doc/style/ownership/builders.md:35:[`std::process::Command`](https://doc.rust-lang.org/stable/std/process/struct.Command.html) -src/doc/trpl/README.md:25:* [Nightly Rust][nr] - Cutting-edge features that aren’t in stable builds yet. -src/doc/trpl/benchmark-tests.md:32:Note the `test` feature gate, which enables this unstable feature. -src/doc/trpl/box-syntax-and-patterns.md:3:Currently the only stable way to create a `Box` is via the `Box::new` method. -src/doc/trpl/box-syntax-and-patterns.md:4:Also it is not possible in stable Rust to destructure a `Box` in a match -src/doc/trpl/box-syntax-and-patterns.md:5:pattern. The unstable `box` keyword can be used to both create and destructure -src/doc/trpl/intrinsics.md:3:> **Note**: intrinsics will forever have an unstable interface, it is -src/doc/trpl/intrinsics.md:4:> recommended to use the stable interfaces of libcore rather than intrinsics -src/doc/trpl/lang-items.md:4:> and lang items themselves have an unstable interface. It is recommended to use -src/doc/trpl/macros.md:418:they are unstable and require feature gates. -src/doc/trpl/macros.md:770:macros, this is significantly more work, the interfaces are much less stable, -src/doc/trpl/nightly-rust.md:3:Rust provides three distribution channels for Rust: nightly, beta, and stable. -src/doc/trpl/nightly-rust.md:4:Unstable features are only available on nightly Rust. For more details on this -src/doc/trpl/no-stdlib.md:81:> **Note**: the core library's structure is unstable, and it is recommended to -src/doc/trpl/release-channels.md:21:nightly goes to beta, beta goes to stable. When `1.x` is released, at -src/doc/trpl/release-channels.md:28:stable release channel. These releases are intended for a general audience. -src/doc/trpl/release-channels.md:32:unstable, new Rust features. However, unstable features are subject to change, -src/doc/trpl/release-channels.md:33:and so any new nightly release may break your code. If you use the stable -src/doc/trpl/release-channels.md:39:What about beta? We encourage all Rust users who use the stable release channel -src/doc/trpl/release-channels.md:56: - stable -src/etc/featureck.py:14:# * That no features are both stable and unstable. -src/etc/featureck.py:17:# * That features that exist in both lang and lib and are stable -src/etc/featureck.py:94: if "[unstable(" in line: -src/etc/featureck.py:95: level = "unstable" -src/etc/featureck.py:96: elif "[stable(" in line: -src/etc/featureck.py:97: level = "stable" -src/etc/featureck.py:104: # `#[unstable(feature = "foo", since = "1.0.0")]` -src/etc/featureck.py:106: p = re.compile('(unstable|stable).*feature *= *"(\w*)"') -src/etc/featureck.py:111: if re.compile("\[ *stable").search(line) is not None: -src/etc/featureck.py:154:# name, lang, lib, status, stable since -src/etc/featureck.py:162: status = "unstable" -src/etc/featureck.py:163: stable_since = None -src/etc/featureck.py:166: status = "stable" -src/etc/featureck.py:167: if status == "stable": -src/etc/featureck.py:168: stable_since = f[1] -src/etc/featureck.py:170: language_feature_stats[name] = (name, lang, lib, status, stable_since) -src/etc/featureck.py:178: status = "unstable" -src/etc/featureck.py:179: stable_since = None -src/etc/featureck.py:181: is_stable = lib_features_and_level.get((name, "stable")) is not None -src/etc/featureck.py:182: is_unstable = lib_features_and_level.get((name, "unstable")) is not None -src/etc/featureck.py:184: if is_stable and is_unstable: -src/etc/featureck.py:185: print("error: feature '%s' is both stable and unstable" % (name)) -src/etc/featureck.py:188: if is_stable: -src/etc/featureck.py:189: status = "stable" -src/etc/featureck.py:190: stable_since = lib_features_and_level[(name, "stable")][0] -src/etc/featureck.py:191: elif is_unstable: -src/etc/featureck.py:192: status = "unstable" -src/etc/featureck.py:194: lib_feature_stats[name] = (name, lang, lib, status, stable_since) -src/etc/featureck.py:206: lang_stable_since = language_feature_stats[name][4] -src/etc/featureck.py:207: lib_stable_since = lib_feature_stats[name][4] -src/etc/featureck.py:214: if lang_stable_since != lib_stable_since: -src/etc/featureck.py:215: print("error: feature '%s' has lang stable since %s " + -src/etc/featureck.py:216: "but lib stable since %s" % (name, lang_stable_since, lib_stable_since)) -src/etc/featureck.py:219: merged_stats[name] = (name, True, True, lang_status, lang_stable_since) -src/liballoc/arc.rs:11:#![stable(feature = "rust1", since = "1.0.0")] -src/liballoc/arc.rs:123:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/arc.rs:140:#[stable(feature = "arc_weak", since = "1.4.0")] -src/liballoc/arc.rs:152:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/arc.rs:184: #[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/arc.rs:214: #[stable(feature = "arc_unique", since = "1.4.0")] -src/liballoc/arc.rs:248: #[stable(feature = "arc_weak", since = "1.4.0")] -src/liballoc/arc.rs:275: #[unstable(feature = "arc_counts", reason = "not clearly useful, and racy", -src/liballoc/arc.rs:283: #[unstable(feature = "arc_counts", reason = "not clearly useful, and racy", -src/liballoc/arc.rs:317:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/arc.rs:366:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/arc.rs:377: #[unstable(feature = "arc_make_unique", reason = "renamed to Arc::make_mut", -src/liballoc/arc.rs:409: #[stable(feature = "arc_unique", since = "1.4.0")] -src/liballoc/arc.rs:481: #[stable(feature = "arc_unique", since = "1.4.0")] -src/liballoc/arc.rs:526:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/arc.rs:615: #[stable(feature = "arc_weak", since = "1.4.0")] -src/liballoc/arc.rs:645:#[stable(feature = "arc_weak", since = "1.4.0")] -src/liballoc/arc.rs:679:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/arc.rs:733:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/arc.rs:769:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/arc.rs:856:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/arc.rs:862:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/arc.rs:865:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/arc.rs:872:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/arc.rs:879:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/arc.rs:886:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/arc.rs:888: #[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/arc.rs:894:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/arc.rs:1152:#[stable(since = "1.5.0", feature = "smart_ptr_as_ref")] -src/liballoc/boxed.rs:54:#![stable(feature = "rust1", since = "1.0.0")] -src/liballoc/boxed.rs:87:#[unstable(feature = "box_heap", -src/liballoc/boxed.rs:94:#[unstable(feature = "box_heap", -src/liballoc/boxed.rs:106:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/boxed.rs:128:#[unstable(feature = "placement_in", -src/liballoc/boxed.rs:212: #[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/boxed.rs:232: #[stable(feature = "box_raw", since = "1.4.0")] -src/liballoc/boxed.rs:253: #[stable(feature = "box_raw", since = "1.4.0")] -src/liballoc/boxed.rs:260:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/boxed.rs:262: #[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/boxed.rs:268:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/boxed.rs:270: #[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/boxed.rs:276:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/boxed.rs:310:#[stable(feature = "box_slice_clone", since = "1.3.0")] -src/liballoc/boxed.rs:322:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/boxed.rs:333:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/boxed.rs:356:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/boxed.rs:363:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/boxed.rs:366:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/boxed.rs:375: #[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/boxed.rs:395: #[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/boxed.rs:405:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/boxed.rs:412:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/boxed.rs:419:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/boxed.rs:429:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/boxed.rs:438:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/boxed.rs:445:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/boxed.rs:455:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/boxed.rs:461:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/boxed.rs:503:#[unstable(feature = "fnbox", reason = "Newly introduced", issue = "0")] -src/liballoc/boxed.rs:538:#[stable(feature = "box_slice_clone", since = "1.3.0")] -src/liballoc/boxed.rs:598:#[stable(since = "1.5.0", feature = "smart_ptr_as_ref")] -src/liballoc/boxed.rs:603:#[stable(since = "1.5.0", feature = "smart_ptr_as_ref")] -src/liballoc/heap.rs:11:#![unstable(feature = "heap_api", -src/liballoc/lib.rs:65:#![unstable(feature = "alloc", -src/liballoc/lib.rs:142:#[unstable(feature = "oom", reason = "not a scrutinized interface", -src/liballoc/rc.rs:151:#![stable(feature = "rust1", since = "1.0.0")] -src/liballoc/rc.rs:183:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/rc.rs:205: #[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/rc.rs:242: #[stable(feature = "rc_unique", since = "1.4.0")] -src/liballoc/rc.rs:263: #[unstable(feature = "rc_would_unwrap", -src/liballoc/rc.rs:283: #[stable(feature = "rc_weak", since = "1.4.0")] -src/liballoc/rc.rs:291: #[unstable(feature = "rc_counts", reason = "not clearly useful", -src/liballoc/rc.rs:299: #[unstable(feature = "rc_counts", reason = "not clearly useful", -src/liballoc/rc.rs:320: #[unstable(feature = "rc_counts", reason = "uniqueness has unclear meaning", -src/liballoc/rc.rs:344: #[stable(feature = "rc_unique", since = "1.4.0")] -src/liballoc/rc.rs:357: #[unstable(feature = "rc_make_unique", reason = "renamed to Rc::make_mut", -src/liballoc/rc.rs:390: #[stable(feature = "rc_unique", since = "1.4.0")] -src/liballoc/rc.rs:417:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/rc.rs:427:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/rc.rs:479:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/rc.rs:503:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/rc.rs:515: #[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/rc.rs:521:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/rc.rs:560:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/rc.rs:563:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/rc.rs:656:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/rc.rs:677:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/rc.rs:684:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/rc.rs:691:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/rc.rs:698:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/rc.rs:712:#[stable(feature = "rc_weak", since = "1.4.0")] -src/liballoc/rc.rs:743: #[stable(feature = "rc_weak", since = "1.4.0")] -src/liballoc/rc.rs:754:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/rc.rs:799:#[stable(feature = "rc_weak", since = "1.4.0")] -src/liballoc/rc.rs:822:#[stable(feature = "rust1", since = "1.0.0")] -src/liballoc/rc.rs:1121:#[stable(since = "1.5.0", feature = "smart_ptr_as_ref")] -src/liballoc_jemalloc/lib.rs:17:#![unstable(feature = "alloc_jemalloc", -src/liballoc_system/lib.rs:17:#![unstable(feature = "alloc_system", -src/libarena/lib.rs:25:#![unstable(feature = "rustc_private", issue = "27812")] -src/libbacktrace/dwarf.c:947:/* Sort the line vector by PC. We want a stable sort here to maintain -src/libcollections/binary_heap.rs:152:#![stable(feature = "rust1", since = "1.0.0")] -src/libcollections/binary_heap.rs:170:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/binary_heap.rs:175:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/binary_heap.rs:186:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/binary_heap.rs:192:#[stable(feature = "binaryheap_debug", since = "1.4.0")] -src/libcollections/binary_heap.rs:209: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/binary_heap.rs:224: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/binary_heap.rs:240: #[unstable(feature = "binary_heap_extras", -src/libcollections/binary_heap.rs:269: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/binary_heap.rs:289: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/binary_heap.rs:304: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/binary_heap.rs:327: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/binary_heap.rs:348: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/binary_heap.rs:354: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/binary_heap.rs:374: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/binary_heap.rs:399: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/binary_heap.rs:424: #[unstable(feature = "binary_heap_extras", -src/libcollections/binary_heap.rs:458: #[unstable(feature = "binary_heap_extras", -src/libcollections/binary_heap.rs:489: #[unstable(feature = "binary_heap_extras", -src/libcollections/binary_heap.rs:511: #[unstable(feature = "binary_heap_extras", -src/libcollections/binary_heap.rs:570: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/binary_heap.rs:574: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/binary_heap.rs:581: #[unstable(feature = "drain", -src/libcollections/binary_heap.rs:590: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/binary_heap.rs:662:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/binary_heap.rs:668:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/binary_heap.rs:675:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/binary_heap.rs:686:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/binary_heap.rs:692:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/binary_heap.rs:696:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/binary_heap.rs:701:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/binary_heap.rs:712:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/binary_heap.rs:718:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/binary_heap.rs:722:#[unstable(feature = "drain", reason = "recent addition", issue = "27711")] -src/libcollections/binary_heap.rs:727:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/binary_heap.rs:738:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/binary_heap.rs:744:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/binary_heap.rs:747:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/binary_heap.rs:754:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/binary_heap.rs:782:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/binary_heap.rs:792:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/binary_heap.rs:806:#[stable(feature = "extend_ref", since = "1.2.0")] -src/libcollections/borrow.rs:13:#![stable(feature = "rust1", since = "1.0.0")] -src/libcollections/borrow.rs:29:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/borrow.rs:42:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/borrow.rs:44: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/borrow.rs:48: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/borrow.rs:52:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/borrow.rs:85:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/borrow.rs:88: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/borrow.rs:92: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/borrow.rs:96:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/borrow.rs:125: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/borrow.rs:151: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/borrow.rs:160:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/borrow.rs:172:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/borrow.rs:175:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/borrow.rs:183:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/borrow.rs:193:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/borrow.rs:202:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/borrow.rs:215:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/borrow.rs:228:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/borrow.rs:238:#[unstable(feature = "into_cow", reason = "may be replaced by `convert::Into`", -src/libcollections/borrow.rs:245:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/borrow.rs:252:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:69:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:85:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:91:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:97:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:103:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:109:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:125:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:128: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:132: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:137:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:144:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:151: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:161: #[unstable(feature = "btree_b", -src/libcollections/btree/map.rs:187: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:218: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:250: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:273: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:334: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:443: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:472:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:506:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:516:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:863:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:872:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:882:#[stable(feature = "extend_ref", since = "1.2.0")] -src/libcollections/btree/map.rs:889:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:898:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:900: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:906:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:914:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:917:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:925:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:933:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:940:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:1055:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:1062:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:1066:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:1069:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:1076:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:1080:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:1083:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:1090:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:1094:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:1100:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:1107:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:1111:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:1118:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:1125:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:1129:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:1154: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:1164: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:1178: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:1186: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:1192: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:1198: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:1205: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:1212: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:1238: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:1271: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:1298: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:1320: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:1340: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:1355: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/map.rs:1512: #[unstable(feature = "btree_range", -src/libcollections/btree/map.rs:1546: #[unstable(feature = "btree_range", -src/libcollections/btree/map.rs:1574: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/node.rs:68: // be more stable in the face of representation changes. -src/libcollections/btree/node.rs:77: // should be more stable in the face of representation changes. -src/libcollections/btree/node.rs:452:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:36:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:42:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:48:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:59:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:66:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:73:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:80:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:96: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:104: #[unstable(feature = "btree_b", -src/libcollections/btree/set.rs:131: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:160: #[unstable(feature = "btree_range", -src/libcollections/btree/set.rs:194: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:217: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:241: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:263: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:280: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:295: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:310: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:330: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:340: #[unstable(feature = "set_recovery", issue = "28050")] -src/libcollections/btree/set.rs:362: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:383: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:428: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:447: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:454: #[unstable(feature = "set_recovery", issue = "28050")] -src/libcollections/btree/set.rs:477: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:487: #[unstable(feature = "set_recovery", issue = "28050")] -src/libcollections/btree/set.rs:493:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:502:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:527:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:537:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:547:#[stable(feature = "extend_ref", since = "1.2.0")] -src/libcollections/btree/set.rs:554:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:556: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:562:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:585:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:608:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:631:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:654:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:664:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:671:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:675:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:679:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:686:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:690:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:721:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:741:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:761:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/btree/set.rs:787:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/enum_set.rs:16:#![unstable(feature = "enumset", -src/libcollections/enum_set.rs:49:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/enum_set.rs:250:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/enum_set.rs:268:#[stable(feature = "extend_ref", since = "1.2.0")] -src/libcollections/fmt.rs:475:#![stable(feature = "rust1", since = "1.0.0")] -src/libcollections/fmt.rs:503:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/lib.rs:21:#![unstable(feature = "collections", -src/libcollections/lib.rs:104:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/lib.rs:109:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/lib.rs:120:#[unstable(feature = "collections_bound", issue = "27787")] -src/libcollections/linked_list.rs:22:#![stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:33:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:57:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:65:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:77:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:87:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:230:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:233: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:240: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:271: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:298: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:305: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:331: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:358: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:385: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:406: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:433: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:454: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:483: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:508: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:534: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:551: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:570: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:600: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:656:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:670:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:692:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:709:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:712:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:735:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:752:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:803: #[unstable(feature = "linked_list_extras", -src/libcollections/linked_list.rs:828: #[unstable(feature = "linked_list_extras", -src/libcollections/linked_list.rs:841:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:854:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:862:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:871:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:883:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:902:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:909:#[stable(feature = "extend_ref", since = "1.2.0")] -src/libcollections/linked_list.rs:916:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:929:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:932:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:939:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:947:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:954:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/linked_list.rs:961:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/macros.rs:43:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/macros.rs:80:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/range.rs:11:#![unstable(feature = "collections_range", reason = "was just added", -src/libcollections/slice.rs:82:#![stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:162:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:172: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:186: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:203: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:210: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:217: #[unstable(feature = "slice_splits", reason = "new API", issue = "27742")] -src/libcollections/slice.rs:224: #[unstable(feature = "slice_splits", reason = "new API", issue = "27742")] -src/libcollections/slice.rs:231: #[unstable(feature = "slice_splits", reason = "new API", issue = "27742")] -src/libcollections/slice.rs:239: #[unstable(feature = "slice_splits", reason = "new API", issue = "27742")] -src/libcollections/slice.rs:256: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:263: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:279: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:287: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:295: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:302: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:315: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:328: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:352: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:367: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:374: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:381: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:406: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:432: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:446: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:470: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:510: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:530: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:538: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:562: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:574: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:600: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:613: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:629: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:645: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:661: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:688: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:724: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:742: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:751: /// This sort is `O(n log n)` worst-case and stable, but allocates -src/libcollections/slice.rs:765: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:790: #[unstable(feature = "clone_from_slice", issue = "27750")] -src/libcollections/slice.rs:796: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:804: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:815:#[unstable(feature = "slice_concat_ext", -src/libcollections/slice.rs:820: #[unstable(feature = "slice_concat_ext", -src/libcollections/slice.rs:833: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:844: #[stable(feature = "rename_connect_to_join", since = "1.3.0")] -src/libcollections/slice.rs:855: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:892:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:897:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/slice.rs:902:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/str.rs:16:#![stable(feature = "rust1", since = "1.0.0")] -src/libcollections/str.rs:109:#[unstable(feature = "str_utf16", issue = "27714")] -src/libcollections/str.rs:114:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/str.rs:137:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/str.rs:143:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/str.rs:156:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/str.rs:166: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/str.rs:180: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/str.rs:211: #[unstable(feature = "str_char", -src/libcollections/str.rs:229: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/str.rs:247: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/str.rs:271: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/str.rs:280: #[unstable(feature = "str_slice_mut", reason = "recently added", -src/libcollections/str.rs:332: #[unstable(feature = "str_char", -src/libcollections/str.rs:392: #[unstable(feature = "str_char", -src/libcollections/str.rs:419: #[unstable(feature = "str_char", -src/libcollections/str.rs:449: #[unstable(feature = "str_char", -src/libcollections/str.rs:485: #[unstable(feature = "str_char", -src/libcollections/str.rs:517: #[stable(feature = "str_split_at", since = "1.4.0")] -src/libcollections/str.rs:524: #[stable(feature = "str_split_at", since = "1.4.0")] -src/libcollections/str.rs:550: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/str.rs:566: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/str.rs:581: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/str.rs:598: #[stable(feature = "split_whitespace", since = "1.1.0")] -src/libcollections/str.rs:625: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/str.rs:653: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/str.rs:662: #[unstable(feature = "str_utf16", -src/libcollections/str.rs:678: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/str.rs:690: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/str.rs:702: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/str.rs:748: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/str.rs:790: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/str.rs:874: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/str.rs:920: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/str.rs:960: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/str.rs:996: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/str.rs:1045: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/str.rs:1090: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/str.rs:1124: #[stable(feature = "str_matches", since = "1.2.0")] -src/libcollections/str.rs:1155: #[stable(feature = "str_matches", since = "1.2.0")] -src/libcollections/str.rs:1195: #[unstable(feature = "str_match_indices", -src/libcollections/str.rs:1234: #[unstable(feature = "str_match_indices", -src/libcollections/str.rs:1251: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/str.rs:1264: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/str.rs:1277: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/str.rs:1305: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/str.rs:1327: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/str.rs:1355: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/str.rs:1380: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/str.rs:1405: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/str.rs:1426: #[stable(feature = "unicode_case_mapping", since = "1.2.0")] -src/libcollections/str.rs:1470: #[stable(feature = "unicode_case_mapping", since = "1.2.0")] -src/libcollections/str.rs:1478: #[unstable(feature = "str_escape", -src/libcollections/str.rs:1486: #[unstable(feature = "str_escape", -src/libcollections/str.rs:1494: #[stable(feature = "box_str", since = "1.4.0")] -src/libcollections/string.rs:13:#![stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:34:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:40:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:48:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:61: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:78: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:151: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:203: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:337: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:357: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:374: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:409: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:424: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:431: #[unstable(feature = "convert", -src/libcollections/string.rs:448: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:463: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:484: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:509: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:526: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:543: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:575: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:595: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:614: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:650: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:678: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:715: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:729: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:743: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:756: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:787: #[unstable(feature = "drain", -src/libcollections/string.rs:818: #[stable(feature = "box_str", since = "1.4.0")] -src/libcollections/string.rs:827: #[unstable(feature = "box_str2", -src/libcollections/string.rs:839: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:843: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:847:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:854:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:861:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:872:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:881:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:890:#[stable(feature = "extend_string", since = "1.4.0")] -src/libcollections/string.rs:899:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:911:#[stable(feature = "extend_ref", since = "1.2.0")] -src/libcollections/string.rs:918:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:927:#[stable(feature = "extend_string", since = "1.4.0")] -src/libcollections/string.rs:955:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:965: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:973: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:989:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:997:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:1005:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:1008: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:1014:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:1022:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:1030:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:1038:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:1049:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:1058:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:1067:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:1076:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:1086:#[stable(feature = "derefmut_for_string", since = "1.2.0")] -src/libcollections/string.rs:1093:#[stable(feature = "derefmut_for_string", since = "1.2.0")] -src/libcollections/string.rs:1100:#[stable(feature = "derefmut_for_string", since = "1.2.0")] -src/libcollections/string.rs:1107:#[stable(feature = "derefmut_for_string", since = "1.2.0")] -src/libcollections/string.rs:1115:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:1125:#[stable(feature = "derefmut_for_string", since = "1.2.0")] -src/libcollections/string.rs:1134:#[unstable(feature = "str_parse_error", reason = "may want to be replaced with \ -src/libcollections/string.rs:1140:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:1170:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:1173: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:1177:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:1189:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:1197:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:1205:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:1224:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:1232:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:1240:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:1247:#[unstable(feature = "into_cow", reason = "may be replaced by `convert::Into`", -src/libcollections/string.rs:1256:#[unstable(feature = "into_cow", reason = "may be replaced by `convert::Into`", -src/libcollections/string.rs:1265:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/string.rs:1281:#[unstable(feature = "drain", reason = "recently added", issue = "27711")] -src/libcollections/string.rs:1296:#[unstable(feature = "drain", reason = "recently added", issue = "27711")] -src/libcollections/string.rs:1310:#[unstable(feature = "drain", reason = "recently added", issue = "27711")] -src/libcollections/string.rs:1324:#[unstable(feature = "drain", reason = "recently added", issue = "27711")] -src/libcollections/vec.rs:60:#![stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:186:/// a Vec. The contents of a Vec wouldn't have a stable address if it were -src/libcollections/vec.rs:227:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:248: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:280: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:330: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:349: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:369: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:393: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:412: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:422: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:444: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:461: #[unstable(feature = "convert", -src/libcollections/vec.rs:472: #[unstable(feature = "convert", -src/libcollections/vec.rs:494: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:520: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:543: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:580: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:614: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:648: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:671: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:699: #[stable(feature = "append", since = "1.4.0")] -src/libcollections/vec.rs:737: #[unstable(feature = "drain", -src/libcollections/vec.rs:786: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:800: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:814: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:837: #[stable(feature = "split_off", since = "1.4.0")] -src/libcollections/vec.rs:878: #[unstable(feature = "vec_resize", -src/libcollections/vec.rs:929: #[unstable(feature = "vec_push_all", -src/libcollections/vec.rs:965: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1056:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1067:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1095:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1103:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1114:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1124:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1133:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1142:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1151:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1161:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1169:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1177:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1185:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1194:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1207:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1218:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1246:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1282:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1292:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1302:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1332:#[stable(feature = "extend_ref", since = "1.2.0")] -src/libcollections/vec.rs:1367:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1375:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1378:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1386:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1408:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1410: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1416:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1423:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1430:#[stable(feature = "vec_as_mut", since = "1.5.0")] -src/libcollections/vec.rs:1437:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1444:#[stable(feature = "vec_as_mut", since = "1.5.0")] -src/libcollections/vec.rs:1451:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1463:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1474:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1498:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1508:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1550:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1574:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1577:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1588:#[unstable(feature = "drain", reason = "recently added", issue = "27711")] -src/libcollections/vec.rs:1602:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1620:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1632:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec.rs:1654:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:19:#![stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:45:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:58:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:65:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:73:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:210: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:216: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:242: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:269: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:298: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:321: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:344: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:365: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:398: #[unstable(feature = "deque_extras", -src/libcollections/vec_deque.rs:480: #[unstable(feature = "deque_extras", -src/libcollections/vec_deque.rs:504: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:530: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:542: #[unstable(feature = "deque_extras", -src/libcollections/vec_deque.rs:563: #[unstable(feature = "deque_extras", -src/libcollections/vec_deque.rs:597: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:612: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:631: #[unstable(feature = "drain", -src/libcollections/vec_deque.rs:652: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:673: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:697: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:717: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:741: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:763: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:786: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:812: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:840: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:881: #[unstable(feature = "deque_extras", -src/libcollections/vec_deque.rs:919: #[unstable(feature = "deque_extras", -src/libcollections/vec_deque.rs:952: #[unstable(feature = "deque_extras", -src/libcollections/vec_deque.rs:1161: #[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:1331: #[stable(feature = "split_off", since = "1.4.0")] -src/libcollections/vec_deque.rs:1392: #[stable(feature = "append", since = "1.4.0")] -src/libcollections/vec_deque.rs:1416: #[stable(feature = "vec_deque_retain", since = "1.4.0")] -src/libcollections/vec_deque.rs:1454: #[unstable(feature = "deque_extras", -src/libcollections/vec_deque.rs:1484:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:1502:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:1523:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:1535:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:1539:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:1546:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:1571:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:1587:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:1592:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:1597:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:1613:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:1621:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:1625:#[unstable(feature = "drain", -src/libcollections/vec_deque.rs:1632:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:1641:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:1657:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:1665:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:1668:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:1676:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:1679:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:1686:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:1694:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:1704:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:1714:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:1722:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:1733:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:1747:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:1757:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:1767:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollections/vec_deque.rs:1776:#[stable(feature = "extend_ref", since = "1.2.0")] -src/libcollections/vec_deque.rs:1783:#[stable(feature = "rust1", since = "1.0.0")] -src/libcollectionstest/slice.rs:470: // only sort on the first element, so an unstable sort -src/libcollectionstest/slice.rs:478: // stable. -src/libcore/any.rs:71:#![stable(feature = "rust1", since = "1.0.0")] -src/libcore/any.rs:91:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/any.rs:94: #[unstable(feature = "get_type_id", -src/libcore/any.rs:108:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/any.rs:118:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/any.rs:127: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/any.rs:142: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/any.rs:160: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/any.rs:179: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/any.rs:186: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/any.rs:193: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/any.rs:214:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/any.rs:222: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/array.rs:17:#![unstable(feature = "fixed_size_array", -src/libcore/array.rs:83: #[stable(feature = "array_borrow", since = "1.4.0")] -src/libcore/array.rs:90: #[stable(feature = "array_borrow", since = "1.4.0")] -src/libcore/array.rs:97: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/array.rs:104: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/array.rs:111: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/array.rs:118: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/array.rs:128: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/array.rs:146: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/array.rs:149: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/array.rs:173: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/array.rs:196: #[stable(since = "1.4.0", feature = "array_default")] -src/libcore/array.rs:205: #[stable(since = "1.4.0", feature = "array_default")] -src/libcore/borrow.rs:13:#![stable(feature = "rust1", since = "1.0.0")] -src/libcore/borrow.rs:37:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/borrow.rs:58: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/borrow.rs:65:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/borrow.rs:82: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/borrow.rs:86:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/borrow.rs:91:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/borrow.rs:96:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/borrow.rs:101:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/borrow.rs:106:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cell.rs:143:#![stable(feature = "rust1", since = "1.0.0")] -src/libcore/cell.rs:156:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cell.rs:171: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cell.rs:191: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cell.rs:208: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cell.rs:233: #[unstable(feature = "as_unsafe_cell", issue = "27708")] -src/libcore/cell.rs:239:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cell.rs:242:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cell.rs:250:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cell.rs:252: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cell.rs:259:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cell.rs:267:#[stable(feature = "cell_eq", since = "1.2.0")] -src/libcore/cell.rs:273:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cell.rs:281:#[unstable(feature = "borrow_state", issue = "27733")] -src/libcore/cell.rs:307: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cell.rs:327: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cell.rs:343: #[unstable(feature = "borrow_state", issue = "27733")] -src/libcore/cell.rs:388: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cell.rs:434: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cell.rs:452: #[unstable(feature = "as_unsafe_cell", issue = "27708")] -src/libcore/cell.rs:458:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cell.rs:461:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cell.rs:469:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cell.rs:471: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cell.rs:478:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cell.rs:486:#[stable(feature = "cell_eq", since = "1.2.0")] -src/libcore/cell.rs:531:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cell.rs:539:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cell.rs:558: #[unstable(feature = "cell_extras", -src/libcore/cell.rs:589: #[unstable(feature = "cell_extras", reason = "recently added", -src/libcore/cell.rs:621: #[unstable(feature = "cell_extras", reason = "recently added", -src/libcore/cell.rs:659: #[unstable(feature = "cell_extras", reason = "recently added", -src/libcore/cell.rs:697: #[unstable(feature = "cell_extras", reason = "recently added", -src/libcore/cell.rs:740:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cell.rs:748:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cell.rs:758:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cell.rs:791:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cell.rs:812: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cell.rs:835: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cell.rs:854: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/char.rs:16:#![stable(feature = "core_char", since = "1.2.0")] -src/libcore/char.rs:67:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/char.rs:81:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/char.rs:94:#[unstable(feature = "char_from_unchecked", reason = "recently added API", -src/libcore/char.rs:121:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/char.rs:142:#[unstable(feature = "core_char_ext", -src/libcore/char.rs:143: reason = "the stable interface is `impl char` in later crate", -src/libcore/char.rs:232:#[unstable(feature = "char_internals", -src/libcore/char.rs:267:#[unstable(feature = "char_internals", -src/libcore/char.rs:291:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/char.rs:307:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/char.rs:366:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/char.rs:379:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/clone.rs:22:#![stable(feature = "rust1", since = "1.0.0")] -src/libcore/clone.rs:27:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/clone.rs:38: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/clone.rs:47: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/clone.rs:53:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/clone.rs:62: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:18:#![stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:47:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:51: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:56: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:72:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:83: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:104:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:107: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:110: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:113: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:154: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:176:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:192: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:196:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:199:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:202: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:208:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:211: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:235:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:260: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:277: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:298: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:318: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:339: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:361:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:379:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:394: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:404: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:418: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:427: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:450: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:458: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:470: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:486: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:498: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:504: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:516: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:523: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:538: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:543: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:548: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:555: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:570: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:575: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:578: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp.rs:586: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp_macros.rs:21: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/cmp_macros.rs:39: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/convert.rs:22:#![stable(feature = "rust1", since = "1.0.0")] -src/libcore/convert.rs:48:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/convert.rs:51: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/convert.rs:56:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/convert.rs:59: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/convert.rs:78:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/convert.rs:81: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/convert.rs:97:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/convert.rs:100: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/convert.rs:109:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/convert.rs:117:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/convert.rs:133:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/convert.rs:149:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/convert.rs:157:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/convert.rs:166:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/convert.rs:173:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/convert.rs:180:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/default.rs:79:#![stable(feature = "rust1", since = "1.0.0")] -src/libcore/default.rs:95:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/default.rs:125: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/default.rs:131: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/default.rs:134: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/builders.rs:57:#[stable(feature = "debug_builders", since = "1.2.0")] -src/libcore/fmt/builders.rs:77: #[stable(feature = "debug_builders", since = "1.2.0")] -src/libcore/fmt/builders.rs:100: #[stable(feature = "debug_builders", since = "1.2.0")] -src/libcore/fmt/builders.rs:123:#[stable(feature = "debug_builders", since = "1.2.0")] -src/libcore/fmt/builders.rs:141: #[stable(feature = "debug_builders", since = "1.2.0")] -src/libcore/fmt/builders.rs:163: #[stable(feature = "debug_builders", since = "1.2.0")] -src/libcore/fmt/builders.rs:182: #[unstable(feature = "debug_builder_formatter", reason = "recently added", -src/libcore/fmt/builders.rs:237:#[stable(feature = "debug_builders", since = "1.2.0")] -src/libcore/fmt/builders.rs:255: #[stable(feature = "debug_builders", since = "1.2.0")] -src/libcore/fmt/builders.rs:262: #[stable(feature = "debug_builders", since = "1.2.0")] -src/libcore/fmt/builders.rs:274: #[stable(feature = "debug_builders", since = "1.2.0")] -src/libcore/fmt/builders.rs:285:#[stable(feature = "debug_builders", since = "1.2.0")] -src/libcore/fmt/builders.rs:303: #[stable(feature = "debug_builders", since = "1.2.0")] -src/libcore/fmt/builders.rs:310: #[stable(feature = "debug_builders", since = "1.2.0")] -src/libcore/fmt/builders.rs:322: #[stable(feature = "debug_builders", since = "1.2.0")] -src/libcore/fmt/builders.rs:333:#[stable(feature = "debug_builders", since = "1.2.0")] -src/libcore/fmt/builders.rs:351: #[stable(feature = "debug_builders", since = "1.2.0")] -src/libcore/fmt/builders.rs:378: #[stable(feature = "debug_builders", since = "1.2.0")] -src/libcore/fmt/builders.rs:391: #[stable(feature = "debug_builders", since = "1.2.0")] -src/libcore/fmt/mod.rs:13:#![stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:36:#[unstable(feature = "fmt_internals", reason = "internal to format_args!", -src/libcore/fmt/mod.rs:43:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:52:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:65:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:77: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:90: #[stable(feature = "fmt_write_char", since = "1.1.0")] -src/libcore/fmt/mod.rs:101: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:124:#[stable(feature = "fmt_write_blanket_impl", since = "1.4.0")] -src/libcore/fmt/mod.rs:142:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:165:#[unstable(feature = "fmt_internals", reason = "internal to format_args!", -src/libcore/fmt/mod.rs:186: #[unstable(feature = "fmt_internals", reason = "internal to format_args!", -src/libcore/fmt/mod.rs:199: #[unstable(feature = "fmt_internals", reason = "internal to format_args!", -src/libcore/fmt/mod.rs:223: #[unstable(feature = "fmt_internals", reason = "internal to format_args!", -src/libcore/fmt/mod.rs:241: #[unstable(feature = "fmt_internals", reason = "internal to format_args!", -src/libcore/fmt/mod.rs:263:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:277:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:284:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:376:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:383: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:423:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:426: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:470:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:473: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:517:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:520: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:565:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:568: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:613:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:616: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:658:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:661: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:701:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:704: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:744:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:747: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:759:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:855: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:930: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:1085: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:1091: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:1097: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:1101: #[unstable(feature = "fmt_flags", reason = "method was just created", -src/libcore/fmt/mod.rs:1106: #[unstable(feature = "fmt_flags", reason = "method was just created", -src/libcore/fmt/mod.rs:1111: #[unstable(feature = "fmt_flags", reason = "method was just created", -src/libcore/fmt/mod.rs:1116: #[unstable(feature = "fmt_flags", reason = "method was just created", -src/libcore/fmt/mod.rs:1121: #[unstable(feature = "fmt_flags", reason = "method was just created", -src/libcore/fmt/mod.rs:1126: #[unstable(feature = "fmt_flags", reason = "method was just created", -src/libcore/fmt/mod.rs:1131: #[unstable(feature = "fmt_flags", reason = "method was just created", -src/libcore/fmt/mod.rs:1136: #[unstable(feature = "fmt_flags", reason = "method was just created", -src/libcore/fmt/mod.rs:1167: #[stable(feature = "debug_builders", since = "1.2.0")] -src/libcore/fmt/mod.rs:1195: #[stable(feature = "debug_builders", since = "1.2.0")] -src/libcore/fmt/mod.rs:1220: #[stable(feature = "debug_builders", since = "1.2.0")] -src/libcore/fmt/mod.rs:1245: #[stable(feature = "debug_builders", since = "1.2.0")] -src/libcore/fmt/mod.rs:1270: #[stable(feature = "debug_builders", since = "1.2.0")] -src/libcore/fmt/mod.rs:1277:#[stable(since = "1.2.0", feature = "formatter_write")] -src/libcore/fmt/mod.rs:1292:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:1304: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:1308: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:1318:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:1325:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:1332:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:1353:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:1360:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:1371:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:1385:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:1413:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:1422:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:1431:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:1489: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:1496: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:1503: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:1510: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:1522:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:1526:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:1538: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:1563:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:1570:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:1582:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:1589:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:1601:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/mod.rs:1608:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/num.rs:143:#[unstable(feature = "fmt_radix", -src/libcore/fmt/num.rs:173:#[unstable(feature = "fmt_radix", -src/libcore/fmt/num.rs:189:#[unstable(feature = "fmt_radix", -src/libcore/fmt/num.rs:198: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/num.rs:204: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/num.rs:215: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/fmt/num.rs:226: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/hash/mod.rs:71:#![stable(feature = "rust1", since = "1.0.0")] -src/libcore/hash/mod.rs:95:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/hash/mod.rs:98: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/hash/mod.rs:102: #[stable(feature = "hash_slice", since = "1.3.0")] -src/libcore/hash/mod.rs:113:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/hash/mod.rs:116: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/hash/mod.rs:120: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/hash/mod.rs:125: #[stable(feature = "hasher_write", since = "1.3.0")] -src/libcore/hash/mod.rs:131: #[stable(feature = "hasher_write", since = "1.3.0")] -src/libcore/hash/mod.rs:137: #[stable(feature = "hasher_write", since = "1.3.0")] -src/libcore/hash/mod.rs:143: #[stable(feature = "hasher_write", since = "1.3.0")] -src/libcore/hash/mod.rs:149: #[stable(feature = "hasher_write", since = "1.3.0")] -src/libcore/hash/mod.rs:159: #[stable(feature = "hasher_write", since = "1.3.0")] -src/libcore/hash/mod.rs:165: #[stable(feature = "hasher_write", since = "1.3.0")] -src/libcore/hash/mod.rs:171: #[stable(feature = "hasher_write", since = "1.3.0")] -src/libcore/hash/mod.rs:177: #[stable(feature = "hasher_write", since = "1.3.0")] -src/libcore/hash/mod.rs:183: #[stable(feature = "hasher_write", since = "1.3.0")] -src/libcore/hash/mod.rs:199: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/hash/mod.rs:229: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/hash/mod.rs:236: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/hash/mod.rs:243: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/hash/mod.rs:253: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/hash/mod.rs:260: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/hash/mod.rs:285: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/hash/mod.rs:294: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/hash/mod.rs:301: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/hash/mod.rs:308: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/hash/mod.rs:315: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/hash/sip.rs:31:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/hash/sip.rs:107: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/hash/sip.rs:114: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/hash/sip.rs:142:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/hash/sip.rs:213:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/hash/sip.rs:231:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/intrinsics.rs:42:#![unstable(feature = "core_intrinsics", -src/libcore/intrinsics.rs:253: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/intrinsics.rs:334: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/intrinsics.rs:364: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/intrinsics.rs:369: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:57:#![stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:84:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:89: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:94: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:109: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:133: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:148: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:166: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:190: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:226: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:246: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:266: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:286: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:322: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:345: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:365: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:386: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:406: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:425: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:451: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:473: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:508: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:530: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:551: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:565: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:581: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:613: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:636: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:662: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:687: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:722: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:750: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:780: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:803: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:829: #[unstable(feature = "iter_cmp", -src/libcore/iter.rs:859: #[unstable(feature = "iter_cmp", -src/libcore/iter.rs:887: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:905: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:949: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:967: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:984: #[unstable(feature = "iter_arith", reason = "bounds recently changed", -src/libcore/iter.rs:1007: #[unstable(feature="iter_arith", reason = "bounds recently changed", -src/libcore/iter.rs:1018: #[unstable(feature = "iter_order", reason = "needs review and revision", issue = "27737")] -src/libcore/iter.rs:1041: #[unstable(feature = "iter_order", reason = "needs review and revision", issue = "27737")] -src/libcore/iter.rs:1064: #[unstable(feature = "iter_order", reason = "needs review and revision", issue = "27737")] -src/libcore/iter.rs:1083: #[unstable(feature = "iter_order", reason = "needs review and revision", issue = "27737")] -src/libcore/iter.rs:1102: #[unstable(feature = "iter_order", reason = "needs review and revision", issue = "27737")] -src/libcore/iter.rs:1129: #[unstable(feature = "iter_order", reason = "needs review and revision", issue = "27737")] -src/libcore/iter.rs:1156: #[unstable(feature = "iter_order", reason = "needs review and revision", issue = "27737")] -src/libcore/iter.rs:1183: #[unstable(feature = "iter_order", reason = "needs review and revision", issue = "27737")] -src/libcore/iter.rs:1240:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1248:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1275: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1283:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1286: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1290: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1294: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1298:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1309:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1312: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1321:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1325: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1329:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1341:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1344: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1357:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1362:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1364:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1368:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1371:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1375:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1382:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1387:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1397:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1404:#[stable(feature = "iter_cloned", since = "1.1.0")] -src/libcore/iter.rs:1411:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1426:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1435:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1443:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1449:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1475:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1505:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1589:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1613:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1619:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1651:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1678:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1685:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1700:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1712:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1719:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1740:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1757:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1764:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1787:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1805:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1811:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1854:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1872:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1878:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1925:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1928:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1933: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1953:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1961:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1987:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:1995:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:2027:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:2033:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:2095:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:2101:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:2107:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:2150:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:2156:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:2164:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:2187:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:2196:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:2229:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:2258:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:2264:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:2318:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:2332:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:2338:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:2356:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:2372:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:2387:#[unstable(feature = "step_trait", -src/libcore/iter.rs:2500:#[unstable(feature = "step_by", reason = "recent addition", -src/libcore/iter.rs:2520: #[unstable(feature = "step_by", reason = "recent addition", -src/libcore/iter.rs:2555: #[unstable(feature = "step_by", reason = "recent addition", -src/libcore/iter.rs:2565:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:2587:#[unstable(feature = "range_inclusive", -src/libcore/iter.rs:2597:#[unstable(feature = "range_inclusive", -src/libcore/iter.rs:2609:#[unstable(feature = "range_inclusive", -src/libcore/iter.rs:2643:#[unstable(feature = "range_inclusive", -src/libcore/iter.rs:2666:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:2705: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:2710:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:2740:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:2756:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:2772:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:2777:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:2787:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:2795:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/iter.rs:2801:#[stable(feature = "iter_empty", since = "1.2.0")] -src/libcore/iter.rs:2804:#[stable(feature = "iter_empty", since = "1.2.0")] -src/libcore/iter.rs:2817:#[stable(feature = "iter_empty", since = "1.2.0")] -src/libcore/iter.rs:2824:#[stable(feature = "iter_empty", since = "1.2.0")] -src/libcore/iter.rs:2833:#[stable(feature = "iter_empty", since = "1.2.0")] -src/libcore/iter.rs:2842:#[stable(feature = "iter_empty", since = "1.2.0")] -src/libcore/iter.rs:2850:#[stable(feature = "iter_empty", since = "1.2.0")] -src/libcore/iter.rs:2857:#[stable(feature = "iter_once", since = "1.2.0")] -src/libcore/iter.rs:2862:#[stable(feature = "iter_once", since = "1.2.0")] -src/libcore/iter.rs:2875:#[stable(feature = "iter_once", since = "1.2.0")] -src/libcore/iter.rs:2882:#[stable(feature = "iter_once", since = "1.2.0")] -src/libcore/iter.rs:2890:#[stable(feature = "iter_once", since = "1.2.0")] -src/libcore/iter.rs:2903:#[unstable(feature = "iter_order", reason = "needs review and revision", -src/libcore/lib.rs:23://! *It is not recommended to use the core library*. The stable -src/libcore/lib.rs:27://! intended to be stable. -src/libcore/lib.rs:52:#![unstable(feature = "core", -src/libcore/lib.rs:69:#![feature(allow_internal_unstable)] -src/libcore/macros.rs:13:#[allow_internal_unstable] -src/libcore/macros.rs:56:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/macros.rs:83:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/macros.rs:127:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/macros.rs:191:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/macros.rs:241:#[unstable(feature = "core", -src/libcore/macros.rs:304:#[unstable(feature = "core", -src/libcore/marker.rs:17:#![stable(feature = "rust1", since = "1.0.0")] -src/libcore/marker.rs:26:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/marker.rs:39:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/marker.rs:48:#[unstable(feature = "unsize", issue = "27732")] -src/libcore/marker.rs:153:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/marker.rs:200:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/marker.rs:355:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/marker.rs:399:#[unstable(feature = "reflect_marker", -src/libcore/mem.rs:16:#![stable(feature = "rust1", since = "1.0.0")] -src/libcore/mem.rs:22:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/mem.rs:112:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/mem.rs:127:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/mem.rs:142:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/mem.rs:159:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/mem.rs:175:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/mem.rs:193:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/mem.rs:208:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/mem.rs:232:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/mem.rs:250:#[unstable(feature = "filling_drop", issue = "5016")] -src/libcore/mem.rs:338:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/mem.rs:360:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/mem.rs:426:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/mem.rs:510:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/mem.rs:533:#[unstable(feature = "filling_drop", issue = "5016")] -src/libcore/mem.rs:536:#[unstable(feature = "filling_drop", issue = "5016")] -src/libcore/mem.rs:539:#[unstable(feature = "filling_drop", issue = "5016")] -src/libcore/mem.rs:544:#[unstable(feature = "filling_drop", issue = "5016")] -src/libcore/mem.rs:548:#[unstable(feature = "filling_drop", issue = "5016")] -src/libcore/mem.rs:575:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/nonzero.rs:12:#![unstable(feature = "nonzero", -src/libcore/num/bignum.rs:25:#![unstable(feature = "core_private_bignum", -src/libcore/num/dec2flt/mod.rs:91:#![unstable(feature = "dec2flt", -src/libcore/num/dec2flt/mod.rs:113: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/dec2flt/mod.rs:154:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/dec2flt/mod.rs:166: #[unstable(feature = "int_error_internals", -src/libcore/num/dec2flt/mod.rs:179:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/diy_float.rs:16:#![unstable(feature = "core_private_diy_float", -src/libcore/num/f32.rs:16:#![stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f32.rs:25:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f32.rs:29:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f32.rs:32:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f32.rs:36:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f32.rs:41:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f32.rs:44:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f32.rs:47:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f32.rs:50:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f32.rs:53:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f32.rs:57:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f32.rs:60:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f32.rs:64:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f32.rs:67:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f32.rs:70:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f32.rs:75:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f32.rs:80: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f32.rs:84: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f32.rs:88: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f32.rs:92: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f32.rs:96: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f32.rs:100: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f32.rs:104: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f32.rs:108: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f32.rs:112: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f32.rs:116: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f32.rs:120: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f32.rs:124: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f32.rs:128: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f32.rs:132: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f32.rs:136: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f32.rs:140: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f64.rs:16:#![stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f64.rs:25:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f64.rs:29:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f64.rs:32:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f64.rs:36:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f64.rs:41:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f64.rs:44:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f64.rs:47:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f64.rs:50:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f64.rs:53:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f64.rs:57:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f64.rs:60:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f64.rs:64:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f64.rs:67:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f64.rs:70:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f64.rs:75:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f64.rs:80: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f64.rs:84: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f64.rs:88: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f64.rs:92: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f64.rs:96: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f64.rs:100: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f64.rs:104: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f64.rs:108: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f64.rs:112: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f64.rs:116: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f64.rs:120: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f64.rs:124: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f64.rs:128: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f64.rs:132: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f64.rs:136: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/f64.rs:140: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/flt2dec/mod.rs:129:#![unstable(feature = "flt2dec", -src/libcore/num/i16.rs:15:#![stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/i32.rs:15:#![stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/i64.rs:15:#![stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/i8.rs:15:#![stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/int_macros.rs:17:#[unstable(feature = "num_bits_bytes", -src/libcore/num/int_macros.rs:24:#[unstable(feature = "num_bits_bytes", -src/libcore/num/int_macros.rs:32:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/int_macros.rs:38:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/isize.rs:15:#![stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:13:#![stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:41:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:43:pub struct Wrapping(#[stable(feature = "rust1", since = "1.0.0")] pub T); -src/libcore/num/mod.rs:57:#[unstable(feature = "zero_one", -src/libcore/num/mod.rs:69:#[unstable(feature = "zero_one", -src/libcore/num/mod.rs:123: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:130: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:145: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:159: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:172: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:188: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:204: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:221: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:239: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:255: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:277: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:299: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:321: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:343: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:358: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:373: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:388: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:404: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:417: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:429: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:441: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:451: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:461: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:478: #[stable(feature = "num_wrapping", since = "1.2.0")] -src/libcore/num/mod.rs:491: #[stable(feature = "num_wrapping", since = "1.2.0")] -src/libcore/num/mod.rs:505: #[stable(feature = "num_wrapping", since = "1.2.0")] -src/libcore/num/mod.rs:514: #[stable(feature = "num_wrapping", since = "1.2.0")] -src/libcore/num/mod.rs:523: #[stable(feature = "num_wrapping", since = "1.2.0")] -src/libcore/num/mod.rs:538: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:570: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:588: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:600: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:606: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:673: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:678: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:695: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:709: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:724: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:740: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:756: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:786: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:806: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:824: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:846: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:868: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:890: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:912: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:927: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:942: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:957: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:973: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:984: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:996: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:1008: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:1018: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:1028: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:1045: #[stable(feature = "num_wrapping", since = "1.2.0")] -src/libcore/num/mod.rs:1058: #[stable(feature = "num_wrapping", since = "1.2.0")] -src/libcore/num/mod.rs:1072: #[stable(feature = "num_wrapping", since = "1.2.0")] -src/libcore/num/mod.rs:1081: #[stable(feature = "num_wrapping", since = "1.2.0")] -src/libcore/num/mod.rs:1090: #[stable(feature = "num_wrapping", since = "1.2.0")] -src/libcore/num/mod.rs:1103: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:1132: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:1141: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:1152: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:1241:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:1244: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:1248: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:1252: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:1256: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:1260: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:1266:#[unstable(feature = "core_float", -src/libcore/num/mod.rs:1267: reason = "stable interface is via `impl f{32,64}` in later crates", -src/libcore/num/mod.rs:1332: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:1439:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/mod.rs:1451: #[unstable(feature = "int_error_internals", -src/libcore/num/mod.rs:1466:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/u16.rs:15:#![stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/u32.rs:15:#![stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/u64.rs:15:#![stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/u8.rs:15:#![stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/uint_macros.rs:15:#[unstable(feature = "num_bits_bytes", -src/libcore/num/uint_macros.rs:20:#[unstable(feature = "num_bits_bytes", -src/libcore/num/uint_macros.rs:26:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/uint_macros.rs:29:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/usize.rs:15:#![stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/wrapping.rs:12:#![unstable(feature = "wrapping", reason = "may be removed or relocated", -src/libcore/num/wrapping.rs:49: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/wrapping.rs:59: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/wrapping.rs:92: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/wrapping.rs:102: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/wrapping.rs:112: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/wrapping.rs:122: #[stable(feature = "wrapping_div", since = "1.3.0")] -src/libcore/num/wrapping.rs:132: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/wrapping.rs:142: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/wrapping.rs:152: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/num/wrapping.rs:162: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:68:#![stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:95:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:98: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:106: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:122: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:132: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:142: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:181:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:184: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:188: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:194: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:235:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:238: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:242: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:248: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:289:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:292: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:296: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:302: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:343:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:346: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:350: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:358: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:374: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:415:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:418: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:422: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:430: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:447: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:462:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:484:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:528:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:531: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:535: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:543: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:545: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:549: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:598:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:601: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:605: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:611: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:652:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:655: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:659: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:665: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:706:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:709: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:713: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:719: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:760:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:763: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:767: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:773: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:814:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:817: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:821: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:827: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:886:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:889: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:893: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:959:#[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] -src/libcore/ops.rs:968: #[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] -src/libcore/ops.rs:1008:#[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] -src/libcore/ops.rs:1017: #[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] -src/libcore/ops.rs:1057:#[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] -src/libcore/ops.rs:1066: #[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] -src/libcore/ops.rs:1106:#[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] -src/libcore/ops.rs:1115: #[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] -src/libcore/ops.rs:1155:#[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] -src/libcore/ops.rs:1164: #[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] -src/libcore/ops.rs:1204:#[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] -src/libcore/ops.rs:1213: #[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] -src/libcore/ops.rs:1253:#[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] -src/libcore/ops.rs:1262: #[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] -src/libcore/ops.rs:1302:#[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] -src/libcore/ops.rs:1311: #[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] -src/libcore/ops.rs:1351:#[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] -src/libcore/ops.rs:1360: #[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] -src/libcore/ops.rs:1419:#[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] -src/libcore/ops.rs:1428: #[unstable(feature = "op_assign_traits", reason = "recently added", issue = "28235")] -src/libcore/ops.rs:1488:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:1491: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:1495: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:1535:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:1538: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:1545:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:1548:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:1558:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:1561: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:1564: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:1568:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:1578:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:1581: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:1585:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:1595:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:1598: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:1602:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:1642:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:1645: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:1649: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:1653:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:1660:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:1707:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:1710: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:1714:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:1721:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:1731:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:1741:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ops.rs:1802:#[unstable(feature = "coerce_unsized", issue = "27732")] -src/libcore/ops.rs:1848:#[unstable(feature = "placement_new_protocol", issue = "27779")] -src/libcore/ops.rs:1879:#[unstable(feature = "placement_new_protocol", issue = "27779")] -src/libcore/ops.rs:1890:#[unstable(feature = "placement_new_protocol", issue = "27779")] -src/libcore/ops.rs:1927:#[unstable(feature = "placement_new_protocol", issue = "27779")] -src/libcore/ops.rs:1941:#[unstable(feature = "placement_new_protocol", issue = "27779")] -src/libcore/option.rs:144:#![stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:166:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:169: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:172: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:197: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:217: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:243: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:264: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:289: #[unstable(feature = "as_slice", -src/libcore/option.rs:329: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:361: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:378: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:396: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:422: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:443: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:466: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:487: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:508: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:532: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:553: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:584: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:609: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:639: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:661: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:687: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:694: #[unstable(feature = "as_slice", reason = "unsure of the utility here", -src/libcore/option.rs:711: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:741: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:754:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:757: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:761:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:785:#[stable(since = "1.4.0", feature = "option_iter")] -src/libcore/option.rs:795:#[stable(since = "1.4.0", feature = "option_iter")] -src/libcore/option.rs:841:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:844:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:854:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:860:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:863:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:871:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:874:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:884:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:890:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:895:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:898:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:908:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:914:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:921:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/option.rs:941: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/panicking.rs:32:#![unstable(feature = "core_panic", -src/libcore/prelude/mod.rs:13:#![stable(feature = "core_prelude", since = "1.4.0")] -src/libcore/prelude/v1.rs:17:#![stable(feature = "core_prelude", since = "1.4.0")] -src/libcore/ptr.rs:17:#![stable(feature = "rust1", since = "1.0.0")] -src/libcore/ptr.rs:34:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ptr.rs:37:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ptr.rs:40:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ptr.rs:54:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ptr.rs:68:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ptr.rs:79:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ptr.rs:102:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ptr.rs:120:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ptr.rs:130:#[unstable(feature = "filling_drop", -src/libcore/ptr.rs:155:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ptr.rs:160:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ptr.rs:164: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ptr.rs:179: #[unstable(feature = "ptr_as_ref", -src/libcore/ptr.rs:202: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ptr.rs:209:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ptr.rs:213: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ptr.rs:228: #[unstable(feature = "ptr_as_ref", -src/libcore/ptr.rs:250: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ptr.rs:263: #[unstable(feature = "ptr_as_ref", -src/libcore/ptr.rs:278:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ptr.rs:284:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ptr.rs:287:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ptr.rs:293:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ptr.rs:296:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ptr.rs:304:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ptr.rs:315: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ptr.rs:323: #[stable(feature = "fnptr_impls", since = "1.4.0")] -src/libcore/ptr.rs:331: #[stable(feature = "fnptr_impls", since = "1.4.0")] -src/libcore/ptr.rs:334: #[stable(feature = "fnptr_impls", since = "1.4.0")] -src/libcore/ptr.rs:342: #[stable(feature = "fnptr_impls", since = "1.4.0")] -src/libcore/ptr.rs:350: #[stable(feature = "fnptr_impls", since = "1.4.0")] -src/libcore/ptr.rs:357: #[stable(feature = "fnptr_impls", since = "1.4.0")] -src/libcore/ptr.rs:364: #[stable(feature = "fnptr_impls", since = "1.4.0")] -src/libcore/ptr.rs:397:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ptr.rs:411:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ptr.rs:431:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ptr.rs:445:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/ptr.rs:473:#[unstable(feature = "unique", reason = "needs an RFC to flesh out design", -src/libcore/ptr.rs:489:#[unstable(feature = "unique", issue = "27730")] -src/libcore/ptr.rs:496:#[unstable(feature = "unique", issue = "27730")] -src/libcore/ptr.rs:499:#[unstable(feature = "unique", issue = "27730")] -src/libcore/ptr.rs:517:#[unstable(feature = "unique", issue= "27730")] -src/libcore/ptr.rs:527:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/raw.rs:12:#![unstable(feature = "raw", issue = "27751")] -src/libcore/result.rs:230:#![stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:246:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:249: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:253: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:261:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:279: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:299: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:323: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:346: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:371: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:398: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:408: #[unstable(feature = "as_slice", reason = "unsure of the utility here", -src/libcore/result.rs:440: #[unstable(feature = "as_slice", -src/libcore/result.rs:479: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:505: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:529: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:550: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:581: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:605: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:635: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:659: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:681: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:701: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:710:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:731: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:751: #[stable(feature = "result_expect", since = "1.4.0")] -src/libcore/result.rs:760:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:781: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:795:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:819:#[stable(since = "1.4.0", feature = "result_iter")] -src/libcore/result.rs:829:#[stable(since = "1.4.0", feature = "result_iter")] -src/libcore/result.rs:844:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:847:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:860:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:866:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:874:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:877:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:890:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:896:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:900:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:903:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:916:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:922:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/result.rs:929:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/simd.rs:24:#![unstable(feature = "core_simd", -src/libcore/simd_old.rs:36:#![unstable(feature = "core_simd", -src/libcore/slice.rs:15:#![stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:66:#[unstable(feature = "core_slice_ext", -src/libcore/slice.rs:67: reason = "stable interface provided by `impl [T]` in later crates", -src/libcore/slice.rs:547:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:557:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:566:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:582:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:591:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:600:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:610:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:624:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:631:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:639:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:652:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:654: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:662:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:672:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:690: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:737: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:788:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:803: #[stable(feature = "iter_to_slice", since = "1.4.0")] -src/libcore/slice.rs:825:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:828:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:834:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:851: #[stable(feature = "iter_to_slice", since = "1.4.0")] -src/libcore/slice.rs:873:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:886:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:894:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:905:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:933:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:959:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:978:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:1013:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:1070:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:1078:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:1085:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:1093:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:1100: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:1125:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:1132:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:1142:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:1196:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:1210:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:1218:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:1225:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:1235:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:1296:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:1312:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:1318:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:1324:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:1388:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:1406:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:1414:#[unstable(feature = "ref_slice", issue = "27774")] -src/libcore/slice.rs:1422:#[unstable(feature = "ref_slice", issue = "27774")] -src/libcore/slice.rs:1462:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:1474:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:1484:#[unstable(feature = "slice_bytes", reason = "needs review", -src/libcore/slice.rs:1526:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:1556:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:1559:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/slice.rs:1580:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:15:#![stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:40:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:43: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:66: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:70:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:108:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:111:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:128:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:158: #[unstable(feature = "utf8_error", reason = "method just added", -src/libcore/str/mod.rs:237:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:273:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:278:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:293:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:323:#[unstable(feature = "str_internals", issue = "0")] -src/libcore/str/mod.rs:387:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:411:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:429: #[stable(feature = "iter_to_slice", since = "1.4.0")] -src/libcore/str/mod.rs:438:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:444:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:468:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:488: #[stable(feature = "iter_to_slice", since = "1.4.0")] -src/libcore/str/mod.rs:499:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:503:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:533:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:541:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:787: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:801: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:847: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:885: #[unstable(feature = "str_match_indices", -src/libcore/str/mod.rs:927: #[stable(feature = "str_matches", since = "1.2.0")] -src/libcore/str/mod.rs:934:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:938:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:953:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:962:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:997:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:1013:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:1157:#[unstable(feature = "str_char", -src/libcore/str/mod.rs:1187: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:1204: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:1214: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:1217: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:1251: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:1269: #[stable(feature = "derefmut_for_string", since = "1.2.0")] -src/libcore/str/mod.rs:1291: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:1308: #[stable(feature = "derefmut_for_string", since = "1.2.0")] -src/libcore/str/mod.rs:1327: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:1343: #[stable(feature = "derefmut_for_string", since = "1.2.0")] -src/libcore/str/mod.rs:1357: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:1367: #[stable(feature = "derefmut_for_string", since = "1.2.0")] -src/libcore/str/mod.rs:1379:#[unstable(feature = "core_str_ext", -src/libcore/str/mod.rs:1380: reason = "stable interface provided by `impl str` in later crates", -src/libcore/str/mod.rs:1797:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:1830:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/mod.rs:1832: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/str/pattern.rs:16:#![unstable(feature = "pattern", -src/libcore/sync/atomic.rs:71:#![stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:84:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:99:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:114:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:129:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:153:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:157: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:162: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:167: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:171: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:175: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:180:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:183:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:186:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:204: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:227: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:251: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:273: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:302: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:335: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:368: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:400: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:432: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:440:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:452: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:475: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:499: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:518: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:545: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:562: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:579: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:595: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:611: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:627: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:633:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:645: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:668: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:692: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:712: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:739: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:756: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:773: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:789: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:805: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:821: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:839: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:863: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:891: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:913: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:940: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:1085:#[stable(feature = "rust1", since = "1.0.0")] -src/libcore/sync/atomic.rs:1100: #[stable(feature = "atomic_debug", since = "1.3.0")] -src/libcore/sync/atomic.rs:1111:#[stable(feature = "atomic_debug", since = "1.3.0")] -src/libcore/sync/mod.rs:13:#![stable(feature = "rust1", since = "1.0.0")] -src/libcore/tuple.rs:30:#![stable(feature = "rust1", since = "1.0.0")] -src/libcore/tuple.rs:52: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/tuple.rs:59: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/tuple.rs:71: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/tuple.rs:74: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/tuple.rs:98: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/tuple.rs:106: #[stable(feature = "rust1", since = "1.0.0")] -src/libcore/tuple.rs:108: #[stable(feature = "rust1", since = "1.0.0")] -src/libcoretest/num/flt2dec/mod.rs:166:trait TestableFloat : DecodableFloat + fmt::Display { -src/libcoretest/num/flt2dec/mod.rs:172:impl TestableFloat for f32 { -src/libcoretest/num/flt2dec/mod.rs:176:impl TestableFloat for f64 { -src/libcoretest/num/flt2dec/mod.rs:181: where T: TestableFloat, -src/libcoretest/num/flt2dec/mod.rs:185: let v: T = TestableFloat::ldexpi(x, e); -src/libflate/lib.rs:20:#![unstable(feature = "rustc_private", issue = "27812")] -src/libfmt_macros/lib.rs:20:#![unstable(feature = "rustc_private", issue = "27812")] -src/libgetopts/lib.rs:82:#![unstable(feature = "rustc_private", -src/libgraphviz/lib.rs:279:#![unstable(feature = "rustc_private", issue = "27812")] -src/liblibc/lib.rs:16: unstable(feature = "libc", reason = "use `libc` from crates.io", -src/liblog/lib.rs:161:#![unstable(feature = "rustc_private", -src/librand/lib.rs:29:#![unstable(feature = "rand", -src/librand/reseeding.rs:114:#[stable(feature = "rust1", since = "1.0.0")] -src/librand/reseeding.rs:116: #[stable(feature = "rust1", since = "1.0.0")] -src/librbml/lib.rs:117:#![unstable(feature = "rustc_private", issue = "27812")] -src/librbml/lib.rs:965: // we should never try to move the stable positions, however. -src/librbml/lib.rs:1102: /// Returns the current position while marking it stable, i.e. -src/librbml/lib.rs:1104: pub fn mark_stable_position(&mut self) -> u64 { -src/librustc/diagnostics.rs:2033:#[stable] // error: stability attributes may not be used outside of the -src/librustc/front/map/mod.rs:408: /// regard should be expected to be highly unstable. -src/librustc/lib.rs:15://! This API is completely unstable and subject to change. -src/librustc/lib.rs:20:#![unstable(feature = "rustc_private", issue = "27812")] -src/librustc/lint/builtin.rs:82: "stable features found in #[feature] directive" -src/librustc/metadata/creader.rs:522: allow_internal_unstable: false, -src/librustc/metadata/encoder.rs:97: let position = rbml_w.mark_stable_position(); -src/librustc/metadata/encoder.rs:890: xref_positions[id as usize] = rbml_w.mark_stable_position() as u32; -src/librustc/metadata/macro_import.rs:163: def.allow_internal_unstable = attr::contains_name(&def.attrs, -src/librustc/metadata/macro_import.rs:164: "allow_internal_unstable"); -src/librustc/metadata/tyencode.rs:62: // type abbreviations needs a stable position -src/librustc/metadata/tyencode.rs:63: let pos = w.mark_stable_position(); -src/librustc/metadata/tyencode.rs:168: let end = w.mark_stable_position(); -src/librustc/metadata/tyencode.rs:182: // other won't have to `mark_stable_position` -src/librustc/middle/check_const.rs:42:use syntax::feature_gate::UnstableFeatures; -src/librustc/middle/check_const.rs:221: // this doesn't come from a macro that has #[allow_internal_unstable] -src/librustc/middle/check_const.rs:222: !self.tcx.sess.codemap().span_allows_unstable(expr.span) -src/librustc/middle/check_const.rs:226: &format!("const fns are an unstable feature")); -src/librustc/middle/check_const.rs:717: if let UnstableFeatures::Disallow = v.tcx.sess.opts.unstable_features { -src/librustc/middle/const_eval.rs:263: #[stable(feature = "rust1", since = "1.0.0")] -src/librustc/middle/stability.rs:79: // Check if deprecated_since < stable_since. If it is, -src/librustc/middle/stability.rs:81: let deprecated_predates_stable = match (stab.deprecated_since.as_ref(), -src/librustc/middle/stability.rs:111: if deprecated_predates_stable { -src/librustc/middle/stability.rs:119: // Don't inherit #[stable(feature = "rust1", since = "1.0.0")] -src/librustc/middle/stability.rs:150: if tag == "unstable" || tag == "stable" || tag == "deprecated" { -src/librustc/middle/stability.rs:260:/// Cross-references the feature names of unstable APIs with enabled -src/librustc/middle/stability.rs:263:pub fn check_unstable_api_usage(tcx: &ty::ctxt) -src/librustc/middle/stability.rs:291: // Only the cross-crate scenario matters when checking unstable APIs -src/librustc/middle/stability.rs:296: Some(&Stability { level: attr::Unstable, ref feature, ref reason, issue, .. }) => { -src/librustc/middle/stability.rs:297: self.used_features.insert(feature.clone(), attr::Unstable); -src/librustc/middle/stability.rs:301: Some(ref r) => format!("use of unstable library feature '{}': {}", -src/librustc/middle/stability.rs:303: None => format!("use of unstable library feature '{}'", &feature) -src/librustc/middle/stability.rs:391: // individually as it's possible to have a stable trait with unstable -src/librustc/middle/stability.rs:548: tcx.sess.codemap().span_allows_unstable(span) -src/librustc/middle/stability.rs:612:pub fn check_unused_or_stable_features(sess: &Session, -src/librustc/middle/stability.rs:619: let stable_msg = "this feature is stable. attribute no longer needed"; -src/librustc/middle/stability.rs:621: for &span in &sess.features.borrow().declared_stable_lang_features { -src/librustc/middle/stability.rs:625: stable_msg.to_string()); -src/librustc/middle/stability.rs:635: stable_msg.to_string()); -src/librustc/plugin/registry.rs:98: NormalTT(ext, _, allow_internal_unstable) => { -src/librustc/plugin/registry.rs:99: NormalTT(ext, Some(self.krate_span), allow_internal_unstable) -src/librustc/plugin/registry.rs:101: IdentTT(ext, _, allow_internal_unstable) => { -src/librustc/plugin/registry.rs:102: IdentTT(ext, Some(self.krate_span), allow_internal_unstable) -src/librustc/session/config.rs:33:use syntax::feature_gate::UnstableFeatures; -src/librustc/session/config.rs:116: /// Indicates how the compiler should treat unstable features -src/librustc/session/config.rs:117: pub unstable_features: UnstableFeatures -src/librustc/session/config.rs:223: unstable_features: UnstableFeatures::Disallow, -src/librustc/session/config.rs:583: unstable_options: bool = (false, parse_bool, -src/librustc/session/config.rs:584: "Adds unstable command line options to rustc interface"), -src/librustc/session/config.rs:678:/// Returns the "short" subset of the stable rustc command line options. -src/librustc/session/config.rs:681: .filter(|g|g.is_stable()) -src/librustc/session/config.rs:686:/// Returns all of the stable rustc command line options. -src/librustc/session/config.rs:689: .filter(|g|g.is_stable()) -src/librustc/session/config.rs:695:pub enum OptionStability { Stable, Unstable } -src/librustc/session/config.rs:704: pub fn is_stable(&self) -> bool { -src/librustc/session/config.rs:708: fn stable(g: getopts::OptGroup) -> RustcOptGroup { -src/librustc/session/config.rs:712: fn unstable(g: getopts::OptGroup) -> RustcOptGroup { -src/librustc/session/config.rs:713: RustcOptGroup { opt_group: g, stability: OptionStability::Unstable } -src/librustc/session/config.rs:721:// *unstable* options, i.e. options that are only enabled when the -src/librustc/session/config.rs:722:// user also passes the `-Z unstable-options` debugging flag. -src/librustc/session/config.rs:734: fn stable(g: getopts::OptGroup) -> R { RustcOptGroup::stable(g) } -src/librustc/session/config.rs:735: fn unstable(g: getopts::OptGroup) -> R { RustcOptGroup::unstable(g) } -src/librustc/session/config.rs:737: // FIXME (pnkfelix): We default to stable since the current set of -src/librustc/session/config.rs:738: // options is defacto stable. However, it would be good to revise the -src/librustc/session/config.rs:739: // code so that a stable option is the thing that takes extra effort -src/librustc/session/config.rs:742: pub fn opt(a: S, b: S, c: S, d: S) -> R { stable(getopts::optopt(a, b, c, d)) } -src/librustc/session/config.rs:743: pub fn multi(a: S, b: S, c: S, d: S) -> R { stable(getopts::optmulti(a, b, c, d)) } -src/librustc/session/config.rs:744: pub fn flag(a: S, b: S, c: S) -> R { stable(getopts::optflag(a, b, c)) } -src/librustc/session/config.rs:745: pub fn flagopt(a: S, b: S, c: S, d: S) -> R { stable(getopts::optflagopt(a, b, c, d)) } -src/librustc/session/config.rs:746: pub fn flagmulti(a: S, b: S, c: S) -> R { stable(getopts::optflagmulti(a, b, c)) } -src/librustc/session/config.rs:749: pub fn opt_u(a: S, b: S, c: S, d: S) -> R { unstable(getopts::optopt(a, b, c, d)) } -src/librustc/session/config.rs:750: pub fn multi_u(a: S, b: S, c: S, d: S) -> R { unstable(getopts::optmulti(a, b, c, d)) } -src/librustc/session/config.rs:751: pub fn flag_u(a: S, b: S, c: S) -> R { unstable(getopts::optflag(a, b, c)) } -src/librustc/session/config.rs:752: pub fn flagopt_u(a: S, b: S, c: S, d: S) -> R { unstable(getopts::optflagopt(a, b, c, d)) } -src/librustc/session/config.rs:753: pub fn flagmulti_u(a: S, b: S, c: S) -> R { unstable(getopts::optflagmulti(a, b, c)) } -src/librustc/session/config.rs:758:/// part of the stable long-term interface for rustc. -src/librustc/session/config.rs:807:/// each option, such as whether the option is part of the stable -src/librustc/session/config.rs:829: "Present the input source, unstable (and less-pretty) variants; -src/librustc/session/config.rs:1057: unstable_features: get_unstable_features_setting(), -src/librustc/session/config.rs:1062:pub fn get_unstable_features_setting() -> UnstableFeatures { -src/librustc/session/config.rs:1063: // Whether this is a feature-staged build, i.e. on the beta or stable channel -src/librustc/session/config.rs:1064: let disable_unstable_features = option_env!("CFG_DISABLE_UNSTABLE_FEATURES").is_some(); -src/librustc/session/config.rs:1066: // subverting the unstable features lints -src/librustc/session/config.rs:1070: match (disable_unstable_features, bootstrap_secret_key, bootstrap_provided_key) { -src/librustc/session/config.rs:1071: (_, Some(ref s), Some(ref p)) if s == p => UnstableFeatures::Cheat, -src/librustc/session/config.rs:1072: (true, _, _) => UnstableFeatures::Disallow, -src/librustc/session/config.rs:1073: (false, _, _) => UnstableFeatures::Allow -src/librustc/session/mod.rs:289: pub fn unstable_options(&self) -> bool { -src/librustc/session/mod.rs:290: self.opts.debugging_opts.unstable_options -src/librustc_back/lib.rs:27:#![unstable(feature = "rustc_private", issue = "27812")] -src/librustc_back/svh.rs:161: // hash leads to unstable SVH, because ident.name is just an index -src/librustc_bitflags/lib.rs:21:#![unstable(feature = "rustc_private", issue = "27812")] -src/librustc_borrowck/borrowck/mod.rs:105: stable_paths: 0, -src/librustc_borrowck/borrowck/mod.rs:120: println!("stable paths : {}", -src/librustc_borrowck/borrowck/mod.rs:121: make_stat(&bccx, bccx.stats.stable_paths)); -src/librustc_borrowck/borrowck/mod.rs:257: stable_paths: 0, -src/librustc_borrowck/borrowck/mod.rs:300: stable_paths: usize, -src/librustc_borrowck/diagnostics.rs:280:https://doc.rust-lang.org/stable/book/references-and-borrowing.html for more -src/librustc_borrowck/lib.rs:14:#![unstable(feature = "rustc_private", issue = "27812")] -src/librustc_data_structures/lib.rs:17://! This API is completely unstable and subject to change. -src/librustc_data_structures/lib.rs:22:#![unstable(feature = "rustc_private", issue = "27812")] -src/librustc_driver/driver.rs:562: sess.opts.unstable_features); -src/librustc_driver/driver.rs:606: sess.opts.unstable_features); -src/librustc_driver/driver.rs:773: stability::check_unstable_api_usage(tcx)); -src/librustc_driver/driver.rs:776: stability::check_unused_or_stable_features( -src/librustc_driver/lib.rs:15://! This API is completely unstable and subject to change. -src/librustc_driver/lib.rs:20:#![unstable(feature = "rustc_private", issue = "27812")] -src/librustc_driver/lib.rs:139: if sess.unstable_options() { -src/librustc_driver/lib.rs:344: let pretty = if sess.opts.debugging_opts.unstable_options { -src/librustc_driver/lib.rs:346: // stable pretty-print variants only -src/librustc_driver/lib.rs:352: if pretty.is_none() && sess.unstable_options() { -src/librustc_driver/lib.rs:354: // extended with unstable pretty-print variants -src/librustc_driver/lib.rs:515:fn usage(verbose: bool, include_unstable_options: bool) { -src/librustc_driver/lib.rs:522: .filter(|x| include_unstable_options || x.is_stable()) -src/librustc_driver/lib.rs:688: // user did not write `-v` nor `-Z unstable-options`, so do not -src/librustc_driver/lib.rs:694: fn allows_unstable_options(matches: &getopts::Matches) -> bool { -src/librustc_driver/lib.rs:696: r.iter().any(|x| *x == "unstable-options") -src/librustc_driver/lib.rs:704: if !allows_unstable_options(&m) { -src/librustc_driver/lib.rs:705: // If -Z unstable-options was not specified, verify that -src/librustc_driver/lib.rs:706: // no unstable options were present. -src/librustc_driver/lib.rs:707: for opt in config::rustc_optgroups().into_iter().filter(|x| !x.is_stable()) { -src/librustc_driver/lib.rs:714: early_error(diagnostic::Auto, &format!("use of unstable option '{}' \ -src/librustc_driver/lib.rs:715: requires -Z unstable-options", -src/librustc_driver/lib.rs:727: // the stable options. -src/librustc_driver/lib.rs:729: Ok(ref m) if allows_unstable_options(m) => { -src/librustc_driver/lib.rs:730: // If -Z unstable-options was specified, redo parsing with the -src/librustc_driver/lib.rs:731: // unstable options to ensure that unstable options are defined -src/librustc_driver/lib.rs:737: // redo option parsing, including unstable options this time, -src/librustc_driver/lib.rs:739: // unstable ones. -src/librustc_driver/lib.rs:745: usage(matches.opt_present("verbose"), allows_unstable_options(&matches)); -src/librustc_driver/test.rs:39:use syntax::feature_gate::UnstableFeatures; -src/librustc_driver/test.rs:110: options.unstable_features = UnstableFeatures::Allow; -src/librustc_front/attr.rs:353: Unstable, -src/librustc_front/attr.rs:376: if tag != "deprecated" && tag != "unstable" && tag != "stable" { -src/librustc_front/attr.rs:442: // Unstable tags don't require a version -src/librustc_front/attr.rs:443: if since == None && tag != "unstable" { -src/librustc_front/attr.rs:447: if tag == "unstable" || tag == "stable" { -src/librustc_front/attr.rs:453: "unstable" => Unstable, -src/librustc_front/attr.rs:454: "stable" => Stable, -src/librustc_front/attr.rs:485: either stable or unstable attribute"); -src/librustc_front/attr.rs:488: } else if stab.as_ref().map_or(false, |s| s.level == Unstable && s.issue.is_none()) { -src/librustc_front/attr.rs:489: // non-deprecated unstable items need to point to issues. -src/librustc_front/attr.rs:491: "non-deprecated unstable items need to point \ -src/librustc_front/hir.rs:347: pub allow_internal_unstable: bool, -src/librustc_front/lib.rs:15://! This API is completely unstable and subject to change. -src/librustc_front/lib.rs:20:#![unstable(feature = "rustc_private", issue = "27812")] -src/librustc_front/lowering.rs:581: allow_internal_unstable: m.allow_internal_unstable, -src/librustc_lint/builtin.rs:701: attr::Unstable => attr::Unstable, -src/librustc_lint/builtin.rs:1192:pub struct UnstableFeatures; -src/librustc_lint/builtin.rs:1197: "enabling unstable features (deprecated. do not use)" -src/librustc_lint/builtin.rs:1200:impl LintPass for UnstableFeatures { -src/librustc_lint/builtin.rs:1206:impl LateLintPass for UnstableFeatures { -src/librustc_lint/builtin.rs:1211: ctx.span_lint(UNSTABLE_FEATURES, item.span, "unstable feature"); -src/librustc_lint/lib.rs:20://! This API is completely unstable and subject to change. -src/librustc_lint/lib.rs:25:#![unstable(feature = "rustc_private", issue = "27812")] -src/librustc_lint/lib.rs:127: UnstableFeatures, -src/librustc_lint/types.rs:397: /// Check if the given type is "ffi-safe" (has a stable, well-defined -src/librustc_lint/types.rs:505: // Primitive types with a stable representation. -src/librustc_llvm/lib.rs:20:#![unstable(feature = "rustc_private", issue = "27812")] -src/librustc_platform_intrinsics/lib.rs:13:#![unstable(feature = "rustc_private", issue = "27812")] -src/librustc_privacy/lib.rs:14:#![unstable(feature = "rustc_private", issue = "27812")] -src/librustc_resolve/lib.rs:14:#![unstable(feature = "rustc_private", issue = "27812")] -src/librustc_trans/back/link.rs:110: * - The hash shown in the filename needs to be predictable and stable for -src/librustc_trans/lib.rs:15://! This API is completely unstable and subject to change. -src/librustc_trans/lib.rs:20:#![unstable(feature = "rustc_private", issue = "27812")] -src/librustc_trans/trans/datum.rs:707: /// This function is private to datums because it leaves memory in an unstable state, where the -src/librustc_trans/trans/debuginfo/doc.rs:171://! This algorithm also provides a stable ID for types that are defined in one -src/librustc_typeck/astconv.rs:850: parenthetical notation is only stable when used with `Fn`-family traits"); -src/librustc_typeck/check/mod.rs:201: ExpectCastableToType(Ty<'tcx>), -src/librustc_typeck/check/mod.rs:209: // Disregard "castable to" expectations because they -src/librustc_typeck/check/mod.rs:212: // "castable to u8" constraint to 22, it will pick the -src/librustc_typeck/check/mod.rs:215: // "castable to" expectation is not the tightest thing -src/librustc_typeck/check/mod.rs:3493: check_expr_with_expectation(fcx, e, ExpectCastableToType(t_cast)); -src/librustc_typeck/check/mod.rs:3863: ExpectCastableToType(t) => { -src/librustc_typeck/check/mod.rs:3864: ExpectCastableToType( -src/librustc_typeck/check/mod.rs:3881: ExpectCastableToType(ty) | -src/librustc_typeck/check/writeback.rs:131: "overloaded augmented assignments are not stable"); -src/librustc_typeck/diagnostics.rs:2981: // https://doc.rust-lang.org/stable/std/ops/trait.Shl.html -src/librustc_typeck/diagnostics.rs:3365:// E0215, // angle-bracket notation is not stable with `Fn` -src/librustc_typeck/diagnostics.rs:3366:// E0216, // parenthetical notation is only stable with `Fn` -src/librustc_typeck/lib.rs:62:This API is completely unstable and subject to change. -src/librustc_typeck/lib.rs:68:#![unstable(feature = "rustc_private", issue = "27812")] -src/librustc_unicode/char.rs:30:#![stable(feature = "rust1", since = "1.0.0")] -src/librustc_unicode/char.rs:37:// stable reexports -src/librustc_unicode/char.rs:40:// unstable reexports -src/librustc_unicode/char.rs:46:#[stable(feature = "rust1", since = "1.0.0")] -src/librustc_unicode/char.rs:49:#[stable(feature = "rust1", since = "1.0.0")] -src/librustc_unicode/char.rs:58:#[stable(feature = "rust1", since = "1.0.0")] -src/librustc_unicode/char.rs:61:#[stable(feature = "rust1", since = "1.0.0")] -src/librustc_unicode/char.rs:110:#[stable(feature = "rust1", since = "1.0.0")] -src/librustc_unicode/char.rs:166: #[stable(feature = "rust1", since = "1.0.0")] -src/librustc_unicode/char.rs:230: #[stable(feature = "rust1", since = "1.0.0")] -src/librustc_unicode/char.rs:263: #[stable(feature = "rust1", since = "1.0.0")] -src/librustc_unicode/char.rs:310: #[stable(feature = "rust1", since = "1.0.0")] -src/librustc_unicode/char.rs:359: #[stable(feature = "rust1", since = "1.0.0")] -src/librustc_unicode/char.rs:379: #[stable(feature = "rust1", since = "1.0.0")] -src/librustc_unicode/char.rs:415: #[unstable(feature = "unicode", -src/librustc_unicode/char.rs:455: #[unstable(feature = "unicode", -src/librustc_unicode/char.rs:481: #[stable(feature = "rust1", since = "1.0.0")] -src/librustc_unicode/char.rs:497: #[unstable(feature = "unicode", -src/librustc_unicode/char.rs:509: #[unstable(feature = "unicode", -src/librustc_unicode/char.rs:541: #[stable(feature = "rust1", since = "1.0.0")] -src/librustc_unicode/char.rs:577: #[stable(feature = "rust1", since = "1.0.0")] -src/librustc_unicode/char.rs:607: #[stable(feature = "rust1", since = "1.0.0")] -src/librustc_unicode/char.rs:651: #[stable(feature = "rust1", since = "1.0.0")] -src/librustc_unicode/char.rs:674: #[stable(feature = "rust1", since = "1.0.0")] -src/librustc_unicode/char.rs:712: #[stable(feature = "rust1", since = "1.0.0")] -src/librustc_unicode/char.rs:753: #[stable(feature = "rust1", since = "1.0.0")] -src/librustc_unicode/char.rs:816: #[stable(feature = "rust1", since = "1.0.0")] -src/librustc_unicode/char.rs:824:#[unstable(feature = "decode_utf16", reason = "recently exposed", issue = "27830")] -src/librustc_unicode/char.rs:875:#[unstable(feature = "decode_utf16", reason = "recently exposed", issue = "27830")] -src/librustc_unicode/char.rs:884:#[unstable(feature = "decode_utf16", reason = "recently exposed", issue = "27830")] -src/librustc_unicode/char.rs:934:#[unstable(feature = "decode_utf16", reason = "recently added", issue = "27830")] -src/librustc_unicode/lib.rs:26:#![unstable(feature = "unicode", issue = "27783")] -src/librustc_unicode/u_str.rs:24:#[stable(feature = "split_whitespace", since = "1.1.0")] -src/librustc_unicode/u_str.rs:124:#[unstable(feature = "decode_utf16", reason = "not exposed in std", issue = "27830")] -src/librustc_unicode/u_str.rs:133:#[unstable(feature = "decode_utf16", reason = "not exposed in std", issue = "27830")] -src/librustc_unicode/u_str.rs:157:#[unstable(feature = "decode_utf16", reason = "not exposed in std", issue = "27830")] -src/librustc_unicode/u_str.rs:202:#[unstable(feature = "decode_utf16", reason = "not exposed in std", issue = "27830")] -src/librustdoc/clean/mod.rs:58:/// A stable identifier to the particular version of JSON output. -src/librustdoc/clean/mod.rs:327: attr::Unstable => "unstable".to_string(), -src/librustdoc/core.rs:25:use syntax::feature_gate::UnstableFeatures; -src/librustdoc/core.rs:112: unstable_features: UnstableFeatures::Allow, -src/librustdoc/html/markdown.rs:393:pub fn find_testable_code(doc: &str, tests: &mut ::test::Collector) { -src/librustdoc/html/render.rs:1611: (Some(attr::Unstable), Some(attr::Stable)) => return Ordering::Greater, -src/librustdoc/html/render.rs:1612: (Some(attr::Stable), Some(attr::Unstable)) => return Ordering::Less, -src/librustdoc/html/render.rs:1727: } else if stab.level == attr::Unstable { -src/librustdoc/html/render.rs:1728: let unstable_extra = if show_reason { -src/librustdoc/html/render.rs:1743: format!("Unstable{}{}", unstable_extra, Markdown(&reason)) -src/librustdoc/html/static/main.css:512:em.stab.unstable { background: #FFF5D6; border-color: #FFC600; } -src/librustdoc/html/static/main.css:534:.module-item.unstable { -src/librustdoc/lib.rs:14:#![unstable(feature = "rustdoc", issue = "27812")] -src/librustdoc/markdown.rs:26:use html::markdown::{Markdown, MarkdownWithToc, find_testable_code, reset_headers}; -src/librustdoc/markdown.rs:152: find_testable_code(&input_str, &mut collector); -src/librustdoc/test.rs:27:use rustc::session::config::{get_unstable_features_setting, OutputType}; -src/librustdoc/test.rs:65: unstable_features: get_unstable_features_setting(), -src/librustdoc/test.rs:185: unstable_features: get_unstable_features_setting(), -src/librustdoc/test.rs:430: markdown::find_testable_code(doc, &mut *self); -src/libserialize/lib.rs:20:#![unstable(feature = "rustc_private", -src/libstd/ascii.rs:13:#![stable(feature = "rust1", since = "1.0.0")] -src/libstd/ascii.rs:21:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ascii.rs:24: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ascii.rs:40: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ascii.rs:59: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ascii.rs:78: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ascii.rs:100: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ascii.rs:120: #[unstable(feature = "ascii", issue = "27809")] -src/libstd/ascii.rs:140: #[unstable(feature = "ascii", issue = "27809")] -src/libstd/ascii.rs:144:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ascii.rs:185:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ascii.rs:228:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ascii.rs:247:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ascii.rs:286:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ascii.rs:317:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ascii.rs:340:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ascii.rs:346:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ascii.rs:352:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:308:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:516: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:530: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:556: #[unstable(feature = "hashmap_hasher", reason = "hasher stuff is unclear", -src/libstd/collections/hash/map.rs:587: #[unstable(feature = "hashmap_hasher", reason = "hasher stuff is unclear", -src/libstd/collections/hash/map.rs:612: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:632: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:744: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:838: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:863: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:888: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:916: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:940: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:961: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:977: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1002: #[unstable(feature = "drain", -src/libstd/collections/hash/map.rs:1027: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1049: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1072: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1097: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1120: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1149: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1220:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1225:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1234:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1244:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1259:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1274:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1280:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1286:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1301:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1316:#[unstable(feature = "drain", -src/libstd/collections/hash/map.rs:1324:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1330:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1338:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1341: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1345: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1358:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1370:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1382:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1416:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1423:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1428:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1435:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1440:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1447:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1452:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1459:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1464:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1471:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1476:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1483:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1489: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1499: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1512: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1518: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1525: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1531: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1539: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1548: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1561:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1575:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/map.rs:1586:#[stable(feature = "hash_extend_copy", since = "1.4.0")] -src/libstd/collections/hash/map.rs:1601:#[unstable(feature = "hashmap_hasher", -src/libstd/collections/hash/map.rs:1609:#[unstable(feature = "hashmap_hasher", -src/libstd/collections/hash/map.rs:1622:#[unstable(feature = "hashmap_hasher", -src/libstd/collections/hash/map.rs:1633:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:111:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:126: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:141: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:168: #[unstable(feature = "hashmap_hasher", reason = "hasher stuff is unclear", -src/libstd/collections/hash/set.rs:195: #[unstable(feature = "hashmap_hasher", reason = "hasher stuff is unclear", -src/libstd/collections/hash/set.rs:214: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:234: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:255: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:276: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:303: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:331: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:354: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:379: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:396: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:411: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:416: #[unstable(feature = "drain", -src/libstd/collections/hash/set.rs:438: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:456: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:468: #[unstable(feature = "set_recovery", issue = "28050")] -src/libstd/collections/hash/set.rs:492: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:513: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:538: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:557: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:562: #[unstable(feature = "set_recovery", issue = "28050")] -src/libstd/collections/hash/set.rs:585: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:597: #[unstable(feature = "set_recovery", issue = "28050")] -src/libstd/collections/hash/set.rs:605:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:616:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:621:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:631:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:645:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:657:#[stable(feature = "hash_extend_copy", since = "1.4.0")] -src/libstd/collections/hash/set.rs:667:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:672: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:678:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:710:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:742:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:774:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:807:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:813:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:819:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:825:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:834:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:843:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:849:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:854:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:866:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:905:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:912:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:917:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:924:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:929:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:936:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:947:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:976:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:1005:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/set.rs:1019:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/hash/state.rs:11:#![unstable(feature = "hashmap_hasher", reason = "hasher stuff is unclear", -src/libstd/collections/mod.rs:363:#![stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/mod.rs:377:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/mod.rs:383:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/collections/mod.rs:391:#[unstable(feature = "hashmap_hasher", reason = "module was recently added", -src/libstd/dynamic_lib.rs:15:#![unstable(feature = "dynamic_lib", -src/libstd/env.rs:17:#![stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:48:#[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:66:#[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:77:#[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:84:#[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:111:#[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:134:#[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:140:#[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:151:#[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:175:#[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:201:#[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:213:#[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:217: #[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:223: #[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:227:#[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:239:#[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:272:#[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:307:#[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:321:#[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:344:#[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:349:#[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:359:#[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:386:#[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:395:#[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:402:#[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:431:#[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:459:#[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:487:#[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:496:#[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:503:#[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:529:#[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:551:#[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:556:#[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:565:#[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:570:#[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:577:#[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:583:#[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:597: #[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:606: #[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:624: #[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:634: #[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:645: #[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:656: #[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:666: #[stable(feature = "env", since = "1.0.0")] -src/libstd/env.rs:676: #[stable(feature = "env", since = "1.0.0")] -src/libstd/error.rs:37:#![stable(feature = "rust1", since = "1.0.0")] -src/libstd/error.rs:64:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/error.rs:71: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/error.rs:75: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/error.rs:80: #[unstable(feature = "error_type_id", -src/libstd/error.rs:88:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/error.rs:95:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/error.rs:102:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/error.rs:122:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/error.rs:129:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/error.rs:134:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/error.rs:141:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/error.rs:148:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/error.rs:155:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/error.rs:162:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/error.rs:172: #[stable(feature = "error_downcast", since = "1.3.0")] -src/libstd/error.rs:187: #[stable(feature = "error_downcast", since = "1.3.0")] -src/libstd/error.rs:205: #[stable(feature = "error_downcast", since = "1.3.0")] -src/libstd/error.rs:224: #[stable(feature = "error_downcast", since = "1.3.0")] -src/libstd/error.rs:231: #[stable(feature = "error_downcast", since = "1.3.0")] -src/libstd/error.rs:238: #[stable(feature = "error_downcast", since = "1.3.0")] -src/libstd/error.rs:247: #[stable(feature = "error_downcast", since = "1.3.0")] -src/libstd/error.rs:254: #[stable(feature = "error_downcast", since = "1.3.0")] -src/libstd/error.rs:261: #[stable(feature = "error_downcast", since = "1.3.0")] -src/libstd/error.rs:270: #[stable(feature = "error_downcast", since = "1.3.0")] -src/libstd/error.rs:291: #[stable(feature = "error_downcast", since = "1.3.0")] -src/libstd/error.rs:305: #[stable(feature = "error_downcast", since = "1.3.0")] -src/libstd/ffi/c_str.rs:65:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/c_str.rs:139:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/c_str.rs:151:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/c_str.rs:182: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/c_str.rs:200: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/c_str.rs:211: #[unstable(feature = "cstr_memory2", reason = "recently added", -src/libstd/ffi/c_str.rs:223: #[stable(feature = "cstr_memory", since = "1.4.0")] -src/libstd/ffi/c_str.rs:238: #[unstable(feature = "cstr_memory2", reason = "recently added", -src/libstd/ffi/c_str.rs:253: #[stable(feature = "cstr_memory", since = "1.4.0")] -src/libstd/ffi/c_str.rs:262: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/c_str.rs:269: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/c_str.rs:275:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/c_str.rs:284:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/c_str.rs:291:#[stable(feature = "cstr_debug", since = "1.3.0")] -src/libstd/ffi/c_str.rs:302:#[stable(feature = "cstr_borrow", since = "1.3.0")] -src/libstd/ffi/c_str.rs:310: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/c_str.rs:315: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/c_str.rs:319:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/c_str.rs:324:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/c_str.rs:331:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/c_str.rs:377: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/c_str.rs:388: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/c_str.rs:405: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/c_str.rs:419: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/c_str.rs:433: #[stable(feature = "cstr_to_str", since = "1.4.0")] -src/libstd/ffi/c_str.rs:453: #[stable(feature = "cstr_to_str", since = "1.4.0")] -src/libstd/ffi/c_str.rs:459:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/c_str.rs:465:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/c_str.rs:467:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/c_str.rs:473:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/c_str.rs:480:#[stable(feature = "cstr_borrow", since = "1.3.0")] -src/libstd/ffi/mod.rs:13:#![stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/mod.rs:15:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/mod.rs:18:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:47:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:53:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:60: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:74: #[unstable(feature = "convert", reason = "recently added", issue = "27704")] -src/libstd/ffi/os_str.rs:91: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:99: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:105: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:111:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:118:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:125:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:135:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:145:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:152:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:159:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:166:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:173:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:176:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:192:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:200:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:208:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:218: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:230: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:238: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:244: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:258: #[unstable(feature = "convert", reason = "recently added", issue = "27704")] -src/libstd/ffi/os_str.rs:274: #[unstable(feature = "convert", reason = "recently added", issue = "27704")] -src/libstd/ffi/os_str.rs:288:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:295:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:302:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:309:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:312:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:328:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:339:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:345:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:353:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:360:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:365:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:371:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:378:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:385:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/ffi/os_str.rs:392:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:18:#![stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:52:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:62:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:76:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:84:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:88:#[unstable(feature = "fs_walk", -src/libstd/fs.rs:137:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:147:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:151:#[stable(feature = "file_type", since = "1.1.0")] -src/libstd/fs.rs:158:#[unstable(feature = "dir_builder", reason = "recently added API", -src/libstd/fs.rs:185: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:207: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:231: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:260: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:288: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:306: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:332:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:341:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:348:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:354:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:360:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:367:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:386: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:403: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:420: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:437: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:454: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:471: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:495: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:512: #[stable(feature = "file_type", since = "1.1.0")] -src/libstd/fs.rs:531: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:548: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:565: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:582: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:608: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:636: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:644: #[stable(feature = "file_type", since = "1.1.0")] -src/libstd/fs.rs:648: #[stable(feature = "file_type", since = "1.1.0")] -src/libstd/fs.rs:652: #[stable(feature = "file_type", since = "1.1.0")] -src/libstd/fs.rs:670:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:679:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:708: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:721: #[stable(feature = "dir_entry_ext", since = "1.1.0")] -src/libstd/fs.rs:736: #[stable(feature = "dir_entry_ext", since = "1.1.0")] -src/libstd/fs.rs:743: #[stable(feature = "dir_entry_ext", since = "1.1.0")] -src/libstd/fs.rs:775:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:803:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:821:#[stable(feature = "symlink_metadata", since = "1.1.0")] -src/libstd/fs.rs:847:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:881:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:901:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:927:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:950:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:957:#[unstable(feature = "fs_canonicalize", reason = "recently added API", -src/libstd/fs.rs:980:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:1005:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:1027:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:1052:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:1103:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/fs.rs:1116:#[unstable(feature = "fs_walk", -src/libstd/fs.rs:1130:#[unstable(feature = "fs_walk", issue = "27707")] -src/libstd/fs.rs:1160:#[unstable(feature = "path_ext", -src/libstd/fs.rs:1162: change and some methods may be removed. For stable code, \ -src/libstd/fs.rs:1254:#[stable(feature = "set_permissions", since = "1.1.0")] -src/libstd/fs.rs:1260:#[unstable(feature = "dir_builder", reason = "recently added API", -src/libstd/io/buffered.rs:46:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/buffered.rs:69: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/buffered.rs:90: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/buffered.rs:118: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/buffered.rs:139: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/buffered.rs:160: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/buffered.rs:164:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/buffered.rs:182:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/buffered.rs:199:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/buffered.rs:209:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/buffered.rs:298:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/buffered.rs:329:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/buffered.rs:343: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/buffered.rs:361: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/buffered.rs:405: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/buffered.rs:423: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/buffered.rs:441: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/buffered.rs:450:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/buffered.rs:468:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/buffered.rs:478:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/buffered.rs:526: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/buffered.rs:559: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/buffered.rs:563:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/buffered.rs:568:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/buffered.rs:575:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/buffered.rs:630:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/buffered.rs:650: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/buffered.rs:671: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/buffered.rs:692: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/buffered.rs:715: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/buffered.rs:737: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/buffered.rs:745:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/buffered.rs:762:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/cursor.rs:77:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/cursor.rs:96: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/cursor.rs:114: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/cursor.rs:130: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/cursor.rs:149: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/cursor.rs:171: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/cursor.rs:191: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/cursor.rs:195:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/cursor.rs:214:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/cursor.rs:223:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/cursor.rs:232:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/cursor.rs:243:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/error.rs:51:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/error.rs:61:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/error.rs:82:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/error.rs:85: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/error.rs:88: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/error.rs:91: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/error.rs:94: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/error.rs:97: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/error.rs:100: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/error.rs:104: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/error.rs:108: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/error.rs:111: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/error.rs:114: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/error.rs:118: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/error.rs:121: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/error.rs:131: #[stable(feature = "io_invalid_data", since = "1.2.0")] -src/libstd/io/error.rs:134: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/error.rs:142: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/error.rs:147: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/error.rs:150: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/error.rs:159: #[unstable(feature = "read_exact", reason = "recently added", issue = "27585")] -src/libstd/io/error.rs:163: #[unstable(feature = "io_error_internals", -src/libstd/io/error.rs:190: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/error.rs:211: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/error.rs:217: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/error.rs:227: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/error.rs:239: #[stable(feature = "io_error_inner", since = "1.3.0")] -src/libstd/io/error.rs:252: #[stable(feature = "io_error_inner", since = "1.3.0")] -src/libstd/io/error.rs:264: #[stable(feature = "io_error_inner", since = "1.3.0")] -src/libstd/io/error.rs:273: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/error.rs:293:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/error.rs:306:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/impls.rs:23:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/impls.rs:45:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/impls.rs:63:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/impls.rs:68:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/impls.rs:87:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/impls.rs:109:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/impls.rs:127:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/impls.rs:132:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/impls.rs:154:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/impls.rs:177:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/impls.rs:186:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/impls.rs:210:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:242:#![stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:410:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:460: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:502: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:540: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:602: #[unstable(feature = "read_exact", reason = "recently added", issue = "27585")] -src/libstd/io/mod.rs:654: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:684: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:721: #[unstable(feature = "io", reason = "the semantics of a partial read/write \ -src/libstd/io/mod.rs:759: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:793: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:829: #[unstable(feature = "io", reason = "the semantics of a partial read/write \ -src/libstd/io/mod.rs:868:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:908: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:934: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:961: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:1013: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:1062: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:1092: #[unstable(feature = "io", reason = "the semantics of a partial read/write \ -src/libstd/io/mod.rs:1129:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:1143: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:1149:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:1152: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:1160: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:1168: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:1251:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:1296: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:1318: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:1359: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:1407: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:1440: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:1465: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:1477:#[unstable(feature = "io", reason = "awaiting stability of Write::broadcast", -src/libstd/io/mod.rs:1484:#[unstable(feature = "io", reason = "awaiting stability of Write::broadcast", -src/libstd/io/mod.rs:1505:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:1512:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:1531:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:1537:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:1546: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:1550:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:1565:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:1587:#[unstable(feature = "io", reason = "awaiting stability of Read::tee", -src/libstd/io/mod.rs:1594:#[unstable(feature = "io", reason = "awaiting stability of Read::tee", -src/libstd/io/mod.rs:1611:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:1616:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:1636:#[unstable(feature = "io", reason = "awaiting stability of Read::chars", -src/libstd/io/mod.rs:1645:#[unstable(feature = "io", reason = "awaiting stability of Read::chars", -src/libstd/io/mod.rs:1656:#[unstable(feature = "io", reason = "awaiting stability of Read::chars", -src/libstd/io/mod.rs:1689:#[unstable(feature = "io", reason = "awaiting stability of Read::chars", -src/libstd/io/mod.rs:1706:#[unstable(feature = "io", reason = "awaiting stability of Read::chars", -src/libstd/io/mod.rs:1726:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:1732:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:1757:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/mod.rs:1762:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/prelude.rs:21:#![stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/stdio.rs:144:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/stdio.rs:153:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/stdio.rs:194:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/stdio.rs:226: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/stdio.rs:257: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/stdio.rs:263:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/stdio.rs:279:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/stdio.rs:289:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/stdio.rs:318:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/stdio.rs:330:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/stdio.rs:371:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/stdio.rs:394: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/stdio.rs:400:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/stdio.rs:415:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/stdio.rs:428:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/stdio.rs:437:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/stdio.rs:474:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/stdio.rs:496: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/stdio.rs:502:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/stdio.rs:517:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/stdio.rs:535:#[unstable(feature = "set_stdio", -src/libstd/io/stdio.rs:559:#[unstable(feature = "set_stdio", -src/libstd/io/stdio.rs:574:#[unstable(feature = "print", -src/libstd/io/util.rs:45:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/util.rs:69:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/util.rs:90:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/util.rs:93:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/util.rs:97:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/util.rs:109:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/util.rs:116:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/util.rs:119:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/util.rs:135:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/util.rs:142:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/io/util.rs:145:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/lib.rs:190:#![stable(feature = "rust1", since = "1.0.0")] -src/libstd/lib.rs:203:#![feature(allow_internal_unstable)] -src/libstd/lib.rs:280:// Make std testable by not duplicating lang items and other globals. See #2912 -src/libstd/lib.rs:390:// unstable module so we can get our build working. -src/libstd/lib.rs:392:#[unstable(feature = "rand", issue = "0")] -src/libstd/macros.rs:37:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/macros.rs:38:#[allow_internal_unstable] -src/libstd/macros.rs:95:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/macros.rs:96:#[allow_internal_unstable] -src/libstd/macros.rs:117:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/macros.rs:153:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/macros.rs:199:#[unstable(feature = "mpsc_select", issue = "27800")] -src/libstd/net/addr.rs:29:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/addr.rs:32: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/addr.rs:35: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/addr.rs:41:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/addr.rs:46:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/addr.rs:51: #[unstable(feature = "ip_addr", reason = "recent addition", issue = "27801")] -src/libstd/net/addr.rs:60: #[unstable(feature = "ip_addr", reason = "recent addition", issue = "27801")] -src/libstd/net/addr.rs:69: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/addr.rs:80: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/addr.rs:93: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/addr.rs:101: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/addr.rs:108: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/addr.rs:124: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/addr.rs:132: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/addr.rs:137: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/addr.rs:142: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/addr.rs:171:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/addr.rs:181:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/addr.rs:188:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/addr.rs:195:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/addr.rs:202:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/addr.rs:209:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/addr.rs:213:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/addr.rs:218:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/addr.rs:225:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/addr.rs:234:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/addr.rs:236:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/addr.rs:239:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/addr.rs:245:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/addr.rs:307:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/addr.rs:311: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/addr.rs:325: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/addr.rs:329:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/addr.rs:337:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/addr.rs:345:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/addr.rs:353:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/addr.rs:365:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/addr.rs:374:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/addr.rs:401:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/addr.rs:422:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/ip.rs:11:#![unstable(feature = "ip", reason = "extra functionality has not been \ -src/libstd/net/ip.rs:13: be stable", -src/libstd/net/ip.rs:26:#[unstable(feature = "ip_addr", reason = "recent addition", issue = "27801")] -src/libstd/net/ip.rs:37:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/ip.rs:44:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/ip.rs:65: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/ip.rs:78: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/ip.rs:163: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/ip.rs:173: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/ip.rs:181:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/ip.rs:191:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/ip.rs:199:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/ip.rs:206:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/ip.rs:211:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/ip.rs:218:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/ip.rs:221:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/ip.rs:228:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/ip.rs:235:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/ip.rs:251:#[stable(feature = "ip_u32", since = "1.1.0")] -src/libstd/net/ip.rs:259:#[stable(feature = "ip_u32", since = "1.1.0")] -src/libstd/net/ip.rs:270: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/ip.rs:282: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/ip.rs:380: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/ip.rs:392:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/ip.rs:462:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/ip.rs:469:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/ip.rs:474:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/ip.rs:481:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/ip.rs:484:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/ip.rs:491:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/ip.rs:498:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/mod.rs:13:#![stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/mod.rs:35:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/mod.rs:39: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/mod.rs:43: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/mod.rs:48: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/mod.rs:85:#[unstable(feature = "lookup_host", reason = "unsure about the returned \ -src/libstd/net/mod.rs:91:#[unstable(feature = "lookup_host", reason = "unsure about the returned \ -src/libstd/net/mod.rs:119:#[unstable(feature = "lookup_host", reason = "unsure about the returned \ -src/libstd/net/mod.rs:132:#[unstable(feature = "lookup_addr", reason = "recent addition", -src/libstd/net/parser.rs:296:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/parser.rs:307:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/parser.rs:318:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/parser.rs:329:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/parser.rs:341:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/parser.rs:345:#[stable(feature = "addr_parse_error_error", since = "1.4.0")] -src/libstd/net/parser.rs:352:#[stable(feature = "addr_parse_error_error", since = "1.4.0")] -src/libstd/net/tcp.rs:41:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/tcp.rs:74:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/tcp.rs:81:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/tcp.rs:90: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/tcp.rs:96: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/tcp.rs:102: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/tcp.rs:112: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/tcp.rs:123: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/tcp.rs:139: #[stable(feature = "socket_timeout", since = "1.4.0")] -src/libstd/net/tcp.rs:155: #[stable(feature = "socket_timeout", since = "1.4.0")] -src/libstd/net/tcp.rs:167: #[stable(feature = "socket_timeout", since = "1.4.0")] -src/libstd/net/tcp.rs:179: #[stable(feature = "socket_timeout", since = "1.4.0")] -src/libstd/net/tcp.rs:185:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/tcp.rs:192:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/tcp.rs:197:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/tcp.rs:204:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/tcp.rs:240: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/tcp.rs:246: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/tcp.rs:256: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/tcp.rs:266: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/tcp.rs:276: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/tcp.rs:282:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/udp.rs:44:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/udp.rs:52: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/udp.rs:59: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/udp.rs:69: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/udp.rs:80: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/udp.rs:90: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/net/udp.rs:106: #[stable(feature = "socket_timeout", since = "1.4.0")] -src/libstd/net/udp.rs:122: #[stable(feature = "socket_timeout", since = "1.4.0")] -src/libstd/net/udp.rs:130: #[stable(feature = "socket_timeout", since = "1.4.0")] -src/libstd/net/udp.rs:138: #[stable(feature = "socket_timeout", since = "1.4.0")] -src/libstd/num/f32.rs:15:#![stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:123:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:126: #[unstable(feature = "float_from_str_radix", reason = "recently moved API", -src/libstd/num/f32.rs:145: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:166: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:186: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:211: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:229: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:256: #[unstable(feature = "float_extras", reason = "signature is undecided", -src/libstd/num/f32.rs:272: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:305: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:327: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:342: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:361: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:382: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:402: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:421: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:440: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:460: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:476: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:492: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:506: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:533: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:557: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:581: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:601: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:630: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:646: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:664: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:689: #[unstable(feature = "float_extras", reason = "desirability is unclear", -src/libstd/num/f32.rs:707: #[unstable(feature = "float_extras", reason = "desirability is unclear", -src/libstd/num/f32.rs:723: #[unstable(feature = "float_extras", -src/libstd/num/f32.rs:752: #[unstable(feature = "float_extras", -src/libstd/num/f32.rs:778: #[unstable(feature = "float_extras", -src/libstd/num/f32.rs:796: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:812: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:835: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:853: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:873: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:890: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:913: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:935: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:955: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:975: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:994: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:1026: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:1047: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:1064: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:1083: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:1104: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:1125: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:1146: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:1164: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:1185: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f32.rs:1206: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:15:#![stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:80:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:83: #[unstable(feature = "float_from_str_radix", reason = "recently moved API", -src/libstd/num/f64.rs:102: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:123: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:143: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:168: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:186: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:211: #[unstable(feature = "float_extras", reason = "signature is undecided", -src/libstd/num/f64.rs:225: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:240: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:256: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:271: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:288: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:309: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:329: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:349: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:353: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:374: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:378: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:397: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:411: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:425: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:437: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:456: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:478: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:494: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:512: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:533: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:547: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:563: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:580: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:595: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:609: #[unstable(feature = "float_extras", -src/libstd/num/f64.rs:636: #[unstable(feature = "float_extras", -src/libstd/num/f64.rs:660: #[unstable(feature = "float_extras", -src/libstd/num/f64.rs:678: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:694: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:715: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:731: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:749: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:766: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:783: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:799: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:819: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:839: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:856: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:888: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:909: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:926: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:945: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:966: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:987: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:1008: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:1024: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:1043: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/f64.rs:1064: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/num/mod.rs:16:#![stable(feature = "rust1", since = "1.0.0")] -src/libstd/os/android/mod.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/mod.rs:18: #![stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:23: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:25: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:28: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:30: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:32: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:34: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:36: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:38: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:42: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:44: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:46: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:48: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:50: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:52: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:54: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:56: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:58: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:60: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:62: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:64: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:66: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:68: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:70: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:72: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:74: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:76: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:78: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:80: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:92: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:94: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:97: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:99: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:101: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:103: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:105: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:107: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:111: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:113: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:115: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:117: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:119: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:121: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:123: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:125: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:127: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:129: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:131: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:133: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:135: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:137: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:139: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:141: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:143: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:145: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:147: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/android/raw.rs:149: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/bitrig/mod.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/bitrig/mod.rs:18: #![stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/bitrig/raw.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/bitrig/raw.rs:18:#[stable(feature = "raw_ext", since = "1.1.0")] pub type blkcnt_t = i64; -src/libstd/os/bitrig/raw.rs:19:#[stable(feature = "raw_ext", since = "1.1.0")] pub type blksize_t = u32; -src/libstd/os/bitrig/raw.rs:20:#[stable(feature = "raw_ext", since = "1.1.0")] pub type dev_t = i32; -src/libstd/os/bitrig/raw.rs:21:#[stable(feature = "raw_ext", since = "1.1.0")] pub type fflags_t = u32; -src/libstd/os/bitrig/raw.rs:22:#[stable(feature = "raw_ext", since = "1.1.0")] pub type ino_t = u64; -src/libstd/os/bitrig/raw.rs:23:#[stable(feature = "raw_ext", since = "1.1.0")] pub type mode_t = u32; -src/libstd/os/bitrig/raw.rs:24:#[stable(feature = "raw_ext", since = "1.1.0")] pub type nlink_t = u32; -src/libstd/os/bitrig/raw.rs:25:#[stable(feature = "raw_ext", since = "1.1.0")] pub type off_t = i64; -src/libstd/os/bitrig/raw.rs:26:#[stable(feature = "raw_ext", since = "1.1.0")] pub type time_t = i64; -src/libstd/os/bitrig/raw.rs:29:#[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/bitrig/raw.rs:31: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/bitrig/raw.rs:33: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/bitrig/raw.rs:35: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/bitrig/raw.rs:37: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/bitrig/raw.rs:39: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/bitrig/raw.rs:41: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/bitrig/raw.rs:43: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/bitrig/raw.rs:45: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/bitrig/raw.rs:47: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/bitrig/raw.rs:49: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/bitrig/raw.rs:51: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/bitrig/raw.rs:53: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/bitrig/raw.rs:55: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/bitrig/raw.rs:57: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/bitrig/raw.rs:59: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/bitrig/raw.rs:61: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/bitrig/raw.rs:63: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/bitrig/raw.rs:65: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/bitrig/raw.rs:67: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/bitrig/raw.rs:69: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/dragonfly/mod.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/dragonfly/mod.rs:18: #![stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/dragonfly/raw.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/dragonfly/raw.rs:18:#[stable(feature = "raw_ext", since = "1.1.0")] pub type blkcnt_t = i64; -src/libstd/os/dragonfly/raw.rs:19:#[stable(feature = "raw_ext", since = "1.1.0")] pub type blksize_t = u32; -src/libstd/os/dragonfly/raw.rs:20:#[stable(feature = "raw_ext", since = "1.1.0")] pub type dev_t = u32; -src/libstd/os/dragonfly/raw.rs:21:#[stable(feature = "raw_ext", since = "1.1.0")] pub type fflags_t = u32; -src/libstd/os/dragonfly/raw.rs:22:#[stable(feature = "raw_ext", since = "1.1.0")] pub type ino_t = u64; -src/libstd/os/dragonfly/raw.rs:23:#[stable(feature = "raw_ext", since = "1.1.0")] pub type mode_t = u16; -src/libstd/os/dragonfly/raw.rs:24:#[stable(feature = "raw_ext", since = "1.1.0")] pub type nlink_t = u16; -src/libstd/os/dragonfly/raw.rs:25:#[stable(feature = "raw_ext", since = "1.1.0")] pub type off_t = i64; -src/libstd/os/dragonfly/raw.rs:26:#[stable(feature = "raw_ext", since = "1.1.0")] pub type time_t = i64; -src/libstd/os/dragonfly/raw.rs:29:#[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/dragonfly/raw.rs:31: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/dragonfly/raw.rs:33: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/dragonfly/raw.rs:35: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/dragonfly/raw.rs:37: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/dragonfly/raw.rs:39: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/dragonfly/raw.rs:41: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/dragonfly/raw.rs:43: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/dragonfly/raw.rs:45: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/dragonfly/raw.rs:47: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/dragonfly/raw.rs:49: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/dragonfly/raw.rs:51: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/dragonfly/raw.rs:53: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/dragonfly/raw.rs:55: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/dragonfly/raw.rs:57: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/dragonfly/raw.rs:59: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/dragonfly/raw.rs:61: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/dragonfly/raw.rs:63: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/dragonfly/raw.rs:65: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/dragonfly/raw.rs:67: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/dragonfly/raw.rs:69: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/dragonfly/raw.rs:71: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/dragonfly/raw.rs:73: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/mod.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/mod.rs:18: #![stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:15:#[stable(feature = "raw_ext", since = "1.1.0")] pub type off_t = i64; -src/libstd/os/freebsd/raw.rs:16:#[stable(feature = "raw_ext", since = "1.1.0")] pub type dev_t = u32; -src/libstd/os/freebsd/raw.rs:17:#[stable(feature = "raw_ext", since = "1.1.0")] pub type ino_t = u32; -src/libstd/os/freebsd/raw.rs:18:#[stable(feature = "raw_ext", since = "1.1.0")] pub type mode_t = u16; -src/libstd/os/freebsd/raw.rs:19:#[stable(feature = "raw_ext", since = "1.1.0")] pub type nlink_t = u16; -src/libstd/os/freebsd/raw.rs:20:#[stable(feature = "raw_ext", since = "1.1.0")] pub type blksize_t = u32; -src/libstd/os/freebsd/raw.rs:21:#[stable(feature = "raw_ext", since = "1.1.0")] pub type blkcnt_t = i64; -src/libstd/os/freebsd/raw.rs:22:#[stable(feature = "raw_ext", since = "1.1.0")] pub type fflags_t = u32; -src/libstd/os/freebsd/raw.rs:33: #[stable(feature = "raw_ext", since = "1.1.0")] pub type time_t = i32; -src/libstd/os/freebsd/raw.rs:36: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:38: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:40: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:42: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:44: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:46: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:48: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:50: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:52: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:54: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:56: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:58: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:60: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:62: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:64: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:66: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:68: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:70: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:72: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:74: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:76: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:78: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:80: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:91: #[stable(feature = "raw_ext", since = "1.1.0")] pub type time_t = i64; -src/libstd/os/freebsd/raw.rs:94: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:96: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:98: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:100: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:102: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:104: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:106: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:108: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:110: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:112: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:114: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:116: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:118: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:120: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:122: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:124: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:126: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:128: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:130: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:132: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:134: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/freebsd/raw.rs:136: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/ios/mod.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/ios/mod.rs:18: #![stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/ios/raw.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/ios/raw.rs:18:#[stable(feature = "raw_ext", since = "1.1.0")] pub type blkcnt_t = i64; -src/libstd/os/ios/raw.rs:19:#[stable(feature = "raw_ext", since = "1.1.0")] pub type blksize_t = i32; -src/libstd/os/ios/raw.rs:20:#[stable(feature = "raw_ext", since = "1.1.0")] pub type dev_t = i32; -src/libstd/os/ios/raw.rs:21:#[stable(feature = "raw_ext", since = "1.1.0")] pub type ino_t = u64; -src/libstd/os/ios/raw.rs:22:#[stable(feature = "raw_ext", since = "1.1.0")] pub type mode_t = u16; -src/libstd/os/ios/raw.rs:23:#[stable(feature = "raw_ext", since = "1.1.0")] pub type nlink_t = u16; -src/libstd/os/ios/raw.rs:24:#[stable(feature = "raw_ext", since = "1.1.0")] pub type off_t = i64; -src/libstd/os/ios/raw.rs:25:#[stable(feature = "raw_ext", since = "1.1.0")] pub type time_t = c_long; -src/libstd/os/ios/raw.rs:28:#[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/ios/raw.rs:30: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/ios/raw.rs:32: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/ios/raw.rs:34: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/ios/raw.rs:36: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/ios/raw.rs:38: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/ios/raw.rs:40: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/ios/raw.rs:42: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/ios/raw.rs:44: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/ios/raw.rs:46: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/ios/raw.rs:48: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/ios/raw.rs:50: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/ios/raw.rs:52: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/ios/raw.rs:54: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/ios/raw.rs:56: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/ios/raw.rs:58: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/ios/raw.rs:60: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/ios/raw.rs:62: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/ios/raw.rs:64: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/ios/raw.rs:66: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/ios/raw.rs:68: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/ios/raw.rs:70: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/ios/raw.rs:72: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/mod.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/mod.rs:18: #![stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:15:#[stable(feature = "raw_ext", since = "1.1.0")] pub type dev_t = u64; -src/libstd/os/linux/raw.rs:16:#[stable(feature = "raw_ext", since = "1.1.0")] pub type mode_t = u32; -src/libstd/os/linux/raw.rs:30: #[stable(feature = "raw_ext", since = "1.1.0")] pub type blkcnt_t = i32; -src/libstd/os/linux/raw.rs:31: #[stable(feature = "raw_ext", since = "1.1.0")] pub type blksize_t = i32; -src/libstd/os/linux/raw.rs:32: #[stable(feature = "raw_ext", since = "1.1.0")] pub type ino_t = u32; -src/libstd/os/linux/raw.rs:33: #[stable(feature = "raw_ext", since = "1.1.0")] pub type nlink_t = u32; -src/libstd/os/linux/raw.rs:34: #[stable(feature = "raw_ext", since = "1.1.0")] pub type off_t = i32; -src/libstd/os/linux/raw.rs:35: #[stable(feature = "raw_ext", since = "1.1.0")] pub type time_t = i32; -src/libstd/os/linux/raw.rs:38: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:40: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:42: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:44: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:46: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:48: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:50: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:52: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:54: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:56: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:58: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:60: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:62: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:64: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:66: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:68: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:70: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:72: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:74: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:76: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:78: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:90: #[stable(feature = "raw_ext", since = "1.1.0")] pub type blkcnt_t = i32; -src/libstd/os/linux/raw.rs:91: #[stable(feature = "raw_ext", since = "1.1.0")] pub type blksize_t = i32; -src/libstd/os/linux/raw.rs:92: #[stable(feature = "raw_ext", since = "1.1.0")] pub type ino_t = u32; -src/libstd/os/linux/raw.rs:93: #[stable(feature = "raw_ext", since = "1.1.0")] pub type nlink_t = u32; -src/libstd/os/linux/raw.rs:94: #[stable(feature = "raw_ext", since = "1.1.0")] pub type off_t = i32; -src/libstd/os/linux/raw.rs:95: #[stable(feature = "raw_ext", since = "1.1.0")] pub type time_t = i32; -src/libstd/os/linux/raw.rs:98: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:100: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:102: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:104: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:106: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:108: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:110: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:112: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:114: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:116: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:118: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:120: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:122: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:124: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:126: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:128: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:130: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:132: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:134: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:136: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:138: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:149: #[stable(feature = "raw_ext", since = "1.1.0")] pub type blkcnt_t = i64; -src/libstd/os/linux/raw.rs:150: #[stable(feature = "raw_ext", since = "1.1.0")] pub type blksize_t = i32; -src/libstd/os/linux/raw.rs:151: #[stable(feature = "raw_ext", since = "1.1.0")] pub type ino_t = u64; -src/libstd/os/linux/raw.rs:152: #[stable(feature = "raw_ext", since = "1.1.0")] pub type nlink_t = u32; -src/libstd/os/linux/raw.rs:153: #[stable(feature = "raw_ext", since = "1.1.0")] pub type off_t = i64; -src/libstd/os/linux/raw.rs:154: #[stable(feature = "raw_ext", since = "1.1.0")] pub type time_t = i64; -src/libstd/os/linux/raw.rs:157: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:159: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:161: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:163: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:165: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:167: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:169: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:171: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:173: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:175: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:177: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:179: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:181: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:183: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:185: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:187: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:189: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:191: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:193: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:195: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:206: #[stable(feature = "raw_ext", since = "1.1.0")] pub type blkcnt_t = i64; -src/libstd/os/linux/raw.rs:207: #[stable(feature = "raw_ext", since = "1.1.0")] pub type blksize_t = i64; -src/libstd/os/linux/raw.rs:208: #[stable(feature = "raw_ext", since = "1.1.0")] pub type ino_t = u64; -src/libstd/os/linux/raw.rs:209: #[stable(feature = "raw_ext", since = "1.1.0")] pub type nlink_t = u64; -src/libstd/os/linux/raw.rs:210: #[stable(feature = "raw_ext", since = "1.1.0")] pub type off_t = i64; -src/libstd/os/linux/raw.rs:211: #[stable(feature = "raw_ext", since = "1.1.0")] pub type time_t = i64; -src/libstd/os/linux/raw.rs:214: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:216: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:218: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:220: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:222: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:224: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:226: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:228: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:230: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:232: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:234: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:236: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:238: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:240: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:242: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:244: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:246: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:248: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/linux/raw.rs:250: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/macos/mod.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/macos/mod.rs:18: #![stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/macos/raw.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/macos/raw.rs:18:#[stable(feature = "raw_ext", since = "1.1.0")] pub type blkcnt_t = i64; -src/libstd/os/macos/raw.rs:19:#[stable(feature = "raw_ext", since = "1.1.0")] pub type blksize_t = i32; -src/libstd/os/macos/raw.rs:20:#[stable(feature = "raw_ext", since = "1.1.0")] pub type dev_t = i32; -src/libstd/os/macos/raw.rs:21:#[stable(feature = "raw_ext", since = "1.1.0")] pub type ino_t = u64; -src/libstd/os/macos/raw.rs:22:#[stable(feature = "raw_ext", since = "1.1.0")] pub type mode_t = u16; -src/libstd/os/macos/raw.rs:23:#[stable(feature = "raw_ext", since = "1.1.0")] pub type nlink_t = u16; -src/libstd/os/macos/raw.rs:24:#[stable(feature = "raw_ext", since = "1.1.0")] pub type off_t = i64; -src/libstd/os/macos/raw.rs:25:#[stable(feature = "raw_ext", since = "1.1.0")] pub type time_t = c_long; -src/libstd/os/macos/raw.rs:28:#[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/macos/raw.rs:30: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/macos/raw.rs:32: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/macos/raw.rs:34: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/macos/raw.rs:36: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/macos/raw.rs:38: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/macos/raw.rs:40: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/macos/raw.rs:42: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/macos/raw.rs:44: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/macos/raw.rs:46: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/macos/raw.rs:48: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/macos/raw.rs:50: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/macos/raw.rs:52: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/macos/raw.rs:54: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/macos/raw.rs:56: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/macos/raw.rs:58: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/macos/raw.rs:60: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/macos/raw.rs:62: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/macos/raw.rs:64: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/macos/raw.rs:66: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/macos/raw.rs:68: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/macos/raw.rs:70: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/macos/raw.rs:72: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/mod.rs:13:#![stable(feature = "os", since = "1.0.0")] -src/libstd/os/nacl/mod.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/mod.rs:18: #![stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:15:#[stable(feature = "raw_ext", since = "1.1.0")] pub type dev_t = u64; -src/libstd/os/nacl/raw.rs:16:#[stable(feature = "raw_ext", since = "1.1.0")] pub type mode_t = u32; -src/libstd/os/nacl/raw.rs:29: #[stable(feature = "raw_ext", since = "1.1.0")] pub type blkcnt_t = i32; -src/libstd/os/nacl/raw.rs:30: #[stable(feature = "raw_ext", since = "1.1.0")] pub type blksize_t = i32; -src/libstd/os/nacl/raw.rs:31: #[stable(feature = "raw_ext", since = "1.1.0")] pub type ino_t = u32; -src/libstd/os/nacl/raw.rs:32: #[stable(feature = "raw_ext", since = "1.1.0")] pub type nlink_t = u32; -src/libstd/os/nacl/raw.rs:33: #[stable(feature = "raw_ext", since = "1.1.0")] pub type off_t = i32; -src/libstd/os/nacl/raw.rs:34: #[stable(feature = "raw_ext", since = "1.1.0")] pub type time_t = i32; -src/libstd/os/nacl/raw.rs:37: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:39: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:41: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:43: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:45: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:47: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:49: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:51: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:53: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:55: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:57: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:59: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:61: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:63: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:65: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:67: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:69: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:71: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:73: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:75: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:77: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:89: #[stable(feature = "raw_ext", since = "1.1.0")] pub type blkcnt_t = i32; -src/libstd/os/nacl/raw.rs:90: #[stable(feature = "raw_ext", since = "1.1.0")] pub type blksize_t = i32; -src/libstd/os/nacl/raw.rs:91: #[stable(feature = "raw_ext", since = "1.1.0")] pub type ino_t = u32; -src/libstd/os/nacl/raw.rs:92: #[stable(feature = "raw_ext", since = "1.1.0")] pub type nlink_t = u32; -src/libstd/os/nacl/raw.rs:93: #[stable(feature = "raw_ext", since = "1.1.0")] pub type off_t = i32; -src/libstd/os/nacl/raw.rs:94: #[stable(feature = "raw_ext", since = "1.1.0")] pub type time_t = i32; -src/libstd/os/nacl/raw.rs:97: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:99: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:101: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:103: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:105: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:107: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:109: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:111: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:113: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:115: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:117: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:119: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:121: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:123: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:125: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:127: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:129: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:131: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:133: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:135: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:137: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:148: #[stable(feature = "raw_ext", since = "1.1.0")] pub type blkcnt_t = i64; -src/libstd/os/nacl/raw.rs:149: #[stable(feature = "raw_ext", since = "1.1.0")] pub type blksize_t = i32; -src/libstd/os/nacl/raw.rs:150: #[stable(feature = "raw_ext", since = "1.1.0")] pub type ino_t = u64; -src/libstd/os/nacl/raw.rs:151: #[stable(feature = "raw_ext", since = "1.1.0")] pub type nlink_t = u32; -src/libstd/os/nacl/raw.rs:152: #[stable(feature = "raw_ext", since = "1.1.0")] pub type off_t = i64; -src/libstd/os/nacl/raw.rs:153: #[stable(feature = "raw_ext", since = "1.1.0")] pub type time_t = i64; -src/libstd/os/nacl/raw.rs:156: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:158: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:160: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:162: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:164: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:166: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:168: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:170: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:172: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:174: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:176: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:178: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:180: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:182: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:184: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:186: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:188: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:190: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:192: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:194: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:205: #[stable(feature = "raw_ext", since = "1.1.0")] pub type blkcnt_t = i64; -src/libstd/os/nacl/raw.rs:206: #[stable(feature = "raw_ext", since = "1.1.0")] pub type blksize_t = i64; -src/libstd/os/nacl/raw.rs:207: #[stable(feature = "raw_ext", since = "1.1.0")] pub type ino_t = u64; -src/libstd/os/nacl/raw.rs:208: #[stable(feature = "raw_ext", since = "1.1.0")] pub type nlink_t = u64; -src/libstd/os/nacl/raw.rs:209: #[stable(feature = "raw_ext", since = "1.1.0")] pub type off_t = i64; -src/libstd/os/nacl/raw.rs:210: #[stable(feature = "raw_ext", since = "1.1.0")] pub type time_t = i64; -src/libstd/os/nacl/raw.rs:213: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:215: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:217: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:219: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:221: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:223: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:225: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:227: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:229: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:231: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:233: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:235: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:237: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:239: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:241: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:243: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:245: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:247: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/nacl/raw.rs:249: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/netbsd/mod.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/netbsd/mod.rs:18: #![stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/netbsd/raw.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/netbsd/raw.rs:18:#[stable(feature = "raw_ext", since = "1.1.0")] pub type blkcnt_t = i64; -src/libstd/os/netbsd/raw.rs:19:#[stable(feature = "raw_ext", since = "1.1.0")] pub type blksize_t = u32; -src/libstd/os/netbsd/raw.rs:20:#[stable(feature = "raw_ext", since = "1.1.0")] pub type dev_t = u64; -src/libstd/os/netbsd/raw.rs:21:#[stable(feature = "raw_ext", since = "1.1.0")] pub type fflags_t = u32; -src/libstd/os/netbsd/raw.rs:22:#[stable(feature = "raw_ext", since = "1.1.0")] pub type ino_t = u64; -src/libstd/os/netbsd/raw.rs:23:#[stable(feature = "raw_ext", since = "1.1.0")] pub type mode_t = u32; -src/libstd/os/netbsd/raw.rs:24:#[stable(feature = "raw_ext", since = "1.1.0")] pub type nlink_t = u32; -src/libstd/os/netbsd/raw.rs:25:#[stable(feature = "raw_ext", since = "1.1.0")] pub type off_t = i64; -src/libstd/os/netbsd/raw.rs:26:#[stable(feature = "raw_ext", since = "1.1.0")] pub type time_t = i64; -src/libstd/os/netbsd/raw.rs:29:#[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/netbsd/raw.rs:31: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/netbsd/raw.rs:33: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/netbsd/raw.rs:35: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/netbsd/raw.rs:37: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/netbsd/raw.rs:39: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/netbsd/raw.rs:41: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/netbsd/raw.rs:43: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/netbsd/raw.rs:45: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/netbsd/raw.rs:47: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/netbsd/raw.rs:49: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/netbsd/raw.rs:51: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/netbsd/raw.rs:53: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/netbsd/raw.rs:55: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/netbsd/raw.rs:57: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/netbsd/raw.rs:59: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/netbsd/raw.rs:61: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/netbsd/raw.rs:63: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/netbsd/raw.rs:65: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/netbsd/raw.rs:67: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/netbsd/raw.rs:69: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/openbsd/mod.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/openbsd/mod.rs:18: #![stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/openbsd/raw.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/openbsd/raw.rs:18:#[stable(feature = "raw_ext", since = "1.1.0")] pub type blkcnt_t = i64; -src/libstd/os/openbsd/raw.rs:19:#[stable(feature = "raw_ext", since = "1.1.0")] pub type blksize_t = u32; -src/libstd/os/openbsd/raw.rs:20:#[stable(feature = "raw_ext", since = "1.1.0")] pub type dev_t = i32; -src/libstd/os/openbsd/raw.rs:21:#[stable(feature = "raw_ext", since = "1.1.0")] pub type fflags_t = u32; -src/libstd/os/openbsd/raw.rs:22:#[stable(feature = "raw_ext", since = "1.1.0")] pub type ino_t = u64; -src/libstd/os/openbsd/raw.rs:23:#[stable(feature = "raw_ext", since = "1.1.0")] pub type mode_t = u32; -src/libstd/os/openbsd/raw.rs:24:#[stable(feature = "raw_ext", since = "1.1.0")] pub type nlink_t = u32; -src/libstd/os/openbsd/raw.rs:25:#[stable(feature = "raw_ext", since = "1.1.0")] pub type off_t = i64; -src/libstd/os/openbsd/raw.rs:26:#[stable(feature = "raw_ext", since = "1.1.0")] pub type time_t = i64; -src/libstd/os/openbsd/raw.rs:29:#[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/openbsd/raw.rs:31: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/openbsd/raw.rs:33: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/openbsd/raw.rs:35: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/openbsd/raw.rs:37: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/openbsd/raw.rs:39: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/openbsd/raw.rs:41: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/openbsd/raw.rs:43: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/openbsd/raw.rs:45: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/openbsd/raw.rs:47: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/openbsd/raw.rs:49: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/openbsd/raw.rs:51: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/openbsd/raw.rs:53: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/openbsd/raw.rs:55: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/openbsd/raw.rs:57: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/openbsd/raw.rs:59: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/openbsd/raw.rs:61: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/openbsd/raw.rs:63: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/openbsd/raw.rs:65: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/openbsd/raw.rs:67: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/openbsd/raw.rs:69: #[stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/os/raw.rs:13:#![stable(feature = "raw_os", since = "1.1.0")] -src/libstd/os/raw.rs:16:#[stable(feature = "raw_os", since = "1.1.0")] pub type c_char = u8; -src/libstd/os/raw.rs:18:#[stable(feature = "raw_os", since = "1.1.0")] pub type c_char = i8; -src/libstd/os/raw.rs:19:#[stable(feature = "raw_os", since = "1.1.0")] pub type c_schar = i8; -src/libstd/os/raw.rs:20:#[stable(feature = "raw_os", since = "1.1.0")] pub type c_uchar = u8; -src/libstd/os/raw.rs:21:#[stable(feature = "raw_os", since = "1.1.0")] pub type c_short = i16; -src/libstd/os/raw.rs:22:#[stable(feature = "raw_os", since = "1.1.0")] pub type c_ushort = u16; -src/libstd/os/raw.rs:23:#[stable(feature = "raw_os", since = "1.1.0")] pub type c_int = i32; -src/libstd/os/raw.rs:24:#[stable(feature = "raw_os", since = "1.1.0")] pub type c_uint = u32; -src/libstd/os/raw.rs:26:#[stable(feature = "raw_os", since = "1.1.0")] pub type c_long = i32; -src/libstd/os/raw.rs:28:#[stable(feature = "raw_os", since = "1.1.0")] pub type c_ulong = u32; -src/libstd/os/raw.rs:30:#[stable(feature = "raw_os", since = "1.1.0")] pub type c_long = i64; -src/libstd/os/raw.rs:32:#[stable(feature = "raw_os", since = "1.1.0")] pub type c_ulong = u64; -src/libstd/os/raw.rs:33:#[stable(feature = "raw_os", since = "1.1.0")] pub type c_longlong = i64; -src/libstd/os/raw.rs:34:#[stable(feature = "raw_os", since = "1.1.0")] pub type c_ulonglong = u64; -src/libstd/os/raw.rs:35:#[stable(feature = "raw_os", since = "1.1.0")] pub type c_float = f32; -src/libstd/os/raw.rs:36:#[stable(feature = "raw_os", since = "1.1.0")] pub type c_double = f64; -src/libstd/os/raw.rs:50:#[stable(feature = "raw_os", since = "1.1.0")] -src/libstd/os/raw.rs:52: #[unstable(feature = "c_void_variant", reason = "should not have to exist", -src/libstd/os/raw.rs:55: #[unstable(feature = "c_void_variant", reason = "should not have to exist", -src/libstd/path.rs:99:#![stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:263:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:266: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:270: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:274: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:278: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:282: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:286: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:314: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:352:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:358:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:446:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:458: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:464: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:470:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:477:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:484:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:496:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:501: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:505: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:509: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:513: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:517: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:523: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:535:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:559:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:580:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:643: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:732: #[unstable(feature = "path_components_peek", issue = "27727")] -src/libstd/path.rs:738:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:745:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:754: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:760:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:767:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:774:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:783:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:790:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:841:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:886:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:893:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:896:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:903:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:934:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:945: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:951: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:965: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1006: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1035: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1054: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1077: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1083:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1090:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1097:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1104:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1113:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1122:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1129:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1138:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1145:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1152:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1159:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1165:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1172:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1175:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1182:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1189:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1196:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1226:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1264: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1279: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1296: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1313: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1328: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1349: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1364: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1374: #[unstable(feature = "path_prefix", -src/libstd/path.rs:1397: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1419: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1447: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1459: #[unstable(feature = "path_relative_from", reason = "see #23284", -src/libstd/path.rs:1485: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1507: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1534: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1557: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1573: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1596: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1619: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1645: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1671: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1688: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1694:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1701:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1709:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1714:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1721:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1728:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1735:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1738:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1745:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1752:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1757:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1762:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1767:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1772:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/path.rs:1777:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/prelude/mod.rs:112://! An unstable extension to slices that shouldn't have to exist. -src/libstd/prelude/mod.rs:127:#![stable(feature = "rust1", since = "1.0.0")] -src/libstd/prelude/v1.rs:13:#![stable(feature = "rust1", since = "1.0.0")] -src/libstd/prelude/v1.rs:16:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/prelude/v1.rs:18:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/prelude/v1.rs:22:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/prelude/v1.rs:26:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/prelude/v1.rs:28:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/prelude/v1.rs:30:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/prelude/v1.rs:32:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/prelude/v1.rs:34:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/prelude/v1.rs:36:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/prelude/v1.rs:38:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/prelude/v1.rs:40:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/prelude/v1.rs:42:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/prelude/v1.rs:44:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/prelude/v1.rs:46:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/prelude/v1.rs:48:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/prelude/v1.rs:50:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/process.rs:13:#![stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:50:#[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:58: #[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:62: #[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:66: #[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:79:#[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:84:#[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:104:#[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:109:#[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:125:#[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:130:#[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:161:#[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:182: #[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:193: #[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:200: #[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:210: #[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:219: #[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:226: #[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:233: #[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:240: #[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:247: #[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:254: #[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:290: #[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:313: #[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:334: #[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:340:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/process.rs:391:#[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:394: #[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:397: #[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:400: #[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:405:#[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:418: #[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:422: #[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:427: #[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:439:#[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:445: #[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:455: #[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:465:#[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:475: #[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:508: #[stable(feature = "process_id", since = "1.3.0")] -src/libstd/process.rs:521: #[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:542: #[stable(feature = "process", since = "1.0.0")] -src/libstd/process.rs:583:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/rand/mod.rs:58:#![unstable(feature = "rand", issue = "0")] -src/libstd/rt.rs:15://! backtrace support. The APIs in this module are highly unstable, -src/libstd/rt.rs:19:#![unstable(feature = "rt", -src/libstd/sync/barrier.rs:32:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/barrier.rs:56: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/barrier.rs:77: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/barrier.rs:104: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/condvar.rs:24:#[unstable(feature = "wait_timeout", reason = "newly added", issue = "27772")] -src/libstd/sync/condvar.rs:29: #[unstable(feature = "wait_timeout", reason = "newly added", issue = "27772")] -src/libstd/sync/condvar.rs:75:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/condvar.rs:92:#[unstable(feature = "static_condvar", -src/libstd/sync/condvar.rs:101:#[unstable(feature = "static_condvar", -src/libstd/sync/condvar.rs:109: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/condvar.rs:145: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/condvar.rs:169: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/condvar.rs:192: #[unstable(feature = "wait_timeout", reason = "waiting for Duration", -src/libstd/sync/condvar.rs:209: #[unstable(feature = "wait_timeout_with", -src/libstd/sync/condvar.rs:231: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/condvar.rs:241: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/condvar.rs:245:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/condvar.rs:254: #[unstable(feature = "static_condvar", -src/libstd/sync/condvar.rs:268: #[unstable(feature = "static_condvar", -src/libstd/sync/condvar.rs:290: #[unstable(feature = "static_condvar", -src/libstd/sync/condvar.rs:308: #[unstable(feature = "static_condvar", -src/libstd/sync/condvar.rs:335: #[unstable(feature = "static_condvar", -src/libstd/sync/condvar.rs:383: #[unstable(feature = "static_condvar", -src/libstd/sync/condvar.rs:391: #[unstable(feature = "static_condvar", -src/libstd/sync/condvar.rs:402: #[unstable(feature = "static_condvar", -src/libstd/sync/mod.rs:18:#![stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mod.rs:116:#![stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mod.rs:291:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mod.rs:303:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mod.rs:311:#[stable(feature = "receiver_into_iter", since = "1.1.0")] -src/libstd/sync/mpsc/mod.rs:318:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mod.rs:329:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mod.rs:343:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mod.rs:345:pub struct SendError(#[stable(feature = "rust1", since = "1.0.0")] pub T); -src/libstd/sync/mpsc/mod.rs:352:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mod.rs:358:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mod.rs:362: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mod.rs:367: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mod.rs:373:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mod.rs:382: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mod.rs:387: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mod.rs:445:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mod.rs:485:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mod.rs:529: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mod.rs:576:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mod.rs:621:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mod.rs:656: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mod.rs:670: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mod.rs:676:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mod.rs:684:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mod.rs:708: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mod.rs:811: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mod.rs:850: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mod.rs:942:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mod.rs:949:#[stable(feature = "receiver_into_iter", since = "1.1.0")] -src/libstd/sync/mpsc/mod.rs:962:#[stable(feature = "receiver_into_iter", since = "1.1.0")] -src/libstd/sync/mpsc/mod.rs:972:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mod.rs:984:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mod.rs:991:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mod.rs:998:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mod.rs:1009:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mod.rs:1019:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mod.rs:1033:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mod.rs:1052:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mod.rs:1059:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mod.rs:1071:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mod.rs:1085:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/mpsc_queue.rs:136:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mpsc/select.rs:51:#![unstable(feature = "mpsc_select", -src/libstd/sync/mutex.rs:113:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mutex.rs:153:#[unstable(feature = "static_mutex", -src/libstd/sync/mutex.rs:167:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mutex.rs:180:#[unstable(feature = "static_mutex", -src/libstd/sync/mutex.rs:187: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mutex.rs:208: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mutex.rs:227: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mutex.rs:242: #[stable(feature = "sync_poison", since = "1.2.0")] -src/libstd/sync/mutex.rs:248:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mutex.rs:258:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mutex.rs:275:#[unstable(feature = "static_mutex", -src/libstd/sync/mutex.rs:333:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mutex.rs:342:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/mutex.rs:349:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/once.rs:36:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/once.rs:44:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/once.rs:49: #[stable(feature = "once_new", since = "1.2.0")] -src/libstd/sync/once.rs:71: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/rwlock.rs:66:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/rwlock.rs:100:#[unstable(feature = "static_rwlock", -src/libstd/sync/rwlock.rs:109:#[unstable(feature = "static_rwlock", -src/libstd/sync/rwlock.rs:117:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/rwlock.rs:128:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/rwlock.rs:147: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/rwlock.rs:172: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/rwlock.rs:196: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/rwlock.rs:220: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/rwlock.rs:244: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/rwlock.rs:259: #[stable(feature = "sync_poison", since = "1.2.0")] -src/libstd/sync/rwlock.rs:265:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/rwlock.rs:272:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/rwlock.rs:289:#[unstable(feature = "static_rwlock", -src/libstd/sync/rwlock.rs:383:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/rwlock.rs:390:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/rwlock.rs:397:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/rwlock.rs:404:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/rwlock.rs:411:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sync/semaphore.rs:11:#![unstable(feature = "semaphore", -src/libstd/sync/semaphore.rs:105:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/common/poison.rs:62:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/common/poison.rs:69:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/common/poison.rs:73: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/common/poison.rs:77: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/common/poison.rs:88:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/common/poison.rs:96:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/common/poison.rs:99:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/common/poison.rs:106:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/common/poison.rs:121: #[stable(feature = "sync_poison", since = "1.2.0")] -src/libstd/sys/common/poison.rs:128: #[stable(feature = "sync_poison", since = "1.2.0")] -src/libstd/sys/common/poison.rs:133: #[stable(feature = "sync_poison", since = "1.2.0")] -src/libstd/sys/common/poison.rs:138: #[stable(feature = "sync_poison", since = "1.2.0")] -src/libstd/sys/common/poison.rs:148:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/common/poison.rs:158:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/common/remutex.rs:11:#![unstable(feature = "reentrant_mutex", reason = "new API", -src/libstd/sys/common/thread_local.rs:58:#![unstable(feature = "thread_local_internals", issue = "0")] -src/libstd/sys/unix/condvar.rs:54: // stable time. pthread_cond_timedwait uses system time, but we want to -src/libstd/sys/unix/condvar.rs:55: // report timeout based on stable time. -src/libstd/sys/unix/condvar.rs:57: let stable_now = time::SteadyTime::now(); -src/libstd/sys/unix/condvar.rs:85: &time::SteadyTime::now() - &stable_now < dur -src/libstd/sys/unix/ext/ffi.rs:13:#![stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/unix/ext/ffi.rs:22:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/unix/ext/ffi.rs:25: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/unix/ext/ffi.rs:29: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/unix/ext/ffi.rs:33:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/unix/ext/ffi.rs:44:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/unix/ext/ffi.rs:46: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/unix/ext/ffi.rs:50: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/unix/ext/ffi.rs:54:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/unix/ext/fs.rs:13:#![stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/unix/ext/fs.rs:25:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] -src/libstd/sys/unix/ext/fs.rs:27:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] -src/libstd/sys/unix/ext/fs.rs:29:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] -src/libstd/sys/unix/ext/fs.rs:31:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] -src/libstd/sys/unix/ext/fs.rs:33:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] -src/libstd/sys/unix/ext/fs.rs:35:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] -src/libstd/sys/unix/ext/fs.rs:37:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] -src/libstd/sys/unix/ext/fs.rs:39:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] -src/libstd/sys/unix/ext/fs.rs:41:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] -src/libstd/sys/unix/ext/fs.rs:43:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] -src/libstd/sys/unix/ext/fs.rs:45:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] -src/libstd/sys/unix/ext/fs.rs:47:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] -src/libstd/sys/unix/ext/fs.rs:49:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] -src/libstd/sys/unix/ext/fs.rs:51:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] -src/libstd/sys/unix/ext/fs.rs:53:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] -src/libstd/sys/unix/ext/fs.rs:55:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] -src/libstd/sys/unix/ext/fs.rs:57:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] -src/libstd/sys/unix/ext/fs.rs:59:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] -src/libstd/sys/unix/ext/fs.rs:61:#[unstable(feature = "fs_mode", reason = "recently added API", issue = "27712")] -src/libstd/sys/unix/ext/fs.rs:65:#[stable(feature = "fs_ext", since = "1.1.0")] -src/libstd/sys/unix/ext/fs.rs:69: #[stable(feature = "fs_ext", since = "1.1.0")] -src/libstd/sys/unix/ext/fs.rs:73: #[stable(feature = "fs_ext", since = "1.1.0")] -src/libstd/sys/unix/ext/fs.rs:78: #[stable(feature = "fs_ext", since = "1.1.0")] -src/libstd/sys/unix/ext/fs.rs:82:#[stable(feature = "fs_ext", since = "1.1.0")] -src/libstd/sys/unix/ext/fs.rs:96:#[stable(feature = "fs_ext", since = "1.1.0")] -src/libstd/sys/unix/ext/fs.rs:102: #[stable(feature = "fs_ext", since = "1.1.0")] -src/libstd/sys/unix/ext/fs.rs:106:#[stable(feature = "fs_ext", since = "1.1.0")] -src/libstd/sys/unix/ext/fs.rs:120:#[stable(feature = "metadata_ext", since = "1.1.0")] -src/libstd/sys/unix/ext/fs.rs:122: #[stable(feature = "metadata_ext", since = "1.1.0")] -src/libstd/sys/unix/ext/fs.rs:124: #[stable(feature = "metadata_ext", since = "1.1.0")] -src/libstd/sys/unix/ext/fs.rs:126: #[stable(feature = "metadata_ext", since = "1.1.0")] -src/libstd/sys/unix/ext/fs.rs:128: #[stable(feature = "metadata_ext", since = "1.1.0")] -src/libstd/sys/unix/ext/fs.rs:130: #[stable(feature = "metadata_ext", since = "1.1.0")] -src/libstd/sys/unix/ext/fs.rs:132: #[stable(feature = "metadata_ext", since = "1.1.0")] -src/libstd/sys/unix/ext/fs.rs:134: #[stable(feature = "metadata_ext", since = "1.1.0")] -src/libstd/sys/unix/ext/fs.rs:136: #[stable(feature = "metadata_ext", since = "1.1.0")] -src/libstd/sys/unix/ext/fs.rs:138: #[stable(feature = "metadata_ext", since = "1.1.0")] -src/libstd/sys/unix/ext/fs.rs:140: #[stable(feature = "metadata_ext", since = "1.1.0")] -src/libstd/sys/unix/ext/fs.rs:142: #[stable(feature = "metadata_ext", since = "1.1.0")] -src/libstd/sys/unix/ext/fs.rs:144: #[stable(feature = "metadata_ext", since = "1.1.0")] -src/libstd/sys/unix/ext/fs.rs:146: #[stable(feature = "metadata_ext", since = "1.1.0")] -src/libstd/sys/unix/ext/fs.rs:148: #[stable(feature = "metadata_ext", since = "1.1.0")] -src/libstd/sys/unix/ext/fs.rs:150: #[stable(feature = "metadata_ext", since = "1.1.0")] -src/libstd/sys/unix/ext/fs.rs:152: #[stable(feature = "metadata_ext", since = "1.1.0")] -src/libstd/sys/unix/ext/fs.rs:181:#[unstable(feature = "file_type_ext", reason = "recently added API", -src/libstd/sys/unix/ext/fs.rs:194:#[unstable(feature = "file_type_ext", reason = "recently added API", -src/libstd/sys/unix/ext/fs.rs:204:#[stable(feature = "dir_entry_ext", since = "1.1.0")] -src/libstd/sys/unix/ext/fs.rs:208: #[stable(feature = "dir_entry_ext", since = "1.1.0")] -src/libstd/sys/unix/ext/fs.rs:239:#[stable(feature = "symlink", since = "1.1.0")] -src/libstd/sys/unix/ext/fs.rs:245:#[unstable(feature = "dir_builder", reason = "recently added API", -src/libstd/sys/unix/ext/io.rs:13:#![stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/unix/ext/io.rs:22:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/unix/ext/io.rs:31:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/unix/ext/io.rs:38: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/unix/ext/io.rs:44:#[stable(feature = "from_raw_os", since = "1.1.0")] -src/libstd/sys/unix/ext/io.rs:58: #[stable(feature = "from_raw_os", since = "1.1.0")] -src/libstd/sys/unix/ext/io.rs:64:#[stable(feature = "into_raw_os", since = "1.4.0")] -src/libstd/sys/unix/ext/io.rs:71: #[stable(feature = "into_raw_os", since = "1.4.0")] -src/libstd/sys/unix/ext/io.rs:75:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/unix/ext/io.rs:81:#[stable(feature = "from_raw_os", since = "1.1.0")] -src/libstd/sys/unix/ext/io.rs:87:#[stable(feature = "into_raw_os", since = "1.4.0")] -src/libstd/sys/unix/ext/io.rs:94:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/unix/ext/io.rs:98:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/unix/ext/io.rs:102:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/unix/ext/io.rs:107:#[stable(feature = "from_raw_os", since = "1.1.0")] -src/libstd/sys/unix/ext/io.rs:114:#[stable(feature = "from_raw_os", since = "1.1.0")] -src/libstd/sys/unix/ext/io.rs:121:#[stable(feature = "from_raw_os", since = "1.1.0")] -src/libstd/sys/unix/ext/io.rs:129:#[stable(feature = "into_raw_os", since = "1.4.0")] -src/libstd/sys/unix/ext/io.rs:135:#[stable(feature = "into_raw_os", since = "1.4.0")] -src/libstd/sys/unix/ext/io.rs:141:#[stable(feature = "into_raw_os", since = "1.4.0")] -src/libstd/sys/unix/ext/mod.rs:30:#![stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/unix/ext/mod.rs:41:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/unix/ext/mod.rs:45: #[doc(no_inline)] #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/unix/ext/mod.rs:51: #[doc(no_inline)] #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/unix/ext/process.rs:13:#![stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/unix/ext/process.rs:22:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/unix/ext/process.rs:27: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/unix/ext/process.rs:32: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/unix/ext/process.rs:44: #[unstable(feature = "process_session_leader", reason = "recently added", -src/libstd/sys/unix/ext/process.rs:49:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/unix/ext/process.rs:68:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/unix/ext/process.rs:71: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/unix/ext/process.rs:75:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/unix/ext/process.rs:85:#[stable(feature = "process_extensions", since = "1.2.0")] -src/libstd/sys/unix/ext/process.rs:92:#[stable(feature = "process_extensions", since = "1.2.0")] -src/libstd/sys/unix/ext/process.rs:99:#[stable(feature = "process_extensions", since = "1.2.0")] -src/libstd/sys/unix/ext/process.rs:106:#[stable(feature = "process_extensions", since = "1.2.0")] -src/libstd/sys/unix/ext/raw.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/sys/unix/ext/raw.rs:15:#[stable(feature = "raw_ext", since = "1.1.0")] pub type uid_t = u32; -src/libstd/sys/unix/ext/raw.rs:16:#[stable(feature = "raw_ext", since = "1.1.0")] pub type gid_t = u32; -src/libstd/sys/unix/ext/raw.rs:17:#[stable(feature = "raw_ext", since = "1.1.0")] pub type pid_t = i32; -src/libstd/sys/unix/fs.rs:81:#[stable(feature = "metadata_ext", since = "1.1.0")] -src/libstd/sys/unix/fs.rs:89: #[stable(feature = "metadata_ext", since = "1.1.0")] -src/libstd/sys/unix/fs.rs:93:#[stable(feature = "metadata_ext", since = "1.1.0")] -src/libstd/sys/windows/ext/ffi.rs:13:#![stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/windows/ext/ffi.rs:23:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/windows/ext/ffi.rs:30: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/windows/ext/ffi.rs:34:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/windows/ext/ffi.rs:42:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/windows/ext/ffi.rs:49: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/windows/ext/ffi.rs:53:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/windows/ext/fs.rs:13:#![stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/windows/ext/fs.rs:22:#[unstable(feature = "open_options_ext", -src/libstd/sys/windows/ext/fs.rs:69:#[stable(feature = "metadata_ext", since = "1.1.0")] -src/libstd/sys/windows/ext/fs.rs:75: #[stable(feature = "metadata_ext", since = "1.1.0")] -src/libstd/sys/windows/ext/fs.rs:82: #[stable(feature = "metadata_ext", since = "1.1.0")] -src/libstd/sys/windows/ext/fs.rs:89: #[stable(feature = "metadata_ext", since = "1.1.0")] -src/libstd/sys/windows/ext/fs.rs:96: #[stable(feature = "metadata_ext", since = "1.1.0")] -src/libstd/sys/windows/ext/fs.rs:103: #[stable(feature = "metadata_ext", since = "1.1.0")] -src/libstd/sys/windows/ext/fs.rs:107:#[stable(feature = "metadata_ext", since = "1.1.0")] -src/libstd/sys/windows/ext/fs.rs:131:#[stable(feature = "symlink", since = "1.1.0")] -src/libstd/sys/windows/ext/fs.rs:152:#[stable(feature = "symlink", since = "1.1.0")] -src/libstd/sys/windows/ext/io.rs:11:#![stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/windows/ext/io.rs:20:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/windows/ext/io.rs:24:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/windows/ext/io.rs:28:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/windows/ext/io.rs:31: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/windows/ext/io.rs:36:#[stable(feature = "from_raw_os", since = "1.1.0")] -src/libstd/sys/windows/ext/io.rs:49: #[stable(feature = "from_raw_os", since = "1.1.0")] -src/libstd/sys/windows/ext/io.rs:55:#[stable(feature = "into_raw_os", since = "1.4.0")] -src/libstd/sys/windows/ext/io.rs:62: #[stable(feature = "into_raw_os", since = "1.4.0")] -src/libstd/sys/windows/ext/io.rs:66:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/windows/ext/io.rs:73:#[stable(feature = "from_raw_os", since = "1.1.0")] -src/libstd/sys/windows/ext/io.rs:81:#[stable(feature = "into_raw_os", since = "1.4.0")] -src/libstd/sys/windows/ext/io.rs:89:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/windows/ext/io.rs:92: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/windows/ext/io.rs:97:#[stable(feature = "from_raw_os", since = "1.1.0")] -src/libstd/sys/windows/ext/io.rs:109: #[stable(feature = "from_raw_os", since = "1.1.0")] -src/libstd/sys/windows/ext/io.rs:115:#[stable(feature = "into_raw_os", since = "1.4.0")] -src/libstd/sys/windows/ext/io.rs:122: #[stable(feature = "into_raw_os", since = "1.4.0")] -src/libstd/sys/windows/ext/io.rs:126:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/windows/ext/io.rs:132:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/windows/ext/io.rs:138:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/windows/ext/io.rs:145:#[stable(feature = "from_raw_os", since = "1.1.0")] -src/libstd/sys/windows/ext/io.rs:152:#[stable(feature = "from_raw_os", since = "1.1.0")] -src/libstd/sys/windows/ext/io.rs:159:#[stable(feature = "from_raw_os", since = "1.1.0")] -src/libstd/sys/windows/ext/io.rs:167:#[stable(feature = "into_raw_os", since = "1.4.0")] -src/libstd/sys/windows/ext/io.rs:174:#[stable(feature = "into_raw_os", since = "1.4.0")] -src/libstd/sys/windows/ext/io.rs:181:#[stable(feature = "into_raw_os", since = "1.4.0")] -src/libstd/sys/windows/ext/mod.rs:17:#![stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/windows/ext/mod.rs:28:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/windows/ext/mod.rs:34: #[doc(no_inline)] #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/sys/windows/ext/process.rs:13:#![stable(feature = "process_extensions", since = "1.2.0")] -src/libstd/sys/windows/ext/process.rs:20:#[stable(feature = "process_extensions", since = "1.2.0")] -src/libstd/sys/windows/ext/process.rs:28:#[stable(feature = "process_extensions", since = "1.2.0")] -src/libstd/sys/windows/ext/process.rs:41:#[stable(feature = "process_extensions", since = "1.2.0")] -src/libstd/sys/windows/ext/process.rs:48:#[stable(feature = "process_extensions", since = "1.2.0")] -src/libstd/sys/windows/ext/process.rs:55:#[stable(feature = "process_extensions", since = "1.2.0")] -src/libstd/sys/windows/ext/raw.rs:13:#![stable(feature = "raw_ext", since = "1.1.0")] -src/libstd/sys/windows/ext/raw.rs:17:#[stable(feature = "raw_ext", since = "1.1.0")] pub type HANDLE = *mut c_void; -src/libstd/sys/windows/ext/raw.rs:19:#[stable(feature = "raw_ext", since = "1.1.0")] pub type SOCKET = u32; -src/libstd/sys/windows/ext/raw.rs:21:#[stable(feature = "raw_ext", since = "1.1.0")] pub type SOCKET = u64; -src/libstd/thread/local.rs:13:#![unstable(feature = "thread_local_internals", issue = "0")] -src/libstd/thread/local.rs:62:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/thread/local.rs:103:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/thread/local.rs:104:#[allow_internal_unstable] -src/libstd/thread/local.rs:124:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/thread/local.rs:125:#[allow_internal_unstable] -src/libstd/thread/local.rs:139:#[unstable(feature = "thread_local_internals", -src/libstd/thread/local.rs:143:#[allow_internal_unstable] -src/libstd/thread/local.rs:156:#[unstable(feature = "thread_local_state", -src/libstd/thread/local.rs:189: #[unstable(feature = "thread_local_internals", -src/libstd/thread/local.rs:210: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/thread/local.rs:253: #[unstable(feature = "thread_local_state", -src/libstd/thread/mod.rs:161:#![stable(feature = "rust1", since = "1.0.0")] -src/libstd/thread/mod.rs:184:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/thread/mod.rs:187:#[unstable(feature = "scoped_tls", -src/libstd/thread/mod.rs:202:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/thread/mod.rs:213: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/thread/mod.rs:223: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/thread/mod.rs:230: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/thread/mod.rs:248: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/thread/mod.rs:314:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/thread/mod.rs:322:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/thread/mod.rs:330:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/thread/mod.rs:337:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/thread/mod.rs:380:#[unstable(feature = "catch_panic", reason = "recent API addition", -src/libstd/thread/mod.rs:399:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/thread/mod.rs:415:#[stable(feature = "thread_sleep", since = "1.4.0")] -src/libstd/thread/mod.rs:445:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/thread/mod.rs:465:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/thread/mod.rs:485:#[stable(feature = "park_timeout", since = "1.4.0")] -src/libstd/thread/mod.rs:508:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/thread/mod.rs:529: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/thread/mod.rs:539: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/thread/mod.rs:545:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/thread/mod.rs:564:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/thread/mod.rs:607:#[stable(feature = "rust1", since = "1.0.0")] -src/libstd/thread/mod.rs:612: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/thread/mod.rs:621: #[stable(feature = "rust1", since = "1.0.0")] -src/libstd/thread/scoped_tls.rs:43:#![unstable(feature = "thread_local_internals", issue = "0")] -src/libstd/thread/scoped_tls.rs:55:#[unstable(feature = "scoped_tls", -src/libstd/thread/scoped_tls.rs:69:#[allow_internal_unstable] -src/libstd/thread/scoped_tls.rs:82:#[unstable(feature = "thread_local_internals", -src/libstd/thread/scoped_tls.rs:85:#[allow_internal_unstable] -src/libstd/thread/scoped_tls.rs:97:#[unstable(feature = "thread_local_internals", -src/libstd/thread/scoped_tls.rs:100:#[allow_internal_unstable] -src/libstd/thread/scoped_tls.rs:118:#[unstable(feature = "scoped_tls", -src/libstd/time/duration.rs:42:#[stable(feature = "duration", since = "1.3.0")] -src/libstd/time/duration.rs:55: #[stable(feature = "duration", since = "1.3.0")] -src/libstd/time/duration.rs:64: #[unstable(feature = "duration_span", -src/libstd/time/duration.rs:76: #[stable(feature = "duration", since = "1.3.0")] -src/libstd/time/duration.rs:82: #[stable(feature = "duration", since = "1.3.0")] -src/libstd/time/duration.rs:93: #[stable(feature = "duration", since = "1.3.0")] -src/libstd/time/duration.rs:101: #[stable(feature = "duration", since = "1.3.0")] -src/libstd/time/mod.rs:13:#![stable(feature = "time", since = "1.3.0")] -src/libsyntax/ast.rs:1897: pub allow_internal_unstable: bool, -src/libsyntax/attr.rs:402: Unstable, -src/libsyntax/attr.rs:425: if tag != "deprecated" && tag != "unstable" && tag != "stable" { -src/libsyntax/attr.rs:491: // Unstable tags don't require a version -src/libsyntax/attr.rs:492: if since == None && tag != "unstable" { -src/libsyntax/attr.rs:496: if tag == "unstable" || tag == "stable" { -src/libsyntax/attr.rs:502: "unstable" => Unstable, -src/libsyntax/attr.rs:503: "stable" => Stable, -src/libsyntax/attr.rs:534: either stable or unstable attribute"); -src/libsyntax/attr.rs:537: } else if stab.as_ref().map_or(false, |s| s.level == Unstable && s.issue.is_none()) { -src/libsyntax/attr.rs:538: // non-deprecated unstable items need to point to issues. -src/libsyntax/attr.rs:540: "non-deprecated unstable items need to point \ -src/libsyntax/codemap.rs:298: /// Whether the macro is allowed to use #[unstable]/feature-gated -src/libsyntax/codemap.rs:301: pub allow_internal_unstable: bool, -src/libsyntax/codemap.rs:1004: /// Check if a span is "internal" to a macro in which #[unstable] -src/libsyntax/codemap.rs:1006: /// `#[allow_internal_unstable]`). -src/libsyntax/codemap.rs:1007: pub fn span_allows_unstable(&self, span: Span) -> bool { -src/libsyntax/codemap.rs:1008: debug!("span_allows_unstable(span = {:?})", span); -src/libsyntax/codemap.rs:1009: let mut allows_unstable = false; -src/libsyntax/codemap.rs:1013: debug!("span_allows_unstable: expninfo = {:?}", expninfo); -src/libsyntax/codemap.rs:1021: debug!("span_allows_unstable: span: {:?} call_site: {:?} callee: {:?}", -src/libsyntax/codemap.rs:1025: debug!("span_allows_unstable: from this expansion? {}, allows unstable? {}", -src/libsyntax/codemap.rs:1027: info.callee.allow_internal_unstable); -src/libsyntax/codemap.rs:1029: allows_unstable = info.callee.allow_internal_unstable; -src/libsyntax/codemap.rs:1043: debug!("span_allows_unstable? {}", allows_unstable); -src/libsyntax/codemap.rs:1044: allows_unstable -src/libsyntax/ext/asm.rs:219: allow_internal_unstable: false, -src/libsyntax/ext/base.rs:424: /// directly use `#[unstable]` things (true == yes). -src/libsyntax/ext/base.rs:466: // format_args uses `unstable` things internally. -src/libsyntax/ext/base.rs:596: #[unstable(feature = "rustc_private")] -src/libsyntax/ext/deriving/generic/mod.rs:1451: allow_internal_unstable: false, -src/libsyntax/ext/deriving/show.rs:71: // We want to make sure we have the expn_id set so that we can use unstable methods -src/libsyntax/ext/expand.rs:58: allow_internal_unstable: true, -src/libsyntax/ext/expand.rs:65: // Sets the expn_id so that we can use unstable methods. -src/libsyntax/ext/expand.rs:66: fn allow_unstable(fld: &mut MacroExpander, span: Span) -> Span { -src/libsyntax/ext/expand.rs:137: // We feed in the `expr_span` because codemap's span_allows_unstable -src/libsyntax/ext/expand.rs:138: // allows the call_site span to inherit the `allow_internal_unstable` -src/libsyntax/ext/expand.rs:140: let span_unstable = allow_unstable(fld, expr_span); -src/libsyntax/ext/expand.rs:141: let path = mk_core_path(fld, span_unstable, p); -src/libsyntax/ext/expand.rs:143: let expr_span_unstable = allow_unstable(fld, span); -src/libsyntax/ext/expand.rs:144: fld.cx.expr_call(expr_span_unstable, path, args) -src/libsyntax/ext/expand.rs:538: NormalTT(ref expandfun, exp_span, allow_internal_unstable) => { -src/libsyntax/ext/expand.rs:544: allow_internal_unstable: allow_internal_unstable, -src/libsyntax/ext/expand.rs:702: NormalTT(ref expander, tt_span, allow_internal_unstable) => { -src/libsyntax/ext/expand.rs:716: allow_internal_unstable: allow_internal_unstable, -src/libsyntax/ext/expand.rs:723: IdentTT(ref expander, tt_span, allow_internal_unstable) => { -src/libsyntax/ext/expand.rs:735: allow_internal_unstable: allow_internal_unstable, -src/libsyntax/ext/expand.rs:756: // unstable (this is orthogonal to whether -src/libsyntax/ext/expand.rs:758: allow_internal_unstable: false, -src/libsyntax/ext/expand.rs:763: let allow_internal_unstable = attr::contains_name(&attrs, -src/libsyntax/ext/expand.rs:764: "allow_internal_unstable"); -src/libsyntax/ext/expand.rs:766: // ensure any #[allow_internal_unstable]s are -src/libsyntax/ext/expand.rs:769: if allow_internal_unstable && !fld.cx.ecfg.enable_allow_internal_unstable() { -src/libsyntax/ext/expand.rs:772: "allow_internal_unstable", -src/libsyntax/ext/expand.rs:787: allow_internal_unstable: allow_internal_unstable, -src/libsyntax/ext/expand.rs:1074: NormalTT(ref expander, tt_span, allow_internal_unstable) => { -src/libsyntax/ext/expand.rs:1080: allow_internal_unstable: allow_internal_unstable, -src/libsyntax/ext/expand.rs:1288: allow_internal_unstable: true, -src/libsyntax/ext/expand.rs:1338: allow_internal_unstable: true, -src/libsyntax/ext/expand.rs:1576: fn enable_allow_internal_unstable = allow_internal_unstable, -src/libsyntax/ext/format.rs:40: /// The macro's call site. References to unstable formatting internals must -src/libsyntax/ext/tt/macro_rules.rs:306: NormalTT(exp, Some(def.span), def.allow_internal_unstable) -src/libsyntax/feature_gate.rs:23://! becomes stable. -src/libsyntax/feature_gate.rs:47:// stable (active). -src/libsyntax/feature_gate.rs:149: // Allows the use of #[allow_internal_unstable]. This is an -src/libsyntax/feature_gate.rs:153: ("allow_internal_unstable", "1.0.0", None, Active), -src/libsyntax/feature_gate.rs:294: and will never be stable")), -src/libsyntax/feature_gate.rs:298: and will never be stable")), -src/libsyntax/feature_gate.rs:302: and will never be stable")), -src/libsyntax/feature_gate.rs:306: and will never be stable")), -src/libsyntax/feature_gate.rs:308: ("allow_internal_unstable", Normal, Gated("allow_internal_unstable", -src/libsyntax/feature_gate.rs:340: "unsafe_no_drop_flag has unstable semantics \ -src/libsyntax/feature_gate.rs:352: ("stable", Whitelisted, Ungated), -src/libsyntax/feature_gate.rs:353: ("unstable", Whitelisted, Ungated), -src/libsyntax/feature_gate.rs:461: pub allow_internal_unstable: bool, -src/libsyntax/feature_gate.rs:469: /// spans of #![feature] attrs for stable language features. for error reporting -src/libsyntax/feature_gate.rs:470: pub declared_stable_lang_features: Vec, -src/libsyntax/feature_gate.rs:493: allow_internal_unstable: false, -src/libsyntax/feature_gate.rs:501: declared_stable_lang_features: Vec::new(), -src/libsyntax/feature_gate.rs:645: // #23973: do not suggest `#![feature(...)]` if we are in beta/stable -src/libsyntax/feature_gate.rs:653: "inline assembly is not stable enough for use and is subject to change"; -src/libsyntax/feature_gate.rs:656: "`log_syntax!` is not stable enough for use and is subject to change"; -src/libsyntax/feature_gate.rs:659: "`concat_idents` is not stable enough for use and is subject to change"; -src/libsyntax/feature_gate.rs:662: "`trace_macros` is not stable enough for use and is subject to change"; -src/libsyntax/feature_gate.rs:664: "allow_internal_unstable side-steps feature gating and stability checks"; -src/libsyntax/feature_gate.rs:667: "`#[derive]` for custom traits is not stable enough for use and is subject to change"; -src/libsyntax/feature_gate.rs:734: if !self.context.cm.span_allows_unstable(span) { -src/libsyntax/feature_gate.rs:742: if !self.context.cm.span_allows_unstable(attr.span) { -src/libsyntax/feature_gate.rs:824: "empty structs with braces are unstable"); -src/libsyntax/feature_gate.rs:878: "empty structs with braces are unstable"); -src/libsyntax/feature_gate.rs:908: "empty structs with braces are unstable"); -src/libsyntax/feature_gate.rs:925: self.gate_feature("const_fn", span, "const fn is unstable"); -src/libsyntax/feature_gate.rs:961: self.gate_feature("const_fn", ti.span, "const fn is unstable"); -src/libsyntax/feature_gate.rs:966: "associated type defaults are unstable"); -src/libsyntax/feature_gate.rs:982: self.gate_feature("const_fn", ii.span, "const fn is unstable"); -src/libsyntax/feature_gate.rs:1063: allow_internal_unstable: cx.has_feature("allow_internal_unstable"), -src/libsyntax/feature_gate.rs:1071: declared_stable_lang_features: accepted_features, -src/libsyntax/feature_gate.rs:1091: unstable: UnstableFeatures) -> Features -src/libsyntax/feature_gate.rs:1093: maybe_stage_features(span_handler, krate, unstable); -src/libsyntax/feature_gate.rs:1101:pub enum UnstableFeatures { -src/libsyntax/feature_gate.rs:1102: /// Hard errors for unstable features are active, as on -src/libsyntax/feature_gate.rs:1103: /// beta/stable channels. -src/libsyntax/feature_gate.rs:1109: /// because the build turns on warnings-as-errors and uses lots of unstable -src/libsyntax/feature_gate.rs:1115: unstable: UnstableFeatures) { -src/libsyntax/feature_gate.rs:1116: let allow_features = match unstable { -src/libsyntax/feature_gate.rs:1117: UnstableFeatures::Allow => true, -src/libsyntax/feature_gate.rs:1118: UnstableFeatures::Disallow => false, -src/libsyntax/feature_gate.rs:1119: UnstableFeatures::Cheat => true -src/libsyntax/lib.rs:15://! This API is completely unstable and subject to change. -src/libsyntax/lib.rs:20:#![unstable(feature = "rustc_private", issue = "27812")] -src/libsyntax/ptr.rs:114:#[stable(feature = "rust1", since = "1.0.0")] -src/libsyntax/std_inject.rs:24:/// The expanded code uses the unstable `#[prelude_import]` attribute. -src/libsyntax/std_inject.rs:31: allow_internal_unstable: true, -src/libsyntax/test.rs:303: allow_internal_unstable: false, -src/libsyntax/test.rs:328:/// The expanded code calls some unstable functions in the test crate. -src/libsyntax/test.rs:335: allow_internal_unstable: true, -src/libsyntax/util/small_vector.rs:68: // FIXME: Could be replaced with `slice::ref_slice(v)` when it is stable. -src/libsyntax/util/small_vector.rs:132: #[unstable(feature = "rustc_private")] -src/libterm/lib.rs:47:#![unstable(feature = "rustc_private", -src/libtest/lib.rs:29:#![unstable(feature = "test", issue = "27812")] -src/libtest/lib.rs:1171: // stable median. -src/rt/miniz.c:31: 5/15/11 v1.09 - Initial stable release. -src/test/auxiliary/const_fn_lib.rs:16:pub const fn foo() -> usize { 22 } //~ ERROR const fn is unstable -src/test/auxiliary/inherited_stability.rs:12:#![unstable(feature = "test_feature", issue = "0")] -src/test/auxiliary/inherited_stability.rs:16:pub fn unstable() {} -src/test/auxiliary/inherited_stability.rs:18:#[stable(feature = "rust1", since = "1.0.0")] -src/test/auxiliary/inherited_stability.rs:19:pub fn stable() {} -src/test/auxiliary/inherited_stability.rs:21:#[stable(feature = "rust1", since = "1.0.0")] -src/test/auxiliary/inherited_stability.rs:22:pub mod stable_mod { -src/test/auxiliary/inherited_stability.rs:23: pub fn unstable() {} -src/test/auxiliary/inherited_stability.rs:25: #[stable(feature = "rust1", since = "1.0.0")] -src/test/auxiliary/inherited_stability.rs:26: pub fn stable() {} -src/test/auxiliary/inherited_stability.rs:29:#[unstable(feature = "test_feature", issue = "0")] -src/test/auxiliary/inherited_stability.rs:30:pub mod unstable_mod { -src/test/auxiliary/inherited_stability.rs:31: #[stable(feature = "test_feature", since = "1.0.0")] -src/test/auxiliary/inherited_stability.rs:35: pub fn unstable() {} -src/test/auxiliary/inherited_stability.rs:38:#[stable(feature = "rust1", since = "1.0.0")] -src/test/auxiliary/inherited_stability.rs:40: fn unstable(&self); -src/test/auxiliary/inherited_stability.rs:42: #[stable(feature = "rust1", since = "1.0.0")] -src/test/auxiliary/inherited_stability.rs:43: fn stable(&self); -src/test/auxiliary/inherited_stability.rs:47: fn unstable(&self) {} -src/test/auxiliary/inherited_stability.rs:48: fn stable(&self) {} -src/test/auxiliary/inherited_stability.rs:51:pub enum Unstable { -src/test/auxiliary/inherited_stability.rs:52: UnstableVariant, -src/test/auxiliary/inherited_stability.rs:53: #[stable(feature = "rust1", since = "1.0.0")] -src/test/auxiliary/internal_unstable.rs:11:#![feature(staged_api, allow_internal_unstable)] -src/test/auxiliary/internal_unstable.rs:13:#![stable(feature = "stable", since = "1.0.0")] -src/test/auxiliary/internal_unstable.rs:15:#[unstable(feature = "function", issue = "0")] -src/test/auxiliary/internal_unstable.rs:16:pub fn unstable() {} -src/test/auxiliary/internal_unstable.rs:19:#[stable(feature = "stable", since = "1.0.0")] -src/test/auxiliary/internal_unstable.rs:21: #[unstable(feature = "struct_field", issue = "0")] -src/test/auxiliary/internal_unstable.rs:26: #[unstable(feature = "method", issue = "0")] -src/test/auxiliary/internal_unstable.rs:30:#[stable(feature = "stable", since = "1.0.0")] -src/test/auxiliary/internal_unstable.rs:32: #[unstable(feature = "struct2_field", issue = "0")] -src/test/auxiliary/internal_unstable.rs:36:#[allow_internal_unstable] -src/test/auxiliary/internal_unstable.rs:38:macro_rules! call_unstable_allow { -src/test/auxiliary/internal_unstable.rs:39: () => { $crate::unstable() } -src/test/auxiliary/internal_unstable.rs:42:#[allow_internal_unstable] -src/test/auxiliary/internal_unstable.rs:44:macro_rules! construct_unstable_allow { -src/test/auxiliary/internal_unstable.rs:50:#[allow_internal_unstable] -src/test/auxiliary/internal_unstable.rs:56:#[allow_internal_unstable] -src/test/auxiliary/internal_unstable.rs:62:#[allow_internal_unstable] -src/test/auxiliary/internal_unstable.rs:69:macro_rules! call_unstable_noallow { -src/test/auxiliary/internal_unstable.rs:70: () => { $crate::unstable() } -src/test/auxiliary/internal_unstable.rs:74:macro_rules! construct_unstable_noallow { -src/test/auxiliary/lint_output_format.rs:15:#![unstable(feature = "test_feature", issue = "0")] -src/test/auxiliary/lint_output_format.rs:17:#[stable(feature = "test_feature", since = "1.0.0")] -src/test/auxiliary/lint_output_format.rs:23:#[unstable(feature = "test_feature", issue = "0")] -src/test/auxiliary/lint_output_format.rs:28:#[unstable(feature = "test_feature", issue = "0")] -src/test/auxiliary/lint_stability.rs:14:#![stable(feature = "lint_stability", since = "1.0.0")] -src/test/auxiliary/lint_stability.rs:16:#[stable(feature = "test_feature", since = "1.0.0")] -src/test/auxiliary/lint_stability.rs:19:#[stable(feature = "test_feature", since = "1.0.0")] -src/test/auxiliary/lint_stability.rs:23:#[unstable(feature = "test_feature", issue = "0")] -src/test/auxiliary/lint_stability.rs:25:pub fn deprecated_unstable() {} -src/test/auxiliary/lint_stability.rs:26:#[unstable(feature = "test_feature", issue = "0")] -src/test/auxiliary/lint_stability.rs:28:pub fn deprecated_unstable_text() {} -src/test/auxiliary/lint_stability.rs:30:#[unstable(feature = "test_feature", issue = "0")] -src/test/auxiliary/lint_stability.rs:31:pub fn unstable() {} -src/test/auxiliary/lint_stability.rs:32:#[unstable(feature = "test_feature", reason = "text", issue = "0")] -src/test/auxiliary/lint_stability.rs:33:pub fn unstable_text() {} -src/test/auxiliary/lint_stability.rs:35:#[stable(feature = "rust1", since = "1.0.0")] -src/test/auxiliary/lint_stability.rs:36:pub fn stable() {} -src/test/auxiliary/lint_stability.rs:37:#[stable(feature = "rust1", since = "1.0.0", reason = "text")] -src/test/auxiliary/lint_stability.rs:38:pub fn stable_text() {} -src/test/auxiliary/lint_stability.rs:40:#[stable(feature = "rust1", since = "1.0.0")] -src/test/auxiliary/lint_stability.rs:44: #[stable(feature = "test_feature", since = "1.0.0")] -src/test/auxiliary/lint_stability.rs:47: #[stable(feature = "test_feature", since = "1.0.0")] -src/test/auxiliary/lint_stability.rs:51: #[unstable(feature = "test_feature", issue = "0")] -src/test/auxiliary/lint_stability.rs:53: pub fn method_deprecated_unstable(&self) {} -src/test/auxiliary/lint_stability.rs:54: #[unstable(feature = "test_feature", issue = "0")] -src/test/auxiliary/lint_stability.rs:56: pub fn method_deprecated_unstable_text(&self) {} -src/test/auxiliary/lint_stability.rs:58: #[unstable(feature = "test_feature", issue = "0")] -src/test/auxiliary/lint_stability.rs:59: pub fn method_unstable(&self) {} -src/test/auxiliary/lint_stability.rs:60: #[unstable(feature = "test_feature", reason = "text", issue = "0")] -src/test/auxiliary/lint_stability.rs:61: pub fn method_unstable_text(&self) {} -src/test/auxiliary/lint_stability.rs:63: #[stable(feature = "rust1", since = "1.0.0")] -src/test/auxiliary/lint_stability.rs:64: pub fn method_stable(&self) {} -src/test/auxiliary/lint_stability.rs:65: #[stable(feature = "rust1", since = "1.0.0", reason = "text")] -src/test/auxiliary/lint_stability.rs:66: pub fn method_stable_text(&self) {} -src/test/auxiliary/lint_stability.rs:69:#[stable(feature = "test_feature", since = "1.0.0")] -src/test/auxiliary/lint_stability.rs:71: #[stable(feature = "test_feature", since = "1.0.0")] -src/test/auxiliary/lint_stability.rs:74: #[stable(feature = "test_feature", since = "1.0.0")] -src/test/auxiliary/lint_stability.rs:78: #[unstable(feature = "test_feature", issue = "0")] -src/test/auxiliary/lint_stability.rs:80: fn trait_deprecated_unstable(&self) {} -src/test/auxiliary/lint_stability.rs:81: #[unstable(feature = "test_feature", issue = "0")] -src/test/auxiliary/lint_stability.rs:83: fn trait_deprecated_unstable_text(&self) {} -src/test/auxiliary/lint_stability.rs:85: #[unstable(feature = "test_feature", issue = "0")] -src/test/auxiliary/lint_stability.rs:86: fn trait_unstable(&self) {} -src/test/auxiliary/lint_stability.rs:87: #[unstable(feature = "test_feature", reason = "text", issue = "0")] -src/test/auxiliary/lint_stability.rs:88: fn trait_unstable_text(&self) {} -src/test/auxiliary/lint_stability.rs:90: #[stable(feature = "rust1", since = "1.0.0")] -src/test/auxiliary/lint_stability.rs:91: fn trait_stable(&self) {} -src/test/auxiliary/lint_stability.rs:92: #[stable(feature = "rust1", since = "1.0.0", reason = "text")] -src/test/auxiliary/lint_stability.rs:93: fn trait_stable_text(&self) {} -src/test/auxiliary/lint_stability.rs:98:#[unstable(feature = "test_feature", issue = "0")] -src/test/auxiliary/lint_stability.rs:99:pub trait UnstableTrait { fn dummy(&self) { } } -src/test/auxiliary/lint_stability.rs:101:#[stable(feature = "test_feature", since = "1.0.0")] -src/test/auxiliary/lint_stability.rs:104: #[stable(feature = "test_feature", since = "1.0.0")] pub i: isize -src/test/auxiliary/lint_stability.rs:106:#[unstable(feature = "test_feature", issue = "0")] -src/test/auxiliary/lint_stability.rs:108:pub struct DeprecatedUnstableStruct { -src/test/auxiliary/lint_stability.rs:109: #[stable(feature = "test_feature", since = "1.0.0")] pub i: isize -src/test/auxiliary/lint_stability.rs:111:#[unstable(feature = "test_feature", issue = "0")] -src/test/auxiliary/lint_stability.rs:112:pub struct UnstableStruct { -src/test/auxiliary/lint_stability.rs:113: #[stable(feature = "test_feature", since = "1.0.0")] pub i: isize -src/test/auxiliary/lint_stability.rs:115:#[stable(feature = "rust1", since = "1.0.0")] -src/test/auxiliary/lint_stability.rs:117: #[stable(feature = "test_feature", since = "1.0.0")] pub i: isize -src/test/auxiliary/lint_stability.rs:120:#[stable(feature = "test_feature", since = "1.0.0")] -src/test/auxiliary/lint_stability.rs:123:#[unstable(feature = "test_feature", issue = "0")] -src/test/auxiliary/lint_stability.rs:125:pub struct DeprecatedUnstableUnitStruct; -src/test/auxiliary/lint_stability.rs:126:#[unstable(feature = "test_feature", issue = "0")] -src/test/auxiliary/lint_stability.rs:127:pub struct UnstableUnitStruct; -src/test/auxiliary/lint_stability.rs:128:#[stable(feature = "rust1", since = "1.0.0")] -src/test/auxiliary/lint_stability.rs:131:#[stable(feature = "test_feature", since = "1.0.0")] -src/test/auxiliary/lint_stability.rs:133: #[stable(feature = "test_feature", since = "1.0.0")] -src/test/auxiliary/lint_stability.rs:136: #[unstable(feature = "test_feature", issue = "0")] -src/test/auxiliary/lint_stability.rs:138: DeprecatedUnstableVariant, -src/test/auxiliary/lint_stability.rs:139: #[unstable(feature = "test_feature", issue = "0")] -src/test/auxiliary/lint_stability.rs:140: UnstableVariant, -src/test/auxiliary/lint_stability.rs:142: #[stable(feature = "rust1", since = "1.0.0")] -src/test/auxiliary/lint_stability.rs:146:#[stable(feature = "test_feature", since = "1.0.0")] -src/test/auxiliary/lint_stability.rs:148:pub struct DeprecatedTupleStruct(#[stable(feature = "rust1", since = "1.0.0")] pub isize); -src/test/auxiliary/lint_stability.rs:149:#[unstable(feature = "test_feature", issue = "0")] -src/test/auxiliary/lint_stability.rs:151:pub struct DeprecatedUnstableTupleStruct(#[stable(feature = "rust1", since = "1.0.0")] pub isize); -src/test/auxiliary/lint_stability.rs:152:#[unstable(feature = "test_feature", issue = "0")] -src/test/auxiliary/lint_stability.rs:153:pub struct UnstableTupleStruct(#[stable(feature = "rust1", since = "1.0.0")] pub isize); -src/test/auxiliary/lint_stability.rs:154:#[stable(feature = "rust1", since = "1.0.0")] -src/test/auxiliary/lint_stability.rs:155:pub struct StableTupleStruct(#[stable(feature = "rust1", since = "1.0.0")] pub isize); -src/test/auxiliary/lint_stability_fields.rs:13:#![stable(feature = "rust1", since = "1.0.0")] -src/test/auxiliary/lint_stability_fields.rs:15:#[stable(feature = "rust1", since = "1.0.0")] -src/test/auxiliary/lint_stability_fields.rs:17: #[stable(feature = "rust1", since = "1.0.0")] -src/test/auxiliary/lint_stability_fields.rs:18: pub inherit: u8, // it's a lie (stable doesn't inherit) -src/test/auxiliary/lint_stability_fields.rs:19: #[unstable(feature = "test_feature", issue = "0")] -src/test/auxiliary/lint_stability_fields.rs:22: #[unstable(feature = "test_feature", issue = "0")] -src/test/auxiliary/lint_stability_fields.rs:26:#[stable(feature = "rust1", since = "1.0.0")] -src/test/auxiliary/lint_stability_fields.rs:27:pub struct Stable2(#[stable(feature = "rust1", since = "1.0.0")] pub u8, -src/test/auxiliary/lint_stability_fields.rs:28: #[unstable(feature = "test_feature", issue = "0")] pub u8, -src/test/auxiliary/lint_stability_fields.rs:29: #[unstable(feature = "test_feature", issue = "0")] -src/test/auxiliary/lint_stability_fields.rs:32:#[unstable(feature = "test_feature", issue = "0")] -src/test/auxiliary/lint_stability_fields.rs:33:pub struct Unstable { -src/test/auxiliary/lint_stability_fields.rs:35: #[stable(feature = "rust1", since = "1.0.0")] -src/test/auxiliary/lint_stability_fields.rs:38: #[unstable(feature = "test_feature", issue = "0")] -src/test/auxiliary/lint_stability_fields.rs:42:#[unstable(feature = "test_feature", issue = "0")] -src/test/auxiliary/lint_stability_fields.rs:43:pub struct Unstable2(pub u8, -src/test/auxiliary/lint_stability_fields.rs:44: #[stable(feature = "rust1", since = "1.0.0")] pub u8, -src/test/auxiliary/lint_stability_fields.rs:45: #[unstable(feature = "test_feature", issue = "0")] -src/test/auxiliary/lint_stability_fields.rs:48:#[unstable(feature = "test_feature", issue = "0")] -src/test/auxiliary/lint_stability_fields.rs:52: #[stable(feature = "rust1", since = "1.0.0")] -src/test/auxiliary/lint_stability_fields.rs:54: #[unstable(feature = "test_feature", issue = "0")] -src/test/auxiliary/lint_stability_fields.rs:58:#[unstable(feature = "test_feature", issue = "0")] -src/test/auxiliary/lint_stability_fields.rs:61: #[stable(feature = "rust1", since = "1.0.0")] pub u8, -src/test/auxiliary/lint_stability_fields.rs:62: #[unstable(feature = "test_feature", issue = "0")] pub u8); -src/test/auxiliary/stability_attribute_issue.rs:13:#![stable(feature = "foo", since = "1.2.0")] -src/test/auxiliary/stability_attribute_issue.rs:16:#[unstable(feature = "foo", issue = "1")] -src/test/auxiliary/stability_attribute_issue.rs:17:pub fn unstable() {} -src/test/auxiliary/stability_attribute_issue.rs:19:#[unstable(feature = "foo", reason = "message", issue = "2")] -src/test/auxiliary/stability_attribute_issue.rs:20:pub fn unstable_msg() {} -src/test/auxiliary/stability_cfg1.rs:12:#![cfg_attr(not(foo), stable(feature = "test_feature", since = "1.0.0"))] -src/test/auxiliary/stability_cfg2.rs:13:#![cfg_attr(foo, unstable(feature = "test_feature", issue = "0"))] -src/test/auxiliary/stability_cfg2.rs:14:#![cfg_attr(not(foo), stable(feature = "test_feature", since = "1.0.0"))] -src/test/compile-fail-fulldeps/qquote.rs:31: allow_internal_unstable: false, -src/test/compile-fail/asm-gated.rs:13: asm!(""); //~ ERROR inline assembly is not stable enough -src/test/compile-fail/asm-gated2.rs:13: println!("{}", asm!("")); //~ ERROR inline assembly is not stable -src/test/compile-fail/augmented-assignments-feature-gate-cross.rs:23: //~^ error: overloaded augmented assignments are not stable -src/test/compile-fail/augmented-assignments-feature-gate.rs:24: //~^ error: overloaded augmented assignments are not stable -src/test/compile-fail/augmented-assignments-trait.rs:12://~^ error: use of unstable library feature 'op_assign_traits' -src/test/compile-fail/augmented-assignments-trait.rs:17: //~^ error: use of unstable library feature 'op_assign_traits' -src/test/compile-fail/augmented-assignments-trait.rs:19: //~^ error: use of unstable library feature 'op_assign_traits' -src/test/compile-fail/concat_idents-gate.rs:15: let a = concat_idents!(X, Y_1); //~ ERROR `concat_idents` is not stable -src/test/compile-fail/concat_idents-gate.rs:16: let b = concat_idents!(X, Y_2); //~ ERROR `concat_idents` is not stable -src/test/compile-fail/concat_idents-gate2.rs:15: assert_eq!(10, concat_idents!(X, Y_1)); //~ ERROR `concat_idents` is not stable -src/test/compile-fail/concat_idents-gate2.rs:16: assert_eq!(20, concat_idents!(X, Y_2)); //~ ERROR `concat_idents` is not stable -src/test/compile-fail/const-fn-stability-calls.rs:19:static FOO: usize = foo(); //~ ERROR const fns are an unstable feature -src/test/compile-fail/const-fn-stability-calls.rs:20:const BAR: usize = foo(); //~ ERROR const fns are an unstable feature -src/test/compile-fail/const-fn-stability-calls.rs:29: BAZ: usize = foo() //~ ERROR const fns are an unstable feature -src/test/compile-fail/const-fn-stability.rs:13:const fn foo() -> usize { 0 } //~ ERROR const fn is unstable -src/test/compile-fail/const-fn-stability.rs:16: const fn foo() -> u32; //~ ERROR const fn is unstable -src/test/compile-fail/const-fn-stability.rs:17: const fn bar() -> u32 { 0 } //~ ERROR const fn is unstable -src/test/compile-fail/const-fn-stability.rs:21: const fn baz() -> u32 { 0 } //~ ERROR const fn is unstable -src/test/compile-fail/const-fn-stability.rs:25: const fn foo() -> u32 { 0 } //~ ERROR const fn is unstable -src/test/compile-fail/deriving-meta-unknown-trait.rs:12://~^ ERROR `#[derive]` for custom traits is not stable enough for use and is subject to change -src/test/compile-fail/empty-struct-with-braces-3.rs:13:struct Empty {} //~ ERROR empty structs with braces are unstable -src/test/compile-fail/empty-struct-with-braces-3.rs:16: let e = Empty {}; //~ ERROR empty structs with braces are unstable -src/test/compile-fail/empty-struct-with-braces-3.rs:19: Empty {} => {} //~ ERROR empty structs with braces are unstable -src/test/compile-fail/enable-unstable-lib-feature.rs:11:// Test that enabling an unstable feature disables warnings -src/test/compile-fail/enable-unstable-lib-feature.rs:18:// Shouldn't generate a warning about unstable features -src/test/compile-fail/feature-gate-allow-internal-unstable-nested-macro.rs:14: #[allow_internal_unstable] -src/test/compile-fail/feature-gate-allow-internal-unstable-nested-macro.rs:15: macro_rules! baz { //~ ERROR allow_internal_unstable side-steps -src/test/compile-fail/feature-gate-allow-internal-unstable.rs:11:#[allow_internal_unstable] //~ ERROR allow_internal_unstable side-steps -src/test/compile-fail/feature-gate-assoc-type-defaults.rs:12: type Bar = u8; //~ ERROR associated type defaults are unstable -src/test/compile-fail/feature-gate-feature-gate.rs:11:#![forbid(unstable_features)] -src/test/compile-fail/feature-gate-feature-gate.rs:12:#![feature(intrinsics)] //~ ERROR unstable feature -src/test/compile-fail/feature-gate-rustc-attrs.rs:15:#[rustc_variance] //~ ERROR the `#[rustc_variance]` attribute is just used for rustc unit tests and will never be stable -src/test/compile-fail/feature-gate-rustc-attrs.rs:16:#[rustc_error] //~ ERROR the `#[rustc_error]` attribute is just used for rustc unit tests and will never be stable -src/test/compile-fail/feature-gate-rustc-attrs.rs:17:#[rustc_move_fragments] //~ ERROR the `#[rustc_move_fragments]` attribute is just used for rustc unit tests and will never be stable -src/test/compile-fail/gated-concat_idents.rs:12: concat_idents!(a, b); //~ ERROR `concat_idents` is not stable enough -src/test/compile-fail/gated-thread-local.rs:15:// is given permission to expand into this unstable attribute even -src/test/compile-fail/gated-trace_macros.rs:13: trace_macros!(true); //~ ERROR: `trace_macros` is not stable -src/test/compile-fail/internal-unstable-noallow.rs:11:// this has to be separate to internal-unstable.rs because these tests -src/test/compile-fail/internal-unstable-noallow.rs:16:// aux-build:internal_unstable.rs -src/test/compile-fail/internal-unstable-noallow.rs:17:// error-pattern:use of unstable library feature 'function' -src/test/compile-fail/internal-unstable-noallow.rs:18:// error-pattern:use of unstable library feature 'struct_field' -src/test/compile-fail/internal-unstable-noallow.rs:19:// error-pattern:use of unstable library feature 'method' -src/test/compile-fail/internal-unstable-noallow.rs:20:// error-pattern:use of unstable library feature 'struct2_field' -src/test/compile-fail/internal-unstable-noallow.rs:23:extern crate internal_unstable; -src/test/compile-fail/internal-unstable-noallow.rs:26: call_unstable_noallow!(); -src/test/compile-fail/internal-unstable-noallow.rs:28: construct_unstable_noallow!(0); -src/test/compile-fail/internal-unstable-noallow.rs:30: |x: internal_unstable::Foo| { call_method_noallow!(x) }; -src/test/compile-fail/internal-unstable-noallow.rs:32: |x: internal_unstable::Bar| { access_field_noallow!(x) }; -src/test/compile-fail/internal-unstable-thread-local.rs:11:// aux-build:internal_unstable.rs -src/test/compile-fail/internal-unstable-thread-local.rs:15:extern crate internal_unstable; -src/test/compile-fail/internal-unstable-thread-local.rs:19:thread_local!(static BAR: () = internal_unstable::unstable()); //~ ERROR use of unstable -src/test/compile-fail/internal-unstable.rs:11:// aux-build:internal_unstable.rs -src/test/compile-fail/internal-unstable.rs:13:#![feature(allow_internal_unstable)] -src/test/compile-fail/internal-unstable.rs:16:extern crate internal_unstable; -src/test/compile-fail/internal-unstable.rs:22: internal_unstable::unstable(); //~ ERROR use of unstable -src/test/compile-fail/internal-unstable.rs:26:#[allow_internal_unstable] -src/test/compile-fail/internal-unstable.rs:30: internal_unstable::unstable()); -src/test/compile-fail/internal-unstable.rs:31: internal_unstable::unstable(); -src/test/compile-fail/internal-unstable.rs:37: call_unstable_allow!(); -src/test/compile-fail/internal-unstable.rs:38: construct_unstable_allow!(0); -src/test/compile-fail/internal-unstable.rs:39: |x: internal_unstable::Foo| { call_method_allow!(x) }; -src/test/compile-fail/internal-unstable.rs:40: |x: internal_unstable::Bar| { access_field_allow!(x) }; -src/test/compile-fail/internal-unstable.rs:43: pass_through_allow!(internal_unstable::unstable()); //~ ERROR use of unstable -src/test/compile-fail/internal-unstable.rs:45: pass_through_noallow!(internal_unstable::unstable()); //~ ERROR use of unstable -src/test/compile-fail/internal-unstable.rs:49: println!("{:?}", internal_unstable::unstable()); //~ ERROR use of unstable -src/test/compile-fail/internal-unstable.rs:51: bar!(internal_unstable::unstable()); //~ ERROR use of unstable -src/test/compile-fail/issue-17337.rs:18: #[unstable(feature = "test_feature")] -src/test/compile-fail/issue-28075.rs:11:// Unstable entities should be caught in import lists -src/test/compile-fail/issue-28075.rs:19:use lint_stability::{unstable, deprecated}; //~ ERROR use of unstable library feature 'test_feature' -src/test/compile-fail/issue-28075.rs:22:use lint_stability::unstable::{self as u}; //~ ERROR use of unstable library feature 'test_feature' -src/test/compile-fail/issue-28388-3.rs:17:use lint_stability::UnstableStruct::{}; //~ ERROR use of unstable library feature 'test_feature' -src/test/compile-fail/lint-output-format.rs:16:extern crate lint_output_format; //~ ERROR use of unstable library feature -src/test/compile-fail/lint-output-format.rs:17:use lint_output_format::{foo, bar}; //~ ERROR use of unstable library feature -src/test/compile-fail/lint-output-format.rs:22: let _y = bar(); //~ ERROR use of unstable library feature -src/test/compile-fail/lint-stability-fields.rs:25: override1: 2, //~ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:28: //~^^ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:32: let _ = x.override1; //~ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:35: //~^^ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:39: override1: _, //~ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:42: //~^^ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:50: let _ = x.1; //~ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:53: //~^^ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:56: _, //~ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:59: //~^^ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:65: let x = Unstable { //~ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:66: inherit: 1, //~ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:70: //~^^ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:73: let _ = x.inherit; //~ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:77: //~^^ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:79: let Unstable { //~ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:80: inherit: _, //~ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:84: //~^^ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:87: let Unstable //~ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:92: let x = Unstable2(1, 2, 3); //~ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:94: let _ = x.0; //~ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:98: //~^^ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:100: let Unstable2 //~ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:101: (_, //~ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:105: //~^^ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:107: let Unstable2 //~ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:114: //~^^ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:117: //~^^ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:122: //~^^ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:127: //~^^ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:132: //~^^ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:136: //~^^ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:139: //~^^ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:143: //~^ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:149: //~^^ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:155: //~^^ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:159: //~^^ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:164: //~^^ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:168: //~^^ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:171: //~^^ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:176: //~^^ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:180: //~^^ ERROR use of unstable -src/test/compile-fail/lint-stability-fields.rs:187: #[stable(feature = "rust1", since = "1.0.0")] -src/test/compile-fail/lint-stability-fields.rs:190: #[unstable(feature = "test_feature", issue = "0")] -src/test/compile-fail/lint-stability-fields.rs:193: #[unstable(feature = "test_feature", issue = "0")] -src/test/compile-fail/lint-stability-fields.rs:197: #[stable(feature = "rust1", since = "1.0.0")] -src/test/compile-fail/lint-stability-fields.rs:199: #[stable(feature = "rust1", since = "1.0.0")] u8, -src/test/compile-fail/lint-stability-fields.rs:200: #[unstable(feature = "test_feature", issue = "0")] -src/test/compile-fail/lint-stability-fields.rs:203: #[unstable(feature = "test_feature", issue = "0")] -src/test/compile-fail/lint-stability-fields.rs:204: struct Unstable { -src/test/compile-fail/lint-stability-fields.rs:206: #[stable(feature = "rust1", since = "1.0.0")] -src/test/compile-fail/lint-stability-fields.rs:209: #[unstable(feature = "test_feature", issue = "0")] -src/test/compile-fail/lint-stability-fields.rs:213: #[unstable(feature = "test_feature", issue = "0")] -src/test/compile-fail/lint-stability-fields.rs:214: struct Unstable2(u8, -src/test/compile-fail/lint-stability-fields.rs:215: #[stable(feature = "rust1", since = "1.0.0")] u8, -src/test/compile-fail/lint-stability-fields.rs:216: #[unstable(feature = "test_feature", issue = "0")] -src/test/compile-fail/lint-stability-fields.rs:219: #[unstable(feature = "test_feature", issue = "0")] -src/test/compile-fail/lint-stability-fields.rs:223: #[stable(feature = "rust1", since = "1.0.0")] -src/test/compile-fail/lint-stability-fields.rs:225: #[unstable(feature = "test_feature", issue = "0")] -src/test/compile-fail/lint-stability-fields.rs:229: #[unstable(feature = "test_feature", issue = "0")] -src/test/compile-fail/lint-stability-fields.rs:232: #[stable(feature = "rust1", since = "1.0.0")] u8, -src/test/compile-fail/lint-stability-fields.rs:233: #[unstable(feature = "test_feature", issue = "0")] u8); -src/test/compile-fail/lint-stability-fields.rs:273: let x = Unstable { -src/test/compile-fail/lint-stability-fields.rs:285: let Unstable { -src/test/compile-fail/lint-stability-fields.rs:292: let Unstable -src/test/compile-fail/lint-stability-fields.rs:297: let x = Unstable2(1, 2, 3); -src/test/compile-fail/lint-stability-fields.rs:304: let Unstable2 -src/test/compile-fail/lint-stability-fields.rs:310: let Unstable2 -src/test/compile-fail/lint-stability.rs:26: extern crate stability_cfg2; //~ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:52: deprecated_unstable(); //~ ERROR use of deprecated item -src/test/compile-fail/lint-stability.rs:53: //~^ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:54: foo.method_deprecated_unstable(); //~ ERROR use of deprecated item -src/test/compile-fail/lint-stability.rs:55: //~^ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:56: Foo::method_deprecated_unstable(&foo); //~ ERROR use of deprecated item -src/test/compile-fail/lint-stability.rs:57: //~^ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:58: ::method_deprecated_unstable(&foo); //~ ERROR use of deprecated item -src/test/compile-fail/lint-stability.rs:59: //~^ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:60: foo.trait_deprecated_unstable(); //~ ERROR use of deprecated item -src/test/compile-fail/lint-stability.rs:61: //~^ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:62: Trait::trait_deprecated_unstable(&foo); //~ ERROR use of deprecated item -src/test/compile-fail/lint-stability.rs:63: //~^ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:64: ::trait_deprecated_unstable(&foo); //~ ERROR use of deprecated item -src/test/compile-fail/lint-stability.rs:65: //~^ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:66: ::trait_deprecated_unstable(&foo); //~ ERROR use of deprecated item -src/test/compile-fail/lint-stability.rs:67: //~^ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:69: deprecated_unstable_text(); //~ ERROR use of deprecated item: text -src/test/compile-fail/lint-stability.rs:70: //~^ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:71: foo.method_deprecated_unstable_text(); //~ ERROR use of deprecated item: text -src/test/compile-fail/lint-stability.rs:72: //~^ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:73: Foo::method_deprecated_unstable_text(&foo); //~ ERROR use of deprecated item: text -src/test/compile-fail/lint-stability.rs:74: //~^ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:75: ::method_deprecated_unstable_text(&foo); //~ ERROR use of deprecated item: text -src/test/compile-fail/lint-stability.rs:76: //~^ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:77: foo.trait_deprecated_unstable_text(); //~ ERROR use of deprecated item: text -src/test/compile-fail/lint-stability.rs:78: //~^ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:79: Trait::trait_deprecated_unstable_text(&foo); //~ ERROR use of deprecated item: text -src/test/compile-fail/lint-stability.rs:80: //~^ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:81: ::trait_deprecated_unstable_text(&foo); //~ ERROR use of deprecated item: text -src/test/compile-fail/lint-stability.rs:82: //~^ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:83: ::trait_deprecated_unstable_text(&foo); //~ ERROR use of deprecated item: text -src/test/compile-fail/lint-stability.rs:84: //~^ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:86: unstable(); //~ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:87: foo.method_unstable(); //~ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:88: Foo::method_unstable(&foo); //~ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:89: ::method_unstable(&foo); //~ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:90: foo.trait_unstable(); //~ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:91: Trait::trait_unstable(&foo); //~ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:92: ::trait_unstable(&foo); //~ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:93: ::trait_unstable(&foo); //~ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:95: unstable_text(); -src/test/compile-fail/lint-stability.rs:96: //~^ ERROR use of unstable library feature 'test_feature': text -src/test/compile-fail/lint-stability.rs:97: foo.method_unstable_text(); -src/test/compile-fail/lint-stability.rs:98: //~^ ERROR use of unstable library feature 'test_feature': text -src/test/compile-fail/lint-stability.rs:99: Foo::method_unstable_text(&foo); -src/test/compile-fail/lint-stability.rs:100: //~^ ERROR use of unstable library feature 'test_feature': text -src/test/compile-fail/lint-stability.rs:101: ::method_unstable_text(&foo); -src/test/compile-fail/lint-stability.rs:102: //~^ ERROR use of unstable library feature 'test_feature': text -src/test/compile-fail/lint-stability.rs:103: foo.trait_unstable_text(); -src/test/compile-fail/lint-stability.rs:104: //~^ ERROR use of unstable library feature 'test_feature': text -src/test/compile-fail/lint-stability.rs:105: Trait::trait_unstable_text(&foo); -src/test/compile-fail/lint-stability.rs:106: //~^ ERROR use of unstable library feature 'test_feature': text -src/test/compile-fail/lint-stability.rs:107: ::trait_unstable_text(&foo); -src/test/compile-fail/lint-stability.rs:108: //~^ ERROR use of unstable library feature 'test_feature': text -src/test/compile-fail/lint-stability.rs:109: ::trait_unstable_text(&foo); -src/test/compile-fail/lint-stability.rs:110: //~^ ERROR use of unstable library feature 'test_feature': text -src/test/compile-fail/lint-stability.rs:112: stable(); -src/test/compile-fail/lint-stability.rs:113: foo.method_stable(); -src/test/compile-fail/lint-stability.rs:114: Foo::method_stable(&foo); -src/test/compile-fail/lint-stability.rs:115: ::method_stable(&foo); -src/test/compile-fail/lint-stability.rs:116: foo.trait_stable(); -src/test/compile-fail/lint-stability.rs:117: Trait::trait_stable(&foo); -src/test/compile-fail/lint-stability.rs:118: ::trait_stable(&foo); -src/test/compile-fail/lint-stability.rs:119: ::trait_stable(&foo); -src/test/compile-fail/lint-stability.rs:121: stable_text(); -src/test/compile-fail/lint-stability.rs:122: foo.method_stable_text(); -src/test/compile-fail/lint-stability.rs:123: Foo::method_stable_text(&foo); -src/test/compile-fail/lint-stability.rs:124: ::method_stable_text(&foo); -src/test/compile-fail/lint-stability.rs:125: foo.trait_stable_text(); -src/test/compile-fail/lint-stability.rs:126: Trait::trait_stable_text(&foo); -src/test/compile-fail/lint-stability.rs:127: ::trait_stable_text(&foo); -src/test/compile-fail/lint-stability.rs:128: ::trait_stable_text(&foo); -src/test/compile-fail/lint-stability.rs:131: let _ = DeprecatedUnstableStruct { -src/test/compile-fail/lint-stability.rs:133: //~^^ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:136: let _ = UnstableStruct { i: 0 }; //~ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:140: let _ = DeprecatedUnstableUnitStruct; //~ ERROR use of deprecated item -src/test/compile-fail/lint-stability.rs:141: //~^ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:142: let _ = UnstableUnitStruct; //~ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:146: let _ = Enum::DeprecatedUnstableVariant; //~ ERROR use of deprecated item -src/test/compile-fail/lint-stability.rs:147: //~^ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:148: let _ = Enum::UnstableVariant; //~ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:152: let _ = DeprecatedUnstableTupleStruct (1); //~ ERROR use of deprecated item -src/test/compile-fail/lint-stability.rs:153: //~^ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:154: let _ = UnstableTupleStruct (1); //~ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:163: macro_test_arg!(deprecated_unstable_text()); //~ ERROR use of deprecated item: text -src/test/compile-fail/lint-stability.rs:164: //~^ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:177: foo.trait_deprecated_unstable(); //~ ERROR use of deprecated item -src/test/compile-fail/lint-stability.rs:178: //~^ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:179: Trait::trait_deprecated_unstable(&foo); //~ ERROR use of deprecated item -src/test/compile-fail/lint-stability.rs:180: //~^ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:181: ::trait_deprecated_unstable(&foo); //~ ERROR use of deprecated item -src/test/compile-fail/lint-stability.rs:182: //~^ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:183: ::trait_deprecated_unstable(&foo); //~ ERROR use of deprecated item -src/test/compile-fail/lint-stability.rs:184: //~^ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:185: foo.trait_deprecated_unstable_text(); //~ ERROR use of deprecated item: text -src/test/compile-fail/lint-stability.rs:186: //~^ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:187: Trait::trait_deprecated_unstable_text(&foo); //~ ERROR use of deprecated item: text -src/test/compile-fail/lint-stability.rs:188: //~^ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:189: ::trait_deprecated_unstable_text(&foo); //~ ERROR use of deprecated item: text -src/test/compile-fail/lint-stability.rs:190: //~^ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:191: ::trait_deprecated_unstable_text(&foo); //~ ERROR use of deprecated item: text -src/test/compile-fail/lint-stability.rs:192: //~^ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:193: foo.trait_unstable(); //~ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:194: Trait::trait_unstable(&foo); //~ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:195: ::trait_unstable(&foo); //~ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:196: ::trait_unstable(&foo); //~ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:197: foo.trait_unstable_text(); -src/test/compile-fail/lint-stability.rs:198: //~^ ERROR use of unstable library feature 'test_feature': text -src/test/compile-fail/lint-stability.rs:199: Trait::trait_unstable_text(&foo); -src/test/compile-fail/lint-stability.rs:200: //~^ ERROR use of unstable library feature 'test_feature': text -src/test/compile-fail/lint-stability.rs:201: ::trait_unstable_text(&foo); -src/test/compile-fail/lint-stability.rs:202: //~^ ERROR use of unstable library feature 'test_feature': text -src/test/compile-fail/lint-stability.rs:203: ::trait_unstable_text(&foo); -src/test/compile-fail/lint-stability.rs:204: //~^ ERROR use of unstable library feature 'test_feature': text -src/test/compile-fail/lint-stability.rs:205: foo.trait_stable(); -src/test/compile-fail/lint-stability.rs:206: Trait::trait_stable(&foo); -src/test/compile-fail/lint-stability.rs:207: ::trait_stable(&foo); -src/test/compile-fail/lint-stability.rs:208: ::trait_stable(&foo); -src/test/compile-fail/lint-stability.rs:214: foo.trait_deprecated_unstable(); //~ ERROR use of deprecated item -src/test/compile-fail/lint-stability.rs:215: //~^ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:216: foo.trait_deprecated_unstable_text(); //~ ERROR use of deprecated item: text -src/test/compile-fail/lint-stability.rs:217: //~^ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:218: foo.trait_unstable(); //~ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:219: foo.trait_unstable_text(); -src/test/compile-fail/lint-stability.rs:220: //~^ ERROR use of unstable library feature 'test_feature': text -src/test/compile-fail/lint-stability.rs:221: foo.trait_stable(); -src/test/compile-fail/lint-stability.rs:226: impl UnstableTrait for S { } //~ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:228: trait LocalTrait : UnstableTrait { } //~ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:231: fn trait_stable(&self) {} -src/test/compile-fail/lint-stability.rs:232: fn trait_unstable(&self) {} //~ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:237: extern crate inherited_stability; //~ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:238: use self::inherited_stability::*; //~ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:241: unstable(); //~ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:242: stable(); -src/test/compile-fail/lint-stability.rs:244: stable_mod::unstable(); //~ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:245: stable_mod::stable(); -src/test/compile-fail/lint-stability.rs:247: unstable_mod::deprecated(); //~ ERROR use of deprecated item -src/test/compile-fail/lint-stability.rs:248: unstable_mod::unstable(); //~ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:250: let _ = Unstable::UnstableVariant; //~ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:251: let _ = Unstable::StableVariant; -src/test/compile-fail/lint-stability.rs:254: x.unstable(); //~ ERROR use of unstable library feature -src/test/compile-fail/lint-stability.rs:255: x.stable(); -src/test/compile-fail/lint-stability.rs:260: #[unstable(feature = "test_feature", issue = "0")] -src/test/compile-fail/lint-stability.rs:263: #[unstable(feature = "test_feature", issue = "0")] -src/test/compile-fail/lint-stability.rs:267: #[unstable(feature = "test_feature", issue = "0")] -src/test/compile-fail/lint-stability.rs:268: pub fn unstable() {} -src/test/compile-fail/lint-stability.rs:269: #[unstable(feature = "test_feature", reason = "text", issue = "0")] -src/test/compile-fail/lint-stability.rs:270: pub fn unstable_text() {} -src/test/compile-fail/lint-stability.rs:272: #[stable(feature = "rust1", since = "1.0.0")] -src/test/compile-fail/lint-stability.rs:273: pub fn stable() {} -src/test/compile-fail/lint-stability.rs:274: #[stable(feature = "rust1", since = "1.0.0", reason = "text")] -src/test/compile-fail/lint-stability.rs:275: pub fn stable_text() {} -src/test/compile-fail/lint-stability.rs:277: #[stable(feature = "rust1", since = "1.0.0")] -src/test/compile-fail/lint-stability.rs:281: #[unstable(feature = "test_feature", issue = "0")] -src/test/compile-fail/lint-stability.rs:284: #[unstable(feature = "test_feature", issue = "0")] -src/test/compile-fail/lint-stability.rs:288: #[unstable(feature = "test_feature", issue = "0")] -src/test/compile-fail/lint-stability.rs:289: pub fn method_unstable(&self) {} -src/test/compile-fail/lint-stability.rs:290: #[unstable(feature = "test_feature", reason = "text", issue = "0")] -src/test/compile-fail/lint-stability.rs:291: pub fn method_unstable_text(&self) {} -src/test/compile-fail/lint-stability.rs:293: #[stable(feature = "rust1", since = "1.0.0")] -src/test/compile-fail/lint-stability.rs:294: pub fn method_stable(&self) {} -src/test/compile-fail/lint-stability.rs:295: #[stable(feature = "rust1", since = "1.0.0", reason = "text")] -src/test/compile-fail/lint-stability.rs:296: pub fn method_stable_text(&self) {} -src/test/compile-fail/lint-stability.rs:300: #[unstable(feature = "test_feature", issue = "0")] -src/test/compile-fail/lint-stability.rs:303: #[unstable(feature = "test_feature", issue = "0")] -src/test/compile-fail/lint-stability.rs:307: #[unstable(feature = "test_feature", issue = "0")] -src/test/compile-fail/lint-stability.rs:308: fn trait_unstable(&self) {} -src/test/compile-fail/lint-stability.rs:309: #[unstable(feature = "test_feature", reason = "text", issue = "0")] -src/test/compile-fail/lint-stability.rs:310: fn trait_unstable_text(&self) {} -src/test/compile-fail/lint-stability.rs:312: #[stable(feature = "rust1", since = "1.0.0")] -src/test/compile-fail/lint-stability.rs:313: fn trait_stable(&self) {} -src/test/compile-fail/lint-stability.rs:314: #[stable(feature = "rust1", since = "1.0.0", reason = "text")] -src/test/compile-fail/lint-stability.rs:315: fn trait_stable_text(&self) {} -src/test/compile-fail/lint-stability.rs:320: #[unstable(feature = "test_feature", issue = "0")] -src/test/compile-fail/lint-stability.rs:323: #[stable(feature = "test_feature", since = "1.0.0")] i: isize -src/test/compile-fail/lint-stability.rs:325: #[unstable(feature = "test_feature", issue = "0")] -src/test/compile-fail/lint-stability.rs:326: pub struct UnstableStruct { -src/test/compile-fail/lint-stability.rs:327: #[stable(feature = "test_feature", since = "1.0.0")] i: isize -src/test/compile-fail/lint-stability.rs:329: #[stable(feature = "rust1", since = "1.0.0")] -src/test/compile-fail/lint-stability.rs:331: #[stable(feature = "test_feature", since = "1.0.0")] i: isize -src/test/compile-fail/lint-stability.rs:334: #[unstable(feature = "test_feature", issue = "0")] -src/test/compile-fail/lint-stability.rs:337: #[unstable(feature = "test_feature", issue = "0")] -src/test/compile-fail/lint-stability.rs:338: pub struct UnstableUnitStruct; -src/test/compile-fail/lint-stability.rs:339: #[stable(feature = "rust1", since = "1.0.0")] -src/test/compile-fail/lint-stability.rs:343: #[unstable(feature = "test_feature", issue = "0")] -src/test/compile-fail/lint-stability.rs:346: #[unstable(feature = "test_feature", issue = "0")] -src/test/compile-fail/lint-stability.rs:347: UnstableVariant, -src/test/compile-fail/lint-stability.rs:349: #[stable(feature = "rust1", since = "1.0.0")] -src/test/compile-fail/lint-stability.rs:353: #[unstable(feature = "test_feature", issue = "0")] -src/test/compile-fail/lint-stability.rs:356: #[unstable(feature = "test_feature", issue = "0")] -src/test/compile-fail/lint-stability.rs:357: pub struct UnstableTupleStruct(isize); -src/test/compile-fail/lint-stability.rs:358: #[stable(feature = "rust1", since = "1.0.0")] -src/test/compile-fail/lint-stability.rs:387: unstable(); -src/test/compile-fail/lint-stability.rs:388: foo.method_unstable(); -src/test/compile-fail/lint-stability.rs:389: Foo::method_unstable(&foo); -src/test/compile-fail/lint-stability.rs:390: ::method_unstable(&foo); -src/test/compile-fail/lint-stability.rs:391: foo.trait_unstable(); -src/test/compile-fail/lint-stability.rs:392: Trait::trait_unstable(&foo); -src/test/compile-fail/lint-stability.rs:393: ::trait_unstable(&foo); -src/test/compile-fail/lint-stability.rs:394: ::trait_unstable(&foo); -src/test/compile-fail/lint-stability.rs:396: unstable_text(); -src/test/compile-fail/lint-stability.rs:397: foo.method_unstable_text(); -src/test/compile-fail/lint-stability.rs:398: Foo::method_unstable_text(&foo); -src/test/compile-fail/lint-stability.rs:399: ::method_unstable_text(&foo); -src/test/compile-fail/lint-stability.rs:400: foo.trait_unstable_text(); -src/test/compile-fail/lint-stability.rs:401: Trait::trait_unstable_text(&foo); -src/test/compile-fail/lint-stability.rs:402: ::trait_unstable_text(&foo); -src/test/compile-fail/lint-stability.rs:403: ::trait_unstable_text(&foo); -src/test/compile-fail/lint-stability.rs:405: stable(); -src/test/compile-fail/lint-stability.rs:406: foo.method_stable(); -src/test/compile-fail/lint-stability.rs:407: Foo::method_stable(&foo); -src/test/compile-fail/lint-stability.rs:408: ::method_stable(&foo); -src/test/compile-fail/lint-stability.rs:409: foo.trait_stable(); -src/test/compile-fail/lint-stability.rs:410: Trait::trait_stable(&foo); -src/test/compile-fail/lint-stability.rs:411: ::trait_stable(&foo); -src/test/compile-fail/lint-stability.rs:412: ::trait_stable(&foo); -src/test/compile-fail/lint-stability.rs:414: stable_text(); -src/test/compile-fail/lint-stability.rs:415: foo.method_stable_text(); -src/test/compile-fail/lint-stability.rs:416: Foo::method_stable_text(&foo); -src/test/compile-fail/lint-stability.rs:417: ::method_stable_text(&foo); -src/test/compile-fail/lint-stability.rs:418: foo.trait_stable_text(); -src/test/compile-fail/lint-stability.rs:419: Trait::trait_stable_text(&foo); -src/test/compile-fail/lint-stability.rs:420: ::trait_stable_text(&foo); -src/test/compile-fail/lint-stability.rs:421: ::trait_stable_text(&foo); -src/test/compile-fail/lint-stability.rs:427: let _ = UnstableStruct { i: 0 }; -src/test/compile-fail/lint-stability.rs:431: let _ = UnstableUnitStruct; -src/test/compile-fail/lint-stability.rs:435: let _ = Enum::UnstableVariant; -src/test/compile-fail/lint-stability.rs:439: let _ = UnstableTupleStruct (1); -src/test/compile-fail/lint-stability.rs:452: foo.trait_unstable(); -src/test/compile-fail/lint-stability.rs:453: Trait::trait_unstable(&foo); -src/test/compile-fail/lint-stability.rs:454: ::trait_unstable(&foo); -src/test/compile-fail/lint-stability.rs:455: ::trait_unstable(&foo); -src/test/compile-fail/lint-stability.rs:456: foo.trait_unstable_text(); -src/test/compile-fail/lint-stability.rs:457: Trait::trait_unstable_text(&foo); -src/test/compile-fail/lint-stability.rs:458: ::trait_unstable_text(&foo); -src/test/compile-fail/lint-stability.rs:459: ::trait_unstable_text(&foo); -src/test/compile-fail/lint-stability.rs:460: foo.trait_stable(); -src/test/compile-fail/lint-stability.rs:461: Trait::trait_stable(&foo); -src/test/compile-fail/lint-stability.rs:462: ::trait_stable(&foo); -src/test/compile-fail/lint-stability.rs:463: ::trait_stable(&foo); -src/test/compile-fail/lint-stability.rs:469: foo.trait_unstable(); -src/test/compile-fail/lint-stability.rs:470: foo.trait_unstable_text(); -src/test/compile-fail/lint-stability.rs:471: foo.trait_stable(); -src/test/compile-fail/lint-stability.rs:474: #[unstable(feature = "test_feature", issue = "0")] -src/test/compile-fail/lint-stability.rs:482: #[unstable(feature = "test_feature", issue = "0")] -src/test/compile-fail/lint-stability.rs:490: #[unstable(feature = "test_feature", issue = "0")] -src/test/compile-fail/log-syntax-gate.rs:12: log_syntax!() //~ ERROR `log_syntax!` is not stable enough -src/test/compile-fail/log-syntax-gate2.rs:12: println!("{}", log_syntax!()); //~ ERROR `log_syntax!` is not stable -src/test/compile-fail/missing-stability.rs:22:#[unstable(feature = "foo", issue = "0")] -src/test/compile-fail/missing-stability.rs:24: // #[unstable] is inherited -src/test/compile-fail/missing-stability.rs:28:#[stable(feature = "bar", since="1.0.0")] -src/test/compile-fail/missing-stability.rs:30: // #[stable] is not inherited -src/test/compile-fail/stability-attribute-issue.rs:19: unstable(); //~ ERROR use of unstable library feature 'foo' (see issue #1) -src/test/compile-fail/stability-attribute-issue.rs:20: unstable_msg(); //~ ERROR use of unstable library feature 'foo': message (see issue #2) -src/test/compile-fail/stability-attribute-non-staged.rs:11:#[unstable] //~ ERROR: stability attributes may not be used -src/test/compile-fail/stability-attribute-non-staged.rs:12:#[stable] //~ ERROR: stability attributes may not be used -src/test/compile-fail/stability-attribute-sanity.rs:17: #[stable(feature = "a", since = "a", reason)] //~ ERROR incorrect meta item -src/test/compile-fail/stability-attribute-sanity.rs:20: #[stable(feature = "a", since, reason = "a")] //~ ERROR incorrect meta item -src/test/compile-fail/stability-attribute-sanity.rs:23: #[stable(feature, since = "a", reason = "a")] //~ ERROR incorrect meta item -src/test/compile-fail/stability-attribute-sanity.rs:26: #[stable(feature = "a", since = "a", reason(b))] //~ ERROR incorrect meta item -src/test/compile-fail/stability-attribute-sanity.rs:29: #[stable(feature = "a", since(b), reason = "a")] //~ ERROR incorrect meta item -src/test/compile-fail/stability-attribute-sanity.rs:32: #[stable(feature(b), since = "a", reason = "a")] //~ ERROR incorrect meta item -src/test/compile-fail/stability-attribute-sanity.rs:37: #[unstable] //~ ERROR incorrect stability attribute type -src/test/compile-fail/stability-attribute-sanity.rs:40: #[unstable = "a"] //~ ERROR incorrect stability attribute type -src/test/compile-fail/stability-attribute-sanity.rs:43: #[stable] //~ ERROR incorrect stability attribute type -src/test/compile-fail/stability-attribute-sanity.rs:46: #[stable = "a"] //~ ERROR incorrect stability attribute type -src/test/compile-fail/stability-attribute-sanity.rs:49: #[stable(feature = "a", since = "b")] -src/test/compile-fail/stability-attribute-sanity.rs:53: #[stable(feature = "a", since = "b")] -src/test/compile-fail/stability-attribute-sanity.rs:59: #[unstable(since = "a", issue = "0")] //~ ERROR missing 'feature' -src/test/compile-fail/stability-attribute-sanity.rs:62: #[unstable(feature = "a")] -src/test/compile-fail/stability-attribute-sanity.rs:65: #[stable(since = "a")] //~ ERROR missing 'feature' -src/test/compile-fail/stability-attribute-sanity.rs:70: #[stable(feature = "a")] //~ ERROR missing 'since' -src/test/compile-fail/stability-attribute-sanity.rs:73: #[stable(feature = "a", since = "b")] -src/test/compile-fail/stability-attribute-sanity.rs:78:#[unstable(feature = "a", since = "b", issue = "0")] -src/test/compile-fail/stability-attribute-sanity.rs:79:#[stable(feature = "a", since = "b")] -src/test/compile-fail/stability-attribute-sanity.rs:82:#[unstable(feature = "a", since = "b", issue = "0")] -src/test/compile-fail/stability-attribute-sanity.rs:83:#[unstable(feature = "a", since = "b", issue = "0")] -src/test/compile-fail/stability-attribute-sanity.rs:86:#[stable(feature = "a", since = "b")] -src/test/compile-fail/stability-attribute-sanity.rs:87:#[stable(feature = "a", since = "b")] -src/test/compile-fail/stability-attribute-sanity.rs:90:#[stable(feature = "a", since = "b")] -src/test/compile-fail/stability-attribute-sanity.rs:97:fn deprecated_without_unstable_or_stable() { } //~ ERROR deprecated attribute must be paired -src/test/compile-fail/stable-features.rs:11:// Testing that the stable_features lint catches use of stable -src/test/compile-fail/stable-features.rs:14:#![deny(stable_features)] -src/test/compile-fail/stable-features.rs:15:#![feature(test_accepted_feature)] //~ ERROR this feature is stable -src/test/compile-fail/stable-features.rs:16:#![feature(rust1)] //~ ERROR this feature is stable -src/test/compile-fail/trace_macros-gate.rs:14: trace_macros!(); //~ ERROR `trace_macros` is not stable -src/test/compile-fail/trace_macros-gate.rs:15: trace_macros!(1); //~ ERROR `trace_macros` is not stable -src/test/compile-fail/trace_macros-gate.rs:16: trace_macros!(ident); //~ ERROR `trace_macros` is not stable -src/test/compile-fail/trace_macros-gate.rs:17: trace_macros!(for); //~ ERROR `trace_macros` is not stable -src/test/compile-fail/trace_macros-gate.rs:18: trace_macros!(true,); //~ ERROR `trace_macros` is not stable -src/test/compile-fail/trace_macros-gate.rs:19: trace_macros!(false 1); //~ ERROR `trace_macros` is not stable -src/test/compile-fail/trace_macros-gate2.rs:19: expando!(true); //~ ERROR `trace_macros` is not stable -src/test/compile-fail/trace_macros-gate3.rs:14: println!("arg: {}", trace_macros!()); //~ ERROR `trace_macros` is not stable -src/test/compile-fail/trace_macros-gate3.rs:15: println!("arg: {}", trace_macros!(1)); //~ ERROR `trace_macros` is not stable -src/test/compile-fail/trace_macros-gate3.rs:16: println!("arg: {}", trace_macros!(ident)); //~ ERROR `trace_macros` is not stable -src/test/compile-fail/trace_macros-gate3.rs:17: println!("arg: {}", trace_macros!(for)); //~ ERROR `trace_macros` is not stable -src/test/compile-fail/trace_macros-gate3.rs:18: println!("arg: {}", trace_macros!(true,)); //~ ERROR `trace_macros` is not stable -src/test/compile-fail/trace_macros-gate3.rs:19: println!("arg: {}", trace_macros!(false 1)); //~ ERROR `trace_macros` is not stable -src/test/compile-fail/unboxed-closure-feature-gate.rs:24: //~^ ERROR parenthetical notation is only stable when used with `Fn`-family -src/test/compile-fail/unsafe_no_drop_flag-gate.rs:14://~^ ERROR unsafe_no_drop_flag has unstable semantics and may be removed -src/test/parse-fail/issue-20711-2.rs:18: #[stable(feature = "rust1", since = "1.0.0")] -src/test/parse-fail/issue-20711.rs:16: #[stable(feature = "rust1", since = "1.0.0")] -src/test/run-fail-fulldeps/qquote.rs:35: allow_internal_unstable: false, -src/test/run-make/allow-warnings-cmdline-stability/bar.rs:14:#![unstable(feature = "test_feature", issue = "0")] -src/test/run-make/graphviz-flowgraph/Makefile:16:LASTBLOCKNUM_$(1) := $(shell $(RUSTC_LIB) -Z unstable-options --pretty=expanded,identified $(1) \ -src/test/run-make/graphviz-flowgraph/Makefile:31: $(RUSTC_LIB) -Z unstable-options --unpretty flowgraph,unlabelled=$(LASTBLOCKNUM_$<) $< -o $@.tmp -src/test/run-make/pretty-expanded-hygiene/Makefile:6: $(RUSTC) -o $(TMPDIR)/input.out -Z unstable-options \ -src/test/run-make/pretty-expanded/Makefile:4: $(RUSTC) -o $(TMPDIR)/input.expanded.rs -Z unstable-options \ -src/test/run-make/pretty-print-path-suffix/Makefile:4: $(RUSTC) -o $(TMPDIR)/foo.out -Z unstable-options --unpretty hir=foo input.rs -src/test/run-make/pretty-print-path-suffix/Makefile:5: $(RUSTC) -o $(TMPDIR)/nest_foo.out -Z unstable-options --unpretty hir=nest::foo input.rs -src/test/run-make/pretty-print-path-suffix/Makefile:6: $(RUSTC) -o $(TMPDIR)/foo_method.out -Z unstable-options --unpretty hir=foo_method input.rs -src/test/run-make/pretty-print-to-file/Makefile:4: $(RUSTC) -o $(TMPDIR)/input.out --pretty=normal -Z unstable-options input.rs -src/test/run-pass-fulldeps/qquote.rs:32: allow_internal_unstable: false, -src/test/run-pass/dropck_tarena_sound_drop.rs:19:#![allow(unstable)] -src/test/run-pass/issue-20823.rs:14:#![deny(unstable)] -src/test/run-pass/minmax-stability-issue-23687.rs:58: assert_stable(&presorted); -src/test/run-pass/minmax-stability-issue-23687.rs:62: assert_stable(&presorted); -src/test/run-pass/minmax-stability-issue-23687.rs:65: fn assert_stable(presorted: &[T]) { -src/test/rustdoc/issue-27759.rs:15:// @has issue_27759/unstable/index.html -src/test/rustdoc/issue-27759.rs:18:#[unstable(feature="test", issue="27759")] -src/test/rustdoc/issue-27759.rs:19:pub mod unstable { -src/test/rustdoc/issue-27759.rs:20: // @has issue_27759/unstable/fn.issue.html -src/test/rustdoc/issue-27759.rs:23: #[unstable(feature="test_function", issue="1234567890")] From d1c7f0ce3eaad87eb3e6b12328de62a428475218 Mon Sep 17 00:00:00 2001 From: Eric Findlay Date: Tue, 13 Oct 2015 14:26:59 +0900 Subject: [PATCH 05/94] Completed first draft of documentation.md --- documentation.md | 41 ++++++++++++++-------------- links | 70 ++++++++++++++++++++++++------------------------ 2 files changed, 55 insertions(+), 56 deletions(-) diff --git a/documentation.md b/documentation.md index 40815f748..41e5732f1 100644 --- a/documentation.md +++ b/documentation.md @@ -29,7 +29,7 @@ above to jump to any particular section. # Getting Started If you haven't seen Rust at all yet, the first thing you should read -is the introduction to [The Rust Programming Language][rust]. It'll +is the introduction to [The Rust Programming Language][rustbook]. It'll give you a good idea of what Rust is like. The book provides a lengthy explanation of Rust, its syntax, and its @@ -41,30 +41,31 @@ Rust. resource, but was then donated to the Rust project. As the name implies, it teaches you Rust through a series of small examples. -[rust_by_example]: ["http://rustbyexample.com/"] +[rustbook]: https://doc.rust-lang.org/book/ +[rust_by_example]: http://rustbyexample.com/ # The Standard Library -We have [API documentation][TODO] for the entire standard library. There's a +We have [API documentation][rustdocs] for the entire standard library. There's a list of crates on the left with more specific sections, or you can use the search bar at the top to search for something if you know its name. -[TODO]: [TODO] +[rustdocs]: https://doc.rust-lang.org/ # Community & Getting Help If you need help with something, or just want to talk about Rust with others, there are a few places you can do that: -The Rust IRC channels on [irc.mozilla.org][mozilla_irc] are the +The Rust IRC channels on [irc.mozilla.org][irc_mozilla] are the fastest way to get help. \#rust is the general discussion channel, and you'll find people willing to help you with any questions you may have. There are also three specialty channels: -\#rust-gamedev" and #rust-osdev are for game development and operating +\#rust-gamedev and #rust-osdev are for game development and operating system development, respectively. There's also #rust-internals, which is for discussion of the development of Rust itself. @@ -78,14 +79,18 @@ There is also a [user forum][user_forum], for all user-oriented discussion, and a [developer forum][developer_forum], where the development of Rust itself is discussed. -[irc_mozilla]: "irc://irc.mozilla.org/" +[irc_mozilla]: https://wiki.mozilla.org/IRC +[stack_overflow]: http://stackoverflow.com/questions/tagged/rust +[reddit]: https://www.reddit.com/r/rust/ +[user_forum]: https://users.rust-lang.org/ +[developer_forum]: https://internals.rust-lang.org/ # Specification Rust does not have an exact specification, but an effort to describe as much of -the language in as much detail as possible is in [the reference][reference]. +the language in as much detail as possible is in [the Reference][reference]. -[reference]: reference.html +[reference]: https://doc.rust-lang.org/reference.html # Tools Rust is still a young language, so there isn't a ton of tooling yet, @@ -98,29 +103,23 @@ lots of good documentation. [Rustdoc][rustdoc] is used to generate documentation for Rust code. -[rustdoc]: "book/documentation.html" +[rustdoc]: https://doc.rust-lang.org/book/documentation.html # FAQs -There are questions that are asked quite often, so we've made FAQs for +There are questions that are asked quite often, so we've made a FAQ for them: -- [Language Design FAQ][language_design_faq] -- [Language FAQ][language_faq] -- [Project FAQ][project_faq] -- [How to submit a bug report][bug_report] +- [FAQ][faq] -[language_design_faq]: "complement-design-faq.html" -[language_faq]: "complement-lang-faq.html" -[project_faq]: "complement-project-faq.html" -[bug_report]: "https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#bug-reports" +[faq]: "faq.md" -# The Error Index +# The Error Index If you encounter an error while compiling your code you may be able to look it up in the [Rust Compiler Error Index][error_index]. -[error_index]: "https://doc.rust-lang.org/error-index.html" +[error_index]: https://doc.rust-lang.org/error-index.html # Community Translations diff --git a/links b/links index dbfccc91c..7a6308da9 100644 --- a/links +++ b/links @@ -1,35 +1,35 @@ -CONTRIBUTING.md:133:Documentation improvements are very welcome. The source of `doc.rust-lang.org` -CONTRIBUTING.md:238:[gsearchdocs]: https://www.google.de/search?q=site:doc.rust-lang.org+your+query+here -src/doc/not_found.md:51: search.value = op.join(' ') + " site:doc.rust-lang.org"; -src/doc/trpl/documentation.md:557: html_root_url = "https://doc.rust-lang.org/")] -src/liballoc/lib.rs:71: html_root_url = "https://doc.rust-lang.org/nightly/", -src/libarena/lib.rs:31: html_root_url = "https://doc.rust-lang.org/nightly/")] -src/libcollections/lib.rs:27: html_root_url = "https://doc.rust-lang.org/nightly/", -src/libcore/lib.rs:60: html_root_url = "https://doc.rust-lang.org/nightly/", -src/libflate/lib.rs:26: html_root_url = "https://doc.rust-lang.org/nightly/")] -src/libfmt_macros/lib.rs:26: html_root_url = "https://doc.rust-lang.org/nightly/", -src/libgetopts/lib.rs:90: html_root_url = "https://doc.rust-lang.org/nightly/", -src/libgraphviz/lib.rs:286: html_root_url = "https://doc.rust-lang.org/nightly/")] -src/liblibc/lib.rs:23: html_root_url = "https://doc.rust-lang.org/nightly/", -src/liblog/lib.rs:169: html_root_url = "https://doc.rust-lang.org/nightly/", -src/librand/lib.rs:25: html_root_url = "https://doc.rust-lang.org/nightly/", -src/librbml/lib.rs:123: html_root_url = "https://doc.rust-lang.org/nightly/", -src/librustc/lib.rs:26: html_root_url = "https://doc.rust-lang.org/nightly/")] -src/librustc_back/lib.rs:33: html_root_url = "https://doc.rust-lang.org/nightly/")] -src/librustc_borrowck/lib.rs:20: html_root_url = "https://doc.rust-lang.org/nightly/")] -src/librustc_data_structures/lib.rs:28: html_root_url = "https://doc.rust-lang.org/nightly/")] -src/librustc_driver/lib.rs:26: html_root_url = "https://doc.rust-lang.org/nightly/")] -src/librustc_front/lib.rs:26: html_root_url = "http://doc.rust-lang.org/nightly/")] -src/librustc_lint/lib.rs:31: html_root_url = "https://doc.rust-lang.org/nightly/")] -src/librustc_llvm/lib.rs:26: html_root_url = "https://doc.rust-lang.org/nightly/")] -src/librustc_privacy/lib.rs:20: html_root_url = "https://doc.rust-lang.org/nightly/")] -src/librustc_resolve/lib.rs:20: html_root_url = "https://doc.rust-lang.org/nightly/")] -src/librustc_trans/lib.rs:26: html_root_url = "https://doc.rust-lang.org/nightly/")] -src/librustc_typeck/lib.rs:74: html_root_url = "https://doc.rust-lang.org/nightly/")] -src/librustc_unicode/lib.rs:31: html_root_url = "https://doc.rust-lang.org/nightly/", -src/librustdoc/lib.rs:20: html_root_url = "https://doc.rust-lang.org/nightly/", -src/libserialize/lib.rs:28: html_root_url = "https://doc.rust-lang.org/nightly/", -src/libstd/lib.rs:196: html_root_url = "https://doc.rust-lang.org/nightly/", -src/libsyntax/lib.rs:26: html_root_url = "https://doc.rust-lang.org/nightly/")] -src/libterm/lib.rs:55: html_root_url = "https://doc.rust-lang.org/nightly/", -src/libtest/lib.rs:35: html_root_url = "https://doc.rust-lang.org/nightly/")] +x CONTRIBUTING.md:133:Documentation improvements are very welcome. The source of `doc.rust-lang.org` +x CONTRIBUTING.md:238:[gsearchdocs]: https://www.google.de/search?q=site:doc.rust-lang.org+your+query+here +x src/doc/not_found.md:51: search.value = op.join(' ') + " site:doc.rust-lang.org"; +x src/doc/trpl/documentation.md:557: html_root_url = "https://doc.rust-lang.org/")] +#![doc] src/liballoc/lib.rs:71: html_root_url = "https://doc.rust-lang.org/nightly/", +#![doc] src/libarena/lib.rs:31: html_root_url = "https://doc.rust-lang.org/nightly/")] + src/libcollections/lib.rs:27: html_root_url = "https://doc.rust-lang.org/nightly/", + src/libcore/lib.rs:60: html_root_url = "https://doc.rust-lang.org/nightly/", + src/libflate/lib.rs:26: html_root_url = "https://doc.rust-lang.org/nightly/")] + src/libfmt_macros/lib.rs:26: html_root_url = "https://doc.rust-lang.org/nightly/", + src/libgetopts/lib.rs:90: html_root_url = "https://doc.rust-lang.org/nightly/", + src/libgraphviz/lib.rs:286: html_root_url = "https://doc.rust-lang.org/nightly/")] + src/liblibc/lib.rs:23: html_root_url = "https://doc.rust-lang.org/nightly/", + src/liblog/lib.rs:169: html_root_url = "https://doc.rust-lang.org/nightly/", + src/librand/lib.rs:25: html_root_url = "https://doc.rust-lang.org/nightly/", + src/librbml/lib.rs:123: html_root_url = "https://doc.rust-lang.org/nightly/", + src/librustc/lib.rs:26: html_root_url = "https://doc.rust-lang.org/nightly/")] + src/librustc_back/lib.rs:33: html_root_url = "https://doc.rust-lang.org/nightly/")] + src/librustc_borrowck/lib.rs:20: html_root_url = "https://doc.rust-lang.org/nightly/")] + src/librustc_data_structures/lib.rs:28: html_root_url = "https://doc.rust-lang.org/nightly/")] + src/librustc_driver/lib.rs:26: html_root_url = "https://doc.rust-lang.org/nightly/")] + src/librustc_front/lib.rs:26: html_root_url = "http://doc.rust-lang.org/nightly/")] + src/librustc_lint/lib.rs:31: html_root_url = "https://doc.rust-lang.org/nightly/")] + src/librustc_llvm/lib.rs:26: html_root_url = "https://doc.rust-lang.org/nightly/")] + src/librustc_privacy/lib.rs:20: html_root_url = "https://doc.rust-lang.org/nightly/")] + src/librustc_resolve/lib.rs:20: html_root_url = "https://doc.rust-lang.org/nightly/")] + src/librustc_trans/lib.rs:26: html_root_url = "https://doc.rust-lang.org/nightly/")] + src/librustc_typeck/lib.rs:74: html_root_url = "https://doc.rust-lang.org/nightly/")] + src/librustc_unicode/lib.rs:31: html_root_url = "https://doc.rust-lang.org/nightly/", + src/librustdoc/lib.rs:20: html_root_url = "https://doc.rust-lang.org/nightly/", + src/libserialize/lib.rs:28: html_root_url = "https://doc.rust-lang.org/nightly/", + src/libstd/lib.rs:196: html_root_url = "https://doc.rust-lang.org/nightly/", + src/libsyntax/lib.rs:26: html_root_url = "https://doc.rust-lang.org/nightly/")] + src/libterm/lib.rs:55: html_root_url = "https://doc.rust-lang.org/nightly/", + src/libtest/lib.rs:35: html_root_url = "https://doc.rust-lang.org/nightly/")] From bea69ad6a469bcede7534fab2c02f7df42dfe3c6 Mon Sep 17 00:00:00 2001 From: Andrew Brinker Date: Thu, 22 Oct 2015 19:42:44 -0400 Subject: [PATCH 06/94] Updated FAQ --- faq.md | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/faq.md b/faq.md index 01914ab5e..983850fca 100644 --- a/faq.md +++ b/faq.md @@ -39,7 +39,7 @@ Rust's default hashing algorithm is cryptographically secure, which means it's g Even so, it's [actually not](https://www.reddit.com/r/rust/comments/3hw9zf/rust_hasher_comparisons/cub4oh6) too bad. As you can see from [these benchmark comparisons](http://cglab.ca/~abeinges/blah/hash-rs/) of different hashing implementations in Rust, Rust's SipHash implementation (the default) is a solid choice for a wide variety of purposes. -#### Can I run benchmarks using test::Bencher on the beta or stable channel? +#### Can I run benchmarks using `test::Bencher` on the beta or stable channel? Sadly, no. The `test` feature, which is necessary for testing and benchmarking in Rust, is restricted to the nightly channel. @@ -65,17 +65,17 @@ That being said, having multiple aliasing `&mut T`s is never allowed. Due to the #### Why doesn't Rust have exceptions? -The design issues of exception handling in programming language have been covered at length elsewhere. Exceptions complicate understanding of control-flow, they express validity/invalidity with a system outside of the type system, they interoperate poorly with multithreaded code (a major focus of Rust), the list goes on. +The design issues for exception handling in programming language have been covered at length elsewhere. Exceptions complicate understanding of control-flow, they express validity/invalidity outside of the type system, they interoperate poorly with multithreaded code (a major focus of Rust), the list goes on. -Rust instead opted for a type-based approach to error handling, which is [covered at length in the book](https://doc.rust-lang.org/nightly/book/error-handling.html#the-limits-of-combinators) (the improved chapter is only on nightly at the moment, but will be on stable soon. Everything it covers works on stable). This fits more nicely with Rust's control flow, concurrency, and everything else. +Rust opted instead for a type-based approach to error handling, which is [covered at length in the book](https://doc.rust-lang.org/nightly/book/error-handling.html#the-limits-of-combinators) (the improved chapter is only on nightly at the moment, but will be on stable soon. Everything it covers works on stable). This fits more nicely with Rust's control flow, concurrency, and everything else. #### What's the deal with `unwrap()` everywhere? -`unwrap()` is a function that gets the value out of an `Option` or `Result` and panics if its not there. It is useful both for causing catastrophic failure in certain cases, but it more useful for quick prototypes where you don't want to handle an error yet, or blog posts where error handling would distract from the main point. `unwrap()` shouldn't be your default way to handle errors, but it is a useful tool to have when you need it. +`unwrap()` is a function that extracts the value inside an `Option` or `Result` and panics if its not there. It is useful both for causing catastrophic failure in certain cases, but it more useful for quick prototypes where you don't want to handle an error yet, or blog posts where error handling would distract from the main point. `unwrap()` shouldn't be your default way to handle errors, but it is a useful tool to have when you need it. #### Why do I get an error when I try to run example code that uses the `try!` macro? -It's probably an issue with return types. The [`try!` macro](https://doc.rust-lang.org/stable/std/macro.try!.html) either extracts the value from a `Result`, or returns early with the error `Result` is carrying. This means that try only works for functions that return `Result` themselves, where the second type implements `From::from(err)`. +It's probably an issue with the function's return type. The [`try!` macro](https://doc.rust-lang.org/stable/std/macro.try!.html) either extracts the value from a `Result`, or returns early with the error `Result` is carrying. This means that try only works for functions that return `Result` themselves, where the `Err`-constructed type implements `From::from(err)`. #### Is there an easier way to do error handling than having `Result`s everywhere? @@ -113,7 +113,7 @@ Flexibility, simplicity, and correctness. Curly braces allow for more flexible s #### I can leave out parentheses on if conditions, why do I have to put brackets around single line blocks? Why is the C style not allowed? -A single line block may not always be a single line block. Forgetting to add in the brackets when you add a line to an `if` block can be the cause of some serious programming errors (just look at Apple's ["goto fail"](https://gotofail.com/) bug). In the interest of safety, Rust makes you use the blocks every time. +A single line block may not always be a single line block. Forgetting to add in the brackets when you add a line to an `if` block can be the cause of some serious programming errors (just look at Apple's [“goto fail”](https://gotofail.com/) bug). In the interest of safety, Rust makes you use the blocks every time. #### Why is there no literal syntax for dictionaries? @@ -130,7 +130,7 @@ You should use an implicit return everywhere it can be used. Unless you're writi #### Why does `match` have to be exhaustive? -`match` being exhaustive has some useful properties. First, if every possibility is covered by the `match`, adding further variants to the `enum` in the future will prompt a compilation failure, rather than runtime panic. Second, it makes cost explicit. In general, the only safe way to have a non-exhaustive `match` would be to panic the thread if nothing is matched, though it could fall through if the type of the `match` expression is `()`. This sort of hidden cost and special casing is against the language's philosophy. It's easy to ignore all unspecified cases by using the `_` wildcard: +`match` being exhaustive has some useful properties. First, if every possibility is covered by the `match`, adding further variants to the `enum` in the future will cause a compilation failure, rather than an error at runtime. Second, it makes cost explicit. In general, the only safe way to have a non-exhaustive `match` would be to panic the thread if nothing is matched, though it could fall through if the type of the `match` expression is `()`. This sort of hidden cost and special casing is against the language's philosophy. It's easy to ignore all unspecified cases by using the `_` wildcard: ```rust match val.do_something() { @@ -147,7 +147,7 @@ Lifetimes are Rust's answer to garbage collection. They are a way of ensuring me #### Why is the lifetime syntax the way it is? -The `'a` syntax comes from the ML family of programming languages, where `'a` is used to indicate a generic type parameter. For Rust, the syntax had to be something that was unambiguous, noticable, and fit nicely in a type right alonside traits and references. Alternative syntaxes have been discussed, but this seemed to work just fine. +The `'a` syntax comes from the ML family of programming languages, where `'a` is used to indicate a generic type parameter. For Rust, the syntax had to be something that was unambiguous, noticable, and fit nicely in a type declaration right alonside traits and references. Alternative syntaxes have been discussed, but this seems to work just fine. #### When is `Rc` useful? @@ -155,7 +155,7 @@ This is covered in the [official documentation for `Rc`](https://doc.rust-lang.o #### How do I return a borrow to something I created from a function? -You need to ensure that the borrowed-to item will outlive the function. This can be done in two ways: by binding the output lifetime to some input lifetime, or by declaring the output lifetime as static. The first option is significantly better than the second. +You need to ensure that the borrowed item will outlive the function. This can be done in two ways: by binding the output lifetime to some input lifetime, or by declaring the output lifetime as static. The first option is significantly better than the second. Here is an example of the each: @@ -175,7 +175,7 @@ The problem with declaring the lifetime as `static` is that it's rarely what you #### How do I return a closure from a function? -To return a closure from a function, it must be what's called a "move closure", meaning that the closure is declared with the `move` keyword. As [explained in the Rust book](https://doc.rust-lang.org/book/closures.html#move-closures), this gives the closure its own stack frame, so it is not dependent on its parent stack frame. Otherwise, returning a closure would be unsafe, as it would allow access to variables that are no longer defined (put another way, it would allow reading potentially invalid memory). +To return a closure from a function, it must be what's called a "move closure", meaning that the closure is declared with the `move` keyword. As [explained in the Rust book](https://doc.rust-lang.org/book/closures.html#move-closures), this gives the closure its own stack frame, so it is not dependent on its parent stack frame. Otherwise, returning a closure would be unsafe, as it would allow access to variables that are no longer defined (put another way, it would allow reading potentially invalid memory). The closure must also be wrapped in a `Box`, so that it is allocated on the heap. Read more about this [in the book](https://doc.rust-lang.org/book/closures.html#returning-closures). #### When are lifetimes required to be defined? From 596d92cd3d6b70bb2ccf08e380f24af5ee439730 Mon Sep 17 00:00:00 2001 From: Andrew Brinker Date: Thu, 22 Oct 2015 19:50:35 -0400 Subject: [PATCH 07/94] Cleanup --- _layouts/faq.html | 95 +++-------------------------------------------- css/style.css | 24 ------------ faq.md | 38 ++++++++++++++++++- 3 files changed, 43 insertions(+), 114 deletions(-) diff --git a/_layouts/faq.html b/_layouts/faq.html index 51c232db8..cb2b21011 100644 --- a/_layouts/faq.html +++ b/_layouts/faq.html @@ -5,94 +5,11 @@
- {{ content }} -
-

Copyright © 2011-2015 The Rust Project Developers.
- Licensed under the Apache License, Version 2.0 or the MIT license, at your option.
- This file may not be copied, modified, or distributed except according to those terms.

-
+ {{ content }} +
+

Copyright © 2011-2015 The Rust Project Developers.
+ Licensed under the Apache License, Version 2.0 or the MIT license, at your option.
+ This file may not be copied, modified, or distributed except according to those terms.

+
- - - - diff --git a/css/style.css b/css/style.css index d5f0772c7..0bc60669d 100644 --- a/css/style.css +++ b/css/style.css @@ -467,23 +467,6 @@ ul.laundry-list { position: relative; } - .faq h1::before { - content: "Draft"; - position: absolute; - top: 1.25rem; - left: -6rem; - font-size: 1.5rem; - line-height: 1em; - display: inline-block; - font-weight: 400; - color: hsla(50, 90%, 30%, 1); - text-align: center; - background-color: hsla(50, 90%, 80%, 1); - border-bottom: 3px solid hsla(50, 90%, 50%, 1); - padding: .55em .5em .2em; - border-radius: .25em; - } - .faq h2 { font-size: 2em; line-height: 1.5em; @@ -584,10 +567,3 @@ ul.laundry-list { content: counter(tos); counter-increment: tos; } - -.todo { - background-color: #FFCC00; - padding: 1em 1em .75em; - border-radius: .25em; - font-family: "Fira Sans"; -} diff --git a/faq.md b/faq.md index 983850fca..18fa02eda 100644 --- a/faq.md +++ b/faq.md @@ -9,7 +9,35 @@ This document exists to answer some common questions about the Rust programming If there is some common or important question you feel is wrongly left unanswered here, feel free to [help us fix it](https://github.com/rust-lang/rust-www/blob/master/CONTRIBUTING.md). -
+ ## Performance @@ -499,9 +527,11 @@ The main project is [Servo](https://github.com/servo/servo), an experimental bro The two biggest open source Rust projects right now are [Servo](https://github.com/servo/servo) and the [Rust compiler](https://github.com/rust-lang/rust) itself. + #### How can I try Rust easily? @@ -597,9 +627,11 @@ fn main() { If you know this is going to happen, perhaps it saves a small number of keystrokes, but it also greatly increases the possibility for surprising error messages when you actually meant for `baz()` to be `bar::baz()`, and it decreases the readability of the code by making the meaning of a function call dependent on module declaration. These are not tradeoffs we are willing to make. + #### How do I do dynamic Rust library loading? @@ -771,13 +803,17 @@ The `repr` attribute can be applied to such `enums` to give them the same repres ## Cross-Platform + + #### What's the idiomatic way to express platform-specific behavior in Rust? From a5329311227a403b82bffab7e4208e71e228b1b6 Mon Sep 17 00:00:00 2001 From: Andrew Brinker Date: Thu, 22 Oct 2015 21:31:10 -0400 Subject: [PATCH 08/94] Corrections --- faq.md | 50 +++++++++++++++++++++++++++++++++++++------------- 1 file changed, 37 insertions(+), 13 deletions(-) diff --git a/faq.md b/faq.md index 18fa02eda..e1b478cf7 100644 --- a/faq.md +++ b/faq.md @@ -77,17 +77,13 @@ In general, tail-call optimization is not guaranteed: see [here](https://mail.mo #### Does Rust have a runtime? -Rust has a [very small and limited runtime](https://github.com/Kimundi/lazy-static.rs) providing a heap, unwinding and backtrace support, and stack guards. This runtime is comparable to the [C runtime](http://www.embecosm.com/appnotes/ean9/html/ch05s02.html), and allows for the calling of Rust functions from C without setup. +Rust has a [very small and limited runtime]() providing a heap, unwinding and backtrace support, and stack guards. This runtime is comparable to the [C runtime](http://www.embecosm.com/appnotes/ean9/html/ch05s02.html), and allows for the calling of Rust functions from C without setup. ## Concurrency #### Can I use globals across threads without `unsafe`? -No, even if the type implements `Sync`. - -Types which are `Sync` are thread-safe when multiple shared references to them are used concurrently. Types which are not `Sync` are not thread-safe, and thus when used in a global require `unsafe` to use. - -That being said, having multiple aliasing `&mut T`s is never allowed. Due to the nature of globals the borrow checker cannot possibly ensure that a `static` obeys the borrowing rules, so taking a mutable reference to a `static` is always unsafe. +Yes, if the type implements `Sync`, doesn't implement `Drop`, and you don't try to mutate the global value. ## Error Handling @@ -201,6 +197,10 @@ fn example2<'a>(s: &'a str) -> &'static str { The problem with declaring the lifetime as `static` is that it's rarely what you actually mean, and is instead a way of escaping the lifetime system. References with a `static` lifetime outlive everything else, and this means that they can be used in ways that would otherwise be invalid with the first method. +An alternative is to return an owning type like `String`. This eliminates the reference issues entirely, at the cost of possibly unnecessary allocations. + +There is also the `Cow` ("copy on write") type, which will only do the extra allocation if you attempt to mutate the contained value. + #### How do I return a closure from a function? To return a closure from a function, it must be what's called a "move closure", meaning that the closure is declared with the `move` keyword. As [explained in the Rust book](https://doc.rust-lang.org/book/closures.html#move-closures), this gives the closure its own stack frame, so it is not dependent on its parent stack frame. Otherwise, returning a closure would be unsafe, as it would allow access to variables that are no longer defined (put another way, it would allow reading potentially invalid memory). The closure must also be wrapped in a `Box`, so that it is allocated on the heap. Read more about this [in the book](https://doc.rust-lang.org/book/closures.html#returning-closures). @@ -240,7 +240,7 @@ At the moment, you can't without `unsafe`. If you have a struct with a pointer t #### What is the difference between consuming and moving/taking ownership? -Consuming means that the value has been dropped, and is no longer defined. With just a move, the value is still alive, but ownership has been transferred to a new owner, meaning the old owner can no longer modify it or lend out references. +These are different terms for the same thing. In both cases, it means the value has been moved into a function, and moved out of the calling owner. #### Why when I pass a struct to a function the compiler says it's been moved and I can't use it anymore, when the same doesn't happen for integers? @@ -292,7 +292,7 @@ Things stabilize all the time, and the beta and stable channels update every six #### How can I convert a `String` or `Vec` to a slice (`&str` and `&[T]`)? -Using Deref coercions! `Strings` and `Vec`s will automatically coerce to their respective slices when referenced. +Using Deref coercions `Strings` and `Vec`s will automatically coerce to their respective slices when passed by reference with `&` or `& mut`. #### How can I convert from `&str` to `String` or the other way around? @@ -337,7 +337,7 @@ let v: Vec<&str> = s.lines().collect(); #### How do I do O(1) character access in a `String`? -You don't, not without converting the `String` into something else. If you do that, it comes with some serious caveats. Strings in Rust are all UTF-8 encoded, and O(1) access to characters is impossible in UTF-8. If you index by bytes as you normally would in ASCII strings you'll get a UTF-8 codepoint, which may or may not be an actual character. +`str` implements both the `Index` and `IndexMut` traits, but because Rust strings are all UTF-8, and so it can be indexed exactly as you would expect. But if you do that, it comes with some serious caveats. Strings in Rust are all UTF-8 encoded, and O(1) access to characters is impossible in UTF-8. If you index by bytes as you normally would in ASCII strings you'll get a UTF-8 codepoint, which may or may not be an actual character. If you try to index a location that is not a valid UTF-8 boundary, the operation with panic, which makes it doubly unlikely that indexing is what you're looking for. If you are absolutely certain your string is in fact ASCII, you can get O(1) access by indexing the underlying buffer like so: @@ -359,7 +359,7 @@ Scanning a `str` for ASCII-range codepoints can still be done safely octet-at-a- Most "character oriented" operations on text only work under very restricted language assumptions sets such as "ASCII-range codepoints only". Outside ASCII-range, you tend to have to use a complex (non-constant-time) algorithm for determining linguistic-unit (glyph, word, paragraph) boundaries anyways. We recommend using an "honest" linguistically-aware, Unicode-approved algorithm. -The `char` type is UCS4. If you honestly need to do a codepoint-at-a-time algorithm, it's trivial to write a `type wstr = [char]`, and unpack a `str` into it in a single pass, then work with the `wstr`. In other words: the fact that the language is not "decoding to UCS4 by default" shouldn't stop you from decoding (or re-encoding any other way) if you need to work with that encoding. +The `char` type is UTF32. If you honestly need to do a codepoint-at-a-time algorithm, it's trivial to write a `type wstr = [char]`, and unpack a `str` into it in a single pass, then work with the `wstr`. In other words: the fact that the language is not "decoding to UTF32 by default" shouldn't stop you from decoding (or re-encoding any other way) if you need to work with that encoding. ## Collections @@ -565,6 +565,10 @@ There are a couple developing options: [RustDT](https://github.com/RustDT/RustDT - There is no global inter-crate namespace; all name management occurs within a crate. - Using another crate binds the root of its namespace into the user's namespace. +#### Why can't the Rust compiler find this library I'm `use`ing? + +There are a number of possible answers, but a common mistake is not realizing that `use` declarations are _always_ relative to the crate root. Try rewriting your declarations to use the paths they would use if defined in the root file of your project and see if that fixes the problem. + #### Why do I have to declare module files with mod at the top level of the crate, instead of just `use`ing them? There are two ways to declare modules in Rust, inline or in another file. Here is an example of each: @@ -663,6 +667,8 @@ Over time more and more answers will be offered for the current version, this im Monomorphisation is the process by which Rust generates specific instances of a generic function based on the types of the various calls to that function. This is used to provide static dispatch for generic functions. For functions using trait objects for generics, dynamic dispatch is used instead, with calls to the function going through a vtable to identify specific function calls for the provided type implementing the given trait. +In C++ people would likely know this as "template instantiation." But unlike C++, Rust's monomorphisation is an implementation detail, and not a language feature. + #### What's the different between a function and a closure that doesn't capture any variables? Functions are a built-in primitive of the language, while closures are essentially syntactic sugar for one of three traits: `Fn`, `FnMut`, and `FnOnce`. When you make a closure, the Rust compiler automatically creates a struct implementing the appropriate trait of those three and containing the captured environment variables as members, and makes it so the the struct can be called as a function. @@ -921,9 +927,9 @@ Rust doesn't currently have an equivalent to template specialization, but it is #### How does Rust's ownership system related to move semantics in C++? -In C++, moving vs copying was added on late with C++11. With Rust the concept of moving vs copying has been around from the beginning. In C++ something can be moved into a function or out of a function using r-value references and either `std::move` or `std::forward`. In Rust, moves happen for anything that does not implement the `Copy` trait (which will cause the value of the type to be copied, rather than moved). This means that moves are the default operation, and that copies must be opted into explicitly. +In C++, moving vs copying was added on late with C++11. With Rust the concept of moving vs copying has been around from the beginning. In C++ something can be moved into a function or out of a function using r-value references and either `std::move` or `std::forward`. In Rust, moves happen for anything that does not implement the `Copy` trait (which will cause the value of the type to be copied, rather than moved). This means that moves are the default operation, and that copies must be opted into explicitly. It's also important to know that moves in Rust are destructive copies, which call `Drop` (equivalent to a C++ destructor) on the moved value. -One thing to note, however is that moves are often not necessary or desirable in Rust. If the function you're writing does not require ownership of the value being passed in, it should probably be borrowed (mutably or immutable, as necessary) rather than moved or copied. +Moves are often not necessary or desirable in Rust. If the function you're writing does not require ownership of the value being passed in, it should probably be borrowed (mutably or immutably, as necessary) rather than moved or copied. It's also useful to note that functions can explicitly require that an input parameter be copied like so: @@ -939,7 +945,25 @@ The simplest way is to interoperate through C. Both Rust and C++ provide a [fore #### Does Rust have C++-style constructors? -No. Functions can serve the same purpose as constructors without adding any language complexity. +No. Functions can serve the same purpose as constructors without adding any language complexity. The usual name for the constructor-equivalent function in Rust is `new()`, although this is just a social norm rather than a language rule. The `new()` function in fact is just like any other function. An example of it looks like so: + +```rust +struct Foo { + a: i32, + b: f64, + c: bool +} + +impl Foo { + fn new() -> Foo { + Foo { + a: 0, + b: 0.0, + c: false + } + } +} +``` #### Does Rust have copy constructors? From b7826590440e28520df61007b4d643326280ae4a Mon Sep 17 00:00:00 2001 From: Andrew Brinker Date: Sat, 24 Oct 2015 11:16:51 -0400 Subject: [PATCH 09/94] Updated FAQ based on Diggsey's suggestions --- faq.md | 22 ++++++++++++++++++++-- 1 file changed, 20 insertions(+), 2 deletions(-) diff --git a/faq.md b/faq.md index e1b478cf7..69bdbd27d 100644 --- a/faq.md +++ b/faq.md @@ -117,7 +117,7 @@ All things being equal, `f64` is likely a better default. #### Why can't I compare floats? -You can! Floats implement the `PartialOrd` trait, which means that `>`, `<`, `<=`, and `>=` are defined for them. But they do _not_ implement the `Ord` trait, because (thanks to `NaN`) there is no total ordering for floating point numbers. +You can! Floats implement the `PartialOrd` trait, which means that `>`, `<`, `<=`, and `>=` are defined for them. But they do _not_ implement the `Ord` trait, because (thanks to `NaN`) there is no total ordering for floating point numbers. There [is a crate](https://crates.io/crates/ordered-float) that provides a total ordering on floats by wrapping them, which may be desirable depending on your use-case. So you can do all the normal comparison operations you would expect, but you can't use the `cmp` function. @@ -232,7 +232,25 @@ more efficient, but bypasses Rust's safety guarantees. #### How can I define a struct that contains a pointer to one of its own fields? -At the moment, you can't without `unsafe`. If you have a struct with a pointer to one of its own fields, the Rust compiler has no way to know if the pointed-to field will be destroyed before or after the containing struct, and so it can't guarantee that the pointer into the field won't potentially point to invalid memory. +You can, but it's useless to do so. The struct becomes permanently borrowed by itself and therefore can't be moved. Here is some code illustrating this: + +```rust +use std::cell::Cell; + +#[derive(Debug)] +struct Unmovable<'a> { + x: u32, + y: Cell>, +} + + +fn main() { + let test = Unmovable { x: 42, y: Cell::new(None) }; + test.y.set(Some(&test.x)); + + println!("{:?}", test); +} +``` #### What does it mean to "consume a value"? From e94751d713d9a4d5158c50bc1403c2f4b564fa2a Mon Sep 17 00:00:00 2001 From: Andrew Brinker Date: Fri, 6 Nov 2015 16:20:47 -0500 Subject: [PATCH 10/94] Addressing feedback --- faq.md | 205 +++++++++++++++++++++++++-------------------------------- 1 file changed, 91 insertions(+), 114 deletions(-) diff --git a/faq.md b/faq.md index 69bdbd27d..86a522fa1 100644 --- a/faq.md +++ b/faq.md @@ -5,7 +5,7 @@ title: Frequently Asked Questions · The Rust Programming Language # Frequently Asked Questions -This document exists to answer some common questions about the Rust programming language. It is not a complete guide to the language, nor is it a tool for teaching the language. Rather, it exists as a reference to answer oft-repeated questions people in the Rust community encounter, and to clarify some of the design and history of the language. +This page exists to answer common questions about the Rust programming language. It is not a complete guide to the language, nor is it a tool for teaching the language. It is a reference to answer oft-repeated questions people in the Rust community encounter, and to clarify the reasoning behind some of Rust's design decisions. If there is some common or important question you feel is wrongly left unanswered here, feel free to [help us fix it](https://github.com/rust-lang/rust-www/blob/master/CONTRIBUTING.md). @@ -39,63 +39,63 @@ If there is some common or important question you feel is wrongly left unanswere -## Performance +### Performance #### How fast is Rust? -As always, this question is difficult to answer. There's still a lot of work to do on speed, and depending on what you're benchmarking, Rust has variable performance. +Fast! Rust is already competitive with idiomatic C and C++ in a number of benchmarks. -That said, it is an explicit goal of Rust to be as fast as C++ for most things. Language decisions are made with performance in mind, and we want Rust to be as fast as possible. Given that Rust is built on top of LLVM, any performance improvements in it also help Rust become faster. +It is an explicit goal of Rust to be at least as fast as C++. Language decisions are made with performance in mind, and given that Rust is built on LLVM, any LLVM performance improvements also help Rust. #### Is Rust garbage collected? -No. A language that requires a GC is a language that opts into a larger, more complex runtime than Rust cares for. Rust is usable on bare metal with no extra runtime. Additionally, garbage collection is frequently a source of non-deterministic behavior. Rust provides the tools to make using a GC possible and even pleasant, but it should not be a requirement for implementing the language. +No. A language that requires a GC is a language that opts into a larger, more complex runtime than Rust cares for. Rust is usable on bare metal with no extra runtime. Additionally, garbage collection is frequently a source of non-deterministic behavior. Rust provides the tools to make using a GC [possible and even pleasant](http://manishearth.github.io/blog/2015/09/01/designing-a-gc-in-rust/), but it is not part of the language as provided. -#### Why is my program compiled with `cargo build` slow? +#### Why is my program slow? -Did you compile with the `--release` flag? The Rust language uses a lot of optimizations in release mode that make the language competitive with C and C++, but you need to explicitly ask for them, as they also result in longer compilation times that may be undesirable during development. +Did you compile with the `--release` flag? The Rust language uses a lot of optimizations in release mode, but you need to explicitly ask for them, as they also result in longer compilation times that may be undesirable during development. #### Why is Rust compilation slow? -It's a combination of factors. Both the type inference and safety-related checks are fairly complex. They make life easier for the programmer, but they require some time to run. Add in the optimizations, and Rust's compilation is slower than a simpler language that doesn't provide Rust's safety guarantees. +Most of the compilation time is spent in type checking and code translation, with some time also used for safety checks. All of these are required for the strong guarantees Rust makes, but they require some time to run. Add in optimizations, and Rust's compilation is slower than a simpler language that doesn't provide Rust's guarantees. -But all is not lost. The Rust compiler has evolved significantly over a number of years, and a lot of good work is being done to make it work faster. So expect improvements in compilation speed over time. +But all is not lost. The Rust compiler has evolved significantly over a number of years, and a lot of good work is being done to make it work faster, and to make it feel faster during development. #### Why is Rust's HashMap so slow? -Rust's default hashing algorithm is cryptographically secure, which means it's great if you need something that can't be easily guessed at, but you pay for that with slower performance relative to a non-cryptographically secure algorithm. +By default, Rust's `HashMap` uses the [SipHash](https://131002.net/siphash/) hashing algorithm, which is designed to prevent [hash table collision attacks](http://programmingisterrible.com/post/40620375793/hash-table-denial-of-service-attacks-revisited) while providing [reasonable performance on a variety of workloads](https://www.reddit.com/r/rust/comments/3hw9zf/rust_hasher_comparisons/cub4oh6). -Even so, it's [actually not](https://www.reddit.com/r/rust/comments/3hw9zf/rust_hasher_comparisons/cub4oh6) too bad. As you can see from [these benchmark comparisons](http://cglab.ca/~abeinges/blah/hash-rs/) of different hashing implementations in Rust, Rust's SipHash implementation (the default) is a solid choice for a wide variety of purposes. +While SipHash [demonstrates competitive performance](http://cglab.ca/%7Eabeinges/blah/hash-rs/) in many cases, one case where it is notably slower than other hashing algorithms is with short keys, such as integers. This is why Rust programmers often observe slow performance with `HashMap`. The [FNV hasher](https://crates.io/crates/fnv) is frequently recommended for these cases, but be aware that it does not have the same collision-resistence properties as SipHash. -#### Can I run benchmarks using `test::Bencher` on the beta or stable channel? +#### Why can't I run benchmarks? -Sadly, no. The `test` feature, which is necessary for testing and benchmarking in Rust, is restricted to the nightly channel. +You can run benchmarks, but only on the nightly channel. Rust's benchmarking mechanism is currently unstable, as the API has not been deemed ready for stabilization. This may change in the future, but until then benchmarking can only be used on nightly. #### Does Rust do tail-call optimization? -In general, tail-call optimization is not guaranteed: see [here](https://mail.mozilla.org/pipermail/rust-dev/2013-April/003557.html) for a detailed explanation with references. There was a [proposed extension](https://github.com/rust-lang/rfcs/pull/81) that would allow tail-call elimination in certain contexts, but it is currently postponed. The compiler is still free to optimize tail-calls [when it pleases](http://llvm.org/docs/CodeGenerator.html#sibling-call-optimization), however. +In general, tail-call optimization is [not guaranteed](https://mail.mozilla.org/pipermail/rust-dev/2013-April/003557.html), but may be done in [limited circumstances](http://llvm.org/docs/CodeGenerator.html#sibling-call-optimization). There was a [proposed extension](https://github.com/rust-lang/rfcs/pull/81) that would allow tail-call elimination in certain contexts, but it is currently postponed. The compiler is still free to optimize tail-calls [when it pleases](http://llvm.org/docs/CodeGenerator.html#sibling-call-optimization), however, and the language has a word (`become`) reserved for future explicit tail calls. #### Does Rust have a runtime? -Rust has a [very small and limited runtime]() providing a heap, unwinding and backtrace support, and stack guards. This runtime is comparable to the [C runtime](http://www.embecosm.com/appnotes/ean9/html/ch05s02.html), and allows for the calling of Rust functions from C without setup. +Rust has a [very small and limited runtime](https://doc.rust-lang.org/std/rt/) providing a heap, unwinding and backtrace support, and stack guards. This runtime is comparable to the [C runtime](http://www.embecosm.com/appnotes/ean9/html/ch05s02.html), and allows for the calling of Rust functions from C without setup. -## Concurrency +### Concurrency #### Can I use globals across threads without `unsafe`? Yes, if the type implements `Sync`, doesn't implement `Drop`, and you don't try to mutate the global value. -## Error Handling +### Error Handling #### Why doesn't Rust have exceptions? -The design issues for exception handling in programming language have been covered at length elsewhere. Exceptions complicate understanding of control-flow, they express validity/invalidity outside of the type system, they interoperate poorly with multithreaded code (a major focus of Rust), the list goes on. +Exceptions complicate understanding of control-flow, they express validity/invalidity outside of the type system, and they interoperate poorly with multithreaded code (a major focus of Rust). -Rust opted instead for a type-based approach to error handling, which is [covered at length in the book](https://doc.rust-lang.org/nightly/book/error-handling.html#the-limits-of-combinators) (the improved chapter is only on nightly at the moment, but will be on stable soon. Everything it covers works on stable). This fits more nicely with Rust's control flow, concurrency, and everything else. +Rust prefers a type-based approach to error handling, which is [covered at length in the book](https://doc.rust-lang.org/stable/book/error-handling.html). This fits more nicely with Rust's control flow, concurrency, and everything else. #### What's the deal with `unwrap()` everywhere? -`unwrap()` is a function that extracts the value inside an `Option` or `Result` and panics if its not there. It is useful both for causing catastrophic failure in certain cases, but it more useful for quick prototypes where you don't want to handle an error yet, or blog posts where error handling would distract from the main point. `unwrap()` shouldn't be your default way to handle errors, but it is a useful tool to have when you need it. +`unwrap()` is a function that extracts the value inside an `Option` or `Result` and panics if no value is present. It is useful in the presence of truly unrecoverable errors, but is more useful for quick prototypes where you don't want to handle an error yet, or blog posts where error handling would distract from the main point. `unwrap()` shouldn't be your default way to handle errors, but it is a useful tool to have. #### Why do I get an error when I try to run example code that uses the `try!` macro? @@ -103,9 +103,9 @@ It's probably an issue with the function's return type. The [`try!` macro](https #### Is there an easier way to do error handling than having `Result`s everywhere? -If you're looking for a way to avoid handling `Result`s in other people's code, there's always `unwrap()`, but it's probably not what you actually want. `Result` is an indicator that some computation may or may not complete. The fact that some languages allow you to ignore failure cases is an anti-feature. Forcing you to handle them is one of the ways that Rust encourages safety. So, if you really don't want to handle error, use `unwrap()`, but you should probably just handle the error for real. +If you're looking for a way to avoid handling `Result`s in other people's code, there's always `unwrap()`, but it's probably not what you actually want. `Result` is an indicator that some computation may or may not complete successfully. The fact that some languages allow you to ignore failure cases is an anti-feature. Forcing you to handle them is one of the ways that Rust encourages safety. So, if you really don't want to handle error, use `unwrap()`, but you should probably just handle the error for real. -## Numerics +### Numerics #### Should I default to using `f32` or `f64`? @@ -117,44 +117,45 @@ All things being equal, `f64` is likely a better default. #### Why can't I compare floats? -You can! Floats implement the `PartialOrd` trait, which means that `>`, `<`, `<=`, and `>=` are defined for them. But they do _not_ implement the `Ord` trait, because (thanks to `NaN`) there is no total ordering for floating point numbers. There [is a crate](https://crates.io/crates/ordered-float) that provides a total ordering on floats by wrapping them, which may be desirable depending on your use-case. - -So you can do all the normal comparison operations you would expect, but you can't use the `cmp` function. +You can! Floats implement the `PartialOrd` trait, which means that `>`, `<`, `<=`, and `>=` are defined for them. But they do _not_ implement the `Ord` trait, because (thanks to `NaN`) there is no total ordering for floating point numbers. There [is a crate](https://crates.io/crates/ordered-float) that provides a total ordering on floats by wrapping them, which may be desirable depending on your use-case. You can still do all of the normal comparison operations you would expect, but you can't use the `cmp` function. #### Why can't I use `f32` or `f64` as `HashMap` keys? -In order to be used as a key in a `HashMap`, a type must implement the `Eq` and `Hash` traits. `f32` and `f64` implement `PartialEq`, but not `Eq`, because both types include `NaN` (stands for "not a number"). `NaN` values are not equal to any float, and are not equal to each other, so there is no total ordering over floating point types in Rust. This means that `f32` and `f64` can't be used as keys in a HashMap. +In order to be used as a key in a `HashMap`, a type must implement the `Eq` and `Hash` traits. `f32` and `f64` implement `PartialEq`, but not `Eq`, because both types include `NaN` (stands for "not a number"). `NaN` values are [not equal to any float, and are not equal to each other](https://en.wikipedia.org/wiki/NaN). This means that `f32` and `f64` can't be used as keys in a HashMap. #### How can I convert between numeric types? There are three ways: the `as` keyword, which does simple casting for primitive types, the `Into` and `From` traits, which are implemented for a number of type conversions (and which you can implement for your own types), and `transmute`, which is an unsafe function that tells the compiler to treat the bits of one type as those of another type. -## Syntax +### Syntax #### Why curly braces? Why can't everything be like Haskell/Python? -Flexibility, simplicity, and correctness. Curly braces allow for more flexible syntax for the programmer, a simpler parser in the compiler, and help reduce the possibility of logic mistakes caused by incorrect indentation, like Apple's classic [goto fail](https://gotofail.com/) bug. +Use of curly braces to denote blocks is a common design choice in a variety of programming languages, and Rust's consistency is useful for people already familiar with the style. + +Curly braces also allow for more flexible syntax for the programmer, a simpler parser in the compiler, and help reduce the possibility of logic mistakes caused by incorrect indentation, like Apple's classic [goto fail](https://gotofail.com/) bug. #### I can leave out parentheses on if conditions, why do I have to put brackets around single line blocks? Why is the C style not allowed? -A single line block may not always be a single line block. Forgetting to add in the brackets when you add a line to an `if` block can be the cause of some serious programming errors (just look at Apple's [“goto fail”](https://gotofail.com/) bug). In the interest of safety, Rust makes you use the blocks every time. +Rust does not require parentheses around the conditional for `if`, `else if`, and the like. If C-style bracketless blocks were allowed, there would be no clear delineation between the condition and the body of the block. Requiring braces also eliminates the dangling-else problem, where nested if-else expressions can lead to ambiguity. #### Why is there no literal syntax for dictionaries? -Dictionaries (or `HashMap`s in Rust parlance) aren't a primitive data type, and so they don't get literal syntax. If you want to make a `HashMap`, use `HashMap::new()`. +Dictionaries (or `HashMap`s in Rust parlance) aren't a primitive data type, and so they don't get literal syntax. If you want more convenient syntax for `HashMap` creation, you can [create a macro](http://stackoverflow.com/questions/27582739/how-do-i-create-a-hashmap-literal/27582993#27582993) to provide it. #### When should I use an implicit return? -You should use an implicit return everywhere it can be used. Unless you're writing an early return (before the end of a function, where typing `return` is mandatory), it should be implicit. +Implicit returns are simply a coding style option, and can be used anywhere they make sense. While early returns require an explicit `return`, any other return can be made implicit according to your preferences or the preferences of your project. #### Why aren't function signatures inferred? -- Mechanically, it simplifies the inference algorithm; inference only requires looking at one function at a time. -- The same simplification goes double for human readers. A reader does not need an IDE running an inference algorithm across an entire crate to be able to guess at a function's argument types; it's always explicit and nearby. +- Mechanically, it simplifies the inference algorithm, as inference only requires looking at one function at a time. +- Mandatory function signatures help enforce interface stability at both the module and crate level. +- It improves code comprehension for programmer, eliminating the need for an IDE running an inference algorithm across an entire crate to be able to guess at a function's argument types; it's always explicit and nearby. #### Why does `match` have to be exhaustive? -`match` being exhaustive has some useful properties. First, if every possibility is covered by the `match`, adding further variants to the `enum` in the future will cause a compilation failure, rather than an error at runtime. Second, it makes cost explicit. In general, the only safe way to have a non-exhaustive `match` would be to panic the thread if nothing is matched, though it could fall through if the type of the `match` expression is `()`. This sort of hidden cost and special casing is against the language's philosophy. It's easy to ignore all unspecified cases by using the `_` wildcard: +`match` being exhaustive has some useful properties. First, if every possibility is covered by the `match`, adding further variants to an `enum` in the future will cause a compilation failure, rather than an error at runtime. Second, it makes cost explicit. In general, the only safe way to have a non-exhaustive `match` would be to panic the thread if nothing is matched, though it could fall through if the type of the `match` expression is `()`. This sort of hidden cost and special casing is against the language's philosophy. It is easy to ignore all unspecified cases by using the `_` wildcard: ```rust match val.do_something() { @@ -163,11 +164,11 @@ match val.do_something() { } ``` -## Lifetimes +### Lifetimes #### Why lifetimes? -Lifetimes are Rust's answer to garbage collection. They are a way of ensuring memory safety without paying hefty performance costs. They are based on a variety of academic work, which can be found in the [Rust book](https://doc.rust-lang.org/stable/book/academic-research.html#type-system). +Lifetimes are Rust's answer to the question of memory safety. They allow Rust to ensure memory safety without mechanisms like garbage collection which carry hefty performance costs. They are based on a variety of academic work, which can be found in the [Rust book](https://doc.rust-lang.org/stable/book/academic-research.html#type-system). #### Why is the lifetime syntax the way it is? @@ -181,7 +182,7 @@ This is covered in the [official documentation for `Rc`](https://doc.rust-lang.o You need to ensure that the borrowed item will outlive the function. This can be done in two ways: by binding the output lifetime to some input lifetime, or by declaring the output lifetime as static. The first option is significantly better than the second. -Here is an example of the each: +Here is an example of each: ```rust // The first method @@ -203,11 +204,11 @@ There is also the `Cow` ("copy on write") type, which will only do the extra all #### How do I return a closure from a function? -To return a closure from a function, it must be what's called a "move closure", meaning that the closure is declared with the `move` keyword. As [explained in the Rust book](https://doc.rust-lang.org/book/closures.html#move-closures), this gives the closure its own stack frame, so it is not dependent on its parent stack frame. Otherwise, returning a closure would be unsafe, as it would allow access to variables that are no longer defined (put another way, it would allow reading potentially invalid memory). The closure must also be wrapped in a `Box`, so that it is allocated on the heap. Read more about this [in the book](https://doc.rust-lang.org/book/closures.html#returning-closures). +To return a closure from a function, it must be a "move closure", meaning that the closure is declared with the `move` keyword. As [explained in the Rust book](https://doc.rust-lang.org/book/closures.html#move-closures), this gives the closure its own copy of the captured variables, independent of its parent stack frame. Otherwise, returning a closure would be unsafe, as it would allow access to variables that are no longer valid (put another way, it would allow reading potentially invalid memory). The closure must also be wrapped in a `Box`, so that it is allocated on the heap. Read more about this [in the book](https://doc.rust-lang.org/book/closures.html#returning-closures). #### When are lifetimes required to be defined? -Lifetimes can often be elided, as explained in the ["Lifetime elision" section](https://doc.rust-lang.org/book/lifetimes.html#lifetime-elision) of the Rust book. "Elided lifetimes" are those lifetimes with are implicit in any code containing references. They are automatically inserted by the compiler with the three following rules: +Lifetimes can often be elided, as explained in the ["Lifetime elision" section](https://doc.rust-lang.org/book/lifetimes.html#lifetime-elision) of the Rust book. "Elided lifetimes" are those lifetimes which are implicit in any code containing references. They are automatically inserted by the compiler with the three following rules: - Each elided lifetime in a function’s arguments becomes a distinct lifetime parameter. - If there is exactly one input lifetime, elided or not, that lifetime is assigned to all elided lifetimes in the return values of that function. @@ -219,20 +220,21 @@ If these rules would result in incorrect code elsewhere, then the Rust compiler Data values in the language can only be constructed through a fixed set of initializer forms. Each of those forms requires that its inputs already be initialized. A liveness analysis ensures that local variables are initialized before use. -## Ownership +### Ownership #### How can I implement a graph or other data structure that contains cycles? -There are two major options: +There are three major options: - You can implement it using `Weak` or `Rc` to allow shared ownership of nodes, although this approach pays the cost of memory management. - You can implement it using `unsafe` code using raw pointers. This will be more efficient, but bypasses Rust's safety guarantees. +- Using vectors and indices into those vectors. There are [several](http://smallcultfollowing.com/babysteps/blog/2015/04/06/modeling-graphs-in-rust-using-vector-indices/) [available](http://featherweightmusings.blogspot.com/2015/04/graphs-in-rust.html) examples and explanations of this approach. #### How can I define a struct that contains a pointer to one of its own fields? -You can, but it's useless to do so. The struct becomes permanently borrowed by itself and therefore can't be moved. Here is some code illustrating this: +It's possible, but useless to do so. The struct becomes permanently borrowed by itself and therefore can't be moved. Here is some code illustrating this: ```rust use std::cell::Cell; @@ -254,15 +256,15 @@ fn main() { #### What does it mean to "consume a value"? -"Consuming a value" means taking ownership of a value and then dropping it. When this is done, the value can't be used elsewhere. +"Consuming a value" means taking ownership of a value. When this is done, the value can't be used elsewhere. #### What is the difference between consuming and moving/taking ownership? These are different terms for the same thing. In both cases, it means the value has been moved into a function, and moved out of the calling owner. -#### Why when I pass a struct to a function the compiler says it's been moved and I can't use it anymore, when the same doesn't happen for integers? +#### Why can I use integers after passing them to a function, but not structs? -If a type implements the `Copy` trait, then it will be copied when passed to a function. All numeric types in Rust implement `Copy`, but function types do not, so they are moved instead. This means that the function can no longer be used elsewhere, unless it is moved back out of the function via the return. +If a type implements the `Copy` trait, then it will be copied when passed to a function. All numeric types in Rust implement `Copy`, but struct types do not implement `Copy` by default, so they are moved instead. This means that the struct can no longer be used elsewhere, unless it is moved back out of the function via the return. #### How do you deal with a "Use of moved value" error? @@ -270,7 +272,9 @@ This error means that the value you're trying to use has been moved to a new own #### What are the rules for using `self`, `&self`, or `&mut self` in a method declaration? -If a method needs to consume the struct, declare it with `self` as the first parameter, if it only needs a reference use `&self`, and if it needs to mutate the struct without consuming it use `&mut self`. +- Use `self` when a function needs to consume the type +- Use `&self` when a function only needs a reference to the type +- Use `&mut self` when a function needs to mutate the type without consuming it #### How can I understand the borrow checker? @@ -281,7 +285,7 @@ There is a certain desire to act as if the borrow checker is some mysterious zen > - one or more references (&T) to a resource. > - exactly one mutable reference (&mut T) -Understanding these rules and understanding [lifetimes](https://doc.rust-lang.org/stable/book/lifetimes.html) is all you need to do to understand the borrow checker. +Understanding these rules and [lifetimes](https://doc.rust-lang.org/stable/book/lifetimes.html) is all you need to do to understand the borrow checker. #### How do deref coercions work? @@ -298,19 +302,19 @@ A Deref implementation indicates that the implementing type may be converted int You can see a [full list of `Deref` implementations](https://doc.rust-lang.org/stable/std/ops/trait.Deref.html#implementors) for the standard library in the documentation. -## Stability +### Stability #### Can I use unstable features in the beta or stable channel? No, you cannot. Rust works hard to provide strong guarantees about the stability of the APIs provided on the beta and stable channels. When something is unstable, it means that we can't provide those guarantees for it yet, and don't want people relying on it staying the same. This gives us the opportunity to try changes in the wild on the nightly channel, while still maintaining strong guarantees for people seeking stability. -Things stabilize all the time, and the beta and stable channels update every six weeks, so if you're waiting for a feature to be available without using the nightly channel, it should hopefully happen quickly. +Things stabilize all the time, and the beta and stable channels update every six weeks. If you're waiting for a feature to be available without using the nightly channel, it should hopefully be available soon. -## Strings +### Strings #### How can I convert a `String` or `Vec` to a slice (`&str` and `&[T]`)? -Using Deref coercions `Strings` and `Vec`s will automatically coerce to their respective slices when passed by reference with `&` or `& mut`. +Using Deref coercions, `Strings` and `Vec`s will automatically coerce to their respective slices when passed by reference with `&` or `& mut`. #### How can I convert from `&str` to `String` or the other way around? @@ -351,13 +355,13 @@ let v: Vec<&str> = s.lines().collect(); #### What are the differences between the different string types? -`String` is an owned string type, while `&str` is a string slice. For a more detailed explanation, [check out the Rust book](https://doc.rust-lang.org/stable/book/). +`String` is an owned string type, while `&str` is a string slice. For a more detailed explanation, [check out the Rust book](https://doc.rust-lang.org/stable/book/strings.html). #### How do I do O(1) character access in a `String`? -`str` implements both the `Index` and `IndexMut` traits, but because Rust strings are all UTF-8, and so it can be indexed exactly as you would expect. But if you do that, it comes with some serious caveats. Strings in Rust are all UTF-8 encoded, and O(1) access to characters is impossible in UTF-8. If you index by bytes as you normally would in ASCII strings you'll get a UTF-8 codepoint, which may or may not be an actual character. If you try to index a location that is not a valid UTF-8 boundary, the operation with panic, which makes it doubly unlikely that indexing is what you're looking for. +Rust strings are UTF-8 encoded, and so one visual "character" may in fact be composed of multiple bytes of "code points." Rust provides several `String` methods which provide iterators over characters (`String::chars()`), bytes (`String::bytes()`), lines (`String::lines()`), and others which should perform as expected in O(n) time instead. -If you are absolutely certain your string is in fact ASCII, you can get O(1) access by indexing the underlying buffer like so: +If you are absolutely certain your string is in fact ASCII (and that each visual character is therefore one byte in size), you can get O(1) access by indexing the underlying buffer like so: ```rust let s = "This is a test."; @@ -365,8 +369,6 @@ let bytes = s.into_bytes(); let c = bytes[2]; // 'i' character ``` -But remember that this operation is almost certainly wrong most of the time. - #### Why are strings UTF-8 by default? The `str` type is UTF-8 because we observe more text in the wild in this encoding – particularly in network transmissions, which are endian-agnostic – and we think it's best that the default treatment of I/O not involve having to recode codepoints in each direction. @@ -375,15 +377,15 @@ This does mean that indexed access to a Unicode codepoint inside a `str` value i Scanning a `str` for ASCII-range codepoints can still be done safely octet-at-a-time. If you use `.as_bytes()`, pulling out a `u8` costs only `O(1)` and produces a value that can be cast and compared to an ASCII-range `char`. So if you're (say) line-breaking on `'\n'`, octet-based treatment still works. UTF8 was well-designed this way. -Most "character oriented" operations on text only work under very restricted language assumptions sets such as "ASCII-range codepoints only". Outside ASCII-range, you tend to have to use a complex (non-constant-time) algorithm for determining linguistic-unit (glyph, word, paragraph) boundaries anyways. We recommend using an "honest" linguistically-aware, Unicode-approved algorithm. +Most "character oriented" operations on text only work under very restricted language assumptions such as "ASCII-range codepoints only". Outside ASCII-range, you tend to have to use a complex (non-constant-time) algorithm for determining linguistic-unit (glyph, word, paragraph) boundaries anyway. We recommend using an "honest" linguistically-aware, Unicode-approved algorithm. -The `char` type is UTF32. If you honestly need to do a codepoint-at-a-time algorithm, it's trivial to write a `type wstr = [char]`, and unpack a `str` into it in a single pass, then work with the `wstr`. In other words: the fact that the language is not "decoding to UTF32 by default" shouldn't stop you from decoding (or re-encoding any other way) if you need to work with that encoding. +The `char` type is UTF32. If you are sure you need to do a codepoint-at-a-time algorithm, it's trivial to write a `type wstr = [char]`, and unpack a `str` into it in a single pass, then work with the `wstr`. In other words: the fact that the language is not "decoding to UTF32 by default" shouldn't stop you from decoding (or re-encoding any other way) if you need to work with that encoding. -## Collections +### Collections #### Can I implement data structures like vectors and linked lists efficiently in Rust? -If your reason for implementing these data structures is to use them for other programs, there's no need, as all the common data structures are provided with the standard library. +If your reason for implementing these data structures is to use them for other programs, there's no need, as efficient implementations of these data structures are provided by the standard library. If, however, your reason is simply to learn, then you will likely need to dip into unsafe code. While these data structures _can_ be implemented entirely in safe Rust, the performance is likely to be worse than they would be with the use of unsafe code. The simple reason for this is that data structures like vectors and link lists rely on pointer and memory operations that are disallowed by safe Rust. @@ -391,26 +393,7 @@ For example, a doubly-linked list requires that there be two mutable references #### How can I join a `Vec` (or an array) of strings into a single string? -Whether the strings are owned strings (`String`) or string slices (`&str`), you can accomplish this with a fold, like so: - -```rust -fn main() { - // For vector of `&str` - let v1 = vec!["This ", "is ", "a ", "sentence."]; - let s1 = v1.iter.fold(String::new(), |acc, s| acc.push_str(s)); - println!("{}", s1); // >> This is a sentence. - - // For vector of `String` - let v2 = vec![ - "This ".to_owned(), - "is ".to_owned(), - "another ".to_owned(), - "sentence.".to_owned() - ]; - let s2 = v2.iter.fold(String::new(), |acc, &s| acc.push_str(s)); - println!("{}", s2); // >> This is another sentence. -} -``` +You can do this using the [`join()`](http://doc.rust-lang.org/std/slice/trait.SliceConcatExt.html#tymethod.join) and [`concat()`](http://doc.rust-lang.org/std/slice/trait.SliceConcatExt.html#tymethod.concat) iterator methods. These allow the concatenation of items being iterated over, with `join()` inserting a separator of your choosing. #### How can I iterate over a `Vec` without moving/consuming it? @@ -426,21 +409,13 @@ println!("\nLength: {}", v.len()); The way Rust `for` loops work, they actually call `into_iter()` (which is defined in the `IntoIterator` trait) for whatever you are trying to iterate over. `IntoIterator` is implemented for `&'a Vec` and `&'a mut Vec`, meaning you can iterate over a vector without consuming it just be using `&v` or `&mut v` (for some vector `v`). -#### How do you write a linked list in Rust? - -You probably don't need to. The Rust standard library provides a doubly-linked list for free. But if you're looking to do it just for personal edification, there are three ways of doing it: - -- Write it as a classic algebraic data-type (also called a "cons list"). This is easiest, but the performance characteristics aren't good at all -- Write it using `Weak` or `Rc` to allow shared ownership of nodes. This can work, but is also a pain. If you're using `Rc`, you need some way to break cycles, otherwise no memory will ever be freed. -- Use `unsafe`. This is the most performant, but also the toughest, because you can't rely on Rust's safety guarantees. - #### Why do I need to type the array size in the array declaration? You don't necessarily have to. If you're declaring an array directly, the size is inferred based on the number of elements. But if you're declaring a function that takes an array, the compiler has to know how big that array will be. -One thing to note is that currently Rust doesn't offer generics over arrays of different size. This is being worked on, but isn't available currently. If you'd like to accept a contiguous container of a variable number of values, use a Vec or slice (depending on whether you need ownership). +One thing to note is that currently Rust doesn't offer generics over arrays of different size. This is a planned feature, but isn't available currently. If you'd like to accept a contiguous container of a variable number of values, use a Vec or slice (depending on whether you need ownership). -## Documentation +### Documentation #### Where do I report issues in the Rust documentation? @@ -450,23 +425,33 @@ You can report issues in the Rust documentation on the Rust compiler [issue trac When you use `cargo doc` to generate documentation for your own project, it also generates docs for the active dependency versions. These are put into the `target/doc` directory of your project. Use `cargo doc --open` to open the docs after building them, or just open up `target/doc/index.html` yourself after building the docs. -## Input / Output +### Input / Output #### How do I read a file into a `String`? Using the `read_to_string()` method, which is defined on the `Read` trait in `std::io`. ```rust -fn main() { - let mut f = try!(File::open("foo.txt")); +fn read_file(path: &str) -> Result { + let mut f = try!(File::open(path)); let mut s = String::new(); try!(f.read_to_string(&mut s)); // `s` contains the contents of "foo.txt" + s +} + +fn main() { + match read_file("foo.txt") { + Ok(_) => println!("Got file contents!"), + Err(err) => println!("Getting file contents failed with error: {}", err) + }; } ``` #### How do I read file input efficiently? -The [`File` type](https://doc.rust-lang.org/stable/std/fs/struct.File.html) implements the `Read` trait, which has a variety of functions for reading and writing data, including `read()`, `read_to_end()`, `bytes()`, `chars()`, and `take()`. Each of these functions reads in a certain amount of input from a given file. `read()` reads input until the provided buffer is full. `read_to_end()` reads the entire buffer into a vector, allocating as much space as is needed. `bytes()` and `chars()` allow you to iterate over the bytes and characters of the file, respectively. Finally, `take()` allows you to read up to an arbitrary number of bytes from the file. Collectively, these should allow you to efficiently read in any data you need. +The [`File` type](https://doc.rust-lang.org/stable/std/fs/struct.File.html) implements the `Read` trait, which has a variety of functions for reading and writing data, including `read()`, `read_to_end()`, `bytes()`, `chars()`, and `take()`. Each of these functions reads in a certain amount of input from a given file. `read()` reads as much input as the underlying system will provide in a single call. `read_to_end()` reads the entire buffer into a vector, allocating as much space as is needed. `bytes()` and `chars()` allow you to iterate over the bytes and characters of the file, respectively. Finally, `take()` allows you to read up to an arbitrary number of bytes from the file. Collectively, these should allow you to efficiently read in any data you need. + +For buffered reads, use the [`BufReader`](http://doc.rust-lang.org/stable/std/io/struct.BufReader.html) struct, which helps to reduce the number of system calls when reading. #### How do I get command line arguments in Rust? @@ -474,11 +459,13 @@ The easiest way is to use `std::env::Args`, which provides an iterator over the If you're looking for something more powerful, the [getopt](https://doc.rust-lang.org/getopts/getopts/index.html) and [docopt](https://github.com/docopt/docopt.rs) crates are both solid options. -## Libraries +If you're looking for something more powerful, there are a [number of options on crates.io](https://crates.io/keywords/argument). + +### Libraries #### How can I make an HTTP request? -[Hyper](https://github.com/hyperium/hyper) is the most popular, but there are [a number of others as well](https://crates.io/search?q=http). +[Hyper](https://github.com/hyperium/hyper) is the most popular, but there are [a number of others as well](https://crates.io/keywords/http). #### How can I write a GUI application in Rust? @@ -500,7 +487,7 @@ Not yet! Want to write one? Yes you can! The major game programming library for Rust is [Piston](http://www.piston.rs/), and there's a whole [community for game programming in Rust](https://www.reddit.com/r/rust_gamedev/) as well. -## Project +### Project #### What is this project's goal? @@ -782,7 +769,7 @@ The following operators can be overloaded: There are some types in Rust that have a partial ordering, or partial equality, but no total ordering or total equality. The floating point types `f32` and `f64` are examples of this. Because a floating point value may be `NaN`, and because `NaN`s aren't equal to any other floating point type, nor less than or greater to any other floating point type, nor equal to each other, these types _can't_ implement `Eq` and `Ord`, although they _can_ implement `PartialEq` and `PartialOrd`. -## Debugging +### Debugging #### How do I debug Rust programs? @@ -792,7 +779,7 @@ Rust programs can be debugged using gdb or lldb, same as C and C++. In fact, eve This error is usually caused by `unwrap()`ing a `None` or `Err`. Enabling backtraces by setting the environment variable `RUST_BACKTRACE=1` helps with getting more information. Compiling in debug mode (the default for `cargo build` is also helpful). Using a debugger like the provided `rust-gdb` or `rust-lldb` is also helpful. -## Low-Level +### Low-Level #### How do I `memcpy` bytes? @@ -825,7 +812,7 @@ enum CLike { The `repr` attribute can be applied to such `enums` to give them the same representation as a primitive. This allows using Rust `enum`s in FFI where C `enum`s are also used, for most use cases. The attribute can also be applied to `struct`s to get the same layout as a C `struct` would. -## Cross-Platform +### Cross-Platform +#### How can I read or write numeric types like `i32` or `f64` in big-endian or little-endian format in a file or other byte stream? -#### How can I try Rust easily? +You should check out the [byteorder crate](http://burntsushi.net/rustdoc/byteorder/), which provides utilities for exactly that. -The easiest way to try Rust is through the [Playground](https://play.rust-lang.org/), an online app for writing and running Rust code. If you want to try it on your system, [install it](https://www.rust-lang.org/install.html) and go through the ["Learn Rust"](https://doc.rust-lang.org/stable/book/learn-rust.html) section of the book. +#### Does Rust specify data layout? -#### How do I get help with Rust issues? +No. In the general case, `enum` and `struct` layout is undefined. This allows the compiler to potentially do optimizations like re-using padding for the discriminant, compacting variants of nested `enum`s, reordering fields to remove padding, etc. `enums` which carry no data ("C-like") are eligible to have a defined representation. Such `enums` are easily distinguished in that they are simply a list of names that carry no data: -There are several ways. You can: +```rust +enum CLike { + A, + B = 32, + C = 34, + D +} +``` -- Post in [users.rust-lang.org](https://users.rust-lang.org/), the official Rust forum -- Ask in the official [Rust IRC channel](https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust) (#rust on irc.mozilla.org) -- Ask on [StackOverflow](http://stackoverflow.com/questions/tagged/rust) with the "rust" tag -- Post in [/r/rust](https://www.reddit.com/r/rust), the official Rust subreddit +The `repr` attribute can be applied to such `enums` to give them the same representation as a primitive. This allows using Rust `enum`s in FFI where C `enum`s are also used, for most use cases. The attribute can also be applied to `struct`s to get the same layout as a C `struct` would. -#### Why has Rust changed so much over time? +

Cross-Platform

-Rust started with a goal of creating a safe but usable systems programming language. In pursuit of this goal it explored a lot of ideas, some of which it kept (lifetimes, traits) while others were discarded (the typestate system). Also, in the run up to 1.0 a lot of the standard library was rewritten. Some of this was out of a desire to improve the old versions of the APIs. Some of it was out of a desire for improved Windows support. + -Rust maintains three "channels": stable, beta, and nightly. Stable and beta are updated every six weeks, with the current nightly becoming the new beta, and the current beta becoming the new stable. Language and standard library features marked unstable or hidden behind feature gates may only be used on the nightly channel. + -- Fixing compiler bugs -- Patching safety holes -- Changing type inference to require new annotations +#### What's the idiomatic way to express platform-specific behavior in Rust? -For details, read the Rust blog post ["Stability as a Deliverable."](http://blog.rust-lang.org/2014/10/30/Stability.html) +Platform-specific behavior can be expressed using [conditional compilation attributes](https://doc.rust-lang.org/reference.html#conditional-compilation) such as `target_os`, `target_family`, `target_endian`, etc. -#### What IDE should I use? +#### Can Rust be used for Android/iOS programming? -There are a couple developing options: [RustDT](https://github.com/RustDT/RustDT) is a Rust plugin for Eclipse, while [SolidOak](https://github.com/oakes/SolidOak) is a from-scratch Rust IDE. Both are solid options for a Rust IDE. Rust also integrates well with a variety of text editors. Detailed information about both text editor and IDE support can be found at [areweideyet.com](http://areweideyet.com/). +Yes it can! There are already examples of using Rust for both [Android](https://github.com/tomaka/android-rs-glue) and [iOS](https://www.bignerdranch.com/blog/building-an-ios-app-in-rust-part-1/). It does require a bit of work to set up, but Rust functions fine on both platforms. -## Modules and Crates +#### Can I run my Rust program in a web browser? + +There [are efforts](https://www.bignerdranch.com/blog/building-an-ios-app-in-rust-part-1/) to make Rust run in the web browser using Emscripten. Given that Rust is implemented on top of LLVM, this should be possible, but Rust currently runs on a special patched version of LLVM, and so it is tougher than it would otherwise be. This will likely improve over time. + +#### How do I cross-compile in Rust? + +Cross compilation is possible in Rust, but it requires [a bit of work](https://github.com/japaric/ruststrap/blob/master/1-how-to-cross-compile.md) to set up. Rust does distribute [copies of the standard library](http://static.rust-lang.org/dist/) for each of the supported platforms, which are contained in the `rust-std-*` files for each of the build directories found on the distribution page. + +

Modules and Crates

#### What is the relationship between a module and a crate? @@ -668,196 +744,33 @@ The Rust language has been around for a number of years, and only reached versio Over time more and more answers will be offered for the current version, this improving this issue as the proportion of out-of-date answers is reduced. -## Generics - -#### What is "monomorphisation"? - -Monomorphisation is the process by which Rust generates specific instances of a generic function based on the types of the various calls to that function. This is used to provide static dispatch for generic functions. For functions using trait objects for generics, dynamic dispatch is used instead, with calls to the function going through a vtable to identify specific function calls for the provided type implementing the given trait. - -In C++ people would likely know this as "template instantiation." But unlike C++, Rust's monomorphisation is an implementation detail, and not a language feature. - -#### What's the difference between a function and a closure that doesn't capture any variables? - -Functions are a built-in primitive of the language, while closures are essentially syntactic sugar for one of three traits: `Fn`, `FnMut`, and `FnOnce`. When you make a closure, the Rust compiler automatically creates a struct implementing the appropriate trait of those three and containing the captured environment variables as members, and makes it so the the struct can be called as a function. - -The big difference between these traits is how they take the `self` parameter. `Fn` takes `&self`, `FnMut` takes `&mut self`, and `FnOnce` takes `self`. - -#### What are higher-kinded types, why would I want them, and why doesn't Rust have them? - -Let's go through these one by one: - -First, higher-kinded types are types that take other types as parameters. Type constructors, like `Vec` are examples. What support for higher-kinded types means is that you can use these type constructors wherever you can use types, such as in a trait `impl`. - -Next, the lack of higher-kinded types makes expression of certain ideas far more tedious than it would otherwise be. For example, implementing a `Functor` trait (a math-y term for something which can be mapped over, obeying certain rules) without higher-kinded types is a pain. With higher-kinded types, it's as simple as (note: theoretical syntax, this does not actually work, and has no guarantee to be how higher-kinded types look when and if they're implemented): - -```rust -trait Functor { - fn fmap B>(&self, f: F) -> Self; -} -``` - -The part that Rust currently can't do is that `Self` above is a type constructor parameterized by another type constructor. This is what support for higher-kinded types lets you express. - -Finally, Rust doesn't currently have them simply because they haven't been a priority. There is nothing inherent to the language that stops us from implementing higher-kinded types, it just hasn't been done yet. There is an open RFC for implementing them, but no real proposal exists yet. If one comes around, it will definitely be considered. +

Libraries

-(Credit to anasaziwochi for his [useful explanation](https://www.reddit.com/r/rust/comments/2av5tv/why_does_rust_not_have_a_functor_trait/ciz6iwm) of higher-kinded types in Rust.) - -#### What do named type parameters in generic types mean? - -These are called [associated types](https://doc.rust-lang.org/stable/book/associated-types.html), and they allow for the expression of trait bounds that can't be expressed with a simple `where` clause. In essence, for a generic type with some type parameters, it is often unecessary to include those type parameters in a function taking that generic type as a parameter. The function shouldn't have to care about being generic over the types which make up the generic type (say, the node and edge types in a graph), but only about being generic over the type itself. - -#### Does Rust have type reflection? - -Rust does have limited type reflection through the `Reflect` and `Any` traits. `Reflect` is a marker trait (meaning it has no functions associated with it) that indicates a function expects a type which can be reflected over. It is implemented for all types. `Any` is automatically implemented for any type that is both `Reflect` and `'static`, and is used for basic dynamic typing, as in the following example, which implements a map indexed on the type of the mapped-to value: - -```rust -use std::any::{Any, TypeId}; -use std::collections::HashMap; - -type Entry = Box; - -#[derive(Debug)] -struct AnyMap(HashMap); - -impl AnyMap { - fn new() -> Self { - AnyMap(HashMap::new()) - } - - fn insert(&mut self, val: T) -> Option{ - self.0.insert(TypeId::of::(), Box::new(val) as Entry) - } - - fn get(&self) -> Option<&T> { - self.0.get(&TypeId::of::()).unwrap().downcast_ref() - } -} - -fn main() { - let mut map = AnyMap::new(); - map.insert(123i32); - map.insert(456i64); - - println!("{:?}", map); - println!("{:?}", map.get::()); -} -``` - -#### Can I override operators? Which ones and how? - -You can provide custom implementations for a variety of operators using their associated traits: `Add` for `+`, `Mult` for `*`. It looks like this: - -```rust -struct Foo; - -impl Add for Foo { - type Output = Foo; - fn add(self, rhs: Foo) -> Self::Output { - println!("Adding!"); - self - } -} -``` - -The following operators can be overloaded: - -| Operation | Trait | -|:--------------------|:-----------| -| `+` | `Add` | -| `binary -` | `Sub` | -| `*` | `Mul` | -| `/` | `Div` | -| `unary -` | `Neg` | -| `%` | `Rem` | -| `&` | `BitAnd` | -| | | `BitOr` | -| `^` | `BitXor` | -| `!` | `Not` | -| `<<` | `Shl` | -| `>>` | `Shr` | -| `*` | `Deref` | -| `mut *` | `DerefMut` | -| `[]` | `Index` | -| `mut []` | `IndexMut` | - -#### Why the split between `Eq`/`PartialEq` and `Ord`/`PartialOrd`? - -There are some types in Rust that have a partial ordering, or partial equality, but no total ordering or total equality. The floating point types `f32` and `f64` are examples of this. Because a floating point value may be `NaN`, and because `NaN`s aren't equal to any other floating point type, nor less than or greater to any other floating point type, nor equal to each other, these types _can't_ implement `Eq` and `Ord`, although they _can_ implement `PartialEq` and `PartialOrd`. - -### Debugging - -#### How do I debug Rust programs? - -Rust programs can be debugged using gdb or lldb, same as C and C++. In fact, every Rust installation comes with rust-gdb and rust-lldb, wrappers over gdb and lldb with Rust pretty-printing enabled. - -#### `rustc` said a panic occurred in standard library code. How do I locate the mistake in my code? - -This error is usually caused by `unwrap()`ing a `None` or `Err`. Enabling backtraces by setting the environment variable `RUST_BACKTRACE=1` helps with getting more information. Compiling in debug mode (the default for `cargo build` is also helpful). Using a debugger like the provided `rust-gdb` or `rust-lldb` is also helpful. - -### Low-Level - -#### How do I `memcpy` bytes? - -To copy potentially overlapping bytes, use `std::ptr::copy`. To copy nonoverlapping bytes, use `std::ptr::cpy_nonoverlapping`. Both of these functions are `unsafe`, as both can be used to subvert the language's safety guarantees. Use caution when using them. - -#### Can Rust reasonably function without the standard library? - -Absolutely. Rust programs can be set to not load the standard library using the `#![no_std]` attribute. With this attribute set, you can continue to use the Rust core, which is nothing but the platform-agnostic primitives. As such, it doesn't include IO, concurrency, heap allocation, etc. Note however that `libcore` has not been stabilized. - -#### Can I write an operating system in Rust? - -Yes! In fact there are several projects underway doing just that, including [reenix](https://github.com/scialex/reenix), [RustOS](https://github.com/ryanra/RustOS), and [redox](http://www.redox-os.org/). - -#### How can I read or write numeric types like `i32` or `f64` in big-endian or little-endian format in a file or other byte stream? - -You should check out the [byteorder crate](http://burntsushi.net/rustdoc/byteorder/), which provides utilities for exactly that. - -#### Does Rust specify data layout? - -No. In the general case, `enum` and `struct` layout is undefined. This allows the compiler to potentially do optimizations like re-using padding for the discriminant, compacting variants of nested `enum`s, reordering fields to remove padding, etc. `enums` which carry no data ("C-like") are eligible to have a defined representation. Such `enums` are easily distinguished in that they are simply a list of names that carry no data: - -```rust -enum CLike { - A, - B = 32, - C = 34, - D -} -``` - -The `repr` attribute can be applied to such `enums` to give them the same representation as a primitive. This allows using Rust `enum`s in FFI where C `enum`s are also used, for most use cases. The attribute can also be applied to `struct`s to get the same layout as a C `struct` would. - -### Cross-Platform - - +[Hyper](https://github.com/hyperium/hyper) is the most popular, but there are [a number of others as well](https://crates.io/keywords/http). - +There are a variety of ways to write GUI applications in Rust. Just check out [this list of GUI frameworks](https://github.com/kud1ing/awesome-rust#gui). -#### What's the idiomatic way to express platform-specific behavior in Rust? +#### How can I parse JSON/XML? -Platform-specific behavior can be expressed using [conditional compilation attributes](https://doc.rust-lang.org/reference.html#conditional-compilation) such as `target_os`, `target_family`, `target_endian`, etc. +[Serde](https://github.com/serde-rs/serde) is the recommended library for serialization and deserialization of Rust data to and from a number of different formats. -#### Can Rust be used for Android/iOS programming? +#### Is there a standard 2D+ dimensional vector and shape crate? -Yes it can! There are already examples of using Rust for both [Android](https://github.com/tomaka/android-rs-glue) and [iOS](https://www.bignerdranch.com/blog/building-an-ios-app-in-rust-part-1/). It does require a bit of work to set up, but Rust functions fine on both platforms. +Not yet! Want to write one? -#### Can I run my Rust program in a web browser? +#### How do I write an OpenGL app in Rust? -There [are efforts](https://www.bignerdranch.com/blog/building-an-ios-app-in-rust-part-1/) to make Rust run in the web browser using Emscripten. Given that Rust is implemented on top of LLVM, this should be possible, but Rust currently runs on a special patched version of LLVM, and so it is tougher than it would otherwise be. This will likely improve over time. +[Glium](https://github.com/tomaka/glium) is the major library for OpenGL programming in Rust. [GLFW](https://github.com/bjz/glfw-rs) is also a solid option. -#### How do I cross-compile in Rust? +#### Can I write a video game in Rust? -Cross compilation is possible in Rust, but it requires [a bit of work](https://github.com/japaric/ruststrap/blob/master/1-how-to-cross-compile.md) to set up. Rust does distribute [copies of the standard library](http://static.rust-lang.org/dist/) for each of the supported platforms, which are contained in the `rust-std-*` files for each of the build directories found on the distribution page. +Yes you can! The major game programming library for Rust is [Piston](http://www.piston.rs/), and there's both a [subreddit for game programming in Rust](https://www.reddit.com/r/rust_gamedev/) and an IRC channel (`#rust-gamedev` on [Mozilla IRC](https://wiki.mozilla.org/IRC)) as well. -### Design Patterns +

Design Patterns

#### Is Rust object oriented? @@ -905,13 +818,7 @@ See the [C++ FQA](http://yosefk.com/c++fqa/ctors.html#fqa-10.12) about the "stat However, `thread_local!` variables (which are restricted to a single thread) are effectively global for the thread in which they are defined, and may have a non-constant constructor and destructor. -## Macros - -#### Can I write a macro to generate identifiers? - -Not currently. Rust macros are so-called hygienic macros, not the unlimited compile-time syntax editing you see in C. Macro invocations can only appear in places where they are explicitly supported: items, methods declarations, statements, expressions, and patterns. Here, "method declarations" means a blank space where a method can be put. They can't be used to complete a partial method declaration. By the same logic, they can't be used to complete a partial variable declaration. - -### Other Languages +

Other Languages

#### How can I implement something like `struct X { static int X; };` in Rust? @@ -1016,7 +923,94 @@ Rust is probably not the best choice in every situation. If you're considering u Rust traits are similar to Haskell typeclasses, but are currently not as powerful. Rust traits cannot express functional dependencies or type families, nor does Rust have full support for higher-kinded types. Some of these may be added in the future, but are not provided currently. -### Licensing +

Documentation

+ +#### Where do I report issues in the Rust documentation? + +You can report issues in the Rust documentation on the Rust compiler [issue tracker](https://github.com/rust-lang/rust/issues). Make sure to read the [contributing guidelines](https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md) first. + +#### How do I view rustdoc documentation for a library my project depends on? + +When you use `cargo doc` to generate documentation for your own project, it also generates docs for the active dependency versions. These are put into the `target/doc` directory of your project. Use `cargo doc --open` to open the docs after building them, or just open up `target/doc/index.html` yourself after building the docs. + +

Project

+ +#### What is this project's goal? + +To design and implement a safe, concurrent, practical, static systems language. + +Rust exists because other languages at this level of abstraction and efficiency are unsatisfactory. In particular: + +1. There is too little attention paid to safety. +2. They have poor concurrency support. +3. There is a lack of practical affordances. + +Rust exists as alternative language that provides both efficient code and a comfortable level of abstraction, while improving on all three of these points. + +#### Is this project controlled by Mozilla? + +No. Rust started as Graydon Hoare's part-time side project in 2006 and remained so for over 3 years. Mozilla got involved in 2009 once the language was mature enough to run basic tests and demonstrate its core concepts. Though it remains sponsored by Mozilla, Rust is developed by a diverse community of enthusiasts from many different places around the world. The [Rust Team](https://www.rust-lang.org/team.html) is composed of both Mozilla and non-Mozilla members. + +#### What are explicit non-goals of Rust? + +1. To employ any particularly cutting-edge technologies. Old, established techniques are better. +2. To prize expressiveness, minimalism or elegance above other goals. These are desirable but subordinate goals. +3. To cover the complete feature-set of C++, or any other language. It should provide majority-case features. +4. To be 100% static, 100% safe, 100% reflective, or too dogmatic in any other sense. Trade-offs exist. +5. To run on "every possible platform". It must eventually work without unnecessary compromises on widely-used hardware and software platforms. + +#### In which projects is Mozilla using Rust? + +The main project is [Servo](https://github.com/servo/servo), an experimental browser engine Mozilla is working on. They are also working to integrate Rust components into Firefox. + +#### What examples are there of large Rust projects? + +The two biggest open source Rust projects right now are [Servo](https://github.com/servo/servo) and the [Rust compiler](https://github.com/rust-lang/rust) itself. + + + +#### How can I try Rust easily? + +The easiest way to try Rust is through the [Playground](https://play.rust-lang.org/), an online app for writing and running Rust code. If you want to try it on your system, [install it](https://www.rust-lang.org/install.html) and go through the ["Learn Rust"](https://doc.rust-lang.org/stable/book/learn-rust.html) section of the book. + +#### How do I get help with Rust issues? + +There are several ways. You can: + +- Post in [users.rust-lang.org](https://users.rust-lang.org/), the official Rust forum +- Ask in the official [Rust IRC channel](https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust) (#rust on irc.mozilla.org) +- Ask on [StackOverflow](http://stackoverflow.com/questions/tagged/rust) with the "rust" tag +- Post in [/r/rust](https://www.reddit.com/r/rust), the official Rust subreddit + +#### Why has Rust changed so much over time? + +Rust started with a goal of creating a safe but usable systems programming language. In pursuit of this goal it explored a lot of ideas, some of which it kept (lifetimes, traits) while others were discarded (the typestate system). Also, in the run up to 1.0 a lot of the standard library was rewritten. Some of this was out of a desire to improve the old versions of the APIs. Some of it was out of a desire for improved Windows support. + +#### How does Rust language versioning work? + +Rust maintains three "channels": stable, beta, and nightly. Stable and beta are updated every six weeks, with the current nightly becoming the new beta, and the current beta becoming the new stable. Language and standard library features marked unstable or hidden behind feature gates may only be used on the nightly channel. + +Anything marked stable will not change without a major version update with three exceptions: + +- Fixing compiler bugs +- Patching safety holes +- Changing type inference to require new annotations + +For details, read the Rust blog post ["Stability as a Deliverable."](http://blog.rust-lang.org/2014/10/30/Stability.html) + +#### Can I use unstable features in the beta or stable channel? + +No, you cannot. Rust works hard to provide strong guarantees about the stability of the APIs provided on the beta and stable channels. When something is unstable, it means that we can't provide those guarantees for it yet, and don't want people relying on it staying the same. This gives us the opportunity to try changes in the wild on the nightly channel, while still maintaining strong guarantees for people seeking stability. + +Things stabilize all the time, and the beta and stable channels update every six weeks. If you're waiting for a feature to be available without using the nightly channel, it should hopefully be available soon. + +#### What IDE should I use? + +There are a couple developing options: [RustDT](https://github.com/RustDT/RustDT) is a Rust plugin for Eclipse, while [SolidOak](https://github.com/oakes/SolidOak) is a from-scratch Rust IDE. Both are solid options for a Rust IDE. Rust also integrates well with a variety of text editors. Detailed information about both text editor and IDE support can be found at [areweideyet.com](http://areweideyet.com/). #### Why a dual MIT/ASL2 License? @@ -1026,12 +1020,9 @@ The Apache license includes important protection against patent aggression, but This is partly due to preference of the original developer (Graydon), and partly due to the fact that languages tend to have a wider audience and more diverse set of possible embeddings and end-uses than products such as web browsers. We'd like to appeal to as many of those potential contributors as possible. -### Naming - #### Why is the language called Rust? As [stated by Graydon Hoare](https://www.reddit.com/r/rust/comments/27jvdt/internet_archaeology_the_definitive_endall_source/), original developer of the Rust language, the name "Rust" comes from his personal interest in fungi, and because it evoked the feeling he was looking for in a programming language name. But truly, as Graydon himself put it: > <graydon> IOW I don't have a really good explanation. it seemed like a good name. (also a substring of "trust", "frustrating", "rustic" and ... "thrust"?)
> <graydon> I think I named it after fungi. rusts are amazing creatures. - From 57f72c57d290de64fb6b20913aeabd7b00fa4583 Mon Sep 17 00:00:00 2001 From: Andrew Brinker Date: Wed, 18 Nov 2015 18:07:52 -0500 Subject: [PATCH 19/94] Simplified CSS --- css/style.css | 138 ++++----------------------- faq.md | 260 +++++++++++++++++++++++++------------------------- 2 files changed, 146 insertions(+), 252 deletions(-) diff --git a/css/style.css b/css/style.css index f24379ef8..bfa665f92 100644 --- a/css/style.css +++ b/css/style.css @@ -385,20 +385,12 @@ ul.laundry-list { } .faq { - font-size: 16px; - line-height: 1.5em; border-top: 1px solid #dedede; - margin-top: 2rem; - margin-bottom: 8rem; - padding-top: 4rem; + margin-top: 2em; + margin-bottom: 8em; + padding-top: 4em; } - @media screen and (min-width: 820px) { - .faq { - padding-right: 4rem; - } - } - .faq p, .faq ul, .faq ol, @@ -409,63 +401,21 @@ ul.laundry-list { } @media screen and (min-width: 820px) { + .faq { + padding-right: 6em; + } + .faq p, .faq ul, .faq ol, .faq blockquote, - .faq pre { - margin-left: 6rem; - } - - .faq ul, - .faq ol { - padding: 0; - } - - .faq ul { - counter-reset: uli; - } - - .faq ul > li { - list-style: none; - position: relative; + .faq pre, + .faq h1, + #toc { + margin-left: 8rem; } - - .faq ul > li:before { - content: counter(uli); - counter-increment: uli; - color: #999; - position: absolute; - top: 0; - left: -1.5em; - width: 1em; - font-family: "Fira Sans"; - text-align: right; - } - - .faq ol { - counter-reset: oli; } - .faq ol > li { - list-style: none; - position: relative; - } - - .faq ol > li:before { - content: counter(oli); - counter-increment: oli; - color: #999; - position: absolute; - top: 0; - left: -1.5em; - width: 1em; - font-family: "Fira Sans"; - text-align: right; - } - - } - .faq blockquote { border-left: .25em solid #dedede; padding-left: 2rem; @@ -478,17 +428,12 @@ ul.laundry-list { .faq h1 { font-size: 2.5em; line-height: 1.5em; - margin: 0 0 1rem; + margin-top: 0; + margin-bottom: 1rem; font-weight: 400; position: relative; } - @media screen and (min-width: 820px) { - .faq h1 { - margin-left: 6rem; - } - } - .faq h2 { font-size: 2em; line-height: 1.5em; @@ -498,34 +443,13 @@ ul.laundry-list { padding-top: 1rem; } - .faq h2 a { - color: #333; - text-decoration: none; - } - .faq h3 { - font-size: 1.5em; - line-height: 1.3em; - font-weight: 500; - margin: 3rem 0 1rem; - } - - .faq h2 + h3 { - margin-top: 2rem; - } - - .faq h4 { font-size: 1em; line-height: 1.5em; font-weight: 500; margin: 2rem 0 .25rem; } - .faq li { - margin: 0; - padding: 0; - } - .faq pre { margin-top: 2rem; margin-bottom: 2rem; @@ -534,9 +458,10 @@ ul.laundry-list { .faq code { display: inline-block; padding: .1em .2em 0; - font-size: 0.9em; + font-size: 0.95em; line-height: 1em; background-color: #f7f7f7; + border-radius: 2px; font-weight: 400; font-family: Consolas, "Andale Mono WT", "Andale Mono", "Lucida Console", "Lucida Sans Typewriter", "DejaVu Sans Mono", "Bitstream Vera Sans Mono", "Liberation Mono", "Nimbus Mono L", Monaco, "Courier New", Courier, monospace; } @@ -546,47 +471,16 @@ ul.laundry-list { line-height: 1.5em; } - .faq .copyright { - font-size: .8em; - color: #999; - border-top: 1px solid #dedede; - margin-top: 6rem; - padding-top: 2rem; - } - -#toc { - margin-top: 2rem; - padding: 2rem; - background-color: #f7f7f7; - border-radius: .25em; - border: 1px solid #ccc; -} - #toc h2 { - font-family: "Fira Sans"; border: 0; - margin: 0 -2rem 2rem; - padding: 0 2rem 1rem; font-size: 2rem; line-height: 1.5em; - border-bottom: 1px solid #ccc; } #toc ol { - counter-reset: tos; - margin: 0; + margin: 0 0 0 2rem; padding: 0; -webkit-columns: 150px 3; -moz-columns: 150px 3; columns: 150px 3; } - - #toc li { - margin-left: 1em; - } - - #toc li::before { - content: counter(tos); - counter-increment: tos; - } - diff --git a/faq.md b/faq.md index 81ff3fc4c..01e5cde08 100644 --- a/faq.md +++ b/faq.md @@ -39,75 +39,75 @@ If there is some common or important question you feel is wrongly left unanswere

Performance

-#### How fast is Rust? +### How fast is Rust? Fast! Rust is already competitive with idiomatic C and C++ in a number of benchmarks. It is an explicit goal of Rust to be at least as fast as C++. Language decisions are made with performance in mind, and given that Rust is built on LLVM, any LLVM performance improvements also help Rust. -#### Is Rust garbage collected? +### Is Rust garbage collected? No. A language that requires a GC is a language that opts into a larger, more complex runtime than Rust cares for. Rust is usable on bare metal with no extra runtime. Additionally, garbage collection is frequently a source of non-deterministic behavior. Rust provides the tools to make using a GC [possible and even pleasant](http://manishearth.github.io/blog/2015/09/01/designing-a-gc-in-rust/), but it is not part of the language as provided. -#### Why is my program slow? +### Why is my program slow? If you compiled with Cargo, did you use the `--release` flag? If you compiled with `rustc` directly, did you use the `-O` flag? Either of these will compile with optimizations turned on. The Rust languages uses a lot of optimizations to create efficient machine code, but you need to explicitly ask for them, as they also result in longer compilation times that may be undesirable during development. -#### Why is Rust compilation slow? +### Why is Rust compilation slow? Most of the compilation time is spent in type checking and code translation, with some time also used for safety checks. All of these are required for the strong guarantees Rust makes, but they require some time to run. Add in optimizations, and Rust's compilation is slower than a simpler language that doesn't provide Rust's guarantees. But all is not lost. The Rust compiler has evolved significantly over a number of years, and a lot of good work is being done to make it work faster, and to make it feel faster during development. -#### Why is Rust's HashMap so slow? +### Why is Rust's HashMap so slow? By default, Rust's `HashMap` uses the [SipHash](https://131002.net/siphash/) hashing algorithm, which is designed to prevent [hash table collision attacks](http://programmingisterrible.com/post/40620375793/hash-table-denial-of-service-attacks-revisited) while providing [reasonable performance on a variety of workloads](https://www.reddit.com/r/rust/comments/3hw9zf/rust_hasher_comparisons/cub4oh6). While SipHash [demonstrates competitive performance](http://cglab.ca/%7Eabeinges/blah/hash-rs/) in many cases, one case where it is notably slower than other hashing algorithms is with short keys, such as integers. This is why Rust programmers often observe slow performance with `HashMap`. The [FNV hasher](https://crates.io/crates/fnv) is frequently recommended for these cases, but be aware that it does not have the same collision-resistence properties as SipHash. -#### Why can't I run benchmarks? +### Why can't I run benchmarks? You can run benchmarks, but only on the nightly channel. Rust's benchmarking mechanism is currently unstable, as the API has not been deemed ready for stabilization. This may change in the future, but until then benchmarking can only be used on nightly. -#### Does Rust do tail-call optimization? +### Does Rust do tail-call optimization? In general, tail-call optimization is [not guaranteed](https://mail.mozilla.org/pipermail/rust-dev/2013-April/003557.html), but may be done in [limited circumstances](http://llvm.org/docs/CodeGenerator.html#sibling-call-optimization). There was a [proposed extension](https://github.com/rust-lang/rfcs/pull/81) that would allow tail-call elimination in certain contexts, but it is currently postponed. The compiler is still free to optimize tail-calls [when it pleases](http://llvm.org/docs/CodeGenerator.html#sibling-call-optimization), however, and the language has a word (`become`) reserved for future explicit tail calls. -#### Does Rust have a runtime? +### Does Rust have a runtime? Rust has a [very small and limited runtime](https://doc.rust-lang.org/std/rt/) providing a heap, backtraces, unwinding, and stack guards. This runtime is comparable to the [C runtime](http://www.embecosm.com/appnotes/ean9/html/ch05s02.html), and allows for the calling of Rust functions from C without setup.

Syntax

-#### Why curly braces? Why can't everything be like Haskell/Python? +### Why curly braces? Why can't everything be like Haskell/Python? Use of curly braces to denote blocks is a common design choice in a variety of programming languages, and Rust's consistency is useful for people already familiar with the style. Curly braces also allow for more flexible syntax for the programmer, a simpler parser in the compiler, and help reduce the possibility of logic mistakes caused by incorrect indentation, like Apple's [goto fail](https://gotofail.com/) bug. -#### I can leave out parentheses on `if` conditions, why do I have to put brackets around single line blocks? Why is the C style not allowed? +### I can leave out parentheses on `if` conditions, why do I have to put brackets around single line blocks? Why is the C style not allowed? Rust does not require parentheses around the conditional for `if`, `else if`, and the like. If C-style bracketless blocks were allowed, there would be no clear delineation between the condition and the body of the block. Requiring braces also eliminates the dangling-else problem, where nested if-else expressions can be to ambiguous. -#### Why is there no literal syntax for dictionaries? +### Why is there no literal syntax for dictionaries? There are two data types in the Rust standard library that fit the definition of a "dictionary": `BTreeMap` and `HashMap`, but they have different performance characteristics, and it's not clear which one should be the default for any potential dictionary literal syntax. Rust prefers to make performance costs explicit, and any selection of a default from these two choices may lead to performance surprises that undermine this intention. If you want a more convenient syntax for `BTreeMap` or `HashMap` creation, you can [create a macro](http://stackoverflow.com/questions/27562739/how-do-i-create-a-hashmap-literal/27582993#27582993) to provide it. -#### When should I use an implicit return? +### When should I use an implicit return? Implicit returns are simply a coding style option, and can be used anywhere they make sense. While early returns require an explicit `return`, any other return can be made implicit according to your preferences or the preferences of your project. -#### Why aren't function signatures inferred? +### Why aren't function signatures inferred? - Mechanically, it simplifies the inference algorithm, as inference only requires looking at one function at a time. - Mandatory function signatures help enforce interface stability at both the module and crate level. - It improves code comprehension for programmer, eliminating the need for an IDE running an inference algorithm across an entire crate to be able to guess at a function's argument types; it's always explicit and nearby. -#### Why does `match` have to be exhaustive? +### Why does `match` have to be exhaustive? `match` being exhaustive has some useful properties. First, if every possibility is covered by the `match`, adding further variants to an `enum` in the future will cause a compilation failure, rather than an error at runtime. Second, it makes cost explicit. In general, the only safe way to have a non-exhaustive `match` would be to panic the thread if nothing is matched, though it could fall through if the type of the `match` expression is `()`. This sort of hidden cost and special casing is against the language's philosophy. It is easy to ignore all unspecified cases by using the `_` wildcard: @@ -120,7 +120,7 @@ match val.do_something() {

Numerics

-#### Should I default to using `f32` or `f64`? +### Should I default to using `f32` or `f64`? The choice of which to use is dependent on the focus of the program. @@ -128,25 +128,25 @@ If you're interested in the greatest degree of precision with your floating poin All things being equal, `f64` is likely a better default. -#### Why can't I compare floats? +### Why can't I compare floats? You can! Floats implement the `PartialOrd` trait, which means that `>`, `<`, `<=`, and `>=` are defined for them. But they do _not_ implement the `Ord` trait, because (thanks to `NaN`) there is no total ordering for floating point numbers. There [is a crate](https://crates.io/crates/ordered-float) that provides a total ordering on floats by wrapping them, which may be desirable depending on your use-case. You can still do all of the normal comparison operations you would expect, but you can't use the `cmp` function. -#### Why can't I use `f32` or `f64` as `HashMap` keys? +### Why can't I use `f32` or `f64` as `HashMap` keys? In order to be used as a key in a `HashMap`, a type must implement the `Eq` and `Hash` traits. `f32` and `f64` implement `PartialEq`, but not `Eq`, because both types include `NaN` (stands for "not a number"). `NaN` values are [not equal to any float, and are not equal to each other](https://en.wikipedia.org/wiki/NaN). This means that `f32` and `f64` can't be used as keys in a HashMap. -#### How can I convert between numeric types? +### How can I convert between numeric types? There are three ways: the `as` keyword, which does simple casting for primitive types, the `Into` and `From` traits, which are implemented for a number of type conversions (and which you can implement for your own types), and `transmute`, which is an unsafe function that tells the compiler to treat the bits of one type as those of another type.

Strings

-#### How can I convert a `String` or `Vec` to a slice (`&str` and `&[T]`)? +### How can I convert a `String` or `Vec` to a slice (`&str` and `&[T]`)? Using Deref coercions, `Strings` and `Vec`s will automatically coerce to their respective slices when passed by reference with `&` or `& mut`. -#### How can I convert from `&str` to `String` or the other way around? +### How can I convert from `&str` to `String` or the other way around? `String`s are automatically converted into `&str` when you take a reference of them. For example, the following code works: @@ -174,7 +174,7 @@ fn main() { } ``` -#### How do I split a `String` into lines? +### How do I split a `String` into lines? The [`lines()`](https://doc.rust-lang.org/stable/std/string/struct.String.html#method.lines) function for `String`s provides an iterator over the lines of a string, which can then be `collect()`ed into a container of lines like so: @@ -183,17 +183,17 @@ let s = "This\nis\na\ntest"; let v: Vec<&str> = s.lines().collect(); ``` -#### What are the differences between the different string types? +### What are the differences between the different string types? `String` is an owned string type, while `&str` is a string slice. For a more detailed explanation, [check out the Rust book](https://doc.rust-lang.org/stable/book/strings.html). -#### How do I do O(1) character access in a `String`? +### How do I do O(1) character access in a `String`? Rust strings are UTF-8 encoded. A single visual character in UTF-8 is not necessarily a single byte as it would be in an ASCII-encoded string. Each byte is called a "code unit" (In UTF-16, code units 2 bytes instead. In UTF-32 they are 4 bytes). "Code points" are composed of one or more code units, and combine in "grapheme clusters" which most closely approximate characters. Thus, even though you may index on bytes in a UTF-8 string, you can't access the `i`th code point or grapheme cluster in constant time. However, if you know at which byte that desired code point or grapheme cluster begins, then you _can_ access it in constant time. Functions including `str::find()` and regex matches return byte indices, facilitating this sort of access. -#### Why are strings UTF-8 by default? +### Why are strings UTF-8 by default? The `str` type is UTF-8 because we observe more text in the wild in this encoding – particularly in network transmissions, which are endian-agnostic – and we think it's best that the default treatment of I/O not involve having to recode codepoints in each direction. @@ -209,7 +209,7 @@ For a more in-depth explanation of why UTF-8 is usually preferable over UTF-16 o

Collections

-#### Can I implement data structures like vectors and linked lists efficiently in Rust? +### Can I implement data structures like vectors and linked lists efficiently in Rust? If your reason for implementing these data structures is to use them for other programs, there's no need, as efficient implementations of these data structures are provided by the standard library. @@ -217,11 +217,11 @@ If, however, your reason is simply to learn, then you will likely need to dip in For example, a doubly-linked list requires that there be two mutable references to each node, but this violates Rust's mutable reference aliasing rules. You can solve this using `Weak`, but the performance will be poorer than you likely want. -#### How can I join a `Vec` (or an array) of strings into a single string? +### How can I join a `Vec` (or an array) of strings into a single string? You can do this using the [`join()`](http://doc.rust-lang.org/std/slice/trait.SliceConcatExt.html#tymethod.join) and [`concat()`](http://doc.rust-lang.org/std/slice/trait.SliceConcatExt.html#tymethod.concat) iterator methods. These allow the concatenation of items being iterated over, with `join()` inserting a separator of your choosing. -#### How can I iterate over a `Vec` without moving/consuming it? +### How can I iterate over a `Vec` without moving/consuming it? The easiest way is by using `Vec`'s `IntoIterator` implementation, like so: @@ -235,7 +235,7 @@ println!("\nLength: {}", v.len()); The way Rust `for` loops work, they actually call `into_iter()` (which is defined in the `IntoIterator` trait) for whatever you are trying to iterate over. `IntoIterator` is implemented for `&'a Vec` and `&'a mut Vec`, meaning you can iterate over a vector without consuming it just be using `&v` or `&mut v` (for some vector `v`). -#### Why do I need to type the array size in the array declaration? +### Why do I need to type the array size in the array declaration? You don't necessarily have to. If you're declaring an array directly, the size is inferred based on the number of elements. But if you're declaring a function that takes an array, the compiler has to know how big that array will be. @@ -243,7 +243,7 @@ One thing to note is that currently Rust doesn't offer generics over arrays of d

Ownership

-#### How can I implement a graph or other data structure that contains cycles? +### How can I implement a graph or other data structure that contains cycles? There are three major options: @@ -253,7 +253,7 @@ although this approach pays the cost of memory management. more efficient, but bypasses Rust's safety guarantees. - Using vectors and indices into those vectors. There are [several](http://smallcultfollowing.com/babysteps/blog/2015/04/06/modeling-graphs-in-rust-using-vector-indices/) [available](http://featherweightmusings.blogspot.com/2015/04/graphs-in-rust.html) examples and explanations of this approach. -#### How can I define a struct that contains a pointer to one of its own fields? +### How can I define a struct that contains a pointer to one of its own fields? It's possible, but useless to do so. The struct becomes permanently borrowed by itself and therefore can't be moved. Here is some code illustrating this: @@ -275,29 +275,29 @@ fn main() { } ``` -#### What does it mean to "consume a value"? +### What does it mean to "consume a value"? "Consuming a value" means taking ownership of a value. When this is done, the value can't be used elsewhere. -#### What is the difference between consuming and moving/taking ownership? +### What is the difference between consuming and moving/taking ownership? These are different terms for the same thing. In both cases, it means the value has been moved into a function, and moved out of the calling owner. -#### Why can I use integers after passing them to a function, but not structs? +### Why can I use integers after passing them to a function, but not structs? If a type implements the `Copy` trait, then it will be copied when passed to a function. All numeric types in Rust implement `Copy`, but struct types do not implement `Copy` by default, so they are moved instead. This means that the struct can no longer be used elsewhere, unless it is moved back out of the function via the return. -#### How do you deal with a "Use of moved value" error? +### How do you deal with a "Use of moved value" error? This error means that the value you're trying to use has been moved to a new owner. The first thing to check is whether the move in question was necessary. If it moved into a function, it may be possible to rewrite the function to use a reference, rather than moving. It may also be possible to implement `Copy` (for implicit copying, rather than moving) or `Clone` (explicit copying) for the type in question. If none of these are possible, you may want to return ownership of the value when the function is done, thus eliminating this error. -#### What are the rules for using `self`, `&self`, or `&mut self` in a method declaration? +### What are the rules for using `self`, `&self`, or `&mut self` in a method declaration? - Use `self` when a function needs to consume the type - Use `&self` when a function only needs a reference to the type - Use `&mut self` when a function needs to mutate the type without consuming it -#### How can I understand the borrow checker? +### How can I understand the borrow checker? There is a certain desire to act as if the borrow checker is some mysterious zen master, doling out knocks on the head whenever its koans are misunderstood. The reality is a little different. In fact, the borrow checker is simply applying a couple simple rules, which can be found in the Rust book's [section on borrowing](https://doc.rust-lang.org/stable/book/references-and-borrowing.html#the-rules): @@ -308,7 +308,7 @@ There is a certain desire to act as if the borrow checker is some mysterious zen Understanding these rules and [lifetimes](https://doc.rust-lang.org/stable/book/lifetimes.html) is all you need to do to understand the borrow checker. -#### How do deref coercions work? +### How do deref coercions work? [Deref coercions](https://doc.rust-lang.org/book/deref-coercions.html) exist to make using Rust more ergonomic, and are implemented via the [`Deref`](https://doc.rust-lang.org/stable/std/ops/trait.Deref.html) trait, which looks like this: @@ -325,19 +325,19 @@ You can see a [full list of `Deref` implementations](https://doc.rust-lang.org/s

Lifetimes

-#### Why lifetimes? +### Why lifetimes? Lifetimes are Rust's answer to the question of memory safety. They allow Rust to ensure memory safety without mechanisms like garbage collection which carry hefty performance costs. They are based on a variety of academic work, which can be found in the [Rust book](https://doc.rust-lang.org/stable/book/academic-research.html#type-system). -#### Why is the lifetime syntax the way it is? +### Why is the lifetime syntax the way it is? The `'a` syntax comes from the ML family of programming languages, where `'a` is used to indicate a generic type parameter. For Rust, the syntax had to be something that was unambiguous, noticable, and fit nicely in a type declaration right alonside traits and references. Alternative syntaxes have been discussed, but this seems to work just fine. -#### When is `Rc` useful? +### When is `Rc` useful? This is covered in the [official documentation for `Rc`](https://doc.rust-lang.org/stable/std/rc/), Rust's non-atomically reference-counted pointer type. In short, `Rc` and its thread-safe cousin `Arc` are useful to express shared ownership of an immutable value, and have the system automatically deallocate the associated memory when no one has access to it. -#### How do I return a borrow to something I created from a function? +### How do I return a borrow to something I created from a function? You need to ensure that the borrowed item will outlive the function. This can be done in two ways: by binding the output lifetime to some input lifetime, or by declaring the output lifetime as static. The first option is significantly better than the second. @@ -361,11 +361,11 @@ An alternative is to return an owning type like `String`. This eliminates the re There is also the `Cow` ("copy on write") type, which will only do the extra allocation if you attempt to mutate the contained value. -#### How do I return a closure from a function? +### How do I return a closure from a function? To return a closure from a function, it must be a "move closure", meaning that the closure is declared with the `move` keyword. As [explained in the Rust book](https://doc.rust-lang.org/book/closures.html#move-closures), this gives the closure its own copy of the captured variables, independent of its parent stack frame. Otherwise, returning a closure would be unsafe, as it would allow access to variables that are no longer valid (put another way, it would allow reading potentially invalid memory). The closure must also be wrapped in a `Box`, so that it is allocated on the heap. Read more about this [in the book](https://doc.rust-lang.org/book/closures.html#returning-closures). -#### When are lifetimes required to be defined? +### When are lifetimes required to be defined? Lifetimes can often be elided, as explained in the ["Lifetime elision" section](https://doc.rust-lang.org/book/lifetimes.html#lifetime-elision) of the Rust book. "Elided lifetimes" are those lifetimes which are implicit in any code containing references. They are automatically inserted by the compiler with the three following rules: @@ -375,25 +375,25 @@ Lifetimes can often be elided, as explained in the ["Lifetime elision" section]( If these rules would result in incorrect code elsewhere, then the Rust compiler will provide errors, and you will need to define the relevant lifetimes to correct that error. -#### How can Rust guarantee "no null pointers"? +### How can Rust guarantee "no null pointers"? Data values in the language can only be constructed through a fixed set of initializer forms. Each of those forms requires that its inputs already be initialized. A liveness analysis ensures that local variables are initialized before use.

Generics

-#### What is "monomorphisation"? +### What is "monomorphisation"? Monomorphisation is the process by which Rust generates specific instances of a generic function based on the types of the various calls to that function. This is used to provide static dispatch for generic functions. For functions using trait objects for generics, dynamic dispatch is used instead, with calls to the function going through a vtable to identify specific function calls for the provided type implementing the given trait. In C++ people would likely know this as "template instantiation." But unlike C++, Rust's monomorphisation is an implementation detail, and not a language feature. -#### What's the difference between a function and a closure that doesn't capture any variables? +### What's the difference between a function and a closure that doesn't capture any variables? Functions are a built-in primitive of the language, while closures are essentially syntactic sugar for one of three traits: `Fn`, `FnMut`, and `FnOnce`. When you make a closure, the Rust compiler automatically creates a struct implementing the appropriate trait of those three and containing the captured environment variables as members, and makes it so the the struct can be called as a function. The big difference between these traits is how they take the `self` parameter. `Fn` takes `&self`, `FnMut` takes `&mut self`, and `FnOnce` takes `self`. -#### What are higher-kinded types, why would I want them, and why doesn't Rust have them? +### What are higher-kinded types, why would I want them, and why doesn't Rust have them? Let's go through these one by one: @@ -413,11 +413,11 @@ Finally, Rust doesn't currently have them simply because they haven't been a pri (Credit to anasaziwochi for his [useful explanation](https://www.reddit.com/r/rust/comments/2av5tv/why_does_rust_not_have_a_functor_trait/ciz6iwm) of higher-kinded types in Rust.) -#### What do named type parameters in generic types mean? +### What do named type parameters in generic types mean? These are called [associated types](https://doc.rust-lang.org/stable/book/associated-types.html), and they allow for the expression of trait bounds that can't be expressed with a simple `where` clause. In essence, for a generic type with some type parameters, it is often unecessary to include those type parameters in a function taking that generic type as a parameter. The function shouldn't have to care about being generic over the types which make up the generic type (say, the node and edge types in a graph), but only about being generic over the type itself. -#### Does Rust have type reflection? +### Does Rust have type reflection? Rust does have limited type reflection through the `Reflect` and `Any` traits. `Reflect` is a marker trait (meaning it has no functions associated with it) that indicates a function expects a type which can be reflected over. It is implemented for all types. `Any` is automatically implemented for any type that is both `Reflect` and `'static`, and is used for basic dynamic typing, as in the following example, which implements a map indexed on the type of the mapped-to value: @@ -454,7 +454,7 @@ fn main() { } ``` -#### Can I override operators? Which ones and how? +### Can I override operators? Which ones and how? You can provide custom implementations for a variety of operators using their associated traits: `Add` for `+`, `Mult` for `*`. It looks like this: @@ -491,13 +491,13 @@ The following operators can be overloaded: | `[]` | `Index` | | `mut []` | `IndexMut` | -#### Why the split between `Eq`/`PartialEq` and `Ord`/`PartialOrd`? +### Why the split between `Eq`/`PartialEq` and `Ord`/`PartialOrd`? There are some types in Rust that have a partial ordering, or partial equality, but no total ordering or total equality. The floating point types `f32` and `f64` are examples of this. Because a floating point value may be `NaN`, and because `NaN`s aren't equal to any other floating point type, nor less than or greater to any other floating point type, nor equal to each other, these types _can't_ implement `Eq` and `Ord`, although they _can_ implement `PartialEq` and `PartialOrd`.

Input / Output

-#### How do I read a file into a `String`? +### How do I read a file into a `String`? Using the `read_to_string()` method, which is defined on the `Read` trait in `std::io`. @@ -517,13 +517,13 @@ fn main() { } ``` -#### How do I read file input efficiently? +### How do I read file input efficiently? The [`File` type](https://doc.rust-lang.org/stable/std/fs/struct.File.html) implements the `Read` trait, which has a variety of functions for reading and writing data, including `read()`, `read_to_end()`, `bytes()`, `chars()`, and `take()`. Each of these functions reads in a certain amount of input from a given file. `read()` reads as much input as the underlying system will provide in a single call. `read_to_end()` reads the entire buffer into a vector, allocating as much space as is needed. `bytes()` and `chars()` allow you to iterate over the bytes and characters of the file, respectively. Finally, `take()` allows you to read up to an arbitrary number of bytes from the file. Collectively, these should allow you to efficiently read in any data you need. For buffered reads, use the [`BufReader`](http://doc.rust-lang.org/stable/std/io/struct.BufReader.html) struct, which helps to reduce the number of system calls when reading. -#### How do I get command line arguments in Rust? +### How do I get command line arguments in Rust? The easiest way is to use `std::env::Args`, which provides an iterator over the input arguments. @@ -531,65 +531,65 @@ If you're looking for something more powerful, there are a [number of options on

Error Handling

-#### Why doesn't Rust have exceptions? +### Why doesn't Rust have exceptions? Exceptions complicate understanding of control-flow, they express validity/invalidity outside of the type system, and they interoperate poorly with multithreaded code (a major focus of Rust). Rust prefers a type-based approach to error handling, which is [covered at length in the book](https://doc.rust-lang.org/stable/book/error-handling.html). This fits more nicely with Rust's control flow, concurrency, and everything else. -#### What's the deal with `unwrap()` everywhere? +### What's the deal with `unwrap()` everywhere? `unwrap()` is a function that extracts the value inside an `Option` or `Result` and panics if no value is present. It is useful in the presence of truly unrecoverable errors, but is more useful for quick prototypes where you don't want to handle an error yet, or blog posts where error handling would distract from the main point. `unwrap()` shouldn't be your default way to handle errors, but it is a useful tool to have. -#### Why do I get an error when I try to run example code that uses the `try!` macro? +### Why do I get an error when I try to run example code that uses the `try!` macro? It's probably an issue with the function's return type. The [`try!` macro](https://doc.rust-lang.org/stable/std/macro.try!.html) either extracts the value from a `Result`, or returns early with the error `Result` is carrying. This means that `try` only works for functions that return `Result` themselves, where the `Err`-constructed type implements `From::from(err)`. -#### Is there an easier way to do error handling than having `Result`s everywhere? +### Is there an easier way to do error handling than having `Result`s everywhere? If you're looking for a way to avoid handling `Result`s in other people's code, there's always `unwrap()`, but it's probably not what you want. `Result` is an indicator that some computation may or may not complete successfully. The fact that some languages allow you to ignore failure cases is an anti-feature. Forcing you to handle them is one of the ways that Rust encourages safety. So, if you really don't want to handle an error, use `unwrap()`, but you should probably just handle the error for real.

Concurrency

-#### Can I use globals across threads without `unsafe`? +### Can I use globals across threads without `unsafe`? Yes, if the type implements `Sync`, doesn't implement `Drop`, and you don't try to mutate the global value.

Macros

-#### Can I write a macro to generate identifiers? +### Can I write a macro to generate identifiers? Not currently. Rust macros are so-called hygienic macros, not the unlimited compile-time syntax editing you see in C. Macro invocations can only appear in places where they are explicitly supported: items, methods declarations, statements, expressions, and patterns. Here, "method declarations" means a blank space where a method can be put. They can't be used to complete a partial method declaration. By the same logic, they can't be used to complete a partial variable declaration.

Debugging

-#### How do I debug Rust programs? +### How do I debug Rust programs? Rust programs can be debugged using gdb or lldb, same as C and C++. In fact, every Rust installation comes with rust-gdb and rust-lldb, wrappers over gdb and lldb with Rust pretty-printing enabled. -#### `rustc` said a panic occurred in standard library code. How do I locate the mistake in my code? +### `rustc` said a panic occurred in standard library code. How do I locate the mistake in my code? This error is usually caused by `unwrap()`ing a `None` or `Err`. Enabling backtraces by setting the environment variable `RUST_BACKTRACE=1` helps with getting more information. Compiling in debug mode (the default for `cargo build` is also helpful). Using a debugger like the provided `rust-gdb` or `rust-lldb` is also helpful.

Low-Level

-#### How do I `memcpy` bytes? +### How do I `memcpy` bytes? To copy potentially overlapping bytes, use `std::ptr::copy`. To copy nonoverlapping bytes, use `std::ptr::cpy_nonoverlapping`. Both of these functions are `unsafe`, as both can be used to subvert the language's safety guarantees. Use caution when using them. -#### Can Rust reasonably function without the standard library? +### Can Rust reasonably function without the standard library? Absolutely. Rust programs can be set to not load the standard library using the `#![no_std]` attribute. With this attribute set, you can continue to use the Rust core, which is nothing but the platform-agnostic primitives. As such, it doesn't include IO, concurrency, heap allocation, etc. Note however that `libcore` has not been stabilized. -#### Can I write an operating system in Rust? +### Can I write an operating system in Rust? Yes! In fact there are several projects underway doing just that, including [reenix](https://github.com/scialex/reenix), [RustOS](https://github.com/ryanra/RustOS), and [redox](http://www.redox-os.org/). -#### How can I read or write numeric types like `i32` or `f64` in big-endian or little-endian format in a file or other byte stream? +### How can I read or write numeric types like `i32` or `f64` in big-endian or little-endian format in a file or other byte stream? You should check out the [byteorder crate](http://burntsushi.net/rustdoc/byteorder/), which provides utilities for exactly that. -#### Does Rust specify data layout? +### Does Rust specify data layout? No. In the general case, `enum` and `struct` layout is undefined. This allows the compiler to potentially do optimizations like re-using padding for the discriminant, compacting variants of nested `enum`s, reordering fields to remove padding, etc. `enums` which carry no data ("C-like") are eligible to have a defined representation. Such `enums` are easily distinguished in that they are simply a list of names that carry no data: @@ -607,36 +607,36 @@ The `repr` attribute can be applied to such `enums` to give them the same repres

Cross-Platform

-#### What's the idiomatic way to express platform-specific behavior in Rust? +### What's the idiomatic way to express platform-specific behavior in Rust? Platform-specific behavior can be expressed using [conditional compilation attributes](https://doc.rust-lang.org/reference.html#conditional-compilation) such as `target_os`, `target_family`, `target_endian`, etc. -#### Can Rust be used for Android/iOS programming? +### Can Rust be used for Android/iOS programming? Yes it can! There are already examples of using Rust for both [Android](https://github.com/tomaka/android-rs-glue) and [iOS](https://www.bignerdranch.com/blog/building-an-ios-app-in-rust-part-1/). It does require a bit of work to set up, but Rust functions fine on both platforms. -#### Can I run my Rust program in a web browser? +### Can I run my Rust program in a web browser? There [are efforts](https://www.bignerdranch.com/blog/building-an-ios-app-in-rust-part-1/) to make Rust run in the web browser using Emscripten. Given that Rust is implemented on top of LLVM, this should be possible, but Rust currently runs on a special patched version of LLVM, and so it is tougher than it would otherwise be. This will likely improve over time. -#### How do I cross-compile in Rust? +### How do I cross-compile in Rust? Cross compilation is possible in Rust, but it requires [a bit of work](https://github.com/japaric/ruststrap/blob/master/1-how-to-cross-compile.md) to set up. Rust does distribute [copies of the standard library](http://static.rust-lang.org/dist/) for each of the supported platforms, which are contained in the `rust-std-*` files for each of the build directories found on the distribution page.

Modules and Crates

-#### What is the relationship between a module and a crate? +### What is the relationship between a module and a crate? - A crate is a top-level compilation unit that corresponds to a single loadable object. - A module is a (possibly nested) unit of name-management inside a crate. @@ -646,13 +646,13 @@ Cross compilation is possible in Rust, but it requires [a bit of work](https://g - There is no global inter-crate namespace; all name management occurs within a crate. - Using another crate binds the root of its namespace into the user's namespace. -#### Why can't the Rust compiler find this library I'm `use`ing? +### Why can't the Rust compiler find this library I'm `use`ing? There are a number of possible answers, but a common mistake is not realizing that `use` declarations are _always_ relative to the crate root. Try rewriting your declarations to use the paths they would use if defined in the root file of your project and see if that fixes the problem. There are also `self` and `super`, which disambiguate `use` paths as being relative to the current module or parent module, respectively. -#### Why do I have to declare module files with mod at the top level of the crate, instead of just `use`ing them? +### Why do I have to declare module files with mod at the top level of the crate, instead of just `use`ing them? There are two ways to declare modules in Rust, inline or in another file. Here is an example of each: @@ -687,15 +687,15 @@ In the first example, the module is defined in the same file it's used. In the s A `use`ing declaration just tells the compiler to bring everything from a particular module into the current module. Without a `mod` declaration first, the compiler doesn't know if the `use`d module exists, and so can't import its contents into the current module. -#### How do I configure Cargo to use a proxy? +### How do I configure Cargo to use a proxy? As explained on the Cargo [configuration documentation](http://doc.crates.io/config.html), you can set Cargo to use a proxy by setting the "proxy" variable under `[http]` in the configuration file. -#### Why can't the compiler find the method implementation even through I'm already `use`ing the crate? +### Why can't the compiler find the method implementation even through I'm already `use`ing the crate? For methods defined on a trait, you have to explicitly import the trait declaration. This means it's not enough to import a module where a struct implements the trait, you must also import the trait itself. -#### Why can't the compiler infer `use` declarations for me? +### Why can't the compiler infer `use` declarations for me? It probably could, but you also don't want it to. While in many cases it is likely that the compiler could determine the correct module to import by simply looking for where a given identifier is defined, this may not be the case in general. Any decision rule in `rustc` for choosing between competing options would likely cause surprise and confusion, and not solve much of a problem. @@ -715,16 +715,16 @@ fn main() { If you know this is going to happen, perhaps it saves a small number of keystrokes, but it also greatly increases the possibility for surprising error messages when you actually meant for `baz()` to be `bar::baz()`, and it decreases the readability of the code by making the meaning of a function call dependent on module declaration. These are not tradeoffs we are willing to make. -#### How do I do dynamic Rust library loading? +### How do I do dynamic Rust library loading? Importing dynamic libraries in Rust can be with [libloading](https://crates.io/crates/libloading), which provides a cross-platform system for dynamic linking. -#### Why doesn't [http://crates.io](http://crates.io) have namespaces? +### Why doesn't [http://crates.io](http://crates.io) have namespaces? Quoting the [official explanation](https://internals.rust-lang.org/t/crates-io-package-policies/1041) of [http://crates.io](http://crates.io)'s design: @@ -738,7 +738,7 @@ Quoting the [official explanation](https://internals.rust-lang.org/t/crates-io-p > > Because namespaces are strictly more complicated in a number of ways,and because they can be added compatibly in the future should they become necessary, we're going to stick with a single shared namespace. -#### Why are so many Rust answers on StackOverflow wrong? +### Why are so many Rust answers on StackOverflow wrong? The Rust language has been around for a number of years, and only reached version 1.0 in May of 2015. In the time before then the language changed significantly, and a number of StackOverflow answers were given at the time of older versions of the language. @@ -746,61 +746,61 @@ Over time more and more answers will be offered for the current version, this im

Libraries

-#### How can I make an HTTP request? +### How can I make an HTTP request? [Hyper](https://github.com/hyperium/hyper) is the most popular, but there are [a number of others as well](https://crates.io/keywords/http). -#### How can I write a GUI application in Rust? +### How can I write a GUI application in Rust? There are a variety of ways to write GUI applications in Rust. Just check out [this list of GUI frameworks](https://github.com/kud1ing/awesome-rust#gui). -#### How can I parse JSON/XML? +### How can I parse JSON/XML? [Serde](https://github.com/serde-rs/serde) is the recommended library for serialization and deserialization of Rust data to and from a number of different formats. -#### Is there a standard 2D+ dimensional vector and shape crate? +### Is there a standard 2D+ dimensional vector and shape crate? Not yet! Want to write one? -#### How do I write an OpenGL app in Rust? +### How do I write an OpenGL app in Rust? [Glium](https://github.com/tomaka/glium) is the major library for OpenGL programming in Rust. [GLFW](https://github.com/bjz/glfw-rs) is also a solid option. -#### Can I write a video game in Rust? +### Can I write a video game in Rust? Yes you can! The major game programming library for Rust is [Piston](http://www.piston.rs/), and there's both a [subreddit for game programming in Rust](https://www.reddit.com/r/rust_gamedev/) and an IRC channel (`#rust-gamedev` on [Mozilla IRC](https://wiki.mozilla.org/IRC)) as well.

Design Patterns

-#### Is Rust object oriented? +### Is Rust object oriented? It is multi-paradigm. Not everything is shoe-horned into a single abstraction. Many things you can do in OO languages you can do in Rust, but not everything, and not always using the same abstraction you're accustomed to. -#### How do I handle configuration of a struct with optional parameters? +### How do I handle configuration of a struct with optional parameters? The easiest way is to use the `Option` type in whatever function you're using to construct instances of the struct (usually `new()`). Another way is to use the builder pattern, where only certain functions instantiating member variables must be called before the construction of the built type. -#### How do I do global variables in Rust? +### How do I do global variables in Rust? Globals in Rust can be done using `const` declarations for compile-time computed global constants, while `static` can be used for mutable globals. Note that modifying a `static` variable requires the use of `unsafe`, as it allows for data races, one of the things guaranteed not to happen in safe Rust. You can also use the `RefCell` and `Option` type to provide interior mutability of an optional global value. It is important to note that `RefCell`s are not thread-safe. -#### How can I set compile-time constants that are defined procedurally? +### How can I set compile-time constants that are defined procedurally? Rust currently has limited support for compile time constants. You can define primitives using `const` declarations (similar to `static`, but immutable) as well as define `const` functions and inherent methods. To define procedural constants that can't be defined via these mechanisms, use the [`lazy-static`](https://github.com/rust-lang-nursery/lazy-static.rs) crate, which emulates compile-time evaluation by automatically evaluating the constant at first use. -#### Can I run initialization code that happens before main? +### Can I run initialization code that happens before main? Rust has no cross-platform concept of "life before `main`". The closest you'll see can be done through the [`lazy_static`](https://github.com/Kimundi/lazy-static.rs) crate, which simulates a "before main" by lazily initializing static variables at their first usage. -#### How do I map object-oriented concepts to Rust? +### How do I map object-oriented concepts to Rust? That depends. There _are_ ways of translating object-oriented concepts like [multiple inheritance](https://www.reddit.com/r/rust/comments/2sryuw/ideaquestion_about_multiple_inheritence/) to Rust, but as Rust is not object-oriented the result of the translation may look substantially different from its appearance in an OO language. -#### Why doesn't Rust have inheritance? +### Why doesn't Rust have inheritance? There are two meanings for the word "inheritance": _subtyping_, and _interface sharing_. Both purposes are already handled by traits. @@ -810,7 +810,7 @@ For the second, interface sharing is handled via trait methods, which define a c Rust has consistently worked to avoid having features with overlapping purposes, preferring to keep features orthogonal. For this reason, and given that the two major purposes are already handled by traits, Rust has opted not to include inheritance. -#### Does Rust allow non-constant-expression values for globals? +### Does Rust allow non-constant-expression values for globals? No. Globals can not have a non-constant-expression constructor and cannot have a destructor at all. This is an opinion of the language. Static constructors are undesirable because they can slow down program startup. Life before main is often considered a misfeature, never to be used. Rust helps this along by just not having the feature. @@ -820,39 +820,39 @@ However, `thread_local!` variables (which are restricted to a single thread) are

Other Languages

-#### How can I implement something like `struct X { static int X; };` in Rust? +### How can I implement something like `struct X { static int X; };` in Rust? Rust does not have `static` fields as shown in the code snippet above. Instead, you can declare a `static` variable in a given module, which is kept private to that module. -#### How can I convert a C-style enum to an integer, or vice-versa? +### How can I convert a C-style enum to an integer, or vice-versa? Converting a C-style enum to an integer to an integer can be done with a simple `as` expression, like `e as i64` (where `e` is some enum). Converting in the other direction is a little tougher, as Rust can't statically ensure that the conversion is valid. As such, it requires `unsafe` via `mem::transmute()`. -#### Why does Rust not have an ABI like C does, and why do I have to annotate things with extern? +### Why does Rust not have an ABI like C does, and why do I have to annotate things with extern? Committing to an ABI is a big thing, and can limit potentially advantageous language changes in the future. Given that Rust only hit 1.0 in May of 2015, it is still too early to make a commitment as big as a stable ABI. This does not mean that one won't happen in the future, though. -#### Can Rust code call C code? +### Can Rust code call C code? Yes. Calling C code from Rust is simple and exactly as efficient as calling C code from C. -#### Can C code call Rust code? +### Can C code call Rust code? Yes. The Rust code has to be exposed via an `extern` declaration, which makes it C-ABI compatible. Such a function can be passed to C code as a function pointer or, if given the `#[no_mangle]` attribute to disable symbol mangling, can be called directly from C code. -#### I already write perfect C++. What does Rust give me? +### I already write perfect C++. What does Rust give me? Modern C++ has made a lot of strides to being a safe and comfortable programming language, but it's not perfect, and it's still very easy to do things unsafely. This is something the C++ core developers are working to overcome, but C++ is limited by a long history that predates a lot of the ideas they are now trying to implement. Rust was designed from day one to be a safe systems programming language, which means it's not limited by historic design decisions that make getting safety right in C++ so complicated. In C++, safety is achieved by careful personal discipline, and is very easy to get wrong. In Rust, safety is the default. -#### How do I do the equivalent of C++ template specialization in Rust? +### How do I do the equivalent of C++ template specialization in Rust? Rust doesn't currently have an equivalent to template specialization, but it is [being worked on](https://github.com/rust-lang/rfcs/pull/1210) and will hopefully be added soon. -#### How does Rust's ownership system related to move semantics in C++? +### How does Rust's ownership system related to move semantics in C++? In C++, moving vs copying was added on late with C++11. With Rust the concept of moving vs copying has been around from the beginning. In C++ something can be moved into a function or out of a function using r-value references and either `std::move` or `std::forward`. In Rust, moves happen for anything that does not implement the `Copy` trait (which will cause the value of the type to be copied, rather than moved). This means that moves are the default operation, and that copies must be opted into explicitly. It's also important to know that moves in Rust leave the moved-out variable as uninitialized memory. This is is contrast to C++, where moves must leave behind a value, resulting the use of dummy values in things like `std::thread`. @@ -866,11 +866,11 @@ fn must_copy(t: T) { } ``` -#### How can I interoperate with C++ from Rust, or with Rust from C++? +### How can I interoperate with C++ from Rust, or with Rust from C++? The simplest way is to interoperate through C. Both Rust and C++ provide a [foreign function interface](https://doc.rust-lang.org/book/ffi.html) for C, and can use that to communicate between each other. If writing C bindings is too tedious, you can always use [rust-bindgen](https://github.com/crabtw/rust-bindgen) to help automatically generate workable C bindings. -#### Does Rust have C++-style constructors? +### Does Rust have C++-style constructors? No. Functions can serve the same purpose as constructors without adding any language complexity. The usual name for the constructor-equivalent function in Rust is `new()`, although this is just a social norm rather than a language rule. The `new()` function in fact is just like any other function. An example of it looks like so: @@ -892,19 +892,19 @@ impl Foo { } ``` -#### Does Rust have copy constructors? +### Does Rust have copy constructors? Not exactly. Types which implement `Copy` will do a standard C-like "shallow copy" with no extra work (similar to "plain old data" in C++). It is impossible to implement `Copy` types that require custom copy behavior. Instead, in Rust "copy constructors" are created by implementing the `Clone` trait, and explicitly calling the `clone` method. Making user-defined copy operators explicit surfaces the underlying complexity, forcing the developer to opt-in to potentially expensive operations. -#### Does Rust have move constructors? +### Does Rust have move constructors? No. Values of all types are moved via `memcpy`. This makes writing generic unsafe code much simpler since assignment, passing and returning are known to never have a side effect like unwinding. -#### Why does Rust not have the ? and ! like in Swift? +### Why does Rust not have the ? and ! like in Swift? In Swift, `?` is used to indicate an optional value. This is already done by `Option` in Rust, and so `?` is not needed. Similarly, `!` is used to "unwrap" an optional value in Swift, which is done by the `unwrap()` function in Rust. In both cases, Rust opted for slightly longer names which more clearly indicate intent. Also, in Rust the `!` symbol already indicates logical negation and macro calls, and does not need a third meaning. -#### How are Go and Rust similar, and how are they different? +### How are Go and Rust similar, and how are they different? Rust and Go have substantially different design goals, and so differ substantially. The following differences are not the only ones (which are too numerous to list), but are a few of the more important ones: @@ -915,27 +915,27 @@ Rust and Go have substantially different design goals, and so differ substantial Rust is probably not the best choice in every situation. If you're considering using either Rust or Go for a project it's probably best to try out both languages a bit and make an informed decision rather than base your decision on a small comparison of the two. -#### `gofmt` is great. Where's `rustfmt`? +### `gofmt` is great. Where's `rustfmt`? `rustfmt` is [right here](https://github.com/nrc/rustfmt/), and is being actively developed to make reading Rust code as easy and predictable as possible. -#### How do Rust traits compare to Haskell typeclasses? +### How do Rust traits compare to Haskell typeclasses? Rust traits are similar to Haskell typeclasses, but are currently not as powerful. Rust traits cannot express functional dependencies or type families, nor does Rust have full support for higher-kinded types. Some of these may be added in the future, but are not provided currently.

Documentation

-#### Where do I report issues in the Rust documentation? +### Where do I report issues in the Rust documentation? You can report issues in the Rust documentation on the Rust compiler [issue tracker](https://github.com/rust-lang/rust/issues). Make sure to read the [contributing guidelines](https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md) first. -#### How do I view rustdoc documentation for a library my project depends on? +### How do I view rustdoc documentation for a library my project depends on? When you use `cargo doc` to generate documentation for your own project, it also generates docs for the active dependency versions. These are put into the `target/doc` directory of your project. Use `cargo doc --open` to open the docs after building them, or just open up `target/doc/index.html` yourself after building the docs.

Project

-#### What is this project's goal? +### What is this project's goal? To design and implement a safe, concurrent, practical, static systems language. @@ -947,11 +947,11 @@ Rust exists because other languages at this level of abstraction and efficiency Rust exists as alternative language that provides both efficient code and a comfortable level of abstraction, while improving on all three of these points. -#### Is this project controlled by Mozilla? +### Is this project controlled by Mozilla? No. Rust started as Graydon Hoare's part-time side project in 2006 and remained so for over 3 years. Mozilla got involved in 2009 once the language was mature enough to run basic tests and demonstrate its core concepts. Though it remains sponsored by Mozilla, Rust is developed by a diverse community of enthusiasts from many different places around the world. The [Rust Team](https://www.rust-lang.org/team.html) is composed of both Mozilla and non-Mozilla members. -#### What are explicit non-goals of Rust? +### What are explicit non-goals of Rust? 1. To employ any particularly cutting-edge technologies. Old, established techniques are better. 2. To prize expressiveness, minimalism or elegance above other goals. These are desirable but subordinate goals. @@ -959,25 +959,25 @@ No. Rust started as Graydon Hoare's part-time side project in 2006 and remained 4. To be 100% static, 100% safe, 100% reflective, or too dogmatic in any other sense. Trade-offs exist. 5. To run on "every possible platform". It must eventually work without unnecessary compromises on widely-used hardware and software platforms. -#### In which projects is Mozilla using Rust? +### In which projects is Mozilla using Rust? The main project is [Servo](https://github.com/servo/servo), an experimental browser engine Mozilla is working on. They are also working to integrate Rust components into Firefox. -#### What examples are there of large Rust projects? +### What examples are there of large Rust projects? The two biggest open source Rust projects right now are [Servo](https://github.com/servo/servo) and the [Rust compiler](https://github.com/rust-lang/rust) itself. -#### How can I try Rust easily? +### How can I try Rust easily? The easiest way to try Rust is through the [Playground](https://play.rust-lang.org/), an online app for writing and running Rust code. If you want to try it on your system, [install it](https://www.rust-lang.org/install.html) and go through the ["Learn Rust"](https://doc.rust-lang.org/stable/book/learn-rust.html) section of the book. -#### How do I get help with Rust issues? +### How do I get help with Rust issues? There are several ways. You can: @@ -986,11 +986,11 @@ There are several ways. You can: - Ask on [StackOverflow](http://stackoverflow.com/questions/tagged/rust) with the "rust" tag - Post in [/r/rust](https://www.reddit.com/r/rust), the official Rust subreddit -#### Why has Rust changed so much over time? +### Why has Rust changed so much over time? Rust started with a goal of creating a safe but usable systems programming language. In pursuit of this goal it explored a lot of ideas, some of which it kept (lifetimes, traits) while others were discarded (the typestate system). Also, in the run up to 1.0 a lot of the standard library was rewritten. Some of this was out of a desire to improve the old versions of the APIs. Some of it was out of a desire for improved Windows support. -#### How does Rust language versioning work? +### How does Rust language versioning work? Rust maintains three "channels": stable, beta, and nightly. Stable and beta are updated every six weeks, with the current nightly becoming the new beta, and the current beta becoming the new stable. Language and standard library features marked unstable or hidden behind feature gates may only be used on the nightly channel. @@ -1002,25 +1002,25 @@ Anything marked stable will not change without a major version update with three For details, read the Rust blog post ["Stability as a Deliverable."](http://blog.rust-lang.org/2014/10/30/Stability.html) -#### Can I use unstable features in the beta or stable channel? +### Can I use unstable features in the beta or stable channel? No, you cannot. Rust works hard to provide strong guarantees about the stability of the APIs provided on the beta and stable channels. When something is unstable, it means that we can't provide those guarantees for it yet, and don't want people relying on it staying the same. This gives us the opportunity to try changes in the wild on the nightly channel, while still maintaining strong guarantees for people seeking stability. Things stabilize all the time, and the beta and stable channels update every six weeks. If you're waiting for a feature to be available without using the nightly channel, it should hopefully be available soon. -#### What IDE should I use? +### What IDE should I use? There are a couple developing options: [RustDT](https://github.com/RustDT/RustDT) is a Rust plugin for Eclipse, while [SolidOak](https://github.com/oakes/SolidOak) is a from-scratch Rust IDE. Both are solid options for a Rust IDE. Rust also integrates well with a variety of text editors. Detailed information about both text editor and IDE support can be found at [areweideyet.com](http://areweideyet.com/). -#### Why a dual MIT/ASL2 License? +### Why a dual MIT/ASL2 License? The Apache license includes important protection against patent aggression, but it is not compatible with the GPL, version 2. To avoid problems using Rust with GPL2, it is alternately MIT licensed. -#### Why a BSD-style permissive license rather than MPL or tri-license? +### Why a BSD-style permissive license rather than MPL or tri-license? This is partly due to preference of the original developer (Graydon), and partly due to the fact that languages tend to have a wider audience and more diverse set of possible embeddings and end-uses than products such as web browsers. We'd like to appeal to as many of those potential contributors as possible. -#### Why is the language called Rust? +### Why is the language called Rust? As [stated by Graydon Hoare](https://www.reddit.com/r/rust/comments/27jvdt/internet_archaeology_the_definitive_endall_source/), original developer of the Rust language, the name "Rust" comes from his personal interest in fungi, and because it evoked the feeling he was looking for in a programming language name. But truly, as Graydon himself put it: From d718d7cb8921697828606f8e31049e35e43d697d Mon Sep 17 00:00:00 2001 From: Andrew Brinker Date: Fri, 20 Nov 2015 18:49:16 -0500 Subject: [PATCH 20/94] Updating answers --- faq.md | 65 +++++++++++++++++++++++++--------------------------------- 1 file changed, 28 insertions(+), 37 deletions(-) diff --git a/faq.md b/faq.md index 01e5cde08..43cf1e0fd 100644 --- a/faq.md +++ b/faq.md @@ -41,27 +41,29 @@ If there is some common or important question you feel is wrongly left unanswere ### How fast is Rust? -Fast! Rust is already competitive with idiomatic C and C++ in a number of benchmarks. +Fast! Rust is already competitive with idiomatic C and C++ in a number of benchmarks (like the [Benchmarks Game](http://benchmarksgame.alioth.debian.org/u64q/compare.php?lang=rust&lang2=gpp) and [others](https://github.com/kostya/benchmarks)). -It is an explicit goal of Rust to be at least as fast as C++. Language decisions are made with performance in mind, and given that Rust is built on LLVM, any LLVM performance improvements also help Rust. +It is an explicit goal of Rust to be at least as fast as C++. Language decisions are made with performance in mind, and given that Rust is built on LLVM and strives to resemble Clang from LLVM's perspective, any LLVM performance improvements also help Rust. ### Is Rust garbage collected? No. A language that requires a GC is a language that opts into a larger, more complex runtime than Rust cares for. Rust is usable on bare metal with no extra runtime. -Additionally, garbage collection is frequently a source of non-deterministic behavior. Rust provides the tools to make using a GC [possible and even pleasant](http://manishearth.github.io/blog/2015/09/01/designing-a-gc-in-rust/), but it is not part of the language as provided. +Additionally, garbage collection is frequently a source of non-deterministic behavior. Rust provides the tools to make using third-party garbage collectors [possible](http://manishearth.github.io/blog/2015/09/01/designing-a-gc-in-rust/), but it is not part of the language as provided. ### Why is my program slow? -If you compiled with Cargo, did you use the `--release` flag? If you compiled with `rustc` directly, did you use the `-O` flag? Either of these will compile with optimizations turned on. The Rust languages uses a lot of optimizations to create efficient machine code, but you need to explicitly ask for them, as they also result in longer compilation times that may be undesirable during development. +The Rust compiler doesn't compile with optimizations unless asked to, as optimizations slow down compilation and are usually undesirable during development. + +If you compile with `cargo`, use the `--release` flag. If you compile with `rustc` directly, use the `-O` flag. Either of these will turn on optimizations. ### Why is Rust compilation slow? -Most of the compilation time is spent in type checking and code translation, with some time also used for safety checks. All of these are required for the strong guarantees Rust makes, but they require some time to run. Add in optimizations, and Rust's compilation is slower than a simpler language that doesn't provide Rust's guarantees. +Code translation and optimizations. Rust provides a number of high level interfaces that compile down into efficient machine code, and those translations take some time to run. -But all is not lost. The Rust compiler has evolved significantly over a number of years, and a lot of good work is being done to make it work faster, and to make it feel faster during development. +But all is not lost. The Rust compiler has evolved significantly over a number of years, and a lot of good work is being done to [make it work faster](https://github.com/rust-lang/rfcs/pull/1211), and to make it feel faster during development. -### Why is Rust's HashMap so slow? +### What hashing algorithm does Rust's `HashMap` use? By default, Rust's `HashMap` uses the [SipHash](https://131002.net/siphash/) hashing algorithm, which is designed to prevent [hash table collision attacks](http://programmingisterrible.com/post/40620375793/hash-table-denial-of-service-attacks-revisited) while providing [reasonable performance on a variety of workloads](https://www.reddit.com/r/rust/comments/3hw9zf/rust_hasher_comparisons/cub4oh6). @@ -69,15 +71,15 @@ While SipHash [demonstrates competitive performance](http://cglab.ca/%7Eabeinges ### Why can't I run benchmarks? -You can run benchmarks, but only on the nightly channel. Rust's benchmarking mechanism is currently unstable, as the API has not been deemed ready for stabilization. This may change in the future, but until then benchmarking can only be used on nightly. +You can run benchmarks, but only on the nightly channel. Rust's benchmarking mechanism is currently unstable, as the API has not been deemed ready for stabilization. This [may change in the future](https://github.com/rust-lang/rust/issues/29553), but until then benchmarking can only be used on nightly. ### Does Rust do tail-call optimization? -In general, tail-call optimization is [not guaranteed](https://mail.mozilla.org/pipermail/rust-dev/2013-April/003557.html), but may be done in [limited circumstances](http://llvm.org/docs/CodeGenerator.html#sibling-call-optimization). There was a [proposed extension](https://github.com/rust-lang/rfcs/pull/81) that would allow tail-call elimination in certain contexts, but it is currently postponed. The compiler is still free to optimize tail-calls [when it pleases](http://llvm.org/docs/CodeGenerator.html#sibling-call-optimization), however, and the language has a word (`become`) reserved for future explicit tail calls. +In general, tail-call optimization is [not guaranteed](https://mail.mozilla.org/pipermail/rust-dev/2013-April/003557.html), but may be done in [limited circumstances](http://llvm.org/docs/CodeGenerator.html#sibling-call-optimization). There was a [proposed extension](https://github.com/rust-lang/rfcs/pull/81) that would allow tail-call elimination in certain contexts, but it is currently postponed. The compiler is still free to optimize tail-calls [when it pleases](http://llvm.org/docs/CodeGenerator.html#sibling-call-optimization), however, and the language has a keyword (`become`) reserved for future explicit tail calls. ### Does Rust have a runtime? -Rust has a [very small and limited runtime](https://doc.rust-lang.org/std/rt/) providing a heap, backtraces, unwinding, and stack guards. This runtime is comparable to the [C runtime](http://www.embecosm.com/appnotes/ean9/html/ch05s02.html), and allows for the calling of Rust functions from C without setup. +Just like C, Rust has a [very small and limited runtime](https://doc.rust-lang.org/std/rt/) providing a heap, backtraces, unwinding, and stack guards. This runtime is comparable to the [C runtime](http://www.embecosm.com/appnotes/ean9/html/ch05s02.html), and allows for the calling of Rust functions from C without setup.

Syntax

@@ -89,7 +91,7 @@ Curly braces also allow for more flexible syntax for the programmer, a simpler p ### I can leave out parentheses on `if` conditions, why do I have to put brackets around single line blocks? Why is the C style not allowed? -Rust does not require parentheses around the conditional for `if`, `else if`, and the like. If C-style bracketless blocks were allowed, there would be no clear delineation between the condition and the body of the block. Requiring braces also eliminates the dangling-else problem, where nested if-else expressions can be to ambiguous. +Whereas C requires mandatory parantheses for `if`-statements but leave brackets optional, Rust makes the opposite choice. Rust's `if`-expressions thus require strictly fewer delimiters than their C counterparts. Furthermore, the optional brackets on C's `if`-statements are well-understood as a hazard to maintenance and refactoring. ### Why is there no literal syntax for dictionaries? @@ -120,11 +122,11 @@ match val.do_something() {

Numerics

-### Should I default to using `f32` or `f64`? +### Which of `f32` and `f64` should I prefer to floating-point math? The choice of which to use is dependent on the focus of the program. -If you're interested in the greatest degree of precision with your floating point numbers, then `f64` is the preferred choice. If you're more interested in keeping the size of the value small, then `f32` is better. +If you're interested in the greatest degree of precision with your floating point numbers, then `f64` is the preferred choice. If you are more interested in keeping the size of the value small or being maximally efficient, and are not concerned about the associated innacuracy of having fewer bits per value, then `f32` is better. All things being equal, `f64` is likely a better default. @@ -134,17 +136,17 @@ You can! Floats implement the `PartialOrd` trait, which means that `>`, `<`, `<= ### Why can't I use `f32` or `f64` as `HashMap` keys? -In order to be used as a key in a `HashMap`, a type must implement the `Eq` and `Hash` traits. `f32` and `f64` implement `PartialEq`, but not `Eq`, because both types include `NaN` (stands for "not a number"). `NaN` values are [not equal to any float, and are not equal to each other](https://en.wikipedia.org/wiki/NaN). This means that `f32` and `f64` can't be used as keys in a HashMap. +In order to be used as a key in a `HashMap`, a type must implement the `Eq` and `Hash` traits. `f32` and `f64` implement `PartialEq`, but not `Eq`, because one of the potential values for floating-point types is `NaN` (or "not a number"). `NaN` values are [not equal to any float, and are not equal to each other](https://en.wikipedia.org/wiki/NaN). This means that `f32` and `f64` can't be used as keys in a HashMap. ### How can I convert between numeric types? -There are three ways: the `as` keyword, which does simple casting for primitive types, the `Into` and `From` traits, which are implemented for a number of type conversions (and which you can implement for your own types), and `transmute`, which is an unsafe function that tells the compiler to treat the bits of one type as those of another type. +There are two ways: the `as` keyword, which does simple casting for primitive types, and the `Into` and `From` traits, which are implemented for a number of type conversions (and which you can implement for your own types).

Strings

### How can I convert a `String` or `Vec` to a slice (`&str` and `&[T]`)? -Using Deref coercions, `Strings` and `Vec`s will automatically coerce to their respective slices when passed by reference with `&` or `& mut`. +Using [Deref coercions](https://doc.rust-lang.org/stable/book/deref-coercions.html), `Strings` and `Vec`s will automatically coerce to their respective slices when passed by reference with `&` or `& mut`. ### How can I convert from `&str` to `String` or the other way around? @@ -161,7 +163,7 @@ fn main() { } ``` -The `to_owned()` is how you convert from a `&str` into a `String`. This is necessary because string literals in Rust are of type `&str`. In this particular example, making `s` into a `String` isn't actually necessary, and the code could be rewritten as: +The `to_owned()` method is how you convert from a `&str` into a `String`. This is necessary because string literals in Rust are of type `&str`. In this particular example, making `s` into a `String` isn't actually necessary, and the code could be rewritten as: ```rust fn say_hello(name: &str) { @@ -174,18 +176,9 @@ fn main() { } ``` -### How do I split a `String` into lines? - -The [`lines()`](https://doc.rust-lang.org/stable/std/string/struct.String.html#method.lines) function for `String`s provides an iterator over the lines of a string, which can then be `collect()`ed into a container of lines like so: - -```rust -let s = "This\nis\na\ntest"; -let v: Vec<&str> = s.lines().collect(); -``` +### What are the differences between the two different string types? -### What are the differences between the different string types? - -`String` is an owned string type, while `&str` is a string slice. For a more detailed explanation, [check out the Rust book](https://doc.rust-lang.org/stable/book/strings.html). +`String` is a buffer of UTF-8 bytes allocated on the heap, while `&str` is a "view" into a `String` allocated elsewhere. ### How do I do O(1) character access in a `String`? @@ -213,17 +206,13 @@ For a more in-depth explanation of why UTF-8 is usually preferable over UTF-16 o If your reason for implementing these data structures is to use them for other programs, there's no need, as efficient implementations of these data structures are provided by the standard library. -If, however, your reason is simply to learn, then you will likely need to dip into unsafe code. While these data structures _can_ be implemented entirely in safe Rust, the performance is likely to be worse than they would be with the use of unsafe code. The simple reason for this is that data structures like vectors and link lists rely on pointer and memory operations that are disallowed by safe Rust. +If, however, [your reason is simply to learn](http://cglab.ca/~abeinges/blah/too-many-lists/book/), then you will likely need to dip into unsafe code. While these data structures _can_ be implemented entirely in safe Rust, the performance is likely to be worse than they would be with the use of unsafe code. The simple reason for this is that data structures like vectors and link lists rely on pointer and memory operations that are disallowed by safe Rust. For example, a doubly-linked list requires that there be two mutable references to each node, but this violates Rust's mutable reference aliasing rules. You can solve this using `Weak`, but the performance will be poorer than you likely want. -### How can I join a `Vec` (or an array) of strings into a single string? - -You can do this using the [`join()`](http://doc.rust-lang.org/std/slice/trait.SliceConcatExt.html#tymethod.join) and [`concat()`](http://doc.rust-lang.org/std/slice/trait.SliceConcatExt.html#tymethod.concat) iterator methods. These allow the concatenation of items being iterated over, with `join()` inserting a separator of your choosing. +### How can I iterate over a collection without moving/consuming it? -### How can I iterate over a `Vec` without moving/consuming it? - -The easiest way is by using `Vec`'s `IntoIterator` implementation, like so: +The easiest way is by using the collection's `IntoIterator` implementation. Here is an example for `Vec`: ```rust let v = vec![1,2,3,4,5]; @@ -233,7 +222,7 @@ for item in &v { println!("\nLength: {}", v.len()); ``` -The way Rust `for` loops work, they actually call `into_iter()` (which is defined in the `IntoIterator` trait) for whatever you are trying to iterate over. `IntoIterator` is implemented for `&'a Vec` and `&'a mut Vec`, meaning you can iterate over a vector without consuming it just be using `&v` or `&mut v` (for some vector `v`). +The way Rust `for` loops work, they actually call `into_iter()` (which is defined in the `IntoIterator` trait) for whatever you are trying to iterate over. `IntoIterator` is implemented for `&Vec` and `&Vec`, meaning you can iterate over a vector without consuming it just be using `&v` or `&mut v` (for some vector `v`). The same is true for the other standard collections as well. ### Why do I need to type the array size in the array declaration? @@ -281,10 +270,12 @@ fn main() { ### What is the difference between consuming and moving/taking ownership? -These are different terms for the same thing. In both cases, it means the value has been moved into a function, and moved out of the calling owner. +These are different terms for the same thing. In both cases, it means the value has been moved to another owner, and moved out of the calling owner. ### Why can I use integers after passing them to a function, but not structs? +### Why can values of some types be used after passing them to a function, while reuse of values of other types results in an error? + If a type implements the `Copy` trait, then it will be copied when passed to a function. All numeric types in Rust implement `Copy`, but struct types do not implement `Copy` by default, so they are moved instead. This means that the struct can no longer be used elsewhere, unless it is moved back out of the function via the return. ### How do you deal with a "Use of moved value" error? From 57f62acde7ce4a81d9dedc8794e12a81634d78e2 Mon Sep 17 00:00:00 2001 From: Andrew Brinker Date: Tue, 15 Dec 2015 21:10:36 -0500 Subject: [PATCH 21/94] Addressed latest round of feedback --- faq.md | 209 ++++++++++++++++++++------------------------------------- 1 file changed, 74 insertions(+), 135 deletions(-) diff --git a/faq.md b/faq.md index 43cf1e0fd..c00cdc199 100644 --- a/faq.md +++ b/faq.md @@ -97,7 +97,7 @@ Whereas C requires mandatory parantheses for `if`-statements but leave brackets There are two data types in the Rust standard library that fit the definition of a "dictionary": `BTreeMap` and `HashMap`, but they have different performance characteristics, and it's not clear which one should be the default for any potential dictionary literal syntax. Rust prefers to make performance costs explicit, and any selection of a default from these two choices may lead to performance surprises that undermine this intention. -If you want a more convenient syntax for `BTreeMap` or `HashMap` creation, you can [create a macro](http://stackoverflow.com/questions/27562739/how-do-i-create-a-hashmap-literal/27582993#27582993) to provide it. +If you want a more convenient syntax for `BTreeMap` or `HashMap` creation, you can [create a macro](http://stackoverflow.com/questions/27582739/how-do-i-create-a-hashmap-literal) to provide it. ### When should I use an implicit return? @@ -285,12 +285,12 @@ This error means that the value you're trying to use has been moved to a new own ### What are the rules for using `self`, `&self`, or `&mut self` in a method declaration? - Use `self` when a function needs to consume the type -- Use `&self` when a function only needs a reference to the type +- Use `&self` when a function only needs a read-only reference to the type - Use `&mut self` when a function needs to mutate the type without consuming it ### How can I understand the borrow checker? -There is a certain desire to act as if the borrow checker is some mysterious zen master, doling out knocks on the head whenever its koans are misunderstood. The reality is a little different. In fact, the borrow checker is simply applying a couple simple rules, which can be found in the Rust book's [section on borrowing](https://doc.rust-lang.org/stable/book/references-and-borrowing.html#the-rules): +There is a certain desire to act as if the borrow checker is some mysterious zen master, doling out knocks on the head whenever its koans are misunderstood. The reality is a little different. In fact, the borrow checker applies only a few straightforward rules, which can be found in the Rust book's [section on borrowing](https://doc.rust-lang.org/stable/book/references-and-borrowing.html#the-rules): > First, any borrow must last for a scope no greater than that of the owner. Second, you may have one or the other of these two kinds of borrows, but not both at the same time: > @@ -301,14 +301,7 @@ Understanding these rules and [lifetimes](https://doc.rust-lang.org/stable/book/ ### How do deref coercions work? -[Deref coercions](https://doc.rust-lang.org/book/deref-coercions.html) exist to make using Rust more ergonomic, and are implemented via the [`Deref`](https://doc.rust-lang.org/stable/std/ops/trait.Deref.html) trait, which looks like this: - -```rust -pub trait Deref { - type Target: ?Sized; - fn deref(&'a self) -> &'a Self::Target; -} -``` +[Deref coercions](https://doc.rust-lang.org/book/deref-coercions.html) exist to make using Rust more ergonomic, and are implemented via the [`Deref`](https://doc.rust-lang.org/stable/std/ops/trait.Deref.html) trait. A Deref implementation indicates that the implementing type may be converted into `Target` by a call to the `deref` function, which takes an immutable reference of a certain lifetime to the calling struct, and returns a reference of the same lifetime to the target. @@ -318,11 +311,11 @@ You can see a [full list of `Deref` implementations](https://doc.rust-lang.org/s ### Why lifetimes? -Lifetimes are Rust's answer to the question of memory safety. They allow Rust to ensure memory safety without mechanisms like garbage collection which carry hefty performance costs. They are based on a variety of academic work, which can be found in the [Rust book](https://doc.rust-lang.org/stable/book/academic-research.html#type-system). +Lifetimes are Rust's answer to the question of memory safety. They allow Rust to ensure memory safety without mechanisms like garbage collection, which can have undesirable implications for performance. They are based on a variety of academic work, which can be found in the [Rust book](https://doc.rust-lang.org/stable/book/academic-research.html#type-system). ### Why is the lifetime syntax the way it is? -The `'a` syntax comes from the ML family of programming languages, where `'a` is used to indicate a generic type parameter. For Rust, the syntax had to be something that was unambiguous, noticable, and fit nicely in a type declaration right alonside traits and references. Alternative syntaxes have been discussed, but this seems to work just fine. +The `'a` syntax comes from the ML family of programming languages, where `'a` is used to indicate a generic type parameter. For Rust, the syntax had to be something that was unambiguous, noticeable, and fit nicely in a type declaration right alonside traits and references. Alternative syntaxes have been discussed, but this seems to work just fine. ### When is `Rc` useful? @@ -330,27 +323,7 @@ This is covered in the [official documentation for `Rc`](https://doc.rust-lang.o ### How do I return a borrow to something I created from a function? -You need to ensure that the borrowed item will outlive the function. This can be done in two ways: by binding the output lifetime to some input lifetime, or by declaring the output lifetime as static. The first option is significantly better than the second. - -Here is an example of each: - -```rust -// The first method -fn example1<'a>(s: &'a str) -> &'a str { - // Do something... -} - -// The second method -fn example2<'a>(s: &'a str) -> &'static str { - // Do something else... -} -``` - -The problem with declaring the lifetime as `static` is that it's rarely what you actually mean, and is instead a way of escaping the lifetime system. References with a `static` lifetime outlive everything else, and this means that they can be used in ways that would otherwise be invalid with the first method. - -An alternative is to return an owning type like `String`. This eliminates the reference issues entirely, at the cost of possibly unnecessary allocations. - -There is also the `Cow` ("copy on write") type, which will only do the extra allocation if you attempt to mutate the contained value. +You need to ensure that the borrowed item will outlive the function. This can be done by binding the output lifetime to some input lifetime. An alternative is to return an owning type like `String`. This eliminates the reference issues entirely, at the cost of possibly unnecessary allocations. There is also the `Cow` ("copy on write") type, which will only do the extra allocation if you attempt to mutate the contained value. ### How do I return a closure from a function? @@ -368,15 +341,17 @@ If these rules would result in incorrect code elsewhere, then the Rust compiler ### How can Rust guarantee "no null pointers"? -Data values in the language can only be constructed through a fixed set of initializer forms. Each of those forms requires that its inputs already be initialized. A liveness analysis ensures that local variables are initialized before use. +The only way to construct a value of type `&Foo` or `&mut Foo` is to specify an existing value of type `Foo` that the reference points to. In this way Rust makes sure no null references are introduced. -

Generics

+### How do I express the absence of a value without `null`? + +You can do that with the `Option` type, which can either be `Some(T)` or `None`. `Some(T)` indicates that a value of type `T` is contained within, while `None` indicates the absence of a value. -### What is "monomorphisation"? +

Generics

-Monomorphisation is the process by which Rust generates specific instances of a generic function based on the types of the various calls to that function. This is used to provide static dispatch for generic functions. For functions using trait objects for generics, dynamic dispatch is used instead, with calls to the function going through a vtable to identify specific function calls for the provided type implementing the given trait. +### What is "monomorphization"? -In C++ people would likely know this as "template instantiation." But unlike C++, Rust's monomorphisation is an implementation detail, and not a language feature. +Monomorphisation is the process by which Rust generates specific instances of a generic function based on the parameter types of calls to that function. This is used to provide static dispatch for generic functions. For functions using trait objects for polymorphism, dynamic dispatch is used instead, with calls to the function monomorphized at runtime based on the particular type implementing the boxed trait. ### What's the difference between a function and a closure that doesn't capture any variables? @@ -384,6 +359,8 @@ Functions are a built-in primitive of the language, while closures are essential The big difference between these traits is how they take the `self` parameter. `Fn` takes `&self`, `FnMut` takes `&mut self`, and `FnOnce` takes `self`. +In the end, functions and closures are operationally equivalent, but have different runtime representations due to their different implementations (as a language primitive and a syntactic sugar over traits, respectively). + ### What are higher-kinded types, why would I want them, and why doesn't Rust have them? Let's go through these one by one: @@ -398,56 +375,19 @@ trait Functor { } ``` -The part that Rust currently can't do is that `Self` above is a type constructor parameterized by another type constructor. This is what support for higher-kinded types lets you express. +The part that Rust currently can't do is that `Self` above is a type constructor parameterized by another type constructor. This is what support for higher-kinded types would let you express. Finally, Rust doesn't currently have them simply because they haven't been a priority. There is nothing inherent to the language that stops us from implementing higher-kinded types, it just hasn't been done yet. There is an open RFC for implementing them, but no real proposal exists yet. If one comes around, it will definitely be considered. (Credit to anasaziwochi for his [useful explanation](https://www.reddit.com/r/rust/comments/2av5tv/why_does_rust_not_have_a_functor_trait/ciz6iwm) of higher-kinded types in Rust.) -### What do named type parameters in generic types mean? +### What do named type parameters like `` in generic types mean? These are called [associated types](https://doc.rust-lang.org/stable/book/associated-types.html), and they allow for the expression of trait bounds that can't be expressed with a simple `where` clause. In essence, for a generic type with some type parameters, it is often unecessary to include those type parameters in a function taking that generic type as a parameter. The function shouldn't have to care about being generic over the types which make up the generic type (say, the node and edge types in a graph), but only about being generic over the type itself. -### Does Rust have type reflection? - -Rust does have limited type reflection through the `Reflect` and `Any` traits. `Reflect` is a marker trait (meaning it has no functions associated with it) that indicates a function expects a type which can be reflected over. It is implemented for all types. `Any` is automatically implemented for any type that is both `Reflect` and `'static`, and is used for basic dynamic typing, as in the following example, which implements a map indexed on the type of the mapped-to value: - -```rust -use std::any::{Any, TypeId}; -use std::collections::HashMap; - -type Entry = Box; - -#[derive(Debug)] -struct AnyMap(HashMap); - -impl AnyMap { - fn new() -> Self { - AnyMap(HashMap::new()) - } - - fn insert(&mut self, val: T) -> Option{ - self.0.insert(TypeId::of::(), Box::new(val) as Entry) - } - - fn get(&self) -> Option<&T> { - self.0.get(&TypeId::of::()).unwrap().downcast_ref() - } -} - -fn main() { - let mut map = AnyMap::new(); - map.insert(123i32); - map.insert(456i64); - - println!("{:?}", map); - println!("{:?}", map.get::()); -} -``` - ### Can I override operators? Which ones and how? -You can provide custom implementations for a variety of operators using their associated traits: `Add` for `+`, `Mult` for `*`. It looks like this: +You can provide custom implementations for a variety of operators using their associated traits: `Add` for `+`, `Mul` for `*`. It looks like this: ```rust struct Foo; @@ -484,7 +424,7 @@ The following operators can be overloaded: ### Why the split between `Eq`/`PartialEq` and `Ord`/`PartialOrd`? -There are some types in Rust that have a partial ordering, or partial equality, but no total ordering or total equality. The floating point types `f32` and `f64` are examples of this. Because a floating point value may be `NaN`, and because `NaN`s aren't equal to any other floating point type, nor less than or greater to any other floating point type, nor equal to each other, these types _can't_ implement `Eq` and `Ord`, although they _can_ implement `PartialEq` and `PartialOrd`. +There are some types in Rust whose values are only partially ordered, or have only partial equality. This means that there are values which are not less than or greater than each other, or values which are not equal to themselves, respectively. The floating point types `f32` and `f64` are examples of this. Because a floating point value may be `NaN`, and because `NaN`s aren't equal to any other floating point type, nor less than or greater to any other floating point type, nor equal to each other, these types _can't_ implement `Eq` and `Ord`, although they _can_ implement `PartialEq` and `PartialOrd`.

Input / Output

@@ -534,17 +474,17 @@ Rust prefers a type-based approach to error handling, which is [covered at lengt ### Why do I get an error when I try to run example code that uses the `try!` macro? -It's probably an issue with the function's return type. The [`try!` macro](https://doc.rust-lang.org/stable/std/macro.try!.html) either extracts the value from a `Result`, or returns early with the error `Result` is carrying. This means that `try` only works for functions that return `Result` themselves, where the `Err`-constructed type implements `From::from(err)`. +It's probably an issue with the function's return type. The [`try!` macro](https://doc.rust-lang.org/stable/std/macro.try!.html) either extracts the value from a `Result`, or returns early with the error `Result` is carrying. This means that `try` only works for functions that return `Result` themselves, where the `Err`-constructed type implements `From::from(err)`. In particular, this means that the `try!` macro cannot work inside the `main` function. ### Is there an easier way to do error handling than having `Result`s everywhere? -If you're looking for a way to avoid handling `Result`s in other people's code, there's always `unwrap()`, but it's probably not what you want. `Result` is an indicator that some computation may or may not complete successfully. The fact that some languages allow you to ignore failure cases is an anti-feature. Forcing you to handle them is one of the ways that Rust encourages safety. So, if you really don't want to handle an error, use `unwrap()`, but you should probably just handle the error for real. +If you're looking for a way to avoid handling `Result`s in other people's code, there's always `unwrap()`, but it's probably not what you want. `Result` is an indicator that some computation may or may not complete successfully. Requiring you to handle them is one of the ways that Rust encourages safety. If you really don't want to handle an error, use `unwrap()`, but know that doing so means that the given code will cause the entire process to panic on failure, which is usually undesirable.

Concurrency

-### Can I use globals across threads without `unsafe`? +### Can I use static values across threads without an `unsafe` block? -Yes, if the type implements `Sync`, doesn't implement `Drop`, and you don't try to mutate the global value. +Yes, if the type implements `Sync`, doesn't implement `Drop`, and you don't try to mutate the value.

Macros

@@ -560,12 +500,14 @@ Rust programs can be debugged using gdb or lldb, same as C and C++. In fact, eve ### `rustc` said a panic occurred in standard library code. How do I locate the mistake in my code? -This error is usually caused by `unwrap()`ing a `None` or `Err`. Enabling backtraces by setting the environment variable `RUST_BACKTRACE=1` helps with getting more information. Compiling in debug mode (the default for `cargo build` is also helpful). Using a debugger like the provided `rust-gdb` or `rust-lldb` is also helpful. +This error is usually caused by `unwrap()`ing a `None` or `Err` in client code. Enabling backtraces by setting the environment variable `RUST_BACKTRACE=1` helps with getting more information. Compiling in debug mode (the default for `cargo build` is also helpful). Using a debugger like the provided `rust-gdb` or `rust-lldb` is also helpful.

Low-Level

### How do I `memcpy` bytes? +If you want to clone an existing slice safely, you can use `std::slice::clone_from_slice`. This function is currently unstable, but [should be stabilized soon](https://internals.rust-lang.org/t/stabilizing-basic-functions-on-arrays-and-slices/2868). + To copy potentially overlapping bytes, use `std::ptr::copy`. To copy nonoverlapping bytes, use `std::ptr::cpy_nonoverlapping`. Both of these functions are `unsafe`, as both can be used to subvert the language's safety guarantees. Use caution when using them. ### Can Rust reasonably function without the standard library? @@ -580,9 +522,9 @@ Yes! In fact there are several projects underway doing just that, including [ree You should check out the [byteorder crate](http://burntsushi.net/rustdoc/byteorder/), which provides utilities for exactly that. -### Does Rust specify data layout? +### Does Rust guarantee a specific data layout? -No. In the general case, `enum` and `struct` layout is undefined. This allows the compiler to potentially do optimizations like re-using padding for the discriminant, compacting variants of nested `enum`s, reordering fields to remove padding, etc. `enums` which carry no data ("C-like") are eligible to have a defined representation. Such `enums` are easily distinguished in that they are simply a list of names that carry no data: +Not by default. In the general case, `enum` and `struct` layout is undefined. This allows the compiler to potentially do optimizations like re-using padding for the discriminant, compacting variants of nested `enum`s, reordering fields to remove padding, etc. `enums` which carry no data ("C-like") are eligible to have a defined representation. Such `enums` are easily distinguished in that they are simply a list of names that carry no data: ```rust enum CLike { @@ -593,7 +535,7 @@ enum CLike { } ``` -The `repr` attribute can be applied to such `enums` to give them the same representation as a primitive. This allows using Rust `enum`s in FFI where C `enum`s are also used, for most use cases. The attribute can also be applied to `struct`s to get the same layout as a C `struct` would. +The `repr` attribute can be applied to such `enums` to give them the same representation they would have in equivalent C code. This allows using Rust `enum`s in FFI code where C `enum`s are also used, for most use cases. The attribute can also be applied to `struct`s to get the same layout as a C `struct` would.

Cross-Platform

@@ -629,7 +571,7 @@ Cross compilation is possible in Rust, but it requires [a bit of work](https://g ### What is the relationship between a module and a crate? -- A crate is a top-level compilation unit that corresponds to a single loadable object. +- A crate is a compilation unit, which is the smallest amount of code that the Rust compiler can operate on. - A module is a (possibly nested) unit of name-management inside a crate. - A crate contains an implicit, un-named top-level module. - Recursive definitions can span modules, but not crates. @@ -639,10 +581,12 @@ Cross compilation is possible in Rust, but it requires [a bit of work](https://g ### Why can't the Rust compiler find this library I'm `use`ing? -There are a number of possible answers, but a common mistake is not realizing that `use` declarations are _always_ relative to the crate root. Try rewriting your declarations to use the paths they would use if defined in the root file of your project and see if that fixes the problem. +There are a number of possible answers, but a common mistake is not realizing that `use` declarations are relative to the crate root. Try rewriting your declarations to use the paths they would use if defined in the root file of your project and see if that fixes the problem. There are also `self` and `super`, which disambiguate `use` paths as being relative to the current module or parent module, respectively. +For complete information on `use`ing libraries, read the Rust book's chapter ["Crates and Modules"](https://doc.rust-lang.org/stable/book/crates-and-modules.html). + ### Why do I have to declare module files with mod at the top level of the crate, instead of just `use`ing them? There are two ways to declare modules in Rust, inline or in another file. Here is an example of each: @@ -769,17 +713,17 @@ It is multi-paradigm. Not everything is shoe-horned into a single abstraction. M ### How do I handle configuration of a struct with optional parameters? -The easiest way is to use the `Option` type in whatever function you're using to construct instances of the struct (usually `new()`). Another way is to use the builder pattern, where only certain functions instantiating member variables must be called before the construction of the built type. +The easiest way is to use the `Option` type in whatever function you're using to construct instances of the struct (usually `new()`). Another way is to use the [builder pattern](https://aturon.github.io/ownership/builders.html), where only certain functions instantiating member variables must be called before the construction of the built type. ### How do I do global variables in Rust? -Globals in Rust can be done using `const` declarations for compile-time computed global constants, while `static` can be used for mutable globals. Note that modifying a `static` variable requires the use of `unsafe`, as it allows for data races, one of the things guaranteed not to happen in safe Rust. +Globals in Rust can be done using `const` declarations for compile-time computed global constants, while `static` can be used for mutable globals. Note that modifying a `static` variable requires the use of `unsafe`, as it allows for data races, one of the things guaranteed not to happen in safe Rust. One important distinction between `const` and `static` values is that you can take references to `static` values, but not references to `const` values, which don't have a specified memory location. For more information on `const` vs. `static`, read [the Rust book](https://doc.rust-lang.org/book/const-and-static.html). You can also use the `RefCell` and `Option` type to provide interior mutability of an optional global value. It is important to note that `RefCell`s are not thread-safe. ### How can I set compile-time constants that are defined procedurally? -Rust currently has limited support for compile time constants. You can define primitives using `const` declarations (similar to `static`, but immutable) as well as define `const` functions and inherent methods. +Rust currently has limited support for compile time constants. You can define primitives using `const` declarations (similar to `static`, but immutable and without a specified location in memory) as well as define `const` functions and inherent methods. To define procedural constants that can't be defined via these mechanisms, use the [`lazy-static`](https://github.com/rust-lang-nursery/lazy-static.rs) crate, which emulates compile-time evaluation by automatically evaluating the constant at first use. @@ -803,7 +747,7 @@ Rust has consistently worked to avoid having features with overlapping purposes, ### Does Rust allow non-constant-expression values for globals? -No. Globals can not have a non-constant-expression constructor and cannot have a destructor at all. This is an opinion of the language. Static constructors are undesirable because they can slow down program startup. Life before main is often considered a misfeature, never to be used. Rust helps this along by just not having the feature. +No. Globals can not have a non-constant-expression constructor and cannot have a destructor at all. This is an opinion of the language. Static constructors are undesirable because portably ensuring a static initialization order is difficult. Life before main is often considered a misfeature, never to be used. Rust helps this along by just not having the feature. See the [C++ FQA](http://yosefk.com/c++fqa/ctors.html#fqa-10.12) about the "static initialization order fiasco", and [Eric Lippert's blog](http://ericlippert.com/2013/02/06/static-constructors-part-one/) for the challenges in C#, which also has this feature. @@ -811,15 +755,15 @@ However, `thread_local!` variables (which are restricted to a single thread) are

Other Languages

-### How can I implement something like `struct X { static int X; };` in Rust? +### How can I implement something like C's `struct X { static int X; };` in Rust? Rust does not have `static` fields as shown in the code snippet above. Instead, you can declare a `static` variable in a given module, which is kept private to that module. ### How can I convert a C-style enum to an integer, or vice-versa? -Converting a C-style enum to an integer to an integer can be done with a simple `as` expression, like `e as i64` (where `e` is some enum). +Converting a C-style enum to an integer can be done with a simple `as` expression, like `e as i64` (where `e` is some enum). -Converting in the other direction is a little tougher, as Rust can't statically ensure that the conversion is valid. As such, it requires `unsafe` via `mem::transmute()`. +Converting in the other direction can be done with a `match` statement, which maps different numeric values to different potential values for the enum. ### Why does Rust not have an ABI like C does, and why do I have to annotate things with extern? @@ -841,21 +785,15 @@ Rust was designed from day one to be a safe systems programming language, which ### How do I do the equivalent of C++ template specialization in Rust? -Rust doesn't currently have an equivalent to template specialization, but it is [being worked on](https://github.com/rust-lang/rfcs/pull/1210) and will hopefully be added soon. +Rust doesn't currently have an exact equivalent to template specialization, but it is [being worked on](https://github.com/rust-lang/rfcs/pull/1210) and will hopefully be added soon. However, similar effects can be achieved via [associated types](https://doc.rust-lang.org/stable/book/associated-types.html). ### How does Rust's ownership system related to move semantics in C++? -In C++, moving vs copying was added on late with C++11. With Rust the concept of moving vs copying has been around from the beginning. In C++ something can be moved into a function or out of a function using r-value references and either `std::move` or `std::forward`. In Rust, moves happen for anything that does not implement the `Copy` trait (which will cause the value of the type to be copied, rather than moved). This means that moves are the default operation, and that copies must be opted into explicitly. It's also important to know that moves in Rust leave the moved-out variable as uninitialized memory. This is is contrast to C++, where moves must leave behind a value, resulting the use of dummy values in things like `std::thread`. - -Moves are often not necessary or desirable in Rust. If the function you're writing does not require ownership of the value being passed in, it should probably be borrowed (mutably or immutably, as necessary) rather than moved or copied. +The notions of a "move" in Rust and a "move" in C++ are quite different, owing to the different systems in which they exist. -It's also useful to note that functions can explicitly require that an input parameter be copied like so: +In C++, R-value references come from a temporary value, or are explicitly created from a named value via `std::move`. In this way, C++ enforces that no mutable references exist to the moved-out value, so that the memory may be safely invalidated. In Rust, mutable aliases are statically eliminated by the borrow checker, and so the rough equivalent of C++'s R-values are found in Rust's mutable references (`&mut`), which can only be used if no other mutable alias already exists to the given memory location. -```rust -fn must_copy(t: T) { - // Do something in here... -} -``` +Rust "move"s are about transferring ownership, rather than eliminating mutable aliases (which are handled via the borrow checker). By default, the ownership of any function parameter is transferred into the function and out of the parameter at the call site, unless that parameter's type implements the `Copy` trait, in which case a shallow copy of the value is used to instantiate the actual parameter of the function. Rust's "move"s are often unecessary and undesirable. If the function you're writing does not require ownership of the value being passed in, that value should probably be borrowed (mutably or immutably, as necessary) rather than moved or copied. ### How can I interoperate with C++ from Rust, or with Rust from C++? @@ -899,7 +837,7 @@ In Swift, `?` is used to indicate an optional value. This is already done by `Op Rust and Go have substantially different design goals, and so differ substantially. The following differences are not the only ones (which are too numerous to list), but are a few of the more important ones: -- Rust is lower level than Go, comparable with C, C++, D, and Nim. It provides access to memory management primitives that do not exist in Go (which has a garbage collector) +- Rust is lower level than Go, comparable with C and C++. It provides access to memory management primitives that do not exist in Go (which has a garbage collector) - Rust's focus is on ensuring safety and efficiency while also providing high-level affordances, while Go's is on being a small, simple language which compiles quickly and can work nicely with a variety of tools - Rust has strong support for generics, which Go does not - Rust has strong influences from the world of functional programming, including a type system which draws from Haskell's typeclasses. Go has a simpler type system, using interfaces for basic generic programming @@ -912,7 +850,15 @@ Rust is probably not the best choice in every situation. If you're considering u ### How do Rust traits compare to Haskell typeclasses? -Rust traits are similar to Haskell typeclasses, but are currently not as powerful. Rust traits cannot express functional dependencies or type families, nor does Rust have full support for higher-kinded types. Some of these may be added in the future, but are not provided currently. +Rust traits are similar to Haskell typeclasses, but are currently not as powerful, as Rust cannot express higher-kinded types. Rust's associated types are equivalent to Haskell type families. + +Some specific difference between Haskell typeclasses and Rust traits include: + +- Rust traits have an implicit first parameter called `Self`. `trait Bar` in Rust corresponds to `class Bar self` in Haskell, and `trait Bar` in Rust corresponds to `class Boo foo self` in Haskell. +- "Supertraits" or "superclass constraints" in Rust are written `trait Sub: Super`, compared to `class Super self => Sub self` in Haskell. +- Rust forbids orphan instances, resulting in different coherence rules in Rust compared to Haskell. +- Rust's `impl` resolution considers the relevant `where` clauses and trait bounds when deciding whether two `impl`s overlap, or choosing between potential `impl`s. Haskell only considers the constraints in the `instance` declaration, disregarding any constraints provided elsewhere. +- A subset of Rust's traits (the ["object safe"](https://github.com/rust-lang/rfcs/blob/master/text/0255-object-safety.md) ones) can be used for dynamic dispatch via trait objects. The same feature is available in Haskell via GHC's `ExistentialQuantification`.

Documentation

@@ -928,31 +874,34 @@ When you use `cargo doc` to generate documentation for your own project, it also ### What is this project's goal? -To design and implement a safe, concurrent, practical, static systems language. +To design and implement a safe, concurrent, practical systems language. Rust exists because other languages at this level of abstraction and efficiency are unsatisfactory. In particular: 1. There is too little attention paid to safety. 2. They have poor concurrency support. 3. There is a lack of practical affordances. +4. They offer limited control over resources. -Rust exists as alternative language that provides both efficient code and a comfortable level of abstraction, while improving on all three of these points. +Rust exists as alternative language that provides both efficient code and a comfortable level of abstraction, while improving on all four of these points. ### Is this project controlled by Mozilla? -No. Rust started as Graydon Hoare's part-time side project in 2006 and remained so for over 3 years. Mozilla got involved in 2009 once the language was mature enough to run basic tests and demonstrate its core concepts. Though it remains sponsored by Mozilla, Rust is developed by a diverse community of enthusiasts from many different places around the world. The [Rust Team](https://www.rust-lang.org/team.html) is composed of both Mozilla and non-Mozilla members. +No. Rust started as Graydon Hoare's part-time side project in 2006 and remained so for over 3 years. Mozilla got involved in 2009 once the language was mature enough to run basic tests and demonstrate its core concepts. Though it remains sponsored by Mozilla, Rust is developed by a diverse community of enthusiasts from many different places around the world. The [Rust Team](https://www.rust-lang.org/team.html) is composed of both Mozilla and non-Mozilla members, and `rustc` (Rust's compiler) has had over [1,000 unique contributors](https://github.com/rust-lang/rust/) so far. + +As far as [project governance](https://github.com/rust-lang/rfcs/blob/master/text/1068-rust-governance.md) goes, Rust is managed by a core team that sets the vision and priorities for the project, and accepts input on the design of the language via RFC proposals. There are also subteams to guide and foster development of particular areas of interest, including Rust libraries, Rust tools, and moderation of the official Rust communities. For changes which do not require an RFC, decisions are made through pull requests on the [`rustc` repository](https://github.com/rust-lang/rust). -### What are explicit non-goals of Rust? +### What are some design goals of Rust? -1. To employ any particularly cutting-edge technologies. Old, established techniques are better. -2. To prize expressiveness, minimalism or elegance above other goals. These are desirable but subordinate goals. -3. To cover the complete feature-set of C++, or any other language. It should provide majority-case features. -4. To be 100% static, 100% safe, 100% reflective, or too dogmatic in any other sense. Trade-offs exist. -5. To run on "every possible platform". It must eventually work without unnecessary compromises on widely-used hardware and software platforms. +1. We do not employ any particularly cutting-edge technologies. Old, established techniques are better. +2. We do not prize expressiveness, minimalism or elegance above other goals. These are desirable but subordinate goals. +3. We do not intend to cover the complete feature-set of C++, or any other language. Rust should provide majority-case features. +4. We do not intend to be 100% static, 100% safe, 100% reflective, or too dogmatic in any other sense. Trade-offs exist. +5. We do not demand that Rust run on "every possible platform". It must eventually work without unnecessary compromises on widely-used hardware and software platforms. ### In which projects is Mozilla using Rust? -The main project is [Servo](https://github.com/servo/servo), an experimental browser engine Mozilla is working on. They are also working to integrate Rust components into Firefox. +The main project is [Servo](https://github.com/servo/servo), an experimental browser engine Mozilla is working on. They are also working to [integrate Rust components](https://bugzilla.mozilla.org/show_bug.cgi?id=1135640) into Firefox. ### What examples are there of large Rust projects? @@ -966,7 +915,7 @@ TODO: Write this answer. ### How can I try Rust easily? -The easiest way to try Rust is through the [Playground](https://play.rust-lang.org/), an online app for writing and running Rust code. If you want to try it on your system, [install it](https://www.rust-lang.org/install.html) and go through the ["Learn Rust"](https://doc.rust-lang.org/stable/book/learn-rust.html) section of the book. +The easiest way to try Rust is through the [playpen](https://play.rust-lang.org/), an online app for writing and running Rust code. If you want to try Rust on your system, [install it](https://www.rust-lang.org/install.html) and go through the ["Learn Rust"](https://doc.rust-lang.org/stable/book/learn-rust.html) section of the book. ### How do I get help with Rust issues? @@ -979,17 +928,13 @@ There are several ways. You can: ### Why has Rust changed so much over time? -Rust started with a goal of creating a safe but usable systems programming language. In pursuit of this goal it explored a lot of ideas, some of which it kept (lifetimes, traits) while others were discarded (the typestate system). Also, in the run up to 1.0 a lot of the standard library was rewritten. Some of this was out of a desire to improve the old versions of the APIs. Some of it was out of a desire for improved Windows support. +Rust started with a goal of creating a safe but usable systems programming language. In pursuit of this goal it explored a lot of ideas, some of which it kept (lifetimes, traits) while others were discarded (the typestate system). Also, in the run up to 1.0 a lot of the standard library was rewritten as early designs were updated to best use Rust's features and provide quality, consistent cross-platform APIs. ### How does Rust language versioning work? -Rust maintains three "channels": stable, beta, and nightly. Stable and beta are updated every six weeks, with the current nightly becoming the new beta, and the current beta becoming the new stable. Language and standard library features marked unstable or hidden behind feature gates may only be used on the nightly channel. +Rust's language versioning follows Semver, with backwards incompatible changes of stable APIs only allowed in minor versions if those changes fix compiler bugs, patch safety holes, or change type inference to require additional annotation. -Anything marked stable will not change without a major version update with three exceptions: - -- Fixing compiler bugs -- Patching safety holes -- Changing type inference to require new annotations +Rust maintains three "release channels": stable, beta, and nightly. Stable and beta are updated every six weeks, with the current nightly becoming the new beta, and the current beta becoming the new stable. Language and standard library features marked unstable or hidden behind feature gates may only be used on the nightly channel. For details, read the Rust blog post ["Stability as a Deliverable."](http://blog.rust-lang.org/2014/10/30/Stability.html) @@ -997,11 +942,11 @@ For details, read the Rust blog post ["Stability as a Deliverable."](http://blog No, you cannot. Rust works hard to provide strong guarantees about the stability of the APIs provided on the beta and stable channels. When something is unstable, it means that we can't provide those guarantees for it yet, and don't want people relying on it staying the same. This gives us the opportunity to try changes in the wild on the nightly channel, while still maintaining strong guarantees for people seeking stability. -Things stabilize all the time, and the beta and stable channels update every six weeks. If you're waiting for a feature to be available without using the nightly channel, it should hopefully be available soon. +Things stabilize all the time, and the beta and stable channels update every six weeks. If you're waiting for a feature to be available without using the nightly channel, you can locate its tracking issue by checking the [`B-unstable`](https://github.com/rust-lang/rust/issues?q=is%3Aissue+is%3Aopen+tracking+label%3AB-unstable) tag on the issue tracker. ### What IDE should I use? -There are a couple developing options: [RustDT](https://github.com/RustDT/RustDT) is a Rust plugin for Eclipse, while [SolidOak](https://github.com/oakes/SolidOak) is a from-scratch Rust IDE. Both are solid options for a Rust IDE. Rust also integrates well with a variety of text editors. Detailed information about both text editor and IDE support can be found at [areweideyet.com](http://areweideyet.com/). +There are a number of options for development environment with Rust, all of which are detailed on the official [IDE support page](https://www.rust-lang.org/ides.html). ### Why a dual MIT/ASL2 License? @@ -1011,9 +956,3 @@ The Apache license includes important protection against patent aggression, but This is partly due to preference of the original developer (Graydon), and partly due to the fact that languages tend to have a wider audience and more diverse set of possible embeddings and end-uses than products such as web browsers. We'd like to appeal to as many of those potential contributors as possible. -### Why is the language called Rust? - -As [stated by Graydon Hoare](https://www.reddit.com/r/rust/comments/27jvdt/internet_archaeology_the_definitive_endall_source/), original developer of the Rust language, the name "Rust" comes from his personal interest in fungi, and because it evoked the feeling he was looking for in a programming language name. But truly, as Graydon himself put it: - -> <graydon> IOW I don't have a really good explanation. it seemed like a good name. (also a substring of "trust", "frustrating", "rustic" and ... "thrust"?)
-> <graydon> I think I named it after fungi. rusts are amazing creatures. From fabd2ba0276f2d9660fa2f12ab4ee21cc49cffce Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Sun, 20 Dec 2015 12:11:31 -0800 Subject: [PATCH 22/94] Take a pass over the whole FAQ --- faq.md | 214 ++++++++++++++++++++++++++++++++------------------------- 1 file changed, 119 insertions(+), 95 deletions(-) diff --git a/faq.md b/faq.md index c00cdc199..fc1f12b4d 100644 --- a/faq.md +++ b/faq.md @@ -32,7 +32,7 @@ If there is some common or important question you feel is wrongly left unanswere
  • Design Patterns
  • Other Languages
  • Documentation
    • -
  • Project
    • +
  • The Rust Project
    • @@ -49,7 +49,7 @@ It is an explicit goal of Rust to be at least as fast as C++. Language decisions No. A language that requires a GC is a language that opts into a larger, more complex runtime than Rust cares for. Rust is usable on bare metal with no extra runtime. -Additionally, garbage collection is frequently a source of non-deterministic behavior. Rust provides the tools to make using third-party garbage collectors [possible](http://manishearth.github.io/blog/2015/09/01/designing-a-gc-in-rust/), but it is not part of the language as provided. +Additionally, garbage collection is frequently a source of non-deterministic behavior. Rust provides tools to make using third-party garbage collectors [possible](http://manishearth.github.io/blog/2015/09/01/designing-a-gc-in-rust/), but it is not part of the language as provided. ### Why is my program slow? @@ -59,11 +59,13 @@ If you compile with `cargo`, use the `--release` flag. If you compile with `rust ### Why is Rust compilation slow? -Code translation and optimizations. Rust provides a number of high level interfaces that compile down into efficient machine code, and those translations take some time to run. +Code translation and optimizations. Rust provides high level abstractions that compile down into efficient machine code, and those translations take time to run, especially when optimizing. -But all is not lost. The Rust compiler has evolved significantly over a number of years, and a lot of good work is being done to [make it work faster](https://github.com/rust-lang/rfcs/pull/1211), and to make it feel faster during development. +But Rust's compilation time is not as bad as it may seem, and there is reason to believe it will improve. When comparing projects of similar size between C++ and Rust, compilation time of the entire project is generally believed to be comparable. The common perception that Rust compilation is slow is in large part due to the differences in the *compilation model* between C++ and Rust: C++'s compilation unit is the file, while Rust's is the crate, composed of many files. Thus, during development, modifying a single C++ file can result in much less recompilation than in Rust. There is a major effort underway to refactor the compiler to introduce [incremental compilation](https://github.com/rust-lang/rfcs/blob/master/text/1298-incremental-compilation.md), which will provide Rust the compile time benefits of C++'s model. -### What hashing algorithm does Rust's `HashMap` use? +Aside from the compilation model, there are several other aspects of Rust's language design and compiler implementation that affect compile-time performance. First, Rust has a moderatly-complex type system, and must spend a non-neglibable amount of compile time enforcing the constraints that make Rust safe at runtime. Secondly, Rust's use of LLVM for code generation is a double-edged sword: while it enables Rust to have world-class runtime performance, LLVM is a large framework that is not focused on compile-time performance. Thirdly, the Rust compiler suffers from long-standing technical debt, and notably generates poor-quality LLVM IR which LLVM must spend time "fixing". There is hope that future [MIR-based](https://github.com/rust-lang/rfcs/blob/master/text/1211-mir.md) optimization and translation passes will ease the burden the Rust compiler places on LLVM. Finally, Rust's preferred strategy of monomorphising generics (ala C++), while producing fast code, demands that significantly more code be generated than other translation strategies. + +### Why are Rust's `HashMap`s slow? By default, Rust's `HashMap` uses the [SipHash](https://131002.net/siphash/) hashing algorithm, which is designed to prevent [hash table collision attacks](http://programmingisterrible.com/post/40620375793/hash-table-denial-of-service-attacks-revisited) while providing [reasonable performance on a variety of workloads](https://www.reddit.com/r/rust/comments/3hw9zf/rust_hasher_comparisons/cub4oh6). @@ -75,11 +77,11 @@ You can run benchmarks, but only on the nightly channel. Rust's benchmarking mec ### Does Rust do tail-call optimization? -In general, tail-call optimization is [not guaranteed](https://mail.mozilla.org/pipermail/rust-dev/2013-April/003557.html), but may be done in [limited circumstances](http://llvm.org/docs/CodeGenerator.html#sibling-call-optimization). There was a [proposed extension](https://github.com/rust-lang/rfcs/pull/81) that would allow tail-call elimination in certain contexts, but it is currently postponed. The compiler is still free to optimize tail-calls [when it pleases](http://llvm.org/docs/CodeGenerator.html#sibling-call-optimization), however, and the language has a keyword (`become`) reserved for future explicit tail calls. +Not generally, no. Tail-call optimization may be done in [limited circumstances](http://llvm.org/docs/CodeGenerator.html#sibling-call-optimization), but is [not guaranteed](https://mail.mozilla.org/pipermail/rust-dev/2013-April/003557.html). As the feature has always been desired Rust has a keyword (`become`) reserved, though it is not clear yet whether it is technically possible, nor whether it will be implemented. There was a [proposed extension](https://github.com/rust-lang/rfcs/pull/81) that would allow tail-call elimination in certain contexts, but it is currently postponed. ### Does Rust have a runtime? -Just like C, Rust has a [very small and limited runtime](https://doc.rust-lang.org/std/rt/) providing a heap, backtraces, unwinding, and stack guards. This runtime is comparable to the [C runtime](http://www.embecosm.com/appnotes/ean9/html/ch05s02.html), and allows for the calling of Rust functions from C without setup. +Not in the typical sense used by languages such as Java, but parts of the Rust standard library can be considered a "runtime", providing a heap, backtraces, unwinding, and stack guards. There is a [small amount of initialization code](https://github.com/rust-lang/rust/blob/33916307780495fe311fe9c080b330d266f35bfb/src/libstd/rt.rs#L43) that runs before the user's `main` function. The Rust standard library additionally links to the the C standard library, which does similar [runtime initialization](http://www.embecosm.com/appnotes/ean9/html/ch05s02.html). Rust code can be compiled without the standard library, in which case there is no runtime at all.

    Syntax

    @@ -89,19 +91,19 @@ Use of curly braces to denote blocks is a common design choice in a variety of p Curly braces also allow for more flexible syntax for the programmer, a simpler parser in the compiler, and help reduce the possibility of logic mistakes caused by incorrect indentation, like Apple's [goto fail](https://gotofail.com/) bug. -### I can leave out parentheses on `if` conditions, why do I have to put brackets around single line blocks? Why is the C style not allowed? +### I can leave out parentheses on `if` conditions, so why do I have to put brackets around single line blocks? Why is the C style not allowed? Whereas C requires mandatory parantheses for `if`-statements but leave brackets optional, Rust makes the opposite choice. Rust's `if`-expressions thus require strictly fewer delimiters than their C counterparts. Furthermore, the optional brackets on C's `if`-statements are well-understood as a hazard to maintenance and refactoring. ### Why is there no literal syntax for dictionaries? -There are two data types in the Rust standard library that fit the definition of a "dictionary": `BTreeMap` and `HashMap`, but they have different performance characteristics, and it's not clear which one should be the default for any potential dictionary literal syntax. Rust prefers to make performance costs explicit, and any selection of a default from these two choices may lead to performance surprises that undermine this intention. +The reason Rust does not have syntax for initializing dictionaries — or collections in general — is due to Rust's overall design preference for limiting the size of the *language* while enabling powerful *libraries*. The only type of collection that Rust has direct syntax for initializing is the array type, which is also the only type of collection built into the language. Note that Rust does not even have syntax for initializing the common `Vec` collection type, instead the standard library defins the [`vec!`](http://doc.rust-lang.org/std/macro.vec!.html) macro. -If you want a more convenient syntax for `BTreeMap` or `HashMap` creation, you can [create a macro](http://stackoverflow.com/questions/27582739/how-do-i-create-a-hashmap-literal) to provide it. +This design choice of using Rust's macro facilities to initialize collections will likely be extended generically to other collections in the future, enabling simple initialization of not only `HashMap` and `Vec`, but also other collection types such as [`BTreeMap`](http://doc.rust-lang.org/collections/struct.BTreeMap.html). In the meantime, if you want a more convenient syntax for initializing collections, you can [create your own macro](http://stackoverflow.com/questions/27582739/how-do-i-create-a-hashmap-literal) to provide it. ### When should I use an implicit return? -Implicit returns are simply a coding style option, and can be used anywhere they make sense. While early returns require an explicit `return`, any other return can be made implicit according to your preferences or the preferences of your project. +Implicit returns are simply a coding style option, and can be used anywhere they make sense. While early returns require an explicit `return`, any other return can be made implicit according to your preferences or the preferences of your project. In the Rust project itself, the style guidelines lean toward preferring implicit returns. ### Why aren't function signatures inferred? @@ -111,7 +113,9 @@ Implicit returns are simply a coding style option, and can be used anywhere they ### Why does `match` have to be exhaustive? -`match` being exhaustive has some useful properties. First, if every possibility is covered by the `match`, adding further variants to an `enum` in the future will cause a compilation failure, rather than an error at runtime. Second, it makes cost explicit. In general, the only safe way to have a non-exhaustive `match` would be to panic the thread if nothing is matched, though it could fall through if the type of the `match` expression is `()`. This sort of hidden cost and special casing is against the language's philosophy. It is easy to ignore all unspecified cases by using the `_` wildcard: +`match` being exhaustive has some useful properties. First, if every possibility is covered by the `match`, adding further variants to an `enum` in the future will cause a compilation failure, rather than an error at runtime. Second, it makes the semantics of the default case explicit: in general, the only safe way to have a non-exhaustive `match` would be to panic the thread if nothing is matched. Early versions of Rust did not require `match` cases to be exhaustive and it was found to be a great source of bugs. + +It is easy to ignore all unspecified cases by using the `_` wildcard: ```rust match val.do_something() { @@ -124,23 +128,25 @@ match val.do_something() { ### Which of `f32` and `f64` should I prefer to floating-point math? -The choice of which to use is dependent on the focus of the program. - -If you're interested in the greatest degree of precision with your floating point numbers, then `f64` is the preferred choice. If you are more interested in keeping the size of the value small or being maximally efficient, and are not concerned about the associated innacuracy of having fewer bits per value, then `f32` is better. +The choice of which to use is dependent on the purpose of the program. -All things being equal, `f64` is likely a better default. - -### Why can't I compare floats? +If you are interested in the greatest degree of precision with your floating point numbers, then prefer `f64`. If you are more interested in keeping the size of the value small or being maximally efficient, and are not concerned about the associated innacuracy of having fewer bits per value, then `f32` is better. Operations on `f32` are usually faster, even on 64-bit hardware. As a common example, graphics programming typically uses `f32` because it requires high performance, and 32-bit floats are sufficient for representing pixels on the screen. -You can! Floats implement the `PartialOrd` trait, which means that `>`, `<`, `<=`, and `>=` are defined for them. But they do _not_ implement the `Ord` trait, because (thanks to `NaN`) there is no total ordering for floating point numbers. There [is a crate](https://crates.io/crates/ordered-float) that provides a total ordering on floats by wrapping them, which may be desirable depending on your use-case. You can still do all of the normal comparison operations you would expect, but you can't use the `cmp` function. +If in doubt, choose `f64` for the more accurate precision. ### Why can't I use `f32` or `f64` as `HashMap` keys? In order to be used as a key in a `HashMap`, a type must implement the `Eq` and `Hash` traits. `f32` and `f64` implement `PartialEq`, but not `Eq`, because one of the potential values for floating-point types is `NaN` (or "not a number"). `NaN` values are [not equal to any float, and are not equal to each other](https://en.wikipedia.org/wiki/NaN). This means that `f32` and `f64` can't be used as keys in a HashMap. +### Why can't I compare floats? + +Floats can be compared in some circumstances, but not others. Floats do implement the `PartialOrd` trait, which means that `>`, `<`, `<=`, and `>=` are defined for them. But they do _not_ implement the `Ord` trait, because (thanks to `NaN`) [there is no total ordering for floating point numbers](https://en.wikipedia.org/wiki/IEEE_floating_point#Total-ordering_predicate). The practical effect of this is that data structures that require a total ordering, such as [`BTreeMap`](http://doc.rust-lang.org/std/collections/struct.BTreeMap.html) do not work with floating point numbers. + +There [is a crate](https://crates.io/crates/ordered-float) that provides a total ordering on floats by wrapping them, which may be desirable depending on your use-case. You can still do all of the normal comparison operations you would expect, but you can't use the `cmp` function. + ### How can I convert between numeric types? -There are two ways: the `as` keyword, which does simple casting for primitive types, and the `Into` and `From` traits, which are implemented for a number of type conversions (and which you can implement for your own types). +There are two ways: the `as` keyword, which does simple casting for primitive types, and the `Into` and `From` traits, which are implemented for a number of type conversions (and which you can implement for your own types). The `Into` and `From` traits are only implemented in cases where conversions are lossless, so for example, `f64::from(0f32)` will compile while `f32:from(0f64)` will not. `as` on the other hand will convert between any two primitive types, truncating values as necessary.

    Strings

    @@ -150,39 +156,30 @@ Using [Deref coercions](https://doc.rust-lang.org/stable/book/deref-coercions.ht ### How can I convert from `&str` to `String` or the other way around? -`String`s are automatically converted into `&str` when you take a reference of them. For example, the following code works: +The `to_owned()` method converts from a `&str` into a `String`, and `String`s are automatically converted into `&str` when you borrow a reference to them. Both are demonstrated in the following example: ```rust -fn say_hello(name: &str) { - println!("Hello {}!", name); -} - fn main() { let s = "Jane Doe".to_owned(); say_hello(&s); } -``` - -The `to_owned()` method is how you convert from a `&str` into a `String`. This is necessary because string literals in Rust are of type `&str`. In this particular example, making `s` into a `String` isn't actually necessary, and the code could be rewritten as: -```rust fn say_hello(name: &str) { println!("Hello {}!", name); } - -fn main() { - let s = "Jane Doe"; - say_hello(s); -} ``` ### What are the differences between the two different string types? -`String` is a buffer of UTF-8 bytes allocated on the heap, while `&str` is a "view" into a `String` allocated elsewhere. +`String` is an owned buffer of UTF-8 bytes allocated on the heap. Mutable `String`s can be modified, growing their capacity as needed.`&str` is fixed-capacity "view" into a `String` allocated elsewhere, commonly on the heap, in the case of slices dereferenced from `String`s, or in static memory, in the case of string literals. + +`&str` is a primitive type implemented by the Rust language, while `String` is implemented in the standard library. ### How do I do O(1) character access in a `String`? -Rust strings are UTF-8 encoded. A single visual character in UTF-8 is not necessarily a single byte as it would be in an ASCII-encoded string. Each byte is called a "code unit" (In UTF-16, code units 2 bytes instead. In UTF-32 they are 4 bytes). "Code points" are composed of one or more code units, and combine in "grapheme clusters" which most closely approximate characters. +You cannot. At least not without a firm understanding of what you mean by "character", and preprocessing the string to find them. + +Rust strings are UTF-8 encoded. A single visual character in UTF-8 is not necessarily a single byte as it would be in an ASCII-encoded string. Each byte is called a "code unit" (in UTF-16, code units are 2 bytes; in UTF-32 they are 4 bytes). "Code points" are composed of one or more code units, and combine in "grapheme clusters" which most closely approximate characters. Thus, even though you may index on bytes in a UTF-8 string, you can't access the `i`th code point or grapheme cluster in constant time. However, if you know at which byte that desired code point or grapheme cluster begins, then you _can_ access it in constant time. Functions including `str::find()` and regex matches return byte indices, facilitating this sort of access. @@ -228,7 +225,7 @@ The way Rust `for` loops work, they actually call `into_iter()` (which is define You don't necessarily have to. If you're declaring an array directly, the size is inferred based on the number of elements. But if you're declaring a function that takes an array, the compiler has to know how big that array will be. -One thing to note is that currently Rust doesn't offer generics over arrays of different size. This is a planned feature, but isn't available currently. If you'd like to accept a contiguous container of a variable number of values, use a Vec or slice (depending on whether you need ownership). +One thing to note is that currently Rust doesn't offer generics over arrays of different size. If you'd like to accept a contiguous container of a variable number of values, use a `Vec` or slice (depending on whether you need ownership).

    Ownership

    @@ -236,7 +233,7 @@ One thing to note is that currently Rust doesn't offer generics over arrays of d There are three major options: -- You can implement it using `Weak` or `Rc` to allow shared ownership of nodes, +- You can implement it using `Rc` and `Weak` to allow shared ownership of nodes, although this approach pays the cost of memory management. - You can implement it using `unsafe` code using raw pointers. This will be more efficient, but bypasses Rust's safety guarantees. @@ -272,15 +269,18 @@ fn main() { These are different terms for the same thing. In both cases, it means the value has been moved to another owner, and moved out of the calling owner. -### Why can I use integers after passing them to a function, but not structs? - ### Why can values of some types be used after passing them to a function, while reuse of values of other types results in an error? If a type implements the `Copy` trait, then it will be copied when passed to a function. All numeric types in Rust implement `Copy`, but struct types do not implement `Copy` by default, so they are moved instead. This means that the struct can no longer be used elsewhere, unless it is moved back out of the function via the return. -### How do you deal with a "Use of moved value" error? +### How do you deal with a "use of moved value" error? -This error means that the value you're trying to use has been moved to a new owner. The first thing to check is whether the move in question was necessary. If it moved into a function, it may be possible to rewrite the function to use a reference, rather than moving. It may also be possible to implement `Copy` (for implicit copying, rather than moving) or `Clone` (explicit copying) for the type in question. If none of these are possible, you may want to return ownership of the value when the function is done, thus eliminating this error. +This error means that the value you're trying to use has been moved to a new owner. The first thing to check is whether the move in question was necessary: if it moved into a function, it may be possible to rewrite the function to use a reference, rather than moving. Otherwise if the type being moved implements `Clone`, then calling `clone()` on it before +moving will move a copy of it, leaving the original still available for further use. Note though that cloning a value should typically be the last resort since cloning can be expensive, causing further allocations. + +If the moved value is of your own custom type, consider implementing `Copy` (for implicit copying, rather than moving) or `Clone` (explicit copying). `Copy` is most commonly implemented with `#[derive(Copy, Clone)]` (`Copy` requires `Clone`), and `Clone` with `#[derive(Clone)]`. + +If none of these are possible, you may want to modify the function that acquired ownership to return ownership of the value when the function exits. ### What are the rules for using `self`, `&self`, or `&mut self` in a method declaration? @@ -301,9 +301,16 @@ Understanding these rules and [lifetimes](https://doc.rust-lang.org/stable/book/ ### How do deref coercions work? -[Deref coercions](https://doc.rust-lang.org/book/deref-coercions.html) exist to make using Rust more ergonomic, and are implemented via the [`Deref`](https://doc.rust-lang.org/stable/std/ops/trait.Deref.html) trait. +[Deref coercions](https://doc.rust-lang.org/book/deref-coercions.html) exist to make using Rust more ergonomic, and are implemented via the [`Deref`](https://doc.rust-lang.org/stable/std/ops/trait.Deref.html) trait, which looks like -A Deref implementation indicates that the implementing type may be converted into `Target` by a call to the `deref` function, which takes an immutable reference of a certain lifetime to the calling struct, and returns a reference of the same lifetime to the target. +```rust +pub trait Deref { + type Target: ?Sized; + fn deref(&self) -> &Self::Target; +} +``` + +A Deref implementation indicates that the implementing type may be converted into `Target` by a call to the `deref` function, which takes an immutable reference of a certain lifetime to the calling struct, and returns a reference of the same lifetime to the target. The `*` prefix operator is shorthand for the `deref` method. You can see a [full list of `Deref` implementations](https://doc.rust-lang.org/stable/std/ops/trait.Deref.html#implementors) for the standard library in the documentation. @@ -311,7 +318,7 @@ You can see a [full list of `Deref` implementations](https://doc.rust-lang.org/s ### Why lifetimes? -Lifetimes are Rust's answer to the question of memory safety. They allow Rust to ensure memory safety without mechanisms like garbage collection, which can have undesirable implications for performance. They are based on a variety of academic work, which can be found in the [Rust book](https://doc.rust-lang.org/stable/book/academic-research.html#type-system). +Lifetimes are Rust's answer to the question of memory safety. They allow Rust to ensure memory safety garbage collection, which can have undesirable implications for performance. They are based on a variety of academic work, which can be found in the [Rust book](https://doc.rust-lang.org/stable/book/academic-research.html#type-system). ### Why is the lifetime syntax the way it is? @@ -319,7 +326,7 @@ The `'a` syntax comes from the ML family of programming languages, where `'a` is ### When is `Rc` useful? -This is covered in the [official documentation for `Rc`](https://doc.rust-lang.org/stable/std/rc/), Rust's non-atomically reference-counted pointer type. In short, `Rc` and its thread-safe cousin `Arc` are useful to express shared ownership of an immutable value, and have the system automatically deallocate the associated memory when no one has access to it. +This is covered in the [official documentation for `Rc`](https://doc.rust-lang.org/stable/std/rc/), Rust's non-atomically reference-counted pointer type. In short, `Rc` and its thread-safe cousin `Arc` are useful to express shared ownership, and have the system automatically deallocate the associated memory when no one has access to it. ### How do I return a borrow to something I created from a function? @@ -345,17 +352,19 @@ The only way to construct a value of type `&Foo` or `&mut Foo` is to specify an ### How do I express the absence of a value without `null`? -You can do that with the `Option` type, which can either be `Some(T)` or `None`. `Some(T)` indicates that a value of type `T` is contained within, while `None` indicates the absence of a value. +You can do that with the [`Option`](https://doc.rust-lang.org/stable/std/option/index.html) type, which can either be `Some(T)` or `None`. `Some(T)` indicates that a value of type `T` is contained within, while `None` indicates the absence of a value.

    Generics

    ### What is "monomorphization"? -Monomorphisation is the process by which Rust generates specific instances of a generic function based on the parameter types of calls to that function. This is used to provide static dispatch for generic functions. For functions using trait objects for polymorphism, dynamic dispatch is used instead, with calls to the function monomorphized at runtime based on the particular type implementing the boxed trait. +Monomorphisation is the process by which Rust translates to machine code specific instances of a generic function based on the parameter types of calls to that function. During monomorphisisation a new copy of the generic function is translated for each unique set of types the function is instantiated with. This strategy is the same as used by C++. It results in fast code that is specialized for every callsite and statically dispatched, with the tradeoff that functions instantiated with many different types can cause "code bloat", where multiple function instances result in larger binaries than would be created with other translation strategies. + +Functions that accept [trait objects](http://doc.rust-lang.org/book/trait-objects.html) instead of type parameters do not undergo monomorphization. Instead, methods on the trait objects are dispatched dynamically at runtime. ### What's the difference between a function and a closure that doesn't capture any variables? -Functions are a built-in primitive of the language, while closures are essentially syntactic sugar for one of three traits: `Fn`, `FnMut`, and `FnOnce`. When you make a closure, the Rust compiler automatically creates a struct implementing the appropriate trait of those three and containing the captured environment variables as members, and makes it so the the struct can be called as a function. +Functions are a built-in primitive of the language, while closures are essentially syntactic sugar for one of three traits: `Fn`, `FnMut`, and `FnOnce`. When you make a closure, the Rust compiler automatically creates a struct implementing the appropriate trait of those three and containing the captured environment variables as members, and makes it so the the struct can be called as a function. Bare functions can not capture an environment. The big difference between these traits is how they take the `self` parameter. `Fn` takes `&self`, `FnMut` takes `&mut self`, and `FnOnce` takes `self`. @@ -379,8 +388,6 @@ The part that Rust currently can't do is that `Self` above is a type constructor Finally, Rust doesn't currently have them simply because they haven't been a priority. There is nothing inherent to the language that stops us from implementing higher-kinded types, it just hasn't been done yet. There is an open RFC for implementing them, but no real proposal exists yet. If one comes around, it will definitely be considered. -(Credit to anasaziwochi for his [useful explanation](https://www.reddit.com/r/rust/comments/2av5tv/why_does_rust_not_have_a_functor_trait/ciz6iwm) of higher-kinded types in Rust.) - ### What do named type parameters like `` in generic types mean? These are called [associated types](https://doc.rust-lang.org/stable/book/associated-types.html), and they allow for the expression of trait bounds that can't be expressed with a simple `where` clause. In essence, for a generic type with some type parameters, it is often unecessary to include those type parameters in a function taking that generic type as a parameter. The function shouldn't have to care about being generic over the types which make up the generic type (say, the node and edge types in a graph), but only about being generic over the type itself. @@ -390,6 +397,8 @@ These are called [associated types](https://doc.rust-lang.org/stable/book/associ You can provide custom implementations for a variety of operators using their associated traits: `Add` for `+`, `Mul` for `*`. It looks like this: ```rust +use std::ops::Add; + struct Foo; impl Add for Foo { @@ -403,24 +412,41 @@ impl Add for Foo { The following operators can be overloaded: -| Operation | Trait | -|:--------------------|:-----------| -| `+` | `Add` | -| `binary -` | `Sub` | -| `*` | `Mul` | -| `/` | `Div` | -| `unary -` | `Neg` | -| `%` | `Rem` | -| `&` | `BitAnd` | -| | | `BitOr` | -| `^` | `BitXor` | -| `!` | `Not` | -| `<<` | `Shl` | -| `>>` | `Shr` | -| `*` | `Deref` | -| `mut *` | `DerefMut` | -| `[]` | `Index` | -| `mut []` | `IndexMut` | +| Operation | Trait | +|:--------------------|:-------------| +| `+` | [`Add`] | +| `binary -` | [`Sub`] | +| `*` | [`Mul`] | +| `/` | [`Div`] | +| `unary -` | [`Neg`] | +| `%` | [`Rem`] | +| `&` | [`BitAnd`] | +| | | [`BitOr`] | +| `^` | [`BitXor`] | +| `!` | [`Not`] | +| `<<` | [`Shl`] | +| `>>` | [`Shr`] | +| `*` | [`Deref`] | +| `mut *` | [`DerefMut`] | +| `[]` | [`Index`] | +| `mut []` | [`IndexMut`] | + +[`Add`]: https://doc.rust-lang.org/stable/std/ops/trait.Add.html +[`Sub`]: https://doc.rust-lang.org/stable/std/ops/trait.Sub.html +[`Mul`]: https://doc.rust-lang.org/stable/std/ops/trait.Mul.html +[`Div`]: https://doc.rust-lang.org/stable/std/ops/trait.Div.html +[`Neg`]: https://doc.rust-lang.org/stable/std/ops/trait.Neg.html +[`Rem`]: https://doc.rust-lang.org/stable/std/ops/trait.Rem.html +[`BitAnd`]: https://doc.rust-lang.org/stable/std/ops/trait.BitAnd.html +[`BitOr`]: https://doc.rust-lang.org/stable/std/ops/trait.BitOr.html +[`BitXor`]: https://doc.rust-lang.org/stable/std/ops/trait.BitXor.html +[`Not`]: https://doc.rust-lang.org/stable/std/ops/trait.Not.html +[`Shl`]: https://doc.rust-lang.org/stable/std/ops/trait.Shl.html +[`Shr`]: https://doc.rust-lang.org/stable/std/ops/trait.Shr.html +[`Deref`]: https://doc.rust-lang.org/stable/std/ops/trait.Deref.html +[`DerefMut`]: https://doc.rust-lang.org/stable/std/ops/trait.DerefMut.html +[`Index`]: https://doc.rust-lang.org/stable/std/ops/trait.Index.html +[`IndexMut`]: https://doc.rust-lang.org/stable/std/ops/trait.IndexMut.html ### Why the split between `Eq`/`PartialEq` and `Ord`/`PartialOrd`? @@ -450,7 +476,7 @@ fn main() { ### How do I read file input efficiently? -The [`File` type](https://doc.rust-lang.org/stable/std/fs/struct.File.html) implements the `Read` trait, which has a variety of functions for reading and writing data, including `read()`, `read_to_end()`, `bytes()`, `chars()`, and `take()`. Each of these functions reads in a certain amount of input from a given file. `read()` reads as much input as the underlying system will provide in a single call. `read_to_end()` reads the entire buffer into a vector, allocating as much space as is needed. `bytes()` and `chars()` allow you to iterate over the bytes and characters of the file, respectively. Finally, `take()` allows you to read up to an arbitrary number of bytes from the file. Collectively, these should allow you to efficiently read in any data you need. +The [`File` type](https://doc.rust-lang.org/stable/std/fs/struct.File.html) implements the `Read` trait, which has a variety of functions for reading and writing data, including `read()`, `read_to_end()`, `bytes()`, `chars()`, and `take()`. Each of these functions reads a certain amount of input from a given file. `read()` reads as much input as the underlying system will provide in a single call. `read_to_end()` reads the entire buffer into a vector, allocating as much space as is needed. `bytes()` and `chars()` allow you to iterate over the bytes and characters of the file, respectively. Finally, `take()` allows you to read up to an arbitrary number of bytes from the file. Collectively, these should allow you to efficiently read in any data you need. For buffered reads, use the [`BufReader`](http://doc.rust-lang.org/stable/std/io/struct.BufReader.html) struct, which helps to reduce the number of system calls when reading. @@ -490,7 +516,7 @@ Yes, if the type implements `Sync`, doesn't implement `Drop`, and you don't try ### Can I write a macro to generate identifiers? -Not currently. Rust macros are so-called hygienic macros, not the unlimited compile-time syntax editing you see in C. Macro invocations can only appear in places where they are explicitly supported: items, methods declarations, statements, expressions, and patterns. Here, "method declarations" means a blank space where a method can be put. They can't be used to complete a partial method declaration. By the same logic, they can't be used to complete a partial variable declaration. +Not currently. Rust macros are so-called ["hygienic macros"](https://en.wikipedia.org/wiki/Hygienic_macro), which intentionally avoid capturing or creating identifiers that may cause name unexpected collisions with other identifiers. Their capabilities are significantly different than the style of macros commonly associated with the C preprocessor. Macro invocations can only appear in places where they are explicitly supported: items, methods declarations, statements, expressions, and patterns. Here, "method declarations" means a blank space where a method can be put. They can't be used to complete a partial method declaration. By the same logic, they can't be used to complete a partial variable declaration.

    Debugging

    @@ -512,11 +538,11 @@ To copy potentially overlapping bytes, use `std::ptr::copy`. To copy nonoverlapp ### Can Rust reasonably function without the standard library? -Absolutely. Rust programs can be set to not load the standard library using the `#![no_std]` attribute. With this attribute set, you can continue to use the Rust core, which is nothing but the platform-agnostic primitives. As such, it doesn't include IO, concurrency, heap allocation, etc. Note however that `libcore` has not been stabilized. +Absolutely. Rust programs can be set to not load the standard library using the `#![no_std]` attribute. With this attribute set, you can continue to use the Rust core library, which is nothing but the platform-agnostic primitives. As such, it doesn't include IO, concurrency, heap allocation, etc. Note however that `libcore` has not been stabilized. ### Can I write an operating system in Rust? -Yes! In fact there are several projects underway doing just that, including [reenix](https://github.com/scialex/reenix), [RustOS](https://github.com/ryanra/RustOS), and [redox](http://www.redox-os.org/). +Yes! In fact there are [several projects underway doing just that](http://wiki.osdev.org/Rust). ### How can I read or write numeric types like `i32` or `f64` in big-endian or little-endian format in a file or other byte stream? @@ -535,7 +561,7 @@ enum CLike { } ``` -The `repr` attribute can be applied to such `enums` to give them the same representation they would have in equivalent C code. This allows using Rust `enum`s in FFI code where C `enum`s are also used, for most use cases. The attribute can also be applied to `struct`s to get the same layout as a C `struct` would. +The `#[repr(C)]` attribute can be applied to such `enums` to give them the same representation they would have in equivalent C code. This allows using Rust `enum`s in FFI code where C `enum`s are also used, for most use cases. The attribute can also be applied to `struct`s to get the same layout as a C `struct` would.

    Cross-Platform

    @@ -546,7 +572,7 @@ TODO: Write this answer. --> @@ -561,11 +587,11 @@ Yes it can! There are already examples of using Rust for both [Android](https:// ### Can I run my Rust program in a web browser? -There [are efforts](https://www.bignerdranch.com/blog/building-an-ios-app-in-rust-part-1/) to make Rust run in the web browser using Emscripten. Given that Rust is implemented on top of LLVM, this should be possible, but Rust currently runs on a special patched version of LLVM, and so it is tougher than it would otherwise be. This will likely improve over time. +Not yet, but there are efforts underway to make Rust compile to the web with Emscripten. ### How do I cross-compile in Rust? -Cross compilation is possible in Rust, but it requires [a bit of work](https://github.com/japaric/ruststrap/blob/master/1-how-to-cross-compile.md) to set up. Rust does distribute [copies of the standard library](http://static.rust-lang.org/dist/) for each of the supported platforms, which are contained in the `rust-std-*` files for each of the build directories found on the distribution page. +Cross compilation is possible in Rust, but it requires [a bit of work](https://github.com/japaric/ruststrap/blob/master/1-how-to-cross-compile.md) to set up. Rust does distribute [copies of the standard library](http://static.rust-lang.org/dist/) for each of the supported platforms, which are contained in the `rust-std-*` files for each of the build directories found on the distribution page, but there are not yet automated ways to install them.

    Modules and Crates

    @@ -587,7 +613,7 @@ There are also `self` and `super`, which disambiguate `use` paths as being relat For complete information on `use`ing libraries, read the Rust book's chapter ["Crates and Modules"](https://doc.rust-lang.org/stable/book/crates-and-modules.html). -### Why do I have to declare module files with mod at the top level of the crate, instead of just `use`ing them? +### Why do I have to declare module files with `mod` at the top level of the crate, instead of just `use`ing them? There are two ways to declare modules in Rust, inline or in another file. Here is an example of each: @@ -657,7 +683,7 @@ TODO: Write this answer. ### How do I do dynamic Rust library loading? -Importing dynamic libraries in Rust can be with [libloading](https://crates.io/crates/libloading), which provides a cross-platform system for dynamic linking. +Import dynamic libraries in Rust with [libloading](https://crates.io/crates/libloading), which provides a cross-platform system for dynamic linking. ### Why doesn't [http://crates.io](http://crates.io) have namespaces? @@ -709,7 +735,7 @@ Yes you can! The major game programming library for Rust is [Piston](http://www. ### Is Rust object oriented? -It is multi-paradigm. Not everything is shoe-horned into a single abstraction. Many things you can do in OO languages you can do in Rust, but not everything, and not always using the same abstraction you're accustomed to. +It is multi-paradigm. Many things you can do in OO languages you can do in Rust, but not everything, and not always using the same abstraction you're accustomed to. ### How do I handle configuration of a struct with optional parameters? @@ -729,7 +755,7 @@ To define procedural constants that can't be defined via these mechanisms, use t ### Can I run initialization code that happens before main? -Rust has no cross-platform concept of "life before `main`". The closest you'll see can be done through the [`lazy_static`](https://github.com/Kimundi/lazy-static.rs) crate, which simulates a "before main" by lazily initializing static variables at their first usage. +Rust has no concept of "life before `main`". The closest you'll see can be done through the [`lazy_static`](https://github.com/Kimundi/lazy-static.rs) crate, which simulates a "before main" by lazily initializing static variables at their first usage. ### How do I map object-oriented concepts to Rust? @@ -747,12 +773,10 @@ Rust has consistently worked to avoid having features with overlapping purposes, ### Does Rust allow non-constant-expression values for globals? -No. Globals can not have a non-constant-expression constructor and cannot have a destructor at all. This is an opinion of the language. Static constructors are undesirable because portably ensuring a static initialization order is difficult. Life before main is often considered a misfeature, never to be used. Rust helps this along by just not having the feature. +No. Globals can not have a non-constant-expression constructor and cannot have a destructor at all. Static constructors are undesirable because portably ensuring a static initialization order is difficult. Life before main is often considered a misfeature so Rust does not allow it. See the [C++ FQA](http://yosefk.com/c++fqa/ctors.html#fqa-10.12) about the "static initialization order fiasco", and [Eric Lippert's blog](http://ericlippert.com/2013/02/06/static-constructors-part-one/) for the challenges in C#, which also has this feature. -However, `thread_local!` variables (which are restricted to a single thread) are effectively global for the thread in which they are defined, and may have a non-constant constructor and destructor. -

    Other Languages

    ### How can I implement something like C's `struct X { static int X; };` in Rust? @@ -765,10 +789,12 @@ Converting a C-style enum to an integer can be done with a simple `as` expressio Converting in the other direction can be done with a `match` statement, which maps different numeric values to different potential values for the enum. -### Why does Rust not have an ABI like C does, and why do I have to annotate things with extern? +### Why does Rust not have a stable ABI like C does, and why do I have to annotate things with extern? Committing to an ABI is a big thing, and can limit potentially advantageous language changes in the future. Given that Rust only hit 1.0 in May of 2015, it is still too early to make a commitment as big as a stable ABI. This does not mean that one won't happen in the future, though. +The `extern` keyword allows Rust to use specific ABI's, such as the well-defined C ABI, for interop with other languages. + ### Can Rust code call C code? Yes. Calling C code from Rust is simple and exactly as efficient as calling C code from C. @@ -779,7 +805,7 @@ Yes. The Rust code has to be exposed via an `extern` declaration, which makes it ### I already write perfect C++. What does Rust give me? -Modern C++ has made a lot of strides to being a safe and comfortable programming language, but it's not perfect, and it's still very easy to do things unsafely. This is something the C++ core developers are working to overcome, but C++ is limited by a long history that predates a lot of the ideas they are now trying to implement. +Modern C++ includes many features that make writing safe and correct code less error-prone, but it's not perfect, and it's still easy to introduce unsafety. This is something the C++ core developers are working to overcome, but C++ is limited by a long history that predates a lot of the ideas they are now trying to implement. Rust was designed from day one to be a safe systems programming language, which means it's not limited by historic design decisions that make getting safety right in C++ so complicated. In C++, safety is achieved by careful personal discipline, and is very easy to get wrong. In Rust, safety is the default. @@ -801,7 +827,7 @@ The simplest way is to interoperate through C. Both Rust and C++ provide a [fore ### Does Rust have C++-style constructors? -No. Functions can serve the same purpose as constructors without adding any language complexity. The usual name for the constructor-equivalent function in Rust is `new()`, although this is just a social norm rather than a language rule. The `new()` function in fact is just like any other function. An example of it looks like so: +No. Functions serve the same purpose as constructors without adding language complexity. The usual name for the constructor-equivalent function in Rust is `new()`, although this is just a convention rather than a language rule. The `new()` function in fact is just like any other function. An example of it looks like so: ```rust struct Foo { @@ -835,18 +861,16 @@ In Swift, `?` is used to indicate an optional value. This is already done by `Op ### How are Go and Rust similar, and how are they different? -Rust and Go have substantially different design goals, and so differ substantially. The following differences are not the only ones (which are too numerous to list), but are a few of the more important ones: +Rust and Go have substantially different design goals. The following differences are not the only ones (which are too numerous to list), but are a few of the more important ones: - Rust is lower level than Go, comparable with C and C++. It provides access to memory management primitives that do not exist in Go (which has a garbage collector) - Rust's focus is on ensuring safety and efficiency while also providing high-level affordances, while Go's is on being a small, simple language which compiles quickly and can work nicely with a variety of tools - Rust has strong support for generics, which Go does not - Rust has strong influences from the world of functional programming, including a type system which draws from Haskell's typeclasses. Go has a simpler type system, using interfaces for basic generic programming -Rust is probably not the best choice in every situation. If you're considering using either Rust or Go for a project it's probably best to try out both languages a bit and make an informed decision rather than base your decision on a small comparison of the two. - ### `gofmt` is great. Where's `rustfmt`? -`rustfmt` is [right here](https://github.com/nrc/rustfmt/), and is being actively developed to make reading Rust code as easy and predictable as possible. +`rustfmt` is [right here](https://github.com/rust-lang-nursery/rustfmt), and is being actively developed to make reading Rust code as easy and predictable as possible. ### How do Rust traits compare to Haskell typeclasses? @@ -870,7 +894,7 @@ You can report issues in the Rust documentation on the Rust compiler [issue trac When you use `cargo doc` to generate documentation for your own project, it also generates docs for the active dependency versions. These are put into the `target/doc` directory of your project. Use `cargo doc --open` to open the docs after building them, or just open up `target/doc/index.html` yourself after building the docs. -

    Project

    +

    The Rust Project

    ### What is this project's goal? @@ -928,11 +952,11 @@ There are several ways. You can: ### Why has Rust changed so much over time? -Rust started with a goal of creating a safe but usable systems programming language. In pursuit of this goal it explored a lot of ideas, some of which it kept (lifetimes, traits) while others were discarded (the typestate system). Also, in the run up to 1.0 a lot of the standard library was rewritten as early designs were updated to best use Rust's features and provide quality, consistent cross-platform APIs. +Rust started with a goal of creating a safe but usable systems programming language. In pursuit of this goal it explored a lot of ideas, some of which it kept (lifetimes, traits) while others were discarded (the typestate system, green threading). Also, in the run up to 1.0 a lot of the standard library was rewritten as early designs were updated to best use Rust's features and provide quality, consistent cross-platform APIs. ### How does Rust language versioning work? -Rust's language versioning follows Semver, with backwards incompatible changes of stable APIs only allowed in minor versions if those changes fix compiler bugs, patch safety holes, or change type inference to require additional annotation. +Rust's language versioning follows [SemVer](http://semver.org/), with backwards incompatible changes of stable APIs only allowed in minor versions if those changes fix compiler bugs, patch safety holes, or change type inference to require additional annotation. Rust maintains three "release channels": stable, beta, and nightly. Stable and beta are updated every six weeks, with the current nightly becoming the new beta, and the current beta becoming the new stable. Language and standard library features marked unstable or hidden behind feature gates may only be used on the nightly channel. @@ -940,7 +964,7 @@ For details, read the Rust blog post ["Stability as a Deliverable."](http://blog ### Can I use unstable features in the beta or stable channel? -No, you cannot. Rust works hard to provide strong guarantees about the stability of the APIs provided on the beta and stable channels. When something is unstable, it means that we can't provide those guarantees for it yet, and don't want people relying on it staying the same. This gives us the opportunity to try changes in the wild on the nightly channel, while still maintaining strong guarantees for people seeking stability. +No, you cannot. Rust works hard to provide strong guarantees about the stability of the features provided on the beta and stable channels. When something is unstable, it means that we can't provide those guarantees for it yet, and don't want people relying on it staying the same. This gives us the opportunity to try changes in the wild on the nightly channel, while still maintaining strong guarantees for people seeking stability. Things stabilize all the time, and the beta and stable channels update every six weeks. If you're waiting for a feature to be available without using the nightly channel, you can locate its tracking issue by checking the [`B-unstable`](https://github.com/rust-lang/rust/issues?q=is%3Aissue+is%3Aopen+tracking+label%3AB-unstable) tag on the issue tracker. From 8b3265fdc4e246b4c83a5d32472a4f70f34960e3 Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Sun, 20 Dec 2015 12:18:48 -0800 Subject: [PATCH 23/94] Fix alignment of operator table in FAQ --- css/style.css | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/css/style.css b/css/style.css index bfa665f92..69f7e8829 100644 --- a/css/style.css +++ b/css/style.css @@ -484,3 +484,7 @@ ul.laundry-list { -moz-columns: 150px 3; columns: 150px 3; } + + .faq table { + margin-left: 8rem; + } \ No newline at end of file From c5b06defcd5e7ab15113b003a3919947b9a2277e Mon Sep 17 00:00:00 2001 From: Eric Findlay Date: Sat, 17 Oct 2015 19:48:19 +0900 Subject: [PATCH 24/94] Added contribution page --- contributions.md | 177 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 177 insertions(+) create mode 100644 contributions.md diff --git a/contributions.md b/contributions.md new file mode 100644 index 000000000..d26fe032c --- /dev/null +++ b/contributions.md @@ -0,0 +1,177 @@ +--- +layout: default +title: How To Contribute +--- + +# Contributing to Rust + +If you're learning Rust, you've no doubt been amazed at how awesome +the language is and will be keen to write more Rust code. Hopefully, +you'll also want to make a meaningful contribution to the community. +If you're not sure how best to do that, then hopefully this page will +help. Most of this page is filled with links to lists of issues to +help you find something to work on. There are issues on the Rust +project itself, a number of supporting projects, and some projects +which are large users of Rust. + +Writing code isn't the only way to make a meaningful contribution. +Writing tests and documentation is how many people get started and is +really useful. There are links to these kind of issues too. Likewise +finding bugs and filing issues in any of the projects linked here is +very much appreciated. As a reminder, all contributors are expected to +follow our [Code of Conduct][coc]. + +[coc]: https://www.rust-lang.org/conduct.html + +## Finding Something to Work On + +#### Issues + +If you're looking for [issues][rust_issues] on the Rust repo +and want something easy-ish to start with, look for the [E-easy][e_easy_issues] +or [E-mentor][e_mentor_issues] labels. + +Contributors with sufficient permissions on the Rust repo can help by +adding labels to triage issues: + +- **Yellow A-prefixed** labels state which area of the project an + issue relates to. +- **Magenta B-prefixed** labels identify bugs which belong elsewhere. +- **Green E-prefixed** labels explain the level of experience + necessary to fix the issue. +- **Red I-prefixed** labels indicate the importance of the issue. The + I-nominated label indicates that an issue has been nominated for +prioritizing at the next triage meeting. +- **Orange P-prefixed** labels indicate a bug's priority. These labels + are only assigned during triage meetings, and replace the +I-nominated label. +- **Blue T-prefixed** bugs denote which team the issue belongs to. +- **Dark blue beta-** labels track changes which need to be backported + into the beta branches. +- **Purple** metabug labels mark lists of bugs collected by other + categories. + +[rust_issues]: https://github.com/rust-lang/rust/issues +[e_easy_issues]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy +[e_mentor_issues]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy+label%3AE-mentor + +#### The Rust compiler + +The compiler is part of the [main repo][main_repo], which also +includes the standard library crates and a whole bunch of supporting +code. For questions about the compiler, there is the +[#rustc][rustc_irc] IRC channel. Compiler errors (ICE for 'internal +compiler errors') can be searched for in issues using the +[I-ICE][i_ice_issues] label. These are usually good bugs to start with +because it's easy to know when you've fixed them, and they're often +relatively self-contained. If you're interested in parsing, macros, +syntactic stuff, the [parsing][parsing_issues] label and the +[macro][macro_issues] label are a good places to start. + +[main_repo]: https://github.com/rust-lang +[rust_irc]: irc://moznet/rustc +[i_ice_issues]: https://github.com/rust-lang/rust/labels/I-ICE +[parsing_issues]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-parser +[macro_issues]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-parser+label%3AA-macros + +#### Standard Libraries + +[Libstd][libstd], [libcollections][libcollections], +[liballoc][liballoc] and [libcore][libcore] are the main library +crates. These all appear to users as if they are part of libstd, the +standard library. These tend to be very fundamental libraries - +built-in types, low level IO and concurrency, allocation, essential +collections, and so forth. You should join [#rust-libs][libs_irc] if +you are interested in contributing to the Rust libraries. + +[libstd]: https://github.com/rust-lang/rust/tree/master/src/libstd +[libcollections]: https://github.com/rust-lang/rust/tree/master/src/libcollections +[liballoc]: https://github.com/rust-lang/rust/tree/master/src/liballoc +[libcore]: https://github.com/rust-lang/rust/tree/master/src/libcore +[libs_irc]: irc://moznet/rust-libs + +#### Cargo + +[Cargo][cargo_issues] is Rust's package manager. + +[cargo_issues]: https://github.com/rust-lang/cargo/issues + +#### Tests + +Contributing tests is extremely valuable to the Rust project. For the +compiler and standard libraries, there are unit tests (usually) +embedded in the source code and regression tests in the +[src/tests][tests] directory. There is a list of issues which have +(probably) been fixed, but still need a test. Nearly any other project +will be extremely welcoming of new tests too. Writing test cases is a +great way to begin to understand a new project and get started +contributing. + +[test]: https://github.com/rust-lang/rust/tree/master/src/test + +#### Checking Older Bugs + +Sometimes, an issue will stay open, even though the bug has been +fixed. And sometimes, the original bug may go stale because something +has changed in the meantime. It can be helpful to go through older bug +reports and make sure that they are still valid. Load up an older +issue, double check that it's still true, and leave a comment letting +us know if it is or is not. The [least recently updated][lru_issues] +sort is good for finding issues like this. + +[lru_issues]: https://github.com/rust-lang/rust/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-asc + +#### Documentation + +Documentation is never good enough and there's never enough of it. +Writing docs is a really valuable way to contribute to open source +projects. Many aspects of the docs don't require super-deep knowledge, +especially if they're aimed at newcomers. It's also a great way to +learn more about the language or specific libraries. + +- [The Book][rustbook_issues] The main guide to learning Rust. +- [Rust Documentation][rustdoc_issues] +- [Rust by Example][rust_by_example_issues] +- [Rust for C++ Programmers][rust_for_cpp_issues] A tutorial aimed +at experienced C++ programmers coming to Rust. + +[rustbook_issues]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-book +[rustdoc_issues]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-docs +[rust_by_example_issues]: https://github.com/rust-lang/rust-by-example/issues +[rust_for_cpp_issues]: https://github.com/nrc/r4cppp/issues + +#### Tools + +Tools play a huge part in the success of a language. Rust has some +great tool support, in particular with debugging and package +management, but we need much more. + +- [cargo](https://github.com/rust-lang/cargo/issues) Rust's package manager and build system. +- [rustdoc](https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-rustdoc) + Produces documentation for the official libraries and user projects. +- [racer](https://github.com/phildawes/racer) Code completion. +- [rustfmt](https://github.com/nrc/rustfmt) Code formatting. +- [multirust](https://github.com/brson/multirust/issues) For managing + multiple installations of the Rust toolchain. +- [homu](https://github.com/barosl/homu/issues) Acts as a gatekeeper for commits. + +#### Other Contributions + +Try [Github Trending][trending] for currently active Rust projects. +There are a number of other ways to contribute to Rust that don't deal +directly with the Rust repository. + +- Answer questions in [#rust][rust_irc], on the [Rust Forum][forum] or + on [Stack Overflow][stack_overflow]. +- Participate in the [RFC process][rfcs]. +- Find a [requested community library][requested], build it, and + publish it to [Crates.io][crates]. Easier said than done, +but very, very valuable! + +[trending]: https://github.com/trending?l=rust +[rust_irc]: irc://moznet/rust +[forum]: https://users.rust-lang.org/ +[stack_overflow]: http://stackoverflow.com/questions/tagged/rust +[rfcs]: https://github.com/rust-lang/rfcs +[requested]: https://github.com/rust-lang/rfcs/labels/A-community-library +[crates]: http://crates.io From 8fb7d957787b7f62177b5bc59a78d7ab2048f13e Mon Sep 17 00:00:00 2001 From: Eric Findlay Date: Wed, 28 Oct 2015 11:26:17 +0900 Subject: [PATCH 25/94] Added "Getting Started" to contribution.md --- contributions.md | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/contributions.md b/contributions.md index d26fe032c..444dde1ba 100644 --- a/contributions.md +++ b/contributions.md @@ -23,16 +23,11 @@ follow our [Code of Conduct][coc]. [coc]: https://www.rust-lang.org/conduct.html -## Finding Something to Work On +## Getting Started By Scanning Through Issues -#### Issues - -If you're looking for [issues][rust_issues] on the Rust repo -and want something easy-ish to start with, look for the [E-easy][e_easy_issues] -or [E-mentor][e_mentor_issues] labels. - -Contributors with sufficient permissions on the Rust repo can help by -adding labels to triage issues: +One way to get started is to scan through [issues][rust_issues] on +the Rust repo. To start with, look for the [E-easy][e_easy_issues] or +[E-mentor][e_mentor_issues] labels. - **Yellow A-prefixed** labels state which area of the project an issue relates to. @@ -51,10 +46,15 @@ I-nominated label. - **Purple** metabug labels mark lists of bugs collected by other categories. +Contributors with sufficient permissions on the Rust repo can help by +adding labels to triage issues. + [rust_issues]: https://github.com/rust-lang/rust/issues [e_easy_issues]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy [e_mentor_issues]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy+label%3AE-mentor +## Getting Started by Topic + #### The Rust compiler The compiler is part of the [main repo][main_repo], which also From 47ba37791888b517498311ddc31c8beb97dc1429 Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Mon, 2 Nov 2015 15:33:57 -0800 Subject: [PATCH 26/94] Various changes to contributions.html --- contributions.md | 214 ++++++++++++++++++++++++++--------------------- 1 file changed, 117 insertions(+), 97 deletions(-) diff --git a/contributions.md b/contributions.md index 444dde1ba..410b20c0b 100644 --- a/contributions.md +++ b/contributions.md @@ -8,108 +8,65 @@ title: How To Contribute If you're learning Rust, you've no doubt been amazed at how awesome the language is and will be keen to write more Rust code. Hopefully, you'll also want to make a meaningful contribution to the community. -If you're not sure how best to do that, then hopefully this page will -help. Most of this page is filled with links to lists of issues to -help you find something to work on. There are issues on the Rust -project itself, a number of supporting projects, and some projects -which are large users of Rust. - -Writing code isn't the only way to make a meaningful contribution. -Writing tests and documentation is how many people get started and is -really useful. There are links to these kind of issues too. Likewise -finding bugs and filing issues in any of the projects linked here is -very much appreciated. As a reminder, all contributors are expected to +If you're not sure how best to do that, then this page will +help. + +**Just want to report a bug in Rust?** [Follow the Rust bug reporting +guide][bugs]. Thanks in advance! + +[bugs]: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#bug-reports + +Rust is an expansive system of projects, some officially maintained +within the [rust-lang] organization on GitHub, but with many +increasingly-important efforts driven from without by its enthusiastic +community. Newcomers will be interested in [an overview of the +organization, processes, and policies of The Rust Project][dev_proc] +and the project's [CONTRIBUTING.md] file, which explains the specifics +of contributing to [rust-lang/rust]. + +There are many ways to contribute to the success of Rust: filing, +triaging and fixing bugs; writing documentation and tests; partipating +in the the design of the language and standard libraries through the +RFC process; improving compile-time and run-time performance; +spreading the tendrils of the Rust community ever-outward. + +This guide focuses on a few avenues for the new contributor: + +* [Bugs, triage, and maintenance](#bugs). Finding issues to fix, + triaging, adding test cases. +* [Documentation](#doc). Not just official documentation, but also + for crates, blog posts, and other unofficial sources. +* [Community building](#comm). Expanding the reach of Rust, and + maintaining its excellence. +* [Tooling, IDEs, and infrastructure](#tool). The hard work of making + Rust accessible to programmers of all kinds. +* [Language and compiler](#comp). Language design, feature + implementation, performance improvement. +* [Libraries](#lib). Including the standard library, but also the + equally-important unofficial crates that make Rust usable. + +As a reminder, all contributors are expected to follow our [Code of Conduct][coc]. +[dev_proc]: dev_process.html +[rust-lang]: https://github.com/rust-lang +[rust-lang/rust]: https://github.com/rust-lang/rust +[CONTRIBUTING.md]: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md [coc]: https://www.rust-lang.org/conduct.html -## Getting Started By Scanning Through Issues - -One way to get started is to scan through [issues][rust_issues] on -the Rust repo. To start with, look for the [E-easy][e_easy_issues] or -[E-mentor][e_mentor_issues] labels. - -- **Yellow A-prefixed** labels state which area of the project an - issue relates to. -- **Magenta B-prefixed** labels identify bugs which belong elsewhere. -- **Green E-prefixed** labels explain the level of experience - necessary to fix the issue. -- **Red I-prefixed** labels indicate the importance of the issue. The - I-nominated label indicates that an issue has been nominated for -prioritizing at the next triage meeting. -- **Orange P-prefixed** labels indicate a bug's priority. These labels - are only assigned during triage meetings, and replace the -I-nominated label. -- **Blue T-prefixed** bugs denote which team the issue belongs to. -- **Dark blue beta-** labels track changes which need to be backported - into the beta branches. -- **Purple** metabug labels mark lists of bugs collected by other - categories. - -Contributors with sufficient permissions on the Rust repo can help by -adding labels to triage issues. - -[rust_issues]: https://github.com/rust-lang/rust/issues -[e_easy_issues]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy -[e_mentor_issues]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy+label%3AE-mentor - -## Getting Started by Topic - -#### The Rust compiler - -The compiler is part of the [main repo][main_repo], which also -includes the standard library crates and a whole bunch of supporting -code. For questions about the compiler, there is the -[#rustc][rustc_irc] IRC channel. Compiler errors (ICE for 'internal -compiler errors') can be searched for in issues using the -[I-ICE][i_ice_issues] label. These are usually good bugs to start with -because it's easy to know when you've fixed them, and they're often -relatively self-contained. If you're interested in parsing, macros, -syntactic stuff, the [parsing][parsing_issues] label and the -[macro][macro_issues] label are a good places to start. - -[main_repo]: https://github.com/rust-lang -[rust_irc]: irc://moznet/rustc -[i_ice_issues]: https://github.com/rust-lang/rust/labels/I-ICE -[parsing_issues]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-parser -[macro_issues]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-parser+label%3AA-macros - -#### Standard Libraries - -[Libstd][libstd], [libcollections][libcollections], -[liballoc][liballoc] and [libcore][libcore] are the main library -crates. These all appear to users as if they are part of libstd, the -standard library. These tend to be very fundamental libraries - -built-in types, low level IO and concurrency, allocation, essential -collections, and so forth. You should join [#rust-libs][libs_irc] if -you are interested in contributing to the Rust libraries. - -[libstd]: https://github.com/rust-lang/rust/tree/master/src/libstd -[libcollections]: https://github.com/rust-lang/rust/tree/master/src/libcollections -[liballoc]: https://github.com/rust-lang/rust/tree/master/src/liballoc -[libcore]: https://github.com/rust-lang/rust/tree/master/src/libcore -[libs_irc]: irc://moznet/rust-libs - -#### Cargo - -[Cargo][cargo_issues] is Rust's package manager. - -[cargo_issues]: https://github.com/rust-lang/cargo/issues - -#### Tests + +## Bugs, triage, and maintenance -Contributing tests is extremely valuable to the Rust project. For the -compiler and standard libraries, there are unit tests (usually) -embedded in the source code and regression tests in the -[src/tests][tests] directory. There is a list of issues which have -(probably) been fixed, but still need a test. Nearly any other project -will be extremely welcoming of new tests too. Writing test cases is a -great way to begin to understand a new project and get started -contributing. +The day-to-day maintenance of the project revolves around Rust's +[issue tracker] and [pull requests], and more help is always +needed. -[test]: https://github.com/rust-lang/rust/tree/master/src/test +The most basic way to get started contributing to Rust is to look for +the [E-easy][e_easy_issues] or [E-mentor][e_mentor_issues] +labels. These are meant to be approachable for new Rust programmers. -#### Checking Older Bugs +Rust is always in need of people to [triage] issues: reproduce bugs, +minimize test cases, apply labels. Sometimes, an issue will stay open, even though the bug has been fixed. And sometimes, the original bug may go stale because something @@ -119,9 +76,30 @@ issue, double check that it's still true, and leave a comment letting us know if it is or is not. The [least recently updated][lru_issues] sort is good for finding issues like this. +While Rust has an [extensive test suite][test] there is always more to +test. The [E-needstest] label indicates issues that are thought to be +fixed but don't have tests. Writing test cases is a great way to begin +to understand a new project and get started contributing. For those +especially interested in testing, there are usually *entirely new +classes* of tests that need to be implemented, and asking #rust-internals +what needs to be tested can be fruitful. + +Once you've found your way around the project and have created a few +pull requests in a particular area of the project, consider actively +reviewing others' pull requests: reviewership is a rare skill and good +reviewers are always appreciated. + [lru_issues]: https://github.com/rust-lang/rust/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-asc +[issue tracker]: https://github.com/rust-lang/rust/issues +[pull requests]: https://github.com/rust-lang/rust/pulls +[e_easy_issues]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy +[e_mentor_issues]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy+label%3AE-mentor +[triage]: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#issue-triage +[E-needstest]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-needstest +[test]: https://github.com/rust-lang/rust-wiki-backup/blob/master/Note-testsuite.md -#### Documentation + +## Documentation Documentation is never good enough and there's never enough of it. Writing docs is a really valuable way to contribute to open source @@ -140,7 +118,12 @@ at experienced C++ programmers coming to Rust. [rust_by_example_issues]: https://github.com/rust-lang/rust-by-example/issues [rust_for_cpp_issues]: https://github.com/nrc/r4cppp/issues -#### Tools + + +## Community building + + +## Tooling, IDEs, and infrastructure Tools play a huge part in the success of a language. Rust has some great tool support, in particular with debugging and package @@ -155,6 +138,43 @@ management, but we need much more. multiple installations of the Rust toolchain. - [homu](https://github.com/barosl/homu/issues) Acts as a gatekeeper for commits. + +## Libraries + +[Libstd][libstd], [libcollections][libcollections], +[liballoc][liballoc] and [libcore][libcore] are the main library +crates. These all appear to users as if they are part of libstd, the +standard library. These tend to be very fundamental libraries - +built-in types, low level IO and concurrency, allocation, essential +collections, and so forth. You should join [#rust-libs][libs_irc] if +you are interested in contributing to the Rust libraries. + +[libstd]: https://github.com/rust-lang/rust/tree/master/src/libstd +[libcollections]: https://github.com/rust-lang/rust/tree/master/src/libcollections +[liballoc]: https://github.com/rust-lang/rust/tree/master/src/liballoc +[libcore]: https://github.com/rust-lang/rust/tree/master/src/libcore +[libs_irc]: irc://moznet/rust-libs + + +## Language and compiler + +The compiler is part of the [main repo][main_repo], which also +includes the standard library crates and a whole bunch of supporting +code. For questions about the compiler, there is the +[#rustc][rustc_irc] IRC channel. Compiler errors (ICE for 'internal +compiler errors') can be searched for in issues using the +[I-ICE][i_ice_issues] label. These are usually good bugs to start with +because it's easy to know when you've fixed them, and they're often +relatively self-contained. If you're interested in parsing, macros, +syntactic stuff, the [parsing][parsing_issues] label and the +[macro][macro_issues] label are a good places to start. + +[main_repo]: https://github.com/rust-lang +[rust_irc]: irc://moznet/rustc +[i_ice_issues]: https://github.com/rust-lang/rust/labels/I-ICE +[parsing_issues]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-parser +[macro_issues]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-parser+label%3AA-macros + #### Other Contributions Try [Github Trending][trending] for currently active Rust projects. From 0eb30faf96c668f64b252ece85933d0238e39bd7 Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Tue, 3 Nov 2015 12:11:51 -0800 Subject: [PATCH 27/94] Add contributing to navbar --- _layouts/default.html | 3 +++ 1 file changed, 3 insertions(+) diff --git a/_layouts/default.html b/_layouts/default.html index 0ee1e5f2a..eaebf542e 100644 --- a/_layouts/default.html +++ b/_layouts/default.html @@ -49,6 +49,9 @@
  • Community
    • +
  • + Contributing +
  • Legal
    • From def9c2a7a3d3d35929dde5779e47b95eae462b51 Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Tue, 3 Nov 2015 13:04:26 -0800 Subject: [PATCH 28/94] Massively expand the contributing page --- _layouts/default.html | 2 +- community.md | 8 +- contribute.md | 454 ++++++++++++++++++++++++++++++++++++++++++ contributions.md | 197 ------------------ 4 files changed, 459 insertions(+), 202 deletions(-) create mode 100644 contribute.md delete mode 100644 contributions.md diff --git a/_layouts/default.html b/_layouts/default.html index eaebf542e..50ed2f934 100644 --- a/_layouts/default.html +++ b/_layouts/default.html @@ -50,7 +50,7 @@ Community
  • - Contributing + Contributing
  • Legal diff --git a/community.md b/community.md index d38288dbb..de72717e2 100644 --- a/community.md +++ b/community.md @@ -129,6 +129,7 @@ socialize with other people with a similar interest. Meetings are usually held monthly and very informal. Meetings are open to everyone. There is a global [calendar][calendar] for keeping up with Rust events. +Contact the [community team][community_team] to add your own. [user_group]: ./user_groups.html [calendar]: https://www.google.com/calendar/embed?src=apd9vmbc22egenmtu5l6c5jbfc@group.calendar.google.com @@ -179,12 +180,11 @@ help get you started. [community_team]: https://www.rust-lang.org/team.html#Community [mod_team]: https://www.rust-lang.org/team.html#Moderation + ## Rust Development Rust has had over [1,200 different contributors][authors], a number that grows -every single week. We'd love for you to join that list! If you aren't sure what -to work on or how to get started, take a look at our -[how to contribute][contribute] page. +every single week. [We'd love for you to join that list][contribute]! As mentioned above, the [Rust Internals Forum][internals_forum] is dedicated to discussing the design and implementation of Rust. A lot of discussion also @@ -203,7 +203,7 @@ team business, including the progression of proposals through the RFC and implementation process. [authors]: https://github.com/rust-lang/rust/blob/master/AUTHORS.txt -[contribute]: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md +[contribute]: contribute.html [github]: https://github.com/rust-lang/rust [rfcs]: https://github.com/rust-lang/rfcs [team_reports]: https://github.com/rust-lang/subteams diff --git a/contribute.md b/contribute.md new file mode 100644 index 000000000..6df1f68a8 --- /dev/null +++ b/contribute.md @@ -0,0 +1,454 @@ +--- +layout: default +title: Contributing to Rust · The Rust Programming Language +--- + +# Contributing to Rust + +You've started learning Rust. You love it, and you want to be a part +of it. If you're not sure how to get involved, then this page +will help. + +**Just want to report a bug in Rust?** [Follow the bug reporting +guide][bugs]. Thanks in advance! + +Rust is an expansive system of projects, the most prominent of which +are maintained by the [The Rust Project Developers][devs] in [the +rust-lang organization on GitHub][rust-lang]. Newcomers may be +interested in [an overview of the organization, processes, and +policies of The Rust Project][dev_proc] and the project's +[CONTRIBUTING.md] file, which explains the specifics of contributing +to [rust-lang/rust]. + +There are many ways to contribute to the success of Rust. +This guide focuses on a few avenues for the new contributor: + +* [Finding, triaging and fixing issues](#bugs). The basic work + of maintaining a large and active project like Rust. +* [Documentation](#docs). Not just official documentation, but also + for crates, blog posts, and other unofficial sources. +* [Community building](#community). Helping your fellow Rustacean, + and expanding the reach of Rust. +* [Tooling, IDEs and infrastructure](#tools). There's so much + to do here. +* [Libraries](#libs). Rust's suitability for any particular task + is mostly dependent on the quality libraries that exist. +* [Language, compiler and the standard library](#compiler). Language design, feature implementation, performance improvement. + +If you need additional guidance ask on [#rust-internals] or +[internals.rust-lang.org]. + +We pride ourselves on maintaining civilized discourse, and to that end +contributors are expected to follow our [Code of Conduct][coc]. If you +have questions about this please inquire with the [community team]. + + + + +## Finding, triaging and fixing issues + +The day-to-day maintenance of the project revolves around Rust's +[issue tracker] and [pull requests][PR], and more help is always +needed. The most basic way to get started contributing to Rust is to +look for the [E-easy] or [E-mentor] labels. These are meant to be +approachable for new Rust programmers. + +On `E-mentor` issues an experienced Rust developer has volunteered in +the comments to mentor you through the solving the issue and +[submitting the fix GitHub pull request][pull]. Contact them about the +issue, on the issue tracker by [@mentioning] their name, on IRC, or +through email. Note that Rust developers get a lot of notifications +and it is easy to miss some; don't hesitate to hunt them down by +whatever means necessary! + +Other projects in Rust maintain similar entry-level tasks, including +the web browser [Servo], the HTTP library [hyper], the +source-formatter [rustfmt], and the lint collection [clippy]. + +While Rust has an [extensive test suite][test] there is always more to +test. The [E-needstest] label indicates issues that are thought to be +fixed but don't have tests. Writing test cases is a great way to +understand a new project and get started contributing. + +Rust is always in need of people to [triage] issues: reproduce bugs, +minimize test cases, apply labels, close resolved issues. Note that +you'll need elevated GitHub permissions to apply labels, but this is +easy to obtain for somebody with a bit of experience in the +project. Ask a [team member][team]. + +Once you've found your way around the project and have created a few +pull requests in a particular area, consider reviewing others' pull +requests: good reviewership is a rare skill and always appreciated. No +prior permission is needed &emdash; just start constructively and politely +commenting on pull requests that interest you. If you want training +on conducting good code reviews [read this guide][reviews]. + + + + +## Documentation + +Documentation is never good enough and there's never enough of it, +writing documentation is a valuable way to contribute. Many aspects of +Rust's documentation don't require deep knowledge to improve, and +writing, reviewing, and editing documentation are great ways to learn +Rust. Furthermore, improvements to documentation are easy to identify +and limitless. Don't like the way something reads? Discover some +information that wasn't documented? Your pull request will be +gleefully embraced. + +***The most impactful documentation you can write is [for the crates +that make up the Rust ecosystem][crate_docs]***. While the in-tree +documentation is relatively complete, the same is not yet true for +[many of the popular crates and tools][awesome-rust] that Rust +programmers interact with every day. Contributing API documentation to +a popular Rust project will earn you the enduring love of its maintainer. + +[The Book] is the primary documentation for Rust, maintained in the +main repository. It has its own issue label, [A-book][book_issues] and +is continually being refined. Other documentation in the main +repository include [The Rust Reference], the [standard library API +documentation][std], [The Rustonomicon] (a guide to using `unsafe` +correctly). The [Rust Style Guidelines] are so incomplete they are not +linked prominently; an ambitious contributor can make much headway +there. The [error index][err] provides extended explanations of the +errors produced by the compiler. As new errors are added this +documentation [must be maintained][err-issue], so there always +errors not reflected in the index to be added. Most in-tree +documentation lives in the [src/doc] directory. To contribute simply +edit it and submit a pull request. These are all covered by the +[A-docs] label on the issue tracker. + +A great deal of important Rust documentation does not live in the main +repository, or is not maintained by the project, but is still +critically important to Rust's success. Examples of excellent Rust +documentation that is actively developed and in need of contributors +include [Rust By Example], [Rust Design Patterns], and [rust-rosetta]. +For other existing documentation projects to contribute to see [rust-learning]. + +Meet other Rust documentarians in [#rust-docs]. + + + + +## Community building + +Help newbies, spread the word, meet interesting people. Make Rust the +shining example of open source development that we all want it to be. + +Keep an eye on the [#rust-beginners] channel. This is where we direct +new Rust programmers to ask for help, and it is vital when they do +that they receive prompt, accurate, and courteous responses. Likewise, +[Stack Overflow], [users.rust-lang.org], and [/r/rust], are all forums +where Rust programers commonly look for assistance. If you want +training on answering programmers' questions [read this +guide][helpful]. + +If you are already experienced in some area of the project, please +look out for potential [E-easy] bugs. When you see an +easy issue on the bug tracker that you know how to fix, write up a +description of the fix and tag it with E-easy. Note that what is +obvious to you is not obvious to a new Rust contributor, and its +important to describe the problem and the solution clearly. It is +thus also helpful to triage E-easy bugs for poor descrptions and +improve them. + +Experienced developers who are patient and communicate clearly should +consider [mentoring new contributors][mentor]. Tag easy issues with +[E-mentor] and mention in a comment that you will mentor. Expect people +to contact you about the issue, and attempt to respond promptly. + +Maintaining entry-level tasks is good not only for The Rust Project +itself but all projects. If your project has a consistent supply of +entry-level tasks you might institute such a program +yourself. ***Curating entry-level tasks is one of the most effective +methods of bringing new programmers into the project***. + +Talk about what you are working on in the weekly "what's everyone +working on this week" threads on [/r/rust] and [users.rust-lang.org], +and indicate what you need help with. These are great starting points +for collaboration. + +Advocate Rust in your own local community. Rust [user groups] and [events] +are a unique and exciting part of the Rust experience: there are so +many, and they are everywhere! If you haven't been yet, go and enjoy +new experiences. If there is nothing Rusty going on near you then +consider organizing something. You can poll for interest and announce +events on [/r/rust] or [users.rust-lang.org]. Contact the [community +team] to put events on the calendar, and thus be announced on [This +Week in Rust]. + +Remember as you are advocating Rust though to be considerate of +others' views — not everybody is going to be receptive to Rust, and +that's just fine. + +Meet other Rust community builders in [#rust-community]. + + + + +## Tooling, IDEs, and infrastructure + +Tools play a huge part in the success of a language, and there is a +great deal left to implement. ***A major focus of Rust development now +is [improving the IDE experience][ides]***. This involves work +throughout the Rust stack, from the compiler itself through your +favorite IDE. Follow the link for more information. + +Both Cargo, the Rust package manager, and rustdoc, +the Rust documentation generator, while full-featured and functional, +suffer from a lack of developers. Rustdoc has many open issues, under +the main repository's [A-rustdoc] label. They are mostly bugs and +contributing is a matter of fixing the bug and submitting a pull +request. Cargo has [its own repository and issues][Cargo], and those +interested in contributing might want to introduce themselves in +[#cargo]. + +Although Rust can be run under both the gdb and lldb debuggers with +limited success, there are still many cases where debugging does not +work as expected. The [A-debuginfo] issue tracks these. + +For ideas for more tooling projects to contributo to see +[awesome-rust]. + +There are often other tooling projects of interest just waiting for +the right people to come along and implement them. Discuss with other +Rust tooling enthusiasts in [#rust-tools]. + + +## Libraries + +If you want to contribute to Rust by writing volumes of Rust code, +then libraries are where it's at: since Rust is a young language, +there are many types of libraries that either do not exist yet +or are incomplete and in need of improvement or competition. + +Deciding what to write that will have impact and be fun is a common +difficulty. Here are some ideas: + +* Read and participate in the weekly "what's everyone working on + this week" threads on [/r/rust] and [users.rust-lang.org]. These are + packed with exciting announcements from other Rust programmers in + need of collaborators. +* Familiarize yourself with the best Rust libraries through + [awesome-rust] and [libs.rs]. +* Some larger projects, including the web browser [Servo], the HTTP + library [hyper], the source-formatter [rustfmt], and the lint + collection [clippy], tag issues with 'easy' labels for new + contributors. +* Get involved with one of the active Rust-oriented GitHub + organizations, such as [PistonDevelopers], [servo], [redox-os], + [iron], [contain-rs], [hyperium]. It's often easier to find a place + to fit in with these subcommunities, they are in greater need of + help than rust-lang itself, and they are filled with experienced + Rust developers to guide you. +* Help guide libraries from [rust-lang-nursery] into rust-lang proper. + Unfortunately there is not much documentation on what needs to be + done here; ask on [#rust-libs]. +* Inspect the RFC issue tracker for a [requested community + library][requested] and build it. +* Watch [Github Trending][trending] for currently active Rust projects. + +As a library author you will want to be aware of the [best practices +for Rust libraries][lib-prac]. + +Meet other Rust library designers in [#rust-libs]. + + + + +## Language, compiler, and the standard library + +The source code to the compiler and standard library are in the main +repository, and as their maintenance is the primary objective of that +repository, many labels on the issue tracker relate to it. Some of +the more fruitful labels include [A-codegen], for translation of +Rust to LLVM IR; [A-debuginfo], generation of metadata used by debuggers; +[A-diagnostics], the feedback the compiler provides on errors; [A-libs], +issues with the standard library; [A-macros] and [A-syntaxext], both +related to syntax extensions; and [A-typesystem], on the topic of types. + +There is no well-maintained guide to the architecture of the +compiler, but [there is a small overview in-tree][rustc-guide], and +individuals [occassionally blog what they've learned of +rustc][rustc-tour]. The [API documentation for the crates that make up +the compiler][internals-docs] can help with navigating the code, as +can the source code browser [Rust DXR]. The [guide to the Rust test +suite][testsuite] will teach you how to exercise the Rust build system +effectively, as will running [`make tips`][tips] at the command line. + +For the foreseable future, one of the major thrusts of Rust compiler +development is converting its internals from operating directly off +the AST to working with an [intermediate representation called +MIR][mir]. This work is expected to open up many new possibilities by +simplifying the compiler and help is needed to e.g. create a MIR-based +translation pass, add MIR-based optimizations, and implement +incremental compilation. There is yet no single source for information +on work needed here, but ask on [internals.rust-lang.org] or +[#rust-internals] for guidance. + +[It's embarrasing when our compiler crashes][ice] — the +dreaded 'internal compiler error' (ICE). The [I-ICE] label +tracks these, and they are often plentiful. These are usually +good bugs to start with because it's easy to know when you've fixed +them, and they're often relatively self-contained. + +The performance of Rust code is one of its great advantages; and the +performance of the Rust compiler one of its great weaknesses. Any +improvements to either runtime or — especially — compiletime performance +are widely celebrated. The [I-slow] and [A-optimization] labels deal +with runtime performance, and [I-compiletime] with compiletime. We have +a [site that tracks compiletime performance][rustc-perf] on a number +of workloads. The `-Z time-passes` compiler flag can help debug +compiler performance, and Rust code can be profiled with standard +profilers like `perf` on Linux. + +Major new features go through a [Request for Comments (RFC)][rfc] +process, by which the design is agreed upon. Though it is open to all, +it is a social process between developers who already have various +amounts of experience working together, and it is recommended to get +involved slowly — submitting a hasty RFC without understanding +the historical, technical, or social context is an easy way +to make a poor impression and come away disappointed. Read the +aforelinkd readme file to understand best how it all works. Many +ideas have been debated in Rust's history, some rejected, some +postponed until the future, and the RFC [issue tracker][rfc-issues] +catalogs some wishlist ideas that have yet to make headway into the +language. Shortly before an RFC is accepted for implementation it +enters 'final commemnt period', indicated by the [final-comment-period +label on the rust-lang/rfcs repository][rfc-fcp]. Likewise, before a +feature is enabled in the stable compiler (called 'ungating') it +enters [final-comment-period in the rust-lang/rust +repository][issue-fcp]. Both FCPs are critical moments to get involved +and express opinions on the direction of the language, and are +advertised in the weekly subteam reports on [internals.rust-lang.org]. + +Meet other Rust compiler engineers in [#rustc], language +designers in [#rust-lang], and library designers in [#rust-libs]. + + + + +[#cargo]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rustc +[#rust-beginners]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-beginners +[#rust-community]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-community +[#rust-docs]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-docs +[#rust-internals]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-internals +[#rust-lang]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-lang +[#rust-libs]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-libs +[#rust-tools]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-tools +[#rustc]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rustc +[/r/rust]: https://reddit.com/r/rust +[@mentioning]: https://github.com/blog/821 +[A-codegen]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-codegen +[A-debuginfo]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-debuginfo +[A-debuginfo]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-debuginfo +[A-diagnostics]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-diagnostics +[A-docs]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-docs +[A-libs]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-libs +[A-macros]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-macros +[A-optimization]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-optimization +[A-rustdoc]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-rustdoc +[A-syntaxext]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-syntaxext +[A-typesystem]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-typesystem +[CONTRIBUTING.md]: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md +[Cargo]: https://github.com/rust-lang/cargo/issues +[E-easy]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy +[E-mentor]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy+label%3AE-mentor +[E-needstest]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-needstest +[I-ICE]: https://github.com/rust-lang/rust/labels/I-ICE +[I-compiletime]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AI-compiletime +[I-slow]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AI-slow +[PR]: https://github.com/rust-lang/rust/pulls +[PistonDevelopers]: https://github.com/PistonDevelopers +[Rust By Example]: https://github.com/rust-lang/rust-by-example +[Rust DXR]: https://dxr.mozilla.org/rust/source/src +[Rust Design Patterns]: https://github.com/nrc/patterns +[Rust Style Guidelines]: http://doc.rust-lang.org/style/index.html +[Servo]: https://github.com/servo/servo +[Stack Overflow]: http://stackoverflow.com/questions/tagged/rust +[The Book]: http://doc.rust-lang.org/book/index.html +[The Rust Reference]: http://doc.rust-lang.org/reference.html +[The Rustonomicon]: http://doc.rust-lang.org/nomicon/index.html +[This Week in Rust]: http://www.this-week-in-rust.org +[awesome-rust]: https://github.com/kud1ing/awesome-rust +[awesome-rust]: https://github.com/kud1ing/awesome-rust +[book_issues]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-book +[bugs]: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#bug-reports +[clippy]: https://github.com/Manishearth/rust-clippy +[coc]: https://www.rust-lang.org/conduct.html +[community team]: https://www.rust-lang.org/team.html#Community +[contain-rs]: https://github.com/contain-rs +[crate_docs]: https://users.rust-lang.org/t/lets-talk-about-ecosystem-documentation/2791 +[dev_proc]: community.html#rust-development +[devs]: https://github.com/rust-lang/rust/blob/master/AUTHORS.txt +[err-issue]: https://github.com/rust-lang/rust/issues/24407 +[err]: http://doc.rust-lang.org/error-index.html +[events]: https://www.google.com/calendar/embed?src=apd9vmbc22egenmtu5l6c5jbfc@group.calendar.google.com +[helpful]: http://blogs.msmvps.com/jonskeet/2009/02/17/answering-technical-questions-helpfully/ +[hyper]: https://github.com/hyperium/hyper +[hyperium]: https://github.com/hyperium +[ice]: https://users.rust-lang.org/t/glacier-a-big-ol-pile-of-ice/3380 +[ides]: ides.html +[internals-docs]: http://manishearth.github.com/rust-internals-docs +[internals.rust-lang.org]: https://internals.rust-lang.org/ +[iron]: https://github.com/iron +[issue tracker]: https://github.com/rust-lang/rust/issues +[issue-fcp]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AB-unstable+label%3Afinal-comment-period +[lib-prac]: https://pascalhertleif.de/artikel/good-practices-for-writing-rust-libraries/ +[libs.rs]: http://www.libs.rs +[lru_issues]: https://github.com/rust-lang/rust/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-asc +[main_repo]: https://github.com/rust-lang +[mentor]: https://users.rust-lang.org/t/mentoring-newcomers-to-the-rust-ecosystem/3088 +[mir]: https://github.com/rust-lang/rust/issues/27840 +[pull]: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#pull-requests +[redox-os]: https://github.com/redox-os +[requested]: https://github.com/rust-lang/rfcs/labels/A-community-library +[reviews]: http://blog.originate.com/blog/2014/09/29/effective-code-reviews/ +[rfc-fcp]: https://github.com/rust-lang/rfcs/pulls?q=is%3Aopen+is%3Apr+label%3Afinal-comment-period +[rfc-issues]: https://github.com/rust-lang/rfcs/issues +[rfc]: https://github.com/rust-lang/rfcs#table-of-contents +[rust-lang-nursery]: https://github.com/rust-lang-nursery +[rust-lang/rust]: https://github.com/rust-lang/rust +[rust-lang]: https://github.com/rust-lang +[rust-learning]: https://github.com/ctjhoa/rust-learning +[rust-rosetta]: https://github.com/Hoverbear/rust-rosetta +[rustc-guide]: https://github.com/rust-lang/rust/blob/master/src/librustc/README.md +[rustc-perf]: http://ncameron.org/perf-rustc/ +[rustc-tour]: http://tomlee.co/2014/04/03/a-more-detailed-tour-of-the-rust-compiler/ +[rustfmt]: https://github.com/nrc/rustfmt +[src/doc]: https://github.com/rust-lang/rust/tree/master/src/doc +[std]: http://doc.rust-lang.org/std/index.html +[team]: team.html +[test]: https://github.com/rust-lang/rust-wiki-backup/blob/master/Note-testsuite.md +[testsuite]: https://github.com/rust-lang/rust-wiki-backup/blob/master/Note-testsuite.md +[tips]: https://github.com/rust-lang/rust/blob/3d1f3c9d389d46607ae28c51cc94c1f43d65f3f9/Makefile.in#L48 +[trending]: https://github.com/trending?l=rust +[triage]: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#issue-triage +[user groups]: user_groups.html +[users.rust-lang.org]: https://users.rust-lang.org + diff --git a/contributions.md b/contributions.md deleted file mode 100644 index 410b20c0b..000000000 --- a/contributions.md +++ /dev/null @@ -1,197 +0,0 @@ ---- -layout: default -title: How To Contribute ---- - -# Contributing to Rust - -If you're learning Rust, you've no doubt been amazed at how awesome -the language is and will be keen to write more Rust code. Hopefully, -you'll also want to make a meaningful contribution to the community. -If you're not sure how best to do that, then this page will -help. - -**Just want to report a bug in Rust?** [Follow the Rust bug reporting -guide][bugs]. Thanks in advance! - -[bugs]: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#bug-reports - -Rust is an expansive system of projects, some officially maintained -within the [rust-lang] organization on GitHub, but with many -increasingly-important efforts driven from without by its enthusiastic -community. Newcomers will be interested in [an overview of the -organization, processes, and policies of The Rust Project][dev_proc] -and the project's [CONTRIBUTING.md] file, which explains the specifics -of contributing to [rust-lang/rust]. - -There are many ways to contribute to the success of Rust: filing, -triaging and fixing bugs; writing documentation and tests; partipating -in the the design of the language and standard libraries through the -RFC process; improving compile-time and run-time performance; -spreading the tendrils of the Rust community ever-outward. - -This guide focuses on a few avenues for the new contributor: - -* [Bugs, triage, and maintenance](#bugs). Finding issues to fix, - triaging, adding test cases. -* [Documentation](#doc). Not just official documentation, but also - for crates, blog posts, and other unofficial sources. -* [Community building](#comm). Expanding the reach of Rust, and - maintaining its excellence. -* [Tooling, IDEs, and infrastructure](#tool). The hard work of making - Rust accessible to programmers of all kinds. -* [Language and compiler](#comp). Language design, feature - implementation, performance improvement. -* [Libraries](#lib). Including the standard library, but also the - equally-important unofficial crates that make Rust usable. - -As a reminder, all contributors are expected to -follow our [Code of Conduct][coc]. - -[dev_proc]: dev_process.html -[rust-lang]: https://github.com/rust-lang -[rust-lang/rust]: https://github.com/rust-lang/rust -[CONTRIBUTING.md]: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md -[coc]: https://www.rust-lang.org/conduct.html - - -## Bugs, triage, and maintenance - -The day-to-day maintenance of the project revolves around Rust's -[issue tracker] and [pull requests], and more help is always -needed. - -The most basic way to get started contributing to Rust is to look for -the [E-easy][e_easy_issues] or [E-mentor][e_mentor_issues] -labels. These are meant to be approachable for new Rust programmers. - -Rust is always in need of people to [triage] issues: reproduce bugs, -minimize test cases, apply labels. - -Sometimes, an issue will stay open, even though the bug has been -fixed. And sometimes, the original bug may go stale because something -has changed in the meantime. It can be helpful to go through older bug -reports and make sure that they are still valid. Load up an older -issue, double check that it's still true, and leave a comment letting -us know if it is or is not. The [least recently updated][lru_issues] -sort is good for finding issues like this. - -While Rust has an [extensive test suite][test] there is always more to -test. The [E-needstest] label indicates issues that are thought to be -fixed but don't have tests. Writing test cases is a great way to begin -to understand a new project and get started contributing. For those -especially interested in testing, there are usually *entirely new -classes* of tests that need to be implemented, and asking #rust-internals -what needs to be tested can be fruitful. - -Once you've found your way around the project and have created a few -pull requests in a particular area of the project, consider actively -reviewing others' pull requests: reviewership is a rare skill and good -reviewers are always appreciated. - -[lru_issues]: https://github.com/rust-lang/rust/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-asc -[issue tracker]: https://github.com/rust-lang/rust/issues -[pull requests]: https://github.com/rust-lang/rust/pulls -[e_easy_issues]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy -[e_mentor_issues]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy+label%3AE-mentor -[triage]: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#issue-triage -[E-needstest]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-needstest -[test]: https://github.com/rust-lang/rust-wiki-backup/blob/master/Note-testsuite.md - - -## Documentation - -Documentation is never good enough and there's never enough of it. -Writing docs is a really valuable way to contribute to open source -projects. Many aspects of the docs don't require super-deep knowledge, -especially if they're aimed at newcomers. It's also a great way to -learn more about the language or specific libraries. - -- [The Book][rustbook_issues] The main guide to learning Rust. -- [Rust Documentation][rustdoc_issues] -- [Rust by Example][rust_by_example_issues] -- [Rust for C++ Programmers][rust_for_cpp_issues] A tutorial aimed -at experienced C++ programmers coming to Rust. - -[rustbook_issues]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-book -[rustdoc_issues]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-docs -[rust_by_example_issues]: https://github.com/rust-lang/rust-by-example/issues -[rust_for_cpp_issues]: https://github.com/nrc/r4cppp/issues - - - -## Community building - - -## Tooling, IDEs, and infrastructure - -Tools play a huge part in the success of a language. Rust has some -great tool support, in particular with debugging and package -management, but we need much more. - -- [cargo](https://github.com/rust-lang/cargo/issues) Rust's package manager and build system. -- [rustdoc](https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-rustdoc) - Produces documentation for the official libraries and user projects. -- [racer](https://github.com/phildawes/racer) Code completion. -- [rustfmt](https://github.com/nrc/rustfmt) Code formatting. -- [multirust](https://github.com/brson/multirust/issues) For managing - multiple installations of the Rust toolchain. -- [homu](https://github.com/barosl/homu/issues) Acts as a gatekeeper for commits. - - -## Libraries - -[Libstd][libstd], [libcollections][libcollections], -[liballoc][liballoc] and [libcore][libcore] are the main library -crates. These all appear to users as if they are part of libstd, the -standard library. These tend to be very fundamental libraries - -built-in types, low level IO and concurrency, allocation, essential -collections, and so forth. You should join [#rust-libs][libs_irc] if -you are interested in contributing to the Rust libraries. - -[libstd]: https://github.com/rust-lang/rust/tree/master/src/libstd -[libcollections]: https://github.com/rust-lang/rust/tree/master/src/libcollections -[liballoc]: https://github.com/rust-lang/rust/tree/master/src/liballoc -[libcore]: https://github.com/rust-lang/rust/tree/master/src/libcore -[libs_irc]: irc://moznet/rust-libs - - -## Language and compiler - -The compiler is part of the [main repo][main_repo], which also -includes the standard library crates and a whole bunch of supporting -code. For questions about the compiler, there is the -[#rustc][rustc_irc] IRC channel. Compiler errors (ICE for 'internal -compiler errors') can be searched for in issues using the -[I-ICE][i_ice_issues] label. These are usually good bugs to start with -because it's easy to know when you've fixed them, and they're often -relatively self-contained. If you're interested in parsing, macros, -syntactic stuff, the [parsing][parsing_issues] label and the -[macro][macro_issues] label are a good places to start. - -[main_repo]: https://github.com/rust-lang -[rust_irc]: irc://moznet/rustc -[i_ice_issues]: https://github.com/rust-lang/rust/labels/I-ICE -[parsing_issues]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-parser -[macro_issues]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-parser+label%3AA-macros - -#### Other Contributions - -Try [Github Trending][trending] for currently active Rust projects. -There are a number of other ways to contribute to Rust that don't deal -directly with the Rust repository. - -- Answer questions in [#rust][rust_irc], on the [Rust Forum][forum] or - on [Stack Overflow][stack_overflow]. -- Participate in the [RFC process][rfcs]. -- Find a [requested community library][requested], build it, and - publish it to [Crates.io][crates]. Easier said than done, -but very, very valuable! - -[trending]: https://github.com/trending?l=rust -[rust_irc]: irc://moznet/rust -[forum]: https://users.rust-lang.org/ -[stack_overflow]: http://stackoverflow.com/questions/tagged/rust -[rfcs]: https://github.com/rust-lang/rfcs -[requested]: https://github.com/rust-lang/rfcs/labels/A-community-library -[crates]: http://crates.io From 87c9ee069a99cc42bc8ea7ae4bc1c271ab733100 Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Wed, 2 Dec 2015 22:19:04 +0000 Subject: [PATCH 29/94] Link the developers to the github contribution page, not AUTHORS.txt --- contribute.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/contribute.md b/contribute.md index 6df1f68a8..b4bd8845d 100644 --- a/contribute.md +++ b/contribute.md @@ -13,7 +13,7 @@ will help. guide][bugs]. Thanks in advance! Rust is an expansive system of projects, the most prominent of which -are maintained by the [The Rust Project Developers][devs] in [the +are maintained by [The Rust Project Developers][devs] in [the rust-lang organization on GitHub][rust-lang]. Newcomers may be interested in [an overview of the organization, processes, and policies of The Rust Project][dev_proc] and the project's @@ -405,7 +405,7 @@ TODO: some of this RFC description could probably go in the RFC readme [contain-rs]: https://github.com/contain-rs [crate_docs]: https://users.rust-lang.org/t/lets-talk-about-ecosystem-documentation/2791 [dev_proc]: community.html#rust-development -[devs]: https://github.com/rust-lang/rust/blob/master/AUTHORS.txt +[devs]: https://github.com/rust-lang/rust/graphs/contributors [err-issue]: https://github.com/rust-lang/rust/issues/24407 [err]: http://doc.rust-lang.org/error-index.html [events]: https://www.google.com/calendar/embed?src=apd9vmbc22egenmtu5l6c5jbfc@group.calendar.google.com From 5d372c88a79878bf90259831755cfa223b626bef Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Fri, 4 Dec 2015 22:50:22 +0000 Subject: [PATCH 30/94] Address feedback on contributing page --- contribute.md | 39 ++++++++++++++++++--------------------- 1 file changed, 18 insertions(+), 21 deletions(-) diff --git a/contribute.md b/contribute.md index b4bd8845d..c8088dd54 100644 --- a/contribute.md +++ b/contribute.md @@ -9,7 +9,7 @@ You've started learning Rust. You love it, and you want to be a part of it. If you're not sure how to get involved, then this page will help. -**Just want to report a bug in Rust?** [Follow the bug reporting +**Found a bug and need to report it?** [Follow the bug reporting guide][bugs]. Thanks in advance! Rust is an expansive system of projects, the most prominent of which @@ -59,10 +59,10 @@ look for the [E-easy] or [E-mentor] labels. These are meant to be approachable for new Rust programmers. On `E-mentor` issues an experienced Rust developer has volunteered in -the comments to mentor you through the solving the issue and -[submitting the fix GitHub pull request][pull]. Contact them about the -issue, on the issue tracker by [@mentioning] their name, on IRC, or -through email. Note that Rust developers get a lot of notifications +the comments to mentor you through solving the issue and [submitting +the fix via GitHub pull request][pull]. Contact them about the issue, +on the issue tracker by [@mentioning] their name in a comment, on IRC, +or through email. Note that Rust developers get a lot of notifications and it is easy to miss some; don't hesitate to hunt them down by whatever means necessary! @@ -84,7 +84,7 @@ project. Ask a [team member][team]. Once you've found your way around the project and have created a few pull requests in a particular area, consider reviewing others' pull requests: good reviewership is a rare skill and always appreciated. No -prior permission is needed &emdash; just start constructively and politely +prior permission is needed — just start constructively and politely commenting on pull requests that interest you. If you want training on conducting good code reviews [read this guide][reviews]. @@ -96,14 +96,13 @@ TODO: @nrc says suggesting everybody review w/o training is bad ## Documentation -Documentation is never good enough and there's never enough of it, -writing documentation is a valuable way to contribute. Many aspects of -Rust's documentation don't require deep knowledge to improve, and -writing, reviewing, and editing documentation are great ways to learn -Rust. Furthermore, improvements to documentation are easy to identify -and limitless. Don't like the way something reads? Discover some -information that wasn't documented? Your pull request will be -gleefully embraced. +Documentation is never good enough and there's never enough of it. +Many aspects of Rust's documentation don't require deep knowledge to +improve, and writing, reviewing, and editing documentation are great +ways to learn Rust. Furthermore, improvements to documentation are +easy to identify and limitless. Don't like the way something reads? +Discover some information that wasn't documented? Your pull request +will be gleefully embraced. ***The most impactful documentation you can write is [for the crates that make up the Rust ecosystem][crate_docs]***. While the in-tree @@ -288,12 +287,11 @@ Rust to LLVM IR; [A-debuginfo], generation of metadata used by debuggers; issues with the standard library; [A-macros] and [A-syntaxext], both related to syntax extensions; and [A-typesystem], on the topic of types. -There is no well-maintained guide to the architecture of the -compiler, but [there is a small overview in-tree][rustc-guide], and -individuals [occassionally blog what they've learned of -rustc][rustc-tour]. The [API documentation for the crates that make up -the compiler][internals-docs] can help with navigating the code, as -can the source code browser [Rust DXR]. The [guide to the Rust test +There is no well-maintained guide to the architecture of the compiler, +but [there is a small overview in-tree][rustc-guide]. The [API +documentation for the crates that make up the +compiler][internals-docs] can help with navigating the code, as can +the source code browser [Rust DXR]. The [guide to the Rust test suite][testsuite] will teach you how to exercise the Rust build system effectively, as will running [`make tips`][tips] at the command line. @@ -439,7 +437,6 @@ TODO: some of this RFC description could probably go in the RFC readme [rust-rosetta]: https://github.com/Hoverbear/rust-rosetta [rustc-guide]: https://github.com/rust-lang/rust/blob/master/src/librustc/README.md [rustc-perf]: http://ncameron.org/perf-rustc/ -[rustc-tour]: http://tomlee.co/2014/04/03/a-more-detailed-tour-of-the-rust-compiler/ [rustfmt]: https://github.com/nrc/rustfmt [src/doc]: https://github.com/rust-lang/rust/tree/master/src/doc [std]: http://doc.rust-lang.org/std/index.html From c9c8f02f336a7420af9105c636c540f4008fd121 Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Tue, 22 Dec 2015 20:54:29 +0000 Subject: [PATCH 31/94] Add *~ to .gitignore --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index 9fb9bbfa1..28f635de7 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,4 @@ _site Gemfile.lock serve/ +*~ \ No newline at end of file From 1bb607f1af91527c9c016a487801eaffc1896013 Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Tue, 22 Dec 2015 20:54:38 +0000 Subject: [PATCH 32/94] Break contribution page into subpages --- contribute-bugs.md | 63 ++++++ contribute-community.md | 81 ++++++++ contribute-compiler.md | 109 +++++++++++ contribute-docs.md | 67 +++++++ contribute-libs.md | 66 +++++++ contribute-tools.md | 40 ++++ contribute.md | 416 ++-------------------------------------- 7 files changed, 441 insertions(+), 401 deletions(-) create mode 100644 contribute-bugs.md create mode 100644 contribute-community.md create mode 100644 contribute-compiler.md create mode 100644 contribute-docs.md create mode 100644 contribute-libs.md create mode 100644 contribute-tools.md diff --git a/contribute-bugs.md b/contribute-bugs.md new file mode 100644 index 000000000..b9b79a0ac --- /dev/null +++ b/contribute-bugs.md @@ -0,0 +1,63 @@ +--- +layout: default +title: Contributing to Rust — finding, triaging and fixing issues · The Rust Programming Language +--- + +# Contributing to Rust — finding, triaging and fixing issues + +The day-to-day maintenance of the project revolves around Rust's +[issue tracker] and [pull requests][PR], and more help is always +needed. The most basic way to get started contributing to Rust is to +look for the [E-easy] or [E-mentor] labels. These are meant to be +approachable for new Rust programmers. + +On `E-mentor` issues an experienced Rust developer has volunteered in +the comments to mentor you through solving the issue and [submitting +the fix via GitHub pull request][pull]. Contact them about the issue, +on the issue tracker by [@mentioning] their name in a comment, on IRC, +or through email. Note that Rust developers get a lot of notifications +and it is easy to miss some; don't hesitate to hunt them down by +whatever means necessary! + +Other projects in Rust maintain similar entry-level tasks, including +the web browser [Servo], the HTTP library [hyper], the +source-formatter [rustfmt], and the lint collection [clippy]. + +While Rust has an [extensive test suite][test] there is always more to +test. The [E-needstest] label indicates issues that are thought to be +fixed but don't have tests. Writing test cases is a great way to +understand a new project and get started contributing. + +Rust is always in need of people to [triage] issues: reproduce bugs, +minimize test cases, apply labels, close resolved issues. Note that +you'll need elevated GitHub permissions to apply labels, but this is +easy to obtain for somebody with a bit of experience in the +project. Ask a [team member][team]. + +Once you've found your way around the project and have created a few +pull requests in a particular area, consider reviewing others' pull +requests: good reviewership is a rare skill and always appreciated. No +prior permission is needed — just start constructively and politely +commenting on pull requests that interest you. If you want training +on conducting good code reviews [read this guide][reviews]. + + + +[@mentioning]: https://github.com/blog/821 +[E-easy]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy +[E-mentor]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy+label%3AE-mentor +[E-needstest]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-needstest +[PR]: https://github.com/rust-lang/rust/pulls +[Servo]: https://github.com/servo/servo +[clippy]: https://github.com/Manishearth/rust-clippy +[hyper]: https://github.com/hyperium/hyper +[issue tracker]: https://github.com/rust-lang/rust/issues +[pull]: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#pull-requests +[reviews]: http://blog.originate.com/blog/2014/09/29/effective-code-reviews/ +[rustfmt]: https://github.com/nrc/rustfmt +[team]: team.html +[test]: https://github.com/rust-lang/rust-wiki-backup/blob/master/Note-testsuite.md +[triage]: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#issue-triage diff --git a/contribute-community.md b/contribute-community.md new file mode 100644 index 000000000..4c9e7d861 --- /dev/null +++ b/contribute-community.md @@ -0,0 +1,81 @@ +--- +layout: default +title: Contributing to Rust — community building · The Rust Programming Language +--- + +# Contributing to Rust — community building + +Help newbies, spread the word, meet interesting people. Make Rust the +shining example of open source development that we all want it to be. + +Keep an eye on the [#rust-beginners] channel. This is where we direct +new Rust programmers to ask for help, and it is vital when they do +that they receive prompt, accurate, and courteous responses. Likewise, +[Stack Overflow], [users.rust-lang.org], and [/r/rust], are all forums +where Rust programers commonly look for assistance. If you want +training on answering programmers' questions [read this +guide][helpful]. + +If you are already experienced in some area of the project, please +look out for potential [E-easy] bugs. When you see an +easy issue on the bug tracker that you know how to fix, write up a +description of the fix and tag it with E-easy. Note that what is +obvious to you is not obvious to a new Rust contributor, and its +important to describe the problem and the solution clearly. It is +thus also helpful to triage E-easy bugs for poor descrptions and +improve them. + +Experienced developers who are patient and communicate clearly should +consider [mentoring new contributors][mentor]. Tag easy issues with +[E-mentor] and mention in a comment that you will mentor. Expect people +to contact you about the issue, and attempt to respond promptly. + +Maintaining entry-level tasks is good not only for The Rust Project +itself but all projects. If your project has a consistent supply of +entry-level tasks you might institute such a program +yourself. ***Curating entry-level tasks is one of the most effective +methods of bringing new programmers into the project***. + +Talk about what you are working on in the weekly "what's everyone +working on this week" threads on [/r/rust] and [users.rust-lang.org], +and indicate what you need help with. These are great starting points +for collaboration. + +Advocate Rust in your own local community. Rust [user groups] and [events] +are a unique and exciting part of the Rust experience: there are so +many, and they are everywhere! If you haven't been yet, go and enjoy +new experiences. If there is nothing Rusty going on near you then +consider organizing something. You can poll for interest and announce +events on [/r/rust] or [users.rust-lang.org]. Contact the [community +team] to put events on the calendar, and thus be announced on [This +Week in Rust]. + +Remember as you are advocating Rust though to be considerate of +others' views — not everybody is going to be receptive to Rust, and +that's just fine. + +Meet other Rust community builders in [#rust-community]. + + + +[#rust-beginners]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-beginners +[#rust-community]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-community +[/r/rust]: https://reddit.com/r/rust +[E-easy]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy +[E-mentor]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy+label%3AE-mentor +[Stack Overflow]: http://stackoverflow.com/questions/tagged/rust +[This Week in Rust]: http://www.this-week-in-rust.org +[community team]: https://www.rust-lang.org/team.html#Community +[events]: https://www.google.com/calendar/embed?src=apd9vmbc22egenmtu5l6c5jbfc@group.calendar.google.com +[helpful]: http://blogs.msmvps.com/jonskeet/2009/02/17/answering-technical-questions-helpfully/ +[mentor]: https://users.rust-lang.org/t/mentoring-newcomers-to-the-rust-ecosystem/3088 +[user groups]: user_groups.html +[users.rust-lang.org]: https://users.rust-lang.org diff --git a/contribute-compiler.md b/contribute-compiler.md new file mode 100644 index 000000000..775ccd698 --- /dev/null +++ b/contribute-compiler.md @@ -0,0 +1,109 @@ +--- +layout: default +title: Contributing to Rust — language, compiler, and the standard library · The Rust Programming Language +--- + +# Contributing to Rust — language, compiler, and the standard library + + +The source code to the compiler and standard library are in the main +repository, and as their maintenance is the primary objective of that +repository, many labels on the issue tracker relate to it. Some of +the more fruitful labels include [A-codegen], for translation of +Rust to LLVM IR; [A-debuginfo], generation of metadata used by debuggers; +[A-diagnostics], the feedback the compiler provides on errors; [A-libs], +issues with the standard library; [A-macros] and [A-syntaxext], both +related to syntax extensions; and [A-typesystem], on the topic of types. + +There is no well-maintained guide to the architecture of the compiler, +but [there is a small overview in-tree][rustc-guide]. The [API +documentation for the crates that make up the +compiler][internals-docs] can help with navigating the code, as can +the source code browser [Rust DXR]. The [guide to the Rust test +suite][testsuite] will teach you how to exercise the Rust build system +effectively, as will running [`make tips`][tips] at the command line. + +For the foreseable future, one of the major thrusts of Rust compiler +development is converting its internals from operating directly off +the AST to working with an [intermediate representation called +MIR][mir]. This work is expected to open up many new possibilities by +simplifying the compiler and help is needed to e.g. create a MIR-based +translation pass, add MIR-based optimizations, and implement +incremental compilation. There is yet no single source for information +on work needed here, but ask on [internals.rust-lang.org] or +[#rust-internals] for guidance. + +[It's embarrasing when our compiler crashes][ice] — the +dreaded 'internal compiler error' (ICE). The [I-ICE] label +tracks these, and they are often plentiful. These are usually +good bugs to start with because it's easy to know when you've fixed +them, and they're often relatively self-contained. + +The performance of Rust code is one of its great advantages; and the +performance of the Rust compiler one of its great weaknesses. Any +improvements to either runtime or — especially — compiletime performance +are widely celebrated. The [I-slow] and [A-optimization] labels deal +with runtime performance, and [I-compiletime] with compiletime. We have +a [site that tracks compiletime performance][rustc-perf] on a number +of workloads. The `-Z time-passes` compiler flag can help debug +compiler performance, and Rust code can be profiled with standard +profilers like `perf` on Linux. + +Major new features go through a [Request for Comments (RFC)][rfc] +process, by which the design is agreed upon. Though it is open to all, +it is a social process between developers who already have various +amounts of experience working together, and it is recommended to get +involved slowly — submitting a hasty RFC without understanding +the historical, technical, or social context is an easy way +to make a poor impression and come away disappointed. Read the +aforelinkd readme file to understand best how it all works. Many +ideas have been debated in Rust's history, some rejected, some +postponed until the future, and the RFC [issue tracker][rfc-issues] +catalogs some wishlist ideas that have yet to make headway into the +language. Shortly before an RFC is accepted for implementation it +enters 'final commemnt period', indicated by the [final-comment-period +label on the rust-lang/rfcs repository][rfc-fcp]. Likewise, before a +feature is enabled in the stable compiler (called 'ungating') it +enters [final-comment-period in the rust-lang/rust +repository][issue-fcp]. Both FCPs are critical moments to get involved +and express opinions on the direction of the language, and are +advertised in the weekly subteam reports on [internals.rust-lang.org]. + +Meet other Rust compiler engineers in [#rustc], language +designers in [#rust-lang], and library designers in [#rust-libs]. + + + + +[#rust-internals]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-internals +[#rust-lang]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-lang +[#rust-libs]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-libs +[#rustc]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rustc +[A-codegen]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-codegen +[A-debuginfo]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-debuginfo +[A-diagnostics]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-diagnostics +[A-libs]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-libs +[A-macros]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-macros +[A-optimization]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-optimization +[A-syntaxext]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-syntaxext +[A-typesystem]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-typesystem +[I-ICE]: https://github.com/rust-lang/rust/labels/I-ICE +[I-compiletime]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AI-compiletime +[I-slow]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AI-slow +[Rust DXR]: https://dxr.mozilla.org/rust/source/src +[ice]: https://users.rust-lang.org/t/glacier-a-big-ol-pile-of-ice/3380 +[internals-docs]: http://manishearth.github.com/rust-internals-docs +[internals.rust-lang.org]: https://internals.rust-lang.org/ +[issue-fcp]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AB-unstable+label%3Afinal-comment-period +[mir]: https://github.com/rust-lang/rust/issues/27840 +[rfc-fcp]: https://github.com/rust-lang/rfcs/pulls?q=is%3Aopen+is%3Apr+label%3Afinal-comment-period +[rfc-issues]: https://github.com/rust-lang/rfcs/issues +[rfc]: https://github.com/rust-lang/rfcs#table-of-contents +[rustc-guide]: https://github.com/rust-lang/rust/blob/master/src/librustc/README.md +[rustc-perf]: http://ncameron.org/perf-rustc/ +[testsuite]: https://github.com/rust-lang/rust-wiki-backup/blob/master/Note-testsuite.md +[tips]: https://github.com/rust-lang/rust/blob/3d1f3c9d389d46607ae28c51cc94c1f43d65f3f9/Makefile.in#L48 diff --git a/contribute-docs.md b/contribute-docs.md new file mode 100644 index 000000000..7a6b8ef24 --- /dev/null +++ b/contribute-docs.md @@ -0,0 +1,67 @@ +--- +layout: default +title: Contributing to Rust — documentation · The Rust Programming Language +--- + +# Contributing to Rust — documentation + +Documentation is never good enough and there's never enough of it. +Many aspects of Rust's documentation don't require deep knowledge to +improve, and writing, reviewing, and editing documentation are great +ways to learn Rust. Furthermore, improvements to documentation are +easy to identify and limitless. Don't like the way something reads? +Discover some information that wasn't documented? Your pull request +will be gleefully embraced. + +***The most impactful documentation you can write is [for the crates +that make up the Rust ecosystem][crate_docs]***. While the in-tree +documentation is relatively complete, the same is not yet true for +[many of the popular crates and tools][awesome-rust] that Rust +programmers interact with every day. Contributing API documentation to +a popular Rust project will earn you the enduring love of its maintainer. + +[The Book] is the primary documentation for Rust, maintained in the +main repository. It has its own issue label, [A-book] and +is continually being refined. Other documentation in the main +repository include [The Rust Reference], the [standard library API +documentation][std], [The Rustonomicon] (a guide to using `unsafe` +correctly). The [Rust Style Guidelines] are so incomplete they are not +linked prominently; an ambitious contributor can make much headway +there. The [error index][err] provides extended explanations of the +errors produced by the compiler. As new errors are added this +documentation [must be maintained][err-issue], so there always +errors not reflected in the index to be added. Most in-tree +documentation lives in the [src/doc] directory. To contribute simply +edit it and submit a pull request. These are all covered by the +[A-docs] label on the issue tracker. + +A great deal of important Rust documentation does not live in the main +repository, or is not maintained by the project, but is still +critically important to Rust's success. Examples of excellent Rust +documentation that is actively developed and in need of contributors +include [Rust By Example], [Rust Design Patterns], and [rust-rosetta]. +For other existing documentation projects to contribute to see [rust-learning]. + +Meet other Rust documentarians in [#rust-docs]. + + + +[#rust-docs]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-docs +[A-book]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-book +[A-docs]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-docs +[Rust By Example]: https://github.com/rust-lang/rust-by-example +[Rust Design Patterns]: https://github.com/nrc/patterns +[Rust Style Guidelines]: http://doc.rust-lang.org/style/index.html +[The Book]: http://doc.rust-lang.org/book/index.html +[The Rust Reference]: http://doc.rust-lang.org/reference.html +[The Rustonomicon]: http://doc.rust-lang.org/nomicon/index.html +[awesome-rust]: https://github.com/kud1ing/awesome-rust +[crate_docs]: https://users.rust-lang.org/t/lets-talk-about-ecosystem-documentation/2791 +[err-issue]: https://github.com/rust-lang/rust/issues/24407 +[err]: http://doc.rust-lang.org/error-index.html +[rust-learning]: https://github.com/ctjhoa/rust-learning +[rust-rosetta]: https://github.com/Hoverbear/rust-rosetta +[src/doc]: https://github.com/rust-lang/rust/tree/master/src/doc +[std]: http://doc.rust-lang.org/std/index.html diff --git a/contribute-libs.md b/contribute-libs.md new file mode 100644 index 000000000..ebeaa6f66 --- /dev/null +++ b/contribute-libs.md @@ -0,0 +1,66 @@ +--- +layout: default +title: Contributing to Rust — libraries · The Rust Programming Language +--- + +# Contributing to Rust — libraries + +If you want to contribute to Rust by writing volumes of Rust code, +then libraries are where it's at: since Rust is a young language, +there are many types of libraries that either do not exist yet +or are incomplete and in need of improvement or competition. + +Deciding what to write that will have impact and be fun is a common +difficulty. Here are some ideas: + +* Read and participate in the weekly "what's everyone working on + this week" threads on [/r/rust] and [users.rust-lang.org]. These are + packed with exciting announcements from other Rust programmers in + need of collaborators. +* Familiarize yourself with the best Rust libraries through + [awesome-rust] and [libs.rs]. +* Some larger projects, including the web browser [Servo], the HTTP + library [hyper], the source-formatter [rustfmt], and the lint + collection [clippy], tag issues with 'easy' labels for new + contributors. +* Get involved with one of the active Rust-oriented GitHub + organizations, such as [PistonDevelopers], [servo], [redox-os], + [iron], [contain-rs], [hyperium]. It's often easier to find a place + to fit in with these subcommunities, they are in greater need of + help than rust-lang itself, and they are filled with experienced + Rust developers to guide you. +* Help guide libraries from [rust-lang-nursery] into rust-lang proper. + Unfortunately there is not much documentation on what needs to be + done here; ask on [#rust-libs]. +* Inspect the RFC issue tracker for a [requested community + library][requested] and build it. +* Watch [Github Trending][trending] for currently active Rust projects. + +As a library author you will want to be aware of the [best practices +for Rust libraries][lib-prac]. + +Meet other Rust library designers in [#rust-libs]. + + + +[#rust-libs]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-libs +[/r/rust]: https://reddit.com/r/rust +[PistonDevelopers]: https://github.com/PistonDevelopers +[Servo]: https://github.com/servo/servo +[Servo]: https://github.com/servo/servo +[awesome-rust]: https://github.com/kud1ing/awesome-rust +[clippy]: https://github.com/Manishearth/rust-clippy +[contain-rs]: https://github.com/contain-rs +[hyper]: https://github.com/hyperium/hyper +[hyperium]: https://github.com/hyperium +[iron]: https://github.com/iron +[lib-prac]: https://pascalhertleif.de/artikel/good-practices-for-writing-rust-libraries/ +[libs.rs]: http://www.libs.rs +[redox-os]: https://github.com/redox-os +[requested]: https://github.com/rust-lang/rfcs/labels/A-community-library +[rust-lang-nursery]: https://github.com/rust-lang-nursery +[rustfmt]: https://github.com/nrc/rustfmt +[trending]: https://github.com/trending?l=rust +[users.rust-lang.org]: https://users.rust-lang.org diff --git a/contribute-tools.md b/contribute-tools.md new file mode 100644 index 000000000..911c532ec --- /dev/null +++ b/contribute-tools.md @@ -0,0 +1,40 @@ +--- +layout: default +title: Contributing to Rust — tooling, IDEs and infrastructure · The Rust Programming Language +--- + +# Contributing to Rust — tooling, IDEs and infrastructure + +Tools play a huge part in the success of a language, and there is a +great deal left to implement. ***A major focus of Rust development now +is [improving the IDE experience][ides]***. This involves work +throughout the Rust stack, from the compiler itself through your +favorite IDE. Follow the link for more information. + +Both Cargo, the Rust package manager, and rustdoc, +the Rust documentation generator, while full-featured and functional, +suffer from a lack of developers. Rustdoc has many open issues, under +the main repository's [A-rustdoc] label. They are mostly bugs and +contributing is a matter of fixing the bug and submitting a pull +request. Cargo has [its own repository and issues][Cargo], and those +interested in contributing might want to introduce themselves in +[#cargo]. + +Although Rust can be run under both the gdb and lldb debuggers with +limited success, there are still many cases where debugging does not +work as expected. The [A-debuginfo] issue tracks these. + +For ideas for more tooling projects to contributo to see +[awesome-rust]. + +There are often other tooling projects of interest just waiting for +the right people to come along and implement them. Discuss with other +Rust tooling enthusiasts in [#rust-tools]. + +[#cargo]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rustc +[#rust-tools]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-tools +[A-debuginfo]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-debuginfo +[A-rustdoc]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-rustdoc +[Cargo]: https://github.com/rust-lang/cargo/issues +[awesome-rust]: https://github.com/kud1ing/awesome-rust +[ides]: ides.html diff --git a/contribute.md b/contribute.md index c8088dd54..c985184b8 100644 --- a/contribute.md +++ b/contribute.md @@ -23,17 +23,21 @@ to [rust-lang/rust]. There are many ways to contribute to the success of Rust. This guide focuses on a few avenues for the new contributor: -* [Finding, triaging and fixing issues](#bugs). The basic work - of maintaining a large and active project like Rust. -* [Documentation](#docs). Not just official documentation, but also - for crates, blog posts, and other unofficial sources. -* [Community building](#community). Helping your fellow Rustacean, - and expanding the reach of Rust. -* [Tooling, IDEs and infrastructure](#tools). There's so much - to do here. -* [Libraries](#libs). Rust's suitability for any particular task - is mostly dependent on the quality libraries that exist. -* [Language, compiler and the standard library](#compiler). Language design, feature implementation, performance improvement. +* [Finding, triaging and fixing issues](contribute-bugs.html). The + basic work of maintaining a large and active project like Rust. +* [Documentation](contribute-docs.html). Not just official + documentation, but also for crates, blog posts, and other unofficial + sources. +* [Community building](contribute-community.html). Helping your fellow + Rustacean, and expanding the reach of Rust. +* [Tooling, IDEs and infrastructure](contribute-tools.html). The + important pieces that make using a language practical and painless. +* [Libraries](contribute-libs.html). Rust's suitability for any + particular task is mostly dependent on availability of quality + libraries. +* [Language, compiler and the standard + library](contribute-compiler.html). Language design, feature + implementation, performance improvement. If you need additional guidance ask on [#rust-internals] or [internals.rust-lang.org]. @@ -49,403 +53,13 @@ TODO: Write guide to advertising Rust projects to link from libs / community building --> - -## Finding, triaging and fixing issues - -The day-to-day maintenance of the project revolves around Rust's -[issue tracker] and [pull requests][PR], and more help is always -needed. The most basic way to get started contributing to Rust is to -look for the [E-easy] or [E-mentor] labels. These are meant to be -approachable for new Rust programmers. - -On `E-mentor` issues an experienced Rust developer has volunteered in -the comments to mentor you through solving the issue and [submitting -the fix via GitHub pull request][pull]. Contact them about the issue, -on the issue tracker by [@mentioning] their name in a comment, on IRC, -or through email. Note that Rust developers get a lot of notifications -and it is easy to miss some; don't hesitate to hunt them down by -whatever means necessary! - -Other projects in Rust maintain similar entry-level tasks, including -the web browser [Servo], the HTTP library [hyper], the -source-formatter [rustfmt], and the lint collection [clippy]. - -While Rust has an [extensive test suite][test] there is always more to -test. The [E-needstest] label indicates issues that are thought to be -fixed but don't have tests. Writing test cases is a great way to -understand a new project and get started contributing. - -Rust is always in need of people to [triage] issues: reproduce bugs, -minimize test cases, apply labels, close resolved issues. Note that -you'll need elevated GitHub permissions to apply labels, but this is -easy to obtain for somebody with a bit of experience in the -project. Ask a [team member][team]. - -Once you've found your way around the project and have created a few -pull requests in a particular area, consider reviewing others' pull -requests: good reviewership is a rare skill and always appreciated. No -prior permission is needed — just start constructively and politely -commenting on pull requests that interest you. If you want training -on conducting good code reviews [read this guide][reviews]. - - - - -## Documentation - -Documentation is never good enough and there's never enough of it. -Many aspects of Rust's documentation don't require deep knowledge to -improve, and writing, reviewing, and editing documentation are great -ways to learn Rust. Furthermore, improvements to documentation are -easy to identify and limitless. Don't like the way something reads? -Discover some information that wasn't documented? Your pull request -will be gleefully embraced. - -***The most impactful documentation you can write is [for the crates -that make up the Rust ecosystem][crate_docs]***. While the in-tree -documentation is relatively complete, the same is not yet true for -[many of the popular crates and tools][awesome-rust] that Rust -programmers interact with every day. Contributing API documentation to -a popular Rust project will earn you the enduring love of its maintainer. - -[The Book] is the primary documentation for Rust, maintained in the -main repository. It has its own issue label, [A-book][book_issues] and -is continually being refined. Other documentation in the main -repository include [The Rust Reference], the [standard library API -documentation][std], [The Rustonomicon] (a guide to using `unsafe` -correctly). The [Rust Style Guidelines] are so incomplete they are not -linked prominently; an ambitious contributor can make much headway -there. The [error index][err] provides extended explanations of the -errors produced by the compiler. As new errors are added this -documentation [must be maintained][err-issue], so there always -errors not reflected in the index to be added. Most in-tree -documentation lives in the [src/doc] directory. To contribute simply -edit it and submit a pull request. These are all covered by the -[A-docs] label on the issue tracker. - -A great deal of important Rust documentation does not live in the main -repository, or is not maintained by the project, but is still -critically important to Rust's success. Examples of excellent Rust -documentation that is actively developed and in need of contributors -include [Rust By Example], [Rust Design Patterns], and [rust-rosetta]. -For other existing documentation projects to contribute to see [rust-learning]. - -Meet other Rust documentarians in [#rust-docs]. - - - - -## Community building - -Help newbies, spread the word, meet interesting people. Make Rust the -shining example of open source development that we all want it to be. - -Keep an eye on the [#rust-beginners] channel. This is where we direct -new Rust programmers to ask for help, and it is vital when they do -that they receive prompt, accurate, and courteous responses. Likewise, -[Stack Overflow], [users.rust-lang.org], and [/r/rust], are all forums -where Rust programers commonly look for assistance. If you want -training on answering programmers' questions [read this -guide][helpful]. - -If you are already experienced in some area of the project, please -look out for potential [E-easy] bugs. When you see an -easy issue on the bug tracker that you know how to fix, write up a -description of the fix and tag it with E-easy. Note that what is -obvious to you is not obvious to a new Rust contributor, and its -important to describe the problem and the solution clearly. It is -thus also helpful to triage E-easy bugs for poor descrptions and -improve them. - -Experienced developers who are patient and communicate clearly should -consider [mentoring new contributors][mentor]. Tag easy issues with -[E-mentor] and mention in a comment that you will mentor. Expect people -to contact you about the issue, and attempt to respond promptly. - -Maintaining entry-level tasks is good not only for The Rust Project -itself but all projects. If your project has a consistent supply of -entry-level tasks you might institute such a program -yourself. ***Curating entry-level tasks is one of the most effective -methods of bringing new programmers into the project***. - -Talk about what you are working on in the weekly "what's everyone -working on this week" threads on [/r/rust] and [users.rust-lang.org], -and indicate what you need help with. These are great starting points -for collaboration. - -Advocate Rust in your own local community. Rust [user groups] and [events] -are a unique and exciting part of the Rust experience: there are so -many, and they are everywhere! If you haven't been yet, go and enjoy -new experiences. If there is nothing Rusty going on near you then -consider organizing something. You can poll for interest and announce -events on [/r/rust] or [users.rust-lang.org]. Contact the [community -team] to put events on the calendar, and thus be announced on [This -Week in Rust]. - -Remember as you are advocating Rust though to be considerate of -others' views — not everybody is going to be receptive to Rust, and -that's just fine. - -Meet other Rust community builders in [#rust-community]. - - - - -## Tooling, IDEs, and infrastructure - -Tools play a huge part in the success of a language, and there is a -great deal left to implement. ***A major focus of Rust development now -is [improving the IDE experience][ides]***. This involves work -throughout the Rust stack, from the compiler itself through your -favorite IDE. Follow the link for more information. - -Both Cargo, the Rust package manager, and rustdoc, -the Rust documentation generator, while full-featured and functional, -suffer from a lack of developers. Rustdoc has many open issues, under -the main repository's [A-rustdoc] label. They are mostly bugs and -contributing is a matter of fixing the bug and submitting a pull -request. Cargo has [its own repository and issues][Cargo], and those -interested in contributing might want to introduce themselves in -[#cargo]. - -Although Rust can be run under both the gdb and lldb debuggers with -limited success, there are still many cases where debugging does not -work as expected. The [A-debuginfo] issue tracks these. - -For ideas for more tooling projects to contributo to see -[awesome-rust]. - -There are often other tooling projects of interest just waiting for -the right people to come along and implement them. Discuss with other -Rust tooling enthusiasts in [#rust-tools]. - - -## Libraries - -If you want to contribute to Rust by writing volumes of Rust code, -then libraries are where it's at: since Rust is a young language, -there are many types of libraries that either do not exist yet -or are incomplete and in need of improvement or competition. - -Deciding what to write that will have impact and be fun is a common -difficulty. Here are some ideas: - -* Read and participate in the weekly "what's everyone working on - this week" threads on [/r/rust] and [users.rust-lang.org]. These are - packed with exciting announcements from other Rust programmers in - need of collaborators. -* Familiarize yourself with the best Rust libraries through - [awesome-rust] and [libs.rs]. -* Some larger projects, including the web browser [Servo], the HTTP - library [hyper], the source-formatter [rustfmt], and the lint - collection [clippy], tag issues with 'easy' labels for new - contributors. -* Get involved with one of the active Rust-oriented GitHub - organizations, such as [PistonDevelopers], [servo], [redox-os], - [iron], [contain-rs], [hyperium]. It's often easier to find a place - to fit in with these subcommunities, they are in greater need of - help than rust-lang itself, and they are filled with experienced - Rust developers to guide you. -* Help guide libraries from [rust-lang-nursery] into rust-lang proper. - Unfortunately there is not much documentation on what needs to be - done here; ask on [#rust-libs]. -* Inspect the RFC issue tracker for a [requested community - library][requested] and build it. -* Watch [Github Trending][trending] for currently active Rust projects. - -As a library author you will want to be aware of the [best practices -for Rust libraries][lib-prac]. - -Meet other Rust library designers in [#rust-libs]. - - - - -## Language, compiler, and the standard library - -The source code to the compiler and standard library are in the main -repository, and as their maintenance is the primary objective of that -repository, many labels on the issue tracker relate to it. Some of -the more fruitful labels include [A-codegen], for translation of -Rust to LLVM IR; [A-debuginfo], generation of metadata used by debuggers; -[A-diagnostics], the feedback the compiler provides on errors; [A-libs], -issues with the standard library; [A-macros] and [A-syntaxext], both -related to syntax extensions; and [A-typesystem], on the topic of types. - -There is no well-maintained guide to the architecture of the compiler, -but [there is a small overview in-tree][rustc-guide]. The [API -documentation for the crates that make up the -compiler][internals-docs] can help with navigating the code, as can -the source code browser [Rust DXR]. The [guide to the Rust test -suite][testsuite] will teach you how to exercise the Rust build system -effectively, as will running [`make tips`][tips] at the command line. - -For the foreseable future, one of the major thrusts of Rust compiler -development is converting its internals from operating directly off -the AST to working with an [intermediate representation called -MIR][mir]. This work is expected to open up many new possibilities by -simplifying the compiler and help is needed to e.g. create a MIR-based -translation pass, add MIR-based optimizations, and implement -incremental compilation. There is yet no single source for information -on work needed here, but ask on [internals.rust-lang.org] or -[#rust-internals] for guidance. - -[It's embarrasing when our compiler crashes][ice] — the -dreaded 'internal compiler error' (ICE). The [I-ICE] label -tracks these, and they are often plentiful. These are usually -good bugs to start with because it's easy to know when you've fixed -them, and they're often relatively self-contained. - -The performance of Rust code is one of its great advantages; and the -performance of the Rust compiler one of its great weaknesses. Any -improvements to either runtime or — especially — compiletime performance -are widely celebrated. The [I-slow] and [A-optimization] labels deal -with runtime performance, and [I-compiletime] with compiletime. We have -a [site that tracks compiletime performance][rustc-perf] on a number -of workloads. The `-Z time-passes` compiler flag can help debug -compiler performance, and Rust code can be profiled with standard -profilers like `perf` on Linux. - -Major new features go through a [Request for Comments (RFC)][rfc] -process, by which the design is agreed upon. Though it is open to all, -it is a social process between developers who already have various -amounts of experience working together, and it is recommended to get -involved slowly — submitting a hasty RFC without understanding -the historical, technical, or social context is an easy way -to make a poor impression and come away disappointed. Read the -aforelinkd readme file to understand best how it all works. Many -ideas have been debated in Rust's history, some rejected, some -postponed until the future, and the RFC [issue tracker][rfc-issues] -catalogs some wishlist ideas that have yet to make headway into the -language. Shortly before an RFC is accepted for implementation it -enters 'final commemnt period', indicated by the [final-comment-period -label on the rust-lang/rfcs repository][rfc-fcp]. Likewise, before a -feature is enabled in the stable compiler (called 'ungating') it -enters [final-comment-period in the rust-lang/rust -repository][issue-fcp]. Both FCPs are critical moments to get involved -and express opinions on the direction of the language, and are -advertised in the weekly subteam reports on [internals.rust-lang.org]. - -Meet other Rust compiler engineers in [#rustc], language -designers in [#rust-lang], and library designers in [#rust-libs]. - - - - -[#cargo]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rustc -[#rust-beginners]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-beginners -[#rust-community]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-community -[#rust-docs]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-docs [#rust-internals]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-internals -[#rust-lang]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-lang -[#rust-libs]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-libs -[#rust-tools]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-tools -[#rustc]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rustc -[/r/rust]: https://reddit.com/r/rust -[@mentioning]: https://github.com/blog/821 -[A-codegen]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-codegen -[A-debuginfo]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-debuginfo -[A-debuginfo]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-debuginfo -[A-diagnostics]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-diagnostics -[A-docs]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-docs -[A-libs]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-libs -[A-macros]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-macros -[A-optimization]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-optimization -[A-rustdoc]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-rustdoc -[A-syntaxext]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-syntaxext -[A-typesystem]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-typesystem [CONTRIBUTING.md]: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md -[Cargo]: https://github.com/rust-lang/cargo/issues -[E-easy]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy -[E-mentor]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy+label%3AE-mentor -[E-needstest]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-needstest -[I-ICE]: https://github.com/rust-lang/rust/labels/I-ICE -[I-compiletime]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AI-compiletime -[I-slow]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AI-slow -[PR]: https://github.com/rust-lang/rust/pulls -[PistonDevelopers]: https://github.com/PistonDevelopers -[Rust By Example]: https://github.com/rust-lang/rust-by-example -[Rust DXR]: https://dxr.mozilla.org/rust/source/src -[Rust Design Patterns]: https://github.com/nrc/patterns -[Rust Style Guidelines]: http://doc.rust-lang.org/style/index.html -[Servo]: https://github.com/servo/servo -[Stack Overflow]: http://stackoverflow.com/questions/tagged/rust -[The Book]: http://doc.rust-lang.org/book/index.html -[The Rust Reference]: http://doc.rust-lang.org/reference.html -[The Rustonomicon]: http://doc.rust-lang.org/nomicon/index.html -[This Week in Rust]: http://www.this-week-in-rust.org -[awesome-rust]: https://github.com/kud1ing/awesome-rust -[awesome-rust]: https://github.com/kud1ing/awesome-rust -[book_issues]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-book [bugs]: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#bug-reports -[clippy]: https://github.com/Manishearth/rust-clippy [coc]: https://www.rust-lang.org/conduct.html [community team]: https://www.rust-lang.org/team.html#Community -[contain-rs]: https://github.com/contain-rs -[crate_docs]: https://users.rust-lang.org/t/lets-talk-about-ecosystem-documentation/2791 [dev_proc]: community.html#rust-development [devs]: https://github.com/rust-lang/rust/graphs/contributors -[err-issue]: https://github.com/rust-lang/rust/issues/24407 -[err]: http://doc.rust-lang.org/error-index.html -[events]: https://www.google.com/calendar/embed?src=apd9vmbc22egenmtu5l6c5jbfc@group.calendar.google.com -[helpful]: http://blogs.msmvps.com/jonskeet/2009/02/17/answering-technical-questions-helpfully/ -[hyper]: https://github.com/hyperium/hyper -[hyperium]: https://github.com/hyperium -[ice]: https://users.rust-lang.org/t/glacier-a-big-ol-pile-of-ice/3380 -[ides]: ides.html -[internals-docs]: http://manishearth.github.com/rust-internals-docs [internals.rust-lang.org]: https://internals.rust-lang.org/ -[iron]: https://github.com/iron -[issue tracker]: https://github.com/rust-lang/rust/issues -[issue-fcp]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AB-unstable+label%3Afinal-comment-period -[lib-prac]: https://pascalhertleif.de/artikel/good-practices-for-writing-rust-libraries/ -[libs.rs]: http://www.libs.rs -[lru_issues]: https://github.com/rust-lang/rust/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-asc -[main_repo]: https://github.com/rust-lang -[mentor]: https://users.rust-lang.org/t/mentoring-newcomers-to-the-rust-ecosystem/3088 -[mir]: https://github.com/rust-lang/rust/issues/27840 -[pull]: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#pull-requests -[redox-os]: https://github.com/redox-os -[requested]: https://github.com/rust-lang/rfcs/labels/A-community-library -[reviews]: http://blog.originate.com/blog/2014/09/29/effective-code-reviews/ -[rfc-fcp]: https://github.com/rust-lang/rfcs/pulls?q=is%3Aopen+is%3Apr+label%3Afinal-comment-period -[rfc-issues]: https://github.com/rust-lang/rfcs/issues -[rfc]: https://github.com/rust-lang/rfcs#table-of-contents -[rust-lang-nursery]: https://github.com/rust-lang-nursery [rust-lang/rust]: https://github.com/rust-lang/rust [rust-lang]: https://github.com/rust-lang -[rust-learning]: https://github.com/ctjhoa/rust-learning -[rust-rosetta]: https://github.com/Hoverbear/rust-rosetta -[rustc-guide]: https://github.com/rust-lang/rust/blob/master/src/librustc/README.md -[rustc-perf]: http://ncameron.org/perf-rustc/ -[rustfmt]: https://github.com/nrc/rustfmt -[src/doc]: https://github.com/rust-lang/rust/tree/master/src/doc -[std]: http://doc.rust-lang.org/std/index.html -[team]: team.html -[test]: https://github.com/rust-lang/rust-wiki-backup/blob/master/Note-testsuite.md -[testsuite]: https://github.com/rust-lang/rust-wiki-backup/blob/master/Note-testsuite.md -[tips]: https://github.com/rust-lang/rust/blob/3d1f3c9d389d46607ae28c51cc94c1f43d65f3f9/Makefile.in#L48 -[trending]: https://github.com/trending?l=rust -[triage]: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#issue-triage -[user groups]: user_groups.html -[users.rust-lang.org]: https://users.rust-lang.org - From 893021c95c286e637add50f7a952ecbbb893a364 Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Wed, 23 Dec 2015 19:14:52 +0000 Subject: [PATCH 33/94] Overhaul documentation page --- documentation.md | 175 +++++++++++++++-------------------------------- 1 file changed, 56 insertions(+), 119 deletions(-) diff --git a/documentation.md b/documentation.md index 41e5732f1..d9655f475 100644 --- a/documentation.md +++ b/documentation.md @@ -1,147 +1,84 @@ --- layout: default -title: Documentation +title: Rust Documentation · The Rust Programming Language --- # Rust Documentation -- [Getting Started][getting_started] -- [The Standard Library][standard_library] -- [Community & Getting Help][community_and_help] -- [Specification][specification] -- [Tools][tools] -- [FAQs][faqs] -- [The Error index][error_index] -- [Community Translations][translations] - -Welcome to the Rust documentation! You can use the section headings -above to jump to any particular section. - -[getting_started]: #getting_started -[standard_library]: #standard_library -[community_and_help]: #community_and_help -[specification]: #specification -[tools]: #tools -[faqs]: #faqs -[error_index]: #error_index -[translations]: #translations - -# Getting Started - If you haven't seen Rust at all yet, the first thing you should read -is the introduction to [The Rust Programming Language][rustbook]. It'll -give you a good idea of what Rust is like. - -The book provides a lengthy explanation of Rust, its syntax, and its -concepts. Upon completing the book, you'll be an intermediate Rust -developer, and will have a good grasp of the fundamental ideas behind -Rust. - -[Rust By Example][rust_by_example] was originally a community -resource, but was then donated to the Rust project. As the name -implies, it teaches you Rust through a series of small examples. - -[rustbook]: https://doc.rust-lang.org/book/ -[rust_by_example]: http://rustbyexample.com/ - -# The Standard Library - -We have [API documentation][rustdocs] for the entire standard library. There's a -list of crates on the left with more specific sections, or you can use -the search bar at the top to search for something if you know its -name. - -[rustdocs]: https://doc.rust-lang.org/ - -# Community & Getting Help - -If you need help with something, or just want to talk about Rust with -others, there are a few places you can do that: - -The Rust IRC channels on [irc.mozilla.org][irc_mozilla] are the -fastest way to get help. - -\#rust is the general discussion channel, and you'll find people -willing to help you with any questions you may have. - -There are also three specialty channels: -\#rust-gamedev and #rust-osdev are for game development and operating -system development, respectively. There's also #rust-internals, which -is for discussion of the development of Rust itself. - -You can also get help on [Stack Overflow][stack_overflow]. Searching -for your problem might reveal someone who has asked it before! - -There is an active [subreddit][reddit] with lots of discussion and -news about Rust. - -There is also a [user forum][user_forum], for all user-oriented -discussion, and a [developer forum][developer_forum], where the -development of Rust itself is discussed. - -[irc_mozilla]: https://wiki.mozilla.org/IRC -[stack_overflow]: http://stackoverflow.com/questions/tagged/rust -[reddit]: https://www.reddit.com/r/rust/ -[user_forum]: https://users.rust-lang.org/ -[developer_forum]: https://internals.rust-lang.org/ - -# Specification - -Rust does not have an exact specification, but an effort to describe as much of -the language in as much detail as possible is in [the Reference][reference]. +is the introduction to the book, [**The Rust Programming +Language**][book]. It will give you a good idea of what Rust is like, +show you how to install it, and explain its syntax and concepts. Upon +completing the book, you'll be an intermediate Rust developer, and +will have a good grasp of the fundamental ideas behind Rust. -[reference]: https://doc.rust-lang.org/reference.html +## Learning Rust -# Tools -Rust is still a young language, so there isn't a ton of tooling yet, -but the tools we have are really nice. +[**The Rust Programming Language**][book]. Also known as "The Book", +The Rust Programming Language is the most comprehensive resource for +all topics related to Rust, and is the primary official document of +the language. -[Cargo][cargo] is Rust's package manager, and its website contains -lots of good documentation. +[**Rust by Example**][rbe]. A collection of self-contained Rust +examples on a variety of topics, executable in-browser. -[cargo]: https://crates.io +[**Frequently asked questions**][faq]. -[Rustdoc][rustdoc] is used to generate documentation for Rust code. +[**The Rustonomicon**][nomicon]. An entire book dedicated to +explaining how to write unsafe Rust code. It is for advanced Rust +programmers. -[rustdoc]: https://doc.rust-lang.org/book/documentation.html +[**rust-learning**]. A community-maintained collection of resources +for learning Rust. -# FAQs +[book]: https://doc.rust-lang.org/book/ +[rbe]: http://rust-by-example.com +[faq]: faq.html +[nomicon]: https://doc.rust-lang.org/nomicon/ +[**rust-learning**]: https://github.com/ctjhoa/rust-learning -There are questions that are asked quite often, so we've made a FAQ for -them: +## References -- [FAQ][faq] +[**Standard Library API Reference**][api]. Documentation for the +standard library. -[faq]: "faq.md" +[**The Rust Reference**][ref]. While Rust does not have a +specification, the reference tries to describe its working in +detail. It tends to be out of date. -# The Error Index +[**The Cargo Guide**][cargo]. The documentation for Cargo, +Rust's package manager. -If you encounter an error while compiling your code you may be able to -look it up in the [Rust Compiler Error Index][error_index]. +[**Compiler Error Index**][err]. Extended explanations of +the errors produced by the Rust compiler. -[error_index]: https://doc.rust-lang.org/error-index.html +[**Rust security policy**][security]. The project's policies for +reporting, fixing and disclosing security-related bugs. -# Community Translations +[**Rust copyright and trademark policies**][legal]. The Rust +copyrights are owned by The Rust Project Developers, and its +trademarks are owned by Mozilla. Appropriate usage of Rust's +trademarks are described here. -Several projects have been started to translate the documentation into other -languages: +[api]: https://doc.rust-lang.org/std/ +[ref]: https://doc.rust-lang.org/reference.html +[cargo]: http://doc.crates.io/guide.html +[err]: https://doc.rust-lang.org/error-index.html +[security]: security.html +[legal]: legal.html +## Nightly and beta documentation -- [Russian][russian_translation] -- [Korean][korean_translation] -- [Chinese][chinese_translation] -- [Spanish][spanish_translation] +Much of the official Rust documentation is also available for the +[nightly] and [beta] releases in addition to the stable documentation +linked above. -[russian_translation]: https://github.com/kgv/rust_book_ru -[korean_translation]: https://github.com/rust-kr/doc.rust-kr.org -[chinese_translation]: https://github.com/KaiserY/rust-book-chinese -[spanish_translation]: https://github.com/goyox86/elpr +[nightly]: http://doc.rust-lang.org/nightly/ +[beta]: http://doc.rust-lang.org/beta/ -Copyright © 2011-2015 The Rust Project Developers. Licensed under the -[Apache License, Version 2.0][apache_license] or the [MIT -license][mit_license], at your option. This file may not be copied, -modified, or distributed except according to those terms. +## Non-english resources -[apache_license]: http://www.apache.org/licenses/LICENSE-2.0 -[mit_license]: http://opensource.org/licenses/MIT +For resources in languages other than English, see the +[locale-specific links in rust-learning][locale]. +[locale]: https://github.com/ctjhoa/rust-learning#locale-links From 6bfb9a631092eec66c594a8663e267ac368b7d4d Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Wed, 23 Dec 2015 19:46:49 +0000 Subject: [PATCH 34/94] Restructure the navbar to contain just four major links --- _layouts/default.html | 38 ++++++-------------------------------- css/style.css | 9 +++++++-- 2 files changed, 13 insertions(+), 34 deletions(-) diff --git a/_layouts/default.html b/_layouts/default.html index 0ee1e5f2a..ae68b94a6 100644 --- a/_layouts/default.html +++ b/_layouts/default.html @@ -24,39 +24,13 @@ Rust logo
    • -

  • Docs (1.5.0)

    - -
    • -

  • Docs (Nightly)

    - -
    • -

  • Resources

    - +
  • +

    Documentation

    +

    Community

    +

    Downloads

    +

    Contribute

    • + {{ content }} + + diff --git a/_layouts/default.html b/_layouts/default.html index ae68b94a6..b3de4e38f 100644 --- a/_layouts/default.html +++ b/_layouts/default.html @@ -1,47 +1,8 @@ - - - - - - {{ page.title }} - - - - - - +--- +layout: basic +--- - - - - +
    + {{ content }} +
    -
    - - -
    - {{ content }} - - - diff --git a/css/style.css b/css/style.css index ab9267206..6ad0619a9 100644 --- a/css/style.css +++ b/css/style.css @@ -128,11 +128,6 @@ div.install { margin-top: 2.5em; margin-bottom: 1.5em; } -@media (min-width: 662px) { - div.install { - margin-top: 5em; - } -} .table-installers { border-spacing: 4px; @@ -180,7 +175,7 @@ p.pitch { @media (min-width: 992px) { p.pitch { font-size: 25px; - margin-top: 2.7em; + margin-top: 1.5em; margin-bottom: 1em; margin-right: 1em; text-align: left; @@ -195,7 +190,7 @@ p.pitch a { color: #777; text-align: right; font-size: 130%; - margin-top: 2em; + margin-top: 0.8em; } .version-rec-box-inner { @@ -207,6 +202,7 @@ p.pitch a { hr { margin-top: 2em; margin-bottom: 3em; + border-top: 4px solid #dedede; } .asterisk { @@ -389,107 +385,105 @@ ul.laundry-list { margin: 5px 10px 0 0; } -.faq { - border-top: 1px solid #dedede; +.content { + border-top: 2px solid #dedede; margin-top: 2em; margin-bottom: 8em; - padding-top: 4em; + padding-top: 2em; +} + +.content p, +.content ul, +.content ol, +.content blockquote, +.content pre { + margin: 0 0 1rem; +} + +.content h1 { + font-size: 2.5em; + line-height: 1.5em; + margin-top: 0; + margin-bottom: 1rem; + font-weight: 400; + position: relative; +} + +.content h2 { + font-size: 2em; + line-height: 1.5em; + margin: 3rem 0 1rem; + font-weight: 400; + border-top: 4px solid #dedede; + padding-top: 1rem; } +.content h3 { + font-size: 1em; + line-height: 1.5em; + font-weight: 500; + margin: 2rem 0 .25rem; +} + +@media screen and (min-width: 820px) { + .faq { + /*padding-right: 6em;*/ + } + .faq p, .faq ul, .faq ol, .faq blockquote, - .faq pre { - margin: 0 0 1rem; - font-family: "Source Serif Pro"; - } - - @media screen and (min-width: 820px) { - .faq { - padding-right: 6em; - } - - .faq p, - .faq ul, - .faq ol, - .faq blockquote, - .faq pre, - .faq h1, - #toc { - margin-left: 8rem; - } - } - - .faq blockquote { - border-left: .25em solid #dedede; - padding-left: 2rem; - } - - .faq blockquote p { - margin: 0; - } - - .faq h1 { - font-size: 2.5em; - line-height: 1.5em; - margin-top: 0; - margin-bottom: 1rem; - font-weight: 400; - position: relative; + .faq pre, + .faq table { + margin-left: 8rem; } +} - .faq h2 { - font-size: 2em; - line-height: 1.5em; - margin: 3rem 0 1rem; - font-weight: 400; - border-top: 4px solid #dedede; - padding-top: 1rem; - } +.faq .faq-intro { + margin-left: 0rem; +} - .faq h3 { - font-size: 1em; - line-height: 1.5em; - font-weight: 500; - margin: 2rem 0 .25rem; - } +.faq blockquote { + border-left: .25em solid #dedede; + padding-left: 2rem; +} - .faq pre { - margin-top: 2rem; - margin-bottom: 2rem; - } +.faq blockquote p { + margin: 0; +} - .faq code { - display: inline-block; - padding: .1em .2em 0; - font-size: 0.95em; - line-height: 1em; - background-color: #f7f7f7; - border-radius: 2px; - font-weight: 400; - font-family: Consolas, "Andale Mono WT", "Andale Mono", "Lucida Console", "Lucida Sans Typewriter", "DejaVu Sans Mono", "Bitstream Vera Sans Mono", "Liberation Mono", "Nimbus Mono L", Monaco, "Courier New", Courier, monospace; - } +.faq pre { + margin-top: 2rem; + margin-bottom: 2rem; +} - .faq pre code { - font-size: 1em; - line-height: 1.5em; - } +.faq code { + display: inline-block; + padding: .1em .2em 0; + font-size: 0.95em; + line-height: 1em; + background-color: #f7f7f7; + border-radius: 2px; + font-weight: 400; + font-family: Consolas, "Andale Mono WT", "Andale Mono", "Lucida Console", "Lucida Sans Typewriter", "DejaVu Sans Mono", "Bitstream Vera Sans Mono", "Liberation Mono", "Nimbus Mono L", Monaco, "Courier New", Courier, monospace; +} - #toc h2 { - border: 0; - font-size: 2rem; - line-height: 1.5em; - } +.faq pre code { + font-size: 1em; + line-height: 1.5em; +} - #toc ol { - margin: 0 0 0 2rem; - padding: 0; - -webkit-columns: 150px 3; - -moz-columns: 150px 3; - columns: 150px 3; - } +#toc h2 { + border: 0; + font-size: 2rem; + line-height: 1.5em; +} - .faq table { - margin-left: 8rem; - } +#toc ol { + margin: 0 0 0 2rem; + padding: 0; + -webkit-columns: 150px 3; + -moz-columns: 150px 3; + columns: 150px 3; +} diff --git a/downloads.html b/downloads.html index c63d40373..f895cb48b 100644 --- a/downloads.html +++ b/downloads.html @@ -1,5 +1,5 @@ --- -layout: default +layout: basic title: Downloads · The Rust Programming Language --- diff --git a/faq.md b/faq.md index 7812993fc..bc70b65aa 100644 --- a/faq.md +++ b/faq.md @@ -5,9 +5,13 @@ title: Frequently Asked Questions · The Rust Programming Language # Frequently Asked Questions +

    This page exists to answer common questions about the Rust programming language. It is not a complete guide to the language, nor is it a tool for teaching the language. It is a reference to answer oft-repeated questions people in the Rust community encounter, and to clarify the reasoning behind some of Rust's design decisions. +

    -If there is some common or important question you feel is wrongly left unanswered here, feel free to [help us fix it](https://github.com/rust-lang/rust-www/blob/master/CONTRIBUTING.md). +

    +If there is some common or important question you feel is wrongly left unanswered here, feel free to help us fix it. +

    Table of Contents

    diff --git a/index.html b/index.html index 31b297e4b..df48ce6ed 100644 --- a/index.html +++ b/index.html @@ -1,5 +1,5 @@ --- -layout: default +layout: basic title: The Rust Programming Language --- From c374cbb5b4cb166d4b53941eae01d1151702af0d Mon Sep 17 00:00:00 2001 From: Andrew Brinker Date: Thu, 7 Jan 2016 18:16:47 -0500 Subject: [PATCH 50/94] First pass with new feedback --- faq.md | 143 +++++++++++++++++++++++++++++++++++++++------------------ 1 file changed, 98 insertions(+), 45 deletions(-) diff --git a/faq.md b/faq.md index 7812993fc..8b780204b 100644 --- a/faq.md +++ b/faq.md @@ -57,21 +57,29 @@ The Rust compiler doesn't compile with optimizations unless asked to, [as optimi If you compile with `cargo`, use the `--release` flag. If you compile with `rustc` directly, use the `-O` flag. Either of these will turn on optimizations. -### Why is Rust compilation slow? +### Rust compilation seems slow. Why is that? Code translation and optimizations. Rust provides high level abstractions that compile down into efficient machine code, and those translations take time to run, especially when optimizing. But Rust's compilation time is not as bad as it may seem, and there is reason to believe it will improve. When comparing projects of similar size between C++ and Rust, compilation time of the entire project is generally believed to be comparable. The common perception that Rust compilation is slow is in large part due to the differences in the *compilation model* between C++ and Rust: C++'s compilation unit is the file, while Rust's is the crate, composed of many files. Thus, during development, modifying a single C++ file can result in much less recompilation than in Rust. There is a major effort underway to refactor the compiler to introduce [incremental compilation](https://github.com/rust-lang/rfcs/blob/master/text/1298-incremental-compilation.md), which will provide Rust the compile time benefits of C++'s model. -Aside from the compilation model, there are several other aspects of Rust's language design and compiler implementation that affect compile-time performance. First, Rust has a moderately-complex type system, and must spend a non-negligible amount of compile time enforcing the constraints that make Rust safe at runtime. Secondly, Rust's use of LLVM for code generation is a double-edged sword: while it enables Rust to have world-class runtime performance, LLVM is a large framework that is not focused on compile-time performance. Thirdly, the Rust compiler suffers from long-standing technical debt, and notably generates poor-quality LLVM IR which LLVM must spend time "fixing". There is hope that future [MIR-based](https://github.com/rust-lang/rfcs/blob/master/text/1211-mir.md) optimization and translation passes will ease the burden the Rust compiler places on LLVM. Finally, while Rust's preferred strategy of monomorphising generics (ala C++) produces fast code, it demands that significantly more code be generated than other translation strategies. +Aside from the compilation model, there are several other aspects of Rust's language design and compiler implementation that affect compile-time performance. + +First, Rust has a moderately-complex type system, and must spend a non-negligible amount of compile time enforcing the constraints that make Rust safe at runtime. + +Secondly, the Rust compiler suffers from long-standing technical debt, and notably generates poor-quality LLVM IR which LLVM must spend time "fixing". There is hope that future [MIR-based](https://github.com/rust-lang/rfcs/blob/master/text/1211-mir.md) optimization and translation passes will ease the burden the Rust compiler places on LLVM. + +Thirdly, Rust's use of LLVM for code generation is a double-edged sword: while it enables Rust to have world-class runtime performance, LLVM is a large framework that is not focused on compile-time performance, particularly when working with poor-quality inputs. + +Finally, while Rust's preferred strategy of monomorphising generics (ala C++) produces fast code, it demands that significantly more code be generated than other translation strategies. ### Why are Rust's `HashMap`s slow? By default, Rust's `HashMap` uses the [SipHash](https://131002.net/siphash/) hashing algorithm, which is designed to prevent [hash table collision attacks](http://programmingisterrible.com/post/40620375793/hash-table-denial-of-service-attacks-revisited) while providing [reasonable performance on a variety of workloads](https://www.reddit.com/r/rust/comments/3hw9zf/rust_hasher_comparisons/cub4oh6). -While SipHash [demonstrates competitive performance](http://cglab.ca/%7Eabeinges/blah/hash-rs/) in many cases, one case where it is notably slower than other hashing algorithms is with short keys, such as integers. This is why Rust programmers often observe slow performance with `HashMap`. The [FNV hasher](https://crates.io/crates/fnv) is frequently recommended for these cases, but be aware that it does not have the same collision-resistence properties as SipHash. +While SipHash [demonstrates competitive performance](http://cglab.ca/%7Eabeinges/blah/hash-rs/) in many cases, one case where it is notably slower than other hashing algorithms is with short keys, such as integers. This is why Rust programmers often observe slow performance with `HashMap`. The [FNV hasher](https://crates.io/crates/fnv) is frequently recommended for these cases, but be aware that it does not have the same collision-resistance properties as SipHash. -### Why can't I run benchmarks? +### Why is there no integrated benchmarking infrastructure? You can run benchmarks, but only on the nightly channel. Rust's benchmarking mechanism is currently unstable, as the API has not been deemed ready for stabilization. This [may change in the future](https://github.com/rust-lang/rust/issues/29553), but until then benchmarking can only be used on nightly. @@ -81,11 +89,11 @@ Not generally, no. Tail-call optimization may be done in [limited circumstances] ### Does Rust have a runtime? -Not in the typical sense used by languages such as Java, but parts of the Rust standard library can be considered a "runtime", providing a heap, backtraces, unwinding, and stack guards. There is a [small amount of initialization code](https://github.com/rust-lang/rust/blob/33916307780495fe311fe9c080b330d266f35bfb/src/libstd/rt.rs#L43) that runs before the user's `main` function. The Rust standard library additionally links to the the C standard library, which does similar [runtime initialization](http://www.embecosm.com/appnotes/ean9/html/ch05s02.html). Rust code can be compiled without the standard library, in which case there is no runtime at all. +Not in the typical sense used by languages such as Java, but parts of the Rust standard library can be considered a "runtime", providing a heap, backtraces, unwinding, and stack guards. There is a [small amount of initialization code](https://github.com/rust-lang/rust/blob/33916307780495fe311fe9c080b330d266f35bfb/src/libstd/rt.rs#L43) that runs before the user's `main` function. The Rust standard library additionally links to the the C standard library, which does similar [runtime initialization](http://www.embecosm.com/appnotes/ean9/html/ch05s02.html). Rust code can be compiled without the standard library, in which case the runtime is roughly equivalent to C's.

    Syntax

    -### Why curly braces? Why can't everything be like Haskell/Python? +### Why curly braces? Why can't Rust's syntax be like Haskell's or Python's? Use of curly braces to denote blocks is a common design choice in a variety of programming languages, and Rust's consistency is useful for people already familiar with the style. @@ -93,23 +101,23 @@ Curly braces also allow for more flexible syntax for the programmer, a simpler p ### I can leave out parentheses on `if` conditions, so why do I have to put brackets around single line blocks? Why is the C style not allowed? -Whereas C requires mandatory parantheses for `if`-statements but leaves brackets optional, Rust makes the opposite choice. Rust's `if`-expressions thus require strictly fewer delimiters than their C counterparts. Furthermore, the optional brackets on C's `if`-statements are well-understood as a hazard to maintenance and refactoring. +Whereas C requires mandatory parentheses for `if`-statement conditionals but leaves brackets optional, Rust makes the opposite choice for its `if`-expressions. This keeps the conditional clearly separate from the body and avoids the hazard of optional brackets, which can lead to easy-to-miss errors during refactoring. ### Why is there no literal syntax for dictionaries? -The reason Rust does not have syntax for initializing dictionaries — or collections in general — is due to Rust's overall design preference for limiting the size of the *language* while enabling powerful *libraries*. The only type of collection that Rust has direct syntax for initializing is the array type, which is also the only type of collection built into the language. Note that Rust does not even have syntax for initializing the common `Vec` collection type, instead the standard library defins the [`vec!`](http://doc.rust-lang.org/std/macro.vec!.html) macro. +The reason Rust does not have syntax for initializing dictionaries — or collections in general — is due to Rust's overall design preference for limiting the size of the *language* while enabling powerful *libraries*. The only type of collection that Rust has direct syntax for initializing is the array type, which is also the only type of collection built into the language. Note that Rust does not even have syntax for initializing the common `Vec` collection type, instead the standard library defines the [`vec!`](http://doc.rust-lang.org/std/macro.vec!.html) macro. This design choice of using Rust's macro facilities to initialize collections will likely be extended generically to other collections in the future, enabling simple initialization of not only `HashMap` and `Vec`, but also other collection types such as [`BTreeMap`](http://doc.rust-lang.org/collections/struct.BTreeMap.html). In the meantime, if you want a more convenient syntax for initializing collections, you can [create your own macro](http://stackoverflow.com/questions/27582739/how-do-i-create-a-hashmap-literal) to provide it. ### When should I use an implicit return? -Implicit returns are simply a coding style option, and can be used anywhere they make sense. While early returns require an explicit `return`, any other return can be made implicit according to your preferences or the preferences of your project. In the Rust project itself, the style guidelines lean toward preferring implicit returns. +Implicit returns are simply a coding style option, and can be used as the final line in a block expression. While early returns require an explicit `return` keyword, any other return can be made implicit according to your preferences or the preferences of your project. In the Rust project itself, the style guidelines lean toward preferring implicit returns. ### Why aren't function signatures inferred? -- Mechanically, it simplifies the inference algorithm, as inference only requires looking at one function at a time. - Mandatory function signatures help enforce interface stability at both the module and crate level. - It improves code comprehension for the programmer, eliminating the need for an IDE running an inference algorithm across an entire crate to be able to guess at a function's argument types; it's always explicit and nearby. +- Mechanically, it simplifies the inference algorithm, as inference only requires looking at one function at a time. ### Why does `match` have to be exhaustive? @@ -130,7 +138,7 @@ match val.do_something() { The choice of which to use is dependent on the purpose of the program. -If you are interested in the greatest degree of precision with your floating point numbers, then prefer `f64`. If you are more interested in keeping the size of the value small or being maximally efficient, and are not concerned about the associated innacuracy of having fewer bits per value, then `f32` is better. Operations on `f32` are usually faster, even on 64-bit hardware. As a common example, graphics programming typically uses `f32` because it requires high performance, and 32-bit floats are sufficient for representing pixels on the screen. +If you are interested in the greatest degree of precision with your floating point numbers, then prefer `f64`. If you are more interested in keeping the size of the value small or being maximally efficient, and are not concerned about the associated inaccuracy of having fewer bits per value, then `f32` is better. Operations on `f32` are usually faster, even on 64-bit hardware. As a common example, graphics programming typically uses `f32` because it requires high performance, and 32-bit floats are sufficient for representing pixels on the screen. If in doubt, choose `f64` for the greater precision. @@ -179,7 +187,7 @@ fn say_hello(name: &str) { You cannot. At least not without a firm understanding of what you mean by "character", and preprocessing the string to find the index of the desired character. -Rust strings are UTF-8 encoded. A single visual character in UTF-8 is not necessarily a single byte as it would be in an ASCII-encoded string. Each byte is called a "code unit" (in UTF-16, code units are 2 bytes; in UTF-32 they are 4 bytes). "Code points" are composed of one or more code units, and combine in "grapheme clusters" which most closely approximate characters. +Rust strings are UTF-8 encoded. A single visual character in UTF-8 is not necessarily a single byte as it would be in an ASCII-encoded string. Each byte is called a "code unit" (in UTF-16, code units are 2 bytes; in UTF-32 they are 4 bytes). "Code points" are composed of one or more code units, and combine in "grapheme clusters" which most closely approximate characters. Thus, even though you may index on bytes in a UTF-8 string, you can't access the `i`th code point or grapheme cluster in constant time. However, if you know at which byte that desired code point or grapheme cluster begins, then you _can_ access it in constant time. Functions including `str::find()` and regex matches return byte indices, facilitating this sort of access. @@ -189,7 +197,7 @@ The `str` type is UTF-8 because we observe more text in the wild in this encodin This does mean that locating a particular Unicode codepoint inside a string is an O(n) operation, although if the starting byte index is already known then they can be accessed in O(1) as expected. On the one hand, this is clearly undesirable; on the other hand, this problem is full of trade-offs and we'd like to point out a few important qualifications: -Scanning a `str` for ASCII-range codepoints can still be done safely byte-at-a-time. If you use `.as_bytes()`, pulling out a `u8` costs only `O(1)` and produces a value that can be cast and compared to an ASCII-range `char`. So if you're (say) line-breaking on `'\n'`, byte-based treatment still works. UTF8 was well-designed this way. +Scanning a `str` for ASCII-range codepoints can still be done safely byte-at-a-time. If you use `.as_bytes()`, pulling out a `u8` costs only `O(1)` and produces a value that can be cast and compared to an ASCII-range `char`. So if you're (say) line-breaking on `'\n'`, byte-based treatment still works. UTF-8 was well-designed this way. Most "character oriented" operations on text only work under very restricted language assumptions such as "ASCII-range codepoints only". Outside ASCII-range, you tend to have to use a complex (non-constant-time) algorithm for determining linguistic-unit (glyph, word, paragraph) boundaries anyway. We recommend using an "honest" linguistically-aware, Unicode-approved algorithm. @@ -209,7 +217,7 @@ For example, a doubly-linked list requires that there be two mutable references ### How can I iterate over a collection without moving/consuming it? -The easiest way is by using the collection's `IntoIterator` implementation. Here is an example for `Vec`: +The easiest way is by using the collection's `IntoIterator` implementation. Here is an example for `&Vec`: ```rust let v = vec![1,2,3,4,5]; @@ -219,7 +227,9 @@ for item in &v { println!("\nLength: {}", v.len()); ``` -The way Rust `for` loops work, they actually call `into_iter()` (which is defined in the `IntoIterator` trait) for whatever you are trying to iterate over. `IntoIterator` is implemented for `&Vec` and `&mut Vec`, meaning you can iterate over a vector without consuming it by using `&v` or `&mut v` (for some vector `v`). The same is true for the other standard collections as well. +Rust `for` loops call `into_iter()` (defined on the `IntoIterator` trait) for whatever they're iterating over. Anything implementing the `IntoIterator` trait may be looped over with a `for` loop. `IntoIterator` is implemented for `&Vec` and `&mut Vec`, causing the iterator from `into_iter()` to borrow the contents of the collection, rather than moving/consuming them. The same is true for other standard collections as well. + +If a moving/consuming iterator is desired, write the `for` loop without `&` or `&mut` on the collection. ### Why do I need to type the array size in the array declaration? @@ -231,13 +241,14 @@ One thing to note is that currently Rust doesn't offer generics over arrays of d ### How can I implement a graph or other data structure that contains cycles? -There are three major options: +There are four major options: - You can implement it using `Rc` and `Weak` to allow shared ownership of nodes, although this approach pays the cost of memory management. - You can implement it using `unsafe` code using raw pointers. This will be more efficient, but bypasses Rust's safety guarantees. - Using vectors and indices into those vectors. There are [several](http://smallcultfollowing.com/babysteps/blog/2015/04/06/modeling-graphs-in-rust-using-vector-indices/) [available](http://featherweightmusings.blogspot.com/2015/04/graphs-in-rust.html) examples and explanations of this approach. +- Using borrowed references with `UnsafeCell`. There are [explanations and code](https://github.com/nrc/r4cppp/blob/master/graphs/README.md#node-and-unsafecell) available for this approach. ### How can I define a struct that contains a pointer to one of its own fields? @@ -263,7 +274,7 @@ fn main() { ### What does it mean to "consume a value"? -"Consuming a value" means taking ownership of a value. When this is done, the value can't be used elsewhere. +"Consuming a value" means taking ownership of a value. When this is done, the value can't be used elsewhere. "Consume" is a fairly evocative term for this event. ### What is the difference between consuming and moving/taking ownership? @@ -300,16 +311,15 @@ While the rules themselves are simple, making sure your code conforms to them ca ### How do deref coercions work? -[Deref coercions](https://doc.rust-lang.org/book/deref-coercions.html) exist to make using Rust more ergonomic, and are implemented via the [`Deref`](https://doc.rust-lang.org/stable/std/ops/trait.Deref.html) trait, which looks like +[Deref coercions](https://doc.rust-lang.org/book/deref-coercions.html) exist to make using Rust more ergonomic, and are implemented via the [`Deref`](https://doc.rust-lang.org/stable/std/ops/trait.Deref.html) trait. -```rust -pub trait Deref { - type Target: ?Sized; - fn deref(&self) -> &Self::Target; -} -``` +A Deref implementation indicates that the implementing type may be converted into a target by a call to the `deref` method, which takes an immutable reference to the calling type and returns a reference (of the same lifetime) to the target type. The `*` prefix operator is shorthand for the `deref` method. -A Deref implementation indicates that the implementing type may be converted into `Target` by a call to the `deref` function, which takes an immutable reference of a certain lifetime to the calling struct, and returns a reference of the same lifetime to the target. The `*` prefix operator is shorthand for the `deref` method. +They're called "coercions" because of the following rule, quoted here [from the Rust book](https://doc.rust-lang.org/stable/book/deref-coercions.html): + +> If you have a type `U`, and it implements `Deref`, values of `&U` will automatically coerce to a `&T`. + +For example, if you have a `&Rc`, it will coerce via this rule into a `&String`, which then coerces to a `&str` in the same way. So if a function takes a `&str` parameter, you can pass in a `&Rc` directly, with all coercions handled automatically via the `Deref` trait. You can see a [full list of `Deref` implementations](https://doc.rust-lang.org/stable/std/ops/trait.Deref.html#implementors) for the standard library in the documentation. @@ -321,7 +331,7 @@ Lifetimes are Rust's answer to the question of memory safety. They allow Rust to ### Why is the lifetime syntax the way it is? -The `'a` syntax comes from the ML family of programming languages, where `'a` is used to indicate a generic type parameter. For Rust, the syntax had to be something that was unambiguous, noticeable, and fit nicely in a type declaration right alonside traits and references. Alternative syntaxes have been discussed, but this seems to work fine. +The `'a` syntax comes from the ML family of programming languages, where `'a` is used to indicate a generic type parameter. For Rust, the syntax had to be something that was unambiguous, noticeable, and fit nicely in a type declaration right alonside traits and references. Alternative syntaxes have been discussed, but no alternative syntax has been demonstrated to be clearly better. ### When is `Rc` useful? @@ -329,7 +339,46 @@ This is covered in the [official documentation for `Rc`](https://doc.rust-lang.o ### How do I return a borrow to something I created from a function? -You need to ensure that the borrowed item will outlive the function. This can be done by binding the output lifetime to some input lifetime. An alternative is to return an owning type like `String`. This eliminates the reference issues entirely, at the cost of possibly unnecessary allocations. There is also the `Cow` ("copy on write") type, which will only do the extra allocation if you attempt to mutate the contained value. +You need to ensure that the borrowed item will outlive the function. This can be done by binding the output lifetime to some input lifetime like so: + +```rust +type Pool = TypedArena; + +// (the lifetime below is only written explicitly for +// expository purposes; it can be omitted via the +// elision rules described in a later FAQ entry) +fn create_borrowed<'a>(pool: &'a Pool, + x: i32, + y: i32) -> &'a Thing { + pool.alloc(Thing { x: x, y: y }) +} +``` + +An alternative is to eliminate the references entirely by returning an owning type like `String`: + +```rust +fn happy_birthday(name: &str, age: i64) -> String { + format!("Hello {}! You're {} years old!", name, age) +} +``` + +This approach is simpler, but often results in unnecessary allocations. + +There is also the `Cow` ("copy on write") type, which will only do the extra allocation if you attempt to mutate the contained value: + +```rust +use std::borrow::Cow; + +fn abs_all(input: &mut Cow<[i32]>) { + for i in 0..input.len() { + let v = input[i]; + if v < 0 { + // clones into a vector the first time (if not already owned) + input.to_mut()[i] = -v; + } + } +} +``` ### How do I return a closure from a function? @@ -363,11 +412,13 @@ Functions that accept [trait objects](http://doc.rust-lang.org/book/trait-object ### What's the difference between a function and a closure that doesn't capture any variables? +Functions and closures are operationally equivalent, but have different runtime representations due to their differing implementations. + Functions are a built-in primitive of the language, while closures are essentially syntactic sugar for one of three traits: `Fn`, `FnMut`, and `FnOnce`. When you make a closure, the Rust compiler automatically creates a struct implementing the appropriate trait of those three and containing the captured environment variables as members, and makes it so the struct can be called as a function. Bare functions can not capture an environment. The big difference between these traits is how they take the `self` parameter. `Fn` takes `&self`, `FnMut` takes `&mut self`, and `FnOnce` takes `self`. -In the end, functions and closures are operationally equivalent, but have different runtime representations due to their different implementations (as a language primitive and a syntactic sugar over traits, respectively). +Even if a closure does not capture any environment variables, it is represeted at runtime as two points, same as any other closure. ### What are higher-kinded types, why would I want them, and why doesn't Rust have them? @@ -379,9 +430,11 @@ Rust doesn't currently have them simply because they haven't been a priority. Th ### What do named type parameters like `` in generic types mean? -These are called [associated types](https://doc.rust-lang.org/stable/book/associated-types.html), and they allow for the expression of trait bounds that can't be expressed with a `where` clause. In essence, for a generic type with some type parameters, it is often unecessary to include those type parameters in a function taking that generic type as a parameter. The function shouldn't have to care about being generic over the types which make up the generic type (say, the node and edge types in a graph), but only about being generic over the type itself. +These are called [associated types](https://doc.rust-lang.org/stable/book/associated-types.html), and they allow for the expression of trait bounds that can't be expressed with a `where` clause. For example, a generic bound `X: Bar` means "`X` must implement the trait `Bar`, and in that implementation of `Bar`, `X` must choose `Foo` for `Bar`'s associated type, `T`." Examples of where such a constraint cannot be expressed via a `where` clause include trait objects like `Box>`. -### Can I override operators? Which ones and how? +Associated types exist because, for a generic type with some type parameters, it is often unecessary to include those type parameters in a function taking that generic type as a parameter. The function shouldn't have to care about being generic over the types which make up the generic type (say, the node and edge types in a graph), but only about being generic over the type itself. + +### Can I overload operators? Which ones and how? You can provide custom implementations for a variety of operators using their associated traits: `Add` for `+`, `Mul` for `*`. It looks like this: @@ -495,7 +548,7 @@ It's probably an issue with the function's return type. The [`try!` macro](https ### Is there an easier way to do error handling than having `Result`s everywhere? -If you're looking for a way to avoid handling `Result`s in other people's code, there's always `unwrap()`, but it's probably not what you want. `Result` is an indicator that some computation may or may not complete successfully. Requiring you to handle these failures explicitly is one of the ways that Rust encourages safety. If you really don't want to handle an error, use `unwrap()`, but know that doing so means that the given code will cause the entire process to panic on failure, which is usually undesirable. +If you're looking for a way to avoid handling `Result`s in other people's code, there's always `unwrap()`, but it's probably not what you want. `Result` is an indicator that some computation may or may not complete successfully. Requiring you to handle these failures explicitly is one of the ways that Rust encourages robustness. If you really don't want to handle an error, use `unwrap()`, but know that doing so means that the given code will cause the entire process to panic on failure, which is usually undesirable.

    Concurrency

    @@ -513,7 +566,7 @@ Not currently. Rust macros are ["hygienic macros"](https://en.wikipedia.org/wiki ### How do I debug Rust programs? -Rust programs can be debugged using [gdb](http://sourceware.org/gdb/current/onlinedocs/gdb/) or [lldb](http://lldb.llvm.org/tutorial.html), same as C and C++. In fact, every Rust installation comes with rust-gdb and rust-lldb, wrappers over gdb and lldb with Rust pretty-printing enabled. +Rust programs can be debugged using [gdb](http://sourceware.org/gdb/current/onlinedocs/gdb/) or [lldb](http://lldb.llvm.org/tutorial.html), same as C and C++. In fact, every Rust installation comes with one or both of rust-gdb and rust-lldb (depending on platform support). These are wrappers over gdb and lldb with Rust pretty-printing enabled. ### `rustc` said a panic occurred in standard library code. How do I locate the mistake in my code? @@ -578,22 +631,22 @@ Yes it can! There are already examples of using Rust for both [Android](https:// ### Can I run my Rust program in a web browser? -Not yet, but there are efforts underway to make Rust compile to the web with Emscripten. +Not yet, but there are efforts underway to make Rust compile to the web with [Emscripten](http://kripken.github.io/emscripten-site/). ### How do I cross-compile in Rust? -Cross compilation is possible in Rust, but it requires [a bit of work](https://github.com/japaric/ruststrap/blob/master/1-how-to-cross-compile.md) to set up. Rust does distribute [copies of the standard library](http://static.rust-lang.org/dist/) for each of the supported platforms, which are contained in the `rust-std-*` files for each of the build directories found on the distribution page, but there are not yet automated ways to install them. +Cross compilation is possible in Rust, but it requires [a bit of work](https://github.com/japaric/ruststrap/blob/master/1-how-to-cross-compile.md) to set up. Every Rust compiler is a cross-compiler, but libraries need to be cross-compiled for the target platform. + +Rust does distribute [copies of the standard library](http://static.rust-lang.org/dist/) for each of the supported platforms, which are contained in the `rust-std-*` files for each of the build directories found on the distribution page, but there are not yet automated ways to install them.

    Modules and Crates

    ### What is the relationship between a module and a crate? - A crate is a compilation unit, which is the smallest amount of code that the Rust compiler can operate on. -- A module is a (possibly nested) unit of name-management inside a crate. +- A module is a (possibly nested) unit of code organization inside a crate. - A crate contains an implicit, un-named top-level module. - Recursive definitions can span modules, but not crates. -- Crates do not have global names, only a set of non-unique metadata tags. -- There is no global inter-crate namespace; all name management occurs within a crate. - Using another crate binds the root of its namespace into the user's namespace. ### Why can't the Rust compiler find this library I'm `use`ing? @@ -728,6 +781,10 @@ Yes you can! The major game programming library for Rust is [Piston](http://www. It is multi-paradigm. Many things you can do in OO languages you can do in Rust, but not everything, and not always using the same abstraction you're accustomed to. +### How do I map object-oriented concepts to Rust? + +That depends. There _are_ ways of translating object-oriented concepts like [multiple inheritance](https://www.reddit.com/r/rust/comments/2sryuw/ideaquestion_about_multiple_inheritence/) to Rust, but as Rust is not object-oriented the result of the translation may look substantially different from its appearance in an OO language. + ### How do I handle configuration of a struct with optional parameters? The easiest way is to use the `Option` type in whatever function you're using to construct instances of the struct (usually `new()`). Another way is to use the [builder pattern](https://aturon.github.io/ownership/builders.html), where only certain functions instantiating member variables must be called before the construction of the built type. @@ -748,10 +805,6 @@ To define procedural constants that can't be defined via these mechanisms, use t Rust has no concept of "life before `main`". The closest you'll see can be done through the [`lazy_static`](https://github.com/Kimundi/lazy-static.rs) crate, which simulates a "before main" by lazily initializing static variables at their first usage. -### How do I map object-oriented concepts to Rust? - -That depends. There _are_ ways of translating object-oriented concepts like [multiple inheritance](https://www.reddit.com/r/rust/comments/2sryuw/ideaquestion_about_multiple_inheritence/) to Rust, but as Rust is not object-oriented the result of the translation may look substantially different from its appearance in an OO language. - ### Why doesn't Rust have inheritance? There are two meanings for the word "inheritance": _subtyping_, and _interface sharing_. Both purposes are already handled by traits. @@ -798,7 +851,7 @@ Yes. The Rust code has to be exposed via an `extern` declaration, which makes it Modern C++ includes many features that make writing safe and correct code less error-prone, but it's not perfect, and it's still easy to introduce unsafety. This is something the C++ core developers are working to overcome, but C++ is limited by a long history that predates a lot of the ideas they are now trying to implement. -Rust was designed from day one to be a safe systems programming language, which means it's not limited by historic design decisions that make getting safety right in C++ so complicated. In C++, safety is achieved by careful personal discipline, and is very easy to get wrong. In Rust, safety is the default. +Rust was designed from day one to be a safe systems programming language, which means it's not limited by historic design decisions that make getting safety right in C++ so complicated. In C++, safety is achieved by careful personal discipline, and is very easy to get wrong. In Rust, safety is the default. It gives you the ability to work in a team that includes people less perfect than you are, without having to spend your time double-checking their code for safety bugs. ### How do I do the equivalent of C++ template specialization in Rust? @@ -854,7 +907,7 @@ In Swift, `?` is used to indicate an optional value. This is already done by `Op Rust and Go have substantially different design goals. The following differences are not the only ones (which are too numerous to list), but are a few of the more important ones: -- Rust is lower level than Go, comparable with C and C++. It provides access to memory management primitives that do not exist in Go (which has a garbage collector). +- Rust provides access to memory management primitives that do not exist in Go, which has a garbage collector. - Rust's focus is on ensuring safety and efficiency while also providing high-level affordances, while Go's is on being a small, simple language which compiles quickly and can work nicely with a variety of tools. - Rust has strong support for generics, which Go does not. - Rust has strong influences from the world of functional programming, including a type system which draws from Haskell's typeclasses. Go has a simpler type system, using interfaces for basic generic programming. @@ -879,7 +932,7 @@ Some specific difference between Haskell typeclasses and Rust traits include: ### Where do I report issues in the Rust documentation? -You can report issues in the Rust documentation on the Rust compiler [issue tracker](https://github.com/rust-lang/rust/issues). Make sure to read the [contributing guidelines](https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md) first. +You can report issues in the Rust documentation on the Rust compiler [issue tracker](https://github.com/rust-lang/rust/issues). Make sure to read the [contributing guidelines](https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#writing-documentation) first. ### How do I view rustdoc documentation for a library my project depends on? @@ -906,7 +959,7 @@ No. Rust started as Graydon Hoare's part-time side project in 2006 and remained As far as [project governance](https://github.com/rust-lang/rfcs/blob/master/text/1068-rust-governance.md) goes, Rust is managed by a core team that sets the vision and priorities for the project, and accepts input on the design of the language via RFC proposals. There are also subteams to guide and foster development of particular areas of interest, including Rust libraries, Rust tools, and moderation of the official Rust communities. For changes which do not require an RFC, decisions are made through pull requests on the [`rustc` repository](https://github.com/rust-lang/rust). -### What are some design goals of Rust? +### What are some non-goals of Rust? 1. We do not employ any particularly cutting-edge technologies. Old, established techniques are better. 2. We do not prize expressiveness, minimalism or elegance above other goals. These are desirable but subordinate goals. From 7ba7f3dfd3ab41f2f1fe73598623479c68c3b4cf Mon Sep 17 00:00:00 2001 From: Andrew Brinker Date: Thu, 7 Jan 2016 19:00:47 -0500 Subject: [PATCH 51/94] New draft of the higher-kinded types answer --- faq.md | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/faq.md b/faq.md index 8b780204b..c10d6d7c5 100644 --- a/faq.md +++ b/faq.md @@ -422,11 +422,13 @@ Even if a closure does not capture any environment variables, it is represeted a ### What are higher-kinded types, why would I want them, and why doesn't Rust have them? -Higher-kinded types are types with unfilled parameters. Support for higher-kinded types means "incomplete" types may be used anywhere "complete" types can be used, such as in a trait `impl`. +Higher-kinded types are typed with unfilled parameters. Type constructors, like `Vec`, `Result`, and `HashMap` are all examples of higher-kinded types. Support for higher-kinded types means these "incomplete" types may be used anywhere "complete" types can be used, such as trait `impl`s. -The lack of support for higher-kinded types makes expression of certain ideas more tedious than it would otherwise be. For example, implementing a `Functor` trait (a term for a container which can be mapped over, obeying certain rules) without higher-kinded types would be difficult, as a `Functor` should be implemented for the container regardless of the type of values it contains. With higher-kinded types, the Functor `impl` for some container could leave the container's type parameter unfilled, with no concrete type. +Any complete type, like `i32`, `bool`, or `char` is of kind `*`. A type with one parameter, like `Vec` is of kind `* -> *`, meaning that `Vec` takes in a complete type like `i32` and returns a complete type `Vec`. A type which three parameters, like `HashMap` is of kind `* -> * -> * -> *`, and takes in three complete types (like `i32`, `String`, and `RandomState`) to produce a new complete type `HashMap`. -Rust doesn't currently have them simply because they haven't been a priority. There is nothing inherent to the language that stops us from implementing support for higher-kinded types, it just hasn't been done yet. +The lack of support for higher-kinded types makes expression of certain ideas more tedious than it would otherwise be. For example, implementing a `Functor` trait (a term for a container which can be mapped over, obeying certain rules) without higher-kinded types requires explicit and otherwise unnecessary handling of the container's type parameters. With higher-kined types, a `Functor` `impl` can ignore the parameters entirely. + +Rust doesn't currently have support for higher-kinded types because it hasn't been a priority. There is nothing inherent to the language that stops the support from being implemented. It just hasn't been done yet. ### What do named type parameters like `` in generic types mean? From e7bab6490321709329c1ac904b08f96120be51b3 Mon Sep 17 00:00:00 2001 From: Andrew Brinker Date: Thu, 7 Jan 2016 19:17:20 -0500 Subject: [PATCH 52/94] Partial addition of API doc links --- faq.md | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/faq.md b/faq.md index c10d6d7c5..43ec96db5 100644 --- a/faq.md +++ b/faq.md @@ -75,9 +75,9 @@ Finally, while Rust's preferred strategy of monomorphising generics (ala C++) pr ### Why are Rust's `HashMap`s slow? -By default, Rust's `HashMap` uses the [SipHash](https://131002.net/siphash/) hashing algorithm, which is designed to prevent [hash table collision attacks](http://programmingisterrible.com/post/40620375793/hash-table-denial-of-service-attacks-revisited) while providing [reasonable performance on a variety of workloads](https://www.reddit.com/r/rust/comments/3hw9zf/rust_hasher_comparisons/cub4oh6). +By default, Rust's [`HashMap`](https://doc.rust-lang.org/stable/std/collections/struct.HashMap.html) uses the [SipHash](https://131002.net/siphash/) hashing algorithm, which is designed to prevent [hash table collision attacks](http://programmingisterrible.com/post/40620375793/hash-table-denial-of-service-attacks-revisited) while providing [reasonable performance on a variety of workloads](https://www.reddit.com/r/rust/comments/3hw9zf/rust_hasher_comparisons/cub4oh6). -While SipHash [demonstrates competitive performance](http://cglab.ca/%7Eabeinges/blah/hash-rs/) in many cases, one case where it is notably slower than other hashing algorithms is with short keys, such as integers. This is why Rust programmers often observe slow performance with `HashMap`. The [FNV hasher](https://crates.io/crates/fnv) is frequently recommended for these cases, but be aware that it does not have the same collision-resistance properties as SipHash. +While SipHash [demonstrates competitive performance](http://cglab.ca/%7Eabeinges/blah/hash-rs/) in many cases, one case where it is notably slower than other hashing algorithms is with short keys, such as integers. This is why Rust programmers often observe slow performance with [`HashMap`](https://doc.rust-lang.org/stable/std/collections/struct.HashMap.html). The [FNV hasher](https://crates.io/crates/fnv) is frequently recommended for these cases, but be aware that it does not have the same collision-resistance properties as SipHash. ### Why is there no integrated benchmarking infrastructure? @@ -144,27 +144,27 @@ If in doubt, choose `f64` for the greater precision. ### Why can't I use `f32` or `f64` as `HashMap` keys? -In order to be used as a key in a `HashMap`, a type must implement the `Eq` and `Hash` traits. `f32` and `f64` implement `PartialEq`, but not `Eq`, because one of the potential values for floating-point types is `NaN` (or "not a number"). `NaN` values are [not equal to any float, and are not equal to each other](https://en.wikipedia.org/wiki/NaN). This means that `f32` and `f64` can't be used as keys in a HashMap. +In order to be used as a key in a [`HashMap`](https://doc.rust-lang.org/stable/std/collections/struct.HashMap.html), a type must implement the [`Eq`](https://doc.rust-lang.org/stable/std/cmp/trait.Eq.html) and [`Hash`](https://doc.rust-lang.org/stable/std/hash/trait.Hash.html) traits. [`f32`](https://doc.rust-lang.org/stable/std/primitive.f32.html) and [`f64`](https://doc.rust-lang.org/stable/std/primitive.f64.html) implement [`PartialEq`](https://doc.rust-lang.org/stable/std/cmp/trait.PartialEq.html), but not `Eq`, because one of the potential values for floating-point types is `NaN` (or "not a number"). `NaN` values are [not equal to any float, and are not equal to each other](https://en.wikipedia.org/wiki/NaN). This means that `f32` and `f64` can't be used as keys in a HashMap. ### Why can't I compare floats? -Floats can be compared in some circumstances, but not others. Floats do implement the `PartialOrd` trait, which means that `>`, `<`, `<=`, and `>=` are defined for them. But they do _not_ implement the `Ord` trait, because (thanks to `NaN`) [there is no total ordering for floating point numbers](https://en.wikipedia.org/wiki/IEEE_floating_point#Total-ordering_predicate). The practical effect of this is that data structures that require a total ordering, such as [`BTreeMap`](http://doc.rust-lang.org/std/collections/struct.BTreeMap.html) do not work with floating point numbers. +Floats can be compared in some circumstances, but not others. Floats do implement the [`PartialOrd`](https://doc.rust-lang.org/stable/std/cmp/trait.PartialOrd.html) trait, which means that `>`, `<`, `<=`, and `>=` are defined for them. But they do _not_ implement the [`Ord`](https://doc.rust-lang.org/stable/std/cmp/trait.Ord.html) trait, because (thanks to `NaN`) [there is no total ordering for floating point numbers](https://en.wikipedia.org/wiki/IEEE_floating_point#Total-ordering_predicate). The practical effect of this is that data structures that require a total ordering, such as [`BTreeMap`](http://doc.rust-lang.org/std/collections/struct.BTreeMap.html) do not work with floating point numbers. There [is a crate](https://crates.io/crates/ordered-float) that provides a total ordering on floats by wrapping them, which may be desirable depending on your use-case. You can still do all of the normal comparison operations you would expect, but you can't use the `cmp` function. ### How can I convert between numeric types? -There are two ways: the `as` keyword, which does simple casting for primitive types, and the `Into` and `From` traits, which are implemented for a number of type conversions (and which you can implement for your own types). The `Into` and `From` traits are only implemented in cases where conversions are lossless, so for example, `f64::from(0f32)` will compile while `f32:from(0f64)` will not. On the other hand, `as` will convert between any two primitive types, truncating values as necessary. +There are two ways: the `as` keyword, which does simple casting for primitive types, and the [`Into`](https://doc.rust-lang.org/stable/std/convert/trait.Into.html) and [`From`](https://doc.rust-lang.org/stable/std/convert/trait.From.html) traits, which are implemented for a number of type conversions (and which you can implement for your own types). The `Into` and `From` traits are only implemented in cases where conversions are lossless, so for example, `f64::from(0f32)` will compile while `f32:from(0f64)` will not. On the other hand, `as` will convert between any two primitive types, truncating values as necessary.

    Strings

    ### How can I convert a `String` or `Vec` to a slice (`&str` and `&[T]`)? -Using [Deref coercions](https://doc.rust-lang.org/stable/book/deref-coercions.html), `Strings` and `Vec`s will automatically coerce to their respective slices when passed by reference with `&` or `& mut`. +Using [Deref coercions](https://doc.rust-lang.org/stable/book/deref-coercions.html), [`String`s](https://doc.rust-lang.org/stable/std/string/struct.String.html) and [`Vec`s](https://doc.rust-lang.org/stable/std/vec/struct.Vec.html) will automatically coerce to their respective slices when passed by reference with `&` or `& mut`. ### How can I convert from `&str` to `String` or the other way around? -The `to_owned()` method converts from a `&str` into a `String`, and `String`s are automatically converted into `&str` when you borrow a reference to them. Both are demonstrated in the following example: +The [`to_owned()`](https://doc.rust-lang.org/stable/std/borrow/trait.ToOwned.html#tymethod.to_owned) method converts from a [`&str`](https://doc.rust-lang.org/stable/std/primitive.str.html) into a [`String`](https://doc.rust-lang.org/stable/std/string/struct.String.html), and `String`s are automatically converted into `&str` when you borrow a reference to them. Both are demonstrated in the following example: ```rust fn main() { @@ -179,7 +179,7 @@ fn say_hello(name: &str) { ### What are the differences between the two different string types? -`String` is an owned buffer of UTF-8 bytes allocated on the heap. Mutable `String`s can be modified, growing their capacity as needed. `&str` is a fixed-capacity "view" into a `String` allocated elsewhere, commonly on the heap, in the case of slices dereferenced from `String`s, or in static memory, in the case of string literals. +[`String`](https://doc.rust-lang.org/stable/std/string/struct.String.html) is an owned buffer of UTF-8 bytes allocated on the heap. Mutable `String`s can be modified, growing their capacity as needed. `&str` is a fixed-capacity "view" into a `String` allocated elsewhere, commonly on the heap, in the case of slices dereferenced from `String`s, or in static memory, in the case of string literals. `&str` is a primitive type implemented by the Rust language, while `String` is implemented in the standard library. From 1594ab32b6e305090c5af87bcdd23bc53e85df10 Mon Sep 17 00:00:00 2001 From: Andrew Brinker Date: Thu, 7 Jan 2016 19:18:14 -0500 Subject: [PATCH 53/94] Fixed based on feedback from pnkfelix --- faq.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/faq.md b/faq.md index 43ec96db5..7b02c11f6 100644 --- a/faq.md +++ b/faq.md @@ -229,7 +229,7 @@ println!("\nLength: {}", v.len()); Rust `for` loops call `into_iter()` (defined on the `IntoIterator` trait) for whatever they're iterating over. Anything implementing the `IntoIterator` trait may be looped over with a `for` loop. `IntoIterator` is implemented for `&Vec` and `&mut Vec`, causing the iterator from `into_iter()` to borrow the contents of the collection, rather than moving/consuming them. The same is true for other standard collections as well. -If a moving/consuming iterator is desired, write the `for` loop without `&` or `&mut` on the collection. +If a moving/consuming iterator is desired, write the `for` loop without `&` or `&mut` in the iteration. ### Why do I need to type the array size in the array declaration? From ffb11a7694ea7e01ab1964df56e816bfca6b27fa Mon Sep 17 00:00:00 2001 From: Andrew Brinker Date: Thu, 7 Jan 2016 21:45:17 -0500 Subject: [PATCH 54/94] Small correction --- faq.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/faq.md b/faq.md index 7b02c11f6..c298457dd 100644 --- a/faq.md +++ b/faq.md @@ -390,7 +390,7 @@ Lifetimes can often be elided, as explained in the ["Lifetime elision" section]( - Each elided lifetime in a function’s arguments becomes a distinct lifetime parameter. - If there is exactly one input lifetime, elided or not, that lifetime is assigned to all elided lifetimes in the return values of that function. -- If there are multiple input lifetimes, but one of them is &self or &mut self, the lifetime of self is assigned to all elided output lifetimes. +- If there are multiple input lifetimes, but one of them is `&self` or `&mut` self, the lifetime of self is assigned to all elided output lifetimes. If these rules would result in incorrect code elsewhere, then the Rust compiler will provide errors, and you will need to define the relevant lifetimes to correct that error. From ea304edfbfbda325f59e1c676b4c10f139b905b0 Mon Sep 17 00:00:00 2001 From: Andrew Brinker Date: Sat, 9 Jan 2016 12:01:34 -0500 Subject: [PATCH 55/94] Updated based on latest feedback --- faq.md | 34 +++++++++++++++++++++++++--------- 1 file changed, 25 insertions(+), 9 deletions(-) diff --git a/faq.md b/faq.md index c298457dd..d76ad1779 100644 --- a/faq.md +++ b/faq.md @@ -111,7 +111,25 @@ This design choice of using Rust's macro facilities to initialize collections wi ### When should I use an implicit return? -Implicit returns are simply a coding style option, and can be used as the final line in a block expression. While early returns require an explicit `return` keyword, any other return can be made implicit according to your preferences or the preferences of your project. In the Rust project itself, the style guidelines lean toward preferring implicit returns. +Rust is a very expression-oriented language, and implicit returns are part of that design. `if`s, `match`es, and normal blocks are all expressions in Rust. For example, the following code checks if an `i64` is odd, returning the result with an implicit return: + +```rust +fn is_odd(x: i64) -> bool { + if x % 2 == 1 { true } else { false } +} +``` + +Although it can be simplified even further like so: + +```rust +fn is_odd(x: i64) -> bool { + x % 2 == 1 +} +``` + +In each example, the last line of the function is the return value of that function. It is important to note that if a function ends in a semicolon, its return type will be `()`, indicating no returned value. Implicit returns must omit the semicolon to work. + +Explicit returns are only used if an implicit return is impossible because you are returning before the end of the function's body. While each of the above functions could have been written with a `return` keyword and semicolon, doing so would be unnecessarily verbose, and inconsistent with the conventions of Rust code. ### Why aren't function signatures inferred? @@ -556,7 +574,9 @@ If you're looking for a way to avoid handling `Result`s in other people's code, ### Can I use static values across threads without an `unsafe` block? -Yes, if the type implements `Sync`, doesn't implement `Drop`, and you don't try to mutate the value. +Mutation is safe if it's synchronized. Mutating a static `Mutex` (lazily initialized via the [lazy_static](https://crates.io/crates/lazy_static/) crate) does not require an `unsafe` block, nor does mutating a static `AtomicUsize` (which can be initialized without lazy_static). + +More generally, if a type implements `Sync` and does not implement `Drop`, it [can be used in a `static`](https://doc.rust-lang.org/book/const-and-static.html#static).

    Macros

    @@ -793,9 +813,7 @@ The easiest way is to use the `Option` type in whatever function you're using to ### How do I do global variables in Rust? -Globals in Rust can be done using `const` declarations for compile-time computed global constants, while `static` can be used for mutable globals. Note that modifying a `static` variable requires the use of `unsafe`, as it allows for data races, one of the things guaranteed not to happen in safe Rust. One important distinction between `const` and `static` values is that you can take references to `static` values, but not references to `const` values, which don't have a specified memory location. For more information on `const` vs. `static`, read [the Rust book](https://doc.rust-lang.org/book/const-and-static.html). - -You can also use the `RefCell` and `Option` type to provide interior mutability of an optional global value. It is important to note that `RefCell`s are not thread-safe. +Globals in Rust can be done using `const` declarations for compile-time computed global constants, while `static` can be used for mutable globals. Note that modifying a `static mut` variable requires the use of `unsafe`, as it allows for data races, one of the things guaranteed not to happen in safe Rust. One important distinction between `const` and `static` values is that you can take references to `static` values, but not references to `const` values, which don't have a specified memory location. For more information on `const` vs. `static`, read [the Rust book](https://doc.rust-lang.org/book/const-and-static.html). ### How can I set compile-time constants that are defined procedurally? @@ -823,6 +841,8 @@ No. Globals cannot have a non-constant-expression constructor and cannot have a See the [C++ FQA](http://yosefk.com/c++fqa/ctors.html#fqa-10.12) about the "static initialization order fiasco", and [Eric Lippert's blog](http://ericlippert.com/2013/02/06/static-constructors-part-one/) for the challenges in C#, which also has this feature. +You can approximate non-constant-expression globals with the [lazy_static](https://crates.io/crates/lazy_static/) crate. +

    Other Languages

    ### How can I implement something like C's `struct X { static int X; };` in Rust? @@ -901,10 +921,6 @@ Not exactly. Types which implement `Copy` will do a standard C-like "shallow cop No. Values of all types are moved via `memcpy`. This makes writing generic unsafe code much simpler since assignment, passing and returning are known to never have a side effect like unwinding. -### Why does Rust not have the ? and ! like in Swift? - -In Swift, `?` is used to indicate an optional value. This is already done by `Option` in Rust, and so `?` is not needed. Similarly, `!` is used to "unwrap" an optional value in Swift, which is done by the `unwrap()` function in Rust. In both cases, Rust opted for slightly longer names which more clearly indicate intent. Also, in Rust the `!` symbol already indicates logical negation and macro calls, and does not need a third meaning. - ### How are Go and Rust similar, and how are they different? Rust and Go have substantially different design goals. The following differences are not the only ones (which are too numerous to list), but are a few of the more important ones: From 8e490bbc073becf55b9aefc042d56e19cf64ca0a Mon Sep 17 00:00:00 2001 From: Andrew Brinker Date: Sat, 9 Jan 2016 12:22:05 -0500 Subject: [PATCH 56/94] Updated ord/eq answers --- faq.md | 18 +++++++++++++----- 1 file changed, 13 insertions(+), 5 deletions(-) diff --git a/faq.md b/faq.md index d76ad1779..5963d9079 100644 --- a/faq.md +++ b/faq.md @@ -160,15 +160,23 @@ If you are interested in the greatest degree of precision with your floating poi If in doubt, choose `f64` for the greater precision. -### Why can't I use `f32` or `f64` as `HashMap` keys? +### Why can't I compare floats? -In order to be used as a key in a [`HashMap`](https://doc.rust-lang.org/stable/std/collections/struct.HashMap.html), a type must implement the [`Eq`](https://doc.rust-lang.org/stable/std/cmp/trait.Eq.html) and [`Hash`](https://doc.rust-lang.org/stable/std/hash/trait.Hash.html) traits. [`f32`](https://doc.rust-lang.org/stable/std/primitive.f32.html) and [`f64`](https://doc.rust-lang.org/stable/std/primitive.f64.html) implement [`PartialEq`](https://doc.rust-lang.org/stable/std/cmp/trait.PartialEq.html), but not `Eq`, because one of the potential values for floating-point types is `NaN` (or "not a number"). `NaN` values are [not equal to any float, and are not equal to each other](https://en.wikipedia.org/wiki/NaN). This means that `f32` and `f64` can't be used as keys in a HashMap. +Floats can be compared with the `==`, `!=`, `<`, `<=`, `>`, and `>=` operators, and with the `partial_cmp()` function. `==` and `!=` are part of the `PartialEq` trait, while `<`, `<=`, `>`, `>=`, and `partial_cmp()` are part of the `PartialOrd` trait. -### Why can't I compare floats? +Floats cannot be compared with the `cmp()` function, which is part of the `Ord` trait, as there is no total ordering for floats. Furthermore, there is no total equality relation for floats, and so they also do not implement the `Eq` trait. + +There is no total ordering or equality on floats because the floating-point value `NaN` is not less than, greater than, or equal to any other floating-point value or itself. + +Because floats do not implement `Eq` or `Ord`, they may not be used in types whose trait bounds require those traits, such as `BTreeMap`. + +There [is a crate](https://crates.io/crates/ordered-float) that wraps `f32` and `f64` to provide `Ord` and `Eq` implementations, which may be useful in certain cases. + +### Why can't I use `f32` or `f64` as `HashMap` keys? -Floats can be compared in some circumstances, but not others. Floats do implement the [`PartialOrd`](https://doc.rust-lang.org/stable/std/cmp/trait.PartialOrd.html) trait, which means that `>`, `<`, `<=`, and `>=` are defined for them. But they do _not_ implement the [`Ord`](https://doc.rust-lang.org/stable/std/cmp/trait.Ord.html) trait, because (thanks to `NaN`) [there is no total ordering for floating point numbers](https://en.wikipedia.org/wiki/IEEE_floating_point#Total-ordering_predicate). The practical effect of this is that data structures that require a total ordering, such as [`BTreeMap`](http://doc.rust-lang.org/std/collections/struct.BTreeMap.html) do not work with floating point numbers. +In order to be used as a key in a [`HashMap`](https://doc.rust-lang.org/stable/std/collections/struct.HashMap.html), a type must implement the [`Eq`](https://doc.rust-lang.org/stable/std/cmp/trait.Eq.html) and [`Hash`](https://doc.rust-lang.org/stable/std/hash/trait.Hash.html) traits. `Eq` is required because keys have to be capable of being tested for equality, otherwise indexing on keys wouldn't work. `Hash` is required so that the type may be hashed by `HashMap`'s hashing algorithm. -There [is a crate](https://crates.io/crates/ordered-float) that provides a total ordering on floats by wrapping them, which may be desirable depending on your use-case. You can still do all of the normal comparison operations you would expect, but you can't use the `cmp` function. +[`f32`](https://doc.rust-lang.org/stable/std/primitive.f32.html) and [`f64`](https://doc.rust-lang.org/stable/std/primitive.f64.html) implement [`PartialEq`](https://doc.rust-lang.org/stable/std/cmp/trait.PartialEq.html), but not `Eq` This is because one of the potential values for floating-point types is `NaN` (or "not a number"). Per the IEEE floating-point specification, `NaN` values are [not equal to any other floating-point value, and not equal to each other](https://en.wikipedia.org/wiki/NaN). This means there is no total equality relation for floating-point types, and thus that `f32` and `f64` can't implement `Eq` and can't used as keys in a `HashMap`. ### How can I convert between numeric types? From 6705771fe1da83876ead054d9c38770b73ccb974 Mon Sep 17 00:00:00 2001 From: Andrew Brinker Date: Sat, 9 Jan 2016 12:32:15 -0500 Subject: [PATCH 57/94] Updated borrow checker answer --- faq.md | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/faq.md b/faq.md index 5963d9079..60821ae27 100644 --- a/faq.md +++ b/faq.md @@ -333,7 +333,15 @@ The borrow checker applies only a few rules, which can be found in the Rust book > - one or more references (&T) to a resource. > - exactly one mutable reference (&mut T) -While the rules themselves are simple, making sure your code conforms to them can be complicated. It is easy to attempt to borrow a value for longer than its lifetime, or to introduce two mutable references to the same value. The borrow checker is useful because it verifies that your code follows these rules, and helps guide corrections when the code doesn't. Many new Rust programmers struggle to satisfy the borrow checker at first, but over time become more skilled at writing memory safe code with minimal borrow checker intervention. +While the rules themselves are simple, following them consistently is not, particularly for those unaccustomed to reasoning about lifetimes and ownership. + +The first step in understanding the borrow checker is reading the errors it produces. A lot of work has been put into making sure the borrow checker provides quality assistance in resolving the issues it identifies. When you encounter a borrow checker problem, the first step is to slowly and carefully read the error reported, and to only approach the code after you understand the error being described. + +The second step is to become familiar with the ownership and mutability-related container types provided by the Rust standard library, including `Cell`, `RefCell`, and `Cow`. These are useful and necessary tools for expressing certain ownership and mutability sutations, and have been written to be of minimal performance cost. + +The single most important part of understanding the borrow checker is practice. Rust's strong static analyses guarantees are strict and quite different from what many programmers have worked with before. It will take some time to become completely comfortable with everything. + +If you find yourself struggling with the borrow checker, or running out of patience, always feel free to reach out to the [Rust community](https://www.rust-lang.org/community.html) for help. ### How do deref coercions work? From 6b75c04be678d841d130984f76024579a41de369 Mon Sep 17 00:00:00 2001 From: Andrew Brinker Date: Sat, 9 Jan 2016 12:36:23 -0500 Subject: [PATCH 58/94] Updated lifetime elision answer --- faq.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/faq.md b/faq.md index 60821ae27..3787051fc 100644 --- a/faq.md +++ b/faq.md @@ -418,15 +418,15 @@ fn abs_all(input: &mut Cow<[i32]>) { To return a closure from a function, it must be a "move closure", meaning that the closure is declared with the `move` keyword. As [explained in the Rust book](https://doc.rust-lang.org/book/closures.html#move-closures), this gives the closure its own copy of the captured variables, independent of its parent stack frame. Otherwise, returning a closure would be unsafe, as it would allow access to variables that are no longer valid; put another way: it would allow reading potentially invalid memory. The closure must also be wrapped in a `Box`, so that it is allocated on the heap. Read more about this [in the book](https://doc.rust-lang.org/book/closures.html#returning-closures). -### When are lifetimes required to be defined? +### When are lifetimes required to be explicit? -Lifetimes can often be elided, as explained in the ["Lifetime elision" section](https://doc.rust-lang.org/book/lifetimes.html#lifetime-elision) of the Rust book. "Elided lifetimes" are those lifetimes which are implicit in any code containing references. They are automatically inserted by the compiler with the three following rules: +Lifetimes must be explicit when the rules for automatic lifetime inference result in compilation errors. The Rust compiler tries its best to automatically infer correct lifetimes (called ["elided lifetimes"](https://doc.rust-lang.org/stable/book/lifetimes.html#lifetime-elision)) based on the following rules: - Each elided lifetime in a function’s arguments becomes a distinct lifetime parameter. - If there is exactly one input lifetime, elided or not, that lifetime is assigned to all elided lifetimes in the return values of that function. - If there are multiple input lifetimes, but one of them is `&self` or `&mut` self, the lifetime of self is assigned to all elided output lifetimes. -If these rules would result in incorrect code elsewhere, then the Rust compiler will provide errors, and you will need to define the relevant lifetimes to correct that error. +If these rules result in compilation errors, the Rust compiler will provide an error message indicating the error caused, and suggesting a potential solution based on which step of the inference process caused the error. ### How can Rust guarantee "no null pointers"? From c4e41f08b71411f6484d342b9bf6f40e68e54de8 Mon Sep 17 00:00:00 2001 From: Andrew Brinker Date: Sat, 9 Jan 2016 12:49:37 -0500 Subject: [PATCH 59/94] Fixed typo --- faq.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/faq.md b/faq.md index 3787051fc..712f8b4d1 100644 --- a/faq.md +++ b/faq.md @@ -590,7 +590,7 @@ If you're looking for a way to avoid handling `Result`s in other people's code, ### Can I use static values across threads without an `unsafe` block? -Mutation is safe if it's synchronized. Mutating a static `Mutex` (lazily initialized via the [lazy_static](https://crates.io/crates/lazy_static/) crate) does not require an `unsafe` block, nor does mutating a static `AtomicUsize` (which can be initialized without lazy_static). +Mutation is safe if it's synchronized. Mutating a static `Mutex` (lazily initialized via the [lazy-static](https://crates.io/crates/lazy_static/) crate) does not require an `unsafe` block, nor does mutating a static `AtomicUsize` (which can be initialized without lazy_static). More generally, if a type implements `Sync` and does not implement `Drop`, it [can be used in a `static`](https://doc.rust-lang.org/book/const-and-static.html#static). @@ -839,7 +839,7 @@ To define procedural constants that can't be defined via these mechanisms, use t ### Can I run initialization code that happens before main? -Rust has no concept of "life before `main`". The closest you'll see can be done through the [`lazy_static`](https://github.com/Kimundi/lazy-static.rs) crate, which simulates a "before main" by lazily initializing static variables at their first usage. +Rust has no concept of "life before `main`". The closest you'll see can be done through the [`lazy-static`](https://github.com/Kimundi/lazy-static.rs) crate, which simulates a "before main" by lazily initializing static variables at their first usage. ### Why doesn't Rust have inheritance? @@ -857,7 +857,7 @@ No. Globals cannot have a non-constant-expression constructor and cannot have a See the [C++ FQA](http://yosefk.com/c++fqa/ctors.html#fqa-10.12) about the "static initialization order fiasco", and [Eric Lippert's blog](http://ericlippert.com/2013/02/06/static-constructors-part-one/) for the challenges in C#, which also has this feature. -You can approximate non-constant-expression globals with the [lazy_static](https://crates.io/crates/lazy_static/) crate. +You can approximate non-constant-expression globals with the [lazy-static](https://crates.io/crates/lazy_static/) crate.

    Other Languages

    From 898dd0f58d47deed9094c49beb3717106aa8f076 Mon Sep 17 00:00:00 2001 From: Andrew Brinker Date: Sat, 9 Jan 2016 13:42:37 -0500 Subject: [PATCH 60/94] Added links to API docs --- faq.md | 257 +++++++++++++++++++++++++++++++++++---------------------- 1 file changed, 159 insertions(+), 98 deletions(-) diff --git a/faq.md b/faq.md index 712f8b4d1..e497cc1eb 100644 --- a/faq.md +++ b/faq.md @@ -75,9 +75,9 @@ Finally, while Rust's preferred strategy of monomorphising generics (ala C++) pr ### Why are Rust's `HashMap`s slow? -By default, Rust's [`HashMap`](https://doc.rust-lang.org/stable/std/collections/struct.HashMap.html) uses the [SipHash](https://131002.net/siphash/) hashing algorithm, which is designed to prevent [hash table collision attacks](http://programmingisterrible.com/post/40620375793/hash-table-denial-of-service-attacks-revisited) while providing [reasonable performance on a variety of workloads](https://www.reddit.com/r/rust/comments/3hw9zf/rust_hasher_comparisons/cub4oh6). +By default, Rust's [`HashMap`][HashMap] uses the [SipHash](https://131002.net/siphash/) hashing algorithm, which is designed to prevent [hash table collision attacks](http://programmingisterrible.com/post/40620375793/hash-table-denial-of-service-attacks-revisited) while providing [reasonable performance on a variety of workloads](https://www.reddit.com/r/rust/comments/3hw9zf/rust_hasher_comparisons/cub4oh6). -While SipHash [demonstrates competitive performance](http://cglab.ca/%7Eabeinges/blah/hash-rs/) in many cases, one case where it is notably slower than other hashing algorithms is with short keys, such as integers. This is why Rust programmers often observe slow performance with [`HashMap`](https://doc.rust-lang.org/stable/std/collections/struct.HashMap.html). The [FNV hasher](https://crates.io/crates/fnv) is frequently recommended for these cases, but be aware that it does not have the same collision-resistance properties as SipHash. +While SipHash [demonstrates competitive performance](http://cglab.ca/%7Eabeinges/blah/hash-rs/) in many cases, one case where it is notably slower than other hashing algorithms is with short keys, such as integers. This is why Rust programmers often observe slow performance with [`HashMap`][HashMap]. The [FNV hasher](https://crates.io/crates/fnv) is frequently recommended for these cases, but be aware that it does not have the same collision-resistance properties as SipHash. ### Why is there no integrated benchmarking infrastructure? @@ -85,7 +85,7 @@ You can run benchmarks, but only on the nightly channel. Rust's benchmarking mec ### Does Rust do tail-call optimization? -Not generally, no. Tail-call optimization may be done in [limited circumstances](http://llvm.org/docs/CodeGenerator.html#sibling-call-optimization), but is [not guaranteed](https://mail.mozilla.org/pipermail/rust-dev/2013-April/003557.html). As the feature has always been desired, Rust has a keyword (`become`) reserved, though it is not clear yet whether it is technically possible, nor whether it will be implemented. There was a [proposed extension](https://github.com/rust-lang/rfcs/pull/81) that would allow tail-call elimination in certain contexts, but it is currently postponed. +Not generally, no. Tail-call optimization may be done in [limited circumstances](http://llvm.org/docs/CodeGenerator.html#sibling-call-optimization), but is [not guaranteed](https://mail.mozilla.org/pipermail/rust-dev/2013-April/003557.html). As the feature has always been desired, Rust has a keyword (`become`) reserved, though it is not clear yet whether it is technically possible, nor whether it will be implemented. There was a [proposed extension](https://github.com/rust-lang/rfcs/pull/81) that would allow tail-call elimination in certain contexts, but it is currently postponed. ### Does Rust have a runtime? @@ -105,17 +105,17 @@ Whereas C requires mandatory parentheses for `if`-statement conditionals but lea ### Why is there no literal syntax for dictionaries? -The reason Rust does not have syntax for initializing dictionaries — or collections in general — is due to Rust's overall design preference for limiting the size of the *language* while enabling powerful *libraries*. The only type of collection that Rust has direct syntax for initializing is the array type, which is also the only type of collection built into the language. Note that Rust does not even have syntax for initializing the common `Vec` collection type, instead the standard library defines the [`vec!`](http://doc.rust-lang.org/std/macro.vec!.html) macro. +The reason Rust does not have syntax for initializing dictionaries — or collections in general — is due to Rust's overall design preference for limiting the size of the *language* while enabling powerful *libraries*. The only type of collection that Rust has direct syntax for initializing is the array type, which is also the only type of collection built into the language. Note that Rust does not even have syntax for initializing the common [`Vec`][Vec] collection type, instead the standard library defines the [`vec!`][VecMacro] macro. -This design choice of using Rust's macro facilities to initialize collections will likely be extended generically to other collections in the future, enabling simple initialization of not only `HashMap` and `Vec`, but also other collection types such as [`BTreeMap`](http://doc.rust-lang.org/collections/struct.BTreeMap.html). In the meantime, if you want a more convenient syntax for initializing collections, you can [create your own macro](http://stackoverflow.com/questions/27582739/how-do-i-create-a-hashmap-literal) to provide it. +This design choice of using Rust's macro facilities to initialize collections will likely be extended generically to other collections in the future, enabling simple initialization of not only [`HashMap`][HashMap] and [`Vec`][Vec], but also other collection types such as [`BTreeMap`][BTreeMap]. In the meantime, if you want a more convenient syntax for initializing collections, you can [create your own macro](http://stackoverflow.com/questions/27582739/how-do-i-create-a-hashmap-literal) to provide it. ### When should I use an implicit return? -Rust is a very expression-oriented language, and implicit returns are part of that design. `if`s, `match`es, and normal blocks are all expressions in Rust. For example, the following code checks if an `i64` is odd, returning the result with an implicit return: +Rust is a very expression-oriented language, and implicit returns are part of that design. `if`s, `match`es, and normal blocks are all expressions in Rust. For example, the following code checks if an [`i64`][i64] is odd, returning the result with an implicit return: ```rust fn is_odd(x: i64) -> bool { - if x % 2 == 1 { true } else { false } + if x % 2 != 0 { true } else { false } } ``` @@ -123,7 +123,7 @@ Although it can be simplified even further like so: ```rust fn is_odd(x: i64) -> bool { - x % 2 == 1 + x % 2 != 0 } ``` @@ -156,41 +156,41 @@ match val.do_something() { The choice of which to use is dependent on the purpose of the program. -If you are interested in the greatest degree of precision with your floating point numbers, then prefer `f64`. If you are more interested in keeping the size of the value small or being maximally efficient, and are not concerned about the associated inaccuracy of having fewer bits per value, then `f32` is better. Operations on `f32` are usually faster, even on 64-bit hardware. As a common example, graphics programming typically uses `f32` because it requires high performance, and 32-bit floats are sufficient for representing pixels on the screen. +If you are interested in the greatest degree of precision with your floating point numbers, then prefer [`f64`][f64]. If you are more interested in keeping the size of the value small or being maximally efficient, and are not concerned about the associated inaccuracy of having fewer bits per value, then [`f32`][f32] is better. Operations on [`f32`][f32] are usually faster, even on 64-bit hardware. As a common example, graphics programming typically uses [`f32`][f32] because it requires high performance, and 32-bit floats are sufficient for representing pixels on the screen. -If in doubt, choose `f64` for the greater precision. +If in doubt, choose [`f64`][f64] for the greater precision. ### Why can't I compare floats? -Floats can be compared with the `==`, `!=`, `<`, `<=`, `>`, and `>=` operators, and with the `partial_cmp()` function. `==` and `!=` are part of the `PartialEq` trait, while `<`, `<=`, `>`, `>=`, and `partial_cmp()` are part of the `PartialOrd` trait. +Floats can be compared with the `==`, `!=`, `<`, `<=`, `>`, and `>=` operators, and with the `partial_cmp()` function. `==` and `!=` are part of the [`PartialEq`][PartialEq] trait, while `<`, `<=`, `>`, `>=`, and `partial_cmp()` are part of the [`PartialOrd`][PartialOrd] trait. -Floats cannot be compared with the `cmp()` function, which is part of the `Ord` trait, as there is no total ordering for floats. Furthermore, there is no total equality relation for floats, and so they also do not implement the `Eq` trait. +Floats cannot be compared with the `cmp()` function, which is part of the [`Ord`][Ord] trait, as there is no total ordering for floats. Furthermore, there is no total equality relation for floats, and so they also do not implement the [`Eq`][Eq] trait. There is no total ordering or equality on floats because the floating-point value `NaN` is not less than, greater than, or equal to any other floating-point value or itself. -Because floats do not implement `Eq` or `Ord`, they may not be used in types whose trait bounds require those traits, such as `BTreeMap`. +Because floats do not implement [`Eq`][Eq] or [`Ord`][Ord], they may not be used in types whose trait bounds require those traits, such as [`BTreeMap`][BTreeMap]. -There [is a crate](https://crates.io/crates/ordered-float) that wraps `f32` and `f64` to provide `Ord` and `Eq` implementations, which may be useful in certain cases. +There [is a crate](https://crates.io/crates/ordered-float) that wraps [`f32`][f32] and [`f64`][f64] to provide [`Ord`][Ord] and [`Eq`][Eq] implementations, which may be useful in certain cases. ### Why can't I use `f32` or `f64` as `HashMap` keys? -In order to be used as a key in a [`HashMap`](https://doc.rust-lang.org/stable/std/collections/struct.HashMap.html), a type must implement the [`Eq`](https://doc.rust-lang.org/stable/std/cmp/trait.Eq.html) and [`Hash`](https://doc.rust-lang.org/stable/std/hash/trait.Hash.html) traits. `Eq` is required because keys have to be capable of being tested for equality, otherwise indexing on keys wouldn't work. `Hash` is required so that the type may be hashed by `HashMap`'s hashing algorithm. +In order to be used as a key in a [`HashMap`][HashMap], a type must implement the [`Eq`][Eq] and [`Hash`][Hash] traits. [`Eq`][Eq] is required because keys have to be capable of being tested for equality, otherwise indexing on keys wouldn't work. [`Hash`][Hash] is required so that the type may be hashed by [`HashMap`'s][HashMap] hashing algorithm. -[`f32`](https://doc.rust-lang.org/stable/std/primitive.f32.html) and [`f64`](https://doc.rust-lang.org/stable/std/primitive.f64.html) implement [`PartialEq`](https://doc.rust-lang.org/stable/std/cmp/trait.PartialEq.html), but not `Eq` This is because one of the potential values for floating-point types is `NaN` (or "not a number"). Per the IEEE floating-point specification, `NaN` values are [not equal to any other floating-point value, and not equal to each other](https://en.wikipedia.org/wiki/NaN). This means there is no total equality relation for floating-point types, and thus that `f32` and `f64` can't implement `Eq` and can't used as keys in a `HashMap`. +[`f32`][f32] and [`f64`][f64] implement [`PartialEq`][PartialEq], but not [`Eq`][Eq] This is because one of the potential values for floating-point types is `NaN` (or "not a number"). Per the IEEE floating-point specification, `NaN` values are [not equal to any other floating-point value, and not equal to each other](https://en.wikipedia.org/wiki/NaN). This means there is no total equality relation for floating-point types, and thus that [`f32`][f32] and [`f64`][f64] can't implement [`Eq`][Eq] and can't used as keys in a [`HashMap`][HashMap]. ### How can I convert between numeric types? -There are two ways: the `as` keyword, which does simple casting for primitive types, and the [`Into`](https://doc.rust-lang.org/stable/std/convert/trait.Into.html) and [`From`](https://doc.rust-lang.org/stable/std/convert/trait.From.html) traits, which are implemented for a number of type conversions (and which you can implement for your own types). The `Into` and `From` traits are only implemented in cases where conversions are lossless, so for example, `f64::from(0f32)` will compile while `f32:from(0f64)` will not. On the other hand, `as` will convert between any two primitive types, truncating values as necessary. +There are two ways: the `as` keyword, which does simple casting for primitive types, and the [`Into`][Into] and [`From`][From] traits, which are implemented for a number of type conversions (and which you can implement for your own types). The [`Into`][Into] and [`From`][From] traits are only implemented in cases where conversions are lossless, so for example, `f64::from(0f32)` will compile while `f32:from(0f64)` will not. On the other hand, `as` will convert between any two primitive types, truncating values as necessary.

    Strings

    ### How can I convert a `String` or `Vec` to a slice (`&str` and `&[T]`)? -Using [Deref coercions](https://doc.rust-lang.org/stable/book/deref-coercions.html), [`String`s](https://doc.rust-lang.org/stable/std/string/struct.String.html) and [`Vec`s](https://doc.rust-lang.org/stable/std/vec/struct.Vec.html) will automatically coerce to their respective slices when passed by reference with `&` or `& mut`. +Using [Deref coercions](https://doc.rust-lang.org/stable/book/deref-coercions.html), [`String`s][String] and [`Vec`s][Vec] will automatically coerce to their respective slices when passed by reference with `&` or `& mut`. ### How can I convert from `&str` to `String` or the other way around? -The [`to_owned()`](https://doc.rust-lang.org/stable/std/borrow/trait.ToOwned.html#tymethod.to_owned) method converts from a [`&str`](https://doc.rust-lang.org/stable/std/primitive.str.html) into a [`String`](https://doc.rust-lang.org/stable/std/string/struct.String.html), and `String`s are automatically converted into `&str` when you borrow a reference to them. Both are demonstrated in the following example: +The [`to_owned()`][to_owned] method converts from a [`&str`][str] into a [`String`][String], and [`String`s][String] are automatically converted into [`&str`][str] when you borrow a reference to them. Both are demonstrated in the following example: ```rust fn main() { @@ -205,29 +205,29 @@ fn say_hello(name: &str) { ### What are the differences between the two different string types? -[`String`](https://doc.rust-lang.org/stable/std/string/struct.String.html) is an owned buffer of UTF-8 bytes allocated on the heap. Mutable `String`s can be modified, growing their capacity as needed. `&str` is a fixed-capacity "view" into a `String` allocated elsewhere, commonly on the heap, in the case of slices dereferenced from `String`s, or in static memory, in the case of string literals. +[`String`][String] is an owned buffer of UTF-8 bytes allocated on the heap. Mutable [`String`s][String] can be modified, growing their capacity as needed. [`&str`][str] is a fixed-capacity "view" into a [`String`][String] allocated elsewhere, commonly on the heap, in the case of slices dereferenced from [`String`s][String], or in static memory, in the case of string literals. -`&str` is a primitive type implemented by the Rust language, while `String` is implemented in the standard library. +[`&str`][str] is a primitive type implemented by the Rust language, while [`String`][String] is implemented in the standard library. ### How do I do O(1) character access in a `String`? You cannot. At least not without a firm understanding of what you mean by "character", and preprocessing the string to find the index of the desired character. -Rust strings are UTF-8 encoded. A single visual character in UTF-8 is not necessarily a single byte as it would be in an ASCII-encoded string. Each byte is called a "code unit" (in UTF-16, code units are 2 bytes; in UTF-32 they are 4 bytes). "Code points" are composed of one or more code units, and combine in "grapheme clusters" which most closely approximate characters. +Rust strings are UTF-8 encoded. A single visual character in UTF-8 is not necessarily a single byte as it would be in an ASCII-encoded string. Each byte is called a "code unit" (in UTF-16, code units are 2 bytes; in UTF-32 they are 4 bytes). "Code points" are composed of one or more code units, and combine in "grapheme clusters" which most closely approximate characters. -Thus, even though you may index on bytes in a UTF-8 string, you can't access the `i`th code point or grapheme cluster in constant time. However, if you know at which byte that desired code point or grapheme cluster begins, then you _can_ access it in constant time. Functions including `str::find()` and regex matches return byte indices, facilitating this sort of access. +Thus, even though you may index on bytes in a UTF-8 string, you can't access the `i`th code point or grapheme cluster in constant time. However, if you know at which byte that desired code point or grapheme cluster begins, then you _can_ access it in constant time. Functions including [`str::find()`][str__find] and regex matches return byte indices, facilitating this sort of access. ### Why are strings UTF-8 by default? -The `str` type is UTF-8 because we observe more text in the wild in this encoding – particularly in network transmissions, which are endian-agnostic – and we think it's best that the default treatment of I/O not involve having to recode codepoints in each direction. +The [`str`][str] type is UTF-8 because we observe more text in the wild in this encoding – particularly in network transmissions, which are endian-agnostic – and we think it's best that the default treatment of I/O not involve having to recode codepoints in each direction. This does mean that locating a particular Unicode codepoint inside a string is an O(n) operation, although if the starting byte index is already known then they can be accessed in O(1) as expected. On the one hand, this is clearly undesirable; on the other hand, this problem is full of trade-offs and we'd like to point out a few important qualifications: -Scanning a `str` for ASCII-range codepoints can still be done safely byte-at-a-time. If you use `.as_bytes()`, pulling out a `u8` costs only `O(1)` and produces a value that can be cast and compared to an ASCII-range `char`. So if you're (say) line-breaking on `'\n'`, byte-based treatment still works. UTF-8 was well-designed this way. +Scanning a [`str`][str] for ASCII-range codepoints can still be done safely byte-at-a-time. If you use [`.as_bytes()`][str__as_bytes], pulling out a [`u8`][u8] costs only `O(1)` and produces a value that can be cast and compared to an ASCII-range [`char`][char]. So if you're (say) line-breaking on `'\n'`, byte-based treatment still works. UTF-8 was well-designed this way. Most "character oriented" operations on text only work under very restricted language assumptions such as "ASCII-range codepoints only". Outside ASCII-range, you tend to have to use a complex (non-constant-time) algorithm for determining linguistic-unit (glyph, word, paragraph) boundaries anyway. We recommend using an "honest" linguistically-aware, Unicode-approved algorithm. -The `char` type is UTF32. If you are sure you need to do a codepoint-at-a-time algorithm, it's trivial to write a `type wstr = [char]`, and unpack a `str` into it in a single pass, then work with the `wstr`. In other words: the fact that the language is not "decoding to UTF32 by default" shouldn't stop you from decoding (or re-encoding any other way) if you need to work with that encoding. +The [`char`][char] type is UTF-32. If you are sure you need to do a codepoint-at-a-time algorithm, it's trivial to write a `type wstr = [char]`, and unpack a [`str`][str] into it in a single pass, then work with the `wstr`. In other words: the fact that the language is not "decoding to UTF32 by default" shouldn't stop you from decoding (or re-encoding any other way) if you need to work with that encoding. For a more in-depth explanation of why UTF-8 is usually preferable over UTF-16 or UTF-32, read the [UTF-8 Everywhere manifesto](http://utf8everywhere.org/). @@ -239,11 +239,11 @@ If your reason for implementing these data structures is to use them for other p If, however, [your reason is simply to learn](http://cglab.ca/~abeinges/blah/too-many-lists/book/), then you will likely need to dip into unsafe code. While these data structures _can_ be implemented entirely in safe Rust, the performance is likely to be worse than it would be with the use of unsafe code. The simple reason for this is that data structures like vectors and linked lists rely on pointer and memory operations that are disallowed in safe Rust. -For example, a doubly-linked list requires that there be two mutable references to each node, but this violates Rust's mutable reference aliasing rules. You can solve this using `Weak`, but the performance will be poorer than you likely want. With unsafe code you can bypass the mutable reference aliasing rule restriction, but must manually verify that your code introduces no memory safety violations. +For example, a doubly-linked list requires that there be two mutable references to each node, but this violates Rust's mutable reference aliasing rules. You can solve this using [`Weak`][Weak], but the performance will be poorer than you likely want. With unsafe code you can bypass the mutable reference aliasing rule restriction, but must manually verify that your code introduces no memory safety violations. ### How can I iterate over a collection without moving/consuming it? -The easiest way is by using the collection's `IntoIterator` implementation. Here is an example for `&Vec`: +The easiest way is by using the collection's [`IntoIterator`][IntoIterator] implementation. Here is an example for [`&Vec`][Vec]: ```rust let v = vec![1,2,3,4,5]; @@ -253,7 +253,7 @@ for item in &v { println!("\nLength: {}", v.len()); ``` -Rust `for` loops call `into_iter()` (defined on the `IntoIterator` trait) for whatever they're iterating over. Anything implementing the `IntoIterator` trait may be looped over with a `for` loop. `IntoIterator` is implemented for `&Vec` and `&mut Vec`, causing the iterator from `into_iter()` to borrow the contents of the collection, rather than moving/consuming them. The same is true for other standard collections as well. +Rust `for` loops call `into_iter()` (defined on the [`IntoIterator`][IntoIterator] trait) for whatever they're iterating over. Anything implementing the [`IntoIterator`][IntoIterator] trait may be looped over with a `for` loop. [`IntoIterator`][IntoIterator] is implemented for [`&Vec`][Vec] and [`&mut Vec`][Vec], causing the iterator from `into_iter()` to borrow the contents of the collection, rather than moving/consuming them. The same is true for other standard collections as well. If a moving/consuming iterator is desired, write the `for` loop without `&` or `&mut` in the iteration. @@ -261,7 +261,7 @@ If a moving/consuming iterator is desired, write the `for` loop without `&` or ` You don't necessarily have to. If you're declaring an array directly, the size is inferred based on the number of elements. But if you're declaring a function that takes an array, the compiler has to know how big that array will be. -One thing to note is that currently Rust doesn't offer generics over arrays of different size. If you'd like to accept a contiguous container of a variable number of values, use a `Vec` or slice (depending on whether you need ownership). +One thing to note is that currently Rust doesn't offer generics over arrays of different size. If you'd like to accept a contiguous container of a variable number of values, use a [`Vec`][Vec] or slice (depending on whether you need ownership).

    Ownership

    @@ -269,12 +269,12 @@ One thing to note is that currently Rust doesn't offer generics over arrays of d There are four major options: -- You can implement it using `Rc` and `Weak` to allow shared ownership of nodes, +- You can implement it using [`Rc`][Rc] and [`Weak`][Weak] to allow shared ownership of nodes, although this approach pays the cost of memory management. - You can implement it using `unsafe` code using raw pointers. This will be more efficient, but bypasses Rust's safety guarantees. - Using vectors and indices into those vectors. There are [several](http://smallcultfollowing.com/babysteps/blog/2015/04/06/modeling-graphs-in-rust-using-vector-indices/) [available](http://featherweightmusings.blogspot.com/2015/04/graphs-in-rust.html) examples and explanations of this approach. -- Using borrowed references with `UnsafeCell`. There are [explanations and code](https://github.com/nrc/r4cppp/blob/master/graphs/README.md#node-and-unsafecell) available for this approach. +- Using borrowed references with [`UnsafeCell`][UnsafeCell]. There are [explanations and code](https://github.com/nrc/r4cppp/blob/master/graphs/README.md#node-and-unsafecell) available for this approach. ### How can I define a struct that contains a pointer to one of its own fields? @@ -308,13 +308,13 @@ These are different terms for the same thing. In both cases, it means the value ### Why can values of some types be used after passing them to a function, while reuse of values of other types results in an error? -If a type implements the `Copy` trait, then it will be copied when passed to a function. All numeric types in Rust implement `Copy`, but struct types do not implement `Copy` by default, so they are moved instead. This means that the struct can no longer be used elsewhere, unless it is moved back out of the function via the return. +If a type implements the [`Copy`][Copy] trait, then it will be copied when passed to a function. All numeric types in Rust implement [`Copy`][Copy], but struct types do not implement [`Copy`][Copy] by default, so they are moved instead. This means that the struct can no longer be used elsewhere, unless it is moved back out of the function via the return. ### How do you deal with a "use of moved value" error? -This error means that the value you're trying to use has been moved to a new owner. The first thing to check is whether the move in question was necessary: if it moved into a function, it may be possible to rewrite the function to use a reference, rather than moving. Otherwise if the type being moved implements `Clone`, then calling `clone()` on it before moving will move a copy of it, leaving the original still available for further use. Note though that cloning a value should typically be the last resort since cloning can be expensive, causing further allocations. +This error means that the value you're trying to use has been moved to a new owner. The first thing to check is whether the move in question was necessary: if it moved into a function, it may be possible to rewrite the function to use a reference, rather than moving. Otherwise if the type being moved implements [`Clone`][Clone], then calling `clone()` on it before moving will move a copy of it, leaving the original still available for further use. Note though that cloning a value should typically be the last resort since cloning can be expensive, causing further allocations. -If the moved value is of your own custom type, consider implementing `Copy` (for implicit copying, rather than moving) or `Clone` (explicit copying). `Copy` is most commonly implemented with `#[derive(Copy, Clone)]` (`Copy` requires `Clone`), and `Clone` with `#[derive(Clone)]`. +If the moved value is of your own custom type, consider implementing [`Copy`][Copy] (for implicit copying, rather than moving) or [`Clone`][Clone] (explicit copying). [`Copy`][Copy] is most commonly implemented with `#[derive(Copy, Clone)]` ([`Copy`][Copy] requires [`Clone`][Clone]), and [`Clone`][Clone] with `#[derive(Clone)]`. If none of these are possible, you may want to modify the function that acquired ownership to return ownership of the value when the function exits. @@ -337,7 +337,7 @@ While the rules themselves are simple, following them consistently is not, parti The first step in understanding the borrow checker is reading the errors it produces. A lot of work has been put into making sure the borrow checker provides quality assistance in resolving the issues it identifies. When you encounter a borrow checker problem, the first step is to slowly and carefully read the error reported, and to only approach the code after you understand the error being described. -The second step is to become familiar with the ownership and mutability-related container types provided by the Rust standard library, including `Cell`, `RefCell`, and `Cow`. These are useful and necessary tools for expressing certain ownership and mutability sutations, and have been written to be of minimal performance cost. +The second step is to become familiar with the ownership and mutability-related container types provided by the Rust standard library, including [`Cell`][Cell], [`RefCell`][RefCell], and [`Cow`][Cow]. These are useful and necessary tools for expressing certain ownership and mutability sutations, and have been written to be of minimal performance cost. The single most important part of understanding the borrow checker is practice. Rust's strong static analyses guarantees are strict and quite different from what many programmers have worked with before. It will take some time to become completely comfortable with everything. @@ -345,7 +345,7 @@ If you find yourself struggling with the borrow checker, or running out of patie ### How do deref coercions work? -[Deref coercions](https://doc.rust-lang.org/book/deref-coercions.html) exist to make using Rust more ergonomic, and are implemented via the [`Deref`](https://doc.rust-lang.org/stable/std/ops/trait.Deref.html) trait. +[Deref coercions](https://doc.rust-lang.org/book/deref-coercions.html) exist to make using Rust more ergonomic, and are implemented via the [`Deref`][Deref] trait. A Deref implementation indicates that the implementing type may be converted into a target by a call to the `deref` method, which takes an immutable reference to the calling type and returns a reference (of the same lifetime) to the target type. The `*` prefix operator is shorthand for the `deref` method. @@ -369,7 +369,7 @@ The `'a` syntax comes from the ML family of programming languages, where `'a` is ### When is `Rc` useful? -This is covered in the [official documentation for `Rc`](https://doc.rust-lang.org/stable/std/rc/), Rust's non-atomically reference-counted pointer type. In short, `Rc` and its thread-safe cousin `Arc` are useful to express shared ownership, and have the system automatically deallocate the associated memory when no one has access to it. +This is covered in the official documentation for [`Rc`][Rc], Rust's non-atomically reference-counted pointer type. In short, [`Rc`][Rc] and its thread-safe cousin [`Arc`][Arc] are useful to express shared ownership, and have the system automatically deallocate the associated memory when no one has access to it. ### How do I return a borrow to something I created from a function? @@ -388,7 +388,7 @@ fn create_borrowed<'a>(pool: &'a Pool, } ``` -An alternative is to eliminate the references entirely by returning an owning type like `String`: +An alternative is to eliminate the references entirely by returning an owning type like [`String`][String]: ```rust fn happy_birthday(name: &str, age: i64) -> String { @@ -398,7 +398,7 @@ fn happy_birthday(name: &str, age: i64) -> String { This approach is simpler, but often results in unnecessary allocations. -There is also the `Cow` ("copy on write") type, which will only do the extra allocation if you attempt to mutate the contained value: +There is also the [`Cow`][Cow] ("copy on write") type, which will only do the extra allocation if you attempt to mutate the contained value: ```rust use std::borrow::Cow; @@ -416,7 +416,7 @@ fn abs_all(input: &mut Cow<[i32]>) { ### How do I return a closure from a function? -To return a closure from a function, it must be a "move closure", meaning that the closure is declared with the `move` keyword. As [explained in the Rust book](https://doc.rust-lang.org/book/closures.html#move-closures), this gives the closure its own copy of the captured variables, independent of its parent stack frame. Otherwise, returning a closure would be unsafe, as it would allow access to variables that are no longer valid; put another way: it would allow reading potentially invalid memory. The closure must also be wrapped in a `Box`, so that it is allocated on the heap. Read more about this [in the book](https://doc.rust-lang.org/book/closures.html#returning-closures). +To return a closure from a function, it must be a "move closure", meaning that the closure is declared with the `move` keyword. As [explained in the Rust book](https://doc.rust-lang.org/book/closures.html#move-closures), this gives the closure its own copy of the captured variables, independent of its parent stack frame. Otherwise, returning a closure would be unsafe, as it would allow access to variables that are no longer valid; put another way: it would allow reading potentially invalid memory. The closure must also be wrapped in a [`Box`][Box], so that it is allocated on the heap. Read more about this [in the book](https://doc.rust-lang.org/book/closures.html#returning-closures). ### When are lifetimes required to be explicit? @@ -434,7 +434,7 @@ The only way to construct a value of type `&Foo` or `&mut Foo` is to specify an ### How do I express the absence of a value without `null`? -You can do that with the [`Option`](https://doc.rust-lang.org/stable/std/option/index.html) type, which can either be `Some(T)` or `None`. `Some(T)` indicates that a value of type `T` is contained within, while `None` indicates the absence of a value. +You can do that with the [`Option`][Option] type, which can either be `Some(T)` or `None`. `Some(T)` indicates that a value of type `T` is contained within, while `None` indicates the absence of a value.

    Generics

    @@ -448,17 +448,17 @@ Functions that accept [trait objects](http://doc.rust-lang.org/book/trait-object Functions and closures are operationally equivalent, but have different runtime representations due to their differing implementations. -Functions are a built-in primitive of the language, while closures are essentially syntactic sugar for one of three traits: `Fn`, `FnMut`, and `FnOnce`. When you make a closure, the Rust compiler automatically creates a struct implementing the appropriate trait of those three and containing the captured environment variables as members, and makes it so the struct can be called as a function. Bare functions can not capture an environment. +Functions are a built-in primitive of the language, while closures are essentially syntactic sugar for one of three traits: [`Fn`][Fn], [`FnMut`][FnMut], and [`FnOnce`][FnOnce]. When you make a closure, the Rust compiler automatically creates a struct implementing the appropriate trait of those three and containing the captured environment variables as members, and makes it so the struct can be called as a function. Bare functions can not capture an environment. -The big difference between these traits is how they take the `self` parameter. `Fn` takes `&self`, `FnMut` takes `&mut self`, and `FnOnce` takes `self`. +The big difference between these traits is how they take the `self` parameter. [`Fn`][Fn] takes `&self`, [`FnMut`][FnMut] takes `&mut self`, and [`FnOnce`][FnOnce] takes `self`. Even if a closure does not capture any environment variables, it is represeted at runtime as two points, same as any other closure. ### What are higher-kinded types, why would I want them, and why doesn't Rust have them? -Higher-kinded types are typed with unfilled parameters. Type constructors, like `Vec`, `Result`, and `HashMap` are all examples of higher-kinded types. Support for higher-kinded types means these "incomplete" types may be used anywhere "complete" types can be used, such as trait `impl`s. +Higher-kinded types are typed with unfilled parameters. Type constructors, like [`Vec`][Vec], [`Result`][Result], and [`HashMap`][HashMap] are all examples of higher-kinded types. Support for higher-kinded types means these "incomplete" types may be used anywhere "complete" types can be used, such as trait `impl`s. -Any complete type, like `i32`, `bool`, or `char` is of kind `*`. A type with one parameter, like `Vec` is of kind `* -> *`, meaning that `Vec` takes in a complete type like `i32` and returns a complete type `Vec`. A type which three parameters, like `HashMap` is of kind `* -> * -> * -> *`, and takes in three complete types (like `i32`, `String`, and `RandomState`) to produce a new complete type `HashMap`. +Any complete type, like [`i32`][i32], [`bool`][bool], or [`char`][char] is of kind `*`. A type with one parameter, like [`Vec`][Vec] is of kind `* -> *`, meaning that [`Vec`][Vec] takes in a complete type like [`i32`][i32] and returns a complete type `Vec`. A type which three parameters, like [`HashMap`][HashMap] is of kind `* -> * -> * -> *`, and takes in three complete types (like [`i32`][32], [`String`][String], and [`RandomState`][RandomState]) to produce a new complete type `HashMap`. The lack of support for higher-kinded types makes expression of certain ideas more tedious than it would otherwise be. For example, implementing a `Functor` trait (a term for a container which can be mapped over, obeying certain rules) without higher-kinded types requires explicit and otherwise unnecessary handling of the container's type parameters. With higher-kined types, a `Functor` `impl` can ignore the parameters entirely. @@ -472,7 +472,7 @@ Associated types exist because, for a generic type with some type parameters, it ### Can I overload operators? Which ones and how? -You can provide custom implementations for a variety of operators using their associated traits: `Add` for `+`, `Mul` for `*`. It looks like this: +You can provide custom implementations for a variety of operators using their associated traits: [`Add`][Add] for `+`, [`Mul`][Mul] for `*`. It looks like this: ```rust use std::ops::Add; @@ -490,53 +490,36 @@ impl Add for Foo { The following operators can be overloaded: -| Operation | Trait | -|:--------------------|:-------------| -| `+` | [`Add`] | -| `binary -` | [`Sub`] | -| `*` | [`Mul`] | -| `/` | [`Div`] | -| `unary -` | [`Neg`] | -| `%` | [`Rem`] | -| `&` | [`BitAnd`] | -| | | [`BitOr`] | -| `^` | [`BitXor`] | -| `!` | [`Not`] | -| `<<` | [`Shl`] | -| `>>` | [`Shr`] | -| `*` | [`Deref`] | -| `mut *` | [`DerefMut`] | -| `[]` | [`Index`] | -| `mut []` | [`IndexMut`] | - -[`Add`]: https://doc.rust-lang.org/stable/std/ops/trait.Add.html -[`Sub`]: https://doc.rust-lang.org/stable/std/ops/trait.Sub.html -[`Mul`]: https://doc.rust-lang.org/stable/std/ops/trait.Mul.html -[`Div`]: https://doc.rust-lang.org/stable/std/ops/trait.Div.html -[`Neg`]: https://doc.rust-lang.org/stable/std/ops/trait.Neg.html -[`Rem`]: https://doc.rust-lang.org/stable/std/ops/trait.Rem.html -[`BitAnd`]: https://doc.rust-lang.org/stable/std/ops/trait.BitAnd.html -[`BitOr`]: https://doc.rust-lang.org/stable/std/ops/trait.BitOr.html -[`BitXor`]: https://doc.rust-lang.org/stable/std/ops/trait.BitXor.html -[`Not`]: https://doc.rust-lang.org/stable/std/ops/trait.Not.html -[`Shl`]: https://doc.rust-lang.org/stable/std/ops/trait.Shl.html -[`Shr`]: https://doc.rust-lang.org/stable/std/ops/trait.Shr.html -[`Deref`]: https://doc.rust-lang.org/stable/std/ops/trait.Deref.html -[`DerefMut`]: https://doc.rust-lang.org/stable/std/ops/trait.DerefMut.html -[`Index`]: https://doc.rust-lang.org/stable/std/ops/trait.Index.html -[`IndexMut`]: https://doc.rust-lang.org/stable/std/ops/trait.IndexMut.html +| Operation | Trait | +|:--------------------|:-----------------------| +| `+` | [`Add`][Add] | +| `binary -` | [`Sub`][Sub] | +| `*` | [`Mul`][Mul] | +| `/` | [`Div`][Div] | +| `unary -` | [`Neg`][Neg] | +| `%` | [`Rem`][Rem] | +| `&` | [`BitAnd`][BitAnd] | +| | | [`BitOr`][BitOr] | +| `^` | [`BitXor`][BitXor] | +| `!` | [`Not`][Not] | +| `<<` | [`Shl`][Shl] | +| `>>` | [`Shr`][Shr] | +| `*` | [`Deref`][Deref] | +| `mut *` | [`DerefMut`][DerefMut] | +| `[]` | [`Index`][Index] | +| `mut []` | [`IndexMut`][IndexMut] | ### Why the split between `Eq`/`PartialEq` and `Ord`/`PartialOrd`? There are some types in Rust whose values are only partially ordered, or have only partial equality. Partial ordering means that there may be values of the given type that are neither less than nor greater than each other. Partial equality means that there may be values of the given type that are not equal to themselves. -Floating point types (`f32` and `f64`) are good examples of each. Any floating point type may have the value `NaN` (meaning "not a number"). `NaN` is not equal to itself (`NaN == Nan` is false), and not less than or greater than any other floating point value. As such, both `f32` and `f64` implement `PartialOrd` and `PartialEq` but not `Ord` and not `Eq`. +Floating point types ([`f32`][f32] and [`f64`][f64]) are good examples of each. Any floating point type may have the value `NaN` (meaning "not a number"). `NaN` is not equal to itself (`NaN == Nan` is false), and not less than or greater than any other floating point value. As such, both [`f32`][f32] and [`f64`][f64] implement [`PartialOrd`][PartialOrd] and [`PartialEq`][PartialEq] but not [`Ord`][Ord] and not [`Eq`][Eq].

    Input / Output

    ### How do I read a file into a `String`? -Using the `read_to_string()` method, which is defined on the `Read` trait in `std::io`. +Using the [`read_to_string()`][read__read_to_string] method, which is defined on the [`Read`][Read] trait in [`std::io`][std-io]. ```rust fn read_file(path: &str) -> Result { @@ -556,13 +539,13 @@ fn main() { ### How do I read file input efficiently? -The [`File` type](https://doc.rust-lang.org/stable/std/fs/struct.File.html) implements the `Read` trait, which has a variety of functions for reading and writing data, including `read()`, `read_to_end()`, `bytes()`, `chars()`, and `take()`. Each of these functions reads a certain amount of input from a given file. `read()` reads as much input as the underlying system will provide in a single call. `read_to_end()` reads the entire buffer into a vector, allocating as much space as is needed. `bytes()` and `chars()` allow you to iterate over the bytes and characters of the file, respectively. Finally, `take()` allows you to read up to an arbitrary number of bytes from the file. Collectively, these should allow you to efficiently read in any data you need. +The [`File`][File] type implements the [`Read`][Read] trait, which has a variety of functions for reading and writing data, including [`read()`][read__read], [`read_to_end()`][read__read_to_end], [`bytes()`][read__bytes], [`chars()`][read__chars], and [`take()`][read__take]. Each of these functions reads a certain amount of input from a given file. [`read()`][read__read] reads as much input as the underlying system will provide in a single call. [`read_to_end()`][read__read_to_end] reads the entire buffer into a vector, allocating as much space as is needed. [`bytes()`][read__bytes] and [`chars()`][read__chars] allow you to iterate over the bytes and characters of the file, respectively. Finally, [`take()`][read__take] allows you to read up to an arbitrary number of bytes from the file. Collectively, these should allow you to efficiently read in any data you need. -For buffered reads, use the [`BufReader`](http://doc.rust-lang.org/stable/std/io/struct.BufReader.html) struct, which helps to reduce the number of system calls when reading. +For buffered reads, use the [`BufReader`][BufReader] struct, which helps to reduce the number of system calls when reading. ### How do I get command line arguments in Rust? -The easiest way is to use `std::env::Args`, which provides an iterator over the input arguments. +The easiest way is to use [`Args`][Args], which provides an iterator over the input arguments. If you're looking for something more powerful, there are a [number of options on crates.io](https://crates.io/keywords/argument). @@ -576,23 +559,23 @@ Rust prefers a type-based approach to error handling, which is [covered at lengt ### What's the deal with `unwrap()` everywhere? -`unwrap()` is a function that extracts the value inside an `Option` or `Result` and panics if no value is present. It is useful in the presence of truly unrecoverable errors, but is more useful for quick prototypes where you don't want to handle an error yet, or blog posts where error handling would distract from the main point. `unwrap()` shouldn't be your default way to handle errors, but it is a useful tool to have. +`unwrap()` is a function that extracts the value inside an [`Option`][Option] or [`Result`][Result] and panics if no value is present. It is useful in the presence of truly unrecoverable errors, but is more useful for quick prototypes where you don't want to handle an error yet, or blog posts where error handling would distract from the main point. `unwrap()` shouldn't be your default way to handle errors, but it is a useful tool to have. ### Why do I get an error when I try to run example code that uses the `try!` macro? -It's probably an issue with the function's return type. The [`try!` macro](https://doc.rust-lang.org/stable/std/macro.try!.html) either extracts the value from a `Result`, or returns early with the error `Result` is carrying. This means that `try` only works for functions that return `Result` themselves, where the `Err`-constructed type implements `From::from(err)`. In particular, this means that the `try!` macro cannot work inside the `main` function. +It's probably an issue with the function's return type. The [`try!`][TryMacro] macro either extracts the value from a [`Result`][Result], or returns early with the error [`Result`][Result] is carrying. This means that [`try`][TryMacro] only works for functions that return [`Result`][Result] themselves, where the `Err`-constructed type implements `From::from(err)`. In particular, this means that the [`try!`][TryMacro] macro cannot work inside the `main` function. ### Is there an easier way to do error handling than having `Result`s everywhere? -If you're looking for a way to avoid handling `Result`s in other people's code, there's always `unwrap()`, but it's probably not what you want. `Result` is an indicator that some computation may or may not complete successfully. Requiring you to handle these failures explicitly is one of the ways that Rust encourages robustness. If you really don't want to handle an error, use `unwrap()`, but know that doing so means that the given code will cause the entire process to panic on failure, which is usually undesirable. +If you're looking for a way to avoid handling [`Result`s][Result] in other people's code, there's always [`unwrap()`][unwrap], but it's probably not what you want. [`Result`][Result] is an indicator that some computation may or may not complete successfully. Requiring you to handle these failures explicitly is one of the ways that Rust encourages robustness. If you really don't want to handle an error, use [`unwrap()`][unwrap], but know that doing so means that the given code will cause the entire process to panic on failure, which is usually undesirable.

    Concurrency

    ### Can I use static values across threads without an `unsafe` block? -Mutation is safe if it's synchronized. Mutating a static `Mutex` (lazily initialized via the [lazy-static](https://crates.io/crates/lazy_static/) crate) does not require an `unsafe` block, nor does mutating a static `AtomicUsize` (which can be initialized without lazy_static). +Mutation is safe if it's synchronized. Mutating a static [`Mutex`][Mutex] (lazily initialized via the [lazy-static](https://crates.io/crates/lazy_static/) crate) does not require an `unsafe` block, nor does mutating a static [`AtomicUsize`][AtomicUsize] (which can be initialized without lazy_static). -More generally, if a type implements `Sync` and does not implement `Drop`, it [can be used in a `static`](https://doc.rust-lang.org/book/const-and-static.html#static). +More generally, if a type implements [`Sync`][Sync] and does not implement [`Drop`][Drop], it [can be used in a `static`](https://doc.rust-lang.org/book/const-and-static.html#static).

    Macros

    @@ -608,15 +591,15 @@ Rust programs can be debugged using [gdb](http://sourceware.org/gdb/current/onli ### `rustc` said a panic occurred in standard library code. How do I locate the mistake in my code? -This error is usually caused by `unwrap()`ing a `None` or `Err` in client code. Enabling backtraces by setting the environment variable `RUST_BACKTRACE=1` helps with getting more information. Compiling in debug mode (the default for `cargo build`) is also helpful. Using a debugger like the provided `rust-gdb` or `rust-lldb` is also helpful. +This error is usually caused by [`unwrap()`ing][unwrap] a `None` or `Err` in client code. Enabling backtraces by setting the environment variable `RUST_BACKTRACE=1` helps with getting more information. Compiling in debug mode (the default for `cargo build`) is also helpful. Using a debugger like the provided `rust-gdb` or `rust-lldb` is also helpful.

    Low-Level

    ### How do I `memcpy` bytes? -If you want to clone an existing slice safely, you can use `std::slice::clone_from_slice`. This function is currently unstable, but [should be stabilized soon](https://internals.rust-lang.org/t/stabilizing-basic-functions-on-arrays-and-slices/2868). +If you want to clone an existing slice safely, you can use [`clone_from_slice`][clone_from_slice]. This function is currently unstable, but [should be stabilized soon](https://internals.rust-lang.org/t/stabilizing-basic-functions-on-arrays-and-slices/2868). -To copy potentially overlapping bytes, use `std::ptr::copy`. To copy nonoverlapping bytes, use `std::ptr::cpy_nonoverlapping`. Both of these functions are `unsafe`, as both can be used to subvert the language's safety guarantees. Take care when using them. +To copy potentially overlapping bytes, use [`copy`][copy]. To copy nonoverlapping bytes, use [`cpy_nonoverlapping`][copy_nonoverlapping]. Both of these functions are `unsafe`, as both can be used to subvert the language's safety guarantees. Take care when using them. ### Can Rust function reasonably without the standard library? @@ -825,7 +808,7 @@ That depends. There _are_ ways of translating object-oriented concepts like [mul ### How do I handle configuration of a struct with optional parameters? -The easiest way is to use the `Option` type in whatever function you're using to construct instances of the struct (usually `new()`). Another way is to use the [builder pattern](https://aturon.github.io/ownership/builders.html), where only certain functions instantiating member variables must be called before the construction of the built type. +The easiest way is to use the [`Option`][Option] type in whatever function you're using to construct instances of the struct (usually `new()`). Another way is to use the [builder pattern](https://aturon.github.io/ownership/builders.html), where only certain functions instantiating member variables must be called before the construction of the built type. ### How do I do global variables in Rust? @@ -901,7 +884,7 @@ The notions of a "move" in Rust and a "move" in C++ are quite different, owing t In C++, R-value references come from a temporary value, or are explicitly created from a named value via `std::move`. In this way, C++ enforces that no mutable references exist to the moved-out value, so that the memory may be safely invalidated. In Rust, mutable aliases are statically eliminated by the borrow checker, and so the rough equivalent of C++'s R-values are found in Rust's mutable references (`&mut`), which can only be used if no other mutable alias already exists to the given memory location. -Rust "move"s are about transferring ownership, rather than eliminating mutable aliases (which are handled via the borrow checker). By default, the ownership of any function parameter is transferred into the function and out of the parameter at the call site, unless that parameter's type implements the `Copy` trait, in which case a shallow copy of the value is used to instantiate the actual parameter of the function. Rust's "move"s are often unecessary and undesirable. If the function you're writing does not require ownership of the value being passed in, that value should probably be borrowed (mutably or immutably, as necessary) rather than moved or copied. +Rust "move"s are about transferring ownership, rather than eliminating mutable aliases (which are handled via the borrow checker). By default, the ownership of any function parameter is transferred into the function and out of the parameter at the call site, unless that parameter's type implements the [`Copy`][Copy] trait, in which case a shallow copy of the value is used to instantiate the actual parameter of the function. Rust's "move"s are often unecessary and undesirable. If the function you're writing does not require ownership of the value being passed in, that value should probably be borrowed (mutably or immutably, as necessary) rather than moved or copied. ### How can I interoperate with C++ from Rust, or with Rust from C++? @@ -931,7 +914,7 @@ impl Foo { ### Does Rust have copy constructors? -Not exactly. Types which implement `Copy` will do a standard C-like "shallow copy" with no extra work (similar to "plain old data" in C++). It is impossible to implement `Copy` types that require custom copy behavior. Instead, in Rust "copy constructors" are created by implementing the `Clone` trait, and explicitly calling the `clone` method. Making user-defined copy operators explicit surfaces the underlying complexity, forcing the developer to opt-in to potentially expensive operations. +Not exactly. Types which implement [`Copy`][Copy] will do a standard C-like "shallow copy" with no extra work (similar to "plain old data" in C++). It is impossible to implement [`Copy`][Copy] types that require custom copy behavior. Instead, in Rust "copy constructors" are created by implementing the [`Clone`][Clone] trait, and explicitly calling the [`clone`][clone] method. Making user-defined copy operators explicit surfaces the underlying complexity, forcing the developer to opt-in to potentially expensive operations. ### Does Rust have move constructors? @@ -1058,3 +1041,81 @@ The Apache license includes important protection against patent aggression, but This is partly due to preference of the original developer (Graydon), and partly due to the fact that languages tend to have a wider audience and more diverse set of possible embeddings and end-uses than products such as web browsers. We'd like to appeal to as many of those potential contributors as possible. +[Vec]: https://doc.rust-lang.org/stable/std/vec/struct.Vec.html +[HashMap]: https://doc.rust-lang.org/stable/std/collections/struct.HashMap.html +[Into]: https://doc.rust-lang.org/stable/std/convert/trait.Into.html +[From]: https://doc.rust-lang.org/stable/std/convert/trait.From.html +[Eq]: https://doc.rust-lang.org/stable/std/cmp/trait.Eq.html +[PartialEq]: https://doc.rust-lang.org/stable/std/cmp/trait.PartialEq.html +[Ord]: https://doc.rust-lang.org/stable/std/cmp/trait.Ord.html +[PartialOrd]: https://doc.rust-lang.org/stable/std/cmp/trait.PartialOrd.html +[f32]: https://doc.rust-lang.org/stable/std/primitive.f32.html +[f64]: https://doc.rust-lang.org/stable/std/primitive.f64.html +[i32]: https://doc.rust-lang.org/stable/std/primitive.i32.html +[i64]: https://doc.rust-lang.org/stable/std/primitive.i64.html +[bool]: https://doc.rust-lang.org/stable/std/primitive.bool.html +[Hash]: https://doc.rust-lang.org/stable/std/hash/trait.Hash.html +[BTreeMap]: https://doc.rust-lang.org/stable/std/collections/struct.BTreeMap.html +[VecMacro]: https://doc.rust-lang.org/stable/std/macro.vec!.html +[String]: https://doc.rust-lang.org/stable/std/string/struct.String.html +[to_owned]: https://doc.rust-lang.org/stable/std/borrow/trait.ToOwned.html#tymethod.to_owned +[str]: https://doc.rust-lang.org/stable/std/primitive.str.html +[str__find]: https://doc.rust-lang.org/stable/std/primitive.str.html#method.find +[str__as_bytes]: https://doc.rust-lang.org/stable/std/primitive.str.html#method.as_bytes +[u8]: https://doc.rust-lang.org/stable/std/primitive.u8.html +[char]: https://doc.rust-lang.org/stable/std/primitive.char.html +[Weak]: https://doc.rust-lang.org/stable/std/rc/struct.Weak.html +[IntoIterator]: https://doc.rust-lang.org/stable/std/iter/trait.IntoIterator.html +[Rc]: https://doc.rust-lang.org/stable/std/rc/struct.Rc.html +[UnsafeCell]: https://doc.rust-lang.org/stable/std/cell/struct.UnsafeCell.html +[Copy]: https://doc.rust-lang.org/stable/std/marker/trait.Copy.html +[Clone]: https://doc.rust-lang.org/stable/std/clone/trait.Clone.html +[Cell]: https://doc.rust-lang.org/stable/std/cell/struct.Cell.html +[RefCell]: https://doc.rust-lang.org/stable/std/cell/struct.RefCell.html +[Cow]: https://doc.rust-lang.org/stable/std/borrow/enum.Cow.html +[Deref]: https://doc.rust-lang.org/stable/std/ops/trait.Deref.html +[Arc]: https://doc.rust-lang.org/stable/std/sync/struct.Arc.html +[Box]: https://doc.rust-lang.org/stable/std/boxed/struct.Box.html +[Option]: https://doc.rust-lang.org/stable/std/option/enum.Option.html +[Fn]: https://doc.rust-lang.org/stable/std/ops/trait.Fn.html +[FnMut]: https://doc.rust-lang.org/stable/std/ops/trait.FnMut.html +[FnOnce]: https://doc.rust-lang.org/stable/std/ops/trait.FnOnce.html +[Result]: https://doc.rust-lang.org/stable/std/result/enum.Result.html +[RandomState]: https://doc.rust-lang.org/stable/std/collections/hash_map/struct.RandomState.html +[Add]: https://doc.rust-lang.org/stable/std/ops/trait.Add.html +[Sub]: https://doc.rust-lang.org/stable/std/ops/trait.Sub.html +[Mul]: https://doc.rust-lang.org/stable/std/ops/trait.Mul.html +[Div]: https://doc.rust-lang.org/stable/std/ops/trait.Div.html +[Neg]: https://doc.rust-lang.org/stable/std/ops/trait.Neg.html +[Rem]: https://doc.rust-lang.org/stable/std/ops/trait.Rem.html +[BitAnd]: https://doc.rust-lang.org/stable/std/ops/trait.BitAnd.html +[BitOr]: https://doc.rust-lang.org/stable/std/ops/trait.BitOr.html +[BitXor]: https://doc.rust-lang.org/stable/std/ops/trait.BitXor.html +[Not]: https://doc.rust-lang.org/stable/std/ops/trait.Not.html +[Shl]: https://doc.rust-lang.org/stable/std/ops/trait.Shl.html +[Shr]: https://doc.rust-lang.org/stable/std/ops/trait.Shr.html +[Deref]: https://doc.rust-lang.org/stable/std/ops/trait.Deref.html +[DerefMut]: https://doc.rust-lang.org/stable/std/ops/trait.DerefMut.html +[Index]: https://doc.rust-lang.org/stable/std/ops/trait.Index.html +[IndexMut]: https://doc.rust-lang.org/stable/std/ops/trait.IndexMut.html +[read__read_to_string]: https://doc.rust-lang.org/stable/std/io/trait.Read.html#method.read_to_string +[Read]: https://doc.rust-lang.org/stable/std/io/trait.Read.html +[std-io]: https://doc.rust-lang.org/stable/std/io/index.html +[File]: https://doc.rust-lang.org/stable/std/fs/struct.File.html +[read__read]: https://doc.rust-lang.org/stable/std/io/trait.Read.html#tymethod.read +[read__read_to_end]: https://doc.rust-lang.org/stable/std/io/trait.Read.html#method.read_to_end +[read__bytes]: https://doc.rust-lang.org/stable/std/io/trait.Read.html#method.bytes +[read__chars]: https://doc.rust-lang.org/stable/std/io/trait.Read.html#method.chars +[read__take]: https://doc.rust-lang.org/stable/std/io/trait.Read.html#method.take +[BufReader]: https://doc.rust-lang.org/stable/std/io/struct.BufReader.html +[Args]: https://doc.rust-lang.org/stable/std/env/struct.Args.html +[TryMacro]: https://doc.rust-lang.org/stable/std/macro.try!.html +[unwrap]: https://doc.rust-lang.org/stable/core/option/enum.Option.html#method.unwrap +[Mutex]: https://doc.rust-lang.org/stable/std/sync/struct.Mutex.html +[AtomicUsize]: https://doc.rust-lang.org/stable/std/sync/atomic/struct.AtomicUsize.html +[Sync]: https://doc.rust-lang.org/stable/std/marker/trait.Sync.html +[Drop]: https://doc.rust-lang.org/stable/std/ops/trait.Drop.html +[clone_from_slice]: https://doc.rust-lang.org/stable/std/primitive.slice.html#method.clone_from_slice +[copy]: https://doc.rust-lang.org/stable/std/ptr/fn.copy.html +[copy_nonoverlapping]: https://doc.rust-lang.org/stable/std/ptr/fn.copy_nonoverlapping.html +[clone]: https://doc.rust-lang.org/stable/std/clone/trait.Clone.html#tymethod.clone From be4e7ebce5550058679abdedf52998ee922a5778 Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Tue, 12 Jan 2016 21:14:23 +0000 Subject: [PATCH 61/94] Add the syntax index --- documentation.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/documentation.md b/documentation.md index 05c272ef3..ed159ac20 100644 --- a/documentation.md +++ b/documentation.md @@ -46,6 +46,10 @@ standard library. specification, the reference tries to describe its working in detail. It tends to be out of date. +[**Syntax Index**][syn]. This appendix from The Book contains examples +of all syntax in Rust cross-referenced with the section of The Book +that describes it. + [**The Cargo Guide**][cargo]. The documentation for Cargo, Rust's package manager. @@ -53,6 +57,7 @@ Rust's package manager. the errors produced by the Rust compiler. [api]: https://doc.rust-lang.org/std/ +[syn]: https://doc.rust-lang.org/book/syntax-index.html [ref]: https://doc.rust-lang.org/reference.html [cargo]: http://doc.crates.io/guide.html [err]: https://doc.rust-lang.org/error-index.html From 3512ebdb6bb55b6e15c5872e6d6c53f4a61d6390 Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Tue, 12 Jan 2016 21:39:50 +0000 Subject: [PATCH 62/94] Fix some links in FAQ --- faq.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/faq.md b/faq.md index e497cc1eb..087dc66db 100644 --- a/faq.md +++ b/faq.md @@ -341,7 +341,7 @@ The second step is to become familiar with the ownership and mutability-related The single most important part of understanding the borrow checker is practice. Rust's strong static analyses guarantees are strict and quite different from what many programmers have worked with before. It will take some time to become completely comfortable with everything. -If you find yourself struggling with the borrow checker, or running out of patience, always feel free to reach out to the [Rust community](https://www.rust-lang.org/community.html) for help. +If you find yourself struggling with the borrow checker, or running out of patience, always feel free to reach out to the [Rust community](community.html) for help. ### How do deref coercions work? @@ -458,7 +458,7 @@ Even if a closure does not capture any environment variables, it is represeted a Higher-kinded types are typed with unfilled parameters. Type constructors, like [`Vec`][Vec], [`Result`][Result], and [`HashMap`][HashMap] are all examples of higher-kinded types. Support for higher-kinded types means these "incomplete" types may be used anywhere "complete" types can be used, such as trait `impl`s. -Any complete type, like [`i32`][i32], [`bool`][bool], or [`char`][char] is of kind `*`. A type with one parameter, like [`Vec`][Vec] is of kind `* -> *`, meaning that [`Vec`][Vec] takes in a complete type like [`i32`][i32] and returns a complete type `Vec`. A type which three parameters, like [`HashMap`][HashMap] is of kind `* -> * -> * -> *`, and takes in three complete types (like [`i32`][32], [`String`][String], and [`RandomState`][RandomState]) to produce a new complete type `HashMap`. +Any complete type, like [`i32`][i32], [`bool`][bool], or [`char`][char] is of kind `*`. A type with one parameter, like [`Vec`][Vec] is of kind `* -> *`, meaning that [`Vec`][Vec] takes in a complete type like [`i32`][i32] and returns a complete type `Vec`. A type which three parameters, like [`HashMap`][HashMap] is of kind `* -> * -> * -> *`, and takes in three complete types (like [`i32`][i32], [`String`][String], and [`RandomState`][RandomState]) to produce a new complete type `HashMap`. The lack of support for higher-kinded types makes expression of certain ideas more tedious than it would otherwise be. For example, implementing a `Functor` trait (a term for a container which can be mapped over, obeying certain rules) without higher-kinded types requires explicit and otherwise unnecessary handling of the container's type parameters. With higher-kined types, a `Functor` `impl` can ignore the parameters entirely. From b505008459ebccad1e245f2c202864b048ae3890 Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Tue, 12 Jan 2016 21:52:52 +0000 Subject: [PATCH 63/94] Use 2px border-top everywhere instead of 2px/4px --- css/style.css | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/css/style.css b/css/style.css index 6ad0619a9..73fe155f4 100644 --- a/css/style.css +++ b/css/style.css @@ -202,7 +202,7 @@ p.pitch a { hr { margin-top: 2em; margin-bottom: 3em; - border-top: 4px solid #dedede; + border-top: 2px solid #dedede; } .asterisk { @@ -414,7 +414,7 @@ ul.laundry-list { line-height: 1.5em; margin: 3rem 0 1rem; font-weight: 400; - border-top: 4px solid #dedede; + border-top: 2px solid #dedede; padding-top: 1rem; } From dd97f0fe11abb3e07ad606fcb08907114f4cd48a Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Tue, 12 Jan 2016 23:31:01 +0000 Subject: [PATCH 64/94] Add anchors for all faqs --- css/style.css | 4 + faq.md | 248 +++++++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 250 insertions(+), 2 deletions(-) diff --git a/css/style.css b/css/style.css index 73fe155f4..5f4a13025 100644 --- a/css/style.css +++ b/css/style.css @@ -474,6 +474,10 @@ ul.laundry-list { line-height: 1.5em; } +.faq a > h3 { + color: black; +} + #toc h2 { border: 0; font-size: 2rem; diff --git a/faq.md b/faq.md index d55aa75ae..bd81389b8 100644 --- a/faq.md +++ b/faq.md @@ -43,25 +43,33 @@ If there is some common or important question you feel is wrongly left unanswere

    Performance

    + ### How fast is Rust? + Fast! Rust is already competitive with idiomatic C and C++ in a number of benchmarks (like the [Benchmarks Game](http://benchmarksgame.alioth.debian.org/u64q/compare.php?lang=rust&lang2=gpp) and [others](https://github.com/kostya/benchmarks)). It is an explicit goal of Rust to be at least as fast as C++. Language decisions are made with performance in mind, and given that Rust is built on LLVM and strives to resemble Clang from LLVM's perspective, any LLVM performance improvements also help Rust. + ### Is Rust garbage collected? + No. A language that requires a GC is a language that opts into a larger, more complex runtime than Rust cares for. Rust is usable on bare metal with no extra runtime. Additionally, garbage collection is frequently a source of non-deterministic behavior. Rust provides tools to make using third-party garbage collectors [possible](http://manishearth.github.io/blog/2015/09/01/designing-a-gc-in-rust/), but it is not part of the language as provided. + ### Why is my program slow? + The Rust compiler doesn't compile with optimizations unless asked to, [as optimizations slow down compilation and are usually undesirable during development](https://users.rust-lang.org/t/why-does-cargo-build-not-optimise-by-default/4150/3). If you compile with `cargo`, use the `--release` flag. If you compile with `rustc` directly, use the `-O` flag. Either of these will turn on optimizations. + ### Rust compilation seems slow. Why is that? + Code translation and optimizations. Rust provides high level abstractions that compile down into efficient machine code, and those translations take time to run, especially when optimizing. @@ -77,43 +85,59 @@ Thirdly, Rust's use of LLVM for code generation is a double-edged sword: while i Finally, while Rust's preferred strategy of monomorphising generics (ala C++) produces fast code, it demands that significantly more code be generated than other translation strategies. + ### Why are Rust's `HashMap`s slow? + By default, Rust's [`HashMap`][HashMap] uses the [SipHash](https://131002.net/siphash/) hashing algorithm, which is designed to prevent [hash table collision attacks](http://programmingisterrible.com/post/40620375793/hash-table-denial-of-service-attacks-revisited) while providing [reasonable performance on a variety of workloads](https://www.reddit.com/r/rust/comments/3hw9zf/rust_hasher_comparisons/cub4oh6). While SipHash [demonstrates competitive performance](http://cglab.ca/%7Eabeinges/blah/hash-rs/) in many cases, one case where it is notably slower than other hashing algorithms is with short keys, such as integers. This is why Rust programmers often observe slow performance with [`HashMap`][HashMap]. The [FNV hasher](https://crates.io/crates/fnv) is frequently recommended for these cases, but be aware that it does not have the same collision-resistance properties as SipHash. + ### Why is there no integrated benchmarking infrastructure? + You can run benchmarks, but only on the nightly channel. Rust's benchmarking mechanism is currently unstable, as the API has not been deemed ready for stabilization. This [may change in the future](https://github.com/rust-lang/rust/issues/29553), but until then benchmarking can only be used on nightly. + ### Does Rust do tail-call optimization? + Not generally, no. Tail-call optimization may be done in [limited circumstances](http://llvm.org/docs/CodeGenerator.html#sibling-call-optimization), but is [not guaranteed](https://mail.mozilla.org/pipermail/rust-dev/2013-April/003557.html). As the feature has always been desired, Rust has a keyword (`become`) reserved, though it is not clear yet whether it is technically possible, nor whether it will be implemented. There was a [proposed extension](https://github.com/rust-lang/rfcs/pull/81) that would allow tail-call elimination in certain contexts, but it is currently postponed. + ### Does Rust have a runtime? + Not in the typical sense used by languages such as Java, but parts of the Rust standard library can be considered a "runtime", providing a heap, backtraces, unwinding, and stack guards. There is a [small amount of initialization code](https://github.com/rust-lang/rust/blob/33916307780495fe311fe9c080b330d266f35bfb/src/libstd/rt.rs#L43) that runs before the user's `main` function. The Rust standard library additionally links to the the C standard library, which does similar [runtime initialization](http://www.embecosm.com/appnotes/ean9/html/ch05s02.html). Rust code can be compiled without the standard library, in which case the runtime is roughly equivalent to C's.

    Syntax

    + ### Why curly braces? Why can't Rust's syntax be like Haskell's or Python's? + Use of curly braces to denote blocks is a common design choice in a variety of programming languages, and Rust's consistency is useful for people already familiar with the style. Curly braces also allow for more flexible syntax for the programmer, a simpler parser in the compiler, and help reduce the possibility of logic mistakes caused by incorrect indentation, like Apple's [goto fail](https://gotofail.com/) bug. + ### I can leave out parentheses on `if` conditions, so why do I have to put brackets around single line blocks? Why is the C style not allowed? + Whereas C requires mandatory parentheses for `if`-statement conditionals but leaves brackets optional, Rust makes the opposite choice for its `if`-expressions. This keeps the conditional clearly separate from the body and avoids the hazard of optional brackets, which can lead to easy-to-miss errors during refactoring. + ### Why is there no literal syntax for dictionaries? + The reason Rust does not have syntax for initializing dictionaries — or collections in general — is due to Rust's overall design preference for limiting the size of the *language* while enabling powerful *libraries*. The only type of collection that Rust has direct syntax for initializing is the array type, which is also the only type of collection built into the language. Note that Rust does not even have syntax for initializing the common [`Vec`][Vec] collection type, instead the standard library defines the [`vec!`][VecMacro] macro. This design choice of using Rust's macro facilities to initialize collections will likely be extended generically to other collections in the future, enabling simple initialization of not only [`HashMap`][HashMap] and [`Vec`][Vec], but also other collection types such as [`BTreeMap`][BTreeMap]. In the meantime, if you want a more convenient syntax for initializing collections, you can [create your own macro](http://stackoverflow.com/questions/27582739/how-do-i-create-a-hashmap-literal) to provide it. + ### When should I use an implicit return? + Rust is a very expression-oriented language, and implicit returns are part of that design. `if`s, `match`es, and normal blocks are all expressions in Rust. For example, the following code checks if an [`i64`][i64] is odd, returning the result with an implicit return: @@ -135,13 +159,17 @@ In each example, the last line of the function is the return value of that funct Explicit returns are only used if an implicit return is impossible because you are returning before the end of the function's body. While each of the above functions could have been written with a `return` keyword and semicolon, doing so would be unnecessarily verbose, and inconsistent with the conventions of Rust code. + ### Why aren't function signatures inferred? + - Mandatory function signatures help enforce interface stability at both the module and crate level. - It improves code comprehension for the programmer, eliminating the need for an IDE running an inference algorithm across an entire crate to be able to guess at a function's argument types; it's always explicit and nearby. - Mechanically, it simplifies the inference algorithm, as inference only requires looking at one function at a time. + ### Why does `match` have to be exhaustive? + `match` being exhaustive has some useful properties. First, if every possibility is covered by the `match`, adding variants to the `enum` in the future will cause a compilation failure, rather than an error at runtime. Second, it makes the semantics of the default case explicit: in general, the only safe way to have a non-exhaustive `match` would be to panic the thread if nothing is matched. Early versions of Rust did not require `match` cases to be exhaustive and it was found to be a great source of bugs. @@ -156,7 +184,9 @@ match val.do_something() {

    Numerics

    + ### Which of `f32` and `f64` should I prefer for floating-point math? + The choice of which to use is dependent on the purpose of the program. @@ -164,7 +194,9 @@ If you are interested in the greatest degree of precision with your floating poi If in doubt, choose [`f64`][f64] for the greater precision. + ### Why can't I compare floats? + Floats can be compared with the `==`, `!=`, `<`, `<=`, `>`, and `>=` operators, and with the `partial_cmp()` function. `==` and `!=` are part of the [`PartialEq`][PartialEq] trait, while `<`, `<=`, `>`, `>=`, and `partial_cmp()` are part of the [`PartialOrd`][PartialOrd] trait. @@ -176,23 +208,31 @@ Because floats do not implement [`Eq`][Eq] or [`Ord`][Ord], they may not be used There [is a crate](https://crates.io/crates/ordered-float) that wraps [`f32`][f32] and [`f64`][f64] to provide [`Ord`][Ord] and [`Eq`][Eq] implementations, which may be useful in certain cases. + ### Why can't I use `f32` or `f64` as `HashMap` keys? + In order to be used as a key in a [`HashMap`][HashMap], a type must implement the [`Eq`][Eq] and [`Hash`][Hash] traits. [`Eq`][Eq] is required because keys have to be capable of being tested for equality, otherwise indexing on keys wouldn't work. [`Hash`][Hash] is required so that the type may be hashed by [`HashMap`'s][HashMap] hashing algorithm. [`f32`][f32] and [`f64`][f64] implement [`PartialEq`][PartialEq], but not [`Eq`][Eq] This is because one of the potential values for floating-point types is `NaN` (or "not a number"). Per the IEEE floating-point specification, `NaN` values are [not equal to any other floating-point value, and not equal to each other](https://en.wikipedia.org/wiki/NaN). This means there is no total equality relation for floating-point types, and thus that [`f32`][f32] and [`f64`][f64] can't implement [`Eq`][Eq] and can't used as keys in a [`HashMap`][HashMap]. + ### How can I convert between numeric types? + There are two ways: the `as` keyword, which does simple casting for primitive types, and the [`Into`][Into] and [`From`][From] traits, which are implemented for a number of type conversions (and which you can implement for your own types). The [`Into`][Into] and [`From`][From] traits are only implemented in cases where conversions are lossless, so for example, `f64::from(0f32)` will compile while `f32:from(0f64)` will not. On the other hand, `as` will convert between any two primitive types, truncating values as necessary.

    Strings

    + ### How can I convert a `String` or `Vec` to a slice (`&str` and `&[T]`)? + Using [Deref coercions](https://doc.rust-lang.org/stable/book/deref-coercions.html), [`String`s][String] and [`Vec`s][Vec] will automatically coerce to their respective slices when passed by reference with `&` or `& mut`. + ### How can I convert from `&str` to `String` or the other way around? + The [`to_owned()`][to_owned] method converts from a [`&str`][str] into a [`String`][String], and [`String`s][String] are automatically converted into [`&str`][str] when you borrow a reference to them. Both are demonstrated in the following example: @@ -207,13 +247,17 @@ fn say_hello(name: &str) { } ``` + ### What are the differences between the two different string types? + [`String`][String] is an owned buffer of UTF-8 bytes allocated on the heap. Mutable [`String`s][String] can be modified, growing their capacity as needed. [`&str`][str] is a fixed-capacity "view" into a [`String`][String] allocated elsewhere, commonly on the heap, in the case of slices dereferenced from [`String`s][String], or in static memory, in the case of string literals. [`&str`][str] is a primitive type implemented by the Rust language, while [`String`][String] is implemented in the standard library. + ### How do I do O(1) character access in a `String`? + You cannot. At least not without a firm understanding of what you mean by "character", and preprocessing the string to find the index of the desired character. @@ -221,7 +265,9 @@ Rust strings are UTF-8 encoded. A single visual character in UTF-8 is not necess Thus, even though you may index on bytes in a UTF-8 string, you can't access the `i`th code point or grapheme cluster in constant time. However, if you know at which byte that desired code point or grapheme cluster begins, then you _can_ access it in constant time. Functions including [`str::find()`][str__find] and regex matches return byte indices, facilitating this sort of access. + ### Why are strings UTF-8 by default? + The [`str`][str] type is UTF-8 because we observe more text in the wild in this encoding – particularly in network transmissions, which are endian-agnostic – and we think it's best that the default treatment of I/O not involve having to recode codepoints in each direction. @@ -237,7 +283,9 @@ For a more in-depth explanation of why UTF-8 is usually preferable over UTF-16 o

    Collections

    + ### Can I implement data structures like vectors and linked lists efficiently in Rust? + If your reason for implementing these data structures is to use them for other programs, there's no need, as efficient implementations of these data structures are provided by the standard library. @@ -245,7 +293,9 @@ If, however, [your reason is simply to learn](http://cglab.ca/~abeinges/blah/too For example, a doubly-linked list requires that there be two mutable references to each node, but this violates Rust's mutable reference aliasing rules. You can solve this using [`Weak`][Weak], but the performance will be poorer than you likely want. With unsafe code you can bypass the mutable reference aliasing rule restriction, but must manually verify that your code introduces no memory safety violations. + ### How can I iterate over a collection without moving/consuming it? + The easiest way is by using the collection's [`IntoIterator`][IntoIterator] implementation. Here is an example for [`&Vec`][Vec]: @@ -261,7 +311,9 @@ Rust `for` loops call `into_iter()` (defined on the [`IntoIterator`][IntoIterato If a moving/consuming iterator is desired, write the `for` loop without `&` or `&mut` in the iteration. + ### Why do I need to type the array size in the array declaration? + You don't necessarily have to. If you're declaring an array directly, the size is inferred based on the number of elements. But if you're declaring a function that takes an array, the compiler has to know how big that array will be. @@ -269,7 +321,9 @@ One thing to note is that currently Rust doesn't offer generics over arrays of d

    Ownership

    + ### How can I implement a graph or other data structure that contains cycles? + There are four major options: @@ -280,7 +334,9 @@ more efficient, but bypasses Rust's safety guarantees. - Using vectors and indices into those vectors. There are [several](http://smallcultfollowing.com/babysteps/blog/2015/04/06/modeling-graphs-in-rust-using-vector-indices/) [available](http://featherweightmusings.blogspot.com/2015/04/graphs-in-rust.html) examples and explanations of this approach. - Using borrowed references with [`UnsafeCell`][UnsafeCell]. There are [explanations and code](https://github.com/nrc/r4cppp/blob/master/graphs/README.md#node-and-unsafecell) available for this approach. + ### How can I define a struct that contains a pointer to one of its own fields? + It's possible, but useless to do so. The struct becomes permanently borrowed by itself and therefore can't be moved. Here is some code illustrating this: @@ -302,19 +358,27 @@ fn main() { } ``` + ### What does it mean to "consume a value"? + "Consuming a value" means taking ownership of a value. When this is done, the value can't be used elsewhere. "Consume" is a fairly evocative term for this event. + ### What is the difference between consuming and moving/taking ownership? + These are different terms for the same thing. In both cases, it means the value has been moved to another owner, and moved out of the calling owner. + ### Why can values of some types be used after passing them to a function, while reuse of values of other types results in an error? + If a type implements the [`Copy`][Copy] trait, then it will be copied when passed to a function. All numeric types in Rust implement [`Copy`][Copy], but struct types do not implement [`Copy`][Copy] by default, so they are moved instead. This means that the struct can no longer be used elsewhere, unless it is moved back out of the function via the return. + ### How do you deal with a "use of moved value" error? + This error means that the value you're trying to use has been moved to a new owner. The first thing to check is whether the move in question was necessary: if it moved into a function, it may be possible to rewrite the function to use a reference, rather than moving. Otherwise if the type being moved implements [`Clone`][Clone], then calling `clone()` on it before moving will move a copy of it, leaving the original still available for further use. Note though that cloning a value should typically be the last resort since cloning can be expensive, causing further allocations. @@ -322,13 +386,17 @@ If the moved value is of your own custom type, consider implementing [`Copy`][Co If none of these are possible, you may want to modify the function that acquired ownership to return ownership of the value when the function exits. + ### What are the rules for using `self`, `&self`, or `&mut self` in a method declaration? + - Use `self` when a function needs to consume the type - Use `&self` when a function only needs a read-only reference to the type - Use `&mut self` when a function needs to mutate the type without consuming it + ### How can I understand the borrow checker? + The borrow checker applies only a few rules, which can be found in the Rust book's [section on borrowing](https://doc.rust-lang.org/stable/book/references-and-borrowing.html#the-rules), when evaluating Rust code. These rules are: @@ -347,7 +415,9 @@ The single most important part of understanding the borrow checker is practice. If you find yourself struggling with the borrow checker, or running out of patience, always feel free to reach out to the [Rust community](community.html) for help. + ### How do deref coercions work? + [Deref coercions](https://doc.rust-lang.org/book/deref-coercions.html) exist to make using Rust more ergonomic, and are implemented via the [`Deref`][Deref] trait. @@ -363,19 +433,27 @@ You can see a [full list of `Deref` implementations](https://doc.rust-lang.org/s

    Lifetimes

    + ### Why lifetimes? + Lifetimes are Rust's answer to the question of memory safety. They allow Rust to ensure memory safety without the performance costs of garbage collection. They are based on a variety of academic work, which can be found in the [Rust book](https://doc.rust-lang.org/stable/book/academic-research.html#type-system). + ### Why is the lifetime syntax the way it is? + The `'a` syntax comes from the ML family of programming languages, where `'a` is used to indicate a generic type parameter. For Rust, the syntax had to be something that was unambiguous, noticeable, and fit nicely in a type declaration right alonside traits and references. Alternative syntaxes have been discussed, but no alternative syntax has been demonstrated to be clearly better. + ### When is `Rc` useful? + This is covered in the official documentation for [`Rc`][Rc], Rust's non-atomically reference-counted pointer type. In short, [`Rc`][Rc] and its thread-safe cousin [`Arc`][Arc] are useful to express shared ownership, and have the system automatically deallocate the associated memory when no one has access to it. + ### How do I return a borrow to something I created from a function? + You need to ensure that the borrowed item will outlive the function. This can be done by binding the output lifetime to some input lifetime like so: @@ -418,11 +496,15 @@ fn abs_all(input: &mut Cow<[i32]>) { } ``` + ### How do I return a closure from a function? + To return a closure from a function, it must be a "move closure", meaning that the closure is declared with the `move` keyword. As [explained in the Rust book](https://doc.rust-lang.org/book/closures.html#move-closures), this gives the closure its own copy of the captured variables, independent of its parent stack frame. Otherwise, returning a closure would be unsafe, as it would allow access to variables that are no longer valid; put another way: it would allow reading potentially invalid memory. The closure must also be wrapped in a [`Box`][Box], so that it is allocated on the heap. Read more about this [in the book](https://doc.rust-lang.org/book/closures.html#returning-closures). + ### When are lifetimes required to be explicit? + Lifetimes must be explicit when the rules for automatic lifetime inference result in compilation errors. The Rust compiler tries its best to automatically infer correct lifetimes (called ["elided lifetimes"](https://doc.rust-lang.org/stable/book/lifetimes.html#lifetime-elision)) based on the following rules: @@ -432,23 +514,31 @@ Lifetimes must be explicit when the rules for automatic lifetime inference resul If these rules result in compilation errors, the Rust compiler will provide an error message indicating the error caused, and suggesting a potential solution based on which step of the inference process caused the error. + ### How can Rust guarantee "no null pointers"? + The only way to construct a value of type `&Foo` or `&mut Foo` is to specify an existing value of type `Foo` that the reference points to. In this way Rust makes sure no null references are introduced. + ### How do I express the absence of a value without `null`? + You can do that with the [`Option`][Option] type, which can either be `Some(T)` or `None`. `Some(T)` indicates that a value of type `T` is contained within, while `None` indicates the absence of a value.

    Generics

    + ### What is "monomorphisation"? + Monomorphisation is the process by which Rust translates to machine code specific instances of a generic function based on the parameter types of calls to that function. During monomorphisisation a new copy of the generic function is translated for each unique set of types the function is instantiated with. This is the same strategy used by C++. It results in fast code that is specialized for every call-site and statically dispatched, with the tradeoff that functions instantiated with many different types can cause "code bloat", where multiple function instances result in larger binaries than would be created with other translation strategies. Functions that accept [trait objects](http://doc.rust-lang.org/book/trait-objects.html) instead of type parameters do not undergo monomorphisation. Instead, methods on the trait objects are dispatched dynamically at runtime. + ### What's the difference between a function and a closure that doesn't capture any variables? + Functions and closures are operationally equivalent, but have different runtime representations due to their differing implementations. @@ -458,7 +548,9 @@ The big difference between these traits is how they take the `self` parameter. [ Even if a closure does not capture any environment variables, it is represeted at runtime as two points, same as any other closure. + ### What are higher-kinded types, why would I want them, and why doesn't Rust have them? + Higher-kinded types are typed with unfilled parameters. Type constructors, like [`Vec`][Vec], [`Result`][Result], and [`HashMap`][HashMap] are all examples of higher-kinded types. Support for higher-kinded types means these "incomplete" types may be used anywhere "complete" types can be used, such as trait `impl`s. @@ -468,13 +560,17 @@ The lack of support for higher-kinded types makes expression of certain ideas mo Rust doesn't currently have support for higher-kinded types because it hasn't been a priority. There is nothing inherent to the language that stops the support from being implemented. It just hasn't been done yet. + ### What do named type parameters like `` in generic types mean? + These are called [associated types](https://doc.rust-lang.org/stable/book/associated-types.html), and they allow for the expression of trait bounds that can't be expressed with a `where` clause. For example, a generic bound `X: Bar` means "`X` must implement the trait `Bar`, and in that implementation of `Bar`, `X` must choose `Foo` for `Bar`'s associated type, `T`." Examples of where such a constraint cannot be expressed via a `where` clause include trait objects like `Box>`. Associated types exist because, for a generic type with some type parameters, it is often unecessary to include those type parameters in a function taking that generic type as a parameter. The function shouldn't have to care about being generic over the types which make up the generic type (say, the node and edge types in a graph), but only about being generic over the type itself. + ### Can I overload operators? Which ones and how? + You can provide custom implementations for a variety of operators using their associated traits: [`Add`][Add] for `+`, [`Mul`][Mul] for `*`. It looks like this: @@ -513,7 +609,9 @@ The following operators can be overloaded: | `[]` | [`Index`][Index] | | `mut []` | [`IndexMut`][IndexMut] | + ### Why the split between `Eq`/`PartialEq` and `Ord`/`PartialOrd`? + There are some types in Rust whose values are only partially ordered, or have only partial equality. Partial ordering means that there may be values of the given type that are neither less than nor greater than each other. Partial equality means that there may be values of the given type that are not equal to themselves. @@ -521,7 +619,9 @@ Floating point types ([`f32`][f32] and [`f64`][f64]) are good examples of each.

    Input / Output

    + ### How do I read a file into a `String`? + Using the [`read_to_string()`][read__read_to_string] method, which is defined on the [`Read`][Read] trait in [`std::io`][std-io]. @@ -541,13 +641,17 @@ fn main() { } ``` + ### How do I read file input efficiently? + The [`File`][File] type implements the [`Read`][Read] trait, which has a variety of functions for reading and writing data, including [`read()`][read__read], [`read_to_end()`][read__read_to_end], [`bytes()`][read__bytes], [`chars()`][read__chars], and [`take()`][read__take]. Each of these functions reads a certain amount of input from a given file. [`read()`][read__read] reads as much input as the underlying system will provide in a single call. [`read_to_end()`][read__read_to_end] reads the entire buffer into a vector, allocating as much space as is needed. [`bytes()`][read__bytes] and [`chars()`][read__chars] allow you to iterate over the bytes and characters of the file, respectively. Finally, [`take()`][read__take] allows you to read up to an arbitrary number of bytes from the file. Collectively, these should allow you to efficiently read in any data you need. For buffered reads, use the [`BufReader`][BufReader] struct, which helps to reduce the number of system calls when reading. + ### How do I get command line arguments in Rust? + The easiest way is to use [`Args`][Args], which provides an iterator over the input arguments. @@ -555,27 +659,37 @@ If you're looking for something more powerful, there are a [number of options on

    Error Handling

    + ### Why doesn't Rust have exceptions? + Exceptions complicate understanding of control-flow, they express validity/invalidity outside of the type system, and they interoperate poorly with multithreaded code (a major focus of Rust). Rust prefers a type-based approach to error handling, which is [covered at length in the book](https://doc.rust-lang.org/stable/book/error-handling.html). This fits more nicely with Rust's control flow, concurrency, and everything else. + ### What's the deal with `unwrap()` everywhere? + `unwrap()` is a function that extracts the value inside an [`Option`][Option] or [`Result`][Result] and panics if no value is present. It is useful in the presence of truly unrecoverable errors, but is more useful for quick prototypes where you don't want to handle an error yet, or blog posts where error handling would distract from the main point. `unwrap()` shouldn't be your default way to handle errors, but it is a useful tool to have. + ### Why do I get an error when I try to run example code that uses the `try!` macro? + It's probably an issue with the function's return type. The [`try!`][TryMacro] macro either extracts the value from a [`Result`][Result], or returns early with the error [`Result`][Result] is carrying. This means that [`try`][TryMacro] only works for functions that return [`Result`][Result] themselves, where the `Err`-constructed type implements `From::from(err)`. In particular, this means that the [`try!`][TryMacro] macro cannot work inside the `main` function. + ### Is there an easier way to do error handling than having `Result`s everywhere? + If you're looking for a way to avoid handling [`Result`s][Result] in other people's code, there's always [`unwrap()`][unwrap], but it's probably not what you want. [`Result`][Result] is an indicator that some computation may or may not complete successfully. Requiring you to handle these failures explicitly is one of the ways that Rust encourages robustness. If you really don't want to handle an error, use [`unwrap()`][unwrap], but know that doing so means that the given code will cause the entire process to panic on failure, which is usually undesirable.

    Concurrency

    + ### Can I use static values across threads without an `unsafe` block? + Mutation is safe if it's synchronized. Mutating a static [`Mutex`][Mutex] (lazily initialized via the [lazy-static](https://crates.io/crates/lazy_static/) crate) does not require an `unsafe` block, nor does mutating a static [`AtomicUsize`][AtomicUsize] (which can be initialized without lazy_static). @@ -583,41 +697,57 @@ More generally, if a type implements [`Sync`][Sync] and does not implement [`Dro

    Macros

    + ### Can I write a macro to generate identifiers? + Not currently. Rust macros are ["hygienic macros"](https://en.wikipedia.org/wiki/Hygienic_macro), which intentionally avoid capturing or creating identifiers that may cause unexpected collisions with other identifiers. Their capabilities are significantly different than the style of macros commonly associated with the C preprocessor. Macro invocations can only appear in places where they are explicitly supported: items, method declarations, statements, expressions, and patterns. Here, "method declarations" means a blank space where a method can be put. They can't be used to complete a partial method declaration. By the same logic, they can't be used to complete a partial variable declaration.

    Debugging

    + ### How do I debug Rust programs? + Rust programs can be debugged using [gdb](http://sourceware.org/gdb/current/onlinedocs/gdb/) or [lldb](http://lldb.llvm.org/tutorial.html), same as C and C++. In fact, every Rust installation comes with one or both of rust-gdb and rust-lldb (depending on platform support). These are wrappers over gdb and lldb with Rust pretty-printing enabled. + ### `rustc` said a panic occurred in standard library code. How do I locate the mistake in my code? + This error is usually caused by [`unwrap()`ing][unwrap] a `None` or `Err` in client code. Enabling backtraces by setting the environment variable `RUST_BACKTRACE=1` helps with getting more information. Compiling in debug mode (the default for `cargo build`) is also helpful. Using a debugger like the provided `rust-gdb` or `rust-lldb` is also helpful.

    Low-Level

    + ### How do I `memcpy` bytes? + If you want to clone an existing slice safely, you can use [`clone_from_slice`][clone_from_slice]. This function is currently unstable, but [should be stabilized soon](https://internals.rust-lang.org/t/stabilizing-basic-functions-on-arrays-and-slices/2868). To copy potentially overlapping bytes, use [`copy`][copy]. To copy nonoverlapping bytes, use [`cpy_nonoverlapping`][copy_nonoverlapping]. Both of these functions are `unsafe`, as both can be used to subvert the language's safety guarantees. Take care when using them. + ### Can Rust function reasonably without the standard library? + Absolutely. Rust programs can be set to not load the standard library using the `#![no_std]` attribute. With this attribute set, you can continue to use the Rust core library, which is nothing but the platform-agnostic primitives. As such, it doesn't include IO, concurrency, heap allocation, etc. + ### Can I write an operating system in Rust? + Yes! In fact there are [several projects underway doing just that](http://wiki.osdev.org/Rust). + ### How can I read or write numeric types like `i32` or `f64` in big-endian or little-endian format in a file or other byte stream? + You should check out the [byteorder crate](http://burntsushi.net/rustdoc/byteorder/), which provides utilities for exactly that. + ### Does Rust guarantee a specific data layout? + Not by default. In the general case, `enum` and `struct` layouts are undefined. This allows the compiler to potentially do optimizations like re-using padding for the discriminant, compacting variants of nested `enum`s, reordering fields to remove padding, etc. `enums` which carry no data ("C-like") are eligible to have a defined representation. Such `enums` are easily distinguished in that they are simply a list of names that carry no data: @@ -646,19 +776,27 @@ TODO: Write this answer. TODO: Write this answer. --> + ### What's the idiomatic way to express platform-specific behavior in Rust? + Platform-specific behavior can be expressed using [conditional compilation attributes](https://doc.rust-lang.org/reference.html#conditional-compilation) such as `target_os`, `target_family`, `target_endian`, etc. + ### Can Rust be used for Android/iOS programming? + Yes it can! There are already examples of using Rust for both [Android](https://github.com/tomaka/android-rs-glue) and [iOS](https://www.bignerdranch.com/blog/building-an-ios-app-in-rust-part-1/). It does require a bit of work to set up, but Rust functions fine on both platforms. + ### Can I run my Rust program in a web browser? + Not yet, but there are efforts underway to make Rust compile to the web with [Emscripten](http://kripken.github.io/emscripten-site/). + ### How do I cross-compile in Rust? + Cross compilation is possible in Rust, but it requires [a bit of work](https://github.com/japaric/ruststrap/blob/master/1-how-to-cross-compile.md) to set up. Every Rust compiler is a cross-compiler, but libraries need to be cross-compiled for the target platform. @@ -666,7 +804,9 @@ Rust does distribute [copies of the standard library](http://static.rust-lang.or

    Modules and Crates

    + ### What is the relationship between a module and a crate? + - A crate is a compilation unit, which is the smallest amount of code that the Rust compiler can operate on. - A module is a (possibly nested) unit of code organization inside a crate. @@ -674,7 +814,9 @@ Rust does distribute [copies of the standard library](http://static.rust-lang.or - Recursive definitions can span modules, but not crates. - Using another crate binds the root of its namespace into the user's namespace. + ### Why can't the Rust compiler find this library I'm `use`ing? + There are a number of possible answers, but a common mistake is not realizing that `use` declarations are relative to the crate root. Try rewriting your declarations to use the paths they would use if defined in the root file of your project and see if that fixes the problem. @@ -682,7 +824,9 @@ There are also `self` and `super`, which disambiguate `use` paths as being relat For complete information on `use`ing libraries, read the Rust book's chapter ["Crates and Modules"](https://doc.rust-lang.org/stable/book/crates-and-modules.html). + ### Why do I have to declare module files with `mod` at the top level of the crate, instead of just `use`ing them? + There are two ways to declare modules in Rust, inline or in another file. Here is an example of each: @@ -717,15 +861,21 @@ In the first example, the module is defined in the same file it's used. In the s A `use`ing declaration just tells the compiler to bring everything from a particular module into the current module. Without a `mod` declaration first, the compiler doesn't know if the `use`d module exists, and so can't import its contents into the current module. + ### How do I configure Cargo to use a proxy? + As explained on the Cargo [configuration documentation](http://doc.crates.io/config.html), you can set Cargo to use a proxy by setting the "proxy" variable under `[http]` in the configuration file. + ### Why can't the compiler find the method implementation even though I'm already `use`ing the crate? + For methods defined on a trait, you have to explicitly import the trait declaration. This means it's not enough to import a module where a struct implements the trait, you must also import the trait itself. + ### Why can't the compiler infer `use` declarations for me? + It probably could, but you also don't want it to. While in many cases it is likely that the compiler could determine the correct module to import by simply looking for where a given identifier is defined, this may not be the case in general. Any decision rule in `rustc` for choosing between competing options would likely cause surprise and confusion, and not solve much of a problem. @@ -750,11 +900,15 @@ If you know this is going to happen, perhaps it saves a small number of keystrok TODO: Write this answer. --> + ### How do I do dynamic Rust library loading? + Import dynamic libraries in Rust with [libloading](https://crates.io/crates/libloading), which provides a cross-platform system for dynamic linking. -### Why doesn't [http://crates.io](http://crates.io) have namespaces? + +### Why doesn't crates.io have namespaces? + Quoting the [official explanation](https://internals.rust-lang.org/t/crates-io-package-policies/1041) of [http://crates.io](http://crates.io)'s design: @@ -768,7 +922,9 @@ Quoting the [official explanation](https://internals.rust-lang.org/t/crates-io-p > > Because namespaces are strictly more complicated in a number of ways,and because they can be added compatibly in the future should they become necessary, we're going to stick with a single shared namespace. + ### Why are so many Rust answers on StackOverflow wrong? + The Rust language has been around for a number of years, and only reached version 1.0 in May of 2015. In the time before then the language changed significantly, and a number of StackOverflow answers were given at the time of older versions of the language. @@ -776,59 +932,85 @@ Over time more and more answers will be offered for the current version, thus im

    Libraries

    + ### How can I make an HTTP request? + [Hyper](https://github.com/hyperium/hyper) is the most popular, but there are [a number of others as well](https://crates.io/keywords/http). + ### How can I write a GUI application in Rust? + There are a variety of ways to write GUI applications in Rust. Just check out [this list of GUI frameworks](https://github.com/kud1ing/awesome-rust#gui). + ### How can I parse JSON/XML? + [Serde](https://github.com/serde-rs/serde) is the recommended library for serialization and deserialization of Rust data to and from a number of different formats. + ### Is there a standard 2D+ dimensional vector and shape crate? + Not yet! Want to write one? + ### How do I write an OpenGL app in Rust? + [Glium](https://github.com/tomaka/glium) is the major library for OpenGL programming in Rust. [GLFW](https://github.com/bjz/glfw-rs) is also a solid option. + ### Can I write a video game in Rust? + Yes you can! The major game programming library for Rust is [Piston](http://www.piston.rs/), and there's both a [subreddit for game programming in Rust](https://www.reddit.com/r/rust_gamedev/) and an IRC channel (`#rust-gamedev` on [Mozilla IRC](https://wiki.mozilla.org/IRC)) as well.

    Design Patterns

    + ### Is Rust object oriented? + It is multi-paradigm. Many things you can do in OO languages you can do in Rust, but not everything, and not always using the same abstraction you're accustomed to. + ### How do I map object-oriented concepts to Rust? + That depends. There _are_ ways of translating object-oriented concepts like [multiple inheritance](https://www.reddit.com/r/rust/comments/2sryuw/ideaquestion_about_multiple_inheritence/) to Rust, but as Rust is not object-oriented the result of the translation may look substantially different from its appearance in an OO language. + ### How do I handle configuration of a struct with optional parameters? + The easiest way is to use the [`Option`][Option] type in whatever function you're using to construct instances of the struct (usually `new()`). Another way is to use the [builder pattern](https://aturon.github.io/ownership/builders.html), where only certain functions instantiating member variables must be called before the construction of the built type. + ### How do I do global variables in Rust? + Globals in Rust can be done using `const` declarations for compile-time computed global constants, while `static` can be used for mutable globals. Note that modifying a `static mut` variable requires the use of `unsafe`, as it allows for data races, one of the things guaranteed not to happen in safe Rust. One important distinction between `const` and `static` values is that you can take references to `static` values, but not references to `const` values, which don't have a specified memory location. For more information on `const` vs. `static`, read [the Rust book](https://doc.rust-lang.org/book/const-and-static.html). + ### How can I set compile-time constants that are defined procedurally? + Rust currently has limited support for compile time constants. You can define primitives using `const` declarations (similar to `static`, but immutable and without a specified location in memory) as well as define `const` functions and inherent methods. To define procedural constants that can't be defined via these mechanisms, use the [`lazy-static`](https://github.com/rust-lang-nursery/lazy-static.rs) crate, which emulates compile-time evaluation by automatically evaluating the constant at first use. + ### Can I run initialization code that happens before main? + Rust has no concept of "life before `main`". The closest you'll see can be done through the [`lazy-static`](https://github.com/Kimundi/lazy-static.rs) crate, which simulates a "before main" by lazily initializing static variables at their first usage. + ### Why doesn't Rust have inheritance? + There are two meanings for the word "inheritance": _subtyping_, and _interface sharing_. Both purposes are already handled by traits. @@ -838,7 +1020,9 @@ For the second, interface sharing is handled via trait methods, which define a c Rust has consistently worked to avoid having features with overlapping purposes, preferring to keep features orthogonal. For this reason, and given that the two major purposes are already handled by traits, Rust has opted not to include inheritance. + ### Does Rust allow non-constant-expression values for globals? + No. Globals cannot have a non-constant-expression constructor and cannot have a destructor at all. Static constructors are undesirable because portably ensuring a static initialization order is difficult. Life before main is often considered a misfeature, so Rust does not allow it. @@ -848,41 +1032,57 @@ You can approximate non-constant-expression globals with the [lazy-static](https

    Other Languages

    + ### How can I implement something like C's `struct X { static int X; };` in Rust? + Rust does not have `static` fields as shown in the code snippet above. Instead, you can declare a `static` variable in a given module, which is kept private to that module. + ### How can I convert a C-style enum to an integer, or vice-versa? + Converting a C-style enum to an integer can be done with an `as` expression, like `e as i64` (where `e` is some enum). Converting in the other direction can be done with a `match` statement, which maps different numeric values to different potential values for the enum. + ### Why does Rust not have a stable ABI like C does, and why do I have to annotate things with extern? + Committing to an ABI is a big decision that can limit potentially advantageous language changes in the future. Given that Rust only hit 1.0 in May of 2015, it is still too early to make a commitment as big as a stable ABI. This does not mean that one won't happen in the future, though. The `extern` keyword allows Rust to use specific ABI's, such as the well-defined C ABI, for interop with other languages. + ### Can Rust code call C code? + Yes. Calling C code from Rust is designed to be as efficient as calling C code from C++. + ### Can C code call Rust code? + Yes. The Rust code has to be exposed via an `extern` declaration, which makes it C-ABI compatible. Such a function can be passed to C code as a function pointer or, if given the `#[no_mangle]` attribute to disable symbol mangling, can be called directly from C code. + ### I already write perfect C++. What does Rust give me? + Modern C++ includes many features that make writing safe and correct code less error-prone, but it's not perfect, and it's still easy to introduce unsafety. This is something the C++ core developers are working to overcome, but C++ is limited by a long history that predates a lot of the ideas they are now trying to implement. Rust was designed from day one to be a safe systems programming language, which means it's not limited by historic design decisions that make getting safety right in C++ so complicated. In C++, safety is achieved by careful personal discipline, and is very easy to get wrong. In Rust, safety is the default. It gives you the ability to work in a team that includes people less perfect than you are, without having to spend your time double-checking their code for safety bugs. + ### How do I do the equivalent of C++ template specialization in Rust? + Rust doesn't currently have an exact equivalent to template specialization, but it is [being worked on](https://github.com/rust-lang/rfcs/pull/1210) and will hopefully be added soon. However, similar effects can be achieved via [associated types](https://doc.rust-lang.org/stable/book/associated-types.html). + ### How does Rust's ownership system relate to move semantics in C++? + The notions of a "move" in Rust and a "move" in C++ are quite different, owing to the different systems in which they exist. @@ -890,11 +1090,15 @@ In C++, R-value references come from a temporary value, or are explicitly create Rust "move"s are about transferring ownership, rather than eliminating mutable aliases (which are handled via the borrow checker). By default, the ownership of any function parameter is transferred into the function and out of the parameter at the call site, unless that parameter's type implements the [`Copy`][Copy] trait, in which case a shallow copy of the value is used to instantiate the actual parameter of the function. Rust's "move"s are often unecessary and undesirable. If the function you're writing does not require ownership of the value being passed in, that value should probably be borrowed (mutably or immutably, as necessary) rather than moved or copied. + ### How can I interoperate with C++ from Rust, or with Rust from C++? + Rust and C++ can interoperate through C. Both Rust and C++ provide a [foreign function interface](https://doc.rust-lang.org/book/ffi.html) for C, and can use that to communicate between each other. If writing C bindings is too tedious, you can always use [rust-bindgen](https://github.com/crabtw/rust-bindgen) to help automatically generate workable C bindings. + ### Does Rust have C++-style constructors? + No. Functions serve the same purpose as constructors without adding language complexity. The usual name for the constructor-equivalent function in Rust is `new()`, although this is just a convention rather than a language rule. The `new()` function in fact is just like any other function. An example of it looks like so: @@ -916,15 +1120,21 @@ impl Foo { } ``` + ### Does Rust have copy constructors? + Not exactly. Types which implement [`Copy`][Copy] will do a standard C-like "shallow copy" with no extra work (similar to "plain old data" in C++). It is impossible to implement [`Copy`][Copy] types that require custom copy behavior. Instead, in Rust "copy constructors" are created by implementing the [`Clone`][Clone] trait, and explicitly calling the [`clone`][clone] method. Making user-defined copy operators explicit surfaces the underlying complexity, forcing the developer to opt-in to potentially expensive operations. + ### Does Rust have move constructors? + No. Values of all types are moved via `memcpy`. This makes writing generic unsafe code much simpler since assignment, passing and returning are known to never have a side effect like unwinding. + ### How are Go and Rust similar, and how are they different? + Rust and Go have substantially different design goals. The following differences are not the only ones (which are too numerous to list), but are a few of the more important ones: @@ -933,11 +1143,15 @@ Rust and Go have substantially different design goals. The following differences - Rust has strong support for generics, which Go does not. - Rust has strong influences from the world of functional programming, including a type system which draws from Haskell's typeclasses. Go has a simpler type system, using interfaces for basic generic programming. + ### `gofmt` is great. Where's `rustfmt`? + `rustfmt` is [right here](https://github.com/rust-lang-nursery/rustfmt), and is being actively developed to make reading Rust code as easy and predictable as possible. + ### How do Rust traits compare to Haskell typeclasses? + Rust traits are similar to Haskell typeclasses, but are currently not as powerful, as Rust cannot express higher-kinded types. Rust's associated types are equivalent to Haskell type families. @@ -951,17 +1165,23 @@ Some specific difference between Haskell typeclasses and Rust traits include:

    Documentation

    + ### Where do I report issues in the Rust documentation? + You can report issues in the Rust documentation on the Rust compiler [issue tracker](https://github.com/rust-lang/rust/issues). Make sure to read the [contributing guidelines](https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#writing-documentation) first. + ### How do I view rustdoc documentation for a library my project depends on? + When you use `cargo doc` to generate documentation for your own project, it also generates docs for the active dependency versions. These are put into the `target/doc` directory of your project. Use `cargo doc --open` to open the docs after building them, or just open up `target/doc/index.html` yourself.

    The Rust Project

    + ### What is this project's goal? + To design and implement a safe, concurrent, practical systems language. @@ -974,13 +1194,17 @@ Rust exists because other languages at this level of abstraction and efficiency Rust exists as an alternative that provides both efficient code and a comfortable level of abstraction, while improving on all four of these points. + ### Is this project controlled by Mozilla? + No. Rust started as Graydon Hoare's part-time side project in 2006 and remained so for over 3 years. Mozilla got involved in 2009 once the language was mature enough to run basic tests and demonstrate its core concepts. Though it remains sponsored by Mozilla, Rust is developed by a diverse community of enthusiasts from many different places around the world. The [Rust Team](https://www.rust-lang.org/team.html) is composed of both Mozilla and non-Mozilla members, and `rustc` (Rust's compiler) has had over [1,000 unique contributors](https://github.com/rust-lang/rust/) so far. As far as [project governance](https://github.com/rust-lang/rfcs/blob/master/text/1068-rust-governance.md) goes, Rust is managed by a core team that sets the vision and priorities for the project, and accepts input on the design of the language via RFC proposals. There are also subteams to guide and foster development of particular areas of interest, including Rust libraries, Rust tools, and moderation of the official Rust communities. For changes which do not require an RFC, decisions are made through pull requests on the [`rustc` repository](https://github.com/rust-lang/rust). + ### What are some non-goals of Rust? + 1. We do not employ any particularly cutting-edge technologies. Old, established techniques are better. 2. We do not prize expressiveness, minimalism or elegance above other goals. These are desirable but subordinate goals. @@ -988,11 +1212,15 @@ As far as [project governance](https://github.com/rust-lang/rfcs/blob/master/tex 4. We do not intend to be 100% static, 100% safe, 100% reflective, or too dogmatic in any other sense. Trade-offs exist. 5. We do not demand that Rust run on "every possible platform". It must eventually work without unnecessary compromises on widely-used hardware and software platforms. + ### In which projects is Mozilla using Rust? + The main project is [Servo](https://github.com/servo/servo), an experimental browser engine Mozilla is working on. They are also working to [integrate Rust components](https://bugzilla.mozilla.org/show_bug.cgi?id=1135640) into Firefox. + ### What examples are there of large Rust projects? + The two biggest open source Rust projects right now are [Servo](https://github.com/servo/servo) and the [Rust compiler](https://github.com/rust-lang/rust) itself. @@ -1002,11 +1230,15 @@ The two biggest open source Rust projects right now are [Servo](https://github.c TODO: Write this answer. --> + ### How can I try Rust easily? + The easiest way to try Rust is through the [playpen](https://play.rust-lang.org/), an online app for writing and running Rust code. If you want to try Rust on your system, [install it](https://www.rust-lang.org/install.html) and go through the ["Learn Rust"](https://doc.rust-lang.org/stable/book/learn-rust.html) section of the book. + ### How do I get help with Rust issues? + There are several ways. You can: @@ -1015,11 +1247,15 @@ There are several ways. You can: - Ask on [StackOverflow](http://stackoverflow.com/questions/tagged/rust) with the "rust" tag - Post in [/r/rust](https://www.reddit.com/r/rust), the official Rust subreddit + ### Why has Rust changed so much over time? + Rust started with a goal of creating a safe but usable systems programming language. In pursuit of this goal it explored a lot of ideas, some of which it kept (lifetimes, traits) while others were discarded (the typestate system, green threading). Also, in the run up to 1.0 a lot of the standard library was rewritten as early designs were updated to best use Rust's features and provide quality, consistent cross-platform APIs. + ### How does Rust language versioning work? + Rust's language versioning follows [SemVer](http://semver.org/), with backwards incompatible changes of stable APIs only allowed in minor versions if those changes fix compiler bugs, patch safety holes, or change type inference to require additional annotation. @@ -1027,21 +1263,29 @@ Rust maintains three "release channels": stable, beta, and nightly. Stable and b For details, read the Rust blog post ["Stability as a Deliverable."](http://blog.rust-lang.org/2014/10/30/Stability.html) -### Can I use unstable features in the beta or stable channel? + +### Can I use unstable features on the beta or stable channel? + No, you cannot. Rust works hard to provide strong guarantees about the stability of the features provided on the beta and stable channels. When something is unstable, it means that we can't provide those guarantees for it yet, and don't want people relying on it staying the same. This gives us the opportunity to try changes in the wild on the nightly channel, while still maintaining strong guarantees for people seeking stability. Things stabilize all the time, and the beta and stable channels update every six weeks. If you're waiting for a feature to be available without using the nightly channel, you can locate its tracking issue by checking the [`B-unstable`](https://github.com/rust-lang/rust/issues?q=is%3Aissue+is%3Aopen+tracking+label%3AB-unstable) tag on the issue tracker. + ### What IDE should I use? + There are a number of options for development environment with Rust, all of which are detailed on the official [IDE support page](https://www.rust-lang.org/ides.html). + ### Why a dual MIT/ASL2 License? + The Apache license includes important protection against patent aggression, but it is not compatible with the GPL, version 2. To avoid problems using Rust with GPL2, it is alternately MIT licensed. + ### Why a BSD-style permissive license rather than MPL or tri-license? + This is partly due to preference of the original developer (Graydon), and partly due to the fact that languages tend to have a wider audience and more diverse set of possible embeddings and end-uses than products such as web browsers. We'd like to appeal to as many of those potential contributors as possible. From 1e9659b0756191c3683a5c51760eec12ae2b38a9 Mon Sep 17 00:00:00 2001 From: Aaron Turon Date: Wed, 13 Jan 2016 09:04:43 -0800 Subject: [PATCH 65/94] Changes to Performance section of FAQ. --- faq.md | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) diff --git a/faq.md b/faq.md index bd81389b8..833677cbc 100644 --- a/faq.md +++ b/faq.md @@ -49,15 +49,22 @@ If there is some common or important question you feel is wrongly left unanswere Fast! Rust is already competitive with idiomatic C and C++ in a number of benchmarks (like the [Benchmarks Game](http://benchmarksgame.alioth.debian.org/u64q/compare.php?lang=rust&lang2=gpp) and [others](https://github.com/kostya/benchmarks)). -It is an explicit goal of Rust to be at least as fast as C++. Language decisions are made with performance in mind, and given that Rust is built on LLVM and strives to resemble Clang from LLVM's perspective, any LLVM performance improvements also help Rust. +Like C++, Rust takes [zero-cost abstractions](http://blog.rust-lang.org/2015/05/11/traits.html) as one of its core principles: none of Rusts abstractions impose a global performance penalty, nor is there overhead from any runtime system. + +Given that Rust is built on LLVM and strives to resemble Clang from LLVM's perspective, any LLVM performance improvements also help Rust. In the long run, the richer information in Rust's type system should also enable optimizations that are difficult or impossible for C/C++ code. ### Is Rust garbage collected? -No. A language that requires a GC is a language that opts into a larger, more complex runtime than Rust cares for. Rust is usable on bare metal with no extra runtime. +No. One of Rust's key innovations is guaranteeing memory safety (no segfaults) *without* requiring garbage collection. + +By avoiding GC, Rust can offer numerous benefits: predictable cleanup of resources, lower overhead for memory management, and essentially no runtime system. All of these traits make Rust lean and easy to embed into arbitrary contexts, and make it much easier to [integrate Rust code with languages that have a GC](http://calculist.org/blog/2015/12/23/neon-node-rust/). + +Rust avoids the need for GC through its system of ownership and borrowing, but that same system helps with a host of other problems, including +[resource management in general](http://blog.skylight.io/rust-means-never-having-to-close-a-socket/) and [concurrency](http://blog.rust-lang.org/2015/04/10/Fearless-Concurrency.html). -Additionally, garbage collection is frequently a source of non-deterministic behavior. Rust provides tools to make using third-party garbage collectors [possible](http://manishearth.github.io/blog/2015/09/01/designing-a-gc-in-rust/), but it is not part of the language as provided. +Finally, Rust gives you the tools to [use or implement third-party garbage collectors](http://manishearth.github.io/blog/2015/09/01/designing-a-gc-in-rust/), but it is not part of the language as provided. ### Why is my program slow? @@ -83,7 +90,7 @@ Secondly, the Rust compiler suffers from long-standing technical debt, and notab Thirdly, Rust's use of LLVM for code generation is a double-edged sword: while it enables Rust to have world-class runtime performance, LLVM is a large framework that is not focused on compile-time performance, particularly when working with poor-quality inputs. -Finally, while Rust's preferred strategy of monomorphising generics (ala C++) produces fast code, it demands that significantly more code be generated than other translation strategies. +Finally, while Rust's preferred strategy of monomorphising generics (ala C++) produces fast code, it demands that significantly more code be generated than other translation strategies. Rust programmers can use trait objects to trade away this code bloat by using dynamic dispatch instead. ### Why are Rust's `HashMap`s slow? @@ -97,7 +104,7 @@ While SipHash [demonstrates competitive performance](http://cglab.ca/%7Eabeinges ### Why is there no integrated benchmarking infrastructure? -You can run benchmarks, but only on the nightly channel. Rust's benchmarking mechanism is currently unstable, as the API has not been deemed ready for stabilization. This [may change in the future](https://github.com/rust-lang/rust/issues/29553), but until then benchmarking can only be used on nightly. +There is, but it's only available on the nightly channel. We ultimately plan to build a pluggable system for integrated benchmarks, but in the meantime, the current system is [considered unstable](https://github.com/rust-lang/rust/issues/29553). ### Does Rust do tail-call optimization? From 65ef9eb81dedd3d5431cc4a9f4c0e324f77f2af8 Mon Sep 17 00:00:00 2001 From: Aaron Turon Date: Wed, 13 Jan 2016 09:18:03 -0800 Subject: [PATCH 66/94] Changes to Syntax section of FAQ --- faq.md | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/faq.md b/faq.md index 833677cbc..16485300e 100644 --- a/faq.md +++ b/faq.md @@ -138,7 +138,7 @@ Whereas C requires mandatory parentheses for `if`-statement conditionals but lea ### Why is there no literal syntax for dictionaries? -The reason Rust does not have syntax for initializing dictionaries — or collections in general — is due to Rust's overall design preference for limiting the size of the *language* while enabling powerful *libraries*. The only type of collection that Rust has direct syntax for initializing is the array type, which is also the only type of collection built into the language. Note that Rust does not even have syntax for initializing the common [`Vec`][Vec] collection type, instead the standard library defines the [`vec!`][VecMacro] macro. +Rust's overall design preference is for limiting the size of the *language* while enabling powerful *libraries*. While Rust does provide initialization syntax for arrays and string literals, these are the only collection types built into the language. Other library-defined types, including the ubiquitous [`Vec`][Vec] collection type, use macros for initialization like the [`vec!`][VecMacro] macro. This design choice of using Rust's macro facilities to initialize collections will likely be extended generically to other collections in the future, enabling simple initialization of not only [`HashMap`][HashMap] and [`Vec`][Vec], but also other collection types such as [`BTreeMap`][BTreeMap]. In the meantime, if you want a more convenient syntax for initializing collections, you can [create your own macro](http://stackoverflow.com/questions/27582739/how-do-i-create-a-hashmap-literal) to provide it. @@ -146,7 +146,7 @@ This design choice of using Rust's macro facilities to initialize collections wi ### When should I use an implicit return? -Rust is a very expression-oriented language, and implicit returns are part of that design. `if`s, `match`es, and normal blocks are all expressions in Rust. For example, the following code checks if an [`i64`][i64] is odd, returning the result with an implicit return: +Rust is a very expression-oriented language, and "implicit returns" are part of that design. Constructs like `if`s, `match`es, and normal blocks are all expressions in Rust. For example, the following code checks if an [`i64`][i64] is odd, returning the result by simply yielding it as a value: ```rust fn is_odd(x: i64) -> bool { @@ -162,7 +162,7 @@ fn is_odd(x: i64) -> bool { } ``` -In each example, the last line of the function is the return value of that function. It is important to note that if a function ends in a semicolon, its return type will be `()`, indicating no returned value. Implicit returns must omit the semicolon to work. +In each example, the last line of the function is the return value of that function. It is important to note that if a block ends in a semicolon, its return type will be `()`, indicating no returned value. Implicit returns must omit the semicolon to work. Explicit returns are only used if an implicit return is impossible because you are returning before the end of the function's body. While each of the above functions could have been written with a `return` keyword and semicolon, doing so would be unnecessarily verbose, and inconsistent with the conventions of Rust code. @@ -170,15 +170,21 @@ Explicit returns are only used if an implicit return is impossible because you a ### Why aren't function signatures inferred? -- Mandatory function signatures help enforce interface stability at both the module and crate level. -- It improves code comprehension for the programmer, eliminating the need for an IDE running an inference algorithm across an entire crate to be able to guess at a function's argument types; it's always explicit and nearby. +In Rust, declarations tend to come with explicit types, while actual code has its types inferred. There are several reasons for this design: + +- Mandatory declaration signatures help enforce interface stability at both the module and crate level. +- Signatures improve code comprehension for the programmer, eliminating the need for an IDE running an inference algorithm across an entire crate to be able to guess at a function's argument types; it's always explicit and nearby. - Mechanically, it simplifies the inference algorithm, as inference only requires looking at one function at a time. ### Why does `match` have to be exhaustive? -`match` being exhaustive has some useful properties. First, if every possibility is covered by the `match`, adding variants to the `enum` in the future will cause a compilation failure, rather than an error at runtime. Second, it makes the semantics of the default case explicit: in general, the only safe way to have a non-exhaustive `match` would be to panic the thread if nothing is matched. Early versions of Rust did not require `match` cases to be exhaustive and it was found to be a great source of bugs. +To aid in refactoring and clarity. + +First, if every possibility is covered by the `match`, adding variants to the `enum` in the future will cause a compilation failure, rather than an error at runtime. This compiler assistance makes fearless refactoring possible in Rust. + +Second, exhaustive checking makes the semantics of the default case explicit: in general, the only safe way to have a non-exhaustive `match` would be to panic the thread if nothing is matched. Early versions of Rust did not require `match` cases to be exhaustive and it was found to be a great source of bugs. It is easy to ignore all unspecified cases by using the `_` wildcard: From b007719e685fd48ace9b87685e3a79f72323a1e1 Mon Sep 17 00:00:00 2001 From: Aaron Turon Date: Wed, 13 Jan 2016 09:21:21 -0800 Subject: [PATCH 67/94] Changes to Numerics section of FAQ --- faq.md | 14 +++----------- 1 file changed, 3 insertions(+), 11 deletions(-) diff --git a/faq.md b/faq.md index 16485300e..bdce32f5b 100644 --- a/faq.md +++ b/faq.md @@ -208,27 +208,19 @@ If you are interested in the greatest degree of precision with your floating poi If in doubt, choose [`f64`][f64] for the greater precision. -### Why can't I compare floats? +### Why can't I compare floats or use them as `HashMap` or `BTreeMap` keys? Floats can be compared with the `==`, `!=`, `<`, `<=`, `>`, and `>=` operators, and with the `partial_cmp()` function. `==` and `!=` are part of the [`PartialEq`][PartialEq] trait, while `<`, `<=`, `>`, `>=`, and `partial_cmp()` are part of the [`PartialOrd`][PartialOrd] trait. Floats cannot be compared with the `cmp()` function, which is part of the [`Ord`][Ord] trait, as there is no total ordering for floats. Furthermore, there is no total equality relation for floats, and so they also do not implement the [`Eq`][Eq] trait. -There is no total ordering or equality on floats because the floating-point value `NaN` is not less than, greater than, or equal to any other floating-point value or itself. +There is no total ordering or equality on floats because the floating-point value [`NaN`](https://en.wikipedia.org/wiki/NaN) is not less than, greater than, or equal to any other floating-point value or itself. -Because floats do not implement [`Eq`][Eq] or [`Ord`][Ord], they may not be used in types whose trait bounds require those traits, such as [`BTreeMap`][BTreeMap]. +Because floats do not implement [`Eq`][Eq] or [`Ord`][Ord], they may not be used in types whose trait bounds require those traits, such as [`BTreeMap`][BTreeMap] or [`HashMap`][HashMap]. This is important because these types *assume* their keys provide a total ordering or total equality relation, and will malfunction otherwise. There [is a crate](https://crates.io/crates/ordered-float) that wraps [`f32`][f32] and [`f64`][f64] to provide [`Ord`][Ord] and [`Eq`][Eq] implementations, which may be useful in certain cases. - -### Why can't I use `f32` or `f64` as `HashMap` keys? - - -In order to be used as a key in a [`HashMap`][HashMap], a type must implement the [`Eq`][Eq] and [`Hash`][Hash] traits. [`Eq`][Eq] is required because keys have to be capable of being tested for equality, otherwise indexing on keys wouldn't work. [`Hash`][Hash] is required so that the type may be hashed by [`HashMap`'s][HashMap] hashing algorithm. - -[`f32`][f32] and [`f64`][f64] implement [`PartialEq`][PartialEq], but not [`Eq`][Eq] This is because one of the potential values for floating-point types is `NaN` (or "not a number"). Per the IEEE floating-point specification, `NaN` values are [not equal to any other floating-point value, and not equal to each other](https://en.wikipedia.org/wiki/NaN). This means there is no total equality relation for floating-point types, and thus that [`f32`][f32] and [`f64`][f64] can't implement [`Eq`][Eq] and can't used as keys in a [`HashMap`][HashMap]. - ### How can I convert between numeric types? From 2ae6a62124003fbd0519875d6334d0012be5cd45 Mon Sep 17 00:00:00 2001 From: Aaron Turon Date: Wed, 13 Jan 2016 09:25:51 -0800 Subject: [PATCH 68/94] Changes to Strings section of FAQ --- faq.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/faq.md b/faq.md index bdce32f5b..d246de825 100644 --- a/faq.md +++ b/faq.md @@ -233,8 +233,11 @@ There are two ways: the `as` keyword, which does simple casting for primitive ty ### How can I convert a `String` or `Vec` to a slice (`&str` and `&[T]`)? +Usually, you can pass a reference to a `String` or `Vec` wherever a slice is expected. Using [Deref coercions](https://doc.rust-lang.org/stable/book/deref-coercions.html), [`String`s][String] and [`Vec`s][Vec] will automatically coerce to their respective slices when passed by reference with `&` or `& mut`. +In some cases, such as generic code, it's necessary to convert manually. Manual conversions can be achieved using the slicing operator, like so: `&my_vec[..]`. + ### How can I convert from `&str` to `String` or the other way around? From 6834f06ade6a07e4925797f7068a69aaff1a55de Mon Sep 17 00:00:00 2001 From: Aaron Turon Date: Wed, 13 Jan 2016 09:27:30 -0800 Subject: [PATCH 69/94] Changes to Collections section of FAQ --- faq.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/faq.md b/faq.md index d246de825..b0fb92a44 100644 --- a/faq.md +++ b/faq.md @@ -319,11 +319,13 @@ Rust `for` loops call `into_iter()` (defined on the [`IntoIterator`][IntoIterato If a moving/consuming iterator is desired, write the `for` loop without `&` or `&mut` in the iteration. +If you need direct access to a borrowing iterator, you can usually get it by calling the `iter()` method. + ### Why do I need to type the array size in the array declaration? -You don't necessarily have to. If you're declaring an array directly, the size is inferred based on the number of elements. But if you're declaring a function that takes an array, the compiler has to know how big that array will be. +You don't necessarily have to. If you're declaring an array directly, the size is inferred based on the number of elements. But if you're declaring a function that takes a fixed-size array, the compiler has to know how big that array will be. One thing to note is that currently Rust doesn't offer generics over arrays of different size. If you'd like to accept a contiguous container of a variable number of values, use a [`Vec`][Vec] or slice (depending on whether you need ownership). From 7d870a86605cea4d70657ce504992f3268dd82f2 Mon Sep 17 00:00:00 2001 From: Aaron Turon Date: Wed, 13 Jan 2016 09:44:27 -0800 Subject: [PATCH 70/94] Changes to Ownership section of FAQ --- faq.md | 42 ++++++++++++++++++------------------------ 1 file changed, 18 insertions(+), 24 deletions(-) diff --git a/faq.md b/faq.md index b0fb92a44..0bb9b16f5 100644 --- a/faq.md +++ b/faq.md @@ -335,7 +335,7 @@ One thing to note is that currently Rust doesn't offer generics over arrays of d ### How can I implement a graph or other data structure that contains cycles? -There are four major options: +There are at least four options (discussed at length in a [draft book](http://cglab.ca/~abeinges/blah/too-many-lists/book/): - You can implement it using [`Rc`][Rc] and [`Weak`][Weak] to allow shared ownership of nodes, although this approach pays the cost of memory management. @@ -368,17 +368,11 @@ fn main() { } ``` - -### What does it mean to "consume a value"? - - -"Consuming a value" means taking ownership of a value. When this is done, the value can't be used elsewhere. "Consume" is a fairly evocative term for this event. - -### What is the difference between consuming and moving/taking ownership? +### What is the difference between passing by value, consuming, moving, and transferring ownership? -These are different terms for the same thing. In both cases, it means the value has been moved to another owner, and moved out of the calling owner. +These are different terms for the same thing. In all cases, it means the value has been moved to another owner, and moved out of the possession of the original owner, who can no longer use it. ### Why can values of some types be used after passing them to a function, while reuse of values of other types results in an error? @@ -400,9 +394,9 @@ If none of these are possible, you may want to modify the function that acquired ### What are the rules for using `self`, `&self`, or `&mut self` in a method declaration? -- Use `self` when a function needs to consume the type -- Use `&self` when a function only needs a read-only reference to the type -- Use `&mut self` when a function needs to mutate the type without consuming it +- Use `self` when a function needs to consume the value +- Use `&self` when a function only needs a read-only reference to the value +- Use `&mut self` when a function needs to mutate the value without consuming it ### How can I understand the borrow checker? @@ -425,6 +419,18 @@ The single most important part of understanding the borrow checker is practice. If you find yourself struggling with the borrow checker, or running out of patience, always feel free to reach out to the [Rust community](community.html) for help. + +### When is `Rc` useful? + + +This is covered in the official documentation for [`Rc`][Rc], Rust's non-atomically reference-counted pointer type. In short, [`Rc`][Rc] and its thread-safe cousin [`Arc`][Arc] are useful to express shared ownership, and have the system automatically deallocate the associated memory when no one has access to it. + + +### How do I return a closure from a function? + + +To return a closure from a function, it must be a "move closure", meaning that the closure is declared with the `move` keyword. As [explained in the Rust book](https://doc.rust-lang.org/book/closures.html#move-closures), this gives the closure its own copy of the captured variables, independent of its parent stack frame. Otherwise, returning a closure would be unsafe, as it would allow access to variables that are no longer valid; put another way: it would allow reading potentially invalid memory. The closure must also be wrapped in a [`Box`][Box], so that it is allocated on the heap. Read more about this [in the book](https://doc.rust-lang.org/book/closures.html#returning-closures). + ### How do deref coercions work? @@ -455,12 +461,6 @@ Lifetimes are Rust's answer to the question of memory safety. They allow Rust to The `'a` syntax comes from the ML family of programming languages, where `'a` is used to indicate a generic type parameter. For Rust, the syntax had to be something that was unambiguous, noticeable, and fit nicely in a type declaration right alonside traits and references. Alternative syntaxes have been discussed, but no alternative syntax has been demonstrated to be clearly better. - -### When is `Rc` useful? - - -This is covered in the official documentation for [`Rc`][Rc], Rust's non-atomically reference-counted pointer type. In short, [`Rc`][Rc] and its thread-safe cousin [`Arc`][Arc] are useful to express shared ownership, and have the system automatically deallocate the associated memory when no one has access to it. - ### How do I return a borrow to something I created from a function? @@ -506,12 +506,6 @@ fn abs_all(input: &mut Cow<[i32]>) { } ``` - -### How do I return a closure from a function? - - -To return a closure from a function, it must be a "move closure", meaning that the closure is declared with the `move` keyword. As [explained in the Rust book](https://doc.rust-lang.org/book/closures.html#move-closures), this gives the closure its own copy of the captured variables, independent of its parent stack frame. Otherwise, returning a closure would be unsafe, as it would allow access to variables that are no longer valid; put another way: it would allow reading potentially invalid memory. The closure must also be wrapped in a [`Box`][Box], so that it is allocated on the heap. Read more about this [in the book](https://doc.rust-lang.org/book/closures.html#returning-closures). - ### When are lifetimes required to be explicit? From bc6a918c61ad4819540a02d22bdab63201b2b0ab Mon Sep 17 00:00:00 2001 From: Aaron Turon Date: Wed, 13 Jan 2016 10:10:44 -0800 Subject: [PATCH 71/94] Changes to Lifetimes section of FAQ --- faq.md | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/faq.md b/faq.md index 0bb9b16f5..46d86940b 100644 --- a/faq.md +++ b/faq.md @@ -459,7 +459,7 @@ Lifetimes are Rust's answer to the question of memory safety. They allow Rust to ### Why is the lifetime syntax the way it is? -The `'a` syntax comes from the ML family of programming languages, where `'a` is used to indicate a generic type parameter. For Rust, the syntax had to be something that was unambiguous, noticeable, and fit nicely in a type declaration right alonside traits and references. Alternative syntaxes have been discussed, but no alternative syntax has been demonstrated to be clearly better. +The `'a` syntax comes from the ML family of programming languages, where `'a` is used to indicate a generic type parameter. For Rust, the syntax had to be something that was unambiguous, noticeable, and fit nicely in a type declaration right alongside traits and references. Alternative syntaxes have been discussed, but no alternative syntax has been demonstrated to be clearly better. ### How do I return a borrow to something I created from a function? @@ -510,19 +510,20 @@ fn abs_all(input: &mut Cow<[i32]>) { ### When are lifetimes required to be explicit? -Lifetimes must be explicit when the rules for automatic lifetime inference result in compilation errors. The Rust compiler tries its best to automatically infer correct lifetimes (called ["elided lifetimes"](https://doc.rust-lang.org/stable/book/lifetimes.html#lifetime-elision)) based on the following rules: +Rust has a shorthand for leaving off lifetimes that covers the vast majority of cases in practice. +This shorthand is called [lifetime elision](https://doc.rust-lang.org/stable/book/lifetimes.html#lifetime-elision), and encompasses three rules: - Each elided lifetime in a function’s arguments becomes a distinct lifetime parameter. - If there is exactly one input lifetime, elided or not, that lifetime is assigned to all elided lifetimes in the return values of that function. -- If there are multiple input lifetimes, but one of them is `&self` or `&mut` self, the lifetime of self is assigned to all elided output lifetimes. +- If there are multiple input lifetimes, but one of them is `&self` or `&mut self`, the lifetime of `self` is assigned to all elided output lifetimes. If these rules result in compilation errors, the Rust compiler will provide an error message indicating the error caused, and suggesting a potential solution based on which step of the inference process caused the error. -### How can Rust guarantee "no null pointers"? +### How can Rust guarantee "no null pointers" and "no dangling pointers"? -The only way to construct a value of type `&Foo` or `&mut Foo` is to specify an existing value of type `Foo` that the reference points to. In this way Rust makes sure no null references are introduced. +The only way to construct a value of type `&Foo` or `&mut Foo` is to specify an existing value of type `Foo` that the reference points to. The reference "borrows" the original value for a given region of code (the lifetime of the reference), and the value being borrowed from cannot be moved or destroyed for the duration of the borrow. ### How do I express the absence of a value without `null`? From 8f4fcd5ff6d4f6fa5f9300adf910b64aa339a84d Mon Sep 17 00:00:00 2001 From: Aaron Turon Date: Wed, 13 Jan 2016 10:29:34 -0800 Subject: [PATCH 72/94] Changes to Generics section of FAQ --- faq.md | 23 ++++++++++++++++------- 1 file changed, 16 insertions(+), 7 deletions(-) diff --git a/faq.md b/faq.md index 46d86940b..09cfa2b66 100644 --- a/faq.md +++ b/faq.md @@ -537,7 +537,10 @@ You can do that with the [`Option`][Option] type, which can either be `Some(T)` ### What is "monomorphisation"? -Monomorphisation is the process by which Rust translates to machine code specific instances of a generic function based on the parameter types of calls to that function. During monomorphisisation a new copy of the generic function is translated for each unique set of types the function is instantiated with. This is the same strategy used by C++. It results in fast code that is specialized for every call-site and statically dispatched, with the tradeoff that functions instantiated with many different types can cause "code bloat", where multiple function instances result in larger binaries than would be created with other translation strategies. +Monomorphisation specializes each use of a generic function (or structure) with specific instance, +based on the parameter types of calls to that function (or uses of the structure). + +During monomorphisisation a new copy of the generic function is translated for each unique set of types the function is instantiated with. This is the same strategy used by C++. It results in fast code that is specialized for every call-site and statically dispatched, with the tradeoff that functions instantiated with many different types can cause "code bloat", where multiple function instances result in larger binaries than would be created with other translation strategies. Functions that accept [trait objects](http://doc.rust-lang.org/book/trait-objects.html) instead of type parameters do not undergo monomorphisation. Instead, methods on the trait objects are dispatched dynamically at runtime. @@ -551,19 +554,23 @@ Functions are a built-in primitive of the language, while closures are essential The big difference between these traits is how they take the `self` parameter. [`Fn`][Fn] takes `&self`, [`FnMut`][FnMut] takes `&mut self`, and [`FnOnce`][FnOnce] takes `self`. -Even if a closure does not capture any environment variables, it is represeted at runtime as two points, same as any other closure. +Even if a closure does not capture any environment variables, it is represeted at runtime as two pointers, the same as any other closure. ### What are higher-kinded types, why would I want them, and why doesn't Rust have them? -Higher-kinded types are typed with unfilled parameters. Type constructors, like [`Vec`][Vec], [`Result`][Result], and [`HashMap`][HashMap] are all examples of higher-kinded types. Support for higher-kinded types means these "incomplete" types may be used anywhere "complete" types can be used, such as trait `impl`s. +Higher-kinded types are types with unfilled parameters. Type constructors, like [`Vec`][Vec], [`Result`][Result], and [`HashMap`][HashMap] are all examples of higher-kinded types: each requires some additional type parameters in order to actually denote a specific type, like `Vec`. Support for higher-kinded types means these "incomplete" types may be used anywhere "complete" types can be used, including as generics for functions. Any complete type, like [`i32`][i32], [`bool`][bool], or [`char`][char] is of kind `*`. A type with one parameter, like [`Vec`][Vec] is of kind `* -> *`, meaning that [`Vec`][Vec] takes in a complete type like [`i32`][i32] and returns a complete type `Vec`. A type which three parameters, like [`HashMap`][HashMap] is of kind `* -> * -> * -> *`, and takes in three complete types (like [`i32`][i32], [`String`][String], and [`RandomState`][RandomState]) to produce a new complete type `HashMap`. -The lack of support for higher-kinded types makes expression of certain ideas more tedious than it would otherwise be. For example, implementing a `Functor` trait (a term for a container which can be mapped over, obeying certain rules) without higher-kinded types requires explicit and otherwise unnecessary handling of the container's type parameters. With higher-kined types, a `Functor` `impl` can ignore the parameters entirely. +In addition to these examples, type constructors can take *lifetime* arguments, which we'll denote as `Lt`. For example, `slice::Iter` has kind `Lt -> * -> *`, because it must be instantiated like `Iter<'a, u32>`. + +The lack of support for higher-kinded types makes it difficult to write certain kinds of generic code. It's particularly problematic for abstracting over concepts like iterators, since iterators are often parameterized over a lifetime at least. That in turn has prevented the creation of traits abstracting over Rust's collections. -Rust doesn't currently have support for higher-kinded types because it hasn't been a priority. There is nothing inherent to the language that stops the support from being implemented. It just hasn't been done yet. +Another common example is concepts like functors or monads, both of which are type constructors, rather than single types. + +Rust doesn't currently have support for higher-kinded types because it hasn't been a priority compared to other improvements we want to make. Since the design is a major, cross-cutting change, we also want to approach it carefully. But there's no inherent reason for the current lack of support. ### What do named type parameters like `` in generic types mean? @@ -571,13 +578,13 @@ Rust doesn't currently have support for higher-kinded types because it hasn't be These are called [associated types](https://doc.rust-lang.org/stable/book/associated-types.html), and they allow for the expression of trait bounds that can't be expressed with a `where` clause. For example, a generic bound `X: Bar` means "`X` must implement the trait `Bar`, and in that implementation of `Bar`, `X` must choose `Foo` for `Bar`'s associated type, `T`." Examples of where such a constraint cannot be expressed via a `where` clause include trait objects like `Box>`. -Associated types exist because, for a generic type with some type parameters, it is often unecessary to include those type parameters in a function taking that generic type as a parameter. The function shouldn't have to care about being generic over the types which make up the generic type (say, the node and edge types in a graph), but only about being generic over the type itself. +Associated types exist because generics often involve families of types, where one type determines all of the others in a family. For example, a trait for graphs might have as its `Self` type the graph itself, and have associated types for nodes and for edges. Each graph type uniquely determines the associated types. Using associated types makes it much more concise to work with these families of types, and also provides better type inference in many cases. ### Can I overload operators? Which ones and how? -You can provide custom implementations for a variety of operators using their associated traits: [`Add`][Add] for `+`, [`Mul`][Mul] for `*`. It looks like this: +You can provide custom implementations for a variety of operators using their associated traits: [`Add`][Add] for `+`, [`Mul`][Mul] for `*`, and so on. It looks like this: ```rust use std::ops::Add; @@ -622,6 +629,8 @@ There are some types in Rust whose values are only partially ordered, or have on Floating point types ([`f32`][f32] and [`f64`][f64]) are good examples of each. Any floating point type may have the value `NaN` (meaning "not a number"). `NaN` is not equal to itself (`NaN == Nan` is false), and not less than or greater than any other floating point value. As such, both [`f32`][f32] and [`f64`][f64] implement [`PartialOrd`][PartialOrd] and [`PartialEq`][PartialEq] but not [`Ord`][Ord] and not [`Eq`][Eq]. +As explained in [the earlier question on floats](#why-cant-i-compare-floats), these distinctions are important because some collections rely on total orderings/equality in order to give correct results. +

    Input / Output

    From 04f3a4208f05bb490c6a91777f0b11ee7e27efcd Mon Sep 17 00:00:00 2001 From: Aaron Turon Date: Wed, 13 Jan 2016 10:35:22 -0800 Subject: [PATCH 73/94] Changes to Error Handling section of FAQ --- faq.md | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/faq.md b/faq.md index 09cfa2b66..1cec488d1 100644 --- a/faq.md +++ b/faq.md @@ -685,7 +685,11 @@ Rust prefers a type-based approach to error handling, which is [covered at lengt ### What's the deal with `unwrap()` everywhere? -`unwrap()` is a function that extracts the value inside an [`Option`][Option] or [`Result`][Result] and panics if no value is present. It is useful in the presence of truly unrecoverable errors, but is more useful for quick prototypes where you don't want to handle an error yet, or blog posts where error handling would distract from the main point. `unwrap()` shouldn't be your default way to handle errors, but it is a useful tool to have. +`unwrap()` is a function that extracts the value inside an [`Option`][Option] or [`Result`][Result] and panics if no value is present. + +`unwrap()` shouldn't be your default way to handle errors you expect to arise, such as incorrect user input. In production code, it should be treated like an assertion that the value is non-empty, which will crash the program if violated. + +It's also useful for quick prototypes where you don't want to handle an error yet, or blog posts where error handling would distract from the main point. ### Why do I get an error when I try to run example code that uses the `try!` macro? @@ -697,7 +701,9 @@ It's probably an issue with the function's return type. The [`try!`][TryMacro] m ### Is there an easier way to do error handling than having `Result`s everywhere? -If you're looking for a way to avoid handling [`Result`s][Result] in other people's code, there's always [`unwrap()`][unwrap], but it's probably not what you want. [`Result`][Result] is an indicator that some computation may or may not complete successfully. Requiring you to handle these failures explicitly is one of the ways that Rust encourages robustness. If you really don't want to handle an error, use [`unwrap()`][unwrap], but know that doing so means that the given code will cause the entire process to panic on failure, which is usually undesirable. +If you're looking for a way to avoid handling [`Result`s][Result] in other people's code, there's always [`unwrap()`][unwrap], but it's probably not what you want. [`Result`][Result] is an indicator that some computation may or may not complete successfully. Requiring you to handle these failures explicitly is one of the ways that Rust encourages robustness. Rust provides tools like the [`try!` macro][TryMacro] to make handling failures ergonomic. + +If you really don't want to handle an error, use [`unwrap()`][unwrap], but know that doing so means that the given code will cause the entire process to panic on failure, which is usually undesirable.

    Concurrency

    From 27739053ef1e535bc5cb0e23e5e2a43ae237a302 Mon Sep 17 00:00:00 2001 From: Aaron Turon Date: Wed, 13 Jan 2016 10:37:13 -0800 Subject: [PATCH 74/94] Changes to Debugging section of FAQ --- faq.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/faq.md b/faq.md index 1cec488d1..36d53f4bc 100644 --- a/faq.md +++ b/faq.md @@ -729,7 +729,7 @@ Not currently. Rust macros are ["hygienic macros"](https://en.wikipedia.org/wiki ### How do I debug Rust programs? -Rust programs can be debugged using [gdb](http://sourceware.org/gdb/current/onlinedocs/gdb/) or [lldb](http://lldb.llvm.org/tutorial.html), same as C and C++. In fact, every Rust installation comes with one or both of rust-gdb and rust-lldb (depending on platform support). These are wrappers over gdb and lldb with Rust pretty-printing enabled. +Rust programs can be debugged using [gdb](http://sourceware.org/gdb/current/onlinedocs/gdb/) or [lldb](http://lldb.llvm.org/tutorial.html), the same as C and C++. In fact, every Rust installation comes with one or both of rust-gdb and rust-lldb (depending on platform support). These are wrappers over gdb and lldb with Rust pretty-printing enabled. ### `rustc` said a panic occurred in standard library code. How do I locate the mistake in my code? From 16502ed882b52605999eb5ba8816fb2aab34b2fc Mon Sep 17 00:00:00 2001 From: Aaron Turon Date: Wed, 13 Jan 2016 10:43:37 -0800 Subject: [PATCH 75/94] Changes to Modules/Crates section of FAQ --- faq.md | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/faq.md b/faq.md index 36d53f4bc..2e49a8cae 100644 --- a/faq.md +++ b/faq.md @@ -879,7 +879,7 @@ pub fn f() { In the first example, the module is defined in the same file it's used. In the second example, the module declaration in the main file tells the compiler to look for either `hello.rs` or `hello/mod.rs`, and to load that file. -A `use`ing declaration just tells the compiler to bring everything from a particular module into the current module. Without a `mod` declaration first, the compiler doesn't know if the `use`d module exists, and so can't import its contents into the current module. +A `use` declaration just tells the compiler to bring *existing* names (reachable through some path) into scope. A `mod` declaration tells the compiler to *define* a module, and also brings that module's name into scope the same as `use` would. ### How do I configure Cargo to use a proxy? @@ -897,7 +897,7 @@ For methods defined on a trait, you have to explicitly import the trait declarat ### Why can't the compiler infer `use` declarations for me? -It probably could, but you also don't want it to. While in many cases it is likely that the compiler could determine the correct module to import by simply looking for where a given identifier is defined, this may not be the case in general. Any decision rule in `rustc` for choosing between competing options would likely cause surprise and confusion, and not solve much of a problem. +It probably could, but you also don't want it to. While in many cases it is likely that the compiler could determine the correct module to import by simply looking for where a given identifier is defined, this may not be the case in general. Any decision rule in `rustc` for choosing between competing options would likely cause surprise and confusion in some cases, and Rust prefers to be explicit about where names are coming from. For example, the compiler could say that in the case of competing identifier definitions the definition from the earliest imported module is chosen. So if both module `foo` and module `bar` define the identifier `baz`, but `foo` is the first registered module, the compiler would insert `use foo::baz;`. @@ -914,6 +914,8 @@ fn main() { If you know this is going to happen, perhaps it saves a small number of keystrokes, but it also greatly increases the possibility for surprising error messages when you actually meant for `baz()` to be `bar::baz()`, and it decreases the readability of the code by making the meaning of a function call dependent on module declaration. These are not tradeoffs we are willing to make. +However, in the future, an IDE could help manage declarations, which gives you the best of both worlds: machine assistance for pulling in names, but explicit declarations about where those names are coming from. + + ### Does Rust allow non-constant-expression values for globals? From 29c6f12db6f96b2d3521d50a59d3bf0f3010ee9a Mon Sep 17 00:00:00 2001 From: Aaron Turon Date: Wed, 13 Jan 2016 11:47:21 -0800 Subject: [PATCH 78/94] Nits from Gabor --- faq.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/faq.md b/faq.md index 2939daf56..703700d0e 100644 --- a/faq.md +++ b/faq.md @@ -703,7 +703,7 @@ It's probably an issue with the function's return type. The [`try!`][TryMacro] m If you're looking for a way to avoid handling [`Result`s][Result] in other people's code, there's always [`unwrap()`][unwrap], but it's probably not what you want. [`Result`][Result] is an indicator that some computation may or may not complete successfully. Requiring you to handle these failures explicitly is one of the ways that Rust encourages robustness. Rust provides tools like the [`try!` macro][TryMacro] to make handling failures ergonomic. -If you really don't want to handle an error, use [`unwrap()`][unwrap], but know that doing so means that the given code will cause the entire process to panic on failure, which is usually undesirable. +If you really don't want to handle an error, use [`unwrap()`][unwrap], but know that doing so means that the code panic on failure, which usually results in a shutting down the process.

    Concurrency

    @@ -879,7 +879,7 @@ pub fn f() { In the first example, the module is defined in the same file it's used. In the second example, the module declaration in the main file tells the compiler to look for either `hello.rs` or `hello/mod.rs`, and to load that file. -A `use` declaration just tells the compiler to bring *existing* names (reachable through some path) into scope. A `mod` declaration tells the compiler to *define* a module, and also brings that module's name into scope the same as `use` would. +A `use` declaration just tells the compiler to bring *existing* names (reachable through some path) into scope. A `mod` declaration tells the compiler to *define* a module, and like all other declaration forms, also brings the name of the module into scope. ### How do I configure Cargo to use a proxy? From 522890359ec7eb6681da28fc273e3356b983ba28 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Wed, 13 Jan 2016 16:26:02 -0500 Subject: [PATCH 79/94] Update entry about copy constructors --- faq.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/faq.md b/faq.md index 7812993fc..a3443628c 100644 --- a/faq.md +++ b/faq.md @@ -840,7 +840,7 @@ impl Foo { ### Does Rust have copy constructors? -Not exactly. Types which implement `Copy` will do a standard C-like "shallow copy" with no extra work (similar to "plain old data" in C++). It is impossible to implement `Copy` types that require custom copy behavior. Instead, in Rust "copy constructors" are created by implementing the `Clone` trait, and explicitly calling the `clone` method. Making user-defined copy operators explicit surfaces the underlying complexity, forcing the developer to opt-in to potentially expensive operations. +Not exactly. Types which implement `Copy` will do a standard C-like "shallow copy" with no extra work (similar to "plain old data" in C++). It is impossible to implement `Copy` types that require custom copy behavior. Instead, in Rust "copy constructors" are created by implementing the `Clone` trait, and explicitly calling the `clone` method. Making user-defined copy operators explicit surfaces the underlying complexity, making it easier for the developer to identify potentially expensive operations. ### Does Rust have move constructors? From 5e0771ac98430034396be8d2f7fe74c8e472942d Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Wed, 13 Jan 2016 16:28:15 -0500 Subject: [PATCH 80/94] Tweak wording when comparing with go --- faq.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/faq.md b/faq.md index a3443628c..de64647df 100644 --- a/faq.md +++ b/faq.md @@ -854,7 +854,7 @@ In Swift, `?` is used to indicate an optional value. This is already done by `Op Rust and Go have substantially different design goals. The following differences are not the only ones (which are too numerous to list), but are a few of the more important ones: -- Rust is lower level than Go, comparable with C and C++. It provides access to memory management primitives that do not exist in Go (which has a garbage collector). +- Rust is lower level than Go. For example, Rust does not require a garbage collector, whereas Go does. In general, Rust affords a level of control that is comparable to C or C++. - Rust's focus is on ensuring safety and efficiency while also providing high-level affordances, while Go's is on being a small, simple language which compiles quickly and can work nicely with a variety of tools. - Rust has strong support for generics, which Go does not. - Rust has strong influences from the world of functional programming, including a type system which draws from Haskell's typeclasses. Go has a simpler type system, using interfaces for basic generic programming. From ded567f91e6324ee39d035d10da63e22d01100e1 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Wed, 13 Jan 2016 17:49:06 -0500 Subject: [PATCH 81/94] Rewrite the section on C++11 references --- faq.md | 53 ++++++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 50 insertions(+), 3 deletions(-) diff --git a/faq.md b/faq.md index de64647df..a9780343e 100644 --- a/faq.md +++ b/faq.md @@ -806,11 +806,58 @@ Rust doesn't currently have an exact equivalent to template specialization, but ### How does Rust's ownership system relate to move semantics in C++? -The notions of a "move" in Rust and a "move" in C++ are quite different, owing to the different systems in which they exist. +The underlying concepts are similar, but the two systems work very +differently in practice. In both systems, "moving" a value is a way to +transfer ownership of its underlying resources. For example, moving a +string would transfer the string's buffer rather than copying it. -In C++, R-value references come from a temporary value, or are explicitly created from a named value via `std::move`. In this way, C++ enforces that no mutable references exist to the moved-out value, so that the memory may be safely invalidated. In Rust, mutable aliases are statically eliminated by the borrow checker, and so the rough equivalent of C++'s R-values are found in Rust's mutable references (`&mut`), which can only be used if no other mutable alias already exists to the given memory location. +In Rust, ownership transfer is the default behavior. For example, if I +write a function that takes a `String` as argument, this function will +take ownership of the `String` value supplied by its caller: -Rust "move"s are about transferring ownership, rather than eliminating mutable aliases (which are handled via the borrow checker). By default, the ownership of any function parameter is transferred into the function and out of the parameter at the call site, unless that parameter's type implements the `Copy` trait, in which case a shallow copy of the value is used to instantiate the actual parameter of the function. Rust's "move"s are often unecessary and undesirable. If the function you're writing does not require ownership of the value being passed in, that value should probably be borrowed (mutably or immutably, as necessary) rather than moved or copied. +```rust +fn process(s: String) { } + +fn caller() { + let s = String::from("Hello, world!"); + process(s); // Transfers ownership of `s` to `process` + process(s); // Error! ownership already transferred. +} +``` + +As you can see in the snippet above, in the function `caller`, the +first call to `process` transfers ownership of the variable `s`. The +compiler tracks ownership, so the second call to `process` results in +an error, because it is illegal to give away ownership of the same +value twice. Rust will also prevent you from moving a value if there +is an outstanding reference into that value. + +C++ takes a different approach. In C++, the default is to copy a value +(to invoke the copy constructor, more specifically). However, callees +can declare their arguments using an "rvalue reference", like +`string&&`, to indicate that they will take ownership of some of the +resources owned by that argument (in this case, the string's internal +buffer). The caller then must either pass a temporary expression or +make an explicit move using `std::move`. The rough equivalent to the +function `process` above, then, would be: + +``` +void process(string&& s) { } + +void caller() { + string s("Hello, world!"); + process(std::move(s)); + process(std::move(s)); +} +``` + +C++ compilers are not obligated to track moves. For example, the code +above compiles without a warning or error, at least using the default +settings on clang. Moreover, in C++ ownership of the string `s` itself +(if not its internal buffer) remains with `caller`, and so the +destructor for `s` will run when `caller` returns, even though it has +been moved (in Rust, in contrast, moved values are dropped only by +their new owners). ### How can I interoperate with C++ from Rust, or with Rust from C++? From 6b39558464e90e63d95c5d523aa6772c9eac1511 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Wed, 13 Jan 2016 17:49:36 -0500 Subject: [PATCH 82/94] Note that C++ does not have a stable ABI --- faq.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/faq.md b/faq.md index a9780343e..e41f8b63f 100644 --- a/faq.md +++ b/faq.md @@ -782,7 +782,7 @@ Converting in the other direction can be done with a `match` statement, which ma ### Why does Rust not have a stable ABI like C does, and why do I have to annotate things with extern? -Committing to an ABI is a big decision that can limit potentially advantageous language changes in the future. Given that Rust only hit 1.0 in May of 2015, it is still too early to make a commitment as big as a stable ABI. This does not mean that one won't happen in the future, though. +Committing to an ABI is a big decision that can limit potentially advantageous language changes in the future. Given that Rust only hit 1.0 in May of 2015, it is still too early to make a commitment as big as a stable ABI. This does not mean that one won't happen in the future, though. (Though C++ has managed to go for many years without specifying a stable ABI.) The `extern` keyword allows Rust to use specific ABI's, such as the well-defined C ABI, for interop with other languages. From 6ae99cf239c209812d3794bb59fe3021993b87b6 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Wed, 13 Jan 2016 17:49:48 -0500 Subject: [PATCH 83/94] Some context seemed to be missing from question on HTTP --- faq.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/faq.md b/faq.md index e41f8b63f..a7f479fce 100644 --- a/faq.md +++ b/faq.md @@ -700,7 +700,7 @@ Over time more and more answers will be offered for the current version, thus im ### How can I make an HTTP request? -[Hyper](https://github.com/hyperium/hyper) is the most popular, but there are [a number of others as well](https://crates.io/keywords/http). +The standard library does not include an implementation of HTTP, so you will want to use an external crate. [Hyper](https://github.com/hyperium/hyper) is the most popular, but there are [a number of others as well](https://crates.io/keywords/http). ### How can I write a GUI application in Rust? From 3c379b3ffffa5bf22aa9e186727e7a50a33cef43 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Wed, 13 Jan 2016 17:50:01 -0500 Subject: [PATCH 84/94] Try to better clarify difference between `mod` and `use` --- faq.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/faq.md b/faq.md index a7f479fce..0760ce39f 100644 --- a/faq.md +++ b/faq.md @@ -637,7 +637,7 @@ pub fn f() { In the first example, the module is defined in the same file it's used. In the second example, the module declaration in the main file tells the compiler to look for either `hello.rs` or `hello/mod.rs`, and to load that file. -A `use`ing declaration just tells the compiler to bring everything from a particular module into the current module. Without a `mod` declaration first, the compiler doesn't know if the `use`d module exists, and so can't import its contents into the current module. +Note the difference between `mod` and `use`: `mod` declares that a module exists, whereas `use` references a module declared elsewhere, bringing its contents into scope within the current module. ### How do I configure Cargo to use a proxy? From 6fb2247630e5e7da6f6ea2e19907e080f9f3ff76 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Wed, 13 Jan 2016 17:50:46 -0500 Subject: [PATCH 85/94] Edit lifetime answer --- faq.md | 28 +++++++++++++++++++++------- 1 file changed, 21 insertions(+), 7 deletions(-) diff --git a/faq.md b/faq.md index 0760ce39f..e53935deb 100644 --- a/faq.md +++ b/faq.md @@ -335,13 +335,27 @@ You need to ensure that the borrowed item will outlive the function. This can be To return a closure from a function, it must be a "move closure", meaning that the closure is declared with the `move` keyword. As [explained in the Rust book](https://doc.rust-lang.org/book/closures.html#move-closures), this gives the closure its own copy of the captured variables, independent of its parent stack frame. Otherwise, returning a closure would be unsafe, as it would allow access to variables that are no longer valid; put another way: it would allow reading potentially invalid memory. The closure must also be wrapped in a `Box`, so that it is allocated on the heap. Read more about this [in the book](https://doc.rust-lang.org/book/closures.html#returning-closures). -### When are lifetimes required to be defined? - -Lifetimes can often be elided, as explained in the ["Lifetime elision" section](https://doc.rust-lang.org/book/lifetimes.html#lifetime-elision) of the Rust book. "Elided lifetimes" are those lifetimes which are implicit in any code containing references. They are automatically inserted by the compiler with the three following rules: - -- Each elided lifetime in a function’s arguments becomes a distinct lifetime parameter. -- If there is exactly one input lifetime, elided or not, that lifetime is assigned to all elided lifetimes in the return values of that function. -- If there are multiple input lifetimes, but one of them is &self or &mut self, the lifetime of self is assigned to all elided output lifetimes. +### Why do some references have lifetimes, like `&'a T`, and some do not, like `&T`? + +In fact, *all* reference types have a lifetime, but most of the time you do not have to write +it explicitly. The rules are as follows: + +1. Within a function body, you never have to write a lifetime explicitly; the correct value + should always be inferred. +2. Within a function *signature* (for example, in the types of its + arguments, or its return type), you *may* have to write a lifetime + explicitly. Lifetimes there use a simple defaulting scheme called + ["lifetime elision"](https://doc.rust-lang.org/book/lifetimes.html#lifetime-elision), + which consists of the following three rules: + + - Each elided lifetime in a function’s arguments becomes a distinct lifetime parameter. + - If there is exactly one input lifetime, elided or not, that + lifetime is assigned to all elided lifetimes in the return values + of that function. + - If there are multiple input lifetimes, but one of them is &self + or &mut self, the lifetime of self is assigned to all elided + output lifetimes. +3. Finally, in a `struct` or `enum` definition, all lifetimes must be explicitly declared. If these rules would result in incorrect code elsewhere, then the Rust compiler will provide errors, and you will need to define the relevant lifetimes to correct that error. From cc6ec7b3acbd74d51459f076f44fb28d0e05f156 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Wed, 13 Jan 2016 17:51:36 -0500 Subject: [PATCH 86/94] Rework entry on deref coercions --- faq.md | 35 +++++++++++++++++++++-------------- 1 file changed, 21 insertions(+), 14 deletions(-) diff --git a/faq.md b/faq.md index e53935deb..05a76d9bf 100644 --- a/faq.md +++ b/faq.md @@ -298,20 +298,27 @@ The borrow checker applies only a few rules, which can be found in the Rust book While the rules themselves are simple, making sure your code conforms to them can be complicated. It is easy to attempt to borrow a value for longer than its lifetime, or to introduce two mutable references to the same value. The borrow checker is useful because it verifies that your code follows these rules, and helps guide corrections when the code doesn't. Many new Rust programmers struggle to satisfy the borrow checker at first, but over time become more skilled at writing memory safe code with minimal borrow checker intervention. -### How do deref coercions work? - -[Deref coercions](https://doc.rust-lang.org/book/deref-coercions.html) exist to make using Rust more ergonomic, and are implemented via the [`Deref`](https://doc.rust-lang.org/stable/std/ops/trait.Deref.html) trait, which looks like - -```rust -pub trait Deref { - type Target: ?Sized; - fn deref(&self) -> &Self::Target; -} -``` - -A Deref implementation indicates that the implementing type may be converted into `Target` by a call to the `deref` function, which takes an immutable reference of a certain lifetime to the calling struct, and returns a reference of the same lifetime to the target. The `*` prefix operator is shorthand for the `deref` method. - -You can see a [full list of `Deref` implementations](https://doc.rust-lang.org/stable/std/ops/trait.Deref.html#implementors) for the standard library in the documentation. +### What is a deref coercion and hoes does it work? + +A [deref coercion](https://doc.rust-lang.org/book/deref-coercions.html) is a handy coercion +that automatically converts references to pointers (e.g., `&Rc` or `&Box`) into references +to their contents (e.g., `&T`). Deref coercions exist to make using Rust more ergonomic. + +The most common sorts of deref coercions are: + +- `&Rc` to `&T` +- `&Box` to `&T` +- `&Arc` to `&T` +- `&Vec` to `&[T]` +- `&String` to `&str` + +In general though, a deref coercion permits coercion `&T` to `&U` if +`T` can be dereferenced to `U`. Dereferencing in Rust is an +overloadable operator controlled by the +[`Deref`](https://doc.rust-lang.org/stable/std/ops/trait.Deref.html) +trait. You can see a +[full list of `Deref` implementations](https://doc.rust-lang.org/stable/std/ops/trait.Deref.html#implementors) +for the standard library in the documentation.

    Lifetimes

    From 113b39c1d12d961432c3477f65f0325a3b801900 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Wed, 13 Jan 2016 17:52:06 -0500 Subject: [PATCH 87/94] Rework GC answer to mention potential upcoming work --- faq.md | 18 +++++++++++++++--- 1 file changed, 15 insertions(+), 3 deletions(-) diff --git a/faq.md b/faq.md index 05a76d9bf..228eaa754 100644 --- a/faq.md +++ b/faq.md @@ -47,9 +47,21 @@ It is an explicit goal of Rust to be at least as fast as C++. Language decisions ### Is Rust garbage collected? -No. A language that requires a GC is a language that opts into a larger, more complex runtime than Rust cares for. Rust is usable on bare metal with no extra runtime. - -Additionally, garbage collection is frequently a source of non-deterministic behavior. Rust provides tools to make using third-party garbage collectors [possible](http://manishearth.github.io/blog/2015/09/01/designing-a-gc-in-rust/), but it is not part of the language as provided. +No. A language that requires a GC is a language that opts into a +larger, more complex runtime than Rust cares for. Rust is usable on +bare metal with no extra runtime. In practice, most Rust programs rely +on reference counting through the standard library's +[`Rc`](http://doc.rust-lang.org/std/rc/struct.Rc.html) and +[`Arc`](http://doc.rust-lang.org/std/sync/struct.Arc.html) types. + +We are however investigating *optional* garbage collection as a future +extension. The goal is to enable smooth integration with +garbage-collected runtimes, such as those offered by the +[Spidermonkey](https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey) +and [V8](https://developers.google.com/v8/?hl=en) JavaScript engines. +Finally, some people have investigated implementing +[pure Rust garbage collectors](http://manishearth.github.io/blog/2015/09/01/designing-a-gc-in-rust/) +without compiler support. ### Why is my program slow? From 0de44080290d18b05a6bea947ea063070e70d641 Mon Sep 17 00:00:00 2001 From: Aaron Turon Date: Wed, 13 Jan 2016 16:03:48 -0800 Subject: [PATCH 88/94] brson's nits --- faq.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/faq.md b/faq.md index 703700d0e..d7185c2f1 100644 --- a/faq.md +++ b/faq.md @@ -162,7 +162,7 @@ fn is_odd(x: i64) -> bool { } ``` -In each example, the last line of the function is the return value of that function. It is important to note that if a block ends in a semicolon, its return type will be `()`, indicating no returned value. Implicit returns must omit the semicolon to work. +In each example, the last line of the function is the return value of that function. It is important to note that if a function ends in a semicolon, its return type will be `()`, indicating no returned value. Implicit returns must omit the semicolon to work. Explicit returns are only used if an implicit return is impossible because you are returning before the end of the function's body. While each of the above functions could have been written with a `return` keyword and semicolon, doing so would be unnecessarily verbose, and inconsistent with the conventions of Rust code. @@ -335,7 +335,7 @@ One thing to note is that currently Rust doesn't offer generics over arrays of d ### How can I implement a graph or other data structure that contains cycles?     -There are at least four options (discussed at length in a [draft book](http://cglab.ca/~abeinges/blah/too-many-lists/book/): +There are at least four options (discussed at length in [Too Many Linked Lists](http://cglab.ca/~abeinges/blah/too-many-lists/book/): - You can implement it using [`Rc`][Rc] and [`Weak`][Weak] to allow shared ownership of nodes, although this approach pays the cost of memory management. From 1a56bff8410cfc6b330ae4a501b78026424e5028 Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Thu, 14 Jan 2016 00:29:39 +0000 Subject: [PATCH 89/94] Don't imply that exhaustive match is the whole refactoring story --- faq.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/faq.md b/faq.md index 2a12bc7f5..b2de552de 100644 --- a/faq.md +++ b/faq.md @@ -194,7 +194,7 @@ In Rust, declarations tend to come with explicit types, while actual code has it To aid in refactoring and clarity. -First, if every possibility is covered by the `match`, adding variants to the `enum` in the future will cause a compilation failure, rather than an error at runtime. This compiler assistance makes fearless refactoring possible in Rust. +First, if every possibility is covered by the `match`, adding variants to the `enum` in the future will cause a compilation failure, rather than an error at runtime. This type of compiler assistance makes fearless refactoring possible in Rust. Second, exhaustive checking makes the semantics of the default case explicit: in general, the only safe way to have a non-exhaustive `match` would be to panic the thread if nothing is matched. Early versions of Rust did not require `match` cases to be exhaustive and it was found to be a great source of bugs. From 2a5ae9933c8f125903fc117224ea7c05340c49c0 Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Thu, 14 Jan 2016 01:01:10 +0000 Subject: [PATCH 90/94] Use HTML for faq headers to create valid markup --- css/style.css | 4 +- faq.md | 720 +++++++++++++++++++++++++------------------------- 2 files changed, 362 insertions(+), 362 deletions(-) diff --git a/css/style.css b/css/style.css index 5f4a13025..6ac30ef95 100644 --- a/css/style.css +++ b/css/style.css @@ -422,7 +422,7 @@ ul.laundry-list { font-size: 1em; line-height: 1.5em; font-weight: 500; - margin: 2rem 0 .25rem; + margin: 2rem 0 .5rem; } @media screen and (min-width: 820px) { @@ -474,7 +474,7 @@ ul.laundry-list { line-height: 1.5em; } -.faq a > h3 { +.faq h3 > a { color: black; } diff --git a/faq.md b/faq.md index b2de552de..794458426 100644 --- a/faq.md +++ b/faq.md @@ -43,9 +43,9 @@ If there is some common or important question you feel is wrongly left unanswere

    Performance

    - -### How fast is Rust? - +

    +How fast is Rust? +

    Fast! Rust is already competitive with idiomatic C and C++ in a number of benchmarks (like the [Benchmarks Game](http://benchmarksgame.alioth.debian.org/u64q/compare.php?lang=rust&lang2=gpp) and [others](https://github.com/kostya/benchmarks)). @@ -53,9 +53,9 @@ Like C++, Rust takes [zero-cost abstractions](http://blog.rust-lang.org/2015/05/ Given that Rust is built on LLVM and strives to resemble Clang from LLVM's perspective, any LLVM performance improvements also help Rust. In the long run, the richer information in Rust's type system should also enable optimizations that are difficult or impossible for C/C++ code. - -### Is Rust garbage collected? - +

    +Is Rust garbage collected? +

    No. One of Rust's key innovations is guaranteeing memory safety (no segfaults) *without* requiring garbage collection. @@ -78,17 +78,17 @@ Finally, some people have investigated implementing [pure Rust garbage collectors](http://manishearth.github.io/blog/2015/09/01/designing-a-gc-in-rust/) without compiler support. - -### Why is my program slow? - +

    +Why is my program slow? +

    The Rust compiler doesn't compile with optimizations unless asked to, [as optimizations slow down compilation and are usually undesirable during development](https://users.rust-lang.org/t/why-does-cargo-build-not-optimise-by-default/4150/3). If you compile with `cargo`, use the `--release` flag. If you compile with `rustc` directly, use the `-O` flag. Either of these will turn on optimizations. - -### Rust compilation seems slow. Why is that? - +

    +Rust compilation seems slow. Why is that? +

    Code translation and optimizations. Rust provides high level abstractions that compile down into efficient machine code, and those translations take time to run, especially when optimizing. @@ -104,59 +104,59 @@ Thirdly, Rust's use of LLVM for code generation is a double-edged sword: while i Finally, while Rust's preferred strategy of monomorphising generics (ala C++) produces fast code, it demands that significantly more code be generated than other translation strategies. Rust programmers can use trait objects to trade away this code bloat by using dynamic dispatch instead. - -### Why are Rust's `HashMap`s slow? - +

    +Why are Rust's HashMaps slow? +

    By default, Rust's [`HashMap`][HashMap] uses the [SipHash](https://131002.net/siphash/) hashing algorithm, which is designed to prevent [hash table collision attacks](http://programmingisterrible.com/post/40620375793/hash-table-denial-of-service-attacks-revisited) while providing [reasonable performance on a variety of workloads](https://www.reddit.com/r/rust/comments/3hw9zf/rust_hasher_comparisons/cub4oh6). While SipHash [demonstrates competitive performance](http://cglab.ca/%7Eabeinges/blah/hash-rs/) in many cases, one case where it is notably slower than other hashing algorithms is with short keys, such as integers. This is why Rust programmers often observe slow performance with [`HashMap`][HashMap]. The [FNV hasher](https://crates.io/crates/fnv) is frequently recommended for these cases, but be aware that it does not have the same collision-resistance properties as SipHash. - -### Why is there no integrated benchmarking infrastructure? - +

    +Why is there no integrated benchmarking infrastructure? +

    There is, but it's only available on the nightly channel. We ultimately plan to build a pluggable system for integrated benchmarks, but in the meantime, the current system is [considered unstable](https://github.com/rust-lang/rust/issues/29553). - -### Does Rust do tail-call optimization? - +

    +Does Rust do tail-call optimization? +

    Not generally, no. Tail-call optimization may be done in [limited circumstances](http://llvm.org/docs/CodeGenerator.html#sibling-call-optimization), but is [not guaranteed](https://mail.mozilla.org/pipermail/rust-dev/2013-April/003557.html). As the feature has always been desired, Rust has a keyword (`become`) reserved, though it is not clear yet whether it is technically possible, nor whether it will be implemented. There was a [proposed extension](https://github.com/rust-lang/rfcs/pull/81) that would allow tail-call elimination in certain contexts, but it is currently postponed. - -### Does Rust have a runtime? - +

    +Does Rust have a runtime? +

    Not in the typical sense used by languages such as Java, but parts of the Rust standard library can be considered a "runtime", providing a heap, backtraces, unwinding, and stack guards. There is a [small amount of initialization code](https://github.com/rust-lang/rust/blob/33916307780495fe311fe9c080b330d266f35bfb/src/libstd/rt.rs#L43) that runs before the user's `main` function. The Rust standard library additionally links to the the C standard library, which does similar [runtime initialization](http://www.embecosm.com/appnotes/ean9/html/ch05s02.html). Rust code can be compiled without the standard library, in which case the runtime is roughly equivalent to C's.

    Syntax

    - -### Why curly braces? Why can't Rust's syntax be like Haskell's or Python's? - +

    +Why curly braces? Why can't Rust's syntax be like Haskell's or Python's? +

    Use of curly braces to denote blocks is a common design choice in a variety of programming languages, and Rust's consistency is useful for people already familiar with the style. Curly braces also allow for more flexible syntax for the programmer, a simpler parser in the compiler, and help reduce the possibility of logic mistakes caused by incorrect indentation, like Apple's [goto fail](https://gotofail.com/) bug. - -### I can leave out parentheses on `if` conditions, so why do I have to put brackets around single line blocks? Why is the C style not allowed? - +

    +I can leave out parentheses on if conditions, so why do I have to put brackets around single line blocks? Why is the C style not allowed? +

    Whereas C requires mandatory parentheses for `if`-statement conditionals but leaves brackets optional, Rust makes the opposite choice for its `if`-expressions. This keeps the conditional clearly separate from the body and avoids the hazard of optional brackets, which can lead to easy-to-miss errors during refactoring. - -### Why is there no literal syntax for dictionaries? - +

    +Why is there no literal syntax for dictionaries? +

    Rust's overall design preference is for limiting the size of the *language* while enabling powerful *libraries*. While Rust does provide initialization syntax for arrays and string literals, these are the only collection types built into the language. Other library-defined types, including the ubiquitous [`Vec`][Vec] collection type, use macros for initialization like the [`vec!`][VecMacro] macro. This design choice of using Rust's macro facilities to initialize collections will likely be extended generically to other collections in the future, enabling simple initialization of not only [`HashMap`][HashMap] and [`Vec`][Vec], but also other collection types such as [`BTreeMap`][BTreeMap]. In the meantime, if you want a more convenient syntax for initializing collections, you can [create your own macro](http://stackoverflow.com/questions/27582739/how-do-i-create-a-hashmap-literal) to provide it. - -### When should I use an implicit return? - +

    +When should I use an implicit return? +

    Rust is a very expression-oriented language, and "implicit returns" are part of that design. Constructs like `if`s, `match`es, and normal blocks are all expressions in Rust. For example, the following code checks if an [`i64`][i64] is odd, returning the result by simply yielding it as a value: @@ -178,9 +178,9 @@ In each example, the last line of the function is the return value of that funct Explicit returns are only used if an implicit return is impossible because you are returning before the end of the function's body. While each of the above functions could have been written with a `return` keyword and semicolon, doing so would be unnecessarily verbose, and inconsistent with the conventions of Rust code. - -### Why aren't function signatures inferred? - +

    +Why aren't function signatures inferred? +

    In Rust, declarations tend to come with explicit types, while actual code has its types inferred. There are several reasons for this design: @@ -188,9 +188,9 @@ In Rust, declarations tend to come with explicit types, while actual code has it - Signatures improve code comprehension for the programmer, eliminating the need for an IDE running an inference algorithm across an entire crate to be able to guess at a function's argument types; it's always explicit and nearby. - Mechanically, it simplifies the inference algorithm, as inference only requires looking at one function at a time. - -### Why does `match` have to be exhaustive? - +

    +Why does match have to be exhaustive? +

    To aid in refactoring and clarity. @@ -209,9 +209,9 @@ match val.do_something() {

    Numerics

    - -### Which of `f32` and `f64` should I prefer for floating-point math? - +

    +Which of `32` and `f64` should I prefer for floating-point math? +

    The choice of which to use is dependent on the purpose of the program. @@ -219,9 +219,9 @@ If you are interested in the greatest degree of precision with your floating poi If in doubt, choose [`f64`][f64] for the greater precision. - -### Why can't I compare floats or use them as `HashMap` or `BTreeMap` keys? - +

    +Why can't I compare floats or use them as HashMap or BTreeMap keys? +

    Floats can be compared with the `==`, `!=`, `<`, `<=`, `>`, and `>=` operators, and with the `partial_cmp()` function. `==` and `!=` are part of the [`PartialEq`][PartialEq] trait, while `<`, `<=`, `>`, `>=`, and `partial_cmp()` are part of the [`PartialOrd`][PartialOrd] trait. @@ -233,26 +233,26 @@ Because floats do not implement [`Eq`][Eq] or [`Ord`][Ord], they may not be used There [is a crate](https://crates.io/crates/ordered-float) that wraps [`f32`][f32] and [`f64`][f64] to provide [`Ord`][Ord] and [`Eq`][Eq] implementations, which may be useful in certain cases. - -### How can I convert between numeric types? - +

    +How can I convert between numeric types? +

    There are two ways: the `as` keyword, which does simple casting for primitive types, and the [`Into`][Into] and [`From`][From] traits, which are implemented for a number of type conversions (and which you can implement for your own types). The [`Into`][Into] and [`From`][From] traits are only implemented in cases where conversions are lossless, so for example, `f64::from(0f32)` will compile while `f32:from(0f64)` will not. On the other hand, `as` will convert between any two primitive types, truncating values as necessary.

    Strings

    - -### How can I convert a `String` or `Vec` to a slice (`&str` and `&[T]`)? - +

    +How can I convert a String or Vec<T> to a slice (&str and &[T])? +

    Usually, you can pass a reference to a `String` or `Vec` wherever a slice is expected. Using [Deref coercions](https://doc.rust-lang.org/stable/book/deref-coercions.html), [`String`s][String] and [`Vec`s][Vec] will automatically coerce to their respective slices when passed by reference with `&` or `& mut`. In some cases, such as generic code, it's necessary to convert manually. Manual conversions can be achieved using the slicing operator, like so: `&my_vec[..]`. - -### How can I convert from `&str` to `String` or the other way around? - +

    +How can I convert from &str to String or the other way around? +

    The [`to_owned()`][to_owned] method converts from a [`&str`][str] into a [`String`][String], and [`String`s][String] are automatically converted into [`&str`][str] when you borrow a reference to them. Both are demonstrated in the following example: @@ -267,17 +267,17 @@ fn say_hello(name: &str) { } ``` - -### What are the differences between the two different string types? - +

    +What are the differences between the two different string types? +

    [`String`][String] is an owned buffer of UTF-8 bytes allocated on the heap. Mutable [`String`s][String] can be modified, growing their capacity as needed. [`&str`][str] is a fixed-capacity "view" into a [`String`][String] allocated elsewhere, commonly on the heap, in the case of slices dereferenced from [`String`s][String], or in static memory, in the case of string literals. [`&str`][str] is a primitive type implemented by the Rust language, while [`String`][String] is implemented in the standard library. - -### How do I do O(1) character access in a `String`? - +

    +How do I do O(1) character access in a String? +

    You cannot. At least not without a firm understanding of what you mean by "character", and preprocessing the string to find the index of the desired character. @@ -285,9 +285,9 @@ Rust strings are UTF-8 encoded. A single visual character in UTF-8 is not necess Thus, even though you may index on bytes in a UTF-8 string, you can't access the `i`th code point or grapheme cluster in constant time. However, if you know at which byte that desired code point or grapheme cluster begins, then you _can_ access it in constant time. Functions including [`str::find()`][str__find] and regex matches return byte indices, facilitating this sort of access. - -### Why are strings UTF-8 by default? - +

    +Why are strings UTF-8 by default? +

    The [`str`][str] type is UTF-8 because we observe more text in the wild in this encoding – particularly in network transmissions, which are endian-agnostic – and we think it's best that the default treatment of I/O not involve having to recode codepoints in each direction. @@ -303,9 +303,9 @@ For a more in-depth explanation of why UTF-8 is usually preferable over UTF-16 o

    Collections

    - -### Can I implement data structures like vectors and linked lists efficiently in Rust? - +

    +Can I implement data structures like vectors and linked lists efficiently in Rust? +

    If your reason for implementing these data structures is to use them for other programs, there's no need, as efficient implementations of these data structures are provided by the standard library. @@ -313,9 +313,9 @@ If, however, [your reason is simply to learn](http://cglab.ca/~abeinges/blah/too For example, a doubly-linked list requires that there be two mutable references to each node, but this violates Rust's mutable reference aliasing rules. You can solve this using [`Weak`][Weak], but the performance will be poorer than you likely want. With unsafe code you can bypass the mutable reference aliasing rule restriction, but must manually verify that your code introduces no memory safety violations. - -### How can I iterate over a collection without moving/consuming it? - +

    +How can I iterate over a collection without moving/consuming it? +

    The easiest way is by using the collection's [`IntoIterator`][IntoIterator] implementation. Here is an example for [`&Vec`][Vec]: @@ -333,9 +333,9 @@ If a moving/consuming iterator is desired, write the `for` loop without `&` or ` If you need direct access to a borrowing iterator, you can usually get it by calling the `iter()` method. - -### Why do I need to type the array size in the array declaration? - +

    +Why do I need to type the array size in the array declaration? +

    You don't necessarily have to. If you're declaring an array directly, the size is inferred based on the number of elements. But if you're declaring a function that takes a fixed-size array, the compiler has to know how big that array will be. @@ -343,9 +343,9 @@ One thing to note is that currently Rust doesn't offer generics over arrays of d

    Ownership

    - -### How can I implement a graph or other data structure that contains cycles? - +

    +How can I implement a graph or other data structure that contains cycles? +

    There are at least four options (discussed at length in [Too Many Linked Lists](http://cglab.ca/~abeinges/blah/too-many-lists/book/): @@ -356,9 +356,9 @@ more efficient, but bypasses Rust's safety guarantees. - Using vectors and indices into those vectors. There are [several](http://smallcultfollowing.com/babysteps/blog/2015/04/06/modeling-graphs-in-rust-using-vector-indices/) [available](http://featherweightmusings.blogspot.com/2015/04/graphs-in-rust.html) examples and explanations of this approach. - Using borrowed references with [`UnsafeCell`][UnsafeCell]. There are [explanations and code](https://github.com/nrc/r4cppp/blob/master/graphs/README.md#node-and-unsafecell) available for this approach. - -### How can I define a struct that contains a pointer to one of its own fields? - +

    +How can I define a struct that contains a pointer to one of its own fields? +

    It's possible, but useless to do so. The struct becomes permanently borrowed by itself and therefore can't be moved. Here is some code illustrating this: @@ -380,21 +380,21 @@ fn main() { } ``` - -### What is the difference between passing by value, consuming, moving, and transferring ownership? - +

    +What is the difference between passing by value, consuming, moving, and transferring ownership? +

    These are different terms for the same thing. In all cases, it means the value has been moved to another owner, and moved out of the possession of the original owner, who can no longer use it. - -### Why can values of some types be used after passing them to a function, while reuse of values of other types results in an error? - +

    +Why can values of some types be used after passing them to a function, while reuse of values of other types results in an error? +

    If a type implements the [`Copy`][Copy] trait, then it will be copied when passed to a function. All numeric types in Rust implement [`Copy`][Copy], but struct types do not implement [`Copy`][Copy] by default, so they are moved instead. This means that the struct can no longer be used elsewhere, unless it is moved back out of the function via the return. - -### How do you deal with a "use of moved value" error? - +

    +How do you deal with a "use of moved value" error? +

    This error means that the value you're trying to use has been moved to a new owner. The first thing to check is whether the move in question was necessary: if it moved into a function, it may be possible to rewrite the function to use a reference, rather than moving. Otherwise if the type being moved implements [`Clone`][Clone], then calling `clone()` on it before moving will move a copy of it, leaving the original still available for further use. Note though that cloning a value should typically be the last resort since cloning can be expensive, causing further allocations. @@ -402,17 +402,17 @@ If the moved value is of your own custom type, consider implementing [`Copy`][Co If none of these are possible, you may want to modify the function that acquired ownership to return ownership of the value when the function exits. - -### What are the rules for using `self`, `&self`, or `&mut self` in a method declaration? - +

    +What are the rules for using self, &self, or &mut self in a method declaration? +

    - Use `self` when a function needs to consume the value - Use `&self` when a function only needs a read-only reference to the value - Use `&mut self` when a function needs to mutate the value without consuming it - -### How can I understand the borrow checker? - +

    +How can I understand the borrow checker? +

    The borrow checker applies only a few rules, which can be found in the Rust book's [section on borrowing](https://doc.rust-lang.org/stable/book/references-and-borrowing.html#the-rules), when evaluating Rust code. These rules are: @@ -431,21 +431,21 @@ The single most important part of understanding the borrow checker is practice. If you find yourself struggling with the borrow checker, or running out of patience, always feel free to reach out to the [Rust community](community.html) for help. - -### When is `Rc` useful? - +

    +When is Rc useful? +

    This is covered in the official documentation for [`Rc`][Rc], Rust's non-atomically reference-counted pointer type. In short, [`Rc`][Rc] and its thread-safe cousin [`Arc`][Arc] are useful to express shared ownership, and have the system automatically deallocate the associated memory when no one has access to it. - -### How do I return a closure from a function? - +

    +How do I return a closure from a function? +

    To return a closure from a function, it must be a "move closure", meaning that the closure is declared with the `move` keyword. As [explained in the Rust book](https://doc.rust-lang.org/book/closures.html#move-closures), this gives the closure its own copy of the captured variables, independent of its parent stack frame. Otherwise, returning a closure would be unsafe, as it would allow access to variables that are no longer valid; put another way: it would allow reading potentially invalid memory. The closure must also be wrapped in a [`Box`][Box], so that it is allocated on the heap. Read more about this [in the book](https://doc.rust-lang.org/book/closures.html#returning-closures). - -### What is a deref coercion and how does it work? - +

    +What is a deref coercion and how does it work? +

    A [deref coercion](https://doc.rust-lang.org/book/deref-coercions.html) is a handy coercion that automatically converts references to pointers (e.g., `&Rc` or `&Box`) into references @@ -469,21 +469,21 @@ The most common sorts of deref coercions are:

    Lifetimes

    - -### Why lifetimes? - +

    +Why lifetimes? +

    Lifetimes are Rust's answer to the question of memory safety. They allow Rust to ensure memory safety without the performance costs of garbage collection. They are based on a variety of academic work, which can be found in the [Rust book](https://doc.rust-lang.org/stable/book/academic-research.html#type-system). - -### Why is the lifetime syntax the way it is? - +

    +Why is the lifetime syntax the way it is? +

    The `'a` syntax comes from the ML family of programming languages, where `'a` is used to indicate a generic type parameter. For Rust, the syntax had to be something that was unambiguous, noticeable, and fit nicely in a type declaration right alongside traits and references. Alternative syntaxes have been discussed, but no alternative syntax has been demonstrated to be clearly better. - -### How do I return a borrow to something I created from a function? - +

    +How do I return a borrow to something I created from a function? +

    You need to ensure that the borrowed item will outlive the function. This can be done by binding the output lifetime to some input lifetime like so: @@ -510,9 +510,9 @@ fn happy_birthday(name: &str, age: i64) -> String { This approach is simpler, but often results in unnecessary allocations. - -### Why do some references have lifetimes, like `&'a T`, and some do not, like `&T`? - +

    +Why do some references have lifetimes, like &'a T, and some do not, like &T? +

    In fact, *all* reference types have a lifetime, but most of the time you do not have to write it explicitly. The rules are as follows: @@ -536,23 +536,23 @@ it explicitly. The rules are as follows: If these rules result in compilation errors, the Rust compiler will provide an error message indicating the error caused, and suggesting a potential solution based on which step of the inference process caused the error. - -### How can Rust guarantee "no null pointers" and "no dangling pointers"? - +

    +How can Rust guarantee "no null pointers" and "no dangling pointers"? +

    The only way to construct a value of type `&Foo` or `&mut Foo` is to specify an existing value of type `Foo` that the reference points to. The reference "borrows" the original value for a given region of code (the lifetime of the reference), and the value being borrowed from cannot be moved or destroyed for the duration of the borrow. - -### How do I express the absence of a value without `null`? - +

    +How do I express the absence of a value without null? +

    You can do that with the [`Option`][Option] type, which can either be `Some(T)` or `None`. `Some(T)` indicates that a value of type `T` is contained within, while `None` indicates the absence of a value.

    Generics

    - -### What is "monomorphisation"? - +

    +What is "monomorphisation"? +

    Monomorphisation specializes each use of a generic function (or structure) with specific instance, based on the parameter types of calls to that function (or uses of the structure). @@ -561,9 +561,9 @@ During monomorphisisation a new copy of the generic function is translated for e Functions that accept [trait objects](http://doc.rust-lang.org/book/trait-objects.html) instead of type parameters do not undergo monomorphisation. Instead, methods on the trait objects are dispatched dynamically at runtime. - -### What's the difference between a function and a closure that doesn't capture any variables? - +

    +What's the difference between a function and a closure that doesn't capture any variables? +

    Functions and closures are operationally equivalent, but have different runtime representations due to their differing implementations. @@ -573,9 +573,9 @@ The big difference between these traits is how they take the `self` parameter. [ Even if a closure does not capture any environment variables, it is represeted at runtime as two pointers, the same as any other closure. - -### What are higher-kinded types, why would I want them, and why doesn't Rust have them? - +

    +What are higher-kinded types, why would I want them, and why doesn't Rust have them? +

    Higher-kinded types are types with unfilled parameters. Type constructors, like [`Vec`][Vec], [`Result`][Result], and [`HashMap`][HashMap] are all examples of higher-kinded types: each requires some additional type parameters in order to actually denote a specific type, like `Vec`. Support for higher-kinded types means these "incomplete" types may be used anywhere "complete" types can be used, including as generics for functions. @@ -589,17 +589,17 @@ Another common example is concepts like functors or monads, both of which are ty Rust doesn't currently have support for higher-kinded types because it hasn't been a priority compared to other improvements we want to make. Since the design is a major, cross-cutting change, we also want to approach it carefully. But there's no inherent reason for the current lack of support. - -### What do named type parameters like `` in generic types mean? - +

    +What do named type parameters like <T=Foo> in generic types mean? +

    These are called [associated types](https://doc.rust-lang.org/stable/book/associated-types.html), and they allow for the expression of trait bounds that can't be expressed with a `where` clause. For example, a generic bound `X: Bar` means "`X` must implement the trait `Bar`, and in that implementation of `Bar`, `X` must choose `Foo` for `Bar`'s associated type, `T`." Examples of where such a constraint cannot be expressed via a `where` clause include trait objects like `Box>`. Associated types exist because generics often involve families of types, where one type determines all of the others in a family. For example, a trait for graphs might have as its `Self` type the graph itself, and have associated types for nodes and for edges. Each graph type uniquely determines the associated types. Using associated types makes it much more concise to work with these families of types, and also provides better type inference in many cases. - -### Can I overload operators? Which ones and how? - +

    +Can I overload operators? Which ones and how? +

    You can provide custom implementations for a variety of operators using their associated traits: [`Add`][Add] for `+`, [`Mul`][Mul] for `*`, and so on. It looks like this: @@ -638,9 +638,9 @@ The following operators can be overloaded: | `[]` | [`Index`][Index] | | `mut []` | [`IndexMut`][IndexMut] | - -### Why the split between `Eq`/`PartialEq` and `Ord`/`PartialOrd`? - +

    +Why the split between Eq/PartialEq and Ord/PartialOrd? +

    There are some types in Rust whose values are only partially ordered, or have only partial equality. Partial ordering means that there may be values of the given type that are neither less than nor greater than each other. Partial equality means that there may be values of the given type that are not equal to themselves. @@ -650,9 +650,9 @@ As explained in [the earlier question on floats](#why-cant-i-compare-floats), th

    Input / Output

    - -### How do I read a file into a `String`? - +

    +How do I read a file into a String? +

    Using the [`read_to_string()`][read__read_to_string] method, which is defined on the [`Read`][Read] trait in [`std::io`][std-io]. @@ -672,17 +672,17 @@ fn main() { } ``` - -### How do I read file input efficiently? - +

    +How do I read file input efficiently? +

    The [`File`][File] type implements the [`Read`][Read] trait, which has a variety of functions for reading and writing data, including [`read()`][read__read], [`read_to_end()`][read__read_to_end], [`bytes()`][read__bytes], [`chars()`][read__chars], and [`take()`][read__take]. Each of these functions reads a certain amount of input from a given file. [`read()`][read__read] reads as much input as the underlying system will provide in a single call. [`read_to_end()`][read__read_to_end] reads the entire buffer into a vector, allocating as much space as is needed. [`bytes()`][read__bytes] and [`chars()`][read__chars] allow you to iterate over the bytes and characters of the file, respectively. Finally, [`take()`][read__take] allows you to read up to an arbitrary number of bytes from the file. Collectively, these should allow you to efficiently read in any data you need. For buffered reads, use the [`BufReader`][BufReader] struct, which helps to reduce the number of system calls when reading. - -### How do I get command line arguments in Rust? - +

    +How do I get command line arguments in Rust? +

    The easiest way is to use [`Args`][Args], which provides an iterator over the input arguments. @@ -690,17 +690,17 @@ If you're looking for something more powerful, there are a [number of options on

    Error Handling

    - -### Why doesn't Rust have exceptions? - +

    +Why doesn't Rust have exceptions? +

    Exceptions complicate understanding of control-flow, they express validity/invalidity outside of the type system, and they interoperate poorly with multithreaded code (a major focus of Rust). Rust prefers a type-based approach to error handling, which is [covered at length in the book](https://doc.rust-lang.org/stable/book/error-handling.html). This fits more nicely with Rust's control flow, concurrency, and everything else. - -### What's the deal with `unwrap()` everywhere? - +

    +What's the deal with unwrap() everywhere? +

    `unwrap()` is a function that extracts the value inside an [`Option`][Option] or [`Result`][Result] and panics if no value is present. @@ -708,15 +708,15 @@ Rust prefers a type-based approach to error handling, which is [covered at lengt It's also useful for quick prototypes where you don't want to handle an error yet, or blog posts where error handling would distract from the main point. - -### Why do I get an error when I try to run example code that uses the `try!` macro? - +

    +Why do I get an error when I try to run example code that uses the try! macro? +

    It's probably an issue with the function's return type. The [`try!`][TryMacro] macro either extracts the value from a [`Result`][Result], or returns early with the error [`Result`][Result] is carrying. This means that [`try`][TryMacro] only works for functions that return [`Result`][Result] themselves, where the `Err`-constructed type implements `From::from(err)`. In particular, this means that the [`try!`][TryMacro] macro cannot work inside the `main` function. - -### Is there an easier way to do error handling than having `Result`s everywhere? - +

    +Is there an easier way to do error handling than having Results everywhere? +

    If you're looking for a way to avoid handling [`Result`s][Result] in other people's code, there's always [`unwrap()`][unwrap], but it's probably not what you want. [`Result`][Result] is an indicator that some computation may or may not complete successfully. Requiring you to handle these failures explicitly is one of the ways that Rust encourages robustness. Rust provides tools like the [`try!` macro][TryMacro] to make handling failures ergonomic. @@ -724,9 +724,9 @@ If you really don't want to handle an error, use [`unwrap()`][unwrap], but know

    Concurrency

    - -### Can I use static values across threads without an `unsafe` block? - +

    +Can I use static values across threads without an unsafe block? +

    Mutation is safe if it's synchronized. Mutating a static [`Mutex`][Mutex] (lazily initialized via the [lazy-static](https://crates.io/crates/lazy_static/) crate) does not require an `unsafe` block, nor does mutating a static [`AtomicUsize`][AtomicUsize] (which can be initialized without lazy_static). @@ -734,57 +734,57 @@ More generally, if a type implements [`Sync`][Sync] and does not implement [`Dro

    Macros

    - -### Can I write a macro to generate identifiers? - +

    +Can I write a macro to generate identifiers? +

    Not currently. Rust macros are ["hygienic macros"](https://en.wikipedia.org/wiki/Hygienic_macro), which intentionally avoid capturing or creating identifiers that may cause unexpected collisions with other identifiers. Their capabilities are significantly different than the style of macros commonly associated with the C preprocessor. Macro invocations can only appear in places where they are explicitly supported: items, method declarations, statements, expressions, and patterns. Here, "method declarations" means a blank space where a method can be put. They can't be used to complete a partial method declaration. By the same logic, they can't be used to complete a partial variable declaration.

    Debugging

    - -### How do I debug Rust programs? - +

    +How do I debug Rust programs? +

    Rust programs can be debugged using [gdb](http://sourceware.org/gdb/current/onlinedocs/gdb/) or [lldb](http://lldb.llvm.org/tutorial.html), the same as C and C++. In fact, every Rust installation comes with one or both of rust-gdb and rust-lldb (depending on platform support). These are wrappers over gdb and lldb with Rust pretty-printing enabled. - -### `rustc` said a panic occurred in standard library code. How do I locate the mistake in my code? - +

    +rustc said a panic occurred in standard library code. How do I locate the mistake in my code? +

    This error is usually caused by [`unwrap()`ing][unwrap] a `None` or `Err` in client code. Enabling backtraces by setting the environment variable `RUST_BACKTRACE=1` helps with getting more information. Compiling in debug mode (the default for `cargo build`) is also helpful. Using a debugger like the provided `rust-gdb` or `rust-lldb` is also helpful.

    Low-Level

    - -### How do I `memcpy` bytes? - +

    +How do I memcpy bytes? +

    If you want to clone an existing slice safely, you can use [`clone_from_slice`][clone_from_slice]. This function is currently unstable, but [should be stabilized soon](https://internals.rust-lang.org/t/stabilizing-basic-functions-on-arrays-and-slices/2868). To copy potentially overlapping bytes, use [`copy`][copy]. To copy nonoverlapping bytes, use [`cpy_nonoverlapping`][copy_nonoverlapping]. Both of these functions are `unsafe`, as both can be used to subvert the language's safety guarantees. Take care when using them. - -### Can Rust function reasonably without the standard library? - +

    +Can Rust function reasonably without the standard library? +

    Absolutely. Rust programs can be set to not load the standard library using the `#![no_std]` attribute. With this attribute set, you can continue to use the Rust core library, which is nothing but the platform-agnostic primitives. As such, it doesn't include IO, concurrency, heap allocation, etc. - -### Can I write an operating system in Rust? - +

    +Can I write an operating system in Rust? +

    Yes! In fact there are [several projects underway doing just that](http://wiki.osdev.org/Rust). - -### How can I read or write numeric types like `i32` or `f64` in big-endian or little-endian format in a file or other byte stream? - +

    +How can I read or write numeric types like i32 or f64 in big-endian or little-endian format in a file or other byte stream? +

    You should check out the [byteorder crate](http://burntsushi.net/rustdoc/byteorder/), which provides utilities for exactly that. - -### Does Rust guarantee a specific data layout? - +

    +Does Rust guarantee a specific data layout? +

    Not by default. In the general case, `enum` and `struct` layouts are undefined. This allows the compiler to potentially do optimizations like re-using padding for the discriminant, compacting variants of nested `enum`s, reordering fields to remove padding, etc. `enums` which carry no data ("C-like") are eligible to have a defined representation. Such `enums` are easily distinguished in that they are simply a list of names that carry no data: @@ -813,27 +813,27 @@ TODO: Write this answer. TODO: Write this answer. --> - -### What's the idiomatic way to express platform-specific behavior in Rust? - +

    +What's the idiomatic way to express platform-specific behavior in Rust? +

    Platform-specific behavior can be expressed using [conditional compilation attributes](https://doc.rust-lang.org/reference.html#conditional-compilation) such as `target_os`, `target_family`, `target_endian`, etc. - -### Can Rust be used for Android/iOS programming? - +

    +Can Rust be used for Android/iOS programming? +

    Yes it can! There are already examples of using Rust for both [Android](https://github.com/tomaka/android-rs-glue) and [iOS](https://www.bignerdranch.com/blog/building-an-ios-app-in-rust-part-1/). It does require a bit of work to set up, but Rust functions fine on both platforms. - -### Can I run my Rust program in a web browser? - +

    +Can I run my Rust program in a web browser? +

    Not yet, but there are efforts underway to make Rust compile to the web with [Emscripten](http://kripken.github.io/emscripten-site/). - -### How do I cross-compile in Rust? - +

    +How do I cross-compile in Rust? +

    Cross compilation is possible in Rust, but it requires [a bit of work](https://github.com/japaric/ruststrap/blob/master/1-how-to-cross-compile.md) to set up. Every Rust compiler is a cross-compiler, but libraries need to be cross-compiled for the target platform. @@ -841,9 +841,9 @@ Rust does distribute [copies of the standard library](http://static.rust-lang.or

    Modules and Crates

    - -### What is the relationship between a module and a crate? - +

    +What is the relationship between a module and a crate? +

    - A crate is a compilation unit, which is the smallest amount of code that the Rust compiler can operate on. - A module is a (possibly nested) unit of code organization inside a crate. @@ -851,9 +851,9 @@ Rust does distribute [copies of the standard library](http://static.rust-lang.or - Recursive definitions can span modules, but not crates. - Using another crate binds the root of its namespace into the user's namespace. - -### Why can't the Rust compiler find this library I'm `use`ing? - +

    +Why can't the Rust compiler find this library I'm useing? +

    There are a number of possible answers, but a common mistake is not realizing that `use` declarations are relative to the crate root. Try rewriting your declarations to use the paths they would use if defined in the root file of your project and see if that fixes the problem. @@ -861,9 +861,9 @@ There are also `self` and `super`, which disambiguate `use` paths as being relat For complete information on `use`ing libraries, read the Rust book's chapter ["Crates and Modules"](https://doc.rust-lang.org/stable/book/crates-and-modules.html). - -### Why do I have to declare module files with `mod` at the top level of the crate, instead of just `use`ing them? - +

    +Why do I have to declare module files with mod at the top level of the crate, instead of just useing them? +

    There are two ways to declare modules in Rust, inline or in another file. Here is an example of each: @@ -898,21 +898,21 @@ In the first example, the module is defined in the same file it's used. In the s Note the difference between `mod` and `use`: `mod` declares that a module exists, whereas `use` references a module declared elsewhere, bringing its contents into scope within the current module. - -### How do I configure Cargo to use a proxy? - +

    +How do I configure Cargo to use a proxy? +

    As explained on the Cargo [configuration documentation](http://doc.crates.io/config.html), you can set Cargo to use a proxy by setting the "proxy" variable under `[http]` in the configuration file. - -### Why can't the compiler find the method implementation even though I'm already `use`ing the crate? - +

    +Why can't the compiler find the method implementation even though I'm already useing the crate? +

    For methods defined on a trait, you have to explicitly import the trait declaration. This means it's not enough to import a module where a struct implements the trait, you must also import the trait itself. - -### Why can't the compiler infer `use` declarations for me? - +

    +Why can't the compiler infer use declarations for me? +

    It probably could, but you also don't want it to. While in many cases it is likely that the compiler could determine the correct module to import by simply looking for where a given identifier is defined, this may not be the case in general. Any decision rule in `rustc` for choosing between competing options would likely cause surprise and confusion in some cases, and Rust prefers to be explicit about where names are coming from. @@ -939,15 +939,15 @@ However, in the future, an IDE could help manage declarations, which gives you t TODO: Write this answer. --> - -### How do I do dynamic Rust library loading? - +

    +How do I do dynamic Rust library loading? +

    Import dynamic libraries in Rust with [libloading](https://crates.io/crates/libloading), which provides a cross-platform system for dynamic linking. - -### Why doesn't crates.io have namespaces? - +

    +Why doesn't crates.io have namespaces? +

    Quoting the [official explanation](https://internals.rust-lang.org/t/crates-io-package-policies/1041) of [http://crates.io](http://crates.io)'s design: @@ -963,79 +963,79 @@ Quoting the [official explanation](https://internals.rust-lang.org/t/crates-io-p

    Libraries

    - -### How can I make an HTTP request? - +

    +How can I make an HTTP request? +

    The standard library does not include an implementation of HTTP, so you will want to use an external crate. [Hyper](https://github.com/hyperium/hyper) is the most popular, but there are [a number of others as well](https://crates.io/keywords/http). - -### How can I write a GUI application in Rust? - +

    +How can I write a GUI application in Rust? +

    There are a variety of ways to write GUI applications in Rust. Just check out [this list of GUI frameworks](https://github.com/kud1ing/awesome-rust#gui). - -### How can I parse JSON/XML? - +

    +How can I parse JSON/XML? +

    [Serde](https://github.com/serde-rs/serde) is the recommended library for serialization and deserialization of Rust data to and from a number of different formats. - -### Is there a standard 2D+ dimensional vector and shape crate? - +

    +Is there a standard 2D+ vector and shape crate? +

    Not yet! Want to write one? - -### How do I write an OpenGL app in Rust? - +

    +How do I write an OpenGL app in Rust? +

    [Glium](https://github.com/tomaka/glium) is the major library for OpenGL programming in Rust. [GLFW](https://github.com/bjz/glfw-rs) is also a solid option. - -### Can I write a video game in Rust? - +

    +Can I write a video game in Rust? +

    Yes you can! The major game programming library for Rust is [Piston](http://www.piston.rs/), and there's both a [subreddit for game programming in Rust](https://www.reddit.com/r/rust_gamedev/) and an IRC channel (`#rust-gamedev` on [Mozilla IRC](https://wiki.mozilla.org/IRC)) as well.

    Design Patterns

    - -### Is Rust object oriented? - +

    +Is Rust object oriented? +

    It is multi-paradigm. Many things you can do in OO languages you can do in Rust, but not everything, and not always using the same abstraction you're accustomed to. - -### How do I map object-oriented concepts to Rust? - +

    +How do I map object-oriented concepts to Rust? +

    That depends. There _are_ ways of translating object-oriented concepts like [multiple inheritance](https://www.reddit.com/r/rust/comments/2sryuw/ideaquestion_about_multiple_inheritence/) to Rust, but as Rust is not object-oriented the result of the translation may look substantially different from its appearance in an OO language. - -### How do I handle configuration of a struct with optional parameters? - +

    +How do I handle configuration of a struct with optional parameters? +

    The easiest way is to use the [`Option`][Option] type in whatever function you're using to construct instances of the struct (usually `new()`). Another way is to use the [builder pattern](https://aturon.github.io/ownership/builders.html), where only certain functions instantiating member variables must be called before the construction of the built type. - -### How do I do global variables in Rust? - +

    +How do I do global variables in Rust? +

    Globals in Rust can be done using `const` declarations for compile-time computed global constants, while `static` can be used for mutable globals. Note that modifying a `static mut` variable requires the use of `unsafe`, as it allows for data races, one of the things guaranteed not to happen in safe Rust. One important distinction between `const` and `static` values is that you can take references to `static` values, but not references to `const` values, which don't have a specified memory location. For more information on `const` vs. `static`, read [the Rust book](https://doc.rust-lang.org/book/const-and-static.html). - -### How can I set compile-time constants that are defined procedurally? - +

    +How can I set compile-time constants that are defined procedurally? +

    Rust currently has limited support for compile time constants. You can define primitives using `const` declarations (similar to `static`, but immutable and without a specified location in memory) as well as define `const` functions and inherent methods. To define procedural constants that can't be defined via these mechanisms, use the [`lazy-static`](https://github.com/rust-lang-nursery/lazy-static.rs) crate, which emulates compile-time evaluation by automatically evaluating the constant at first use. - -### Can I run initialization code that happens before main? - +

    +Can I run initialization code that happens before main? +

    Rust has no concept of "life before `main`". The closest you'll see can be done through the [`lazy-static`](https://github.com/Kimundi/lazy-static.rs) crate, which simulates a "before main" by lazily initializing static variables at their first usage. @@ -1043,9 +1043,9 @@ Rust has no concept of "life before `main`". The closest you'll see can be done This answer needs significant work. Let's revise after the initial posting. --aturon - -### Why doesn't Rust have inheritance? - +

    +Why doesn't Rust have inheritance? +

    There are two meanings for the word "inheritance": _subtyping_, and _interface sharing_. Both purposes are already handled by traits. @@ -1057,9 +1057,9 @@ Rust has consistently worked to avoid having features with overlapping purposes, --> - -### Does Rust allow non-constant-expression values for globals? - +

    +Does Rust allow non-constant-expression values for globals? +

    No. Globals cannot have a non-constant-expression constructor and cannot have a destructor at all. Static constructors are undesirable because portably ensuring a static initialization order is difficult. Life before main is often considered a misfeature, so Rust does not allow it. @@ -1069,57 +1069,57 @@ You can approximate non-constant-expression globals with the [lazy-static](https

    Other Languages

    - -### How can I implement something like C's `struct X { static int X; };` in Rust? - +

    +How can I implement something like C's struct X { static int X; }; in Rust? +

    Rust does not have `static` fields as shown in the code snippet above. Instead, you can declare a `static` variable in a given module, which is kept private to that module. - -### How can I convert a C-style enum to an integer, or vice-versa? - +

    +How can I convert a C-style enum to an integer, or vice-versa? +

    Converting a C-style enum to an integer can be done with an `as` expression, like `e as i64` (where `e` is some enum). Converting in the other direction can be done with a `match` statement, which maps different numeric values to different potential values for the enum. - -### Why does Rust not have a stable ABI like C does, and why do I have to annotate things with extern? - +

    +Why does Rust not have a stable ABI like C does, and why do I have to annotate things with extern? +

    Committing to an ABI is a big decision that can limit potentially advantageous language changes in the future. Given that Rust only hit 1.0 in May of 2015, it is still too early to make a commitment as big as a stable ABI. This does not mean that one won't happen in the future, though. (Though C++ has managed to go for many years without specifying a stable ABI.) The `extern` keyword allows Rust to use specific ABI's, such as the well-defined C ABI, for interop with other languages. - -### Can Rust code call C code? - +

    +Can Rust code call C code? +

    Yes. Calling C code from Rust is designed to be as efficient as calling C code from C++. - -### Can C code call Rust code? - +

    +Can C code call Rust code? +

    Yes. The Rust code has to be exposed via an `extern` declaration, which makes it C-ABI compatible. Such a function can be passed to C code as a function pointer or, if given the `#[no_mangle]` attribute to disable symbol mangling, can be called directly from C code. - -### I already write perfect C++. What does Rust give me? - +

    +I already write perfect C++. What does Rust give me? +

    Modern C++ includes many features that make writing safe and correct code less error-prone, but it's not perfect, and it's still easy to introduce unsafety. This is something the C++ core developers are working to overcome, but C++ is limited by a long history that predates a lot of the ideas they are now trying to implement. Rust was designed from day one to be a safe systems programming language, which means it's not limited by historic design decisions that make getting safety right in C++ so complicated. In C++, safety is achieved by careful personal discipline, and is very easy to get wrong. In Rust, safety is the default. It gives you the ability to work in a team that includes people less perfect than you are, without having to spend your time double-checking their code for safety bugs. - -### How do I do the equivalent of C++ template specialization in Rust? - +

    +How do I do the equivalent of C++ template specialization in Rust? +

    Rust doesn't currently have an exact equivalent to template specialization, but it is [being worked on](https://github.com/rust-lang/rfcs/pull/1210) and will hopefully be added soon. However, similar effects can be achieved via [associated types](https://doc.rust-lang.org/stable/book/associated-types.html). - -### How does Rust's ownership system relate to move semantics in C++? - +

    +How does Rust's ownership system relate to move semantics in C++? +

    The underlying concepts are similar, but the two systems work very differently in practice. In both systems, "moving" a value is a way to @@ -1174,15 +1174,15 @@ destructor for `s` will run when `caller` returns, even though it has been moved (in Rust, in contrast, moved values are dropped only by their new owners). - -### How can I interoperate with C++ from Rust, or with Rust from C++? - +

    +How can I interoperate with C++ from Rust, or with Rust from C++? +

    Rust and C++ can interoperate through C. Both Rust and C++ provide a [foreign function interface](https://doc.rust-lang.org/book/ffi.html) for C, and can use that to communicate between each other. If writing C bindings is too tedious, you can always use [rust-bindgen](https://github.com/crabtw/rust-bindgen) to help automatically generate workable C bindings. - -### Does Rust have C++-style constructors? - +

    +Does Rust have C++-style constructors? +

    No. Functions serve the same purpose as constructors without adding language complexity. The usual name for the constructor-equivalent function in Rust is `new()`, although this is just a convention rather than a language rule. The `new()` function in fact is just like any other function. An example of it looks like so: @@ -1204,21 +1204,21 @@ impl Foo { } ``` - -### Does Rust have copy constructors? - +

    +Does Rust have copy constructors? +

    Not exactly. Types which implement `Copy` will do a standard C-like "shallow copy" with no extra work (similar to "plain old data" in C++). It is impossible to implement `Copy` types that require custom copy behavior. Instead, in Rust "copy constructors" are created by implementing the `Clone` trait, and explicitly calling the `clone` method. Making user-defined copy operators explicit surfaces the underlying complexity, making it easier for the developer to identify potentially expensive operations. - -### Does Rust have move constructors? - +

    +Does Rust have move constructors? +

    No. Values of all types are moved via `memcpy`. This makes writing generic unsafe code much simpler since assignment, passing and returning are known to never have a side effect like unwinding. - -### How are Go and Rust similar, and how are they different? - +

    +How are Go and Rust similar, and how are they different? +

    Rust and Go have substantially different design goals. The following differences are not the only ones (which are too numerous to list), but are a few of the more important ones: @@ -1227,15 +1227,15 @@ Rust and Go have substantially different design goals. The following differences - Rust has strong support for generics, which Go does not. - Rust has strong influences from the world of functional programming, including a type system which draws from Haskell's typeclasses. Go has a simpler type system, using interfaces for basic generic programming. - -### `gofmt` is great. Where's `rustfmt`? - +

    +gofmt is great. Where's rustfmt? +

    `rustfmt` is [right here](https://github.com/rust-lang-nursery/rustfmt), and is being actively developed to make reading Rust code as easy and predictable as possible. - -### How do Rust traits compare to Haskell typeclasses? - +

    +How do Rust traits compare to Haskell typeclasses? +

    Rust traits are similar to Haskell typeclasses, but are currently not as powerful, as Rust cannot express higher-kinded types. Rust's associated types are equivalent to Haskell type families. @@ -1249,31 +1249,31 @@ Some specific difference between Haskell typeclasses and Rust traits include:

    Documentation

    - -### Why are so many Rust answers on StackOverflow wrong? - +

    +Why are so many Rust answers on StackOverflow wrong? +

    The Rust language has been around for a number of years, and only reached version 1.0 in May of 2015. In the time before then the language changed significantly, and a number of StackOverflow answers were given at the time of older versions of the language. Over time more and more answers will be offered for the current version, thus improving this issue as the proportion of out-of-date answers is reduced. - -### Where do I report issues in the Rust documentation? - +

    +Where do I report issues in the Rust documentation? +

    You can report issues in the Rust documentation on the Rust compiler [issue tracker](https://github.com/rust-lang/rust/issues). Make sure to read the [contributing guidelines](https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#writing-documentation) first. - -### How do I view rustdoc documentation for a library my project depends on? - +

    +How do I view rustdoc documentation for a library my project depends on? +

    When you use `cargo doc` to generate documentation for your own project, it also generates docs for the active dependency versions. These are put into the `target/doc` directory of your project. Use `cargo doc --open` to open the docs after building them, or just open up `target/doc/index.html` yourself.

    The Rust Project

    - -### What is this project's goal? - +

    +What is this project's goal? +

    To design and implement a safe, concurrent, practical systems language. @@ -1286,17 +1286,17 @@ Rust exists because other languages at this level of abstraction and efficiency Rust exists as an alternative that provides both efficient code and a comfortable level of abstraction, while improving on all four of these points. - -### Is this project controlled by Mozilla? - +

    +Is this project controlled by Mozilla? +

    No. Rust started as Graydon Hoare's part-time side project in 2006 and remained so for over 3 years. Mozilla got involved in 2009 once the language was mature enough to run basic tests and demonstrate its core concepts. Though it remains sponsored by Mozilla, Rust is developed by a diverse community of enthusiasts from many different places around the world. The [Rust Team](https://www.rust-lang.org/team.html) is composed of both Mozilla and non-Mozilla members, and `rustc` (Rust's compiler) has had over [1,000 unique contributors](https://github.com/rust-lang/rust/) so far. As far as [project governance](https://github.com/rust-lang/rfcs/blob/master/text/1068-rust-governance.md) goes, Rust is managed by a core team that sets the vision and priorities for the project, and accepts input on the design of the language via RFC proposals. There are also subteams to guide and foster development of particular areas of interest, including Rust libraries, Rust tools, and moderation of the official Rust communities. For changes which do not require an RFC, decisions are made through pull requests on the [`rustc` repository](https://github.com/rust-lang/rust). - -### What are some non-goals of Rust? - +

    +What are some non-goals of Rust? +

    1. We do not employ any particularly cutting-edge technologies. Old, established techniques are better. 2. We do not prize expressiveness, minimalism or elegance above other goals. These are desirable but subordinate goals. @@ -1304,15 +1304,15 @@ As far as [project governance](https://github.com/rust-lang/rfcs/blob/master/tex 4. We do not intend to be 100% static, 100% safe, 100% reflective, or too dogmatic in any other sense. Trade-offs exist. 5. We do not demand that Rust run on "every possible platform". It must eventually work without unnecessary compromises on widely-used hardware and software platforms. - -### In which projects is Mozilla using Rust? - +

    +In which projects is Mozilla using Rust? +

    The main project is [Servo](https://github.com/servo/servo), an experimental browser engine Mozilla is working on. They are also working to [integrate Rust components](https://bugzilla.mozilla.org/show_bug.cgi?id=1135640) into Firefox. - -### What examples are there of large Rust projects? - +

    +What examples are there of large Rust projects? +

    The two biggest open source Rust projects right now are [Servo](https://github.com/servo/servo) and the [Rust compiler](https://github.com/rust-lang/rust) itself. @@ -1322,15 +1322,15 @@ The two biggest open source Rust projects right now are [Servo](https://github.c TODO: Write this answer. --> - -### How can I try Rust easily? - +

    +How can I try Rust easily? +

    The easiest way to try Rust is through the [playpen](https://play.rust-lang.org/), an online app for writing and running Rust code. If you want to try Rust on your system, [install it](https://www.rust-lang.org/install.html) and go through the ["Learn Rust"](https://doc.rust-lang.org/stable/book/learn-rust.html) section of the book. - -### How do I get help with Rust issues? - +

    +How do I get help with Rust issues? +

    There are several ways. You can: @@ -1339,15 +1339,15 @@ There are several ways. You can: - Ask on [StackOverflow](http://stackoverflow.com/questions/tagged/rust) with the "rust" tag - Post in [/r/rust](https://www.reddit.com/r/rust), the official Rust subreddit - -### Why has Rust changed so much over time? - +

    +Why has Rust changed so much over time? +

    Rust started with a goal of creating a safe but usable systems programming language. In pursuit of this goal it explored a lot of ideas, some of which it kept (lifetimes, traits) while others were discarded (the typestate system, green threading). Also, in the run up to 1.0 a lot of the standard library was rewritten as early designs were updated to best use Rust's features and provide quality, consistent cross-platform APIs. - -### How does Rust language versioning work? - +

    +How does Rust language versioning work? +

    Rust's language versioning follows [SemVer](http://semver.org/), with backwards incompatible changes of stable APIs only allowed in minor versions if those changes fix compiler bugs, patch safety holes, or change type inference to require additional annotation. @@ -1355,29 +1355,29 @@ Rust maintains three "release channels": stable, beta, and nightly. Stable and b For details, read the Rust blog post ["Stability as a Deliverable."](http://blog.rust-lang.org/2014/10/30/Stability.html) - -### Can I use unstable features on the beta or stable channel? - +

    +Can I use unstable features on the beta or stable channel? +

    No, you cannot. Rust works hard to provide strong guarantees about the stability of the features provided on the beta and stable channels. When something is unstable, it means that we can't provide those guarantees for it yet, and don't want people relying on it staying the same. This gives us the opportunity to try changes in the wild on the nightly channel, while still maintaining strong guarantees for people seeking stability. Things stabilize all the time, and the beta and stable channels update every six weeks. If you're waiting for a feature to be available without using the nightly channel, you can locate its tracking issue by checking the [`B-unstable`](https://github.com/rust-lang/rust/issues?q=is%3Aissue+is%3Aopen+tracking+label%3AB-unstable) tag on the issue tracker. - -### What IDE should I use? - +

    +What IDE should I use? +

    There are a number of options for development environment with Rust, all of which are detailed on the official [IDE support page](https://www.rust-lang.org/ides.html). - -### Why a dual MIT/ASL2 License? - +

    +Why a dual MIT/ASL2 License? +

    The Apache license includes important protection against patent aggression, but it is not compatible with the GPL, version 2. To avoid problems using Rust with GPL2, it is alternately MIT licensed. - -### Why a BSD-style permissive license rather than MPL or tri-license? - +

    +Why a BSD-style permissive license rather than MPL or tri-license? +

    This is partly due to preference of the original developer (Graydon), and partly due to the fact that languages tend to have a wider audience and more diverse set of possible embeddings and end-uses than products such as web browsers. We'd like to appeal to as many of those potential contributors as possible. From 13bddcfad1460b253b8e8f0ead97622b1949ad94 Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Thu, 14 Jan 2016 01:05:43 +0000 Subject: [PATCH 91/94] Move the rust project faqs to the top of the faq --- faq.md | 227 +++++++++++++++++++++++++++++---------------------------- 1 file changed, 114 insertions(+), 113 deletions(-) diff --git a/faq.md b/faq.md index 794458426..f7eef7a85 100644 --- a/faq.md +++ b/faq.md @@ -16,6 +16,7 @@ If there is some common or important question you feel is wrongly left unanswere

    Table of Contents

      +
    1. The Rust Project
    2. Performance
    3. Syntax
    4. Numerics
      5. @@ -36,11 +37,123 @@ If there is some common or important question you feel is wrongly left unanswere
    5. Design Patterns
    6. Other Languages
    7. Documentation
      8. -
    8. The Rust Project
    + +

    The Rust Project

    + +

    +What is this project's goal? +

    + +To design and implement a safe, concurrent, practical systems language. + +Rust exists because other languages at this level of abstraction and efficiency are unsatisfactory. In particular: + +1. There is too little attention paid to safety. +2. They have poor concurrency support. +3. There is a lack of practical affordances. +4. They offer limited control over resources. + +Rust exists as an alternative that provides both efficient code and a comfortable level of abstraction, while improving on all four of these points. + +

    +Is this project controlled by Mozilla? +

    + +No. Rust started as Graydon Hoare's part-time side project in 2006 and remained so for over 3 years. Mozilla got involved in 2009 once the language was mature enough to run basic tests and demonstrate its core concepts. Though it remains sponsored by Mozilla, Rust is developed by a diverse community of enthusiasts from many different places around the world. The [Rust Team](https://www.rust-lang.org/team.html) is composed of both Mozilla and non-Mozilla members, and `rustc` (Rust's compiler) has had over [1,000 unique contributors](https://github.com/rust-lang/rust/) so far. + +As far as [project governance](https://github.com/rust-lang/rfcs/blob/master/text/1068-rust-governance.md) goes, Rust is managed by a core team that sets the vision and priorities for the project, and accepts input on the design of the language via RFC proposals. There are also subteams to guide and foster development of particular areas of interest, including Rust libraries, Rust tools, and moderation of the official Rust communities. For changes which do not require an RFC, decisions are made through pull requests on the [`rustc` repository](https://github.com/rust-lang/rust). + +

    +What are some non-goals of Rust? +

    + +1. We do not employ any particularly cutting-edge technologies. Old, established techniques are better. +2. We do not prize expressiveness, minimalism or elegance above other goals. These are desirable but subordinate goals. +3. We do not intend to cover the complete feature-set of C++, or any other language. Rust should provide majority-case features. +4. We do not intend to be 100% static, 100% safe, 100% reflective, or too dogmatic in any other sense. Trade-offs exist. +5. We do not demand that Rust run on "every possible platform". It must eventually work without unnecessary compromises on widely-used hardware and software platforms. + +

    +In which projects is Mozilla using Rust? +

    + +The main project is [Servo](https://github.com/servo/servo), an experimental browser engine Mozilla is working on. They are also working to [integrate Rust components](https://bugzilla.mozilla.org/show_bug.cgi?id=1135640) into Firefox. + +

    +What examples are there of large Rust projects? +

    + +The two biggest open source Rust projects right now are [Servo](https://github.com/servo/servo) and the [Rust compiler](https://github.com/rust-lang/rust) itself. + + + +

    +How can I try Rust easily? +

    + +The easiest way to try Rust is through the [playpen](https://play.rust-lang.org/), an online app for writing and running Rust code. If you want to try Rust on your system, [install it](https://www.rust-lang.org/install.html) and go through the ["Learn Rust"](https://doc.rust-lang.org/stable/book/learn-rust.html) section of the book. + +

    +How do I get help with Rust issues? +

    + +There are several ways. You can: + +- Post in [users.rust-lang.org](https://users.rust-lang.org/), the official Rust forum +- Ask in the official [Rust IRC channel](https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust) (#rust on irc.mozilla.org) +- Ask on [StackOverflow](http://stackoverflow.com/questions/tagged/rust) with the "rust" tag +- Post in [/r/rust](https://www.reddit.com/r/rust), the official Rust subreddit + +

    +Why has Rust changed so much over time? +

    + +Rust started with a goal of creating a safe but usable systems programming language. In pursuit of this goal it explored a lot of ideas, some of which it kept (lifetimes, traits) while others were discarded (the typestate system, green threading). Also, in the run up to 1.0 a lot of the standard library was rewritten as early designs were updated to best use Rust's features and provide quality, consistent cross-platform APIs. + +

    +How does Rust language versioning work? +

    + +Rust's language versioning follows [SemVer](http://semver.org/), with backwards incompatible changes of stable APIs only allowed in minor versions if those changes fix compiler bugs, patch safety holes, or change type inference to require additional annotation. + +Rust maintains three "release channels": stable, beta, and nightly. Stable and beta are updated every six weeks, with the current nightly becoming the new beta, and the current beta becoming the new stable. Language and standard library features marked unstable or hidden behind feature gates may only be used on the nightly channel. + +For details, read the Rust blog post ["Stability as a Deliverable."](http://blog.rust-lang.org/2014/10/30/Stability.html) + +

    +Can I use unstable features on the beta or stable channel? +

    + +No, you cannot. Rust works hard to provide strong guarantees about the stability of the features provided on the beta and stable channels. When something is unstable, it means that we can't provide those guarantees for it yet, and don't want people relying on it staying the same. This gives us the opportunity to try changes in the wild on the nightly channel, while still maintaining strong guarantees for people seeking stability. + +Things stabilize all the time, and the beta and stable channels update every six weeks. If you're waiting for a feature to be available without using the nightly channel, you can locate its tracking issue by checking the [`B-unstable`](https://github.com/rust-lang/rust/issues?q=is%3Aissue+is%3Aopen+tracking+label%3AB-unstable) tag on the issue tracker. + +

    +What IDE should I use? +

    + +There are a number of options for development environment with Rust, all of which are detailed on the official [IDE support page](https://www.rust-lang.org/ides.html). + +

    +Why a dual MIT/ASL2 License? +

    + +The Apache license includes important protection against patent aggression, but it is not compatible with the GPL, version 2. To avoid problems using Rust with GPL2, it is alternately MIT licensed. + +

    +Why a BSD-style permissive license rather than MPL or tri-license? +

    + +This is partly due to preference of the original developer (Graydon), and partly due to the fact that languages tend to have a wider audience and more diverse set of possible embeddings and end-uses than products such as web browsers. We'd like to appeal to as many of those potential contributors as possible. +

    Performance

    @@ -1269,118 +1382,6 @@ How do I view rustdoc documentation for a library my project depends on? When you use `cargo doc` to generate documentation for your own project, it also generates docs for the active dependency versions. These are put into the `target/doc` directory of your project. Use `cargo doc --open` to open the docs after building them, or just open up `target/doc/index.html` yourself. -

    The Rust Project

    - -

    -What is this project's goal? -

    - -To design and implement a safe, concurrent, practical systems language. - -Rust exists because other languages at this level of abstraction and efficiency are unsatisfactory. In particular: - -1. There is too little attention paid to safety. -2. They have poor concurrency support. -3. There is a lack of practical affordances. -4. They offer limited control over resources. - -Rust exists as an alternative that provides both efficient code and a comfortable level of abstraction, while improving on all four of these points. - -

    -Is this project controlled by Mozilla? -

    - -No. Rust started as Graydon Hoare's part-time side project in 2006 and remained so for over 3 years. Mozilla got involved in 2009 once the language was mature enough to run basic tests and demonstrate its core concepts. Though it remains sponsored by Mozilla, Rust is developed by a diverse community of enthusiasts from many different places around the world. The [Rust Team](https://www.rust-lang.org/team.html) is composed of both Mozilla and non-Mozilla members, and `rustc` (Rust's compiler) has had over [1,000 unique contributors](https://github.com/rust-lang/rust/) so far. - -As far as [project governance](https://github.com/rust-lang/rfcs/blob/master/text/1068-rust-governance.md) goes, Rust is managed by a core team that sets the vision and priorities for the project, and accepts input on the design of the language via RFC proposals. There are also subteams to guide and foster development of particular areas of interest, including Rust libraries, Rust tools, and moderation of the official Rust communities. For changes which do not require an RFC, decisions are made through pull requests on the [`rustc` repository](https://github.com/rust-lang/rust). - -

    -What are some non-goals of Rust? -

    - -1. We do not employ any particularly cutting-edge technologies. Old, established techniques are better. -2. We do not prize expressiveness, minimalism or elegance above other goals. These are desirable but subordinate goals. -3. We do not intend to cover the complete feature-set of C++, or any other language. Rust should provide majority-case features. -4. We do not intend to be 100% static, 100% safe, 100% reflective, or too dogmatic in any other sense. Trade-offs exist. -5. We do not demand that Rust run on "every possible platform". It must eventually work without unnecessary compromises on widely-used hardware and software platforms. - -

    -In which projects is Mozilla using Rust? -

    - -The main project is [Servo](https://github.com/servo/servo), an experimental browser engine Mozilla is working on. They are also working to [integrate Rust components](https://bugzilla.mozilla.org/show_bug.cgi?id=1135640) into Firefox. - -

    -What examples are there of large Rust projects? -

    - -The two biggest open source Rust projects right now are [Servo](https://github.com/servo/servo) and the [Rust compiler](https://github.com/rust-lang/rust) itself. - - - -

    -How can I try Rust easily? -

    - -The easiest way to try Rust is through the [playpen](https://play.rust-lang.org/), an online app for writing and running Rust code. If you want to try Rust on your system, [install it](https://www.rust-lang.org/install.html) and go through the ["Learn Rust"](https://doc.rust-lang.org/stable/book/learn-rust.html) section of the book. - -

    -How do I get help with Rust issues? -

    - -There are several ways. You can: - -- Post in [users.rust-lang.org](https://users.rust-lang.org/), the official Rust forum -- Ask in the official [Rust IRC channel](https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust) (#rust on irc.mozilla.org) -- Ask on [StackOverflow](http://stackoverflow.com/questions/tagged/rust) with the "rust" tag -- Post in [/r/rust](https://www.reddit.com/r/rust), the official Rust subreddit - -

    -Why has Rust changed so much over time? -

    - -Rust started with a goal of creating a safe but usable systems programming language. In pursuit of this goal it explored a lot of ideas, some of which it kept (lifetimes, traits) while others were discarded (the typestate system, green threading). Also, in the run up to 1.0 a lot of the standard library was rewritten as early designs were updated to best use Rust's features and provide quality, consistent cross-platform APIs. - -

    -How does Rust language versioning work? -

    - -Rust's language versioning follows [SemVer](http://semver.org/), with backwards incompatible changes of stable APIs only allowed in minor versions if those changes fix compiler bugs, patch safety holes, or change type inference to require additional annotation. - -Rust maintains three "release channels": stable, beta, and nightly. Stable and beta are updated every six weeks, with the current nightly becoming the new beta, and the current beta becoming the new stable. Language and standard library features marked unstable or hidden behind feature gates may only be used on the nightly channel. - -For details, read the Rust blog post ["Stability as a Deliverable."](http://blog.rust-lang.org/2014/10/30/Stability.html) - -

    -Can I use unstable features on the beta or stable channel? -

    - -No, you cannot. Rust works hard to provide strong guarantees about the stability of the features provided on the beta and stable channels. When something is unstable, it means that we can't provide those guarantees for it yet, and don't want people relying on it staying the same. This gives us the opportunity to try changes in the wild on the nightly channel, while still maintaining strong guarantees for people seeking stability. - -Things stabilize all the time, and the beta and stable channels update every six weeks. If you're waiting for a feature to be available without using the nightly channel, you can locate its tracking issue by checking the [`B-unstable`](https://github.com/rust-lang/rust/issues?q=is%3Aissue+is%3Aopen+tracking+label%3AB-unstable) tag on the issue tracker. - -

    -What IDE should I use? -

    - -There are a number of options for development environment with Rust, all of which are detailed on the official [IDE support page](https://www.rust-lang.org/ides.html). - -

    -Why a dual MIT/ASL2 License? -

    - -The Apache license includes important protection against patent aggression, but it is not compatible with the GPL, version 2. To avoid problems using Rust with GPL2, it is alternately MIT licensed. - -

    -Why a BSD-style permissive license rather than MPL or tri-license? -

    - -This is partly due to preference of the original developer (Graydon), and partly due to the fact that languages tend to have a wider audience and more diverse set of possible embeddings and end-uses than products such as web browsers. We'd like to appeal to as many of those potential contributors as possible. - [Vec]: https://doc.rust-lang.org/stable/std/vec/struct.Vec.html [HashMap]: https://doc.rust-lang.org/stable/std/collections/struct.HashMap.html [Into]: https://doc.rust-lang.org/stable/std/convert/trait.Into.html From 86ac45172bb57ff5d05da6693c28a30e0e8837fe Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Thu, 14 Jan 2016 01:11:36 +0000 Subject: [PATCH 92/94] Rename Debugging faq section to 'Debugging and Tooling'. Fill it out. I particularly wanted to get the IDE question out of 'The Rust Project'. --- faq.md | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/faq.md b/faq.md index f7eef7a85..04338fb3d 100644 --- a/faq.md +++ b/faq.md @@ -29,7 +29,7 @@ If there is some common or important question you feel is wrongly left unanswere
  • Error Handling
  • Concurrency
  • Macros
    • -
  • Debugging
    • +
  • Debugging and Tooling
  • Low-Level
  • Cross-Platform
  • Modules and Crates
    • @@ -136,12 +136,6 @@ No, you cannot. Rust works hard to provide strong guarantees about the stability Things stabilize all the time, and the beta and stable channels update every six weeks. If you're waiting for a feature to be available without using the nightly channel, you can locate its tracking issue by checking the [`B-unstable`](https://github.com/rust-lang/rust/issues?q=is%3Aissue+is%3Aopen+tracking+label%3AB-unstable) tag on the issue tracker. -

    -What IDE should I use? -

    - -There are a number of options for development environment with Rust, all of which are detailed on the official [IDE support page](https://www.rust-lang.org/ides.html). -

    Why a dual MIT/ASL2 License?

    @@ -853,7 +847,7 @@ Can I write a macro to generate identifiers? Not currently. Rust macros are ["hygienic macros"](https://en.wikipedia.org/wiki/Hygienic_macro), which intentionally avoid capturing or creating identifiers that may cause unexpected collisions with other identifiers. Their capabilities are significantly different than the style of macros commonly associated with the C preprocessor. Macro invocations can only appear in places where they are explicitly supported: items, method declarations, statements, expressions, and patterns. Here, "method declarations" means a blank space where a method can be put. They can't be used to complete a partial method declaration. By the same logic, they can't be used to complete a partial variable declaration. -

    Debugging

    +

    Debugging and Tooling

    How do I debug Rust programs? @@ -867,6 +861,18 @@ Rust programs can be debugged using [gdb](http://sourceware.org/gdb/current/onli This error is usually caused by [`unwrap()`ing][unwrap] a `None` or `Err` in client code. Enabling backtraces by setting the environment variable `RUST_BACKTRACE=1` helps with getting more information. Compiling in debug mode (the default for `cargo build`) is also helpful. Using a debugger like the provided `rust-gdb` or `rust-lldb` is also helpful. +

    +What IDE should I use? +

    + +There are a number of options for development environment with Rust, all of which are detailed on the official [IDE support page](https://www.rust-lang.org/ides.html). + +

    +gofmt is great. Where's rustfmt? +

    + +`rustfmt` is [right here](https://github.com/rust-lang-nursery/rustfmt), and is being actively developed to make reading Rust code as easy and predictable as possible. +

    Low-Level

    @@ -1340,12 +1346,6 @@ Rust and Go have substantially different design goals. The following differences - Rust has strong support for generics, which Go does not. - Rust has strong influences from the world of functional programming, including a type system which draws from Haskell's typeclasses. Go has a simpler type system, using interfaces for basic generic programming. -

    -gofmt is great. Where's rustfmt? -

    - -`rustfmt` is [right here](https://github.com/rust-lang-nursery/rustfmt), and is being actively developed to make reading Rust code as easy and predictable as possible. -

    How do Rust traits compare to Haskell typeclasses?

    From 07d53633b2387ca28afb335909a80981718ce19f Mon Sep 17 00:00:00 2001 From: Aaron Turon Date: Thu, 14 Jan 2016 10:44:52 -0800 Subject: [PATCH 93/94] Changes to Project section of FAQ --- faq.md | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/faq.md b/faq.md index 04338fb3d..a11096c4a 100644 --- a/faq.md +++ b/faq.md @@ -65,7 +65,8 @@ Is this project controlled by Mozilla? No. Rust started as Graydon Hoare's part-time side project in 2006 and remained so for over 3 years. Mozilla got involved in 2009 once the language was mature enough to run basic tests and demonstrate its core concepts. Though it remains sponsored by Mozilla, Rust is developed by a diverse community of enthusiasts from many different places around the world. The [Rust Team](https://www.rust-lang.org/team.html) is composed of both Mozilla and non-Mozilla members, and `rustc` (Rust's compiler) has had over [1,000 unique contributors](https://github.com/rust-lang/rust/) so far. -As far as [project governance](https://github.com/rust-lang/rfcs/blob/master/text/1068-rust-governance.md) goes, Rust is managed by a core team that sets the vision and priorities for the project, and accepts input on the design of the language via RFC proposals. There are also subteams to guide and foster development of particular areas of interest, including Rust libraries, Rust tools, and moderation of the official Rust communities. For changes which do not require an RFC, decisions are made through pull requests on the [`rustc` repository](https://github.com/rust-lang/rust). +As far as [project governance](https://github.com/rust-lang/rfcs/blob/master/text/1068-rust-governance.md) goes, Rust is managed by a core team that sets the vision and priorities for the project, +guiding it from a global perspective. There are also subteams to guide and foster development of particular areas of interest, including the core language, the compiler, Rust libraries, Rust tools, and moderation of the official Rust communities. Designs in each these areas are advanced through an [RFC process](https://github.com/rust-lang/rfcs). For changes which do not require an RFC, decisions are made through pull requests on the [`rustc` repository](https://github.com/rust-lang/rust).

    What are some non-goals of Rust? @@ -107,7 +108,7 @@ How do I get help with Rust issues? There are several ways. You can: -- Post in [users.rust-lang.org](https://users.rust-lang.org/), the official Rust forum +- Post in [users.rust-lang.org](https://users.rust-lang.org/), the official Rust users forum - Ask in the official [Rust IRC channel](https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust) (#rust on irc.mozilla.org) - Ask on [StackOverflow](http://stackoverflow.com/questions/tagged/rust) with the "rust" tag - Post in [/r/rust](https://www.reddit.com/r/rust), the official Rust subreddit @@ -122,11 +123,11 @@ Rust started with a goal of creating a safe but usable systems programming langu How does Rust language versioning work?

    -Rust's language versioning follows [SemVer](http://semver.org/), with backwards incompatible changes of stable APIs only allowed in minor versions if those changes fix compiler bugs, patch safety holes, or change type inference to require additional annotation. +Rust's language versioning follows [SemVer](http://semver.org/), with backwards incompatible changes of stable APIs only allowed in minor versions if those changes fix compiler bugs, patch safety holes, or change dispatch or type inference to require additional annotation. More detailed guidelines for minor version changes are available as approved RFCs for both the [language](https://github.com/rust-lang/rfcs/blob/master/text/1122-language-semver.md) and [standard library](https://github.com/rust-lang/rfcs/blob/master/text/1105-api-evolution.md). -Rust maintains three "release channels": stable, beta, and nightly. Stable and beta are updated every six weeks, with the current nightly becoming the new beta, and the current beta becoming the new stable. Language and standard library features marked unstable or hidden behind feature gates may only be used on the nightly channel. +Rust maintains three "release channels": stable, beta, and nightly. Stable and beta are updated every six weeks, with the current nightly becoming the new beta, and the current beta becoming the new stable. Language and standard library features marked unstable or hidden behind feature gates may only be used on the nightly channel. New features land as unstable, and are "ungated" once approved by the core team and relevant subteams. This approach allows for experimentation while providing strong backwards-compatibility guarantees for the stable channel. -For details, read the Rust blog post ["Stability as a Deliverable."](http://blog.rust-lang.org/2014/10/30/Stability.html) +For additional details, read the Rust blog post ["Stability as a Deliverable."](http://blog.rust-lang.org/2014/10/30/Stability.html)

    Can I use unstable features on the beta or stable channel? From 4d7e991dffa1260e0be43f922c8e5ad13b8cf32b Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Thu, 14 Jan 2016 19:10:42 +0000 Subject: [PATCH 94/94] Change faq contributing link to contribute.html --- faq.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/faq.md b/faq.md index 04338fb3d..a32dd5337 100644 --- a/faq.md +++ b/faq.md @@ -10,7 +10,7 @@ This page exists to answer common questions about the Rust programming language.

    -If there is some common or important question you feel is wrongly left unanswered here, feel free to help us fix it. +If there is some common or important question you feel is wrongly left unanswered here, feel free to help us fix it.