tuples: don't use unexplained concepts. Closes #45

Author: Jorge Aparicio

src/tuples/input.md

@@ -1,6 +1,7 @@
-A tuple is a collection of values of different types. Tuples are declared
-using parentheses `()`, and each tuple belongs to a type of the form
-`(T1, T2, ...)`. Function can use tuples to return multiple values.
+A tuple is a collection of values of different types. Tuples are constructed
+using parentheses `()`, and each tuple itself is a value with type signature
+`(T1, T2, ...)`, where `T1`, `T2` are the types of its members. Functions can
+use tuples to return multiple values, as tuples can hold any number of values.
 
 {tuples.rs}
 

src/tuples/tuples.rs

@@ -1,53 +1,28 @@
-// function that returns two values
-fn chimpanzees() -> (int, &str) {
-    (6, "Pan troglodytes")
-}
-
-fn elephants() -> (int, &str) {
-    (9, "Elephas maximus")
-}
+// tuples can be used as function arguments and as return values
+fn reverse(pair: (int, bool)) -> (bool, int) {
+    // `let` can be used to bind the members of a tuple to variables
+    let (integer, boolean) = pair;
 
-fn penguins() -> (int, &str) {
-    (4, "Spheniscus demersus")
-}
-
-fn wolves() -> (int, &str) {
-    (6, "Canis lupus")
-}
-
-// tuples can be function arguments
-fn show(pair: (int, &str)) {
-    // destructuring a tuple
-    let (amount, species) = pair;
-
-    println!("There are {} {}", amount, species);
+    (boolean, integer)
 }
 
 fn main() {
     // a tuple with a bunch of different types
     let long_tuple = (1u8, 2u16, 3u32, 4u64,
                       -1i8, -2i16, -3i32, -4i64,
                       0.1f32, 0.2f64,
-                      'a', "abc");
+                      'a', true);
 
     // values can be extracted from the tuple using the valN methods
     println!("long tuple first value: {}", long_tuple.val0());
     println!("long tuple second value: {}", long_tuple.val1());
 
-    // `let` can be used to bind a tuple members to variables
-    let pair = (3, 4);
-    let (x, y) = pair;
-    println!("x is {}, and y is {}", x, y);
+    // tuples can be tuple members
+    let tuple_of_tuples = ((1u8, 2u16, 2u32), (4u64, -1i8), -2i16);
 
-    // but you can also print a tuple directly
+    // tuples are printable
+    let pair = (1, true);
     println!("pair is {}", pair);
 
-    // a tuple of tuples
-    let tuple_of_tuples = ((1u8, 2u16, 2u32), (4u64, -1i8), -2i16);
-
-    println!("Animal inventory");
-    show(chimpanzees());
-    show(elephants());
-    show(penguins());
-    show(wolves());
+    println!("the reversed pair is {}", reverse(pair));
 }