Rust：功能强大的组合器

已于 2022-05-12 08:54:39 修改
阅读量1.2k 收藏 5
点赞数 3
分类专栏： # Rust 文章标签： rust 组合器 and_then or ok_or
于 2022-05-11 19:07:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/quicmous/article/details/124714140
版权

Rust 能够用组合器简化代码编写。之前觉得没啥用，实际完成一个项目后，才知道组合器的威力强大。下面列举一下常见的组合器，可用于 Option、Result、集合等类型。

一、数值转换：数据类型不变，仅数值替换

1. or()

例子：

fn main() {
    let x=Some(1);
    let y = Some(2);
    let z1 = x.or(y);
    let z2 = None.or(y);
    println!("{:?}", z1);
    println!("{:?}", z2);
}
======== cargo run ========
Some(1)
Some(2)

组合器实现代码：

    pub fn or(self, optb: Option<T>) -> Option<T> {
        match self {
            Some(_) => self,
            None => optb,
        }
    }

2. and()

例子：

fn main() {
    let x = Some(1);
    let y = Some(2);
    let z = x.and(y);
    println!("{:?}", z);
}
======== cargo run ========
Some(2)

组合器实现代码：

    pub fn and<U>(self, optb: Option<U>) -> Option<U> {
        match self {
            Some(_) => optb,
            None => None,
        }
    }

3. or_else()

例子：

fn main() {
    let x = Some(1);
    let z = x.or_else(||Some(2));
    println!("{:?}", z);
}
======== cargo run ========
Some(1)

组合器实现代码：

    pub fn or_else<F: FnOnce() -> Option<T>>(self, f: F) -> Option<T> {
        match self {
            Some(_) => self,
            None => f(),
        }
    }

FnOnce 说明这个函数的参数是个闭包。

4. and_then()

例子：

fn main() {
    let x = Some(1);
    let z = x.and_then(|x| Some(x + 1));
    println!("{:?}", z);
}
======== cargo run ========
Some(2)

组合器实现代码：

    pub fn and_then<U, F: FnOnce(T) -> Option<U>>(self, f: F) -> Option<U> {
        match self {
            Some(x) => f(x),
            None => None,
        }
    }

FnOnce（T） 说明这个函数的参数是个闭包，而且以 T 为闭包函数的传入参数。

5. filter

例子：

fn main() {
    let x = Some(3);
    let x1 = x.filter(|x| x < &5);
    let x2 = x.filter(|x| x > &5);
    println!("x1 = {:?}", x1);
    println!("x2 = {:?}", x2);
}
======== cargo run ========
x1 = Some(3)
x2 = None

组合器实现代码：

   pub fn filter<P: FnOnce(&T) -> bool>(self, predicate: P) -> Self {
        if let Some(x) = self {
            if predicate(&x) {
                return Some(x);
            }
        }
        None
   }

话说 filter 也可用于数组，写了段代码如下：

fn main() {
    let x = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    let z = x.iter().filter(|x| **x < 5).collect::<Vec<_>>();
    println!("z= {:?}", z);
}
======== cargo run ========
z= [1, 2, 3, 4]

组合器实现代码：

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
        Self: Sized,
        P: FnMut(&Self::Item) -> bool,
    {
        Filter::new(self, predicate)
    }

看代码，此 filter 非彼 filter。

二、类型转换：用新类型的数据替换原来的数据

1. map()

例子：

fn main() {
    let x = Some("12345");
    let z = x.map(|x| x.len());
    println!("z = {:?}", z);
}
======== cargo run ========
z = Some(5)

组合器实现代码：

    pub fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Option<U> {
        match self {
            Some(x) => Some(f(x)),
            None => None,
        }
    }

用于集合的例子。和上面的不是同一个map，后面所有的组合器实现代码都不贴了：

fn main() {
    let x = vec![1, 2, 3, 4, 5];
    let z = x.iter().map(|x| (*x) as f64).collect::<Vec<f64>>();
    println!("z = {:?}", z);
}
======== cargo run ========
z = [1.0, 2.0, 3.0, 4.0, 5.0]

2. map_err()

只修改 Err 的值， Ok的值不变。看例子：

fn main() {
    let x: Result<i32, i32> = Ok(123);
    let y: Result<i32, i32> = Err(456);
    let z1: Result<i32, i32> = x.map_err(|_| 999);
    let z2: Result<i32, i32> = y.map_err(|_| 999);
    println!("z1 = {:?}", z1);
    println!("z2 = {:?}", z2);
}
======== cargo run ========
z1 = Ok(123)
z2 = Err(999)

3. map_or()

仅支持 Option 类型（不支持 Result ）。将闭包应用于 Some 中的值，然后根据闭包返回输出。对于 None 将返回给定的默认值。

fn main() {
    let x: Option<i32> = Some(123);
    let y: Option<i32> = None;
    let z1 = x.map_or(999, |x| x * 2);
    let z2 = y.map_or(999, |x| x * 2);
    println!("z1 = {:?}", z1);
    println!("z2 = {:?}", z2);
}
======== cargo run ========
z1 = 246
z2 = 999

4. map_or_else()

支持 Option 类型和 Results 类型（Result 还在 nightly）。与 map_or() 类似，但要对于第一个参数，要提供另一个闭包，而不是默认值。

fn main() {
    let x: Option<i32> = Some(123);
    let y: Option<i32> = None;
    let z1 = x.map_or_else(|| 999, |x| x * 2);
    let z2 = y.map_or_else(|| 999, |x| x * 2);
    println!("z1 = {:?}", z1);
    println!("z2 = {:?}", z2);
}
======== cargo run ========
z1 = 246
z2 = 999

5. ok_or() : Option -> Result

ok_or() 将Option类型转换为Result类型。
例子：

fn main() {
    let x = Some(123);
    let y: Option<i32> = None;
    let z1: Result<i32, i32> = x.ok_or(999);
    let z2: Result<i32, i32> = y.ok_or(999);
    println!("z1 = {:?}", z1);
    println!("z2 = {:?}", z2);
}
======== cargo run ========
z1 = Ok(123)
z2 = Err(999)

6. ok_or_else() : Option -> Result

ok_or_else() 将Option类型转换为Result类型，用闭包作为参数。

fn main() {
    let x = Some(123);
    let y: Option<i32> = None;
    let z1: Result<i32, i32> = x.ok_or_else(||999);
    let z2: Result<i32, i32> = y.ok_or_else(||999);
    println!("z1 = {:?}", z1);
    println!("z2 = {:?}", z2);
}
======== cargo run ========
z1 = Ok(123)
z2 = Err(999)

三、变量形态变化

1. as_ref()：Some(T) -> Some(&T), Result<S,T> -> Result<&S,&T>

例子（Option）：

fn print_type_of<T>(_: &T) {
    println!("{}", std::any::type_name::<T>())
}
fn main() {
    let mut x= Some(123);
    print_type_of(&x);
    let z = x.as_ref();
    print_type_of(&z);
}
======== cargo run ========
core::option::Option<i32>
core::option::Option<&i32>

例子（Result）：

fn print_type_of<T>(_: &T) {
    println!("{}", std::any::type_name::<T>())
}
fn main() {
    let mut x:Result<i32,i32>= Ok(123);
    print_type_of(&x);
    let z = x.as_ref();
    print_type_of(&z);
}
======== cargo run ========
core::result::Result<i32, i32>
core::result::Result<&i32, &i32>

2. as_mut()：Option(T) -> Option(&mut T), Result<S,T> -> Result<&mut S,&mut T>

例子（Option）：

fn print_type_of<T>(_: &T) {
    println!("{}", std::any::type_name::<T>())
}
fn main() {
    let mut x= Some(123);
    print_type_of(&x);
    let z = x.as_mut();
    print_type_of(&z);
}
======== cargo run ========
core::option::Option<i32>
core::option::Option<&mut i32>

例子（Result）：

fn print_type_of<T>(_: &T) {
    println!("{}", std::any::type_name::<T>())
}
fn main() {
    let mut x:Result<i32,i32>= Ok(123);
    print_type_of(&x);
    let z = x.as_mut();
    print_type_of(&z);
}
======== cargo run ========
core::result::Result<i32, i32>
core::result::Result<&mut i32, &mut i32>
Rust：Restful API 服务程序开发详述
程序猿视角
09-03 1979
hyper库提供了低级别的HTTP/1和HTTP/2协议支持，可以用于构建高性能的HTTP客户端和服务器。它利用Rust的类型系统来确保代码的正确性，并与Rust的异步生态系统无缝集成，支持异步非阻塞I/O。Warp 建立在 hyper 和 Tokio 这两个异步 Rust 运行时之上，因此它自动继承了 HTTP/1 和 HTTP/2 支持、异步功能以及 hyper 被认为是最快之一的 HTTP 实现。
Rust：深入浅出说一说 Error 类型
程序猿视角
09-13 1592
在 Rust 标准库中，`std::io::Error` 是一个用于表示 I/O 操作错误的类型。这个类型是由 Rust 标准库提供的，而不是由用户直接定义的。不过，我们可以根据 Rust 的错误处理机制和类型系统的特点，给出一个示意性的表示，以帮助你理解 `std::io::Error` 是如何被设计的。
Rust组合器
alex wang的博客
06-03 884
Rust 组合器
[译] 通过 Rust 学习解析器组合器 — Part 1
weixin_34121282的博客
06-10 407
原文地址：Learning Parser Combinators With Rust 原文作者：Bodil 译文出自：掘金翻译计划 本文永久链接：github.com/xitu/gold-m… 译者：suhanyujie 本文面向会使用 Rust 编程的人员，提供一些解析器的基础知识。如果不具备其他知识，我们将会介绍和 Rust 无直接关系的所有内容，以及使用 Rust 实现这个会更加超出...
rust 组合算法
zhnxin_163的博客
08-16 896
rust 组合算法 简述 代码 计算下一个组合序号 emmm 求所有组合中的最大和 rust 组合算法 简述 组合：求一个m长的数列，n(n\&amp;lt;= m)个元素的所有组合。 代码 计算下一个组合序号 fn generate_next_index(length :usize,index:&amp;amp;mut Vec&amp;lt;usize&amp;gt;){ ...
用Rust实现23种设计模式之 组合模式
Program with head, not hand
08-03 1804
组合模式是一种结构型设计模式，它允许将对象组合成树状结构，并且能够以统一的方式处理单个对象和组合对象。通过组合模式，我们可以将对象组合成树状结构，以统一的方式处理单个对象和组合对象，提高代码的灵活性和可扩展性。叶子组件表示树中的叶子节点，容器组件表示树中的容器节点，可以包含其他组件。然后，我们将叶子组件添加到容器组件中，并调用容器组件的。方法，用于执行容器组件的操作。在上述代码中，我们首先定义了组件接口。方法，用于向容器中添加和删除组件。函数中，我们创建了两个叶子组件。方法，用于执行叶子组件的操作。
【译】通过 Rust 学习解析器组合器 — Part 1
suhanyujie的专栏
07-13 156
原文地址：Learning Parser Combinators With Rust 原文作者：Bodil 译文出自：掘金翻译计划 本文永久链接：https://github.com/xitu/gold-miner/blob/master/TODO1/learning-parser-combinators-with-rust-1.md 译者：suhanyujie 通过 Rust 学习解析...
nom：Rust解析器组合器框架
02-05
**解析器组合器：** 解析器组合器是一种设计模式，它将解析任务分解为一系列小型、可重用的解析操作。这些解析器可以像函数一样组合起来，创建出能够处理更复杂语法的解析器。在 `nom` 中，每个解析器都是一个函数...
Rust编程艺术：迭代器与闭包的精妙运用
07-25
#### 二、迭代器：Rust 的集合遍历神器 迭代器是 Rust 中一种重要的数据抽象概念，它提供了一种懒加载（lazy）的遍历机制，允许你遍历集合而不需要展开整个集合。迭代器为集合的遍历提供了统一的接口，使得遍历更加...
[译] 通过 Rust 学习解析器组合器 — 第二部分
weixin_34226182的博客
06-15 227
原文地址：Learning Parser Combinators With Rust 原文作者：Bodil 译文出自：掘金翻译计划 本文永久链接：github.com/xitu/gold-m… 译者：suhanyujie 校对者：twang1727 通过 Rust 学习解析器组合器 — 第二部分 如果你没看过本系列的其他几篇文章，建议你按照顺序进行阅读： 通过 Rust 学习解析器组合器...
探索 Combine：Rust 的强大解析器组合库
gitblog_00349的博客
08-12 441
探索 Combine：Rust 的强大解析器组合库 combineA parser combinator library for Rust项目地址:https://gitcode.com/gh_mirrors/co/combine 在现代软件开发中，解析器是处理数据格式和协议的关键组件。Rust 社区中，Combine 库以其高效和灵活性脱颖而出，成为解析器组合库的佼佼者。本文将深入介绍 Com...
Rust用组合实现java中的继承重写
weixin_33724570的博客
08-22 660
2019独角兽企业重金招聘Python工程师标准>>> ...
用Java编写继承重写_Rust用组合实现java中的继承重写
weixin_31328555的博客
02-26 210
先来看看Java的继承和重写是怎么做的吧！##Java继承的示例class Person{private String name;public void setName(String name){this.name = name;}public void say() {System.out.println("我是一个人，名字叫" + this.name);}}// 学生继承人的属性的方法// 添加...
Rust中鼓励组合来代替继承
u013195275的博客
11-30 367
struct People { eaten_apples: i32, } impl People { fn eat_apple(&mut self) { self.eaten_apples += 1; println!("{} apples eaten", self.eaten_apples); } } struct Student { people: People, } impl Student { fn eat_ap.
rust 笔记 高级错误处理
个人博客，记录了本人学习的各种有趣的技术。
12-03 2389
虽然标准库定义了大量的错误类型，但是一个严谨的项目，光使用这些错误类型往往是不够的，例如我们可能会为暴露给用户的错误定义相应的类型。当自定义类型实现该特征后，该类型就可以作为 Err 来使用。实际上，自定义错误类型只需要实现 Debug 和 Display 特征即可，source 方法是可选的，而 Debug 特征往往也无需手动实现，可以直接通过 derive 来派生最简单的错误// AppError 是自定义错误类型，它可以是当前包中定义的任何类型，在这里为了简化，我们使用了单元结构体作为例子。
Rust入坑指南：亡羊补牢
K_Ohaha的博客
01-01 1678
如果你已经开始学习Rust，相信你已经体会过Rust编译器的强大。它可以帮助你避免程序中的大部分错误，但是编译器也不是万能的，如果程序写的不恰当，还是会发生错误，让程序崩溃。所以今天我们就来聊一聊Rust中如何处理程序错误，也就是所谓的“亡羊补牢”。
Rust中Option、Result的map和and_then的区别
qq_44075310的博客
10-09 1006
如果闭包函数返回值也是一个Option\Result的话，那么整体结果就会出现嵌套，此时使用and_then就可以避免.看签名这两个函数返回值都是Result，不同之处在于闭包的返回值，and_then要求我们手动包起来。map和and_then最大区别就是map在链式调用时可能会出现嵌套的Option或者Result.
rust学习之错误处理
最新发布
2301_79967122的博客
09-28 510
为了更好的定义错误，Rust 在标准库中提供了一些可复用的特征，如特征自定义错误类型只需要实现Debug和Display特征就可以作为Err来使用，source方法是可选的，而Debug特征往往也无需手动实现，可以直接通过derive来派生。然而实现Debug和Display特征并不是作为Err// AppError 是自定义错误类型，它可以是当前包中定义的任何类型，在这里为了简化，我们使用了单元结构体作为例子。// 为 AppError 自动派生 Debug 特征。
nom：Rust语言的高效解析器组合器库
资源摘要信息:"nom是一个用Rust编写的解析器组合器库，它的目标是提供构建安全的解析器...总的来说，nom是一个强大的Rust解析器组合器库，它的高性能和安全性使其在处理大型数据流和复杂的数据结构时具有很大的优势。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

许野平

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值