---

yaml
---
r: 40931
b: refs/heads/dist-snap
c: 8554d5e
h: refs/heads/master
i:
  40929: 6423e16
  40927: e59c756
v: v3

Author: catamorphism

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278
 refs/heads/incoming: e90142e536c150df0d9b4b2f11352152177509b5
-refs/heads/dist-snap: b99a2542f38a2d08b863d2e2ab73bfd64647e520
+refs/heads/dist-snap: 8554d5e7104be30d20ce8e8dc08239ce20b171c2
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/doc/rust.md

@@ -1072,6 +1072,15 @@ let p = Point {x: 10, y: 11};
 let px: int = p.x;
 ~~~~
 
+A _tuple structure_ is a nominal [tuple type](#tuple-types), also defined with the keyword `struct`.
+For example:
+
+~~~~
+struct Point(int, int);
+let p = Point(10, 11);
+let px: int = match p { Point(x, _) => x };
+~~~~
+
 ### Enumerations
 
 An _enumeration_ is a simultaneous definition of a nominal [enumerated type](#enumerated-types) as well as a set of *constructors*,
@@ -1534,22 +1543,32 @@ values.
 ~~~~~~~~{.ebnf .gram}
 struct_expr : expr_path '{' ident ':' expr
                       [ ',' ident ':' expr ] *
-                      [ ".." expr ] '}'
+                      [ ".." expr ] '}' |
+              expr_path '(' expr
+                      [ ',' expr ] * ')'
 ~~~~~~~~
 
+There are several forms of structure expressions.
 A _structure expression_ consists of the [path](#paths) of a [structure item](#structures),
 followed by a brace-enclosed list of one or more comma-separated name-value pairs,
 providing the field values of a new instance of the structure.
 A field name can be any identifier, and is separated from its value expression by a colon.
 To indicate that a field is mutable, the `mut` keyword is written before its name.
 
+A _tuple structure expression_ constists of the [path](#paths) of a [structure item](#structures),
+followed by a parenthesized list of one or more comma-separated expressions
+(in other words, the path of a structured item followed by a tuple expression).
+The structure item must be a tuple structure item.
+
 The following are examples of structure expressions:
 
 ~~~~
 # struct Point { x: float, y: float }
+# struct TuplePoint(float, float);
 # mod game { pub struct User { name: &str, age: uint, mut score: uint } } 
 # use game;
 Point {x: 10f, y: 20f};
+TuplePoint(10f, 20f);
 let u = game::User {name: "Joe", age: 35u, mut score: 100_000};
 ~~~~
 
@@ -2597,6 +2616,7 @@ the resulting `struct` value will always be laid out in memory in the order spec
 The fields of a `struct` may be qualified by [visibility modifiers](#visibility-modifiers),
 to restrict access to implementation-private data in a structure.
 
+A `tuple struct` type is just like a structure type, except that the fields are anonymous.
 
 ### Enumerated types
 

branches/dist-snap/doc/tutorial.md

@@ -902,6 +902,22 @@ match mytup {
 }
 ~~~~
 
+## Tuple structs
+
+Rust also has _nominal tuples_, which behave like both structs and tuples,
+except that nominal tuple types have names
+(so `Foo(1, 2)` has a different type from `Bar(1, 2)`),
+and nominal tuple types' _fields_ do not have names.
+
+For example:
+~~~~
+struct MyTup(int, int, float);
+let mytup: MyTup = MyTup(10, 20, 30.0);
+match mytup {
+  MyTup(a, b, c) => log(info, a + b + (c as int))
+}
+~~~~
+
 # Functions and methods
 
 We've already seen several function definitions. Like all other static