Chapter 2. - Rust Data

use std::fmt::{Debug};

#[allow(dead_code)]
pub fn run () {

  /*-- fully specified --*/
  let i:i32 = 5;
  let f:f64 = 3.4;
  let a:[f32; 5] = [1.0, 1.5, 2.0, 1.5, 1.0];
  let t:(i32, f64, String) = (1, 2.0, "three".to_string());
  #[derive(Debug)]
  struct S{i:i32, s:&'static str, };
  let s:S = S{i:15, s:"a literal string" };
  #[derive(Debug)]
  enum E {BS(String), MS(String), PhD(String),};
  let e:E = E::MS("Computer Engineering".to_string());

  print!("\n  -- fully specified types --\n");
  print!("\n  i = {:?}", i);
  print!("\n  f = {:?}", f);
  print!("\n  a = {:?}", a);
  print!("\n  t = {:?}", t);
  print!("\n  s = {:?}", s);
  print!("\n  e = {:?}", e);

  /*-- using type deduction --*/
  let i = 5;
  let f = 3.4;
  let a = [1.0, 1.5, 2.0, 1.5, 1.0];
  let t = (1, 2.0, "three".to_string());
  let s = S{i:15, s:"a literal string" };
  let e = E::MS("Computer Engineering".to_string());

  print!("\n\n  -- using type deduction --\n");
  print!("\n  i = {:?}", i);
  print!("\n  f = {:?}", f);
  print!("\n  a = {:?}", a);
  print!("\n  t = {:?}", t);
  print!("\n  s = {:?}", s);
  print!("\n  e = {:?}", e);
}

fn main() {

  main_title("string_probes");
  putlinen(2);

  /*-- char --*/

  show_op("let v = vec!['R', 'u', 's', 't']");
  let v:Vec<char> = vec!['R', 'u', 's', 't'];
  log(&v);
  log(&'R');
  putlinen(2);

  show_op("let ch = 'a' as u8");
  let ch:u8 = 'a' as u8;
  log(&ch);
  show("char is ", &(ch as char));
  putlinen(2);

  /*-- String --*/

  show_op("let s = String::from(\"Rust\")");
  let s:String = String::from("Rust");
  log(&s);
  let i:usize = 2;
  let ch = at(&s, i);
  print!("\n  in string \"{}\", char at {} is {}", &s, i, ch);
  show("length in bytes of s = {:?}", &s.len());
  putlinen(2);

  show_op("let v = Vec::from(s.clone())");
  let s1 = s.clone();
  let v:Vec<u8> = Vec::from(s1);
  log(&v[0]);
  show("vec from string",&v);
  putlinen(2);

  /*-----------------------------------------------------
    Displaying emoji's to illustrate the potential
    of using utf-8.
  */
  show_op("displaying emoji's");
  let mut s2 = String::new();
  s2.push_str("\u{1F600}");
  s2.push('\u{1F601}');
  s2.push('\u{1F602}');
  s2.push('\u{1F609}');
  print!("\n  {}", s2);
  print!("\n  {}", '\u{1F601}');
  putlinen(2);

  /*-- str --*/

  show_op("let s_slice = &s[..]");
  let s_slice = &s[..];   // slice containing all chars of s
  log(&s_slice);
  show("s_slice = ", &s_slice);
  putlinen(2);

  show_op("let s_slice2 = s.as_str()");
  let s_slice2 = s.as_str();
  log(&s_slice2);
  putlinen(2);

  /*-- create string and mutate --*/

  show_op("let mut s = string::new()");
  let mut s = String::new();
  s.push('a');
  s.push(' ');
  s.push_str("test string");
  log(&s);
  putlinen(2);

  show_op("let t = s.replace(from: \"string\", to: \"Rust String\"");
  let t = s.replace("string","Rust String");
  log(&t);
  putlinen(2);

  show_op("tok in s.split_whitespace()");
  for tok in s.split_whitespace() {
    print!("\n  {}", tok);
  }
  putline();

  /*-----------------------------------------------------
     Another, order n, way to index string:
    - chars returns iterator over utf8 chars in string slice
    - nth(i) calls next on iterator until it gets to i
    - nth(i) returns std::option::Option<char>:
       - that contains Some(ch) or None if operation failed
  */
  show("\n  s = ", &s);
  putline();
  show_op("let result = s.chars().nth(0)");
  putline();
  let result = s.chars().nth(0);
  match result {
    Some(r) => show("  s.chars().nth(0) = ", &r),
    None => print!("\n  couldn't extract char"),
  }
  putline();
  show_op("let result = s.chars().nth(2)");
  putline();
  let result = s.chars().nth(2);
  match result {
    Some(r) => show("  s.chars().nth(2) = ", &r),
    None => print!("\n  couldn't extract char"),
  }
  putlinen(2);

  {
    /*-------------------------------------------------
       Caution here:
       - slice is returning array of bytes, not utf8 chars
       - this works only because we use all ASCII chars
    */
    /*-- slices are non-owning views and are borrows of s --*/
    show_op("let slice_all = &s");
    let slice_all = &s;
    log(&slice_all);
    show("slice_all = ", &slice_all);
    putlinen(2);

    show_op("let third = &s[2..3]");
    let third = &s[2..3];       // string slice with one char
    log(&third);
    show("\n  third = ",&third);
    putlinen(2);

    /*-- this works for utf-8 encoding --*/
    show_op("let ch = third.chars().nth(0)");
    let ch = third.chars().nth(0);  //
    log(&ch);
    match ch {
      Some(x) => { log(&x); show("\n  match ch = ", &x); },
      None => print!("\n can't return ch"),
    }

    ///////////////////////////////////////////////////
    // compile fails
    // - can't modify owner while borrows are active
    //------------------------------------------------
    // s.push('Z');
    // log(&slice_all);

  }   // elem borrow ends here

  s.push('Z');  // ok, borrows no longer active
  putlinen(2);

  /* format_args! macro */

  show_op("let s = std::fmt::format(format_args!(...))");
  let s = std::fmt::format(format_args!("\n  {}, {}, {}", 1, 2, 3.5));
  put_str(&s);
  put(&s);
  putlinen(2);

  show_op("struct S { x:i32, y:f64, s:String, }");
  #[allow(dead_code)]
  #[derive(Debug)]
  struct S {x:i32, y:f64, s:String, }
  let st:S = S { x:3, y:4.2, s:"xyz".to_string() };
  put("\n  ");
  putdb(&st);
  putline();

  sub_title("That's all Folks!");
  putlinen(2);
}

fn main() {

  show_title("Demonstrate std Library Types");
  use std::collections::{VecDeque, HashMap};

  show_label("std::Vec<T>");

  show_op("let mut vi = vec![1, 2, 3, 2, 1]");
  let mut vi = vec![1, 2, 3, 2, 1];
  show_type(&vi);
  show_value(&vi);
  show_op("vi[1] = -2");
  vi[1] = -2;
  show_value(&vi);
  show_op("vi.push(0)");
  vi.push(0);
  show_value(&vi);
  show_op("vi.insert(1, 42)");
  vi.insert(1, 42);
  show_value(&vi);
  println!();

  show_label("VecDeque<T>");
  show_op("let mut vdeq = VecDeque::<f64>::new()");
  let mut vdeq = VecDeque::<f64>::new();
  show_type(&vdeq);
  show_value(&vdeq);
  show_op("vdeq.push_back(2.5)");
  vdeq.push_back(2.5);
  show_op("vdeq.push_front(1.0)");
  vdeq.push_front(1.0);
  show_value(&vdeq);
  println!();

  show_label("HashMap<K, V>");
  show_op("let mut hm = HashMap::<i32, &str>::new()");
  let mut hm = HashMap::<i32, &str>::new();
  show_type(&hm);
  show_value(&hm);
  show_op("hm.insert(1,\"one\")");
  hm.insert(1,"one");
  show_value(&hm);
  hm.insert(0,"zero");
  show_value(&hm);
  hm.insert(2,"two");
  show_value(&hm);
  hm.insert(-2,"minus two");
  show_value(&hm);
  show_op("hm.remove(&0)");
  hm.remove(&0);
  show_value(&hm);
  /*
    using entry API for HashMap
    - if the key exists then modify the value
      with a closure
  */
  show_op("hm.entry(1).and_modify(|v| *v = \"the number 1\")");
  hm.entry(1).and_modify(|v| *v = "the number 1");
  show_value(&hm);

  println!("\n  That's all Folks!");
}