More Rust Basics

Writing Programs

• Programs look a lot like any imperative language

• Can't have mutable global variables (kind of)

• Assignment is done with let statement, needn't provide types (static type inference)

• Types must agree completely, conversions are explicit with as or conversion functions

• Blocks must be bracketed. (Brackets and parens are kind of interchangeable)

• Semicolon is statement separator; optional null statements and expressions (comma)

• Last expression in block is value of that block

• if statement is ternary expression

• Fairly normal-looking while and for

• match is switch equivalent

• Functions have reasonable declaration syntax using fn

Rust Datatypes

• Emphasis on safe, efficient, simple

• Type system borrows heavily from all the other parametric/template type systems out there

• "Borrow checker" tangled in with the type system statically checks lifetimes

Fundamental Datatypes

• Unit type: ()

• Boolean type: bool (true, false)

• Integer types:

  • i8, u8, i16, u16, i32, u32, i64, u64, i128, u128
  • isize, usize

• Floating types: f32, f64

• Character type: char

  • 32-bit Unicode code point
  • Conversion-to implies checking: from_u32 vs from_u32_unchecked
  • Strings are UTF-8, so not array of char

• These types can be copied implicitly

• Numeric literals can have type suffix e.g. 0u64, underbars e.g. 1_000_000_u64

Data Structuring

• Tuple types e.g. (u8, char, f64)

• Structure types e.g. struct { x: u8, y: char }

• Enumerated types e.g. enum { X, Y(char) }

• Arrays with size e.g. [u16;12] type,

• References to things e.g. &mut [int;12]

• Box and Vec types

• Functions and closures are complicated

• Strings are complicated (!)

Tuples

• Fixed number of values of diverse type

    (u64, f64, char)
  

  with obvious value representation

    let t = (12, 1.2, 'x');
  

• Great for e.g. multiple return values, points

• Copyable if elements are

• Pattern-matching syntax

• Accessible by dot-index

Structs

• Fairly standard structure syntax with colons

    struct Point {
        x: u64,
        y: u64,
    }
  

  initialized as they look

    let p = Point { x: 12, y: 20 };
  

  with all kinds of super-secret shortcuts (see book)

• Structs can have an "implementation"

    impl Point {
        fn x_coord(&self) -> u64 {
            self.x
        }
    }
  

  for OO-like syntax and vaguely OO semantics

    let px = p.x_coord();
  

Enums

• Fairly simple

    enum Color {
        Red,
        Green,
        Blue,
        Custom(f64, f64, f64),
    }
  

• "Disjoint union" / "sum type": value of this type is one of the above. Note that variants can contain values

    let c = Color::Custom(0.7,0.5,0.3);
  

Arrays

• Rust arrays have their size encoded in the type

    [u64;3]
  

• Can create with list of values

    let a = [1,2,3];
  

  or with constant value

    let a = [0u64;3];
  

  but cannot be created uninitialized

• Array lookup and assignment work as expected

    a[2] = 7;
    a[2] + 1
  

• Array indices are always bounds-checked

References

• When you stick an & in front of a thing, you get a "sort of pointer" to that thing

• For arrays, for example, you get a "fat pointer" that keeps track of the position in the array and the length of the resulting "slice"

    let a = [1,2,3,4];
    let ar = &a[2..3];
    println!("{}", (*ar)[0]);
    let b = a.clone();
  

• That last bit of syntax is obnoxious: fortunately, things are derefed automatically mostly

    println!("{}", ar[0]);
  

• Much more to say next week about references

Box

• Causes storage to be allocated (think malloc)

    let b = Box::new(5);
  

• Boxes can be treated like references

• Boxes can be passed around and stuff

• Much more next week

Vec

• Like Box, but for arrays

• Can create with Vec::new() or the vec! macro

    let v = Vec::new();
    let w = vec![1,2,3];
  

Strings

• Representation is UTF-8 stored as sequence of u8

    "h\u{1F980}ello"
  

• However, protected so that invalid UTF-8 cannot be stored

• Two types: str is UTF-8-safe array, String is like Vec but UTF-8 safe

• There's lots of automatic interconversion between stuff to try to make this mess right

• You probably want to skip ahead to ch 17 (why?) and skim that

Book Example: Iron-GCD

• Turn the command-line app into a webapp

• There are a lot of neat web frameworks in Rust

• Performance is pretty good

Book Example: Mandelbrot

• Shows use of external crate via module interface

• Shows performance of Rust

• Concurrency!