---

yaml
---
r: 32758
b: refs/heads/dist-snap
c: c2bc512
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -7,6 +7,6 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
 refs/heads/incoming: d9317a174e434d4c99fc1a37fd7dc0d2f5328d37
-refs/heads/dist-snap: fd0de8bfd70b01dd01ca541bfdfb52703fa44d9c
+refs/heads/dist-snap: c2bc5122cd2122edcc0a4fd23288b19378ad2d3a
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/dist-snap/doc/tutorial.md

@@ -2,79 +2,52 @@
 
 # Introduction
 
-## Scope
-
-This is a tutorial for the Rust programming language. It assumes the
-reader is familiar with the basic concepts of programming, and has
-programmed in one or more other languages before. It will often make
-comparisons to other languages in the C family. This tutorial covers
-the fundamentals of the language, including the syntax, the type
-system and memory model, and generics.
-[Additional tutorials](#what-next) cover specific language features in
-greater depth.
-
-## Language overview
-
-Rust is a systems programming language with a focus on type safety,
-memory safety, concurrency and performance. It is intended for writing
-large, high-performance applications while preventing several classes
-of errors commonly found in languages like C++. Rust has a
-sophisticated memory model that makes possible many of the efficient
-data structures used in C++, while disallowing invalid memory accesses
-that would otherwise cause segmentation faults. Like other systems
-languages, it is statically typed and compiled ahead of time.
+Rust is a programming language with a focus on type safety, memory
+safety, concurrency and performance. It is intended for writing
+large-scale, high-performance software while preventing several
+classes of common errors. Rust has a sophisticated memory model that
+encourages efficient data structures and safe concurrency patterns,
+forbidding invalid memory accesses that would otherwise cause
+segmentation faults. It is statically typed and compiled ahead of
+time.
 
 As a multi-paradigm language, Rust supports writing code in
-procedural, functional and object-oriented styles. Some of its nice
-high-level features include:
+procedural, functional and object-oriented styles. Some of its
+pleasant high-level features include:
 
-* **Pattern matching and algebraic data types (enums).** Common in
-  functional languages, pattern matching on ADTs provides a compact
-  and expressive way to encode program logic.
+* **Pattern matching and algebraic data types (enums).** As
+  popularized by functional languages, pattern matching on ADTs
+  provides a compact and expressive way to encode program logic.
+* **Type inference.** Type annotations on local variable
+  declarations are optional.
 * **Task-based concurrency.** Rust uses lightweight tasks that do
   not share memory.
-* **Higher-order functions.** Rust functions may take closures as
-  arguments or return closures as return values.  Closures in Rust are
-  very powerful and used pervasively.
-* **Trait polymorphism.** Rust's type system features a unique
-  combination of Java-style interfaces and Haskell-style typeclasses
-  called _traits_.
+* **Higher-order functions.** Rust's efficient and flexible closures
+  are heavily relied on to provide iteration and other control
+  structures
 * **Parametric polymorphism (generics).** Functions and types can be
-  parameterized over type variables with optional type constraints.
-* **Type inference.** Type annotations on local variable
-  declarations can be omitted.
-
-## First impressions
-
-As a curly-brace language in the tradition of C, C++, and JavaScript,
-Rust looks a lot like other languages you may be familiar with.
+  parameterized over type variables with optional trait-based type
+  constraints.
+* **Trait polymorphism.** Rust's type system features a unique
+  combination of type classes and object-oriented interfaces.
 
-~~~~
-fn boring_old_factorial(n: int) -> int {
-    let mut result = 1, i = 1;
-    while i <= n {
-        result *= i;
-        i += 1;
-    }
-    return result;
-}
-~~~~
+## Scope
 
-Several differences from C stand out. Types do not come before, but
-after variable names (preceded by a colon). For local variables
-(introduced with `let`), types are optional, and will be inferred when
-left off. Constructs like `while` and `if` do not require parentheses
-around the condition (though they allow them).
+This is an introductory tutorial for the Rust programming language. It
+covers the fundamentals of the language, including the syntax, the
+type system and memory model, and generics.  [Additional
+tutorials](#what-next) cover specific language features in greater
+depth.
 
-You should, however, not conclude that Rust is simply an evolution of
-C. As will become clear in the rest of this tutorial, it goes in quite
-a different direction, with efficient, strongly-typed and memory-safe
-support for many high-level idioms.
+It assumes the reader is familiar with the basic concepts of
+programming, and has programmed in one or more other languages
+before. It will often make comparisons to other languages,
+particularly those in the C family.
 
 ## Conventions
 
 Throughout the tutorial, words that indicate language keywords or
-identifiers defined in the example code are displayed in `code font`.
+identifiers defined in example code are displayed in `code font`.
 
 Code snippets are indented, and also shown in a monospaced font. Not
 all snippets constitute whole programs. For brevity, we'll often show