Rust by Example

Slices are similar to arrays, but their length is not known at compile time. Instead, a slice is a two-word object, the first word is a pointer to the data, and the second word is the length of the slice. The word size is the same as usize, determined by the processor architecture eg 64 bits on an x86-64. Slices can be used to borrow a section of an array, and have the type signature &[T].

use std::mem;

// This function borrows a slice

fn analyze_slice(slice: &[i32]) {

println!("first element of the slice: {}", slice[0]);

println!("the slice has {} elements", slice.len());

}

fn main() {

// Fixed-size array (type signature is superfluous)

let xs: [i32; 5] = [1, 2, 3, 4, 5];

// All elements can be initialized to the same value

let ys: [i32; 500] = [0; 500];

// Indexing starts at 0

println!("first element of the array: {}", xs[0]);

println!("second element of the array: {}", xs[1]);

// `len` returns the count of elements in the array

println!("number of elements in array: {}", xs.len());

// Arrays are stack allocated

println!("array occupies {} bytes", mem::size_of_val(&xs));

// Arrays can be automatically borrowed as slices

println!("borrow the whole array as a slice");

analyze_slice(&xs);

// Slices can point to a section of an array

// They are of the form [starting_index..ending_index]

// starting_index is the first position in the slice

// ending_index is one more than the last position in the slice

println!("borrow a section of the array as a slice");

analyze_slice(&ys[1 .. 4]);

// Out of bound indexing causes compile error

println!("{}", xs[5]);

}

הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Custom Types

Rust custom data types are formed mainly through the two keywords:

   • struct: define a structure

   • enum: define an enumeration

Constants can also be created via the const and static keywords.

Structures

There are three types of structures ("structs") that can be created using the struct keyword:

   • Tuple structs, which are, basically, named tuples.

   • The classic C structs

   • Unit structs, which are field-less, are useful for generics.

#[derive(Debug)]

struct Person {

name: String,

age: u8,

}

// A unit struct

struct Unit;

// A tuple struct

struct Pair(i32, f32);

// A struct with two fields

struct Point {

x: f32,

y: f32,

}

// Structs can be reused as fields of another struct

#[allow(dead_code)]

struct Rectangle {

// A rectangle can be specified by where the top left and bottom right

// corners are in space.

top_left: Point,

bottom_right: Point,

}