Introduction

Last week, we discussed about memory allocation in programming languages and the notion of scope in programming languages.
We talked about what was involved in terms of memory allocation when a subroutine is called and we discussed how objects memory might be dynamically allocated from the run time heap for strings, arrays, objects, etc.
Next we looked at what name value bindings a language supported and at the textual regions in code where the bindings would be active (scope).
We discussed how static scope is implemented in BASIC, Fortran, and C.
We gave an example of the differences between static and dynamic scope.
Finally, we started introducing the Rust programming language. We said that the way it handles memory allocation is interesting (different from C/C++, and Java), and it also has interesting features in terms of scope rules.
Today, we continue our discussion of Rust...

Lexicon

Rust programs are assumed to be written in Unicode encoded as UTF-8.
Rust keywords are divided into three categories:
1. Strict - Keywords that can only be used in their correct context: Variables, names of things in a crate (Rust version of package) or crate name, fields names in struct's, type parameters, labels, macros.
2. Reserved - Keywords that are not currently used by Rust, but might be in a future version: abstract, become, box, do, final, macro, override, priv, try, typeof, unsized, virtual, yield
3. Weak - Keywords have special meaning only in certain contexts. For example, it is possible to declare a variable named union even though the keyword union can be used to declare union types.
Identifiers such as for variable names can begin with a non-numeric letter/ideograph character (XID_Start symbols) followed by zero or more of the same and/or numbers (XID_Continue symbols). For example: my_variable1, mon_itérateur, 我的变量1
```
fn main() {
    let 我的变量1 = "hello";
    println!("{}, world!", 我的变量1);
}
```

Comments in Rust

Like C++, you can use either // for single line comments or /* */ for multi-line comments.
Like Java, Python, PHP, etc, Rust has a notion of documentation comment which can be used to make HTML documentation for your project.

For a documentation comment that you would like to apply to the current scope, you can use /// for a single line comment or /** ... */ for a multi-line comment:

/// #Using Markdown this is an H1 heading comment describing the super_awesome function
///
/// As you might expect, the super_awesome does something awesome.
fn super_awesome {
  // code for super_awesome.
}

For a documentation comment that you would like to apply to the parent scope, you can use //! for single line comments, or /*! ... */ for multi-line comments:
```
//! #My Crate
//!
//! `my_crate` is a collection structs hand-crafted from 1's and 0's
```
You can extract the documentation using:
```
rustdoc name_of_rust_file.rs
```
This will create a doc folder and if you point your browser to the subfolder for the name of the file, you can see the documentation generated.
Alternatively, if you are using cargo and want to make the documentation for your project you can use:
```
cargo doc
```
Then to see the documentation:
```
cargo doc --open
```

Variables - Immutability and Mutability

By default, variables in Rust are immutable. That is, after we assign a variable a value, we cannot change it. For example,

fn main () {
  let x = 7;
  x = x + 1;
  println!("The value of x is: {}", x);
}

would give the error:

error[E0384]: cannot assign twice to immutable variable `x`
 --> immutable_test.rs:3:3
  |
2 |   let x = 7;
  |       -
  |       |
  |       first assignment to `x`
  |       help: consider making this binding mutable: `mut x`
3 |   x = x + 1;
  |   ^^^^^^^^^ cannot assign twice to immutable variable

We can think of a line beginning with let as introducing a new scope in which variables from outer scopes are visible unless shadowed by the inner scope. So the following is legal:

fn main () {
  let x = 7;
  let x = x + 1; // On the right hand, x is from outer scope. On the left hand,
                 // it is a new shadowing variable for x from the new let scope
  println!("The value of x is: {}", x);
}

Alternatively, we can explicitly tell Rust that a variable can be changed using the mut keyword:
```
fn main () {
  let mut x = 7;
  x = x + 1; 
  println!("The value of x is: {}", x);
}
```

Types in Rust

When we create a variable in Rust, we can explicitly indicate its type using the syntax:

let name_of_variable : some_type = some_value;

For example,

let x:u32 = 755; // x will be a 32 bit unsigned int

Rust has a strong static type system -- so every variable has a specific type.

Rust, however, uses type inference to try to guess the types of variables, etc., even if we don't explicitly state them. Only if it can't determine the type, will it give an error. For example:

use std::any::type_name;

fn type_of(_: T) -> &'static str { //magic for now
    type_name::()
}

fn main () {
  let x = 7; // since 7 is of type i32, x will be inferred to be of type i32
  println!("The value of x is: {} and its type is {}", x, type_of(x));
}

Primitive Types

Rust supports four primitive type:
1. Boolean - This type has two literals: true and false.
```
let flag:bool;
flag = true; 
```
2. Numeric - One of u8, u16, u32, u64, u128, or usize (platform default) (unsigned int's); or i8, i16, i32, i64, i128 or isize(signed int's); or f32 or f64 (floats)
3. Textual - One of char (32 bit unsigned Unicode 32 word) or str (dynamically sized string - a sequence of unsigned 8 bit numbers representing a UTF-8 encoded string).
4. Never - The never type ! is a type with no values, representing the result of computations that never complete (will talk about later).

Constants and Statics in Rust

A constant in Rust is an immutable, not reassignable value.

Here is an example of declaring and using a constant:

const FOO: i32 = 37; //type of constant must be declared

fn main() {
   println!("{}", FOO);
   /* 
   let FOO = 77; // this would cause an error if not commented out as
                 // can't reassign a constant
   println!("{}", FOO);
   */
}

Rust supports a notion of static variable.
```
static FOO: u32 = 37;
```
Such a variable has lifetime the duration of the program and the variable refers to a fixed location in memory.
Unlike constants, a static variable name can be reassigned and can be mutable.

Quiz

Which of the following statements is true?

Runtime heaps are typically used to manage local variables for function calls.
C is a dynamically scoped language.
C supports nested blocks.

Expressions

Rust supports a variety of different kinds of expressions: literal expressions (for numeric or string literals), path expressions (for a local variable or an item), block expressions (for control flow), etc.
Since we just talked about primitive types, we will consider literal expressions and operator expressions using these types.

Below are some literal expressions, for numeric and textual types:

"hello"; // string type
'5'; // character type
5; // integer type

For operator expressions, when using a numeric type, you can use the operators +, *, -, /, % (remainder), & (logical and), | (logical or), ^ (XOR), << (shift left), >> (shift right). For example,
```
let x = (7+3) - 2;
```

Comparison operators: ==, !=, <, <=, >, >=. For example,

assert!(123 == 123); //assert! does nothing on true, gives backtrace on false
assert!("hello" <= "world");

Lazy Boolean Operators: ||, &&

let x = false || true; // true
let y = false && panic!(); // operator is lazy, since if left argument is false, 
                 // doesn't evaluate right. I.e., 'panic!()' not evaluated

Compound Assignment Expressions: +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=
Note: Rust does not have ++ or --.

Control Structures - if

If statements behave similar to in C, but don't put conditions in parentheses. For example,

use std::env; //use this to get command line arguments

fn main() {
  let args: Vec<_> = env::args().collect();
  if args.len() > 1 {
    let a:u32 = args[1].parse().unwrap(); //converts to int
    if a > 10 { //notice: no parentheses
      println!("a is big");
    } else if a <= 10 && a > 5 {
      println!("a is medium");
    } else {
      println!("a is small");
    }
  } else {
    println!("I need arguments");
  }
}

If can be used in a let statement, which has a similar meaning to the ?: operator in C:

fn main() {
  let condition = true;
  let number = if condition {
     5 //this is the return value of the block
  } else {
     6 // types of all branches must be same to work
  }
  println!("The value of number is: {}", number);
}

Control Structures - match

The analog of switch/case in Rust is the match statement:

let x = 4;
match x {
   1 => println!("one"),
   2 => println!("two"),
   3 => println!("three"),
   _ => println!("that number is too big!");
}

Control Structures - loop, while

The easy way to repeat a block of code in Rust is using loop:

fn main () {
   loop {
      println!("Say this over and over.");
   }
}

The above will print Say this over and over., again and again, indefinitely.
Rust supports the two keywords continue (skip to end of loop) and break (break out of current loop), Rust can also return a value from a loop much like we did with if statements of the previous slide:
```
fn main () {
   let mut i = 0;
   let x = loop {
      println!("Say this over and over.");
      if i > 10 {
         break i;
      }
      i+= 1;
   };
   println!("x = {}", x);
}
```

Rust also supports while loops in a similar fashion to C:

fn main () {
    let mut count_down = 10;
    while count_down > 0 {
        println!("{}!", count_down);
        count_down -= 1; 
    }
    println!("Blast Off!");
}

Control Structures - for

In Rust, for in some_range is the analog C/C++/Java style for loops:

fn main() {
   for i in 1..10 { //doesn't include 10
      println!("{}", i);
   }

   for i in 1..=10 { //includes 10
      println!("{}", i);
   }

   for i in (1..10).step_by(2) {
       //1 3 5 7 9
       println!("{}", i);
   }

   let m = 60;
   for i in m/2..m {
       //30, 31,..., 59
       println!("{}", i);
   }
}

Functions

We have already seen the main() function.

The general format for a function declaration is:

fn name_of_function(var1:type1, ... var_n:type_n) -> return_type {
   //code
   return some_value;
}