---

yaml
---
r: 209787
b: refs/heads/try
c: bf13103
h: refs/heads/master
i:
  209785: 2557c9f
  209783: f51b1b2
v: v3

Author: SimonSapin

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 3e561f05c00cd180ec02db4ccab2840a4aba93d2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ba0e1cd8147d452c356aacb29fb87568ca26f111
-refs/heads/try: bd8101d698cc0f599ff10f9b5550716502bb1e91
+refs/heads/try: bf1310389ed2f2bbff529929e1606b59c8a20dfa
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try/mk/main.mk

@@ -13,12 +13,12 @@
 ######################################################################
 
 # The version number
-CFG_RELEASE_NUM=1.1.0
+CFG_RELEASE_NUM=1.0.0
 
 # An optional number to put after the label, e.g. '.2' -> '-beta.2'
 # NB Make sure it starts with a dot to conform to semver pre-release
 # versions (section 9)
-CFG_PRERELEASE_VERSION=.1
+CFG_PRERELEASE_VERSION=.3
 
 CFG_FILENAME_EXTRA=4e7c5e5c
 

branches/try/src/doc/trpl/README.md

@@ -24,15 +24,13 @@ is the first. After this:
 * [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.
-* [Academic Research][ar] - Literature that influenced Rust.
 
 [gs]: getting-started.html
 [lr]: learn-rust.html
 [er]: effective-rust.html
 [ss]: syntax-and-semantics.html
 [nr]: nightly-rust.html
 [gl]: glossary.html
-[ar]: academic-research.html
 
 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

branches/try/src/doc/trpl/SUMMARY.md

@@ -9,7 +9,6 @@
     * [The Stack and the Heap](the-stack-and-the-heap.md)
     * [Debug and Display](debug-and-display.md)
     * [Testing](testing.md)
-    * [Conditional Compilation](conditional-compilation.md)
     * [Documentation](documentation.md)
     * [Iterators](iterators.md)
     * [Concurrency](concurrency.md)
@@ -44,17 +43,18 @@
     * [Closures](closures.md)
     * [Universal Function Call Syntax](ufcs.md)
     * [Crates and Modules](crates-and-modules.md)
-    * [`const` and `static`](const-and-static.md)
+    * [`static`](static.md)
+    * [`const`](const.md)
     * [Tuple Structs](tuple-structs.md)
     * [Attributes](attributes.md)
+    * [Conditional Compilation](conditional-compilation.md)
     * [`type` aliases](type-aliases.md)
     * [Casting between types](casting-between-types.md)
     * [Associated Types](associated-types.md)
     * [Unsized Types](unsized-types.md)
     * [Deref coercions](deref-coercions.md)
     * [Macros](macros.md)
     * [Raw Pointers](raw-pointers.md)
-    * [`unsafe`](unsafe.md)
 * [Nightly Rust](nightly-rust.md)
     * [Compiler Plugins](compiler-plugins.md)
     * [Inline Assembly](inline-assembly.md)

branches/try/src/doc/trpl/associated-types.md

@@ -1,8 +1,8 @@
 % Associated Types
 
-Associated types are a powerful part of Rust’s type system. They’re related to
-the idea of a ‘type family’, in other words, grouping multiple types together. That
-description is a bit abstract, so let’s dive right into an example. If you want
+Associated types are a powerful part of Rust's type system. They're related to
+the idea of a 'type family', in other words, grouping multiple types together. That
+description is a bit abstract, so let's dive right into an example. If you want
 to write a `Graph` trait, you have two types to be generic over: the node type
 and the edge type. So you might write a trait, `Graph<N, E>`, that looks like
 this:
@@ -48,11 +48,11 @@ fn distance<G: Graph>(graph: &G, start: &G::N, end: &G::N) -> uint { ... }
 
 No need to deal with the `E`dge type here!
 
-Let’s go over all this in more detail.
+Let's go over all this in more detail.
 
 ## Defining associated types
 
-Let’s build that `Graph` trait. Here’s the definition:
+Let's build that `Graph` trait. Here's the definition:
 
 ```rust
 trait Graph {
@@ -86,7 +86,7 @@ trait Graph {
 ## Implementing associated types
 
 Just like any trait, traits that use associated types use the `impl` keyword to
-provide implementations. Here’s a simple implementation of Graph:
+provide implementations. Here's a simple implementation of Graph:
 
 ```rust
 # trait Graph {
@@ -118,13 +118,13 @@ impl Graph for MyGraph {
 This silly implementation always returns `true` and an empty `Vec<Edge>`, but it
 gives you an idea of how to implement this kind of thing. We first need three
 `struct`s, one for the graph, one for the node, and one for the edge. If it made
-more sense to use a different type, that would work as well, we’re just going to
+more sense to use a different type, that would work as well, we're just going to
 use `struct`s for all three here.
 
 Next is the `impl` line, which is just like implementing any other trait.
 
 From here, we use `=` to define our associated types. The name the trait uses
-goes on the left of the `=`, and the concrete type we’re `impl`ementing this
+goes on the left of the `=`, and the concrete type we're `impl`ementing this
 for goes on the right. Finally, we use the concrete types in our function
 declarations.
 

branches/try/src/doc/trpl/attributes.md

@@ -1,70 +1,3 @@
 % Attributes
 
-Declarations can be annotated with ‘attributes’ in Rust. They look like this:
-
-```rust
-#[test]
-# fn foo() {}
-```
-
-or like this:
-
-```rust
-# mod foo {
-#![test]
-# }
-```
-
-The difference between the two is the `!`, which changes what the attribute
-applies to:
-
-```rust,ignore
-#[foo]
-struct Foo;
-
-mod bar {
-    #![bar]
-}
-```
-
-The `#[foo]` attribute applies to the next item, which is the `struct`
-declaration. The `#![bar]` attribute applies to the item enclosing it, which is
-the `mod` declaration. Otherwise, they’re the same. Both change the meaning of
-the item they’re attached to somehow.
-
-For example, consider a function like this:
-
-```rust
-#[test]
-fn check() {
-    assert_eq!(2, 1 + 1);
-}
-```
-
-It is marked with `#[test]`. This means it’s special: when you run
-[tests][tests], this function will execute. When you compile as usual, it won’t
-even be included. This function is now a test function.
-
-[tests]: testing.html
-
-Attributes may also have additional data:
-
-```rust
-#[inline(always)]
-fn super_fast_fn() {
-# }
-```
-
-Or even keys and values:
-
-```rust
-#[cfg(target_os = "macos")]
-mod macos_only {
-# }
-```
-
-Rust attributes are used for a number of different things. There is a full list
-of attributes [in the reference][reference]. Currently, you are not allowed to
-create your own attributes, the Rust compiler defines them.
-
-[reference]: reference.html#attributes
+Coming Soon!

branches/try/src/doc/trpl/casting-between-types.md

@@ -33,7 +33,7 @@ let b = a as u32; // four eights makes 32
 
 It’s a ‘non-scalar cast’ because we have multiple values here: the four
 elements of the array. These kinds of casts are very dangerous, because they
-make assumptions about the way that multiple underlying structures are
+make assumptions about the way that multiple underlying strucutres are
 implemented. For this, we need something more dangerous.
 
 # `transmute`
@@ -59,7 +59,7 @@ unsafe {
 }
 ```
 
-We have to wrap the operation in an `unsafe` block for this to compile
+We have to wrap the operation in an `unsafe` block, but this will compile
 successfully. Technically, only the `mem::transmute` call itself needs to be in
 the block, but it's nice in this case to enclose everything related, so you
 know where to look. In this case, the details about `a` are also important, and