diff --git a/src/doc/trpl/README.md b/src/doc/trpl/README.md index 6e8d394afa5b1..b2e1a6ec0bc19 100644 --- a/src/doc/trpl/README.md +++ b/src/doc/trpl/README.md @@ -1,39 +1,192 @@ % The Rust Programming Language -Welcome! This book will teach you about [the Rust Programming -Language](http://www.rust-lang.org/). Rust is a modern systems programming -language focusing on safety and speed. It accomplishes these goals by being -memory safe without using garbage collection. +Welcome! This book will teach you about the [Rust Programming Language][rust]. +Rust is a systems programming language focused on three goals: safety, speed, +and concurrency. It maintains these goals without having a garbage collector, +making it a useful language for a number of use cases other languages aren’t +good at: embedding in other languages, programs with specific space and time +requirements, and writing low-level code, like device drivers and operating +systems. It improves on current languages targeting this space by having a +number of compile-time safety checks that produce no runtime overhead, while +eliminating all data races. Rust also aims to achieve ‘zero-cost abstrations’ +even though some of these abstractions feel like those of a high-level +language. Even then, Rust still allows precise control like a low-level +language would. -"The Rust Programming Language" is split into three sections, which you can -navigate through the menu on the left. +[rust]: http://rust-lang.org -

Basics

+“The Rust Programming Language” is split into seven sections. This introduction +is the first. After this: -This section is a linear introduction to the basic syntax and semantics of -Rust. It has individual sections on each part of Rust's syntax. +* [Getting started][gs] - Set up your computer for Rust development. +* [Learn Rust][lr] - Learn Rust programming through small projects. +* [Effective Rust][er] - Higher-level concepts for writing excellent Rust code. +* [Syntax and Semantics][ss] - Each bit of Rust, broken down into small chunks. +* [Nightly Rust][nr] - Cutting-edge features that aren’t in stable builds yet. +* [Glossary][gl] - A reference of terms used in the book. -After reading "Basics," you will have a good foundation to learn more about -Rust, and can write very simple programs. +[gs]: getting-started.html +[lr]: learn-rust.html +[er]: effective-rust.html +[ss]: syntax-and-semantics.html +[nr]: nightly-rust.html +[gl]: glossary.html -

Intermediate

+After reading this introduction, you’ll want to dive into either ‘Learn Rust’ +or ‘Syntax and Semantics’, depending on your preference: ‘Learn Rust’ if you +want to dive in with a project, or ‘Syntax and Semantics’ if you prefer to +start small, and learn a single concept thoroughly before moving onto the next. +Copious cross-linking connects these parts together. -This section contains individual chapters, which are self-contained. They focus -on specific topics, and can be read in any order. +## A brief introduction to Rust -After reading "Intermediate," you will have a solid understanding of Rust, -and will be able to understand most Rust code and write more complex programs. +Is Rust a language you might be interested in? Let’s examine a few small code +samples to show off a few of its strengths. -

Advanced

+The main concept that makes Rust unique is called ‘ownership’. Consider this +small example: -In a similar fashion to "Intermediate," this section is full of individual, -deep-dive chapters, which stand alone and can be read in any order. These -chapters focus on Rust's most complex features. +```rust +fn main() { + let mut x = vec!["Hello", "world"]; +} +``` -

Unstable

+This program makes a [variable binding][var] named `x`. The value of this +binding is a `Vec`, a ‘vector’, that we create through a [macro][macro] +defined in the standard library. This macro is called `vec`, and we invoke +macros with a `!`. This follows a general principle of Rust: make things +explicit. Macros can do significantly more complicated things than function +calls, and so they’re visually distinct. The `!` also helps with parsing, +making tooling easier to write, which is also important. -In a similar fashion to "Intermediate," this section is full of individual, -deep-dive chapters, which stand alone and can be read in any order. +We used `mut` to make `x` mutable: bindings are immutable by default in Rust. +We’ll be mutating this vector later in the example. -This chapter contains things that are only available on the nightly channel of -Rust. +It’s also worth noting that we didn’t need a type annotation here: while Rust +is statically typed, we didn’t need to explicitly annotate the type. Rust has +type inference to balance out the power of static typing with the verbosity of +annotating types. + +Rust prefers stack allocation to heap allocation: `x` is placed directly on the +stack. However, the `Vec` type allocates space for the elements of the +vector on the heap. If you’re not familiar with this distinction, you can +ignore it for now, or check out [‘The Stack and the Heap’][heap]. As a systems +programming language, Rust gives you the ability to control how your memory is +allocated, but when we’re getting started, it’s less of a big deal. + +[var]: variable-bindings.html +[macro]: macros.html +[heap]: the-stack-and-the-heap.html + +Earlier, we mentioned that ‘ownership’ is the key new concept in Rust. In Rust +parlance, `x` is said to ‘own’ the vector. This means that when `x` goes out of +scope, the vector’s memory will be de-allocated. This is done deterministically +by the Rust compiler, rather than through a mechanism such as a garbage +collector. In other words, in Rust, you don’t call functions like `malloc` and +`free` yourself: the compiler statically determines when you need to allocate +or deallocate memory, and inserts those calls itself. To err is to be human, +but compilers never forget. + +Let’s add another line to our example: + +```rust +fn main() { + let mut x = vec!["Hello", "world"]; + + let y = &x[0]; +} +``` + +We’ve introduced another binding, `y`. In this case, `y` is a ‘reference’ to +the first element of the vector. Rust’s references are similar to pointers in +other languages, but with additional compile-time safety checks. References +interact with the ownership system by [‘borrowing’][borrowing] what they point +to, rather than owning it. The difference is, when the reference goes out of +scope, it will not deallocate the underlying memory. If it did, we’d +de-allocate twice, which is bad! + +[borrowing]: references-and-borrowing.html + +Let’s add a third line. It looks innocent enough, but causes a compiler error: + +```rust,ignore +fn main() { + let mut x = vec!["Hello", "world"]; + + let y = &x[0]; + + x.push(4); +} +``` + +`push` is a method on vectors that appends another element to the end of the +vector. When we try to compile this program, we get an error: + +```text +error: cannot borrow `x` as mutable because it is also borrowed as immutable + x.push(4); + ^ +note: previous borrow of `x` occurs here; the immutable borrow prevents +subsequent moves or mutable borrows of `x` until the borrow ends + let y = &x[0]; + ^ +note: previous borrow ends here +fn main() { + +} +^ +``` + +Whew! The Rust compiler gives quite detailed errors at times, and this is one +of those times. As the error explains, while we made our binding mutable, we +still cannot call `push`. This is because we already have a reference to an +element of the vector, `y`. Mutating something while another reference exists +is dangerous, because we may invalidate the reference. In this specific case, +when we create the vector, we may have only allocated space for three elements. +Adding a fourth would mean allocating a new chunk of memory for all those elements, +copying the old values over, and updating the internal pointer to that memory. +That all works just fine. The problem is that `y` wouldn’t get updated, and so +we’d have a ‘dangling pointer’. That’s bad. Any use of `y` would be an error in +this case, and so the compiler has caught this for us. + +So how do we solve this problem? There are two approaches we can take. The first +is making a copy rather than using a reference: + +```rust +fn main() { + let mut x = vec!["Hello", "world"]; + + let y = x[0].clone(); + + x.push(4); +} +``` + +Rust has [move semantics][move] by default, so if we want to make a copy of some +data, we call the `clone()` method. In this example, `y` is no longer a reference +to the vector stored in `x`, but a copy of its first element, `"hello"`. Now +that we don’t have a reference, our `push()` works just fine. + +[move]: move-semantics.html + +If we truly want a reference, we need the other option: ensure that our reference +goes out of scope before we try to do the mutation. That looks like this: + +```rust +fn main() { + let mut x = vec!["Hello", "world"]; + + { + let y = &x[0]; + } + + x.push(4); +} +``` + +We created an inner scope with an additional set of curly braces. `y` will go out of +scope before we call `push()`, and so we’re all good. + +This concept of ownership isn’t just good for preventing danging pointers, but an +entire set of related problems, like iterator invalidation, concurrency, and more. diff --git a/src/doc/trpl/SUMMARY.md b/src/doc/trpl/SUMMARY.md index d894e1c47253b..029facdec762b 100644 --- a/src/doc/trpl/SUMMARY.md +++ b/src/doc/trpl/SUMMARY.md @@ -17,8 +17,8 @@ * [`Deref` coercions](deref-coercions.md) * [Syntax and Semantics](syntax-and-semantics.md) * [Variable Bindings](variable-bindings.md) - * [Primitive Types](primitive-types.md) * [Functions](functions.md) + * [Primitive Types](primitive-types.md) * [Comments](comments.md) * [Structs](structs.md) * [Mutability](mutability.md) @@ -35,8 +35,6 @@ * [Move semantics](move-semantics.md) * [Drop](drop.md) * [Vectors](vectors.md) - * [Arrays](arrays.md) - * [Slices](slices.md) * [Strings](strings.md) * [Traits](traits.md) * [Operators and Overloading](operators-and-overloading.md) @@ -47,7 +45,6 @@ * [Crates and Modules](crates-and-modules.md) * [`static`](static.md) * [`const`](const.md) - * [Tuples](tuples.md) * [Tuple Structs](tuple-structs.md) * [Attributes](attributes.md) * [Conditional Compilation](conditional-compilation.md) @@ -67,3 +64,4 @@ * [Benchmark Tests](benchmark-tests.md) * [Box Syntax and Patterns](box-syntax-and-patterns.md) * [Glossary](glossary.md) +* [Academic Research](academic-research.md) diff --git a/src/doc/trpl/academic-research.md b/src/doc/trpl/academic-research.md new file mode 100644 index 0000000000000..f4f066fb3dfe3 --- /dev/null +++ b/src/doc/trpl/academic-research.md @@ -0,0 +1,46 @@ +% Academic Research + +An incomplete list of papers that have had some influence in Rust. + +Recommended for inspiration and a better understanding of Rust's background. + +### Type system + +* [Region based memory management in Cyclone](http://209.68.42.137/ucsd-pages/Courses/cse227.w03/handouts/cyclone-regions.pdf) +* [Safe manual memory management in Cyclone](http://www.cs.umd.edu/projects/PL/cyclone/scp.pdf) +* [Typeclasses: making ad-hoc polymorphism less ad hoc](http://www.ps.uni-sb.de/courses/typen-ws99/class.ps.gz) +* [Macros that work together](https://www.cs.utah.edu/plt/publications/jfp12-draft-fcdf.pdf) +* [Traits: composable units of behavior](http://scg.unibe.ch/archive/papers/Scha03aTraits.pdf) +* [Alias burying](http://www.cs.uwm.edu/faculty/boyland/papers/unique-preprint.ps) - We tried something similar and abandoned it. +* [External uniqueness is unique enough](http://www.computingscience.nl/research/techreps/repo/CS-2002/2002-048.pdf) +* [Uniqueness and Reference Immutability for Safe Parallelism](https://research.microsoft.com/pubs/170528/msr-tr-2012-79.pdf) +* [Region Based Memory Management](http://www.cs.ucla.edu/~palsberg/tba/papers/tofte-talpin-iandc97.pdf) + +### Concurrency + +* [Singularity: rethinking the software stack](https://research.microsoft.com/pubs/69431/osr2007_rethinkingsoftwarestack.pdf) +* [Language support for fast and reliable message passing in singularity OS](https://research.microsoft.com/pubs/67482/singsharp.pdf) +* [Scheduling multithreaded computations by work stealing](http://supertech.csail.mit.edu/papers/steal.pdf) +* [Thread scheduling for multiprogramming multiprocessors](http://www.eecis.udel.edu/%7Ecavazos/cisc879-spring2008/papers/arora98thread.pdf) +* [The data locality of work stealing](http://www.aladdin.cs.cmu.edu/papers/pdfs/y2000/locality_spaa00.pdf) +* [Dynamic circular work stealing deque](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.170.1097&rep=rep1&type=pdf) - The Chase/Lev deque +* [Work-first and help-first scheduling policies for async-finish task parallelism](http://www.cs.rice.edu/%7Eyguo/pubs/PID824943.pdf) - More general than fully-strict work stealing +* [A Java fork/join calamity](http://www.coopsoft.com/ar/CalamityArticle.html) - critique of Java's fork/join library, particularly its application of work stealing to non-strict computation +* [Scheduling techniques for concurrent systems](http://www.ece.rutgers.edu/%7Eparashar/Classes/ece572-papers/05/ps-ousterhout.pdf) +* [Contention aware scheduling](http://www.blagodurov.net/files/a8-blagodurov.pdf) +* [Balanced work stealing for time-sharing multicores](http://www.cse.ohio-state.edu/hpcs/WWW/HTML/publications/papers/TR-12-1.pdf) +* [Three layer cake](http://www.upcrc.illinois.edu/workshops/paraplop10/papers/paraplop10_submission_8.pdf) +* [Non-blocking steal-half work queues](http://www.cs.bgu.ac.il/%7Ehendlerd/papers/p280-hendler.pdf) +* [Reagents: expressing and composing fine-grained concurrency](http://www.mpi-sws.org/~turon/reagents.pdf) +* [Algorithms for scalable synchronization of shared-memory multiprocessors](https://www.cs.rochester.edu/u/scott/papers/1991_TOCS_synch.pdf) + +### Others + +* [Crash-only software](https://www.usenix.org/legacy/events/hotos03/tech/full_papers/candea/candea.pdf) +* [Composing High-Performance Memory Allocators](http://people.cs.umass.edu/~emery/pubs/berger-pldi2001.pdf) +* [Reconsidering Custom Memory Allocation](http://people.cs.umass.edu/~emery/pubs/berger-oopsla2002.pdf) + +### Papers *about* Rust + +* [GPU programming in Rust](http://www.cs.indiana.edu/~eholk/papers/hips2013.pdf) +* [Parallel closures: a new twist on an old idea](https://www.usenix.org/conference/hotpar12/parallel-closures-new-twist-old-idea) - not exactly about rust, but by nmatsakis diff --git a/src/doc/trpl/arrays.md b/src/doc/trpl/arrays.md deleted file mode 100644 index a6ecac962d60d..0000000000000 --- a/src/doc/trpl/arrays.md +++ /dev/null @@ -1,48 +0,0 @@ -% Arrays - -Like many programming languages, Rust has list types to represent a sequence of -things. The most basic is the *array*, a fixed-size list of elements of the -same type. By default, arrays are immutable. - -```{rust} -let a = [1, 2, 3]; // a: [i32; 3] -let mut m = [1, 2, 3]; // mut m: [i32; 3] -``` - -There's a shorthand for initializing each element of an array to the same -value. In this example, each element of `a` will be initialized to `0`: - -```{rust} -let a = [0; 20]; // a: [i32; 20] -``` - -Arrays have type `[T; N]`. We'll talk about this `T` notation later, when we -cover generics. - -You can get the number of elements in an array `a` with `a.len()`, and use -`a.iter()` to iterate over them with a for loop. This code will print each -number in order: - -```{rust} -let a = [1, 2, 3]; - -println!("a has {} elements", a.len()); -for e in a.iter() { - println!("{}", e); -} -``` - -You can access a particular element of an array with *subscript notation*: - -```{rust} -let names = ["Graydon", "Brian", "Niko"]; // names: [&str; 3] - -println!("The second name is: {}", names[1]); -``` - -Subscripts start at zero, like in most programming languages, so the first name -is `names[0]` and the second name is `names[1]`. The above example prints -`The second name is: Brian`. If you try to use a subscript that is not in the -array, you will get an error: array access is bounds-checked at run-time. Such -errant access is the source of many bugs in other systems programming -languages. diff --git a/src/doc/trpl/effective-rust.md b/src/doc/trpl/effective-rust.md index 6ea0759e99d7b..582ed3b7e65c5 100644 --- a/src/doc/trpl/effective-rust.md +++ b/src/doc/trpl/effective-rust.md @@ -1 +1,8 @@ % Effective Rust + +So you’ve learned how to write some Rust code. But there’s a difference between +writing *any* Rust code and writing *good* Rust code. + +This section consists of relatively independent tutorials which show you how to +take your Rust to the next level. Common patterns and standard library features +will be introduced. Read these sections in any order of your choosing. diff --git a/src/doc/trpl/getting-started.md b/src/doc/trpl/getting-started.md index a164def516b93..555d40e659706 100644 --- a/src/doc/trpl/getting-started.md +++ b/src/doc/trpl/getting-started.md @@ -1 +1,5 @@ % Getting Started + +This first section of the book will get you going with Rust and its tooling. +First, we’ll install Rust. Then: the classic ‘Hello World’ program. Finally, +we’ll talk about Cargo, Rust’s build system and package manager. diff --git a/src/doc/trpl/hello-cargo.md b/src/doc/trpl/hello-cargo.md index ae2a79bafecd5..8d8b17343343e 100644 --- a/src/doc/trpl/hello-cargo.md +++ b/src/doc/trpl/hello-cargo.md @@ -1,26 +1,27 @@ % Hello, Cargo! -[Cargo](http://crates.io) is a tool that Rustaceans use to help manage their -Rust projects. Cargo is currently in a pre-1.0 state, just like Rust, and so it -is still a work in progress. However, it is already good enough to use for many -Rust projects, and so it is assumed that Rust projects will use Cargo from the -beginning. +[Cargo][cratesio] is a tool that Rustaceans use to help manage their Rust +projects. Cargo is currently in a pre-1.0 state, and so it is still a work in +progress. However, it is already good enough to use for many Rust projects, and +so it is assumed that Rust projects will use Cargo from the beginning. + +[cratesio]: https://doc.crates.io Cargo manages three things: building your code, downloading the dependencies your code needs, and building those dependencies. At first, your -program doesn't have any dependencies, so we'll only be using the first part of -its functionality. Eventually, we'll add more. Since we started off by using +program doesn’t have any dependencies, so we’ll only be using the first part of +its functionality. Eventually, we’ll add more. Since we started off by using Cargo, it'll be easy to add later. -If you installed Rust via the official installers you will also have -Cargo. If you installed Rust some other way, you may want to [check -the Cargo -README](https://github.com/rust-lang/cargo#installing-cargo-from-nightlies) -for specific instructions about installing it. +If you installed Rust via the official installers you will also have Cargo. If +you installed Rust some other way, you may want to [check the Cargo +README][cargoreadme] for specific instructions about installing it. + +[cargoreadme]: https://github.com/rust-lang/cargo#installing-cargo-from-nightlies ## Converting to Cargo -Let's convert Hello World to Cargo. +Let’s convert Hello World to Cargo. To Cargo-ify our project, we need to do two things: Make a `Cargo.toml` configuration file, and put our source file in the right place. Let's @@ -52,14 +53,9 @@ Put this inside: name = "hello_world" version = "0.0.1" authors = [ "Your name " ] - -[[bin]] - -name = "hello_world" ``` -This file is in the [TOML](https://github.com/toml-lang/toml) format. Let's let -it explain itself to you: +This file is in the [TOML][toml] format. Let’s let it explain itself to you: > TOML aims to be a minimal configuration file format that's easy to read due > to obvious semantics. TOML is designed to map unambiguously to a hash table. @@ -68,10 +64,7 @@ it explain itself to you: TOML is very similar to INI, but with some extra goodies. -Anyway, there are two *tables* in this file: `package` and `bin`. The first -tells Cargo metadata about your package. The second tells Cargo that we're -interested in building a binary, not a library (though we could do both!), as -well as what it is named. +[toml]: https://github.com/toml-lang/toml Once you have this file in place, we should be ready to build! Try this: @@ -83,13 +76,32 @@ Hello, world! ``` Bam! We build our project with `cargo build`, and run it with -`./target/debug/hello_world`. This hasn't bought us a whole lot over our simple use -of `rustc`, but think about the future: when our project has more than one -file, we would need to call `rustc` more than once and pass it a bunch of options to -tell it to build everything together. With Cargo, as our project grows, we can -just `cargo build`, and it'll work the right way. When your project is finally -ready for release, you can use `cargo build --release` to compile your crates with -optimizations. +`./target/debug/hello_world`. We can do both in one step with `cargo run`: + +```bash +$ cargo run + Running `target/debug/hello_world` +Hello, world! +``` + +Notice that we didn’t re-build the project this time. Cargo figured out that +we hadn’t changed the source file, and so it just ran the binary. If we had +made a modification, we would have seen it do both: + +```bash +$ cargo build + Compiling hello_world v0.0.1 (file:///home/yourname/projects/hello_world) + Running `target/debug/hello_world` +Hello, world! +``` + +This hasn’t bought us a whole lot over our simple use of `rustc`, but think +about the future: when our project gets more complex, we would need to do more +things to get all of the parts to properly compile. With Cargo, as our project +grows, we can just `cargo build`, and it’ll work the right way. + +When your project is finally ready for release, you can use +`cargo build --release` to compile your project with optimizations. You'll also notice that Cargo has created a new file: `Cargo.lock`. @@ -100,18 +112,25 @@ version = "0.0.1" ``` This file is used by Cargo to keep track of dependencies in your application. -Right now, we don't have any, so it's a bit sparse. You won't ever need +Right now, we don’t have any, so it’s a bit sparse. You won't ever need to touch this file yourself, just let Cargo handle it. -That's it! We've successfully built `hello_world` with Cargo. Even though our -program is simple, it's using much of the real tooling that you'll use for the -rest of your Rust career. +That’s it! We’ve successfully built `hello_world` with Cargo. Even though our +program is simple, it’s using much of the real tooling that you’ll use for the +rest of your Rust career. You can expect to do this to get started with +virtually all Rust projects: + +```bash +$ git clone someurl.com/foo +$ cd foo +$ cargo build +``` ## A New Project -You don't have to go through this whole process every time you want to start a new -project! Cargo has the ability to make a bare-bones project directory in which you -can start developing right away. +You don’t have to go through this whole process every time you want to start a +new project! Cargo has the ability to make a bare-bones project directory in +which you can start developing right away. To start a new project with Cargo, use `cargo new`: @@ -119,8 +138,8 @@ To start a new project with Cargo, use `cargo new`: $ cargo new hello_world --bin ``` -We're passing `--bin` because we're making a binary program: if we -were making a library, we'd leave it off. +We’re passing `--bin` because we're making a binary program: if we were making +a library, we'd leave it off. Let's check out what Cargo has generated for us: @@ -135,10 +154,10 @@ $ tree . 1 directory, 2 files ``` -If you don't have the `tree` command, you can probably get it from your distro's package -manager. It's not necessary, but it's certainly useful. +If you don't have the `tree` command, you can probably get it from your +distribution’s package manager. It’s not necessary, but it’s certainly useful. -This is all we need to get started. First, let's check out `Cargo.toml`: +This is all we need to get started. First, let’s check out `Cargo.toml`: ```toml [package] @@ -148,11 +167,11 @@ version = "0.0.1" authors = ["Your Name "] ``` -Cargo has populated this file with reasonable defaults based off the arguments you gave -it and your `git` global configuration. You may notice that Cargo has also initialized -the `hello_world` directory as a `git` repository. +Cargo has populated this file with reasonable defaults based off the arguments +you gave it and your `git` global configuration. You may notice that Cargo has +also initialized the `hello_world` directory as a `git` repository. -Here's what's in `src/main.rs`: +Here’s what’s in `src/main.rs`: ```rust fn main() { @@ -160,9 +179,20 @@ fn main() { } ``` -Cargo has generated a "Hello World!" for us, and you're ready to start coding! A -much more in-depth guide to Cargo can be found [here](http://doc.crates.io/guide.html). +Cargo has generated a "Hello World!" for us, and you’re ready to start coding! Cargo +has its own [guide][guide] which covers Cargo’s features in much more depth. -Now that you've got the tools down, let's actually learn more about the Rust +[guide]: http://doc.crates.io/guide.html + +Now that you’ve got the tools down, let’s actually learn more about the Rust language itself. These are the basics that will serve you well through the rest of your time with Rust. + +You have two options: Dive into a project with ‘[Learn Rust][learnrust]’, or +start from the bottom and work your way up with ‘[Syntax and +Semantics][syntax]’. More experienced systems programmers will probably prefer +‘Learn Rust’, while those from dynamic backgrounds may enjoy either. Different +people learn differently! Choose whatever’s right for you. + +[learnrust]: learn-rust.html +[syntax]: syntax-and-semantics.html diff --git a/src/doc/trpl/hello-world.md b/src/doc/trpl/hello-world.md index f726f8627c929..7026003069120 100644 --- a/src/doc/trpl/hello-world.md +++ b/src/doc/trpl/hello-world.md @@ -1,9 +1,9 @@ % Hello, world! -Now that you have Rust installed, let's write your first Rust program. It's +Now that you have Rust installed, let’s write your first Rust program. It’s traditional to make your first program in any new language one that prints the -text "Hello, world!" to the screen. The nice thing about starting with such a -simple program is that you can verify that your compiler isn't just installed, +text “Hello, world!” to the screen. The nice thing about starting with such a +simple program is that you can verify that your compiler isn’t just installed, but also working properly. And printing information to the screen is a pretty common thing to do. @@ -12,38 +12,37 @@ to make a `projects` directory in my home directory, and keep all my projects there. Rust does not care where your code lives. This actually leads to one other concern we should address: this guide will -assume that you have basic familiarity with the command line. Rust does not -require that you know a whole ton about the command line, but until the -language is in a more finished state, IDE support is spotty. Rust makes no -specific demands on your editing tooling, or where your code lives. +assume that you have basic familiarity with the command line. Rust itself makes +no specific demands on your editing tooling, or where your code lives. If you +prefer an IDE to the command line, you may want to check out +[SolidOak][solidoak], or wherever plugins are for your favorite IDE. There are +a number of extensions of varying quality in development by the community. The +Rust team also ships [plugins for various editors][plugins]. Configuring your +editor or IDE is out of the scope of this tutorial, so check the documentation +for your setup, specifically. -With that said, let's make a directory in our projects directory. +[solidoak]: https://github.com/oakes/SolidOak +[plugins]: https://github.com/rust-lang/rust/blob/master/src/etc/CONFIGS.md -```{bash} +With that said, let’s make a directory in our projects directory. + +```bash $ mkdir ~/projects $ cd ~/projects $ mkdir hello_world $ cd hello_world ``` -If you're on Windows and not using PowerShell, the `~` may not work. Consult +If you’re on Windows and not using PowerShell, the `~` may not work. Consult the documentation for your shell for more details. -Let's make a new source file next. I'm going to use the syntax `editor -filename` to represent editing a file in these examples, but you should use -whatever method you want. We'll call our file `main.rs`: - -```{bash} -$ editor main.rs -``` +Let’s make a new source file next. We’ll call our file `main.rs`. Rust files +always end in a `.rs` extension. If you’re using more than one word in your +filename, use an underscore: `hello_world.rs` rather than `helloworld.rs`. -Rust files always end in a `.rs` extension. If you're using more than one word -in your filename, use an underscore. `hello_world.rs` rather than -`helloworld.rs`. +Now that you’ve got your file open, type this in: -Now that you've got your file open, type this in: - -```{rust} +```rust fn main() { println!("Hello, world!"); } @@ -51,87 +50,88 @@ fn main() { Save the file, and then type this into your terminal window: -```{bash} +```bash $ rustc main.rs $ ./main # or main.exe on Windows Hello, world! ``` -You can also run these examples on [play.rust-lang.org](http://play.rust-lang.org/) by clicking on the arrow that appears in the upper right of the example when you mouse over the code. - -Success! Let's go over what just happened in detail. +Success! Let’s go over what just happened in detail. -```{rust} +```rust fn main() { } ``` These lines define a *function* in Rust. The `main` function is special: -it's the beginning of every Rust program. The first line says "I'm declaring a -function named `main`, which takes no arguments and returns nothing." If there +it's the beginning of every Rust program. The first line says "I’m declaring a +function named `main` which takes no arguments and returns nothing." If there were arguments, they would go inside the parentheses (`(` and `)`), and because -we aren't returning anything from this function, we can omit the return type -entirely. We'll get to it later. +we aren’t returning anything from this function, we can omit the return type +entirely. We’ll get to it later. -You'll also note that the function is wrapped in curly braces (`{` and `}`). +You’ll also note that the function is wrapped in curly braces (`{` and `}`). Rust requires these around all function bodies. It is also considered good style to put the opening curly brace on the same line as the function declaration, with one space in between. Next up is this line: -```{rust} +```rust println!("Hello, world!"); ``` This line does all of the work in our little program. There are a number of -details that are important here. The first is that it's indented with four +details that are important here. The first is that it’s indented with four spaces, not tabs. Please configure your editor of choice to insert four spaces -with the tab key. We provide some [sample configurations for various -editors](https://github.com/rust-lang/rust/tree/master/src/etc/CONFIGS.md). +with the tab key. If you’re using any of the officially distributed plugins, +they will handle this for you. -The second point is the `println!()` part. This is calling a Rust *macro*, +The second point is the `println!()` part. This is calling a Rust [macro][macro], which is how metaprogramming is done in Rust. If it were a function instead, it -would look like this: `println()`. For our purposes, we don't need to worry -about this difference. Just know that sometimes, you'll see a `!`, and that -means that you're calling a macro instead of a normal function. Rust implements -`println!` as a macro rather than a function for good reasons, but that's a -very advanced topic. You'll learn more when we talk about macros later. One -last thing to mention: Rust's macros are significantly different from C macros, -if you've used those. Don't be scared of using macros. We'll get to the details -eventually, you'll just have to trust us for now. - -Next, `"Hello, world!"` is a *string*. Strings are a surprisingly complicated -topic in a systems programming language, and this is a *statically allocated* -string. We will talk more about different kinds of allocation later. We pass -this string as an argument to `println!`, which prints the string to the -screen. Easy enough! - -Finally, the line ends with a semicolon (`;`). Rust is an *expression -oriented* language, which means that most things are expressions. The `;` is -used to indicate that this expression is over, and the next one is ready to -begin. Most lines of Rust code end with a `;`. We will cover this in-depth -later in the guide. - -Finally, actually *compiling* and *running* our program. We can compile -with our compiler, `rustc`, by passing it the name of our source file: - -```{bash} +would look like this: `println()`. For our purposes, we don’t need to worry +about this difference. Just know that sometimes, you’ll see a `!`, and that +means that you’re calling a macro instead of a normal function. Rust implements +`println!` as a macro rather than a function for good reasons, but that's an +advanced topic. One last thing to mention: Rust’s macros are significantly +different from C macros, if you’ve used those. Don’t be scared of using macros. +We’ll get to the details eventually, you’ll just have to trust us for now. + +[macro]: macros.html + +Next, `"Hello, world!"` is a ‘string’. Strings are a surprisingly complicated +topic in a systems programming language, and this is a ‘statically allocated’ +string. If you want to read further about allocation, check out [the stack and +the heap], but you don’t need to right now if you don’t want to. We pass this +string as an argument to `println!`, which prints the string to the screen. +Easy enough! + +[allocation]: the-stack-and-the-heap.html + +Finally, the line ends with a semicolon (`;`). Rust is an ‘expression oriented’ +language, which means that most things are expressions, rather than statements. +The `;` is used to indicate that this expression is over, and the next one is +ready to begin. Most lines of Rust code end with a `;`. + +Finally, actually compiling and running our program. We can compile with our +compiler, `rustc`, by passing it the name of our source file: + +```bash $ rustc main.rs ``` This is similar to `gcc` or `clang`, if you come from a C or C++ background. Rust will output a binary executable. You can see it with `ls`: -```{bash} +```bash $ ls main main.rs ``` Or on Windows: -```{bash} +```bash $ dir main.exe main.rs ``` @@ -139,7 +139,7 @@ main.exe main.rs There are now two files: our source code, with the `.rs` extension, and the executable (`main.exe` on Windows, `main` everywhere else) -```{bash} +```bash $ ./main # or main.exe on Windows ``` @@ -147,15 +147,15 @@ This prints out our `Hello, world!` text to our terminal. If you come from a dynamically typed language like Ruby, Python, or JavaScript, you may not be used to these two steps being separate. Rust is an -*ahead-of-time compiled language*, which means that you can compile a -program, give it to someone else, and they don't need to have Rust installed. -If you give someone a `.rb` or `.py` or `.js` file, they need to have a +‘ahead-of-time compiled language’, which means that you can compile a program, +give it to someone else, and they don't need to have Rust installed. If you +give someone a `.rb` or `.py` or `.js` file, they need to have a Ruby/Python/JavaScript implementation installed, but you just need one command -to both compile and run your program. Everything is a tradeoff in language design, -and Rust has made its choice. +to both compile and run your program. Everything is a tradeoff in language +design, and Rust has made its choice. Congratulations! You have officially written a Rust program. That makes you a -Rust programmer! Welcome. +Rust programmer! Welcome. 🎊🎉👍 Next, I'd like to introduce you to another tool, Cargo, which is used to write real-world Rust programs. Just using `rustc` is nice for simple things, but as diff --git a/src/doc/trpl/installing-rust.md b/src/doc/trpl/installing-rust.md index c839688047aa6..e4054a097989d 100644 --- a/src/doc/trpl/installing-rust.md +++ b/src/doc/trpl/installing-rust.md @@ -1,27 +1,32 @@ % Installing Rust The first step to using Rust is to install it! There are a number of ways to -install Rust, but the easiest is to use the `rustup` script. If you're on -Linux or a Mac, all you need to do is this (note that you don't need to type -in the `$`s, they just indicate the start of each command): +install Rust, but the easiest is to use the `rustup` script. If you're on Linux +or a Mac, all you need to do is this (note that you don't need to type in the +`$`s, they just indicate the start of each command): ```bash $ curl -sf -L https://static.rust-lang.org/rustup.sh | sudo sh ``` -If you're concerned about the [potential insecurity](http://curlpipesh.tumblr.com/) of using `curl | sudo sh`, -please keep reading and see our disclaimer below. And feel free to use a two-step version of the installation and examine our installation script: +If you're concerned about the [potential insecurity][insecurity] of using `curl +| sudo sh`, please keep reading and see our disclaimer below. And feel free to +use a two-step version of the installation and examine our installation script: ```bash $ curl -f -L https://static.rust-lang.org/rustup.sh -O $ sudo sh rustup.sh ``` -If you're on Windows, please download either the [32-bit -installer](https://static.rust-lang.org/dist/rust-1.0.0-beta-i686-pc-windows-gnu.exe) -or the [64-bit -installer](https://static.rust-lang.org/dist/rust-1.0.0-beta-x86_64-pc-windows-gnu.exe) -and run it. +[insecurity]: http://curlpipesh.tumblr.com + +If you're on Windows, please download either the [32-bit installer][win32] or +the [64-bit installer][win64] and run it. + +[win32]: https://static.rust-lang.org/dist/rust-1.0.0-beta-i686-pc-windows-gnu.msi +[win64]: https://static.rust-lang.org/dist/rust-1.0.0-beta-x86_64-pc-windows-gnu.msi + +## Uninstalling If you decide you don't want Rust anymore, we'll be a bit sad, but that's okay. Not every programming language is great for everyone. Just run the uninstall @@ -31,22 +36,20 @@ script: $ sudo /usr/local/lib/rustlib/uninstall.sh ``` -If you used the Windows installer, just re-run the `.exe` and it will give you +If you used the Windows installer, just re-run the `.msi` and it will give you an uninstall option. -You can re-run this script any time you want to update Rust. Which, at this -point, is often. Rust is still pre-1.0, and so people assume that you're using -a very recent Rust. +Some people, and somewhat rightfully so, get very upset when we tell you to +`curl | sudo sh`. Basically, when you do this, you are trusting that the good +people who maintain Rust aren't going to hack your computer and do bad things. +That's a good instinct! If you're one of those people, please check out the +documentation on [building Rust from Source][from source], or [the official +binary downloads][install page]. And we promise that this method will not be +the way to install Rust forever: it's just the easiest way to keep people +updated while Rust is in its alpha state. -This brings me to one other point: some people, and somewhat rightfully so, get -very upset when we tell you to `curl | sudo sh`. And they should be! Basically, -when you do this, you are trusting that the good people who maintain Rust -aren't going to hack your computer and do bad things. That's a good instinct! -If you're one of those people, please check out the documentation on [building -Rust from Source](https://github.com/rust-lang/rust#building-from-source), or -[the official binary downloads](http://www.rust-lang.org/install.html). And we -promise that this method will not be the way to install Rust forever: it's just -the easiest way to keep people updated while Rust is in its alpha state. +[from source]: https://github.com/rust-lang/rust#building-from-source +[install page]: http://www.rust-lang.org/install.html Oh, we should also mention the officially supported platforms: @@ -73,7 +76,7 @@ $ rustc --version You should see the version number, commit hash, commit date and build date: ```bash -rustc 1.0.0-nightly (f11f3e7ba 2015-01-04) (built 2015-01-06) +rustc 1.0.0-beta (9854143cb 2015-04-02) (built 2015-04-02) ``` If you did, Rust has been installed successfully! Congrats! @@ -84,10 +87,13 @@ On Windows, it's in a `share/doc` directory, inside wherever you installed Rust to. If not, there are a number of places where you can get help. The easiest is -[the #rust IRC channel on irc.mozilla.org](irc://irc.mozilla.org/#rust), which -you can access through -[Mibbit](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust). Click -that link, and you'll be chatting with other Rustaceans (a silly nickname we -call ourselves), and we can help you out. Other great resources include [the -/r/rust subreddit](http://www.reddit.com/r/rust), and [Stack -Overflow](http://stackoverflow.com/questions/tagged/rust). +[the #rust IRC channel on irc.mozilla.org][irc], which you can access through +[Mibbit][mibbit]. Click that link, and you'll be chatting with other Rustaceans +(a silly nickname we call ourselves), and we can help you out. Other great +resources include [the user’s forum][users], and [Stack Overflow][stack +overflow]. + +[irc]: irc://irc.mozilla.org/#rust +[mibbit]: http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust +[users]: http://users.rust-lang.org/ +[stack overflow]: http://stackoverflow.com/questions/tagged/rust diff --git a/src/doc/trpl/learn-rust.md b/src/doc/trpl/learn-rust.md index e5482d3fb9681..3d8ef8090bfb7 100644 --- a/src/doc/trpl/learn-rust.md +++ b/src/doc/trpl/learn-rust.md @@ -1 +1,4 @@ % Learn Rust + +This section is coming soon! It will eventually have a few tutorials with +building real Rust projects, but they are under development. diff --git a/src/doc/trpl/nightly-rust.md b/src/doc/trpl/nightly-rust.md index 1b58b73994dc9..da6985da19f48 100644 --- a/src/doc/trpl/nightly-rust.md +++ b/src/doc/trpl/nightly-rust.md @@ -2,7 +2,9 @@ Rust provides three distribution channels for Rust: nightly, beta, and stable. Unstable features are only available on nightly Rust. For more details on this -process, see [this post](http://blog.rust-lang.org/2014/10/30/Stability.html). +process, see ‘[Stability as a deliverable][stability]’. + +[stability]: http://blog.rust-lang.org/2014/10/30/Stability.html To install nightly Rust, you can use `rustup.sh`: @@ -10,19 +12,24 @@ To install nightly Rust, you can use `rustup.sh`: $ curl -s https://static.rust-lang.org/rustup.sh | sudo sh -s -- --channel=nightly ``` -If you're concerned about the [potential insecurity](http://curlpipesh.tumblr.com/) of using `curl | sudo sh`, -please keep reading and see our disclaimer below. And feel free to use a two-step version of the installation and examine our installation script: +If you're concerned about the [potential insecurity][insecurity] of using `curl +| sudo sh`, please keep reading and see our disclaimer below. And feel free to +use a two-step version of the installation and examine our installation script: ```bash $ curl -f -L https://static.rust-lang.org/rustup.sh -O -$ sudo sh rustup.sh --channel=nightly +$ sudo sh rustup.sh ``` -If you're on Windows, please download either the [32-bit -installer](https://static.rust-lang.org/dist/rust-nightly-i686-pc-windows-gnu.exe) -or the [64-bit -installer](https://static.rust-lang.org/dist/rust-nightly-x86_64-pc-windows-gnu.exe) -and run it. +[insecurity]: http://curlpipesh.tumblr.com + +If you're on Windows, please download either the [32-bit installer][win32] or +the [64-bit installer][win64] and run it. + +[win32]: https://static.rust-lang.org/dist/rust-1.0.0-beta-i686-pc-windows-gnu.msi +[win64]: https://static.rust-lang.org/dist/rust-1.0.0-beta-x86_64-pc-windows-gnu.msi + +## Uninstalling If you decide you don't want Rust anymore, we'll be a bit sad, but that's okay. Not every programming language is great for everyone. Just run the uninstall @@ -32,20 +39,64 @@ script: $ sudo /usr/local/lib/rustlib/uninstall.sh ``` -If you used the Windows installer, just re-run the `.exe` and it will give you +If you used the Windows installer, just re-run the `.msi` and it will give you an uninstall option. -You can re-run this script any time you want to update Rust. Which, at this -point, is often. Rust is still pre-1.0, and so people assume that you're using -a very recent Rust. +Some people, and somewhat rightfully so, get very upset when we tell you to +`curl | sudo sh`. Basically, when you do this, you are trusting that the good +people who maintain Rust aren't going to hack your computer and do bad things. +That's a good instinct! If you're one of those people, please check out the +documentation on [building Rust from Source][from source], or [the official +binary downloads][install page]. And we promise that this method will not be +the way to install Rust forever: it's just the easiest way to keep people +updated while Rust is in its alpha state. + +[from source]: https://github.com/rust-lang/rust#building-from-source +[install page]: http://www.rust-lang.org/install.html + +Oh, we should also mention the officially supported platforms: + +* Windows (7, 8, Server 2008 R2) +* Linux (2.6.18 or later, various distributions), x86 and x86-64 +* OSX 10.7 (Lion) or greater, x86 and x86-64 + +We extensively test Rust on these platforms, and a few others, too, like +Android. But these are the ones most likely to work, as they have the most +testing. + +Finally, a comment about Windows. Rust considers Windows to be a first-class +platform upon release, but if we're honest, the Windows experience isn't as +integrated as the Linux/OS X experience is. We're working on it! If anything +does not work, it is a bug. Please let us know if that happens. Each and every +commit is tested against Windows just like any other platform. + +If you've got Rust installed, you can open up a shell, and type this: + +```bash +$ rustc --version +``` + +You should see the version number, commit hash, commit date and build date: + +```bash +rustc 1.0.0-nightly (f11f3e7ba 2015-01-04) (built 2015-01-06) +``` + +If you did, Rust has been installed successfully! Congrats! + +This installer also installs a copy of the documentation locally, so you can +read it offline. On UNIX systems, `/usr/local/share/doc/rust` is the location. +On Windows, it's in a `share/doc` directory, inside wherever you installed Rust +to. -This brings me to one other point: some people, and somewhat rightfully so, get -very upset when we tell you to `curl | sudo sh`. And they should be! Basically, -when you do this, you are trusting that the good people who maintain Rust -aren't going to hack your computer and do bad things. That's a good instinct! -If you're one of those people, please check out the documentation on [building -Rust from Source](https://github.com/rust-lang/rust#building-from-source), or -[the official binary downloads](http://www.rust-lang.org/install.html). And we -promise that this method will not be the way to install Rust forever: it's just -the easiest way to keep people updated while Rust is in its alpha state. +If not, there are a number of places where you can get help. The easiest is +[the #rust IRC channel on irc.mozilla.org][irc], which you can access through +[Mibbit][mibbit]. Click that link, and you'll be chatting with other Rustaceans +(a silly nickname we call ourselves), and we can help you out. Other great +resources include [the user’s forum][users], and [Stack Overflow][stack +overflow]. +[irc]: irc://irc.mozilla.org/#rust +[mibbit]: http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust +[users]: http://users.rust-lang.org/ +[stack overflow]: http://stackoverflow.com/questions/tagged/rust diff --git a/src/doc/trpl/primitive-types.md b/src/doc/trpl/primitive-types.md index 2878e7ce4754e..fcbe2b2f8bf70 100644 --- a/src/doc/trpl/primitive-types.md +++ b/src/doc/trpl/primitive-types.md @@ -1,3 +1,268 @@ % Primitive Types -Coming Soon! +The Rust language has a number of types that are considered ‘primitive’. This +means that they’re built-in to the language. Rust is structured in such a way +that the standard library also provides a number of useful types built on top +of these ones, as well, but these are the most primitive. + +# Booleans + +Rust has a built in boolean type, named `bool`. It has two values, `true` and `false`: + +```rust +let x = true; + +let y: bool = false; +``` + +A common use of booleans is in [`if` statements][if]. + +[if]: if.html + +You can find more documentation for `bool`s [in the standard library +documentation][bool]. + +[bool]: ../std/primitive.bool.html + +# `char` + +The `char` type represents a single Unicode scalar value. You can create `char`s +with a single tick: (`'`) + +```rust +let x = 'x'; +let two_hearts = '💕'; +``` + +Unlike some other languages, this means that Rust’s `char` is not a single byte, +but four. + +You can find more documentation for `char`s [in the standard library +documentation][char]. + +[char]: ../std/primitive.char.html + +# Numeric types + +Rust has a variety of numeric types in a few categories: signed and unsigned, +fixed and variable, floating-point and integer. + +These types consist of two parts: the category, and the size. For example, +`u16` is an unsigned type with sixteen bits of size. More bits lets you have +bigger numbers. + +If a number literal has nothing to cause its type to be inferred, it defaults: + +```rust +let x = 42; // x has type i32 + +let y = 1.0; // y has type f64 +``` + +Here’s a list of the different numeric types, with links to their documentation +in the standard library: + +* [i16](../std/primitive.i16.html) +* [i32](../std/primitive.i32.html) +* [i64](../std/primitive.i64.html) +* [i8](../std/primitive.i8.html) +* [u16](../std/primitive.u16.html) +* [u32](../std/primitive.u32.html) +* [u64](../std/primitive.u64.html) +* [u8](../std/primitive.u8.html) +* [isize](../std/primitive.isize.html) +* [usize](../std/primitive.usize.html) +* [f32](../std/primitive.f32.html) +* [f64](../std/primitive.f64.html) + +Let’s go over them by category: + +## Signed and Unsigned + +Integer types come in two varieties: signed and unsigned. To understand the +difference, let’s consider a number with four bits of size. A signed, four-bit +number would let you store numbers from `-8` to `+7`. Signed numbers use +‘two’s compliment representation’. An unsigned four bit number, since it does +not need to store negatives, can store values from `0` to `+15`. + +Unsigned types use a `u` for their category, and signed types use `i`. The `i` +is for ‘integer’. So `u8` is an eight-bit unsigned number, and `i8` is an +eight-bit signed number. + +## Fixed size types + +Fixed size types have a specific number of bits in their representation. Valid +bit sizes are `8`, `16`, `32`, and `64`. So, `u32` is an unsigned, 32-bit integer, +and `i64` is a signed, 64-bit integer. + +## Variable sized types + +Rust also provides types whose size depends on the size of a pointer of the +underlying machine. These types have ‘size’ as the category, and come in signed +and unsigned varieties. This makes for two types: `isize` and `usize`. + +## Floating-point types + +Rust also two floating point types: `f32` and `f64`. These correspond to +IEEE-754 single and double precision numbers. + +# Arrays + +Like many programming languages, Rust has list types to represent a sequence of +things. The most basic is the *array*, a fixed-size list of elements of the +same type. By default, arrays are immutable. + +```rust +let a = [1, 2, 3]; // a: [i32; 3] +let mut m = [1, 2, 3]; // m: [i32; 3] +``` + +Arrays have type `[T; N]`. We’ll talk about this `T` notation [in the generics +section][generics]. The `N` is a compile-time constant, for the length of the +array. + +There’s a shorthand for initializing each element of an array to the same +value. In this example, each element of `a` will be initialized to `0`: + +```rust +let a = [0; 20]; // a: [i32; 20] +``` + +You can get the number of elements in an array `a` with `a.len()`: + +```rust +let a = [1, 2, 3]; + +println!("a has {} elements", a.len()); +``` + +You can access a particular element of an array with *subscript notation*: + +```rust +let names = ["Graydon", "Brian", "Niko"]; // names: [&str; 3] + +println!("The second name is: {}", names[1]); +``` + +Subscripts start at zero, like in most programming languages, so the first name +is `names[0]` and the second name is `names[1]`. The above example prints +`The second name is: Brian`. If you try to use a subscript that is not in the +array, you will get an error: array access is bounds-checked at run-time. Such +errant access is the source of many bugs in other systems programming +languages. + +You can find more documentation for `array`s [in the standard library +documentation][array]. + +[array]: ../std/primitive.array.html + +# Slices + +A ‘slice’ is a reference to (or “view” into) another data structure. They are +useful for allowing safe, efficient access to a portion of an array without +copying. For example, you might want to reference just one line of a file read +into memory. By nature, a slice is not created directly, but from an existing +variable. Slices have a length, can be mutable or not, and in many ways behave +like arrays: + +```rust +let a = [0, 1, 2, 3, 4]; +let middle = &a[1..4]; // A slice of a: just the elements 1, 2, and 3 +``` + +Slices have type `&[T]`. We’ll talk about that `T` when we cover +[generics][generics]. + +[generics]: generics.html + +You can find more documentation for `slices`s [in the standard library +documentation][slice]. + +[slice]: ../std/primitive.slice.html + +# `str` + +Rust’s `str` type is the most primitive string type. As an [unsized type][dst], +it’s not very useful by itself, but becomes useful when placed behind a reference, +like [`&str`][strings]. As such, we’ll just leave it at that. + +[dst]: unsized-types.html +[strings]: strings.html + +You can find more documentation for `str` [in the standard library +documentation][str]. + +[str]: ../std/primitive.str.html + +# Tuples + +A tuple is an ordered list of fixed size. Like this: + +```rust +let x = (1, "hello"); +``` + +The parentheses and commas form this two-length tuple. Here’s the same code, but +with the type annotated: + +```rust +let x: (i32, &str) = (1, "hello"); +``` + +As you can see, the type of a tuple looks just like the tuple, but with each +position having a type name rather than the value. Careful readers will also +note that tuples are heterogeneous: we have an `i32` and a `&str` in this tuple. +In systems programming languages, strings are a bit more complex than in other +languages. For now, just read `&str` as a *string slice*, and we’ll learn more +soon. + +You can access the fields in a tuple through a *destructuring let*. Here’s +an example: + +```rust +let (x, y, z) = (1, 2, 3); + +println!("x is {}", x); +``` + +Remember [before][let] when I said the left-hand side of a `let` statement was more +powerful than just assigning a binding? Here we are. We can put a pattern on +the left-hand side of the `let`, and if it matches up to the right-hand side, +we can assign multiple bindings at once. In this case, `let` "destructures," +or "breaks up," the tuple, and assigns the bits to three bindings. + +[let]: variable-bindings.html + +This pattern is very powerful, and we’ll see it repeated more later. + +There are also a few things you can do with a tuple as a whole, without +destructuring. You can assign one tuple into another, if they have the same +contained types and [arity]. Tuples have the same arity when they have the same +length. + +[arity]: glossary.html#arity + +```rust +let mut x = (1, 2); // x: (i32, i32) +let y = (2, 3); // y: (i32, i32) + +x = y; +``` + +You can find more documentation for tuples [in the standard library +documentation][tuple]. + +[tuple]: ../std/primitive.tuple.html + +# Functions + +Functions also have a type! They look like this: + +``` +fn foo(x: i32) -> i32 { x } + +let x: fn(i32) -> i32 = foo; +``` + +In this case, `x` is a ‘function pointer’ to a function that takes an `i32` and +returns an `i32`. diff --git a/src/doc/trpl/slices.md b/src/doc/trpl/slices.md deleted file mode 100644 index a31c0ac3c4e69..0000000000000 --- a/src/doc/trpl/slices.md +++ /dev/null @@ -1,21 +0,0 @@ -% Slices - -A *slice* is a reference to (or "view" into) an array. They are useful for -allowing safe, efficient access to a portion of an array without copying. For -example, you might want to reference just one line of a file read into memory. -By nature, a slice is not created directly, but from an existing variable. -Slices have a length, can be mutable or not, and in many ways behave like -arrays: - -```{rust} -let a = [0, 1, 2, 3, 4]; -let middle = &a[1..4]; // A slice of a: just the elements 1, 2, and 3 - -for e in middle.iter() { - println!("{}", e); // Prints 1, 2, 3 -} -``` - -You can also take a slice of a vector, `String`, or `&str`, because they are -backed by arrays. Slices have type `&[T]`, which we'll talk about when we cover -generics. diff --git a/src/doc/trpl/syntax-and-semantics.md b/src/doc/trpl/syntax-and-semantics.md index 6f992cf688736..cce985c9e484c 100644 --- a/src/doc/trpl/syntax-and-semantics.md +++ b/src/doc/trpl/syntax-and-semantics.md @@ -1 +1,10 @@ % Syntax and Semantics + +This section breaks Rust down into small chunks, one for each concept. + +If you’d like to learn Rust from the bottom up, reading this in order is a +great way to do that. + +These sections also form a reference for each concept, so if you’re reading +another tutorial and find something confusing, you can find it explained +somewhere in here. diff --git a/src/doc/trpl/tuples.md b/src/doc/trpl/tuples.md deleted file mode 100644 index dd526d05b671e..0000000000000 --- a/src/doc/trpl/tuples.md +++ /dev/null @@ -1,97 +0,0 @@ -% Tuples - -The first compound data type we're going to talk about is called the *tuple*. -A tuple is an ordered list of fixed size. Like this: - -```rust -let x = (1, "hello"); -``` - -The parentheses and commas form this two-length tuple. Here's the same code, but -with the type annotated: - -```rust -let x: (i32, &str) = (1, "hello"); -``` - -As you can see, the type of a tuple looks just like the tuple, but with each -position having a type name rather than the value. Careful readers will also -note that tuples are heterogeneous: we have an `i32` and a `&str` in this tuple. -You have briefly seen `&str` used as a type before, and we'll discuss the -details of strings later. In systems programming languages, strings are a bit -more complex than in other languages. For now, just read `&str` as a *string -slice*, and we'll learn more soon. - -You can access the fields in a tuple through a *destructuring let*. Here's -an example: - -```rust -let (x, y, z) = (1, 2, 3); - -println!("x is {}", x); -``` - -Remember before when I said the left-hand side of a `let` statement was more -powerful than just assigning a binding? Here we are. We can put a pattern on -the left-hand side of the `let`, and if it matches up to the right-hand side, -we can assign multiple bindings at once. In this case, `let` "destructures," -or "breaks up," the tuple, and assigns the bits to three bindings. - -This pattern is very powerful, and we'll see it repeated more later. - -There are also a few things you can do with a tuple as a whole, without -destructuring. You can assign one tuple into another, if they have the same -contained types and [arity]. Tuples have the same arity when they have the same -length. - -```rust -let mut x = (1, 2); // x: (i32, i32) -let y = (2, 3); // y: (i32, i32) - -x = y; -``` - -You can also check for equality with `==`. Again, this will only compile if the -tuples have the same type. - -```rust -let x = (1, 2, 3); -let y = (2, 2, 4); - -if x == y { - println!("yes"); -} else { - println!("no"); -} -``` - -This will print `no`, because some of the values aren't equal. - -Note that the order of the values is considered when checking for equality, -so the following example will also print `no`. - -```rust -let x = (1, 2, 3); -let y = (2, 1, 3); - -if x == y { - println!("yes"); -} else { - println!("no"); -} -``` - -One other use of tuples is to return multiple values from a function: - -```rust -fn next_two(x: i32) -> (i32, i32) { (x + 1, x + 2) } - -fn main() { - let (x, y) = next_two(5); - println!("x, y = {}, {}", x, y); -} -``` - -Even though Rust functions can only return one value, a tuple *is* one value, -that happens to be made up of more than one value. You can also see in this -example how you can destructure a pattern returned by a function, as well. diff --git a/src/doc/trpl/variable-bindings.md b/src/doc/trpl/variable-bindings.md index 88babd8659c2b..d971e557a9a2e 100644 --- a/src/doc/trpl/variable-bindings.md +++ b/src/doc/trpl/variable-bindings.md @@ -1,44 +1,48 @@ % Variable Bindings -The first thing we'll learn about are *variable bindings*. They look like this: +Vitually every non-’Hello World’ Rust program uses *variable bindings*. They +look like this: -```{rust} +```rust fn main() { let x = 5; } ``` -Putting `fn main() {` in each example is a bit tedious, so we'll leave that out -in the future. If you're following along, make sure to edit your `main()` -function, rather than leaving it off. Otherwise, you'll get an error. +Putting `fn main() {` in each example is a bit tedious, so we’ll leave that out +in the future. If you’re following along, make sure to edit your `main()` +function, rather than leaving it off. Otherwise, you’ll get an error. -In many languages, this is called a *variable*. But Rust's variable bindings -have a few tricks up their sleeves. Rust has a very powerful feature called -*pattern matching* that we'll get into detail with later, but the left -hand side of a `let` expression is a full pattern, not just a variable name. -This means we can do things like: +In many languages, this is called a *variable*, but Rust’s variable bindings +have a few tricks up their sleeves. For example the left-hand side of a `let` +expression is a ‘[pattern][pattern]’, not just a variable name. This means we +can do things like: -```{rust} +```rust let (x, y) = (1, 2); ``` After this expression is evaluated, `x` will be one, and `y` will be two. -Patterns are really powerful, but this is about all we can do with them so far. -So let's just keep this in the back of our minds as we go forward. +Patterns are really powerful, and have [their own section][pattern] in the +book. We don’t need those features for now, so we’ll just keep this in the back +of our minds as we go forward. + +[pattern]: patterns.html Rust is a statically typed language, which means that we specify our types up -front. So why does our first example compile? Well, Rust has this thing called -*type inference*. If it can figure out what the type of something is, Rust -doesn't require you to actually type it out. +front, and they’re checked at compile time. So why does our first example +compile? Well, Rust has this thing called ‘type inference’. If it can figure +out what the type of something is, Rust doesn’t require you to actually type it +out. We can add the type if we want to, though. Types come after a colon (`:`): -```{rust} +```rust let x: i32 = 5; ``` -If I asked you to read this out loud to the rest of the class, you'd say "`x` -is a binding with the type `i32` and the value `five`." +If I asked you to read this out loud to the rest of the class, you’d say “`x` +is a binding with the type `i32` and the value `five`.” In this case we chose to represent `x` as a 32-bit signed integer. Rust has many different primitive integer types. They begin with `i` for signed integers @@ -48,19 +52,20 @@ bits. In future examples, we may annotate the type in a comment. The examples will look like this: -```{rust} +```rust fn main() { let x = 5; // x: i32 } ``` -Note the similarities between this annotation and the syntax you use with `let`. -Including these kinds of comments is not idiomatic Rust, but we'll occasionally -include them to help you understand what the types that Rust infers are. +Note the similarities between this annotation and the syntax you use with +`let`. Including these kinds of comments is not idiomatic Rust, but we'll +occasionally include them to help you understand what the types that Rust +infers are. By default, bindings are *immutable*. This code will not compile: -```{ignore} +```rust,ignore let x = 5; x = 10; ``` @@ -75,30 +80,30 @@ error: re-assignment of immutable variable `x` If you want a binding to be mutable, you can use `mut`: -```{rust} +```rust let mut x = 5; // mut x: i32 x = 10; ``` There is no single reason that bindings are immutable by default, but we can -think about it through one of Rust's primary focuses: safety. If you forget to +think about it through one of Rust’s primary focuses: safety. If you forget to say `mut`, the compiler will catch it, and let you know that you have mutated something you may not have intended to mutate. If bindings were mutable by default, the compiler would not be able to tell you this. If you _did_ intend mutation, then the solution is quite easy: add `mut`. -There are other good reasons to avoid mutable state when possible, but they're +There are other good reasons to avoid mutable state when possible, but they’re out of the scope of this guide. In general, you can often avoid explicit mutation, and so it is preferable in Rust. That said, sometimes, mutation is -what you need, so it's not verboten. +what you need, so it’s not verboten. -Let's get back to bindings. Rust variable bindings have one more aspect that +Let’s get back to bindings. Rust variable bindings have one more aspect that differs from other languages: bindings are required to be initialized with a value before you're allowed to use them. -Let's try it out. Change your `src/main.rs` file to look like this: +Let’s try it out. Change your `src/main.rs` file to look like this: -```{rust} +```rust fn main() { let x: i32; @@ -106,21 +111,22 @@ fn main() { } ``` -You can use `cargo build` on the command line to build it. You'll get a warning, -but it will still print "Hello, world!": +You can use `cargo build` on the command line to build it. You’ll get a +warning, but it will still print "Hello, world!": ```text Compiling hello_world v0.0.1 (file:///home/you/projects/hello_world) -src/main.rs:2:9: 2:10 warning: unused variable: `x`, #[warn(unused_variable)] on by default +src/main.rs:2:9: 2:10 warning: unused variable: `x`, #[warn(unused_variable)] + on by default src/main.rs:2 let x: i32; ^ ``` -Rust warns us that we never use the variable binding, but since we never use it, -no harm, no foul. Things change if we try to actually use this `x`, however. Let's -do that. Change your program to look like this: +Rust warns us that we never use the variable binding, but since we never use +it, no harm, no foul. Things change if we try to actually use this `x`, +however. Let’s do that. Change your program to look like this: -```{rust,ignore} +```rust,ignore fn main() { let x: i32; @@ -128,9 +134,9 @@ fn main() { } ``` -And try to build it. You'll get an error: +And try to build it. You’ll get an error: -```{bash} +```bash $ cargo build Compiling hello_world v0.0.1 (file:///home/you/projects/hello_world) src/main.rs:4:39: 4:40 error: use of possibly uninitialized variable: `x` @@ -144,18 +150,20 @@ error: aborting due to previous error Could not compile `hello_world`. ``` -Rust will not let us use a value that has not been initialized. Next, let's +Rust will not let us use a value that has not been initialized. Next, let’s talk about this stuff we've added to `println!`. If you include two curly braces (`{}`, some call them moustaches...) in your string to print, Rust will interpret this as a request to interpolate some sort of value. *String interpolation* is a computer science term that means "stick in the middle of a string." We add a comma, and then `x`, to indicate that we -want `x` to be the value we're interpolating. The comma is used to separate -arguments we pass to functions and macros, if you're passing more than one. - -When you just use the curly braces, Rust will attempt to display the -value in a meaningful way by checking out its type. If you want to specify the -format in a more detailed manner, there are a [wide number of options -available](../std/fmt/index.html). For now, we'll just stick to the default: -integers aren't very complicated to print. +want `x` to be the value we’re interpolating. The comma is used to separate +arguments we pass to functions and macros, if you’re passing more than one. + +When you just use the curly braces, Rust will attempt to display the value in a +meaningful way by checking out its type. If you want to specify the format in a +more detailed manner, there are a [wide number of options available][format]. +For now, we'll just stick to the default: integers aren't very complicated to +print. + +[format]: ../std/fmt/index.html diff --git a/src/libcollections/borrow.rs b/src/libcollections/borrow.rs index 4503ad14e92b4..7332bf4670ae5 100644 --- a/src/libcollections/borrow.rs +++ b/src/libcollections/borrow.rs @@ -39,7 +39,7 @@ use self::Cow::*; /// Borrow>` and `Vec: Borrow<[T]>`. #[stable(feature = "rust1", since = "1.0.0")] pub trait Borrow { - /// Immutably borrow from an owned value. + /// Immutably borrows from an owned value. /// /// # Examples /// @@ -67,7 +67,7 @@ pub trait Borrow { /// Similar to `Borrow`, but for mutable borrows. #[stable(feature = "rust1", since = "1.0.0")] pub trait BorrowMut : Borrow { - /// Mutably borrow from an owned value. + /// Mutably borrows from an owned value. /// /// # Examples /// @@ -126,7 +126,7 @@ impl<'a, B: ?Sized> Borrow for Cow<'a, B> where B: ToOwned, ::O } } -/// A generalization of Clone to borrowed data. +/// A generalization of `Clone` to borrowed data. /// /// Some types make it possible to go from borrowed to owned, usually by /// implementing the `Clone` trait. But `Clone` works only for going from `&T` @@ -137,7 +137,7 @@ pub trait ToOwned { #[stable(feature = "rust1", since = "1.0.0")] type Owned: Borrow; - /// Create owned data from borrowed data, usually by copying. + /// Creates owned data from borrowed data, usually by cloning. #[stable(feature = "rust1", since = "1.0.0")] fn to_owned(&self) -> Self::Owned; } @@ -155,9 +155,9 @@ impl ToOwned for T where T: Clone { /// data lazily when mutation or ownership is required. The type is designed to /// work with general borrowed data via the `Borrow` trait. /// -/// `Cow` implements both `Deref`, which means that you can call +/// `Cow` implements `Deref`, which means that you can call /// non-mutating methods directly on the data it encloses. If mutation -/// is desired, `to_mut` will obtain a mutable references to an owned +/// is desired, `to_mut` will obtain a mutable reference to an owned /// value, cloning if necessary. /// /// # Examples @@ -200,7 +200,7 @@ impl<'a, B: ?Sized> Clone for Cow<'a, B> where B: ToOwned { } impl<'a, B: ?Sized> Cow<'a, B> where B: ToOwned { - /// Acquire a mutable reference to the owned form of the data. + /// Acquires a mutable reference to the owned form of the data. /// /// Copies the data if it is not already owned. /// @@ -226,7 +226,7 @@ impl<'a, B: ?Sized> Cow<'a, B> where B: ToOwned { } } - /// Extract the owned data. + /// Extracts the owned data. /// /// Copies the data if it is not already owned. /// @@ -327,7 +327,7 @@ impl<'a, B: ?Sized> Hash for Cow<'a, B> where B: Hash + ToOwned } } -/// Trait for moving into a `Cow` +/// Trait for moving into a `Cow`. #[unstable(feature = "into_cow", reason = "may be replaced by `convert::Into`")] pub trait IntoCow<'a, B: ?Sized> where B: ToOwned { /// Moves `self` into `Cow` diff --git a/src/libcore/convert.rs b/src/libcore/convert.rs index 85b648bbd5980..f874d4f6a2796 100644 --- a/src/libcore/convert.rs +++ b/src/libcore/convert.rs @@ -10,15 +10,35 @@ //! Traits for conversions between types. //! -//! The traits in this module provide a general way to talk about -//! conversions from one type to another. They follow the standard -//! Rust conventions of `as`/`to`/`into`/`from`. +//! The traits in this module provide a general way to talk about conversions from one type to +//! another. They follow the standard Rust conventions of `as`/`to`/`into`/`from`. +//! +//! Like many traits, these are often used as bounds for generic functions, to support arguments of +//! multiple types. +//! +//! See each trait for usage examples. #![stable(feature = "rust1", since = "1.0.0")] use marker::Sized; /// A cheap, reference-to-reference conversion. +/// +/// # Examples +/// +/// Both `String` and `&str` implement `AsRef`: +/// +/// ``` +/// fn is_hello>(s: T) { +/// assert_eq!("hello", s.as_ref()); +/// } +/// +/// let s = "hello"; +/// is_hello(s); +/// +/// let s = "hello".to_string(); +/// is_hello(s); +/// ``` #[stable(feature = "rust1", since = "1.0.0")] pub trait AsRef { /// Performs the conversion. @@ -34,8 +54,21 @@ pub trait AsMut { fn as_mut(&mut self) -> &mut T; } -/// A conversion that consumes `self`, which may or may not be -/// expensive. +/// A conversion that consumes `self`, which may or may not be expensive. +/// +/// # Examples +/// +/// `String` implements `Into>`: +/// +/// ``` +/// fn is_hello>>(s: T) { +/// let bytes = b"hello".to_vec(); +/// assert_eq!(bytes, s.into()); +/// } +/// +/// let s = "hello".to_string(); +/// is_hello(s); +/// ``` #[stable(feature = "rust1", since = "1.0.0")] pub trait Into: Sized { /// Performs the conversion. @@ -44,6 +77,21 @@ pub trait Into: Sized { } /// Construct `Self` via a conversion. +/// +/// # Examples +/// +/// `Vec` implements `From`: +/// +/// ``` +/// fn is_hello>(v: T) { +/// let string = "hello".to_string(); +/// +/// assert_eq!(string, v.from()); +/// } +/// +/// let b = b"hello".to_vec(); +/// is_hello(b); +/// ``` #[stable(feature = "rust1", since = "1.0.0")] pub trait From { /// Performs the conversion. diff --git a/src/librustc/middle/traits/coherence.rs b/src/librustc/middle/traits/coherence.rs index 2f2db8f38bd87..d21891ab23f1c 100644 --- a/src/librustc/middle/traits/coherence.rs +++ b/src/librustc/middle/traits/coherence.rs @@ -26,7 +26,7 @@ use syntax::codemap::{DUMMY_SP, Span}; use util::ppaux::Repr; #[derive(Copy, Clone)] -struct ParamIsLocal(bool); +struct InferIsLocal(bool); /// True if there exist types that satisfy both of the two given impls. pub fn overlapping_impls(infcx: &InferCtxt, @@ -60,7 +60,7 @@ fn overlap(selcx: &mut SelectionContext, let (a_trait_ref, a_obligations) = impl_trait_ref_and_oblig(selcx, a_def_id, - util::free_substs_for_impl); + util::fresh_type_vars_for_impl); let (b_trait_ref, b_obligations) = impl_trait_ref_and_oblig(selcx, b_def_id, @@ -104,7 +104,7 @@ pub fn trait_ref_is_knowable<'tcx>(tcx: &ty::ctxt<'tcx>, trait_ref: &ty::TraitRe // if the orphan rules pass, that means that no ancestor crate can // impl this, so it's up to us. - if orphan_check_trait_ref(tcx, trait_ref, ParamIsLocal(false)).is_ok() { + if orphan_check_trait_ref(tcx, trait_ref, InferIsLocal(false)).is_ok() { debug!("trait_ref_is_knowable: orphan check passed"); return true; } @@ -126,7 +126,7 @@ pub fn trait_ref_is_knowable<'tcx>(tcx: &ty::ctxt<'tcx>, trait_ref: &ty::TraitRe // implemented by an upstream crate, which means that the impl // must be visible to us, and -- since the trait is fundamental // -- we can test. - orphan_check_trait_ref(tcx, trait_ref, ParamIsLocal(true)).is_err() + orphan_check_trait_ref(tcx, trait_ref, InferIsLocal(true)).is_err() } type SubstsFn = for<'a,'tcx> fn(infcx: &InferCtxt<'a, 'tcx>, @@ -196,16 +196,16 @@ pub fn orphan_check<'tcx>(tcx: &ty::ctxt<'tcx>, return Ok(()); } - orphan_check_trait_ref(tcx, &trait_ref, ParamIsLocal(false)) + orphan_check_trait_ref(tcx, &trait_ref, InferIsLocal(false)) } fn orphan_check_trait_ref<'tcx>(tcx: &ty::ctxt<'tcx>, trait_ref: &ty::TraitRef<'tcx>, - param_is_local: ParamIsLocal) + infer_is_local: InferIsLocal) -> Result<(), OrphanCheckErr<'tcx>> { - debug!("orphan_check_trait_ref(trait_ref={}, param_is_local={})", - trait_ref.repr(tcx), param_is_local.0); + debug!("orphan_check_trait_ref(trait_ref={}, infer_is_local={})", + trait_ref.repr(tcx), infer_is_local.0); // First, create an ordered iterator over all the type parameters to the trait, with the self // type appearing first. @@ -215,12 +215,12 @@ fn orphan_check_trait_ref<'tcx>(tcx: &ty::ctxt<'tcx>, // Find the first input type that either references a type parameter OR // some local type. for input_ty in input_tys { - if ty_is_local(tcx, input_ty, param_is_local) { + if ty_is_local(tcx, input_ty, infer_is_local) { debug!("orphan_check_trait_ref: ty_is_local `{}`", input_ty.repr(tcx)); // First local input type. Check that there are no // uncovered type parameters. - let uncovered_tys = uncovered_tys(tcx, input_ty, param_is_local); + let uncovered_tys = uncovered_tys(tcx, input_ty, infer_is_local); for uncovered_ty in uncovered_tys { if let Some(param) = uncovered_ty.walk().find(|t| is_type_parameter(t)) { debug!("orphan_check_trait_ref: uncovered type `{}`", param.repr(tcx)); @@ -234,7 +234,7 @@ fn orphan_check_trait_ref<'tcx>(tcx: &ty::ctxt<'tcx>, // Otherwise, enforce invariant that there are no type // parameters reachable. - if !param_is_local.0 { + if !infer_is_local.0 { if let Some(param) = input_ty.walk().find(|t| is_type_parameter(t)) { debug!("orphan_check_trait_ref: uncovered type `{}`", param.repr(tcx)); return Err(OrphanCheckErr::UncoveredTy(param)); @@ -249,14 +249,14 @@ fn orphan_check_trait_ref<'tcx>(tcx: &ty::ctxt<'tcx>, fn uncovered_tys<'tcx>(tcx: &ty::ctxt<'tcx>, ty: Ty<'tcx>, - param_is_local: ParamIsLocal) + infer_is_local: InferIsLocal) -> Vec> { - if ty_is_local_constructor(tcx, ty, param_is_local) { + if ty_is_local_constructor(tcx, ty, infer_is_local) { vec![] } else if fundamental_ty(tcx, ty) { ty.walk_shallow() - .flat_map(|t| uncovered_tys(tcx, t, param_is_local).into_iter()) + .flat_map(|t| uncovered_tys(tcx, t, infer_is_local).into_iter()) .collect() } else { vec![ty] @@ -271,10 +271,10 @@ fn is_type_parameter<'tcx>(ty: Ty<'tcx>) -> bool { } } -fn ty_is_local<'tcx>(tcx: &ty::ctxt<'tcx>, ty: Ty<'tcx>, param_is_local: ParamIsLocal) -> bool +fn ty_is_local<'tcx>(tcx: &ty::ctxt<'tcx>, ty: Ty<'tcx>, infer_is_local: InferIsLocal) -> bool { - ty_is_local_constructor(tcx, ty, param_is_local) || - fundamental_ty(tcx, ty) && ty.walk_shallow().any(|t| ty_is_local(tcx, t, param_is_local)) + ty_is_local_constructor(tcx, ty, infer_is_local) || + fundamental_ty(tcx, ty) && ty.walk_shallow().any(|t| ty_is_local(tcx, t, infer_is_local)) } fn fundamental_ty<'tcx>(tcx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool @@ -293,7 +293,7 @@ fn fundamental_ty<'tcx>(tcx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool fn ty_is_local_constructor<'tcx>(tcx: &ty::ctxt<'tcx>, ty: Ty<'tcx>, - param_is_local: ParamIsLocal) + infer_is_local: InferIsLocal) -> bool { debug!("ty_is_local_constructor({})", ty.repr(tcx)); @@ -310,13 +310,13 @@ fn ty_is_local_constructor<'tcx>(tcx: &ty::ctxt<'tcx>, ty::ty_ptr(..) | ty::ty_rptr(..) | ty::ty_tup(..) | - ty::ty_infer(..) | + ty::ty_param(..) | ty::ty_projection(..) => { false } - ty::ty_param(..) => { - param_is_local.0 + ty::ty_infer(..) => { + infer_is_local.0 } ty::ty_enum(def_id, _) | diff --git a/src/librustc/middle/traits/util.rs b/src/librustc/middle/traits/util.rs index 297cea13207e5..3a1be785580af 100644 --- a/src/librustc/middle/traits/util.rs +++ b/src/librustc/middle/traits/util.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use middle::region; use middle::subst::{Substs, VecPerParamSpace}; use middle::infer::InferCtxt; use middle::ty::{self, Ty, AsPredicate, ToPolyTraitRef}; @@ -304,34 +303,6 @@ pub fn fresh_type_vars_for_impl<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>, infcx.fresh_substs_for_generics(span, &impl_generics) } -// determine the `self` type, using fresh variables for all variables -// declared on the impl declaration e.g., `impl for Box<[(A,B)]>` -// would return ($0, $1) where $0 and $1 are freshly instantiated type -// variables. -pub fn free_substs_for_impl<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>, - _span: Span, - impl_def_id: ast::DefId) - -> Substs<'tcx> -{ - let tcx = infcx.tcx; - let impl_generics = ty::lookup_item_type(tcx, impl_def_id).generics; - - let some_types = impl_generics.types.map(|def| { - ty::mk_param_from_def(tcx, def) - }); - - let some_regions = impl_generics.regions.map(|def| { - // FIXME. This destruction scope information is pretty darn - // bogus; after all, the impl might not even be in this crate! - // But given what we do in coherence, it is harmless enough - // for now I think. -nmatsakis - let extent = region::DestructionScopeData::new(ast::DUMMY_NODE_ID); - ty::free_region_from_def(extent, def) - }); - - Substs::new(some_types, some_regions) -} - impl<'tcx, N> fmt::Debug for VtableImplData<'tcx, N> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "VtableImpl({:?})", self.impl_def_id) diff --git a/src/libstd/sync/mpsc/mod.rs b/src/libstd/sync/mpsc/mod.rs index e544484351600..93b27b6ce9efd 100644 --- a/src/libstd/sync/mpsc/mod.rs +++ b/src/libstd/sync/mpsc/mod.rs @@ -345,8 +345,8 @@ pub struct SendError(#[stable(feature = "rust1", since = "1.0.0")] pub T); #[stable(feature = "rust1", since = "1.0.0")] pub struct RecvError; -/// This enumeration is the list of the possible reasons that try_recv could not -/// return data when called. +/// This enumeration is the list of the possible reasons that `try_recv` could +/// not return data when called. #[derive(PartialEq, Eq, Clone, Copy, Debug)] #[stable(feature = "rust1", since = "1.0.0")] pub enum TryRecvError { diff --git a/src/test/compile-fail/coherence-overlap-all-t-and-tuple.rs b/src/test/compile-fail/coherence-overlap-all-t-and-tuple.rs new file mode 100644 index 0000000000000..3fd635b3d616f --- /dev/null +++ b/src/test/compile-fail/coherence-overlap-all-t-and-tuple.rs @@ -0,0 +1,28 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// 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. + +// Check that we detect an overlap here in the case where: +// +// for some type X: +// T = (X,) +// T11 = X, U11 = X +// +// Seems pretty basic, but then there was issue #24241. :) + +trait From { +} + +impl From for T { //~ ERROR E0119 +} + +impl From<(U11,)> for (T11,) { +} + +fn main() { } diff --git a/src/test/run-pass/issue-19097.rs b/src/test/run-pass/issue-19097.rs new file mode 100644 index 0000000000000..ca4b72f9e5bd0 --- /dev/null +++ b/src/test/run-pass/issue-19097.rs @@ -0,0 +1,22 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// 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. + +// regression test for #19097 + +struct Foo(T); + +impl<'a, T> Foo<&'a T> { + fn foo(&self) {} +} +impl<'a, T> Foo<&'a mut T> { + fn foo(&self) {} +} + +fn main() {}