12.1.1 What Choice Do Programmers Have?🔗

Consider two families of languages:

• C/C++:

  • Type-unsafe — pointer arithmetic, unchecked casts

  • Low-level control over memory layout and hardware

  • Performance over safety and ease of use

  • Manual memory management, e.g., with malloc/free

• Java, OCaml, Go, Ruby, …:

  • Type-safe — runtime type errors are prevented statically

  • High-level, less control over memory

  • Ease-of-use and safety over performance

  • Automatic memory management via garbage collection — no explicit malloc/free

Rust occupies the space in between: it offers low-level control and manual memory management without a garbage collector, while still being type-safe and thread-safe.

12.2.1 Rust in the Real World🔗

Rust is used in production by many organizations:

• Firefox Quantum and the Servo browser engine

• REmacs — a port of Emacs to Rust

• Amethyst game engine

• Magic Pocket filesystem from Dropbox

• OpenDNS malware detection components

12.2.2 Features of Rust🔗

Rust takes ideas from both functional and object-oriented languages, as well as recent programming-languages research:

• Lifetimes and Ownership — the key feature for ensuring memory and thread safety at compile time

• Traits as the core of the object(-like) system

• Variables are immutable by default

• Data types and pattern matching (like OCaml)

• Type inference — no need to write types for local variables

• Generics (aka parametric polymorphism)

• First-class functions

• Efficient C bindings

12.3.1 Installing Rust🔗

Rust can be installed via rustup, the official toolchain installer:

• On macOS or Linux, open a terminal and run:

  curl https://sh.rustup.rs -sSf | sh

• On Windows, download and run rustup-init.exe.

12.3.2 Rust Compiler and Build System🔗

Rust programs can be compiled directly using rustc:

• Source files use the .rs suffix.

• Compilation produces an executable by default (no -c option).

The preferred workflow is to use cargo, Rust’s package manager and build system:

• Invokes rustc as needed to build files.

• Downloads and builds dependencies automatically.

• Based on a .toml configuration file and a .lock file.

• Analogous to ocamlbuild or dune in OCaml.

12.3.3 Using cargo🔗

% cd hello_cargo
% cargo build
   Compiling hello_cargo v0.1.0 (file:///...)
   Finished dev [unoptimized + debuginfo] ...
% ./target/debug/hello_cargo
Hello, world!

The default src/main.rs contains:

Rust REPL

fn main() { 
      println!("Hello, world!"); 
 }

[Output]
Hello, world!

cargo can also run tests; we will discuss that later in the course.

12.3.4 Rust Interactively🔗

Unlike OCaml or Ruby, Rust has no top-level read-eval-print loop (REPL). For quick experiments, use the in-browser Rust Playground at https://play.rust-lang.org/.

12.3.5 Rust Documentation🔗

The official documentation is an excellent reference and learning resource:

• The Rust Book (The Rust Programming Language by Klabnik and Nichols) — most of our slides are based on this.

• The Rust Book With Quizzes (The Rust Programming Language With Quizzes by Klabnik and Nichols) — most of our slides are based on this.

• The reference manual.

• Short manuals on rustc, cargo, and more.

All of these are linked from https://doc.rust-lang.org/stable/.

12.4.1 Functions🔗

Functions are declared with the fn keyword. The entry point of every Rust program is main. println! is a macro (note the !):

Rust REPL

// comment 
 fn main() { 
      println!("Hello, world!"); 
 }

[Output]
Hello, world!

12.4.2 Let Statements🔗

Local variables are introduced with let. By default, variables are immutable:

{
  let x = 37;
  let y = x + 5;
  y
} //42

Attempting to assign to an immutable variable is a compile-time error:

{
  let x = 37;
  x = x + 5; //err
  x
}

To allow reassignment, declare the variable with mut:

{
  let mut x = 37;
  x = x + 5;
  x
} //42

Shadowing: Rust allows redefining a variable with a new let binding, which shadows the previous binding (similar to OCaml). This is different from mutation and should generally be avoided:

{
  let x = 37;
  let x = x + 5;  // shadows previous x
  x
} //42

Type annotations: Types are inferred by default. Optional annotations must be consistent with the inferred type (and may override the default numeric type):

{
  let x:i16 = -1;
  let y:i16 = x + 5;
  y
} //4

Trying to assign a value that is out of range for the declared type is an error:

{   //err:
  let x:u32 = -1;  // u32 cannot hold negative values
  let y = x + 5;
  y
}

12.4.3 Conditionals🔗

Rust conditionals look like C but the condition does not require parentheses. Braces { } around each branch are required:

Rust REPL

fn main() { 
    let n = 5; 
    if n < 0 { 
      print!("{} is negative", n); 
    } else if n > 0 { 
      print!("{} is positive", n); 
    } else { 
      print!("{} is zero", n); 
    } 
 }

[Output]
5 is positive

12.4.4 Conditionals Are Expressions🔗

Like OCaml, if/else in Rust is an expression, not just a statement. You can use it on the right-hand side of a let:

Rust REPL

fn main() { 
    let n = 5; 
    let x = if n < 0 { 
      10 
    } else { 
      20 
    }; 
    print!("x={:?}", x); 
 }

[Output]
x=20

Because if is an expression, both branches must have the same type. The following is a type error — the if branch has type i32 and the else branch has type &str:

let x = if n < 0 {
  10       // i32
} else {
  "a"     // &str  <-- type error
};

if x > 5 {
    println!("x is greater than 5");
}

if x > 5 {
    1  // i32, but else branch implicitly returns ()
}

12.4.5 Functions with Arguments and Return Types🔗

Functions take typed parameters and declare a return type after ->. The last expression in the body is the return value (no return keyword needed):

Rust REPL

fn fact(n:i32) -> i32 
 { 
    if n == 0 { 
       1 
    } else { 
      n * fact(n-1) 
    } 
 } 
 
 fn fact2(n:u32)->u32{ 
     let mut i = n; 
     let mut a = 1; 
     loop{   //infinite 
           if i < 1 {break;} 
           a = a * i; 
           i = i - 1; 
     } 
     a 
 } 
 
 fn fact3(n:u32)->u32{ 
     let mut a = 1; 
     for i in 1..n+1{ 
           a = a * i; 
     } 
     a 
 } 
 
 fn main() { 
    let res1 = fact(6); 
    let res2 = fact2(6); 
    let res3 = fact3(6); 
    println!("fact(6) = {},{},{}", res1,res2,res3); 
 }

[Output]
fact(6) = 720,720,720

12.4.6 Mutation and Iteration🔗

Mutation is useful when performing iteration, just as in C and Java. Rust provides an infinite loop construct that runs forever until you break out of it:

fn fact(n: u32) -> u32 {
  let mut x = n;
  let mut a = 1;
  loop {
    if x <= 1 { break; }  // infinite loop, break out
    a = a * x;
    x = x - 1;
  }
  a
}

12.4.7 Other Looping Constructs🔗

Rust also has while loops and for loops:

• while e block — loop while condition is true

• for pat in e block — iterate over a collection

for x in 0..10 {
  println!("{}", x); // x: i32
}

The range 0..10 produces integers from 0 up to (but not including) 10.

12.4.8 Loops Are Expressions🔗

Like if, all three looping constructs (loop, while, for) are expressions. loop returns the final computed value, or () if none. while and for always evaluate to (). A break may carry a value, which becomes the loop’s result:

let mut x = 5;
let y = loop {
  x += x - 3;
  println!("{}", x); // 7 11 19 35
  if x % 5 == 0 { break x; }
};
print!("{}", y); // 35

12.4.9 Scalar Types🔗

Rust’s primitive scalar types are:

• Integers — signed: i8, i16, i32, i64, isize; unsigned: u8, u16, u32, u64, usize. isize/usize are the machine word size. Default inferred type is i32.

• Characters — char, Unicode scalar values.

• Booleans — bool = {true, false}.

• Floating point — f32, f64 (default inferred is f64).

Arithmetic operators (+, -, etc.) are overloaded across numeric types, but operands must have the same type.

12.4.10 Compound Data: Tuples🔗

An n-tuple groups n values of possibly different types. The type of an n-tuple is written (t1, …, tn). unit () is simply the 0-tuple.

Tuple fields are accessed by index (.0, .1, …) or via pattern matching:

let tuple = ("hello", 5, 'c');
assert_eq!(tuple.0, "hello");
let (x, y, z) = tuple;

Patterns may appear directly in function parameters:

fn dist(s:(f64,f64), e:(f64,f64)) -> f64 {
  let (sx, sy) = s;
  let ex = e.0;
  let ey = e.1;
  let dx = ex - sx;
  let dy = ey - sy;
  (dx*dx + dy*dy).sqrt()
}

Equivalently, you can destructure in the parameter list:

fn dist2((sx,sy):(f64,f64), (ex,ey):(f64,f64)) -> f64 {
  let dx = ex - sx;
  let dy = ey - sy;
  (dx*dx + dy*dy).sqrt()
}

Rust structs (covered later) generalize tuples with named fields.

12.4.11 Arrays🔗

Arrays in Rust have a fixed length known at compile time. The type of an array of n elements of type T is [T;n]. Arrays can be mutable or immutable:

let nums = [1,2,3];          // type is [i32;3]
let strs = ["Monday","Tuesday","Wednesday"]; // [&str;3]
let x = nums[0];            // 1
let s = strs[1];            // "Tuesday"
let mut xs = [1,2,3];
xs[0] = 1;                  // OK, xs is mutable
let i = 4;
let y = nums[i];            // fails (panics) at run-time

Out-of-bounds indexing compiles successfully but causes a runtime panic.

To iterate over an array, use .iter(), which produces an iterator (similar to Java’s Iterator). The for loop calls .next() repeatedly until no elements remain — with no possibility of going out of bounds:

let a = [10,20,30,40,50];
for element in a.iter() {
  println!("the value is: {}", element);
}

12.4.12 Testing🔗

Testing in Rust is a first-class citizen — the testing framework is built into cargo, unlike most languages which require extra libraries (e.g., Minitest in Ruby, OUnit in OCaml, JUnit in Java).

Unit testing is for local or private functions. Place unit tests in the same file as your code, inside a module annotated with #[cfg(test)]. Each test function is marked #[test]:

fn bad_add(a: i32, b: i32) -> i32 {
  a - b
}

#[cfg(test)]   // this module contains tests
mod tests {
  #[test]      // this function is a test
  fn test_bad_add() {
    assert_eq!(bad_add(1,2), 3);
  }
}

Use assert! to check that a condition holds, and assert_eq! to check equality between two values that implement the PartialEq trait (e.g., integers, booleans). Traits are covered later.

Integration testing is for APIs and whole programs. Create a tests/ directory at the project root, with separate files for each major area of functionality. Integration test files do not need #[cfg(test)] or a special module, but each test function still needs #[test]. Tests treat the crate as an external library: import it with extern crate and bring items into scope with use.

12.5.1 GC-less Memory Management, Safely🔗

Rust manages heap memory without a garbage collector. The type checker ensures:

• No dangling pointers and no buffer overflows — unsafe idioms are rejected at compile time.

• Safety is enforced through two key concepts: ownership and lifetimes.

  • Every piece of data has a single owner. Immutable aliases are permitted, but mutation is only allowed through the owner or a single mutable reference.

  • How long data is alive is determined by its lifetime, tracked statically by the compiler.

12.5.2 Memory: the Stack and the Heap🔗

Recall the two memory regions:

• The stack — constant-time, automatic (de)allocation. Data size and lifetime must be known at compile time (function parameters and locals of fixed size).

• The heap — dynamically sized data with non-fixed lifetime. Slightly slower to access (via a pointer). Three strategies:

  • GC: automatic deallocation, but adds space/time overhead.

  • Manual (C/C++): low overhead, but non-trivial opportunity for devastating bugs — dangling pointers, double free, and other forms of memory corruption.

  • Rust: automatic deallocation triggered by scope exit, no GC.

In C, the programmer manually allocates and frees heap data:

// C
char *p = malloc(10);
...
free(p);   // p deleted from stack when function returns

In Java, objects live on the heap and are collected by the GC when no longer reachable:

// Java
String p = new String("rust");
...
p = null;  //GC will collect later

In Rust, heap data is freed automatically when its owner goes out of scope — no manual free, no GC:

// Rust
let p = String::from("hello");
...
// p deleted from stack when function terminates;
// heap data freed automatically

12.5.3 Rules of Ownership🔗

Rust’s ownership system rests on three rules, enforced at compile time:

1. Each value in Rust has a variable that is its owner.

2. There can only be one owner at a time.

3. When the owner goes out of scope, the value is dropped (freed).

String is Rust’s dynamically-sized, heap-allocated, mutable string type. When s goes out of scope, Rust automatically calls s.drop():

{
  let mut s = String::from("hello"); //s is the owner
  s.push_str(", world!");
  println!("{}", s);
} //s's data is freed by calling s.drop()

12.5.4 Assignment Transfers Ownership🔗

By default, assigning a heap value moves it — ownership transfers to the new variable, leaving the old variable invalid:

let x = String::from("hello");
let y = x; //x moved to y

After the move, only y is the owner; using x is a compile-time error:

println!("{}, world!", y); //ok
println!("{}, world!", x); //fails — x was moved

Why? Both x and y could otherwise point to the same underlying heap data. Allowing both to exist would risk a double free or use-after-free when either goes out of scope. The move ensures there is always exactly one owner.

12.5.5 The Copy Trait🔗

Primitive types — i32, char, bool, f32, tuples of these types, etc. — do not transfer ownership on assignment. Instead, assignment copies the entire value:

let x = 5;
let y = x;
println!("{} = 5!", y); //ok
println!("{} = 5!", x); //ok

This works because these types implement the Copy trait. Assigning a Copy type duplicates the object rather than moving it.

Traits

A trait is a way of saying that a type has a particular property:

• Copy — objects with this trait are copied on assignment rather than moved. Primitive types derive Copy automatically.

• Traits also specify functions a type must implement, similar to Java interfaces. For example:

  • Deref — indicates that an object can be dereferenced via the * operator; the compiler calls the object’s deref() method.

We will see more traits later in the course.

Cloning

If you need two independent copies of a heap value without losing ownership of the original, call .clone():

let x = String::from("hello");
let y = x.clone(); //x ownership not moved
println!("{}, world!", y); //ok
println!("{}, world!", x); //ok

Cloning avoids the loss of ownership but performs a full heap copy — use it deliberately, not as a default.

12.5.6 Ownership Transfer in Function Calls🔗

Ownership follows the same move semantics across function calls:

• Passing an argument moves ownership from the caller to the called function’s parameter.

• Returning a value moves ownership from the called function to the caller’s receiver.

fn main() {
  let s1 = String::from("hello");
  let s2 = id(s1);    //s1 moved to arg
  println!("{}", s2); //id's result moved to s2
  println!("{}", s1); //fails — s1 was moved
}

fn id(s: String) -> String {
  s // s moved to caller on return
}

Passing s1 to id moves it; s1 cannot be used afterwards. The returned value is moved into s2.

12.5.7 References and Borrowing🔗

Moving ownership into every function that needs to read a value would be cumbersome. Instead, you can lend a reference to a value without transferring ownership. This is called borrowing.

A reference is created with the & operator and is immutable by default:

Rust REPL

fn main() { 
    let s1 = String::from("hello"); 
    let len = calc_len(&s1); //lends reference 
    println!("the length of '{}' is {}", s1, len); 
 } 
 fn calc_len(s: &String) -> usize { 
    // s.push_str("hi"); //fails! refs are immutable 
    s.len()           // s dropped; but not its referent 
 }

[Output]
the length of 'hello' is 5

When s (the reference) is dropped at the end of calc_len, only the reference is dropped — the underlying s1 in main is unaffected.

12.5.8 Rules of References🔗

Rust enforces two rules about references at compile time:

1. At any given time you can have either — but not both — of:

   • One mutable reference, or

   • Any number of immutable references.

2. References must always be valid (the pointed-to value must not have been dropped).

These rules prevent data races and dangling pointers statically.

12.5.9 Borrowing and Mutation🔗

You can make an immutable reference to a mutable value. While the immutable reference is live, mutation of the original is disallowed:

{
  let mut s1 = String::from("hello");
  {
    let s2 = &s1;
    println!("String is {} and {}", s1, s2); //ok
    s1.push_str(" world!"); //disallowed while s2 alive
    println!("{}", s2); //otherwise, NLL (Non-Lexical Lifetimes) may drop s2 early
  } //drops s2
  s1.push_str(" world!"); //ok
  println!("String is {}", s1); //prints updated s1
}

12.5.10 Mutable References🔗

To allow mutation through a reference, use &mut instead of &. This is only permitted on mut variables:

let mut s1 = String::from("hello");
{
  let s2 = &s1;
  s2.push_str(" there"); //disallowed; s2 immut
} //s2 dropped
let s3 = &mut s1; //ok since s1 mutable
s3.push_str(" there"); //ok since s3 mutable
println!("String is {}", s3); //ok

12.5.11 Non-lexical lifetimes (NLL)🔗

let mut s = String::from("hello");
let r = &s;
println!("{}", r); // last use of r
s.push('!');       // OK with NLL

In practice, assume borrows last to the end of scope. Use inner scopes or drop() to end them early.

12.6.1 String Representation🔗

Rust’s String type is represented internally as a 3-tuple on the stack:

• A pointer to a heap-allocated byte array (interpreted as UTF-8)

• A current length (number of bytes used)

• A maximum capacity (number of bytes allocated)

The invariant length ≤ capacity always holds. When the capacity is exhausted and more data is pushed, Rust reallocates a larger buffer. When the owner is dropped, the pointed-to heap data is freed automatically.

let mut s = String::new();
println!("{}", s.capacity()); // 0
for _ in 0..5 {
  s.push_str("hello");
  println!("{},{}", s.len(), s.capacity());
}
// prints: 0 / 5,5 / 10,10 / 15,20 / 20,20 / 25,40

Capacity doubles when exhausted, so reallocation is amortized O(1) per push.

12.6.2 UTF-8 and Rust Strings🔗

Rust strings are UTF-8 encoded. UTF-8 is a variable-length encoding:

• The first 128 characters (US-ASCII) use one byte each.

• The next 1,920 characters use two bytes, covering most Latin-script alphabets.

• Up to four bytes for all Unicode code points.

Because a character may span multiple bytes, direct indexing of a String is rejected by the compiler — you could land in the middle of a multi-byte character:

let s1 = String::from("hello");
let h = s1[0]; // rejected

Use slices or character iterators instead.

12.6.3 Slices🔗

A slice is a reference to a contiguous subsequence of a collection’s data — it shares the underlying bytes without copying them. A slice stores a pointer and a length but no capacity.

For a String s, the notation &s[range] creates a string slice of type &str:

• &s[i..j] — bytes from index i up to (but not including) j

• &s[i..] — bytes from i to the end

• &s[..j] — bytes from 0 to j

• &s[..] — the entire string as a slice

&str is the type of a String slice (and of string literals).

pub fn first_word(s: &String) -> &str {
  for (i, item) in s.char_indices() {
    if item == ' ' {
      return &s[0..i];
    }
  }
  s.as_str()
}

let mut s = String::from("hello world");
let word = first_word(&s); //borrow
s.clear(); // Error! Can't take mut ref while word alive
println!("{word}");

// ok: two immutable slices
let b = &s[..];
let c = &s[..];
print!("{}{}", b, c);

// error: two mutable slices
let b = &mut s[..];
let c = &mut s[..]; //error
print!("{}{}", b, c);

let s: &str = "hello world";

fn first_word(s: &str) -> &str { ... }

12.6.4 Vectors🔗

Vec<T> is Rust’s dynamically-sized, heap-allocated array — analogous to ArrayList<T> in Java. All elements must have the same type.

{
  let mut v: Vec<i32> = Vec::new();
  v.push(1);          // adds 1 to v
  v.push("hi");      // error — v contains i32s
  let w = vec![1, 2, 3]; // vec! is a macro
} // v, w and their elements dropped

Indexing can be done in two ways:

• &v[i] — returns a reference; panics at runtime if out of bounds.

• v.get(i) — returns Option<&T>; returns None if out of bounds instead of panicking.

let v = vec![1, 2, 3, 4, 5];
let third: &i32       = &v[2];        //panics if OOB
let third: Option<&i32> = v.get(2);  //None if OOB

let v = vec![1, 2, 3, 4, 5];
let third: Option<&i32> = v.get(2);
let z = match third {
  Some(i) => Some(i + 1), //matches here
  None    => None
};

let mut a = vec![10, 20, 30, 40, 50];
let p = &mut a[1]; //mutable borrow
*p = 2;            //updates a[1]
println!("vector contains {:?}", &a);
println!("{p}");

let mut a = vec![10, 20, 30, 40, 50];
let p = &mut a[1]; //mutable borrow
*p = 2;            //updates a[1]
println!("vector contains {:?}", &a);

let mut v = vec![100, 32, 57];
for i in &v     { println!("{}", i); }  // immutable
for i in &mut v { *i += 50; }            // mutable

let a = vec![10, 20, 30, 40, 50];
let b = &a[1..3]; //[20, 30]
let c = &b[1];    //30
println!("{}", c); //prints 30

12.6.5 HashMaps🔗

HashMap<K,V> is Rust’s generic hash table, mapping keys of type K to values of type V. Key methods:

• new() : () -> HashMap<K,V> — create an empty map

• insert(k, v) : (K,V) -> Option<V> — insert a key-value pair; returns the old value wrapped in Some, or None if the key was absent

• get(&k) : (&K) -> Option<&V> — look up a key; returns a reference to the value or None

12.6.6 Primitive Data Conversion with as🔗

Unlike C, Rust performs no implicit numeric conversions. To convert between primitive types use the as keyword:

Rust REPL

fn main() { 
      let decimal = 65.4321_f32; //floating point number 
 
      //let integer: u8 = decimal; //error: no auto-convert 
 
      // Explicit conversion 
      let integer   = decimal as u8;   // explicit conversion 
      let character = integer as char; 
      println!("Casting: {} -> {} -> {}", decimal, integer, character); 
 }

[Output]
Casting: 65.4321 -> 65 -> A

Conversion truncates towards zero; wrapping and saturation rules apply for out-of-range values.

12.7.1 Structs🔗

A struct groups named fields under a single type. By convention, struct names use CamelCase.

println!("rect1 is {}", rect1);
// error[E0277]: the trait bound `Rectangle: std::fmt::Display`
//               is not satisfied

struct MutablePoint {
    x: mut i32, // error: expected type, found keyword `mut`
    y: mut i32,
}

let mut point = Point { x: 0, y: 0 };
point.x = 5;  // ok — the binding is mut

12.7.2 Methods🔗

Methods are defined in an impl block associated with a struct. The first parameter is always self, which refers to the instance. The ownership rules determine how self is passed:

• &self — read-only borrowed reference (preferred for non-mutating methods)

• &mut self — mutable borrowed reference (needed to modify fields)

• self — takes full ownership (rare; consumes the instance)

Rust REPL

struct Rectangle { 
      width:  u32, 
      height: u32, 
 } 
 
 impl Rectangle { 
      fn new(width: u32, height: u32) -> Rectangle { 
          return Rectangle { width, height }; //name match 
      } 
      fn area(&self) -> u32 { 
          self.width * self.height 
      } 
 } 
 fn main() { 
      let rect1 = Rectangle::new(30, 50); 
      println!("The area is {} pixels.", rect1.area()); 
 }

[Output]
The area is 1500 pixels.

Methods are called with dot syntax: rect1.area(). If the method takes additional arguments, pass them inside the parentheses: rect1.area(3).

12.7.3 Generic Lifetimes in Structs🔗

When a struct holds a reference rather than an owned value, Rust requires a lifetime annotation on the reference field. The annotation tells the compiler how long the referenced data must remain valid relative to the struct:

struct ImportantExcerpt<'a> {
    part: &'a str,
}

fn main() {
    let novel = String::from("Generic Lifetime");
    let i = ImportantExcerpt { part: &novel };
}

Here ’a is a lifetime parameter. It says: an ImportantExcerpt cannot outlive the string slice stored in part. The lifetime of i is inferred by the compiler (lifetime elision) — you rarely need to write it manually at call sites.

The lifetime parameter must also appear on the impl block:

impl<'a> ImportantExcerpt<'a> {
    fn level(&self) -> i32 {
        3
    }
}

The <’a> after impl is a lifetime parameter — analogous to a generic type parameter in Java. The compiler can often infer it.

12.7.4 Enums🔗

Enums define a type with a fixed set of variants, each of which can carry data. They are equivalent to OCaml datatypes (algebraic data types).

enum IpAddr {
    V4(String),
    V6(String),
}

let home     = IpAddr::V4(String::from("127.0.0.1"));
let loopback = IpAddr::V6(String::from("::1"));

type ip_addr = V4 of string | V6 of string
let home     = V4 "127.0.0.1"
let loopback = V6 "::1"

impl IpAddr {
    fn call(&self) {
        // method body defined here
    }
}

let m = IpAddr::V6(String::from("::1"));
m.call();

struct Ipv4Addr { /* details elided */ }
struct Ipv6Addr { /* details elided */ }

enum IpAddr {
    V4(Ipv4Addr),
    V6(Ipv6Addr),
}

12.8.1 Standard Traits🔗

Several traits appear throughout the standard library and have been mentioned in earlier sections:

• Clone — the type has a clone() method that produces a deep copy

• Copy — assignment copies the value instead of moving it (no ownership transfer); holds for primitive types and types whose fields are all Copy

• Deref — the type can be dereferenced with *; the compiler calls deref() automatically

• Display — the type can be converted to a human-readable string via "{}" in format macros

• PartialOrd — the type supports comparison operators (<, >, etc.)

Rust REPL

#![allow(unused_variables)] 
 #![allow(dead_code)] 
 trait HasArea { 
      fn area(&self) -> f64; 
 } 
 struct Circle { 
      x: f64, 
      y: f64, 
      radius: f64, 
 } 
 impl HasArea for Circle { 
      fn area(&self) -> f64 { 
          std::f64::consts::PI * (self.radius * self.radius) 
      } 
 } 
 
 struct Square { 
      x: f64, 
      y: f64, 
      side: f64, 
 } 
 
 impl HasArea for Square { 
      fn area(&self) -> f64 { 
          self.side * self.side 
      } 
 } 
 // This example shows how Rust uses traits + generics to achieve 
 // polymorphism (different types sharing the same behavior). 
 fn print_area<T: HasArea>(shape: T) { 
      println!("This shape has an area of {}", shape.area()); 
 } 
 
 fn main() { 
      let c = Circle { 
          x: 0.0f64, 
          y: 0.0f64, 
          radius: 1.0f64, 
      }; 
 
      let s = Square { 
          x: 0.0f64, 
          y: 0.0f64, 
          side: 1.0f64, 
      }; 
      print_area(c); 
      print_area(s); 
 }

[Output]
This shape has an area of 3.141592653589793
This shape has an area of 1

The following function finds the largest element in a slice of any type T, provided T implements both PartialOrd (needed for >) and Copy (needed so that assigning item to largest copies rather than moves):

Rust REPL

fn largest<T: PartialOrd + Copy>(list: &[T]) -> T { 
      let mut largest = list[0]; 
      for &item in list.iter() { 
          if item > largest { 
              largest = item; 
          } 
      } 
      largest 
 } 
 
 fn main() { 
      let number_list = vec![34, 50, 25, 100, 65]; 
      let result = largest(&number_list); 
      println!("The largest number is {}", result); 
 
      let char_list = vec!['y', 'm', 'a', 'q']; 
      let result = largest(&char_list); 
      println!("The largest char is {}", result); 
 }

[Output]
The largest number is 100
The largest char is y

Output:

The largest number is 100
The largest char is y

PartialOrd is required to use >; Copy is required because largest = item inside the loop would otherwise move item out of the slice, which is not permitted.

12.9.1 Closures and Local Functions🔗

Rust supports both local functions and closures. The key difference is that closures may capture variables from the surrounding environment, while local functions cannot:

fn moveit(l: bool, x: i32) -> i32 {
    let left  = |x| x - 1;          // closure: may capture env
    fn right(x: i32) -> i32 { x+1 } // local fn: no environment
    if l { left(x) }
    else { right(x) }
}

The OCaml equivalent uses anonymous functions for both:

let moveit l x =
  let left  = fun x -> x - 1 in
  let right = fun x -> x + 1 in
  if l then left x
       else right x

Closure syntax in Rust uses vertical bars for the parameter list: |x| body.

12.9.2 Limits of Type Inference for Closures🔗

Rust infers monomorphic types for closures — a closure is fixed to one concrete type once it is first used:

let id = |x| x;
let x  = id(1);    // infers id : i32 -> i32
let y  = id("hi"); // fails: &str ≠ i32

This contrasts with OCaml, which infers polymorphic types:

let f = fun x -> x  (* 'a -> 'a *)
let x = f 1    (* OK *)
let y = f "hi" (* OK *)

Because Rust closures are monomorphic, a closure cannot be reused at different types. Use a generic function with a trait bound (see below) to achieve polymorphic behaviour.

The following complete program shows both ideas together. moveit uses local fn definitions (not closures) for left and right; the commented line shows the closure alternative. Then main demonstrates monomorphism: after id(1) fixes the type to i32, calling id("hi") fails at compile time:

fn moveit(l: bool, x: i32) -> i32 {
    // let left = |x| x - 1;  // closure alternative
    fn left(x: i32) -> i32 { x - 1 }
    fn right(x: i32) -> i32 { x + 1 }
    if l { left(x) }
    else { right(x) }
}

fn main() {
    let t = moveit(false, 100);
    println!("{}", t);     // 101

    let id = |x| x;
    let x = id(1);        // infers id: i32 -> i32
    let y = id("hi");    // fails: &str ≠ i32
}

12.9.3 The Iterator Trait🔗

Iteration in Rust is built on the Iterator trait. Calling .iter() on a collection returns a value that implements Iterator:

let a = vec![10, 20, 30, 40, 50];
for e in a.iter() {
    println!("the value is: {}", e);
}

The trait is defined as:

trait Iterator {
    type Item;                                   // associated type
    fn next(&mut self) -> Option<Self::Item>;
    // ... default method implementations
}

type Item is an associated type — a type placeholder that each implementation fills in concretely (e.g., type Item = &i32 for a Vec<i32> iterator).

12.9.4 Unpacking for🔗

A for loop is syntactic sugar for repeatedly calling next on a mut iterator until it returns None:

let a = vec![10, 20];
let mut iter = a.iter();
assert_eq!(iter.next(), Some(&10));
assert_eq!(iter.next(), Some(&20));
assert_eq!(iter.next(), None);