1、rust标准库#Option

1. Option在rust标准库中的定义

enum Option<T> {
    Some(T),
    None,
}

2. Option的典型用法

fn main()
{
  let x: Option<i32> = None;
  let y: Option<i32> = Some(5);
  let z: Option<f64> = Some(5.0f64);

  println!("{:?}", x);
  println!("{:?}", y);
  println!("{:?}", z);
}

➜  main make
rustc main.rs
./main
None
Some(5)
Some(5.0)
➜  main

3. match 解包 Option

fn main()
{
  let x: Option<i32> = None;
  let y: Option<i32> = Some(5);
  let z: Option<f64> = Some(5.0f64);

  match x {
    Some(x) => { println!("x = {}", x) },
    None => { println!("x = None") },
  }

  match y {
    Some(y) => { println!("y = {}", y) },
    None => { println!("y = None") },
  }

  match z {
    Some(z) => { println!("z = {:?}", z) },
    None => { println!("z = None") },
  }
}

➜  main make
rustc main.rs
./main
x = None
y = 5
z = 5.0
➜  main

4. if let 解包 Option

fn main()
{
  let x: Option<i32> = None;
  let y: Option<i32> = Some(5);
  let z: Option<f64> = Some(5.0f64);

  if let Some(val) = x {
    println!("val = {}", val);
  } else {
    println!("x = None");
  }

  if let Some(val) = y {
    println!("val = {}", val);
  } else {
    println!("y = None");
  }

  if let Some(val) = z {
    println!("val = {:?}", val);
  } else {
    println!("z = None");
  }
}

➜  main make
rustc main.rs
./main
x = None
val = 5
val = 5.0
➜  main

5. while let 解包 Option

fn main()
{
  // 可变绑定的可选值
  let mut num: Option<i32> = Some(0);
  
  // while let 解包/打包 Option类型的变量
  while let Some(i) = num {
    if i > 5 {
      num = None; // 可选值赋值为None
      break;
    } else {
      print!("{}, ", i); 
      num = Some(i+1); // 可选值+1后，继续打包为可选值
    }
  }
  println!(""); 
  println!("num = {:?}", num);
}

➜  main make
rustc main.rs
./main
0, 1, 2, 3, 4, 5,
num = None
➜  main

2、类似于C++模板编程

1. 函数模板

fn make_pair<T, U>(a: T, b: U) -> (T, U) {
  (a, b)
}

fn main()
{
  let couple1 = make_pair("man", "female");
  println!("couple1 = {:?}", couple1);

  let couple2 = make_pair(99i32, 109f64);
  println!("couple2 = {:?}", couple2);
}

➜  main make
rustc main.rs
./main
couple1 = ("man", "female")
couple2 = (99, 109.0)
➜  main

2. 函数模板 + 面向接口

// 接口1
trait Man {
  fn name(&self) -> String;
}

// 接口2
trait Animal {
  fn name(&self) -> String;
}

// 接口3
trait Runnable {
  fn run(&self);
}

fn make_pair<T, U>(a: T, b: U) -> (T, U) 
  where T: Man, 
        U: Animal + Runnable // 模板参数U必须实现两个接口
{
  (a, b)
}

fn main()
{}

3. 类（struct）模板

#[derive(Debug)]
struct Point<T> {
  x: T,
  y: T,
}

fn main()
{
  let int_origin = Point { x: 0, y: 0 };
  let float_origin = Point { x: 0.0, y: 0.0 };

  println!("{:?}", int_origin);
  println!("{:?}", float_origin);
}

➜  main make
rustc main.rs
./main
Point { x: 0, y: 0 }
Point { x: 0.0, y: 0.0 }
➜  main

3、type 关联模板参数类型

1. 接口具体实现

// 接口
trait Graph {
  type N; // 模板参数1
  type E; // 模板参数2

  fn has_edge(&self, &Self::N, &Self::N) -> bool; // 返回bool
  fn edges(&self, &Self::N) -> &Vec<Self::E>; // 返回Vec数组的引用（临时使用权）
}

// 实体类
struct Node;
struct Edge;
struct SimpleGraph {
  edges: Vec<Edge>
}

// 给实体类增加接口实现
impl Graph for SimpleGraph {
  // 1. 给接口中模板参数，确定具体的数据类型
  type N = Node;
  type E = Edge;

  // 2. 接口方法实现1
  fn has_edge(&self, n1: &Node, n2: &Node) -> bool {
    return true;
  }

  // 3. 接口方法实现2
  fn edges(&self, n: &Node) -> &Vec<Edge> { //注意：-> Vec<E> 中的模板参数E要替换为具体数据类型
    return &(self.edges);
  }
}

fn main()
{
  let graph = SimpleGraph {edges: vec![Edge{}, Edge{}, Edge{}]};
  let object = Box::new(graph) as Box<Graph<N=Node, E=Edge>>;
}

➜  main make
rustc main.rs
./main
➜  main

2. < T > 绑定模板参数的接口作为函数参数类型

// 接口定义
trait Graph<N, E> {
  // 接口中方法定义时，函数形参不需要使用参数名
  fn has_edge(&self, &N, &N) -> bool;
  fn edges(&self, &N) -> Vec<E>;
}

// 全局函数，函数形参的类型为接口类型
// => 必须先传入【N、E】的数据类型
// => 再确定【Graph<N, E>】的数据类型
fn distance<N, E, G: Graph<N, E>>(
  graph: &G, 
  start: &N, 
  end: &N) -> u32 {
  return 99;
}

fn main()
{}

3. type绑定模板参数的接口作为函数参数类型

// 接口定义
trait Graph {
  type N;
  type E;

  fn has_edge(&self, &Self::N, &Self::N) -> bool;
  fn edges(&self, &Self::N) -> Vec<Self::E>;
}

// 全局函数，函数形参的类型为接口类型
fn distance<G: Graph>(
  graph: &G, 
  start: &G::N, 
  end: &G::N) -> i32 {
  return 99;
}

fn main()
{}