cantrip — Rust中的数据结构 // Lib.rs

8个不稳定版本 (3个破坏性更新)

0.4.0	2024年7月31日
0.3.3	2024年7月23日
0.2.0	2024年7月22日
0.1.1	2024年7月20日

#273 in 数据结构

每月下载量768次

MIT/Apache

700KB
5K SLoC

Rust标准库集合的实用扩展方法。

允许直接以函数式风格操作集合，而不使用通常的迭代器样板代码。

概述

将标准迭代器方法添加到标准库集合中
还包括在集合库中常见的一些附加实用方法
所有方法都将集合实例视为不可变，尽管其中一些会消费它们
修改集合的方法返回一个新的集合，而不是迭代器
性能接近最优，开销仅限于新集合的创建

功能

搜索 - 修改 - 过滤 - 映射 - 检查 - 聚合
选择 - 转换 - 分区 - 合并 - 排序 - 杂项

示例

use cantrip::*;

let a = vec![1, 2, 3];

a.fold(0, |r, x| r + x);                    // 6

a.map_ref(|&x| (x, x)).to_map();            // HashMap::from([(1, 1), (2, 2), (3, 3)])

a.flat_map(|x| [x, -x]).sorted();           // vec![-3, -2, -1, 1, 2, 3]

a.filter(|&x| x > 1).to_set();              // HashSet::from([2, 3])

a.group_by(|x| x % 2);                      // HashMap::from([(0, vec![2]), (1, vec![1, 3])])

a.delete(&1).add(2).unique();               // vec![2, 3]

a.substitute_at(0, 4).to_list();            // LinkedList::from([4, 2, 3])

a.position_multi(|&x| x % 2 == 1);          // vec![0, 2]

a.rev().into_iter().to_deque();             // VecDeque::from([3, 2, 1])

方法

搜索

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
find	*	*	*	*	N
find_map	*		*	*	Y
find_map_ref	*	*	*	*	N
find_position	*	*			N
first	*	*			N
last	*				N
max_by	*	*	*	*	N
max_by_key	*	*	*	*	N
max_of	*	*	*	*	N
min_by	*	*	*	*	N
min_by_key	*	*	*	*	N
min_of	*	*	*	*	N
minmax_by	*	*	*	*	N
minmax_by_key	*	*	*	*	N
minmax_of	*	*	*	*	N
position	*	*			N
position_multi	*	*			N
position_of	*	*			N
position_of_multi	*	*			N
position_sequence	*	*			N
rfind	*	*			N
rposition	*	*			N

修改

方法 / 集合类型	Vec, VecDeque, LinkedList	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
add	*	*	*	Y
add_at	*			Y
add_at_multi	*			Y
add_multi	*	*	*	Y
delete	*	*	*	Y
delete_at	*			Y
delete_at_multi	*			Y
delete_multi	*	*	*	Y
move_at	*			Y
pad_left	*			Y
pad_left_with	*			Y
pad_right	*			Y
pad_right_with	*			Y
rev	*			Y
substitute	*	*	*	Y
substitute_at	*			Y
substitute_at_multi	*			Y
substitute_multi	*	*	*	Y
swap_at	*			Y

过滤

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
duplicates	*				Y
duplicates_by	*				Y
filter	*		*	*	Y
filter_keys				*	Y
filter_map	*		*	*	Y
filter_map_ref	*		*	*	N
filter_ref	*		*	*	N
filter_values				*	Y
init	*				Y
init_ref		*			Y
intersect	*		*	*	Y
largest	*		*		Y
slice	*				Y
smallest	*		*		Y
skip	*				Y
skip_while	*				Y
skip_ref		*			Y
skip_while_ref		*			Y
step_by	*				Y
take	*				Y
take_while	*				Y
take_ref		*			Y
take_while_ref		*			Y
独特	*				Y
按独特性排序	*				Y
尾部	*				Y
尾部引用		*			N

映射

方法 / 集合类型	Vec, VecDeque, LinkedList	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
合并	*			Y
枚举	*			Y
扁平映射	*	*	*	Y
扁平映射引用	*	*	*	N
映射	*	*	*	Y
映射引用	*	*	*	N
映射键			*	Y
映射值			*	Y
映射条件	*			N
扫描	*			Y
扫描引用	*			N

检查

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
全部	*	*	*	*	N
任何	*	*	*	*	N
公共前缀长度	*	*			N
公共后缀长度	*	*			N
按计数	*	*	*	*	N
计数唯一	*	*		*	N
非交集	*	*	*	*	N
等价	*	*			N
频率	*	*			N
按频率排序	*	*			N
子集	*	*	*	*	N
超集	*	*	*	*	N

聚合

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
折叠	*		*	*	Y
折叠引用	*	*	*	*	N
分组折叠	*		*		Y
分组折叠引用	*	*	*		N
分组减少	*		*		Y
分组减少引用	*	*	*		N
乘积	*		*		Y
乘积键				*	Y
乘积值				*	Y
减少	*		*	*	Y
减少引用	*	*	*	*	N
递归折叠	*				Y
递归折叠引用	*	*			N
总和	*		*		Y
总和键				*	Y
总和值				*	Y

选择

方法 / 集合类型	Vec, VecDeque, LinkedList	HashSet, BTreeSet, BinaryHeap	消耗
分块	*		Y
按分块排序	*		Y
精确分块	*		Y
笛卡尔积	*		N
组合	*	*	N
多组合	*		N
幂集	*	*	N
排列	*		N
窗口	*		N
环形窗口	*		N

分区

方法 / 集合类型	Vec, VecDeque, LinkedList	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
分割	*			Y
按分割排序	*			Y
按组排序	*	*		Y
分区	*	*	*	Y
分区	*	*		N
分区映射	*	*	*	Y
分区映射引用	*	*	*	N
解包	*			Y

合并

方法 / 集合类型	Vec, VecDeque, LinkedList	HashSet, BTreeSet, BinaryHeap	消耗
扁平化	*	*	Y
交错	*		Y
精确交错	*		Y
插入	*		Y
插入...	*		Y
连接	*		N
合并	*		Y
按合并排序	*		Y
连接	*		Y
填充	*		Y

排序

方法 / 集合类型	Vec, VecDeque, LinkedList	消耗
排序	*	Y
按排序排序	*	Y
按缓存键排序	*	Y
按键排序	*	Y
不稳定排序	*	Y
按排序排序	*	Y
按键排序	*	Y

转换

方法 / 集合类型	Vec, VecDeque, LinkedList	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
收集	*	*	*	Y
到_bmap	*	*	*	Y
到_bset	*	*	*	Y
到_heap	*	*	*	Y
到_keys			*	Y
到_list	*	*	*	Y
到_map	*	*	*	Y
到_set	*	*	*	Y
到_values			*	Y
到_vec	*	*	*	Y
到_deque	*	*	*	Y

杂项

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
填充	*				Y
用...	*		*	*	Y
遍历	*	*	*	*	N
重复	*
单元	*		*	*	Y

灵感来自

构建

需求

Rust 1.80+

设置

cargo install cargo-make

测试

makers build

基准

makers bench

贡献

请随时打开问题或拉取请求，提出问题、想法、功能、改进或修复。

许可证

根据您的选择，受以下许可证之一许可：

Apache 许可证 2.0 (LICENSE-APACHE或https://apache.ac.cn/licenses/LICENSE-2.0)
MIT 许可证 (LICENSE-MIT或https://open-source.org.cn/licenses/MIT)

。

Rust标准库集合的实用扩展方法。

允许直接以函数式风格操作集合，而不使用通常的迭代器样板代码。

特性

将标准迭代器方法添加到标准库集合中
还包括在集合库中常见的一些附加实用方法
转换方法返回新的集合实例，而不是返回迭代器
所有方法都将集合实例视为不可变，尽管其中一些可能会消耗它们
性能接近最优，开销仅限于新集合的创建

示例

use cantrip::*;

let a = vec![1, 2, 3];

a.fold(0, |r, x| r + x);                    // 6

a.map_ref(|&x| (x, x + 1)).to_map();        // HashMap::from([(1, 2), (2, 3), (3, 4)])

a.flat_map(|x| [x, -x]).sorted();           // vec![-3, -2, -1, 1, 2, 3]

a.filter(|&x| x > 1).into_set();            // HashSet::from([2, 3])

a.group_by(|x| x % 2);                      // HashMap::from([(0, vec![2]), (1, vec![1, 3])])

a.delete(&1).add(2).unique();               // vec![2, 3]

a.substitute_at(0, 4).to_list();            // LinkedList::from([4, 2, 3])

a.position_multi(|&x| x % 2 == 1);          // vec![0, 2]

a.rev().into_iter().into_deque();           // VecDeque::from([3, 2, 1])

方法

搜索

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
find	*	*	*	*	N
find_map	*		*	*	Y
find_map_ref	*	*	*	*	N
find_position	*	*			N
first	*	*			N
last	*				N
position	*	*			N
position_multi	*	*			N
position_of	*	*			N
position_of_multi	*	*			N
position_sequence	*	*			N
rfind	*	*			N
rposition	*	*			N

修改

方法 / 集合类型	Vec, VecDeque, LinkedList	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
add	*	*	*	Y
add_at	*			Y
add_at_multi	*			Y
add_multi	*	*	*	Y
合并	*			Y
delete	*	*	*	Y
delete_at	*			Y
delete_at_multi	*			Y
delete_multi	*	*	*	Y
枚举	*			Y
映射	*	*	*	Y
映射引用	*	*	*	N
映射键			*	Y
映射值			*	Y
映射条件	*			N
move_at	*			Y
pad_left	*			Y
pad_left_with	*			Y
pad_right	*			Y
pad_right_with	*			Y
rev	*			Y
扫描	*			Y
扫描引用	*			N
substitute	*	*	*	Y
substitute_at	*			Y
substitute_at_multi	*			Y
substitute_multi	*	*	*	Y
swap_at	*			Y

过滤

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
duplicates	*				Y
duplicates_by	*				Y
filter	*		*	*	Y
filter_keys				*	Y
filter_map	*		*	*	Y
filter_map_ref	*		*	*	N
filter_ref	*		*	*	N
filter_values				*	Y
init	*	*			Y
largest	*		*		Y
slice	*				Y
smallest	*		*		Y
skip	*	*			Y
skip_while	*	*			Y
step_by	*				Y
take	*	*			Y
take_while	*	*			Y
独特	*				Y
按独特性排序	*				Y
尾部	*	*			Y

检查

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
全部	*	*	*	*	N
任何	*	*	*	*	N
公共前缀长度	*	*			N
公共后缀长度	*	*			N
非交集	*	*	*	*	N
等价	*	*			N
intersect	*		*	*	Y
子集	*	*	*	*	N
超集	*	*	*	*	N

聚合

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
按计数	*	*	*	*	N
计数唯一	*	*		*	N
折叠	*		*	*	Y
折叠引用	*	*	*	*	N
频率	*	*			N
按频率排序	*	*			N
分组折叠	*		*		Y
分组折叠引用	*	*	*		N
分组减少	*		*		Y
分组减少引用	*	*	*		N
max_by	*	*	*	*	N
max_by_key	*	*	*	*	N
max_of	*	*	*	*	N
min_by	*	*	*	*	N
min_by_key	*	*	*	*	N
min_of	*	*	*	*	N
minmax_by	*	*	*	*	N
minmax_by_key	*	*	*	*	N
minmax_of	*	*	*	*	N
乘积	*		*		Y
乘积键				*	Y
乘积值				*	Y
减少	*		*	*	Y
减少引用	*	*	*	*	N
递归折叠	*				Y
递归折叠引用	*	*			N
总和	*		*		Y
总和键				*	Y
总和值				*	Y

选择

方法 / 集合类型	Vec, VecDeque, LinkedList	HashSet, BTreeSet, BinaryHeap	消耗
分块	*		Y
按分块排序	*		Y
精确分块	*		Y
笛卡尔积	*		N
组合	*	*	N
多组合	*		N
幂集	*	*	N
排列	*		N
窗口	*		N
环形窗口	*		N

分区

方法 / 集合类型	Vec, VecDeque, LinkedList	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
分割	*			Y
按分割排序	*			Y
按组排序	*	*		Y
分区	*	*	*	Y
分区映射	*	*	*	Y
分区映射引用	*	*	*	N
解包	*			Y

合并

方法 / 集合类型	Vec, VecDeque, LinkedList	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
扁平映射	*	*	*	Y
扁平映射引用	*	*	*	N
扁平化	*	*		Y
交错	*			Y
精确交错	*			Y
插入	*			Y
插入...	*			Y
连接	*			N
合并	*			Y
按合并排序	*			Y
连接	*			Y
填充	*			Y

排序

方法 / 集合类型	Vec, VecDeque, LinkedList	消耗
排序	*	Y
按排序排序	*	Y
按缓存键排序	*	Y
按键排序	*	Y
不稳定排序	*	Y
按排序排序	*	Y
按键排序	*	Y

转换

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
收集	*	*	*	*	N
collect_to	*	*	*	*	Y
into_bmap	*		*	*	Y
into_bset	*		*	*	Y
into_heap	*		*	*	Y
into_list	*		*	*	Y
into_map	*		*	*	Y
into_set	*		*	*	Y
into_vec	*	*	*	*	Y
into_deque	*		*	*	Y
到_bmap	*	*	*	*	N
到_bset	*	*	*	*	N
到_heap	*	*	*	*	N
到_keys				*	N
到_list	*	*	*	*	N
到_map	*	*	*	*	N
到_set	*	*	*	*	N
到_values				*	N
到_vec	*	*	*	*	N
到_deque	*	*	*	*	N

杂项

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
填充	*				Y
用...	*		*	*	Y
遍历	*	*	*	*	N
重复	*
单元	*		*	*	Y

灵感来自

构建

需求

Rust 1.80+

设置

cargo install cargo-make

测试

makers build

基准

makers bench

贡献

请随时打开问题或拉取请求，提出问题、想法、功能、改进或修复。

许可证

根据您的选择，受以下许可证之一许可：

Apache 许可证 2.0 (LICENSE-APACHE或https://apache.ac.cn/licenses/LICENSE-2.0)
MIT 许可证 (LICENSE-MIT或https://open-source.org.cn/licenses/MIT)

。

Rust标准库集合的实用扩展方法。

允许直接以函数式风格操作集合，而不使用通常的迭代器样板代码。

特性

将标准迭代器方法添加到标准库集合中
还包括在集合库中常见的一些附加实用方法
转换方法返回新的集合实例，而不是返回迭代器
所有方法都将集合实例视为不可变，尽管其中一些可能会消耗它们
性能接近最优，开销仅限于新集合的创建

示例

use cantrip::*;

let a = vec![1, 2, 3];

a.fold(0, |r, x| r + x);                    // 6

a.map_ref(|&x| (x, x + 1)).to_map();        // HashMap::from([(1, 2), (2, 3), (3, 4)])

a.flat_map(|x| [x, -x]).sorted();           // vec![-3, -2, -1, 1, 2, 3]

a.filter(|&x| x > 1).into_set();            // HashSet::from([2, 3])

a.group_by(|x| x % 2);                      // HashMap::from([(0, vec![2]), (1, vec![1, 3])])

a.delete(&1).add(2).unique();               // vec![2, 3]

a.substitute_at(0, 4).to_list();            // LinkedList::from([4, 2, 3])

a.position_multi(|&x| x % 2 == 1);          // vec![0, 2]

a.rev().into_iter().into_deque();           // VecDeque::from([3, 2, 1])

方法

搜索

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
find	*	*	*	*	N
find_map	*		*	*	Y
find_map_ref	*	*	*	*	N
find_position	*	*			N
first	*	*			N
last	*				N
position	*	*			N
position_multi	*	*			N
position_of	*	*			N
position_of_multi	*	*			N
position_sequence	*	*			N
rfind	*	*			N
rposition	*	*			N

修改

方法 / 集合类型	Vec, VecDeque, LinkedList	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
add	*	*	*	Y
add_at	*			Y
add_at_multi	*			Y
add_multi	*	*	*	Y
合并	*			Y
delete	*	*	*	Y
delete_at	*			Y
delete_at_multi	*			Y
delete_multi	*	*	*	Y
枚举	*			Y
映射	*	*	*	Y
映射引用	*	*	*	N
映射键			*	Y
映射值			*	Y
映射条件	*			N
move_at	*			Y
pad_left	*			Y
pad_left_with	*			Y
pad_right	*			Y
pad_right_with	*			Y
rev	*			Y
扫描	*			Y
扫描引用	*			N
substitute	*	*	*	Y
substitute_at	*			Y
substitute_at_multi	*			Y
substitute_multi	*	*	*	Y
swap_at	*			Y

过滤

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
duplicates	*				Y
duplicates_by	*				Y
filter	*		*	*	Y
filter_keys				*	Y
filter_map	*		*	*	Y
filter_map_ref	*		*	*	N
filter_ref	*		*	*	N
filter_values				*	Y
init	*	*			Y
largest	*		*		Y
slice	*				Y
smallest	*		*		Y
skip	*	*			Y
skip_while	*	*			Y
step_by	*				Y
take	*	*			Y
take_while	*	*			Y
独特	*				Y
按独特性排序	*				Y
尾部	*	*			Y

检查

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
全部	*	*	*	*	N
任何	*	*	*	*	N
公共前缀长度	*	*			N
公共后缀长度	*	*			N
非交集	*	*	*	*	N
等价	*	*			N
intersect	*		*	*	Y
子集	*	*	*	*	N
超集	*	*	*	*	N

聚合

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
按计数	*	*	*	*	N
计数唯一	*	*		*	N
折叠	*		*	*	Y
折叠引用	*	*	*	*	N
频率	*	*			N
按频率排序	*	*			N
分组折叠	*		*		Y
分组折叠引用	*	*	*		N
分组减少	*		*		Y
分组减少引用	*	*	*		N
max_by	*	*	*	*	N
max_by_key	*	*	*	*	N
max_of	*	*	*	*	N
min_by	*	*	*	*	N
min_by_key	*	*	*	*	N
min_of	*	*	*	*	N
minmax_by	*	*	*	*	N
minmax_by_key	*	*	*	*	N
minmax_of	*	*	*	*	N
乘积	*		*		Y
乘积键				*	Y
乘积值				*	Y
减少	*		*	*	Y
减少引用	*	*	*	*	N
递归折叠	*				Y
递归折叠引用	*	*			N
总和	*		*		Y
总和键				*	Y
总和值				*	Y

选择

方法 / 集合类型	Vec, VecDeque, LinkedList	HashSet, BTreeSet, BinaryHeap	消耗
分块	*		Y
按分块排序	*		Y
精确分块	*		Y
笛卡尔积	*		N
组合	*	*	N
多组合	*		N
幂集	*	*	N
排列	*		N
窗口	*		N
环形窗口	*		N

分区

方法 / 集合类型	Vec, VecDeque, LinkedList	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
分割	*			Y
按分割排序	*			Y
按组排序	*	*		Y
分区	*	*	*	Y
分区映射	*	*	*	Y
分区映射引用	*	*	*	N
解包	*			Y

合并

方法 / 集合类型	Vec, VecDeque, LinkedList	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
扁平映射	*	*	*	Y
扁平映射引用	*	*	*	N
扁平化	*	*		Y
交错	*			Y
精确交错	*			Y
插入	*			Y
插入...	*			Y
连接	*			N
合并	*			Y
按合并排序	*			Y
连接	*			Y
填充	*			Y

排序

方法 / 集合类型	Vec, VecDeque, LinkedList	消耗
排序	*	Y
按排序排序	*	Y
按缓存键排序	*	Y
按键排序	*	Y
不稳定排序	*	Y
按排序排序	*	Y
按键排序	*	Y

转换

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
收集	*	*	*	*	N
collect_to	*	*	*	*	Y
into_bmap	*		*	*	Y
into_bset	*		*	*	Y
into_heap	*		*	*	Y
into_list	*		*	*	Y
into_map	*		*	*	Y
into_set	*		*	*	Y
into_vec	*	*	*	*	Y
into_deque	*		*	*	Y
到_bmap	*	*	*	*	N
到_bset	*	*	*	*	N
到_heap	*	*	*	*	N
到_keys				*	N
到_list	*	*	*	*	N
到_map	*	*	*	*	N
到_set	*	*	*	*	N
到_values				*	N
到_vec	*	*	*	*	N
到_deque	*	*	*	*	N

杂项

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
填充	*				Y
用...	*		*	*	Y
遍历	*	*	*	*	N
重复	*
单元	*		*	*	Y

灵感来自

构建

需求

Rust 1.80+

设置

cargo install cargo-make

测试

makers build

基准

makers bench

贡献

请随时打开问题或拉取请求，提出问题、想法、功能、改进或修复。

许可证

根据您的选择，受以下许可证之一许可：

Apache 许可证 2.0 (LICENSE-APACHE或https://apache.ac.cn/licenses/LICENSE-2.0)
MIT 许可证 (LICENSE-MIT或https://open-source.org.cn/licenses/MIT)

。

Rust标准库集合的实用扩展方法。

允许直接以函数式风格操作集合，而不使用通常的迭代器样板代码。

特性

将标准迭代器方法添加到标准库集合中
还包括在集合库中常见的一些附加实用方法
转换方法返回新的集合实例，而不是返回迭代器
所有方法都将集合实例视为不可变，尽管其中一些可能会消耗它们
性能接近最优，开销仅限于新集合的创建

示例

use cantrip::*;

let a = vec![1, 2, 3];

a.fold(0, |r, x| r + x);                    // 6

a.map_ref(|&x| (x, x + 1)).to_map();        // HashMap::from([(1, 2), (2, 3), (3, 4)])

a.flat_map(|x| [x, -x]).sorted();           // vec![-3, -2, -1, 1, 2, 3]

a.filter(|&x| x > 1).into_set();            // HashSet::from([2, 3])

a.group_by(|x| x % 2);                      // HashMap::from([(0, vec![2]), (1, vec![1, 3])])

a.delete(&1).add(2).unique();               // vec![2, 3]

a.substitute_at(0, 4).to_list();            // LinkedList::from([4, 2, 3])

a.position_multi(|&x| x % 2 == 1);          // vec![0, 2]

a.rev().into_iter().into_deque();           // VecDeque::from([3, 2, 1])

方法

搜索

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
find	*	*	*	*	N
find_map	*		*	*	Y
find_map_ref	*	*	*	*	N
find_position	*	*			N
first	*	*			N
last	*				N
position	*	*			N
position_multi	*	*			N
position_of	*	*			N
position_of_multi	*	*			N
position_sequence	*	*			N
rfind	*	*			N
rposition	*	*			N

修改

方法 / 集合类型	Vec, VecDeque, LinkedList	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
add	*	*	*	Y
add_at	*			Y
add_at_multi	*			Y
add_multi	*	*	*	Y
合并	*			Y
delete	*	*	*	Y
delete_at	*			Y
delete_at_multi	*			Y
delete_multi	*	*	*	Y
枚举	*			Y
映射	*	*	*	Y
映射引用	*	*	*	N
映射键			*	Y
映射值			*	Y
映射条件	*			N
move_at	*			Y
pad_left	*			Y
pad_left_with	*			Y
pad_right	*			Y
pad_right_with	*			Y
rev	*			Y
扫描	*			Y
扫描引用	*			N
substitute	*	*	*	Y
substitute_at	*			Y
substitute_at_multi	*			Y
substitute_multi	*	*	*	Y
swap_at	*			Y

过滤

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
duplicates	*				Y
duplicates_by	*				Y
filter	*		*	*	Y
filter_keys				*	Y
filter_map	*		*	*	Y
filter_map_ref	*		*	*	N
filter_ref	*		*	*	N
filter_values				*	Y
init	*	*			Y
largest	*		*		Y
slice	*				Y
smallest	*		*		Y
skip	*	*			Y
skip_while	*	*			Y
step_by	*				Y
take	*	*			Y
take_while	*	*			Y
独特	*				Y
按独特性排序	*				Y
尾部	*	*			Y

检查

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
全部	*	*	*	*	N
任何	*	*	*	*	N
公共前缀长度	*	*			N
公共后缀长度	*	*			N
非交集	*	*	*	*	N
等价	*	*			N
intersect	*		*	*	Y
子集	*	*	*	*	N
超集	*	*	*	*	N

聚合

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
按计数	*	*	*	*	N
计数唯一	*	*		*	N
折叠	*		*	*	Y
折叠引用	*	*	*	*	N
频率	*	*			N
按频率排序	*	*			N
分组折叠	*		*		Y
分组折叠引用	*	*	*		N
分组减少	*		*		Y
分组减少引用	*	*	*		N
max_by	*	*	*	*	N
max_by_key	*	*	*	*	N
max_of	*	*	*	*	N
min_by	*	*	*	*	N
min_by_key	*	*	*	*	N
min_of	*	*	*	*	N
minmax_by	*	*	*	*	N
minmax_by_key	*	*	*	*	N
minmax_of	*	*	*	*	N
乘积	*		*		Y
乘积键				*	Y
乘积值				*	Y
减少	*		*	*	Y
减少引用	*	*	*	*	N
递归折叠	*				Y
递归折叠引用	*	*			N
总和	*		*		Y
总和键				*	Y
总和值				*	Y

选择

方法 / 集合类型	Vec, VecDeque, LinkedList	HashSet, BTreeSet, BinaryHeap	消耗
分块	*		Y
按分块排序	*		Y
精确分块	*		Y
笛卡尔积	*		N
组合	*	*	N
多组合	*		N
幂集	*	*	N
排列	*		N
窗口	*		N
环形窗口	*		N

分区

方法 / 集合类型	Vec, VecDeque, LinkedList	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
分割	*			Y
按分割排序	*			Y
按组排序	*	*		Y
分区	*	*	*	Y
分区映射	*	*	*	Y
分区映射引用	*	*	*	N
解包	*			Y

合并

方法 / 集合类型	Vec, VecDeque, LinkedList	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
扁平映射	*	*	*	Y
扁平映射引用	*	*	*	N
扁平化	*	*		Y
交错	*			Y
精确交错	*			Y
插入	*			Y
插入...	*			Y
连接	*			N
合并	*			Y
按合并排序	*			Y
连接	*			Y
填充	*			Y

排序

方法 / 集合类型	Vec, VecDeque, LinkedList	消耗
排序	*	Y
按排序排序	*	Y
按缓存键排序	*	Y
按键排序	*	Y
不稳定排序	*	Y
按排序排序	*	Y
按键排序	*	Y

转换

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
收集	*	*	*	*	N
collect_to	*	*	*	*	Y
into_bmap	*		*	*	Y
into_bset	*		*	*	Y
into_heap	*		*	*	Y
into_list	*		*	*	Y
into_map	*		*	*	Y
into_set	*		*	*	Y
into_vec	*	*	*	*	Y
into_deque	*		*	*	Y
到_bmap	*	*	*	*	N
到_bset	*	*	*	*	N
到_heap	*	*	*	*	N
到_keys				*	N
到_list	*	*	*	*	N
到_map	*	*	*	*	N
到_set	*	*	*	*	N
到_values				*	N
到_vec	*	*	*	*	N
到_deque	*	*	*	*	N

杂项

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
填充	*				Y
用...	*		*	*	Y
遍历	*	*	*	*	N
重复	*
单元	*		*	*	Y

灵感来自

构建

需求

Rust 1.80+

设置

cargo install cargo-make

测试

makers build

基准

makers bench

贡献

请随时打开问题或拉取请求，提出问题、想法、功能、改进或修复。

许可证

根据您的选择，受以下许可证之一许可：

Apache 许可证 2.0 (LICENSE-APACHE或https://apache.ac.cn/licenses/LICENSE-2.0)
MIT 许可证 (LICENSE-MIT或https://open-source.org.cn/licenses/MIT)

。

Rust标准库集合的实用扩展方法。

允许直接以函数式风格操作集合，而不使用通常的迭代器样板代码。

特性

将标准迭代器方法添加到标准库集合中
还包括在集合库中常见的一些附加实用方法
转换方法返回新的集合实例，而不是返回迭代器
所有方法都将集合实例视为不可变，尽管其中一些可能会消耗它们
性能接近最优，开销仅限于新集合的创建

示例

use cantrip::*;

let a = vec![1, 2, 3];

a.fold(0, |r, x| r + x);                    // 6

a.map_ref(|&x| (x, x + 1)).to_map();        // HashMap::from([(1, 2), (2, 3), (3, 4)])

a.flat_map(|x| [x, -x]).sorted();           // vec![-3, -2, -1, 1, 2, 3]

a.filter(|&x| x > 1).into_set();            // HashSet::from([2, 3])

a.group_by(|x| x % 2);                      // HashMap::from([(0, vec![2]), (1, vec![1, 3])])

a.delete(&1).add(2).unique();               // vec![2, 3]

a.substitute_at(0, 4).to_list();            // LinkedList::from([4, 2, 3])

a.position_multi(|&x| x % 2 == 1);          // vec![0, 2]

a.rev().into_iter().into_deque();           // VecDeque::from([3, 2, 1])

方法

搜索

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
find	*	*	*	*	N
find_map	*		*	*	Y
find_map_ref	*	*	*	*	N
find_position	*	*			N
first	*	*			N
last	*				N
position	*	*			N
position_multi	*	*			N
position_of	*	*			N
position_of_multi	*	*			N
position_sequence	*	*			N
rfind	*	*			N
rposition	*	*			N

修改

方法 / 集合类型	Vec, VecDeque, LinkedList	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
add	*	*	*	Y
add_at	*			Y
add_at_multi	*			Y
add_multi	*	*	*	Y
合并	*			Y
delete	*	*	*	Y
delete_at	*			Y
delete_at_multi	*			Y
delete_multi	*	*	*	Y
枚举	*			Y
映射	*	*	*	Y
映射引用	*	*	*	N
映射键			*	Y
映射值			*	Y
映射条件	*			N
move_at	*			Y
pad_left	*			Y
pad_left_with	*			Y
pad_right	*			Y
pad_right_with	*			Y
rev	*			Y
扫描	*			Y
扫描引用	*			N
substitute	*	*	*	Y
substitute_at	*			Y
substitute_at_multi	*			Y
substitute_multi	*	*	*	Y
swap_at	*			Y

过滤

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
duplicates	*				Y
duplicates_by	*				Y
filter	*		*	*	Y
filter_keys				*	Y
filter_map	*		*	*	Y
filter_map_ref	*		*	*	N
filter_ref	*		*	*	N
filter_values				*	Y
init	*	*			Y
largest	*		*		Y
slice	*				Y
smallest	*		*		Y
skip	*	*			Y
skip_while	*	*			Y
step_by	*				Y
take	*	*			Y
take_while	*	*			Y
独特	*				Y
按独特性排序	*				Y
尾部	*	*			Y

检查

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
全部	*	*	*	*	N
任何	*	*	*	*	N
公共前缀长度	*	*			N
公共后缀长度	*	*			N
非交集	*	*	*	*	N
等价	*	*			N
intersect	*		*	*	Y
子集	*	*	*	*	N
超集	*	*	*	*	N

聚合

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
按计数	*	*	*	*	N
计数唯一	*	*		*	N
折叠	*		*	*	Y
折叠引用	*	*	*	*	N
频率	*	*			N
按频率排序	*	*			N
分组折叠	*		*		Y
分组折叠引用	*	*	*		N
分组减少	*		*		Y
分组减少引用	*	*	*		N
max_by	*	*	*	*	N
max_by_key	*	*	*	*	N
max_of	*	*	*	*	N
min_by	*	*	*	*	N
min_by_key	*	*	*	*	N
min_of	*	*	*	*	N
minmax_by	*	*	*	*	N
minmax_by_key	*	*	*	*	N
minmax_of	*	*	*	*	N
乘积	*		*		Y
乘积键				*	Y
乘积值				*	Y
减少	*		*	*	Y
减少引用	*	*	*	*	N
递归折叠	*				Y
递归折叠引用	*	*			N
总和	*		*		Y
总和键				*	Y
总和值				*	Y

选择

方法 / 集合类型	Vec, VecDeque, LinkedList	HashSet, BTreeSet, BinaryHeap	消耗
分块	*		Y
按分块排序	*		Y
精确分块	*		Y
笛卡尔积	*		N
组合	*	*	N
多组合	*		N
幂集	*	*	N
排列	*		N
窗口	*		N
环形窗口	*		N

分区

方法 / 集合类型	Vec, VecDeque, LinkedList	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
分割	*			Y
按分割排序	*			Y
按组排序	*	*		Y
分区	*	*	*	Y
分区映射	*	*	*	Y
分区映射引用	*	*	*	N
解包	*			Y

合并

方法 / 集合类型	Vec, VecDeque, LinkedList	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
扁平映射	*	*	*	Y
扁平映射引用	*	*	*	N
扁平化	*	*		Y
交错	*			Y
精确交错	*			Y
插入	*			Y
插入...	*			Y
连接	*			N
合并	*			Y
按合并排序	*			Y
连接	*			Y
填充	*			Y

排序

方法 / 集合类型	Vec, VecDeque, LinkedList	消耗
排序	*	Y
按排序排序	*	Y
按缓存键排序	*	Y
按键排序	*	Y
不稳定排序	*	Y
按排序排序	*	Y
按键排序	*	Y

转换

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
收集	*	*	*	*	N
collect_to	*	*	*	*	Y
into_bmap	*		*	*	Y
into_bset	*		*	*	Y
into_heap	*		*	*	Y
into_list	*		*	*	Y
into_map	*		*	*	Y
into_set	*		*	*	Y
into_vec	*	*	*	*	Y
into_deque	*		*	*	Y
到_bmap	*	*	*	*	N
到_bset	*	*	*	*	N
到_heap	*	*	*	*	N
到_keys				*	N
到_list	*	*	*	*	N
到_map	*	*	*	*	N
到_set	*	*	*	*	N
到_values				*	N
到_vec	*	*	*	*	N
到_deque	*	*	*	*	N

杂项

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
填充	*				Y
用...	*		*	*	Y
遍历	*	*	*	*	N
重复	*
单元	*		*	*	Y

灵感来自

构建

需求

Rust 1.80+

设置

cargo install cargo-make

测试

makers build

基准

makers bench

贡献

请随时打开问题或拉取请求，提出问题、想法、功能、改进或修复。

许可证

根据您的选择，受以下许可证之一许可：

Apache 许可证 2.0 (LICENSE-APACHE或https://apache.ac.cn/licenses/LICENSE-2.0)
MIT 许可证 (LICENSE-MIT或https://open-source.org.cn/licenses/MIT)

。

Rust标准库集合的实用扩展方法。

允许直接以函数式风格操作集合，而不使用通常的迭代器样板代码。

特性

将标准迭代器方法添加到标准库集合中
还包括在集合库中常见的一些附加实用方法
转换方法返回新的集合实例，而不是返回迭代器
所有方法都将集合实例视为不可变，尽管其中一些可能会消耗它们
性能接近最优，开销仅限于新集合的创建

示例

use cantrip::*;

let a = vec![1, 2, 3];

a.fold(0, |r, x| r + x);                    // 6

a.map_ref(|&x| (x, x + 1)).to_map();        // HashMap::from([(1, 2), (2, 3), (3, 4)])

a.flat_map(|x| [x, -x]).sorted();           // vec![-3, -2, -1, 1, 2, 3]

a.filter(|&x| x > 1).into_set();            // HashSet::from([2, 3])

a.group_by(|x| x % 2);                      // HashMap::from([(0, vec![2]), (1, vec![1, 3])])

a.delete(&1).add(2).unique();               // vec![2, 3]

a.substitute_at(0, 4).to_list();            // LinkedList::from([4, 2, 3])

a.position_multi(|&x| x % 2 == 1);          // vec![0, 2]

a.rev().into_iter().into_deque();           // VecDeque::from([3, 2, 1])

方法

搜索

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
find	*	*	*	*	N
find_map	*		*	*	Y
find_map_ref	*	*	*	*	N
find_position	*	*			N
first	*	*			N
last	*				N
position	*	*			N
position_multi	*	*			N
position_of	*	*			N
position_of_multi	*	*			N
position_sequence	*	*			N
rfind	*	*			N
rposition	*	*			N

修改

方法 / 集合类型	Vec, VecDeque, LinkedList	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
add	*	*	*	Y
add_at	*			Y
add_at_multi	*			Y
add_multi	*	*	*	Y
合并	*			Y
delete	*	*	*	Y
delete_at	*			Y
delete_at_multi	*			Y
delete_multi	*	*	*	Y
枚举	*			Y
映射	*	*	*	Y
映射引用	*	*	*	N
映射键			*	Y
映射值			*	Y
映射条件	*			N
move_at	*			Y
pad_left	*			Y
pad_left_with	*			Y
pad_right	*			Y
pad_right_with	*			Y
rev	*			Y
扫描	*			Y
扫描引用	*			N
substitute	*	*	*	Y
substitute_at	*			Y
substitute_at_multi	*			Y
substitute_multi	*	*	*	Y
swap_at	*			Y

过滤

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
duplicates	*				Y
duplicates_by	*				Y
filter	*		*	*	Y
filter_keys				*	Y
filter_map	*		*	*	Y
filter_map_ref	*		*	*	N
filter_ref	*		*	*	N
filter_values				*	Y
init	*	*			Y
largest	*		*		Y
slice	*				Y
smallest	*		*		Y
skip	*	*			Y
skip_while	*	*			Y
step_by	*				Y
take	*	*			Y
take_while	*	*			Y
独特	*				Y
按独特性排序	*				Y
尾部	*	*			Y

检查

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
全部	*	*	*	*	N
任何	*	*	*	*	N
公共前缀长度	*	*			N
公共后缀长度	*	*			N
非交集	*	*	*	*	N
等价	*	*			N
intersect	*		*	*	Y
子集	*	*	*	*	N
超集	*	*	*	*	N

聚合

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
按计数	*	*	*	*	N
计数唯一	*	*		*	N
折叠	*		*	*	Y
折叠引用	*	*	*	*	N
频率	*	*			N
按频率排序	*	*			N
分组折叠	*		*		Y
分组折叠引用	*	*	*		N
分组减少	*		*		Y
分组减少引用	*	*	*		N
max_by	*	*	*	*	N
max_by_key	*	*	*	*	N
max_of	*	*	*	*	N
min_by	*	*	*	*	N
min_by_key	*	*	*	*	N
min_of	*	*	*	*	N
minmax_by	*	*	*	*	N
minmax_by_key	*	*	*	*	N
minmax_of	*	*	*	*	N
乘积	*		*		Y
乘积键				*	Y
乘积值				*	Y
减少	*		*	*	Y
减少引用	*	*	*	*	N
递归折叠	*				Y
递归折叠引用	*	*			N
总和	*		*		Y
总和键				*	Y
总和值				*	Y

选择

方法 / 集合类型	Vec, VecDeque, LinkedList	HashSet, BTreeSet, BinaryHeap	消耗
分块	*		Y
按分块排序	*		Y
精确分块	*		Y
笛卡尔积	*		N
组合	*	*	N
多组合	*		N
幂集	*	*	N
排列	*		N
窗口	*		N
环形窗口	*		N

分区

方法 / 集合类型	Vec, VecDeque, LinkedList	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
分割	*			Y
按分割排序	*			Y
按组排序	*	*		Y
分区	*	*	*	Y
分区映射	*	*	*	Y
分区映射引用	*	*	*	N
解包	*			Y

合并

方法 / 集合类型	Vec, VecDeque, LinkedList	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
扁平映射	*	*	*	Y
扁平映射引用	*	*	*	N
扁平化	*	*		Y
交错	*			Y
精确交错	*			Y
插入	*			Y
插入...	*			Y
连接	*			N
合并	*			Y
按合并排序	*			Y
连接	*			Y
填充	*			Y

排序

方法 / 集合类型	Vec, VecDeque, LinkedList	消耗
排序	*	Y
按排序排序	*	Y
按缓存键排序	*	Y
按键排序	*	Y
不稳定排序	*	Y
按排序排序	*	Y
按键排序	*	Y

转换

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
收集	*	*	*	*	N
collect_to	*	*	*	*	Y
into_bmap	*		*	*	Y
into_bset	*		*	*	Y
into_heap	*		*	*	Y
into_list	*		*	*	Y
into_map	*		*	*	Y
into_set	*		*	*	Y
into_vec	*	*	*	*	Y
into_deque	*		*	*	Y
到_bmap	*	*	*	*	N
到_bset	*	*	*	*	N
到_heap	*	*	*	*	N
到_keys				*	N
到_list	*	*	*	*	N
到_map	*	*	*	*	N
到_set	*	*	*	*	N
到_values				*	N
到_vec	*	*	*	*	N
到_deque	*	*	*	*	N

杂项

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
填充	*				Y
用...	*		*	*	Y
遍历	*	*	*	*	N
重复	*
单元	*		*	*	Y

灵感来自

构建

需求

Rust 1.80+

设置

cargo install cargo-make

测试

makers build

基准

makers bench

贡献

请随时打开问题或拉取请求，提出问题、想法、功能、改进或修复。

许可证

根据您的选择，受以下许可证之一许可：

Apache 许可证 2.0 (LICENSE-APACHE或https://apache.ac.cn/licenses/LICENSE-2.0)
MIT 许可证 (LICENSE-MIT或https://open-source.org.cn/licenses/MIT)

。

Rust标准库集合的实用扩展方法。

允许直接以函数式风格操作集合，而不使用通常的迭代器样板代码。

特性

将标准迭代器方法添加到标准库集合中
还包括在集合库中常见的一些附加实用方法
转换方法返回新的集合实例，而不是返回迭代器
所有方法都将集合实例视为不可变，尽管其中一些可能会消耗它们
性能接近最优，开销仅限于新集合的创建

示例

use cantrip::*;

let a = vec![1, 2, 3];

a.fold(0, |r, x| r + x);                    // 6

a.map_ref(|&x| (x, x + 1)).to_map();        // HashMap::from([(1, 2), (2, 3), (3, 4)])

a.flat_map(|x| [x, -x]).sorted();           // vec![-3, -2, -1, 1, 2, 3]

a.filter(|&x| x > 1).into_set();            // HashSet::from([2, 3])

a.group_by(|x| x % 2);                      // HashMap::from([(0, vec![2]), (1, vec![1, 3])])

a.delete(&1).add(2).unique();               // vec![2, 3]

a.substitute_at(0, 4).to_list();            // LinkedList::from([4, 2, 3])

a.position_multi(|&x| x % 2 == 1);          // vec![0, 2]

a.rev().into_iter().into_deque();           // VecDeque::from([3, 2, 1])

方法

搜索

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
find	*	*	*	*	N
find_map	*		*	*	Y
find_map_ref	*	*	*	*	N
find_position	*	*			N
first	*	*			N
last	*				N
position	*	*			N
position_multi	*	*			N
position_of	*	*			N
position_of_multi	*	*			N
position_sequence	*	*			N
rfind	*	*			N
rposition	*	*			N

修改

方法 / 集合类型	Vec, VecDeque, LinkedList	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
add	*	*	*	Y
add_at	*			Y
add_at_multi	*			Y
add_multi	*	*	*	Y
合并	*			Y
delete	*	*	*	Y
delete_at	*			Y
delete_at_multi	*			Y
delete_multi	*	*	*	Y
枚举	*			Y
映射	*	*	*	Y
映射引用	*	*	*	N
映射键			*	Y
映射值			*	Y
映射条件	*			N
move_at	*			Y
pad_left	*			Y
pad_left_with	*			Y
pad_right	*			Y
pad_right_with	*			Y
rev	*			Y
扫描	*			Y
扫描引用	*			N
substitute	*	*	*	Y
substitute_at	*			Y
substitute_at_multi	*			Y
substitute_multi	*	*	*	Y
swap_at	*			Y

过滤

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
duplicates	*				Y
duplicates_by	*				Y
filter	*		*	*	Y
filter_keys				*	Y
filter_map	*		*	*	Y
filter_map_ref	*		*	*	N
filter_ref	*		*	*	N
filter_values				*	Y
init	*	*			Y
largest	*		*		Y
slice	*				Y
smallest	*		*		Y
skip	*	*			Y
skip_while	*	*			Y
step_by	*				Y
take	*	*			Y
take_while	*	*			Y
独特	*				Y
按独特性排序	*				Y
尾部	*	*			Y

检查

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
全部	*	*	*	*	N
任何	*	*	*	*	N
公共前缀长度	*	*			N
公共后缀长度	*	*			N
非交集	*	*	*	*	N
等价	*	*			N
intersect	*		*	*	Y
子集	*	*	*	*	N
超集	*	*	*	*	N

聚合

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
按计数	*	*	*	*	N
计数唯一	*	*		*	N
折叠	*		*	*	Y
折叠引用	*	*	*	*	N
频率	*	*			N
按频率排序	*	*			N
分组折叠	*		*		Y
分组折叠引用	*	*	*		N
分组减少	*		*		Y
分组减少引用	*	*	*		N
max_by	*	*	*	*	N
max_by_key	*	*	*	*	N
max_of	*	*	*	*	N
min_by	*	*	*	*	N
min_by_key	*	*	*	*	N
min_of	*	*	*	*	N
minmax_by	*	*	*	*	N
minmax_by_key	*	*	*	*	N
minmax_of	*	*	*	*	N
乘积	*		*		Y
乘积键				*	Y
乘积值				*	Y
减少	*		*	*	Y
减少引用	*	*	*	*	N
递归折叠	*				Y
递归折叠引用	*	*			N
总和	*		*		Y
总和键				*	Y
总和值				*	Y

选择

方法 / 集合类型	Vec, VecDeque, LinkedList	HashSet, BTreeSet, BinaryHeap	消耗
分块	*		Y
按分块排序	*		Y
精确分块	*		Y
笛卡尔积	*		N
组合	*	*	N
多组合	*		N
幂集	*	*	N
排列	*		N
窗口	*		N
环形窗口	*		N

分区

方法 / 集合类型	Vec, VecDeque, LinkedList	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
分割	*			Y
按分割排序	*			Y
按组排序	*	*		Y
分区	*	*	*	Y
分区映射	*	*	*	Y
分区映射引用	*	*	*	N
解包	*			Y

合并

方法 / 集合类型	Vec, VecDeque, LinkedList	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
扁平映射	*	*	*	Y
扁平映射引用	*	*	*	N
扁平化	*	*		Y
交错	*			Y
精确交错	*			Y
插入	*			Y
插入...	*			Y
连接	*			N
合并	*			Y
按合并排序	*			Y
连接	*			Y
填充	*			Y

排序

方法 / 集合类型	Vec, VecDeque, LinkedList	消耗
排序	*	Y
按排序排序	*	Y
按缓存键排序	*	Y
按键排序	*	Y
不稳定排序	*	Y
按排序排序	*	Y
按键排序	*	Y

转换

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
收集	*	*	*	*	N
collect_to	*	*	*	*	Y
into_bmap	*		*	*	Y
into_bset	*		*	*	Y
into_heap	*		*	*	Y
into_list	*		*	*	Y
into_map	*		*	*	Y
into_set	*		*	*	Y
into_vec	*	*	*	*	Y
into_deque	*		*	*	Y
到_bmap	*	*	*	*	N
到_bset	*	*	*	*	N
到_heap	*	*	*	*	N
到_keys				*	N
到_list	*	*	*	*	N
到_map	*	*	*	*	N
到_set	*	*	*	*	N
到_values				*	N
到_vec	*	*	*	*	N
到_deque	*	*	*	*	N

杂项

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
填充	*				Y
用...	*		*	*	Y
遍历	*	*	*	*	N
重复	*
单元	*		*	*	Y

灵感来自

构建

需求

Rust 1.80+

设置

cargo install cargo-make

测试

makers build

基准

makers bench

贡献

请随时打开问题或拉取请求，提出问题、想法、功能、改进或修复。

许可证

根据您的选择，受以下许可证之一许可：

Apache 许可证 2.0 (LICENSE-APACHE或https://apache.ac.cn/licenses/LICENSE-2.0)
MIT 许可证 (LICENSE-MIT或https://open-source.org.cn/licenses/MIT)

。

Rust标准库集合的实用扩展方法。

允许直接以函数式风格操作集合，而不使用通常的迭代器样板代码。

特性

将标准迭代器方法添加到标准库集合中
还包括在集合库中常见的一些附加实用方法
转换方法返回新的集合实例，而不是返回迭代器
所有方法都将集合实例视为不可变，尽管其中一些可能会消耗它们
性能接近最优，开销仅限于新集合的创建

示例

use cantrip::*;

let a = vec![1, 2, 3];

a.fold(0, |r, x| r + x);                    // 6

a.map_ref(|&x| (x, x + 1)).to_map();        // HashMap::from([(1, 2), (2, 3), (3, 4)])

a.flat_map(|x| [x, -x]).sorted();           // vec![-3, -2, -1, 1, 2, 3]

a.filter(|&x| x > 1).into_set();            // HashSet::from([2, 3])

a.group_by(|x| x % 2);                      // HashMap::from([(0, vec![2]), (1, vec![1, 3])])

a.delete(&1).add(2).unique();               // vec![2, 3]

a.substitute_at(0, 4).to_list();            // LinkedList::from([4, 2, 3])

a.position_multi(|&x| x % 2 == 1);          // vec![0, 2]

a.rev().into_iter().into_deque();           // VecDeque::from([3, 2, 1])

方法

搜索

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
find	*	*	*	*	N
find_map	*		*	*	Y
find_map_ref	*	*	*	*	N
find_position	*	*			N
first	*	*			N
last	*				N
position	*	*			N
position_multi	*	*			N
position_of	*	*			N
position_of_multi	*	*			N
position_sequence	*	*			N
rfind	*	*			N
rposition	*	*			N

修改

方法 / 集合类型	Vec, VecDeque, LinkedList	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
add	*	*	*	Y
add_at	*			Y
add_at_multi	*			Y
add_multi	*	*	*	Y
合并	*			Y
delete	*	*	*	Y
delete_at	*			Y
delete_at_multi	*			Y
delete_multi	*	*	*	Y
枚举	*			Y
映射	*	*	*	Y
映射引用	*	*	*	N
映射键			*	Y
映射值			*	Y
映射条件	*			N
move_at	*			Y
pad_left	*			Y
pad_left_with	*			Y
pad_right	*			Y
pad_right_with	*			Y
rev	*			Y
扫描	*			Y
扫描引用	*			N
substitute	*	*	*	Y
substitute_at	*			Y
substitute_at_multi	*			Y
substitute_multi	*	*	*	Y
swap_at	*			Y

过滤

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
duplicates	*				Y
duplicates_by	*				Y
filter	*		*	*	Y
filter_keys				*	Y
filter_map	*		*	*	Y
filter_map_ref	*		*	*	N
filter_ref	*		*	*	N
filter_values				*	Y
init	*	*			Y
largest	*		*		Y
slice	*				Y
smallest	*		*		Y
skip	*	*			Y
skip_while	*	*			Y
step_by	*				Y
take	*	*			Y
take_while	*	*			Y
独特	*				Y
按独特性排序	*				Y
尾部	*	*			Y

检查

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
全部	*	*	*	*	N
任何	*	*	*	*	N
公共前缀长度	*	*			N
公共后缀长度	*	*			N
非交集	*	*	*	*	N
等价	*	*			N
intersect	*		*	*	Y
子集	*	*	*	*	N
超集	*	*	*	*	N

聚合

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
按计数	*	*	*	*	N
计数唯一	*	*		*	N
折叠	*		*	*	Y
折叠引用	*	*	*	*	N
频率	*	*			N
按频率排序	*	*			N
分组折叠	*		*		Y
分组折叠引用	*	*	*		N
分组减少	*		*		Y
分组减少引用	*	*	*		N
max_by	*	*	*	*	N
max_by_key	*	*	*	*	N
max_of	*	*	*	*	N
min_by	*	*	*	*	N
min_by_key	*	*	*	*	N
min_of	*	*	*	*	N
minmax_by	*	*	*	*	N
minmax_by_key	*	*	*	*	N
minmax_of	*	*	*	*	N
乘积	*		*		Y
乘积键				*	Y
乘积值				*	Y
减少	*		*	*	Y
减少引用	*	*	*	*	N
递归折叠	*				Y
递归折叠引用	*	*			N
总和	*		*		Y
总和键				*	Y
总和值				*	Y

选择

方法 / 集合类型	Vec, VecDeque, LinkedList	HashSet, BTreeSet, BinaryHeap	消耗
分块	*		Y
按分块排序	*		Y
精确分块	*		Y
笛卡尔积	*		N
组合	*	*	N
多组合	*		N
幂集	*	*	N
排列	*		N
窗口	*		N
环形窗口	*		N

分区

方法 / 集合类型	Vec, VecDeque, LinkedList	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
分割	*			Y
按分割排序	*			Y
按组排序	*	*		Y
分区	*	*	*	Y
分区映射	*	*	*	Y
分区映射引用	*	*	*	N
解包	*			Y

合并

方法 / 集合类型	Vec, VecDeque, LinkedList	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
扁平映射	*	*	*	Y
扁平映射引用	*	*	*	N
扁平化	*	*		Y
交错	*			Y
精确交错	*			Y
插入	*			Y
插入...	*			Y
连接	*			N
合并	*			Y
按合并排序	*			Y
连接	*			Y
填充	*			Y

排序

方法 / 集合类型	Vec, VecDeque, LinkedList	消耗
排序	*	Y
按排序排序	*	Y
按缓存键排序	*	Y
按键排序	*	Y
不稳定排序	*	Y
按排序排序	*	Y
按键排序	*	Y

转换

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
收集	*	*	*	*	N
collect_to	*	*	*	*	Y
into_bmap	*		*	*	Y
into_bset	*		*	*	Y
into_heap	*		*	*	Y
into_list	*		*	*	Y
into_map	*		*	*	Y
into_set	*		*	*	Y
into_vec	*	*	*	*	Y
into_deque	*		*	*	Y
到_bmap	*	*	*	*	N
到_bset	*	*	*	*	N
到_heap	*	*	*	*	N
到_keys				*	N
到_list	*	*	*	*	N
到_map	*	*	*	*	N
到_set	*	*	*	*	N
到_values				*	N
到_vec	*	*	*	*	N
到_deque	*	*	*	*	N

杂项

方法 / 集合类型	Vec, VecDeque, LinkedList	切片	HashSet, BTreeSet, BinaryHeap	HashMap, BTreeMap	消耗
填充	*				Y
用...	*		*	*	Y
遍历	*	*	*	*	N
重复	*
单元	*		*	*	Y

灵感来自

构建

需求

Rust 1.80+

设置

cargo install cargo-make

测试

makers build

基准

makers bench

贡献

请随时打开问题或拉取请求，提出问题、想法、功能、改进或修复。

许可证

根据您的选择，受以下许可证之一许可：

Apache 许可证 2.0 (LICENSE-APACHE或https://apache.ac.cn/licenses/LICENSE-2.0)
MIT 许可证 (LICENSE-MIT或https://open-source.org.cn/licenses/MIT)

。