Rust 中的 RAII 模式

xhcoding

2021-09-25

一个送信的逻辑：

#[derive(Clone)]
pub struct Letter {
    text: String,
}

pub struct Envelope {
    letter: Option<Letter>,
}

pub struct PickupLorryHandle {
    done: bool,
}

impl Letter {
    pub fn new(text: String) -> Self {
        Letter { text: text }
    }
}

impl Envelope {
    pub fn wrap(&mut self, letter: &Letter) {
        self.letter = Some(letter.clone());
    }
}

pub fn buy_prestamped_envelope() -> Envelope {
    Envelope { letter: None }
}

impl PickupLorryHandle {
    pub fn pickup(&mut self, _envelope: &Envelope) {
        // give letter
    }

    pub fn done(&mut self) {
        self.done = true;
        println!("sent");
    }
}

pub fn order_pickup() -> PickupLorryHandle {
    PickupLorryHandle { done: false }
}

fn main() {
    let letter = Letter::new(String::from("Dear RustFest"));
    let mut envelope = buy_prestamped_envelope();
    envelope.wrap(&letter);
    let mut lorry = order_pickup();
    lorry.pickup(&envelope);
    lorry.done();
}

sent

上面存在的问题：

阅读全文

Rust 中的 trait 系统

xhcoding

2021-09-20

trait 是 Rust 的灵魂，Rust 中的所有抽象，如接口抽象，OOP 范式抽象，函数式范式抽象，都是基于 trait 完成的。

trait 是在行为上对类型的约束，这种约束让 trait 有如下四种用法：

阅读全文

Rust 中的析构顺序

xhcoding

2021-09-16

一般来讲，变量的析构顺序和声明顺序相反，但是并不是所有的情况都是这样。

本地变量

本地变量先声明后析构。

struct PrintDrop(&'static str);
impl Drop for PrintDrop {
    fn drop(&mut self) {
        println!("Dropping {}", self.0)
    }
}

fn main() {
    let _x = PrintDrop("x");
    let _y = PrintDrop("y");
}

1
2

Dropping y
Dropping x

元组

struct PrintDrop(&'static str);
impl Drop for PrintDrop {
    fn drop(&mut self) {
        println!("Dropping {}", self.0)
    }
}

fn main() {
    let _tup1 = (PrintDrop("x"), PrintDrop("y"));
    let _tup2 = (PrintDrop("s"), PrintDrop("z"));
}

Dropping s
Dropping z
Dropping x
Dropping y

先析构 tup2 ，后析构 tup1 ，在元组内部是前面的先析构，后面的后析构。

阅读全文

Rust 中的枚举

xhcoding

2021-09-15

在 Rust 结构体中讲了枚举体也是代数数据类型，属于其中的和类型，满足加法原理。

使用枚举体来定义颜色。从而重构 Rust 结构体中的代码。

// 用枚举表示颜色
enum Color {
    Red,
    Yellow,
}

// 实现响应的方法
impl Color {
    fn to_fg_str(&self) -> &str {
        match *self {
            Color::Red => "31",
            Color::Yellow => "33",
        }
    }

    fn to_bg_str(&self) -> &str {
        match *self {
            Color::Red => "41",
            Color::Yellow => "43",
        }
    }
}

use std::convert::From;
use std::str::FromStr;
use std::string::String;

impl<'a> From<&'a str> for Color {
    fn from(src: &str) -> Self {
        src.parse().unwrap_or(Color::Red)
    }
}

impl From<String> for Color {
    fn from(src: String) -> Self {
        src.parse().unwrap_or(Color::Red)
    }
}

impl FromStr for Color {
    type Err = ();
    fn from_str(src: &str) -> Result<Self, Self::Err> {
        let src = src.to_lowercase();
        match src.as_ref() {
            "red" => Ok(Color::Red),
            "yellow" => Ok(Color::Yellow),
            _ => Err(()),
        }
    }
}

struct ColoredString {
    input: String,
    fgcolor: Option<Color>,
    bgcolor: Option<Color>,
}

trait Colorize {
    fn red(self) -> ColoredString;
    fn yellow(self) -> ColoredString;
    fn color<S: Into<Color>>(self, color: S) -> ColoredString;

    fn on_red(self) -> ColoredString;
    fn on_yellow(self) -> ColoredString;
    fn on_color<S: Into<Color>>(self, color: S) -> ColoredString;
}

// 实现默认方法
impl Default for ColoredString {
    fn default() -> Self {
        ColoredString {
            input: String::default(),
            fgcolor: None,
            bgcolor: None,
        }
    }
}

// 为 ColoredString 实现 Colorize trait

impl<'a> Colorize for ColoredString {
    fn red(self) -> ColoredString {
        self.color(Color::Red)
    }

    fn yellow(self) -> ColoredString {
        self.color(Color::Yellow)
    }

    fn on_red(self) -> ColoredString {
        self.on_color(Color::Red)
    }

    fn on_yellow(self) -> ColoredString {
        self.on_color(Color::Yellow)
    }

    fn color<S: Into<Color>>(self, color: S) -> ColoredString {
        ColoredString {
            fgcolor: Some(color.into()),
            ..self
        }
    }

    fn on_color<S: Into<Color>>(self, color: S) -> ColoredString {
        ColoredString {
            bgcolor: Some(color.into()),
            ..self
        }
    }
}

impl<'a> Colorize for &'a str {
    fn red(self) -> ColoredString {
        self.color(Color::Red)
    }

    fn yellow(self) -> ColoredString {
        self.color(Color::Yellow)
    }

    fn on_red(self) -> ColoredString {
        self.on_color(Color::Red)
    }

    fn on_yellow(self) -> ColoredString {
        self.on_color(Color::Yellow)
    }

    fn color<S: Into<Color>>(self, color: S) -> ColoredString {
        ColoredString {
            fgcolor: Some(color.into()),
            input: String::from(self),
            ..ColoredString::default()
        }
    }

    fn on_color<S: Into<Color>>(self, color: S) -> ColoredString {
        ColoredString {
            bgcolor: Some(color.into()),
            input: String::from(self),
            ..ColoredString::default()
        }
    }
}

impl ColoredString {
    fn compute_style(&self) -> String {
        let mut res = String::from("\x1B[");
        let mut has_wrote = false;
        if let Some(ref bgcolor) = self.bgcolor {
            res.push_str(bgcolor.to_bg_str());
            has_wrote = true;
        }
        if let Some(ref fgcolor) = self.fgcolor {
            if has_wrote {
                res.push_str(";");
            }
            res.push_str(fgcolor.to_fg_str());
        }
        res.push('m');
        res
    }
}

use std::fmt;

impl fmt::Display for ColoredString {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str(&self.compute_style())?;
        f.write_str(&self.input)?;
        f.write_str("\x1B[0m")?;
        Ok(())
    }
}

fn main() {
    let hi = "Hello".red().on_yellow();
    println!("{}", hi);
}

Hello

阅读全文

Rust 中的结构体

xhcoding

2021-09-12

在 Rust 类型系统中，结构体（Struct）和枚举体（Enum）都属于 代数数据类型（ADT, Algebraic Data Type） 。

ADT 指的是指的是具备代数能力的数据类型，即数据类型可以进行代数运算并满足一定的运算规则。比如一个结构体中的所有成员是可以复制的，那么这个结构体就可以通过派生属性 #[derive] 实现 Copy 。

阅读全文