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 。

阅读全文

Rust 中的字符串

xhcoding

2021-09-10

字符串编码

rust 中的字符串都是使用的 UTF-8 编码，rust 代码文件也是 UTF-8 编码，如果不是，rust 会报错。

use std::str;

fn main() {
    let tao = str::from_utf8(&[0xE9u8, 0x81u8, 0x93u8]).unwrap(); // UTF8 到 str
    assert_eq!("道", tao);
    assert_eq!("道", String::from("\u{9053}"));
    let unicode_x = 0x9053; //  unicode 码点
    let utf_x_hex = 0xe98193;
    let utf_x_bin = 0b111010011000000110010011;
    println!("unicode_x: {:b}", unicode_x);
    println!("utf_x_hex: {:b}", utf_x_hex);
    println!("utf_x_bin: 0x{:b}", utf_x_bin);
}

1
2
3

unicode_x: 1001000001010011
utf_x_hex: 111010011000000110010011
utf_x_bin: 0x111010011000000110010011

字符

Rust 使用 char 表示单个字符，char 类型使用的整数值和 Unicode 标量值一一对应。为了存储任意的 Unicode 标量值，Rust 规定每个字符都占 4 个字节

阅读全文