编辑：张汉东

返回多态类型

  1. use rand::{thread_rng, Rng};
  3. /// This is the trait that every die needs to implement to be... well... "rollable", right?
  4. pub trait Rollable {
  5.     /// Roll the die
  6.     fn roll() -> Self;
  7.     /// Get the value from the latest roll
  8.     fn val(&self) -> u8;
  9. }
  11. /// A generic function to roll a given die.
  12. pub fn roll<T: Rollable>() -> T {
  13.     Rollable::roll() // <- Note that here `Rollable` is the current type for a given call!
  14. }
  16. /// A D6 die (6 faces): a roll will give you a `u8` in the `1..=6` range.
  17. #[derive(Debug)]
  18. pub struct D6(u8);
  20. impl Rollable for D6 {
  21.     fn roll() -> D6 {
  22.         D6 {
  23.             0: thread_rng().gen_range(1..=6),
  24.         }
  25.     }
  26.     fn val(&self) -> u8 {
  27.         self.0
  28.     }
  29. }
  31. /// A D8 die (8 faces): a roll will give you a `u8` in the `1..=8` range.
  32. #[derive(Debug)]
  33. pub struct D8(u8);
  35. impl Rollable for D8 {
  36.     fn roll() -> D8 {
  37.         D8 {
  38.             0: thread_rng().gen_range(1..=8),
  39.         }
  40.     }
  41.     fn val(&self) -> u8 {
  42.         self.0
  43.     }
  44. }
  46. #[derive(Debug)]
  47. struct Fake100(u8);
  49. impl Rollable for Fake100 {
  50.     fn roll() -> Fake100 {
  51.         Fake100 { 0: 100 } // <- forces it to roll 100
  52.     }
  53.     fn val(&self) -> u8 {
  54.         self.0
  55.     }
  56. }
  58. fn main() {
  59.     // let's roll a D6
  60.     let r: D6 = roll();
  61.     println!("{:?}", r); // D6(3)
  63.     // let's roll a D8
  64.     let r: D8 = roll();
  65.     println!("{:?}", r); // D8(3)
  67.     println!("I bet I'll get a 100 this time!");
  68.     let d: Fake100 = roll();
  69.     println!("Look what I got: {}!", d.val()) // <- yeah this will always be 100
  70. }

也支持类型推断：

  1. fn try_dodge_attack(d6: D6, d8: D8) -> bool {
  2.     d6.val() + d8.val() > 10
  3. }
  5. fn main() {
  6.     let escaped = try_dodge_attack(roll(), roll());
  7.     println!(
  8.         "{}",
  9.         match escaped {
  10.             true => "You dogded!",
  11.             false => "Ouch! The attack hit you!",
  12.         }
  13.     );
  14. }

来源

一个零开销链表的实现

下面代码实现了一个 持久性/不变性（Persistent / Immutable ）的单向链表（Singly-linked）。

  1. #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
  2. pub enum List<'a, T> {
  3.     Node { data: T, next: &'a List<'a, T> },
  4.     Tail,
  5. }
  7. impl<T> Default for List<'_, T> {
  8.     fn default() -> Self {
  9.         List::Tail
  10.     }
  11. }
  13. impl<'a, T> List<'a, T> {
  14.     pub fn add(&'a self, data: T) -> Self {
  15.         List::Node { data, next: self }
  16.     }
  18.     pub fn rev_iter(&'a self, f: impl Fn(&'a T)) {
  19.         if let List::Node { data, next } = self {
  20.             next.rev_iter(&f);
  21.             f(data);
  22.         }
  23.     }
  25.     pub fn try_rev_iter<E, F>(&'a self, f: F) -> Result<(), E>
  26.     where
  27.         F: Fn(&'a T) -> Result<(), E>,
  28.     {
  29.         if let List::Node { data, next } = self {
  30.             next.try_rev_iter(&f)?;
  31.             f(data)?;
  32.         }
  33.         Ok(())
  34.     }
  35. }
  37. pub struct ListIter<'a, T>(&'a List<'a, T>);
  39. impl<'a, T> IntoIterator for &'a List<'a, T> {
  40.     type Item = &'a T;
  42.     type IntoIter = ListIter<'a, T>;
  44.     fn into_iter(self) -> Self::IntoIter {
  45.         ListIter(self)
  46.     }
  47. }
  49. impl<'a, T> Iterator for ListIter<'a, T> {
  50.     type Item = &'a T;
  52.     fn next(&mut self) -> Option<Self::Item> {
  53.         match self.0 {
  54.             List::Node { data, next } => {
  55.                 self.0 = next;
  56.                 Some(data)
  57.             }
  58.             List::Tail => None,
  59.         }
  60.     }
  61. }
  64. #[derive(Debug, Clone, PartialEq)]
  65. pub enum Value {
  66.     Num(f64),
  67.     Bool(bool),
  68.     String(String),
  69. }
  71. #[derive(PartialEq)]
  72. pub enum ValueKind {
  73.     Num,
  74.     Bool,
  75.     String,
  76. }
  78. impl Value {
  79.     pub fn kind(&self) -> ValueKind {
  80.         match self {
  81.             Value::Num(_) => ValueKind::Num,
  82.             Value::Bool(_) => ValueKind::Bool,
  83.             Value::String(_) => ValueKind::String,
  84.         }
  85.     }
  86. }
  88. #[derive(Debug, Clone)]
  89. pub enum Expr {
  90.     Value(Value),
  91.     Variable(String),
  92.     UnExpr(UnExprKind, Box<Expr>),
  93.     BinExpr(BinExprKind, Box<(Expr, Expr)>),
  94.     Define(String, Box<(Expr, Expr)>),
  95.     IfThenElse(Box<(Expr, Expr, Expr)>),
  96. }
  98. #[derive(Debug, Copy, Clone)]
  99. pub enum UnExprKind {
  100.     Not,
  101.     Neg,
  102. }
  104. #[derive(Debug, PartialEq, Copy, Clone)]
  105. pub enum BinExprKind {
  106.     // Arithmetic
  107.     Add,
  108.     Sub,
  109.     Mul,
  110.     Div,
  112.     // Logic
  113.     And,
  114.     Or,
  115.     Equals,
  116.     NotEquals,
  117. }
  119. type Variables<'a> = List<'a, (String, Value)>;
  121. pub fn eval(vars: &Variables<'_>, expr: Expr) -> Option<Value> {
  122.     match expr {
  123.         Expr::Value(val) => Some(val),
  125.         Expr::Variable(var) => vars
  126.             .into_iter()
  127.             .find(|&(v, _)| *v == var)
  128.             .map(|(_, val)| val.clone()),
  130.         Expr::UnExpr(kind, expr) => {
  131.             eval_unary(kind, vars, *expr)
  132.         }
  134.         Expr::BinExpr(kind, exprs) => {
  135.             eval_binary(kind, vars, exprs.0, exprs.1)
  136.         }
  138.         Expr::Define(name, exprs) => {
  139.             let value = eval(vars, exprs.0)?;
  140.             let vars = vars.add((name, value));
  141.             eval(&vars, exprs.1)
  142.         }
  144.         Expr::IfThenElse(exprs) => {
  145.             if let Value::Bool(b) = eval(vars, exprs.0)? {
  146.                 eval(vars, if b { exprs.1 } else { exprs.2 })
  147.             } else {
  148.                 None
  149.             }
  150.         }
  151.     }
  152. }
  154. fn eval_unary(
  155.     kind: UnExprKind,
  156.     vars: &Variables<'_>,
  157.     expr: Expr,
  158. ) -> Option<Value> {
  159.     let val = eval(vars, expr)?;
  160.     match (kind, val) {
  161.         (UnExprKind::Not, Value::Bool(b)) => {
  162.             Some(Value::Bool(!b))
  163.         }
  164.         (UnExprKind::Neg, Value::Num(n)) => Some(Value::Num(-n)),
  165.         _ => None,
  166.     }
  167. }
  169. fn eval_binary(
  170.     kind: BinExprKind,
  171.     vars: &Variables<'_>,
  172.     lhs: Expr,
  173.     rhs: Expr,
  174. ) -> Option<Value> {
  175.     let lhs = eval(vars, lhs)?;
  177.     match kind {
  178.         BinExprKind::Add => {
  179.             if let Value::Num(lhs) = lhs {
  180.                 if let Value::Num(rhs) = eval(vars, rhs)? {
  181.                     return Some(Value::Num(lhs + rhs));
  182.                 }
  183.             }
  184.             None
  185.         }
  186.         BinExprKind::Sub => {
  187.             if let Value::Num(lhs) = lhs {
  188.                 if let Value::Num(rhs) = eval(vars, rhs)? {
  189.                     return Some(Value::Num(lhs - rhs));
  190.                 }
  191.             }
  192.             None
  193.         }
  194.         BinExprKind::Mul => {
  195.             if let Value::Num(lhs) = lhs {
  196.                 if let Value::Num(rhs) = eval(vars, rhs)? {
  197.                     return Some(Value::Num(lhs * rhs));
  198.                 }
  199.             }
  200.             None
  201.         }
  202.         BinExprKind::Div => {
  203.             if let Value::Num(lhs) = lhs {
  204.                 if let Value::Num(rhs) = eval(vars, rhs)? {
  205.                     return Some(Value::Num(lhs / rhs));
  206.                 }
  207.             }
  208.             None
  209.         }
  211.         BinExprKind::And => {
  212.             if let Value::Bool(lhs) = lhs {
  213.                 if !lhs {
  214.                     return Some(Value::Bool(false));
  215.                 }
  216.                 if let Value::Bool(rhs) = eval(vars, rhs)? {
  217.                     return Some(Value::Bool(rhs));
  218.                 }
  219.             }
  220.             None
  221.         }
  222.         BinExprKind::Or => {
  223.             if let Value::Bool(lhs) = lhs {
  224.                 if lhs {
  225.                     return Some(Value::Bool(true));
  226.                 }
  227.                 if let Value::Bool(rhs) = eval(vars, rhs)? {
  228.                     return Some(Value::Bool(rhs));
  229.                 }
  230.             }
  231.             None
  232.         }
  233.         BinExprKind::Equals => {
  234.             let rhs = eval(vars, rhs)?;
  235.             if lhs.kind() == rhs.kind() {
  236.                 Some(Value::Bool(lhs == rhs))
  237.             } else {
  238.                 None
  239.             }
  240.         }
  241.         BinExprKind::NotEquals => {
  242.             let rhs = eval(vars, rhs)?;
  243.             if lhs.kind() == rhs.kind() {
  244.                 Some(Value::Bool(lhs != rhs))
  245.             } else {
  246.                 None
  247.             }
  248.         }
  249.     }
  250. }

来源