Course Notes

Grammar:

<var-decl>  ::= let <var-ident> = <expr>
              | let mut <var-ident> = <expr>
<var-ident> ::= ; snake_case ;

Variables are immutable by default. This is generally safer (mutability is the root of much evil). If you attempt to mutate an immutable variable, you'll get a compiler error. You can reuse (i.e., shadow) variable names with declarations.

Example:

let x = 1;
assert_eq!(x, 1);

We use the mut keyword to declare mutable variables, which are allowed to be reassigned/mutated.

Example:

let mut x = 1;
x = 2;
assert_eq!(x, 2);

Grammar:

<const-decl>  ::= const <const-ident> : <ty> = <expr>
<const-ident> ::= ; SCREAMING_SNAKE_CASE ;

Constants are like immutable variables except that:

• they are declared with the const keyword
• by convention, they are named using SCREAMING_SNAKE_CASE
• they must be type annotated (I don't know why yet)
• they must be assigned to a value that can be computed at compile-time (e.g., no stdin reads)

As in most PLs, constants are primarily useful for code clarity and maintenance.

Example:

const SPEED_OF_LIGHT : u32 = 299792458;
assert_eq!(SPEED_OF_LIGHT, 299792458);

Grammar:

<ty>          ::= <scalar-ty> | <compound-ty>
<scalar-ty>   ::= <int-ty> | <float-ty> | bool | char
<int-ty>      ::= <sint-ty> | <uint-ty>
<sint-ty>     ::= i16 | i32 | i64 | i128 | isize
<uint-ty>     ::= u16 | u32 | u64 | u128 | usize
<float-ty>    ::= f32 | f64
<compound-ty> ::= <tuple-ty> | <array-ty>
<tuple-ty>    ::= ( <tys> )
<tys>         ::= ϵ | <ty> | <ty> , <tys>
<array-ty>    ::= [<ty>；<usize-lit>]

Rust is statically typed, i.e., the type of every variable is known at compile-time. Rust does some amount of type inference (except for constant, it seems). When in doubt, type annotate variables. It doesn't hurt, and can act as a simple form of documentation.

There are two kinds of data types: scalar and compound. We'll do a quick outline of these types below, most of this should be familiar.

• Scalar:
  • Integers:
    • i8, i16, i32, i64, i128, and u8, u16, u32, u64, u128
    • The number indicates the number of bits used to represent the integer. The default for type inference is i32.
    • There is also isize and usize used for indexing
    • There are standard literals for decimal, hex, octal, binary, and bytes. Look them up if you need them.
    • Rust's compiler can check for integer overflow in debug mode, but wraps by default for release mode. We're gonna ignore this for now (as if we'll be writing any production code…)
  • Floating-point numbers:
    • f32 and f64. The default for type inference is f64.
    • Represented using IEEE-754 (of course)
  • Booleans:
    • type: bool
    • two literals: true and false
  • Characters:
    • type: char
    • example: 'q', '✗'
    • four bytes, represent unicode scalars (characters are weird but I don't care at the moment though)
• Compound:
  • Tuples:
    • type: (t1, t2,..., tk)
    • literal: (e1, e2,..., ek)

    • accessor: p.i

      Example:

      let tup: (i32, bool, u32) = (2, true, 2);
      assert_eq!(tup.1, true);
      

  • Arrays:
    • type: [t; n] where t is a type and n is a usize for the number of elements. IMPORTANT: Arrays are fixed length.
    • Arrays are allocated on the stack. Rust panics if an index is out of bounds (in particular, it actually checks at runtime).

    • indexing: a[i], where i is a usize.

      Example:

      const J : usize = 5;
      let a : [u32; J] = [1, 2, 3, 4, 5];
      let i : usize = 2;
      assert_eq!(a[i], 3);
      

Check here for details on operators, arithmetic, Boolean or otherwise. We will, of course, see more types as the course goes on (and define our own types).

Grammar:

<fun-decl>  ::= fn <fun-ident>(<params>) <block>
              | fn <fun-ident>(<params>) -> <ty> <block>
<params>    ::= ϵ | <param> | <param> , <params>
<param>     ::= <var-ident> : <ty>
<block>     ::= { <stmts> }
<fun-ident> ::= ; snake_case ;

Functions in Rust behave much like functions in other languages. A couple key notes:

• parameters must be type-annotated
• the return type must be given if the function returns a value

There is a return keyword, but we don't often use it; the return value is the last expression in the function block. If no last expression is given then the return value is () of type () (i.e., the unit type); see the <block> case in the given grammar for more details about how the bodies of functions might look (there's a bit of trickiness with regards to semicolons but I'm not going to dwell on it since the compiler is pretty good at catching these things).

Example:

fn sum_of_squares(x : u32, y : u32) -> u32 {
    let x_squared = x * x;
    let y_squared = y * y;
    x_squared + y_squared
}

Grammar:

<stmts>      ::= ϵ
               | <expr>
               | <fun-decl> <stmts>
               | <stmt> ；<stmts>
               | <expr> ；<stmts>
               | <expr-no-sc> <stmts>
<stmt>       ::= <var-decl> | <const-decl>
<expr-no-sc> ::= <if-expr> | <while-expr> | <for-expr>
<expr>       ::= <block>
               | <lit>
               | <uop-expr>
               | <bop-expr>
               | <call-expr>
               | ( <expr> )
<lit>        ::= <int-lit> | <float-lit>
               | <char-lit> | bool-lit>
<int-lit>    ::= ; see docs ;
<float-lit>  ::= ; see docs ;
<char-lit>   ::= ; see docs ;
<bool-lit>   ::= true | false
<uop-expr>   ::= <uop> <expr>
<bop-expr>   ::= <expr> <bop> <expr>
<uop>        ::= ; see docs ;
<bop>        ::= ; see docs ;
<call-expr>  ::= <fn-ident>(<exprs>);
<exprs>      ::= ϵ | <expr> | <expr> , <exprs>

Statements perform actions and do not have a value. Expressions have values, and are evaluated. The only statements we've seen so far are declarations. Any expression can be assigned to a variable (you should check this, it works even for things like while expressions).

Use them or don't, I don't really care.

Example:

// a comment
// another comment

Grammar:

<if-expr>      ::= if <expr> { <stmts> } <else-if-expr>
<else-if-expr> ::= ϵ | else { <stmts> } | else if { <stmts> } <else-if-expr>
<while-expr>   ::= while <expr> { <stmts> }
<for-expr>     ::= for <var-ident> in <expr> { <stmts> }

Control flow is also pretty standard. A couple things to keep in mind:

• control flow is defined by expressions. This means they can be used as the values of variables; this is particularly nice for if-expressions
• the then-case and the else-case blocks must be the same type

• there are two kinds of memory we need to think about: stack and heap
  • We won't care too much about this except up to it's usefulness as an analogy.
  • Stack memory is simple. If all we needed to do was work with the stack, then we wouldn't be having this conversation.
    • The restriction: the stack needs to have fixed size.
      • I still don't really know why, why not store dynamic sized memory on the stack? (Let's just assume this)
  • The heap is less organized
    • You must request space, and it must be allocated, you work with a pointer to the memory.
    • In rust we won't often think in terms of pointers, this is part of the point
  • pushing to the stack is faster, accessing is faster, but data must be fixed size, and is ephemeral. Why would we want to put anything on the stack? If it's size can change, or if it needs to persist
  • The problem: if we put things on the heap, we need to know when we can deallocate to free up memory.
    • In C, you have to do this by hand
    • In modern programming languages, there is so-called garbage collecting
    • In Swift, there is automatic reference counting
      • What are the benefits of GC? Not sure. I think it's a bit of magic.
    • We also don't want to DUPLICATE
• The main idea: every value has a single owner (variable). When the owner goes out of scope, so does the value.
  • This requires carefully understanding scope.
    • The scope of a variable is: after it is declared up to the end of the block in which it is declared.
    • expression which update must be updating something on the heap

• Rust automatically calls drop function when a any variable goes out of scope
• (We should say something about static memory)
• Values which implement the Copy trait are types which can be copied assignment, no moving.
• There are three things: copy, move, (mutable) borrow
• Exercise how can we implement the swap function? (We can't really)