Tuples
Structs
Tuple-structs
They are useful to group objects of different types.
At the end of the chapter, you’ll see some code style conventions.
The Tuples
This will print: 10000000, 183.19, Q.
The “data” variable is a composite object, as it is composed of three objects. Even arrays are composite objects, but they are constrained to be composed of objects of the same type, while the “data” variable is composed of objects of different types: an integer number, a floating-point number, and a character.
Therefore, our object is not an array but a tuple.
The declaration of tuples looks like that of arrays. The only difference is that round parentheses are used instead of square brackets.
Each item of a tuple is named field.
The type has the same format as the expression giving the value, where, for each field, the expression giving the value is replaced by its type.
As shown in the second statement, an entire tuple may be used to initialize another tuple of the same type.
You can access the fields of a tuple by their position, using the dot notation. When accessing the seventh item of the “arr” array, you must write “arr[6]”; to access the seventh field of the “data” tuple, you must write “data.6”.
This will print: -5, 183.19, x.
Similarly to arrays, tuples can also have any number of fields, including zero. Because to write the type of a tuple you write the sequence of the types of its fields, enclosed in parentheses, then, if there are no fields, only the parentheses remain. Therefore, to write the type of a tuple with no fields, you just write “().”
But in Chapter 6, we already saw this type and this value. So now it is explained why they are named empty tuples.
The compiler generates, at the last line, the error: no field `i` on type `({integer}, {integer}, {integer})`. There is no way to get the value of a field of a tuple using an index determined at runtime.
The Structs
Is it clear that this code will print 3?
This code is illegal. Can you spot the error?
This will print: 60, 10000000, 183.19, Q.
The first statement occupies six lines: it starts with the struct keyword and proceeds with a block. Its effect is to declare the SomeData type . Any object of that type is a sequence of four fields. For each field, its name and its type are declared, separated by a colon. The list of field declarations is comma separated, with an optional ending comma. Let’s name struct such a kind of data type.
Also the second statement occupies six lines. It declares the variable “data” and initializes it with an object of the type just declared. Notice that the initialization syntax looks like the type declaration syntax, where the struct keyword is removed, and each field type is replaced by an expression whose value is to be assigned to such a field. Let’s name struct-object such kind of an object, which is any object whose type is a struct.
The third statement accesses the fields of the just-defined struct-object, using the so-called dot notation . This notation consists of an expression representing the struct-object, followed by a dot, followed by the name of the field to access.
Let’s see where this C code differs from the preceding Rust code.
While in C the fields are separated by semicolons, in Rust they are separated by commas.
In Rust, the type is written after the name of the field, like in the Pascal language.
In C you can declare several fields of the same type, by specifying the type just once, that is, in this way: int a, b;. In Rust, instead, you must specify the type once for every field, in this way: a: i32, b: i32,.
In C the initialization of “data” is done simply by listing the values, similarly to Rust tuples. In Rust, instead, for each field you must specify also the name of that field.
Both in C and in Rust, the dot notation is used.
This will print: 8.2, 10.
The Tuple-Structs
Create a tuple, whose type has no name, it was not previously declared, and whose fields have no name.
Create a struct, whose type has a name, it must have been previously declared, and whose fields have a name.
This will print: Q, 10000000, 183.19, 250.
As shown in the example, the tuple-struct is defined before instantiating it, by using the keyword struct like for structs, but enclosing its fields in parentheses instead of braces, and without specifying the names of the fields, like for tuples. The initialization starts with the name of the type, like for structs, but it goes on like for tuples.
Its fields are accessed like those of tuples, because they have no name.
Differing from both tuples and structs, empty tuple-structs are not allowed.
Actually, tuple-structs are not used often.
Lexical Conventions
Now that we have seen a good deal of different Rust constructs (but not yet all of them), it is a good time to think about some lexical conventions adopted by almost every Rust programmer, so they are strongly recommended to everyone. Such conventions are so entrenched, that even the compiler emits a warning if they are violated.
Names of constants (for example: MAXIMUM_POWER) contain only uppercase characters, with words separated by underscore. This convention is usually named screaming snake case, or upper snake case, or simply upper case.
Type names defined by application code or by the standard library (for example: VehicleKind and VehicleData) and enum variant names (for example: Car) are comprised of words stuck together, where every word has an uppercase initial letter, followed by lowercase letters. This convention is usually named upper camel case or PascalCase.
Any other name (for example, keywords like let, primitive types like u8, and field identifiers like registration_year) use only lowercase letters, with words separated by underscores. This convention is usually named snake case.