Skip to content

Purged "record" from the manual. #14680

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Jun 6, 2014
Merged

Purged "record" from the manual. #14680

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
36 changes: 18 additions & 18 deletions src/doc/rust.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2524,10 +2524,10 @@ Note that for a given *unit-like* structure type, this will always be the same v

A structure expression can terminate with the syntax `..` followed by an expression to denote a functional update.
The expression following `..` (the base) must have the same structure type as the new structure type being formed.
The entire expression denotes the result of allocating a new structure
The entire expression denotes the result of constructing a new structure
(with the same type as the base expression)
with the given values for the fields that were explicitly specified
and the values in the base record for all other fields.
and the values in the base expression for all other fields.

~~~~
# struct Point3d { x: int, y: int, z: int }
Expand Down Expand Up @@ -2575,15 +2575,15 @@ when not immediately followed by a parenthesized expression-list (the latter is
A field expression denotes a field of a [structure](#structure-types).

~~~~ {.ignore .field}
myrecord.myfield;
mystruct.myfield;
foo().x;
(Struct {a: 10, b: 20}).a;
~~~~

A field access on a record is an [lvalue](#lvalues-rvalues-and-temporaries) referring to the value of that field.
When the field is mutable, it can be [assigned](#assignment-expressions) to.
A field access is an [lvalue](#lvalues-rvalues-and-temporaries) referring to the value of that field.
When the type providing the field inherits mutabilty, it can be [assigned](#assignment-expressions) to.

When the type of the expression to the left of the dot is a pointer to a record or structure,
Also, if the type of the expression to the left of the dot is a pointer,
it is automatically dereferenced to make the field access possible.

### Vector expressions
Expand Down Expand Up @@ -3038,7 +3038,7 @@ match_pat : pat [ '|' pat ] * [ "if" expr ] ? ;

A `match` expression branches on a *pattern*. The exact form of matching that
occurs depends on the pattern. Patterns consist of some combination of
literals, destructured vectors or enum constructors, structures, records and
literals, destructured vectors or enum constructors, structures and
tuples, variable binding specifications, wildcards (`..`), and placeholders
(`_`). A `match` expression has a *head expression*, which is the value to
compare to the patterns. The type of the patterns must equal the type of the
Expand Down Expand Up @@ -3315,17 +3315,16 @@ such as `&str` or `String`.

### Tuple types

The tuple type-constructor forms a new heterogeneous product of values similar
to the record type-constructor. The differences are as follows:

* tuple elements cannot be mutable, unlike record fields
* tuple elements are not named and can be accessed only by pattern-matching
A tuple *type* is a heterogeneous product of other types, called the *elements*
of the tuple. It has no nominal name and is instead structurally typed.

Tuple types and values are denoted by listing the types or values of their
elements, respectively, in a parenthesized, comma-separated
list.

The members of a tuple are laid out in memory contiguously, like a record, in
Because tuple elements don't have a name, they can only be accessed by pattern-matching.

The members of a tuple are laid out in memory contiguously, in
order specified by the tuple type.

An example of a tuple type and its use:
Expand Down Expand Up @@ -3377,12 +3376,13 @@ of the type.[^structtype]

New instances of a `struct` can be constructed with a [struct expression](#structure-expressions).

The memory order of fields in a `struct` is given by the item defining it.
Fields may be given in any order in a corresponding struct *expression*;
the resulting `struct` value will always be laid out in memory in the order specified by the corresponding *item*.
The memory layout of a `struct` is undefined by default to allow for compiler optimziations like
field reordering, but it can be fixed with the `#[repr(...)]` attribute.
In either case, fields may be given in any order in a corresponding struct *expression*;
the resulting `struct` value will always have the same memory layout.

The fields of a `struct` may be qualified by [visibility modifiers](#re-exporting-and-visibility),
to restrict access to implementation-private data in a structure.
to allow access to data in a structure outside a module.

A _tuple struct_ type is just like a structure type, except that the fields are anonymous.

Expand Down Expand Up @@ -3933,7 +3933,7 @@ The runtime provides C and Rust code to assist with various built-in types,
such as vectors, strings, and the low level communication system (ports,
channels, tasks).

Support for other built-in types such as simple types, tuples, records, and
Support for other built-in types such as simple types, tuples and
enums is open-coded by the Rust compiler.

### Task scheduling and communication
Expand Down