前言
Rust 以其高性能、内存安全和先进的并发支持，在金融量化领域具有显著优势。它提供了接近 C/C++ 的执行速度，适合处理大规模数据集和高频交易。
此外，Rust 的生态系统包括用于数据科学、并行计算和 Web 服务开发的库，增强了其实用性。Rust 的泛型编程能力也促进了代码复用和高质量开发。
但是，目前为止市面上介绍 Rust 应用于金融量化领域的书籍寥寥无几，经转载授权，在这里引用某大佬的开源文档进行推广，同时相关链接置于本文末尾，欢迎 star 。
| 一级目录 | 二级目录 | 三级目录 |
|---|---|---|
| 6 变量和作用域 | 作用域和遮蔽 | |
| 不可变变量 | ||
| 可变变量 | ||
| 语句(Statements)，表达式(Expressions) 和 变量绑定(Variable Bindings) | 语句(Statements) | |
| 表达式(Expressions) | ||
| 7 类型系统 | 字面量 (Literals) | |
| 强类型系统 (Strong type system) | ||
| 类型转换 (Casting) | ||
| 自动类型推断(Inference) | ||
| 泛型 (Generic Type) | 案例：通用投资组合 | |
| 别名 (Alias) | ||
| 8 类型转换 | From 和 Into 特性 | |
| TryFrom 和 TryInto 特性 | ||
| ToString和FromStr | ||
| 9 流程控制 | if 条件语句 | |
| for 循环 (For Loops) | 范围 | |
| 迭代器 | ||
| 迭代器的诸种方法 | map方法 | |
| 案例：用map计算并映射x的平方 | ||
| 案例： 计算对数收益率 | ||
| filter 方法 | ||
| next方法 | ||
| fold 方法 | ||
| collect 方法 | ||
| while 循环 (While Loops) | ||
| loop循环 | ||
| if let 和 while let语法糖 | ||
| 并发迭代器 | ||
| 10 函数, 方法 和 闭包 | 函数进阶 | 泛型函数(Generic Functions) |
| 高阶函数(Higher-Order Functions) | ||
| 匿名函数(Anonymous Functions) | ||
| 案例：计算投资组合的预期收益和风险 | ||
| 补充学习：zip方法 | ||
| 闭包进阶 | ||
| 11 模块 | 案例：软件工程：组织金融产品模块 |
Chapter 6 - 变量和作用域
6.1 作用域和遮蔽
变量绑定有一个作用域(scope)，它被限定只在一个代码块(block)中生存(live)。 代码块是一个被 {} 包围的语句集合。另外也允许变量遮蔽。
fn main() {// 此绑定生存于 main 函数中let outer_binding = 1;// 这是一个代码块，比 main 函数拥有更小的作用域{// 此绑定只存在于本代码块let inner_binding = 2;println!("inner: {}", inner_binding);// 此绑定*遮蔽*了外面的绑定let outer_binding = 5_f32;println!("inner shadowed outer: {}", outer_binding);}// 代码块结束// 此绑定仍然在作用域内println!("outer: {}", outer_binding);// 此绑定同样*遮蔽*了前面的绑定let outer_binding = 'a';println!("outer shadowed outer: {}", outer_binding);}
执行结果：
inner: 2inner shadowed outer: 5outer: 1outer shadowed outer: a
6.2 不可变变量
在Rust中，你可以使用 mut 关键字来声明可变变量。可变变量与不可变变量相比，允许在绑定后修改它们的值。以下是一些常见的可变类型：
可变绑定(Mutable Bindings)：使用
let mut声明的变量是可变的。这意味着你可以在创建后修改它们的值。例如：let mut x = 5; // x是可变变量x = 10; // 可以修改x的值可变引用(Mutable References)：通过使用可变引用，你可以在不改变变量绑定的情况下修改值。可变引用使用
&mut声明。例如：fn main() {let mut x = 5;modify_value(&mut x); // 通过可变引用修改x的值println!("x: {}", x); // 输出 "x: 10"}fn modify_value(y: &mut i32) {*y = 10;}可变字段(Mutable Fields)：结构体和枚举可以包含可变字段，这些字段在结构体或枚举创建后可以修改。你可以使用
mut关键字来声明结构体或枚举的字段是可变的。例如：struct Point {x: i32,y: i32,}fn main() {let mut p = Point { x: 1, y: 2 };p.x = 10; // 可以修改Point结构体中的字段x的值}可变数组(Mutable Arrays)：使用
mut关键字声明的数组是可变的，允许修改数组中的元素。例如：fn main() {let mut arr = [1, 2, 3];arr[0] = 4; // 可以修改数组中的元素}可变字符串(Mutable Strings)：使用
String类型的变量和push_str、push等方法可以修改字符串的内容。例如：fn main() {let mut s = String::from("Hello");s.push_str(", world!"); // 可以修改字符串的内容}
这些是一些常见的可变类型示例。可变性是Rust的一个关键特性，它允许你在需要修改值时更改绑定，同时仍然提供了强大的安全性和借用检查。
6.3 可变变量
在Rust中，你可以使用 mut 关键字来声明可变变量。可变变量与不可变变量相比，允许在绑定后修改它们的值。以下是一些常见的可变类型：
可变绑定(Mutable Bindings)：使用
let mut声明的变量是可变的。这意味着你可以在创建后修改它们的值。例如：let mut x = 5; // x是可变变量x = 10; // 可以修改x的值可变引用(Mutable References)：通过使用可变引用，你可以在不改变变量绑定的情况下修改值。可变引用使用
&mut声明。例如：fn main() {let mut x = 5;modify_value(&mut x); // 通过可变引用修改x的值println!("x: {}", x); // 输出 "x: 10"}fn modify_value(y: &mut i32) {*y = 10;}可变字段(Mutable Fields)：结构体和枚举可以包含可变字段，这些字段在结构体或枚举创建后可以修改。你可以使用
mut关键字来声明结构体或枚举的字段是可变的。例如：struct Point {x: i32,y: i32,}fn main() {let mut p = Point { x: 1, y: 2 };p.x = 10; // 可以修改Point结构体中的字段x的值}可变数组(Mutable Arrays)：使用
mut关键字声明的数组是可变的，允许修改数组中的元素。例如：fn main() {let mut arr = [1, 2, 3];arr[0] = 4; // 可以修改数组中的元素}可变字符串(Mutable Strings)：使用
String类型的变量和push_str、push等方法可以修改字符串的内容。例如：fn main() {let mut s = String::from("Hello");s.push_str(", world!"); // 可以修改字符串的内容}
这些是一些常见的可变类型示例。可变性是Rust的一个关键特性，它允许你在需要修改值时更改绑定，同时仍然提供了强大的安全性和借用检查。
6.4 语句(Statements)，表达式(Expressions) 和 变量绑定(Variable Bindings)
6.4.1 语句(Statements)
Rust 有多种语句。在Rust中，下面的内容通常被视为语句：
变量声明语句，如 let x = 5;。赋值语句，如 x = 10;。函数调用语句，如 println!("Hello, world!");。控制流语句，如 if、else、while、for等。
fn main() {// 变量声明语句let x = 5;// 赋值语句let mut y = 10;y = y + x;// 函数调用语句println!("The value of y is: {}", y);// 控制流语句if y > 10 {println!("y is greater than 10");} else {println!("y is not greater than 10");}}
6.4.2 表达式(Expressions)
在Rust中，语句(Statements)和表达式(Expressions)有一些重要的区别：
返回值：
语句没有返回值。它们执行某些操作或赋值，但不产生值本身。例如，赋值语句 let x = 5;不返回任何值。表达式总是有返回值。每个表达式都会计算出一个值，并可以被用于其他表达式或赋值给变量。例如， 5 + 3表达式返回值8。
可嵌套性：
语句可以包含表达式，但不能嵌套其他语句。例如， let x = { 5 + 3; };在代码块中包含了一个表达式，但代码块本身是一个语句。表达式可以包含其他表达式，形成复杂的表达式树。例如， let y = 5 + (3 * (2 - 1));中的表达式包含了嵌套的子表达式。
使用场景：
语句通常用于执行某些操作，如声明变量、赋值、执行函数调用等。它们不是为了返回值而存在的。 表达式通常用于计算值，这些值可以被用于赋值、函数调用的参数、条件语句的判断条件等。它们总是有返回值。
分号：
语句通常以分号 ;结尾，表示语句的结束。表达式也可以以分号 ;结尾，但这样做通常会忽略表达式的结果。如果省略分号，表达式的值将被返回。
下面是一些示例来说明语句和表达式之间的区别：
// 这是一个语句，它没有返回值let x = 5;// 这是一个表达式，它的值为 8let y = 5 + 3;// 这是一个语句块，其中包含了两个语句，但没有返回值{let a = 1;let b = 2;}// 这是一个表达式，其值为 6，这个值可以被赋给变量或用于其他表达式中let z = {let a = 2;let b = 3;a + b // 注意，没有分号，所以这是一个表达式};
再来看一下，如果给表达式强制以分号 ; 结尾的效果。
fn main() {//变量绑定， 创建一个无符号整数变量 `x`let x = 5u32;// 创建一个新的变量 `y` 并初始化它let y = {// 创建 `x` 的平方let x_squared = x * x;// 创建 `x` 的立方let x_cube = x_squared * x;// 计算 `x_cube + x_squared + x` 并将结果赋给 `y`x_cube + x_squared + x};// 代码块也是表达式，所以它们可以用作赋值中的值。// 这里的代码块的最后一个表达式是 `2 * x`，但由于有分号结束了这个代码块，所以将 `()` 赋给 `z`let z = {2 * x;};// 打印变量的值println!("x is {:?}", x);println!("y is {:?}", y);println!("z is {:?}", z);}
返回的是
x is 5y is 155z is ()
总之，语句用于执行操作，而表达式用于计算值。理解这两者之间的区别对于编写Rust代码非常重要。
Chapter 7 - 类型系统
在量化金融领域，Rust 的类型系统具有出色的表现，它强调了类型安全、性能和灵活性，这使得 Rust 成为一个理想的编程语言来处理金融数据和算法交易。以下是一个详细介绍 Rust 类型系统的案例，涵盖了如何在金融领域中利用其特性：
7.1 字面量 (Literals)
对数值字面量，只要把类型作为后缀加上去，就完成了类型说明。比如指定字面量 42 的类型是 i32，只需要写 42i32。
无后缀的数值字面量，其类型取决于怎样使用它们。如果没有限制，编译器会对整数使用 i32，对浮点数使用 f64。
fn main() {let a = 3f32;let b = 1;let c = 1.0;let d = 2u32;let e = 1u8;println!("size of `a` in bytes: {}", std::mem::size_of_val(&a));println!("size of `b` in bytes: {}", std::mem::size_of_val(&b));println!("size of `c` in bytes: {}", std::mem::size_of_val(&c));println!("size of `d` in bytes: {}", std::mem::size_of_val(&d));println!("size of `e` in bytes: {}", std::mem::size_of_val(&e));}
执行结果:
size of `a` in bytes: 4size of `b` in bytes: 4size of `c` in bytes: 8size of `d` in bytes: 4size of `e` in bytes: 1
PS: 上面的代码使用了一些还没有讨论过的概念。
std::mem::size_of_val 是 Rust 标准库中的一个函数，用于获取一个值(变量或表达式)所占用的字节数。具体来说，它返回一个值的大小(以字节为单位)，即该值在内存中所占用的空间大小。
std::mem::size_of_val的调用方式使用了完整路径(full path)。在 Rust 中，代码可以被组织成称为模块(module)的逻辑单元，而模块可以嵌套在其他模块内。在这个示例中：
size_of_val函数是在名为mem的模块中定义的。mem模块又是在名为std的 crate 中定义的。
让我们详细解释这些概念：
Crate：在 Rust 中，crate 是最高级别的代码组织单元，可以看作是一个库或一个包。Rust 的标准库(Standard Library)也是一个 crate，通常被引用为
std。模块：模块是用于组织和封装代码的逻辑单元。模块可以包含函数、结构体、枚举、常量等。在示例中，
stdcrate 包含了一个名为mem的模块，而mem模块包含了size_of_val函数。完整路径：在 Rust 中，如果要调用一个函数、访问一个模块中的变量等，可以使用完整路径来指定它们的位置。完整路径包括 crate 名称、模块名称、函数名称等，用于明确指定要使用的项。在示例中，
std::mem::size_of_val使用了完整路径，以确保编译器能够找到正确的函数。
所以，std::mem::size_of_val 的意思是从标准库 crate(std)中的 mem 模块中调用 size_of_val函数。这种方式有助于防止命名冲突和确保代码的可读性和可维护性，因为它明确指定了要使用的函数的来源。
7.2 强类型系统 (Strong type system)
Rust 的类型系统是强类型的，这意味着每个变量都必须具有明确定义的类型，并且在编译时会严格检查类型的一致性。这一特性在金融计算中尤为重要，因为它有助于防止可能导致严重错误的类型不匹配问题。
举例来说，考虑以下代码片段：
let price: f64 = 150.0; // 价格是一个浮点数let quantity: i32 = 100; // 数量是一个整数let total_value = price * quantity; // 编译错误，不能将浮点数与整数相乘
在这个示例中，我们明确指定了 price 是一个浮点数，而 quantity 是一个整数。当我们尝试将它们相乘时，Rust 在编译时就会立即捕获到类型不匹配的错误。这种类型检查的严格性有助于避免金融计算中常见的错误，例如将不同类型的数据混淆或错误地进行数学运算。因此，Rust 的强类型系统提供了额外的安全性层，确保金融应用程序在编译时捕获潜在的问题，从而减少了在运行时出现错误的风险。
在 Rust 的强类型系统中，类型之间的转换通常需要显式进行，以确保类型安全。
7.3 类型转换 (Casting)
Rust 不支持原生类型之间的隐式类型转换(coercion)，但允许通过 as 关键字进行明确的类型转换(casting)。
as 运算符：可以使用
as运算符执行类型转换，但是只能用于数值之间的转换。例如，将整数转换为浮点数或将浮点数转换为整数。let integer_num: i32 = 42;let float_num: f64 = integer_num as f64;let float_value: f64 = 3.14;let integer_value: i32 = float_value as i32;需要注意的是，使用
as进行类型转换可能会导致数据丢失或不确定行为，因此要谨慎使用。在程序设计之初，最好就能规划好变量数据的类型。From 和 Into trait：
在量化金融领域，
From和Intotrait 可以用来实现自定义类型之间的转换，以便在处理金融数据和算法时更方便地操作不同的数据类型。下面让我们使用一个简单的例子来说明这两个 trait 在量化金融中的应用。假设我们有两种不同的金融工具类型：
Stock(股票)和Option(期权)。我们希望能够在这两种类型之间进行转换，以便在金融算法中更灵活地处理它们。首先，我们可以定义这两种类型的结构体：
struct Stock {symbol: String,price: f64,}struct Option {symbol: String,strike_price: f64,expiration_date: String,}现在，让我们使用
From和Intotrait 来实现类型之间的转换。从 Stock 到 Option 的转换：
假设我们希望从一个股票创建一个对应的期权。我们可以实现
Fromtrait 来定义如何从Stock转换为Option：impl From<Stock> for Option {fn from(stock: Stock) -> Self {Option {symbol: stock.symbol,strike_price: stock.price * 1.1, // 假设期权的行权价是股票价格的110%expiration_date: String::from("2023-12-31"), // 假设期权到期日期}}}现在，我们可以这样进行转换：
let stock = Stock {symbol: String::from("AAPL"),price: 150.0,};let option: Option = stock.into(); // 使用 Into trait 进行转换从 Option 到 Stock 的转换：
如果我们希望从一个期权创建一个对应的股票，我们可以实现相反方向的转换，使用
Fromtrait 或Intotrait 的逆操作。impl From<Option> for Stock {fn from(option: Option) -> Self {Stock {symbol: option.symbol,price: option.strike_price / 1.1, // 假设期权的行权价是股票价格的110%}}}或者，我们可以使用
Intotrait 进行相反方向的转换：let option = Option {symbol: String::from("AAPL"),strike_price: 165.0,expiration_date: String::from("2023-12-31"),};let stock: Stock = option.into(); // 使用 Into trait 进行转换通过实现
From和Intotrait，我们可以自定义类型之间的转换逻辑，使得在量化金融算法中更容易地处理不同的金融工具类型，提高了代码的灵活性和可维护性。这有助于简化金融数据处理的代码，并使其更具可读性。
7.4 自动类型推断(Inference)
在Rust中，类型推断引擎非常强大，它不仅在初始化变量时考虑右值(r-value)的类型，还会分析变量之后的使用情况，以便更准确地推断类型。以下是一个更复杂的类型推断示例，我们将详细说明它的工作原理。
fn main() {let mut x = 5; // 变量 x 被初始化为整数 5x = 10; // 现在，将 x 更新为整数 10println!("x = {}", x);}
在这个示例中，我们首先声明了一个变量 x，并将其初始化为整数5。然后，我们将 x 的值更改为整数10，并最后打印出 x 的值。
Rust的类型推断引擎如何工作：
变量初始化：当我们声明 x并将其初始化为5时，Rust的类型推断引擎会根据右值的类型(这里是整数5)推断出x的类型为整数(i32)。赋值操作：当我们执行 x = 10;这行代码时，Rust不仅检查右值(整数10)的类型，还会考虑左值(变量x)的类型。它发现x已经被推断为整数(i32)，所以它知道我们尝试将一个整数赋给x，并且这是合法的。打印：最后，我们使用 println!宏打印x的值。Rust仍然知道x的类型是整数，因此它可以正确地将其格式化为字符串并打印出来。
7.5 泛型 (Generic Type)
在Rust中，泛型(Generics)允许你编写可以处理多种数据类型的通用代码，这对于金融领域的金融工具尤其有用。你可以编写通用函数或数据结构，以处理不同类型的金融工具(即金融工具的各种数据类型)，而不必为每种类型都编写重复的代码。
以下是一个简单的示例，演示如何使用Rust的泛型来处理不同类型的金融工具：
struct FinancialInstrument<T> {symbol: String,value: T,}impl<T> FinancialInstrument<T> {fn new(symbol: &str, value: T) -> Self {FinancialInstrument {symbol: String::from(symbol),value,}}fn get_value(&self) -> &T {&self.value}}fn main() {let stock = FinancialInstrument::new("AAPL", "150.0"); // 引发混淆，value的类型应该是数字let option = FinancialInstrument::new("AAPL Call", true); // 引发混淆，value的类型应该是数字或金额println!("Stock value: {}", stock.get_value()); // 这里应该处理数字，但现在是字符串println!("Option value: {}", option.get_value()); // 这里应该处理数字或金额，但现在是布尔值}
执行结果:
Stock value: 150.0Option value: true
在这个示例中，我们定义了一个泛型结构体 FinancialInstrument<T>，它可以存储不同类型的金融工具的值。无论是股票还是期权，我们都可以使用相同的代码来创建和访问它们的值。
在 main 函数中，我们创建了一个股票(stock)和一个期权(option)，它们都使用了相同的泛型结构体 FinancialInstrument<T>。然后，我们使用 get_value 方法来访问它们的值，并打印出来。
但是,
在实际操作层面,这是一个非常好的反例,应该尽量避免,因为使用泛型把不同的金融工具归纳为FinancialInstrument, 会造成不必要的混淆。
在实际应用中使用泛型时需要考虑的建议：
合理使用泛型：只有在需要处理多种数据类型的情况下才使用泛型。如果只有一种或少数几种数据类型，那么可能不需要泛型，可以直接使用具体类型。 提供有意义的类型参数名称：为泛型参数选择有意义的名称，以便其他开发人员能够理解代码的含义。避免使用过于抽象的名称。 文档和注释：为使用泛型的代码提供清晰的文档和注释，解释泛型参数的作用和预期的数据类型。这有助于其他开发人员更容易理解代码。 测试和验证：确保使用泛型的代码经过充分的测试和验证，以确保其正确性和性能。泛型代码可能会引入更多的复杂性，因此需要额外的关注。 避免过度抽象：避免在不必要的地方使用泛型。如果一个特定的实现对于某个特定问题更加清晰和高效，不要强行使用泛型。
案例： 通用投资组合
承接上文，让我们看一个更合适的案例，其中泛型用于处理更具体的问题。考虑一个投资组合管理系统，其中有不同类型的资产(股票、债券、期权等)。我们可以使用泛型来实现一个通用的投资组合结构，但同时保留每种资产的具体类型：
// 定义一个泛型的资产结构#[derive(Debug)]struct Asset<T> {name: String,asset_type: T,// 这里可以包含资产的其他属性}// 定义不同类型的资产#[derive(Debug)]enum AssetType {Stock,Bond,Option,// 可以添加更多类型}// 示例资产类型之一：股票#[allow(dead_code)]#[derive(Debug)]struct Stock {ticker: String,price: f64,// 其他股票相关属性}// 示例资产类型之一：债券#[allow(dead_code)]#[derive(Debug)]struct Bond {issuer: String,face_value: f64,// 其他债券相关属性}// 示例资产类型之一：期权#[allow(dead_code)]#[derive(Debug)]struct Option {underlying_asset: String,strike_price: f64,// 其他期权相关属性}fn main() {// 创建不同类型的资产实例let stock = Asset {name: "Apple Inc.".to_string(),asset_type: AssetType::Stock,};let bond = Asset {name: "US Treasury Bond".to_string(),asset_type: AssetType::Bond,};let option = Asset {name: "Call Option on Google".to_string(),asset_type: AssetType::Option,};// 打印不同类型的资产println!("Asset 1: {} ({:?})", stock.name, stock.asset_type);println!("Asset 2: {} ({:?})", bond.name, bond.asset_type);println!("Asset 3: {} ({:?})", option.name, option.asset_type);}
在这个示例中，我们定义了一个泛型结构体 Asset<T> 代表投资组合中的资产。这个泛型结构体使用了泛型参数 T，以保持投资组合的多样和灵活性——因为我们可以通过 trait 和具体的资产类型(比如 Stock、Option 等)来确保每种资产都有自己独特的属性和行为。
7.6 别名 (Alias)
在很多编程语言中，包括像Rust、TypeScript和Python等，都提供了一种机制来给已有的类型取一个新的名字，这通常被称为"类型别名"或"类型重命名"。这可以增加代码的可读性和可维护性，尤其在处理复杂的类型时很有用。Rust的类型系统可以非常强大和灵活。
让我们再次演示一个量化金融领域的案例，这次类型别名是主角。这个示例将使用类型别名来表示不同的金融数据， 如价格、交易量、日期等。
// 定义一个类型别名，表示价格type Price = f64;// 定义一个类型别名，表示交易量type Volume = u32;// 定义一个类型别名，表示日期type Date = String;// 定义一个结构体，表示股票数据struct StockData {symbol: String,date: Date,price: Price,volume: Volume,}// 定义一个结构体，表示债券数据struct BondData {name: String,date: Date,price: Price,}fn main() {// 创建股票数据let apple_stock = StockData {symbol: String::from("AAPL"),date: String::from("2023-09-13"),price: 150.0,volume: 10000,};// 创建债券数据let us_treasury_bond = BondData {name: String::from("US Treasury Bond"),date: String::from("2023-09-13"),price: 1000.0,};// 输出股票数据和债券数据println!("Stock Data:");println!("Symbol: {}", apple_stock.symbol);println!("Date: {}", apple_stock.date);println!("Price: ${}", apple_stock.price);println!("Volume: {}", apple_stock.volume);println!("");println!("Bond Data:");println!("Name: {}", us_treasury_bond.name);println!("Date: {}", us_treasury_bond.date);println!("Price: ${}", us_treasury_bond.price);}
执行结果：
Stock Data:Symbol: AAPLDate: 2023-09-13Price: $150Volume: 10000Bond Data:Name: US Treasury BondDate: 2023-09-13Price: $1000
Chapter 8 - 类型转换
8.1 From 和 Into 特性
在7.3我们已经讲过通过From和Into Traits 来实现类型转换，现在我们来详细解释以下它的基础。
From 和 Into 是一种相关但略有不同的 trait，它们通常一起使用以提供类型之间的双向转换。这两个 trait 的关系如下：
FromTrait：它定义了如何从一个类型创建另一个类型的值。通常，你会为需要自定义类型转换的情况实现Fromtrait。例如，你可以实现From<i32>来定义如何从i32转换为你自定义的类型。IntoTrait：它是From的反向操作。Intotrait 允许你定义如何将一个类型转换为另一个类型。当你实现了Fromtrait 时，Rust 会自动为你提供Intotrait 的实现，因此你无需显式地为类型的反向转换实现Into。
实际上，这两个 trait 通常是一体的，因为它们是相互关联的。如果你实现了 From，就可以使用 into() 方法来进行类型转换，而如果你实现了 Into，也可以使用 from() 方法来进行类型转换。这使得代码更具灵活性和可读性。
标准库中具有 From 特性实现的类型有很多，以下是一些例子：
&str 到 String: 可以使用
String::from()方法将字符串切片(&str)转换为String：let my_str = "hello";let my_string = String::from(my_str);&String 到 &str:
String类型可以通过引用转换为字符串切片：let my_string = String::from("hello");let my_str: &str = &my_string;数字类型之间的转换: 例如，可以将整数类型转换为浮点数类型，或者反之：
let int_num = 42;let float_num = f64::from(int_num);字符到字符串: 字符类型可以使用
to_string()方法转换为字符串：let my_char = 'a';let my_string = my_char.to_string();Vec 到 Boxed Slice: 可以使用
Vec::into_boxed_slice()将Vec转换为堆分配的切片(Box<[T]>)：let my_vec = vec![1, 2, 3];let boxed_slice: Box<[i32]> = my_vec.into_boxed_slice();
这些都是标准库中常见的 From 实现的示例，它们使得不同类型之间的转换更加灵活和方便。要记住，From 特性是一种用于定义类型之间转换规则的强大工具。
8.2 TryFrom 和 TryInto 特性
与 From 和 Into 类似，TryFrom 和 TryInto 是用于类型转换的通用 traits。不同之处在于，TryFrom 和 TryInto 主要用于可能会 导致错误 的转换，因此它们的返回类型也是 Result。
当使用量化金融案例时，可以考虑如何处理不同金融工具的价格或指标之间的转换，例如将股票价格转换为对数收益率。以下是一个示例：
use std::convert::{TryFrom, TryInto};// 我们来自己建立一个自定义的错误类型 ConversionError , 用来汇报类型转换出错#[derive(Debug)]struct ConversionError;// 定义一个结构体表示股票价格struct StockPrice {price: f64,}// 实现 TryFrom 来尝试将股票价格转换为对数收益率，可能失败impl TryFrom<StockPrice> for f64 {type Error = ConversionError;fn try_from(stock_price: StockPrice) -> Result<Self, Self::Error> {if stock_price.price > 0.0 {Ok(stock_price.price.ln()) // 计算对数收益率} else {Err(ConversionError)}}}fn main() {// 尝试使用 TryFrom 进行类型转换let valid_price = StockPrice { price: 50.0 };let result: Result<f64, ConversionError> = valid_price.try_into();println!("{:?}", result); // 打印对数收益率let invalid_price = StockPrice { price: -10.0 };let result: Result<f64, ConversionError> = invalid_price.try_into();println!("{:?}", result); // 打印错误信息}
在这个示例中，我们定义了一个 StockPrice 结构体来表示股票价格，然后使用 TryFrom 实现了从 StockPrice 到 f64 的类型转换，其中 f64 表示对数收益率。
自然对数(英语：Natural logarithm)为以数学常数e为底数的对数函数，我们知道它的定义域是**(0, +∞)**，也就是取值是要大于0的。如果股票价格小于等于0，转换会产生错误。在 main 函数中，我们演示了如何使用 TryFrom 进行类型转换，并在可能失败的情况下获取 Result 类型的结果。这个示例展示了如何在量化金融中处理不同类型之间的转换。
8.3 ToString和FromStr
这两个 trait 是用于类型转换和解析字符串的常用方法。让我给你解释一下它们的作用和在量化金融领域中的一个例子。
首先，ToString trait 是用于将类型转换为字符串的 trait。它是一个通用 trait，可以为任何类型实现。通过实现ToString trait，类型可以使用to_string()方法将自己转换为字符串。例如，如果有一个表示价格的自定义结构体，可以实现ToString trait以便将其价格转换为字符串形式。
struct Price {currency: String,value: f64,}impl ToString for Price {fn to_string(&self) -> String {format!("{} {}", self.value, self.currency)}}fn main() {let price = Price {currency: String::from("USD"),value: 10.99,};let price_string = price.to_string();println!("Price: {}", price_string); // 输出: "Price: 10.99 USD"}
接下来，FromStr trait 是用于从字符串解析出指定类型的 trait。它也是通用 trait，可以为任何类型实现。通过实现FromStr trait，类型可以使用from_str()方法从字符串中解析出自身。
例如，在金融领域中，如果有一个表示股票价格的类型，可以实现FromStr trait以便从字符串解析出股票价格。
use std::str::FromStr;// 自定义结构体，表示股票价格struct StockPrice {ticker_symbol: String,price: f64,}// 实现ToString trait，将StockPrice转换为字符串impl ToString for StockPrice {// 将StockPrice结构体转换为字符串fn to_string(&self) -> String {format!("{}:{}", self.ticker_symbol, self.price)}}// 实现FromStr trait，从字符串解析出StockPriceimpl FromStr for StockPrice {type Err = ();// 从字符串解析StockPricefn from_str(s: &str) -> Result<Self, Self::Err> {// 将字符串s根据冒号分隔成两个部分let components: Vec<&str> = s.split(':').collect();// 如果字符串不由两部分组成，那一定是发生错误了，返回错误if components.len() != 2 {return Err(());}// 解析第一个部分为股票代码let ticker_symbol = String::from(components[0]);// 解析第二个部分为价格// 这里使用unwrap()用于简化示例，实际应用中可能需要更完备的错误处理let price = components[1].parse::<f64>().unwrap();// 返回解析后的StockPriceOk(StockPrice {ticker_symbol,price,})}}fn main() {let price_string = "AAPL:150.64";// 使用from_str()方法从字符串解析出StockPricelet stock_price = StockPrice::from_str(price_string).unwrap();// 输出解析得到的StockPrice字段println!("Ticker Symbol: {}", stock_price.ticker_symbol); // 输出: "AAPL"println!("Price: {}", stock_price.price); // 输出: "150.64"// 使用to_string()方法将StockPrice转换为字符串let price_string_again = stock_price.to_string();// 输出转换后的字符串println!("Price String: {}", price_string_again); // 输出: "AAPL:150.64"}
执行结果：
Ticker Symbol: AAPL # from_str方法解析出来的股票代码信息Price: 150.64 # from_str方法解析出来的价格信息Price String: AAPL:150.64 # 和"let price_string = "AAPL:150.64";"又对上了
Chapter 9 - 流程控制
9.1 if 条件语句
在Rust中，if 语句用于条件控制，允许根据条件的真假来执行不同的代码块。Rust的if语句有一些特点和语法细节，以下是对Rust的if语句的介绍：
基本语法：
if condition {// 如果条件为真(true)，执行这里的代码块} else {// 如果条件为假(false)，执行这里的代码块(可选)}condition是一个布尔表达式，根据其结果，决定执行哪个代码块。else部分是可选的，你可以选择不包括它。多条件的
if语句：你可以使用
else if来添加多个条件分支，例如：if condition1 {// 条件1为真时执行} else if condition2 {// 条件1为假，条件2为真时执行} else {// 所有条件都为假时执行}这允许你在多个条件之间进行选择。
表达式返回值：
在Rust中，
if语句是一个表达式，意味着它可以返回一个值。这使得你可以将if语句的结果赋值给一个变量，如下所示：let result = if condition { 1 } else { 0 };这里，
result的值将根据条件的真假来赋值为1或0。注意并不是布尔值。模式匹配：
你还可以使用
if语句进行模式匹配，而不仅仅是布尔条件。例如，你可以匹配枚举类型或其他自定义类型的值。enum Status {Success,Error,}let status = Status::Success;if let Status::Success = status {// 匹配成功} else {// 匹配失败}
总的来说，Rust的if语句提供了强大的条件控制功能，同时具有表达式和模式匹配的特性，使得它在处理不同类型的条件和场景时非常灵活和可读。
现在我们来简单应用一下if语句，顺便预习for语句：
fn main() {// 初始化投资组合的风险分数let portfolio_risk_scores = vec![0.8, 0.6, 0.9, 0.5, 0.7];let risk_threshold = 0.7; // 风险分数的阈值// 计算高风险资产的数量let mut high_risk_assets = 0;for &risk_score in portfolio_risk_scores.iter() {// 使用 if 条件语句判断风险分数是否超过阈值if risk_score > risk_threshold {high_risk_assets += 1;}}// 基于高风险资产数量输出不同的信息if high_risk_assets == 0 {println!("投资组合风险水平低，没有高风险资产。");} else if high_risk_assets <= 2 {println!("投资组合风险水平中等，有少量高风险资产。");} else {println!("投资组合风险水平较高，有多个高风险资产。");}}
执行结果：
投资组合风险水平中等，有少量高风险资产。9.2 for 循环 (For Loops)
Rust 是一种系统级编程语言，它具有强大的内存安全性和并发性能。在 Rust 中，使用 for 循环来迭代集合(如数组、向量、切片等)中的元素或者执行某个操作一定次数。下面是 Rust 中 for 循环的基本语法和一些示例：
9.2.1 范围
你还可以使用 for 循环来执行某个操作一定次数，可以使用 .. 运算符创建一个范围，并在循环中使用它：
fn main() {for i in 1..=5 {println!("Iteration: {}", i);}}
上述示例将打印数字 1 到 5，包括 5。范围使用 1..=5 表示，包括起始值 1 和结束值 5。
9.2.2 迭代器
在 Rust 中，使用 for 循环来迭代集合(例如数组或向量)中的元素非常简单。下面是一个示例，演示如何迭代一个整数数组中的元素：
fn main() {let numbers = [1, 2, 3, 4, 5];for number in numbers.iter() {println!("Number: {}", number);}}
在这个示例中，numbers.iter() 返回一个迭代器，通过 for 循环迭代器中的元素并打印每个元素的值。
9.3 迭代器的诸种方法
除了使用 for 循环，你还可以使用 Rust 的迭代器方法来处理集合中的元素。这些方法包括 map、filter、fold 等，它们允许你进行更复杂的操作。
9.3.1 map方法
在Rust中，map方法是用于迭代和转换集合元素的常见方法之一。map方法接受一个闭包(或函数)，并将其应用于集合中的每个元素，然后返回一个新的集合，其中包含了应用了闭包后的结果。这个方法通常用于对集合中的每个元素执行某种操作，然后生成一个新的集合，而不会修改原始集合。
案例1 用map计算并映射x的平方
fn main() {// 创建一个包含一些数字的向量let numbers = vec![1, 2, 3, 4, 5];// 使用map方法对向量中的每个元素进行平方操作，并创建一个新的向量let squared_numbers: Vec<i32> = numbers.iter().map(|&x| x * x).collect();// 输出新的向量println!("{:?}", squared_numbers);}
在这个例子中，我们首先创建了一个包含一些整数的向量numbers。然后，我们使用map方法对numbers中的每个元素执行了平方操作，这个操作由闭包|&x| x * x定义。最后，我们使用collect方法将结果收集到一个新的向量squared_numbers 中，并打印出来。
案例2 计算对数收益率
fn main() {// 创建一个包含股票价格的向量let stock_prices = vec![100.0, 105.0, 110.0, 115.0, 120.0];// 使用map方法计算每个价格的对数收益率，并创建一个新的向量let log_returns: Vec<f64> = stock_prices.iter().map(|&price| price / 100.0f64.ln()).collect();// 输出对数收益率println!("{:?}", log_returns);}
执行结果：
[21.71472409516259, 22.80046029992072, 23.88619650467885, 24.971932709436977, 26.05766891419511]在上述示例中，我们使用了 map 方法将原始向量中的每个元素都乘以 2，然后使用 collect 方法将结果收集到一个新的向量中。
9.3.2 filter 方法
filter方法是一个在金融数据分析中常用的方法，它用于筛选出符合特定条件的元素并返回一个新的迭代器。这个方法需要传入一个闭包作为参数，该闭包接受一个元素的引用并返回一个布尔值，用于判断该元素是否应该被包含在结果迭代器中。
在金融分析中，我们通常需要筛选出符合某些条件的数据进行处理，例如筛选出大于某个阈值的股票或者小于某个阈值的交易。filter方法可以帮助我们方便地实现这个功能。
下面是一个使用filter方法筛选出大于某个阈值的交易的例子：
// 定义一个Trade结构体#[derive(Debug, PartialEq)]struct Trade {price: f64,volume: i32,}fn main() {let trades = vec![Trade { price: 10.0, volume: 100 },Trade { price: 20.0, volume: 200 },Trade { price: 30.0, volume: 300 },];let threshold = 25.0;let mut filtered_trades = trades.iter().filter(|trade| trade.price > threshold);match filtered_trades.next() {Some(&Trade { price: 30.0, volume: 300 }) => println!("第一个交易正确"),_ => println!("第一个交易不正确"),}match filtered_trades.next() {None => println!("没有更多的交易"),_ => println!("还有更多的交易"),}}
执行结果：
第一个交易正确没有更多的交易
在这个例子中，我们有一个包含多个交易的向量，每个交易都有一个价格和交易量。我们想要筛选出价格大于25.0的交易。我们使用filter方法传入一个闭包来实现这个筛选。闭包接受一个Trade的引用并返回该交易的价格是否大于阈值。最终，我们得到一个只包含符合条件的交易的迭代器。
9.3.2 next方法
在金融领域，一个常见的用例是处理时间序列数据。假设我们有一个包含股票价格的时间序列数据集，我们想要找出大于给定阈值的下一个价格。我们可以使用Rust中的next方法来实现这个功能。
首先，我们需要定义一个结构体来表示时间序列数据。假设我们的数据存储在一个Vec<f64>中，其中每个元素代表一个时间点的股票价格。我们可以创建一个名为TimeSeries的结构体，并实现Iterator trait来使其可迭代。
pub struct TimeSeries {data: Vec<f64>,index: usize,}impl TimeSeries {pub fn new(data: Vec<f64>) -> Self {Self { data, index: 0 }}}impl Iterator for TimeSeries {type Item = f64;fn next(&mut self) -> Option<Self::Item> {if self.index < self.data.len() {let value = self.data[self.index];self.index += 1;Some(value)} else {None}}}
接下来，我们可以创建一个函数来找到大于给定阈值的下一个价格。我们可以使用filter方法和next方法来遍历时间序列数据，并找到第一个大于阈值的价格。
pub fn find_next_threshold(time_series: &mut TimeSeries, threshold: f64) -> Option<f64> {time_series.filter(|&price| price > threshold).next()}
现在，我们可以使用这个函数来查找时间序列数据中大于给定阈值的下一个价格。以下是一个示例：
fn main() {let data = vec![10.0, 20.0, 30.0, 40.0, 50.0];let mut time_series = TimeSeries::new(data);let threshold = 35.0;match find_next_threshold(&mut time_series, threshold) {Some(price) => println!("下一个大于{}的价格是{}", threshold, price),None => println!("没有找到大于{}的价格", threshold),}}
在这个示例中，我们创建了一个包含股票价格的时间序列数据，并使用find_next_threshold函数找到大于35.0的下一个价格。输出将会是"下一个大于35的价格是40"。如果没有找到大于阈值的价格，输出将会是"没有找到大于35的价格"。
9.3.4 fold 方法
fold 是 Rust 标准库中 Iterator trait 提供的一个重要方法之一。它用于在迭代器中累积值，将一个初始值和一个闭包函数应用于迭代器的每个元素，并返回最终的累积结果。fold 方法的签名如下：
fn fold<B, F>(self, init: B, f: F) -> BwhereF: FnMut(B, Self::Item) -> B,
self是迭代器本身。init是一个初始值，用于累积操作的初始状态。f是一个闭包函数，它接受两个参数：累积值（初始值或上一次迭代的结果）和迭代器的下一个元素，然后返回新的累积值。
fold 方法的执行过程如下：
使用初始值 init初始化累积值。对于迭代器的每个元素，调用闭包函数 f，传递当前累积值和迭代器的元素。将闭包函数的返回值更新为新的累积值。 重复步骤 2 和 3，直到迭代器中的所有元素都被处理。 返回最终的累积值。
现在，让我们通过一个金融案例来演示 fold 方法的使用。假设我们有一组金融交易记录，每个记录包含交易类型（存款或提款）和金额。我们想要计算总存款和总提款的差值，以查看账户的余额。
struct Transaction {transaction_type: &'static str,amount: f64,}fn main() {let transactions = vec![Transaction { transaction_type: "Deposit", amount: 100.0 },Transaction { transaction_type: "Withdrawal", amount: 50.0 },Transaction { transaction_type: "Deposit", amount: 200.0 },Transaction { transaction_type: "Withdrawal", amount: 75.0 },];let initial_balance = 0.0; // 初始余额为零let balance = transactions.iter().fold(initial_balance, |acc, transaction| {match transaction.transaction_type {"Deposit" => acc + transaction.amount,"Withdrawal" => acc - transaction.amount,_ => acc,}});println!("Account Balance: ${:.2}", balance);}
在这个示例中，我们首先定义了一个 Transaction 结构体来表示交易记录，包括交易类型和金额。然后，我们创建了一个包含多个交易记录的 transactions 向量。我们使用 fold 方法来计算总存款和总提款的差值，以获取账户的余额。
在 fold 方法的闭包函数中，我们根据交易类型来更新累积值 acc。如果交易类型是 "Deposit"，我们将金额添加到余额上，如果是 "Withdrawal"，则将金额从余额中减去。最终，我们打印出账户余额。
9.3.5 collect 方法
collect 是 Rust 中用于将迭代器的元素收集到一个集合（collection）中的方法。它是 Iteratortrait 提供的一个重要方法。collect 方法的签名如下：
fn collect<B>(self) -> BwhereB: FromIterator<Self::Item>,
self是迭代器本身。B是要收集到的集合类型，它必须实现FromIteratortrait，这意味着可以从迭代器的元素类型构建该集合类型。collect方法将迭代器中的元素转换为集合B并返回。
collect 方法的工作原理如下：
创建一个空的集合 B，这个集合将用于存储迭代器中的元素。对于迭代器的每个元素，将元素添加到集合 B中。返回集合 B。
现在，让我们通过一个金融案例来演示 collect 方法的使用。假设我们有一组金融交易记录，每个记录包含交易类型（存款或提款）和金额。我们想要将所有存款记录收集到一个向量中，以进一步分析。
struct Transaction {transaction_type: &'static str,amount: f64,}fn main() {let transactions = vec![Transaction { transaction_type: "Deposit", amount: 100.0 },Transaction { transaction_type: "Withdrawal", amount: 50.0 },Transaction { transaction_type: "Deposit", amount: 200.0 },Transaction { transaction_type: "Withdrawal", amount: 75.0 },];// 使用 collect 方法将存款记录收集到一个向量中let deposits: Vec<Transaction> = transactions.iter().filter(|&transaction| transaction.transaction_type == "Deposit").cloned().collect();println!("Deposit Transactions: {:?}", deposits);}
在这个示例中，我们首先定义了一个 Transaction 结构体来表示交易记录，包括交易类型和金额。然后，我们创建了一个包含多个交易记录的 transactions 向量。
接下来，我们使用 collect 方法来将所有存款记录收集到一个新的 Vec<Transaction> 向量中。我们首先使用 iter() 方法将 transactions 向量转换为迭代器，然后使用 filter 方法筛选出交易类型为 "Deposit" 的记录。接着，我们使用 cloned() 方法来克隆这些记录，以便将它们收集到新的向量中。
最后，我们打印出包含所有存款记录的向量。这样，我们就成功地使用 collect 方法将特定类型的交易记录收集到一个集合中，以便进一步分析或处理。
9.4 while 循环 (While Loops)
while 循环是一种在 Rust 中用于重复执行代码块直到条件不再满足的控制结构。它的执行方式是在每次循环迭代之前检查一个条件表达式，只要条件为真，循环就会继续执行。一旦条件为假，循环将终止，控制流将跳出循环。
以下是 while 循环的一般形式：
while condition {// 循环体代码}
condition是一个布尔表达式，它用于检查循环是否应该继续执行。只要condition为真，循环体中的代码将被执行。循环体包含要重复执行的代码，通常会改变某些状态以最终使得 condition为假，从而退出循环。
下面是一个使用 while 循环的示例，演示了如何计算存款和提款的总和，直到交易记录列表为空：
struct Transaction {transaction_type: &'static str,amount: f64,}fn main() {let mut transactions = vec![Transaction { transaction_type: "Deposit", amount: 100.0 },Transaction { transaction_type: "Withdrawal", amount: 50.0 },Transaction { transaction_type: "Deposit", amount: 200.0 },Transaction { transaction_type: "Withdrawal", amount: 75.0 },];let mut total_balance = 0.0;while !transactions.is_empty() {let transaction = transactions.pop().unwrap(); // 从末尾取出一个交易记录match transaction.transaction_type {"Deposit" => total_balance += transaction.amount,"Withdrawal" => total_balance -= transaction.amount,_ => (),}}println!("Account Balance: ${:.2}", total_balance);}
在这个示例中，我们定义了一个 Transaction 结构体来表示交易记录，包括交易类型和金额。我们创建了一个包含多个交易记录的 transactions 向量，并初始化 total_balance 为零。
然后，我们使用 while 循环来迭代处理交易记录，直到 transactions 向量为空。在每次循环迭代中，我们从 transactions 向量的末尾取出一个交易记录，并根据交易类型更新 total_balance。最终，当所有交易记录都处理完毕时，循环将终止，我们打印出账户余额。
这个示例演示了如何使用 while 循环来处理一个动态变化的数据集，直到满足退出条件为止。在金融领域，这种循环可以用于处理交易记录、账单或其他需要迭代处理的数据。
9.5 loop循环
loop 循环是 Rust 中的一种基本循环结构，它允许你无限次地重复执行一个代码块，直到明确通过 break 语句终止循环。与 while 循环不同，loop 循环没有条件表达式来判断是否退出循环，因此它总是会无限循环，直到遇到 break。
以下是 loop 循环的一般形式：
loop {// 循环体代码if condition {break; // 通过 break 语句终止循环}}
循环体中的代码块将无限次地执行，直到遇到 break语句。condition是一个可选的条件表达式，当条件为真时，循环将终止。
下面是一个使用 loop 循环的示例，演示了如何计算存款和提款的总和，直到输入的交易记录为空：
struct Transaction {transaction_type: &'static str,amount: f64,}fn main() {let mut transactions = Vec::new();loop {let transaction_type: String = {println!("Enter transaction type (Deposit/Withdrawal) or 'done' to finish:");let mut input = String::new();std::io::stdin().read_line(&mut input).expect("Failed to read line");input.trim().to_string()};if transaction_type == "done" {break; // 通过 break 语句终止循环}let amount: f64 = {println!("Enter transaction amount:");let mut input = String::new();std::io::stdin().read_line(&mut input).expect("Failed to read line");input.trim().parse().expect("Invalid input")};transactions.push(Transaction {transaction_type: &transaction_type,amount,});}let mut total_balance = 0.0;for transaction in &transactions {match transaction.transaction_type {"Deposit" => total_balance += transaction.amount,"Withdrawal" => total_balance -= transaction.amount,_ => (),}}println!("Account Balance: ${:.2}", total_balance);}
在这个示例中，我们首先定义了一个 Transaction 结构体来表示交易记录，包括交易类型和金额。然后，我们创建了一个空的 transactions 向量，用于存储用户输入的交易记录。
接着，我们使用 loop 循环来反复询问用户输入交易类型和金额，直到用户输入 "done" 为止。如果用户输入 "done"，则通过 break 语句终止循环。否则，我们将用户输入的交易记录添加到 transactions 向量中。
最后，我们遍历 transactions 向量，计算存款和提款的总和，以获取账户余额，并打印出结果。
这个示例演示了如何使用 loop 循环处理用户输入的交易记录，直到用户选择退出。在金融领域，这种循环可以用于交互式地记录和计算账户的交易信息。
9.6 if let 和 while let语法糖
if let 和 while let 是 Rust 中的语法糖，用于简化模式匹配的常见用例，特别是用于处理 Option 和 Result 类型。它们允许你以更简洁的方式进行模式匹配，以处理可能的成功或失败情况。
1. if let 表达式：
if let 允许你检查一个值是否匹配某个模式，并在匹配成功时执行代码块。语法如下：
if let Some(value) = some_option {// 匹配成功，使用 value} else {// 匹配失败}
在上述示例中，如果 some_option 是 Some 包装的值，那么匹配成功，并且 value 将被绑定到 Some 中的值，然后执行相应的代码块。如果 some_option 是 None，则匹配失败，执行 else 块。
2. while let 循环：
while let 允许你重复执行一个代码块，直到匹配失败（通常是直到 None）。语法如下：
while let Some(value) = some_option {// 匹配成功，使用 value}
在上述示例中，只要 some_option 是 Some 包装的值，就会重复执行代码块，并且 value 会在每次迭代中被绑定到 Some 中的值。一旦匹配失败（即 some_option 变为 None），循环将终止。
金融案例示例：
假设我们有一个金融应用程序，其中用户可以进行存款和提款操作，而每个操作都以 Transaction 结构体表示。我们将使用 Option 来模拟用户输入的交易，然后使用 if let 和 while let 处理这些交易。
struct Transaction {transaction_type: &'static str,amount: f64,}fn main() {let mut account_balance = 0.0;// 模拟用户输入的交易列表let transactions = vec![Some(Transaction { transaction_type: "Deposit", amount: 100.0 }),Some(Transaction { transaction_type: "Withdrawal", amount: 50.0 }),Some(Transaction { transaction_type: "Deposit", amount: 200.0 }),None, // 用户结束输入];for transaction in transactions {if let Some(tx) = transaction {match tx.transaction_type {"Deposit" => {account_balance += tx.amount;println!("Deposited ${:.2}", tx.amount);}"Withdrawal" => {account_balance -= tx.amount;println!("Withdrawn ${:.2}", tx.amount);}_ => println!("Invalid transaction type"),}} else {break; // 用户结束输入，退出循环}}println!("Account Balance: ${:.2}", account_balance);}
在这个示例中，我们使用 transactions 向量来模拟用户输入的交易记录，包括存款和提款，以及一个 None 表示用户结束输入。然后，我们使用 for 循环和 if let 来处理每个交易记录，当遇到 None 时，循环终止。
这个示例演示了如何使用 if let 和 while let 简化模式匹配，以处理可能的成功和失败情况，以及在金融应用程序中处理用户输入的交易记录。
9.7 并发迭代器
在 Rust 中，通过标准库的 rayon crate，你可以轻松创建并发迭代器，用于在并行计算中高效处理集合的元素。rayon 提供了一种并发编程的方式，能够利用多核处理器的性能，特别适合处理大规模数据集。
以下是如何使用并发迭代器的一般步骤：
首先，确保在
Cargo.toml中添加rayoncrate 的依赖：[dependencies]rayon = "1.5"导入
rayoncrate：use rayon::prelude::*;使用
.par_iter()方法将集合转换为并发迭代器。然后，你可以调用.for_each()、.map()、.filter()等方法来进行并行操作。
以下是一个金融案例，演示如何使用并发迭代器计算多个账户的总余额。每个账户包含一组交易记录，每个记录都有交易类型（存款或提款）和金额。我们将并行计算每个账户的总余额，然后计算所有账户的总余额。
use rayon::prelude::*;struct Transaction {transaction_type: &'static str,amount: f64,}struct Account {transactions: Vec<Transaction>,}impl Account {fn new(transactions: Vec<Transaction>) -> Self {Account { transactions }}fn calculate_balance(&self) -> f64 {self.transactions.par_iter() // 将迭代器转换为并发迭代器.map(|transaction| {match transaction.transaction_type {"Deposit" => transaction.amount,"Withdrawal" => -transaction.amount,_ => 0.0,}}).sum() // 并行计算总和}}fn main() {let account1 = Account::new(vec![Transaction { transaction_type: "Deposit", amount: 100.0 },Transaction { transaction_type: "Withdrawal", amount: 50.0 },Transaction { transaction_type: "Deposit", amount: 200.0 },]);let account2 = Account::new(vec![Transaction { transaction_type: "Deposit", amount: 300.0 },Transaction { transaction_type: "Withdrawal", amount: 75.0 },]);let total_balance: f64 = vec![&account1, &account2].par_iter().map(|account| account.calculate_balance()).sum(); // 并行计算总和println!("Total Account Balance: ${:.2}", total_balance);}
在这个示例中，我们定义了 Transaction 结构体表示交易记录和 Account 结构体表示账户。每个账户包含一组交易记录。在 Account 结构体上，我们实现了 calculate_balance() 方法，该方法使用并发迭代器计算账户的总余额。
在 main 函数中，我们创建了两个账户 account1 和 account2，然后将它们放入一个向量中。接着，我们使用并发迭代器来并行计算每个账户的余额，并将所有账户的总余额相加，最后打印出结果。
这个示例演示了如何使用 rayon crate 的并发迭代器来高效处理金融应用程序中的数据，特别是在处理多个账户时，可以充分利用多核处理器的性能。
Chapter 10 - 函数, 方法 和 闭包
在Rust中，函数、方法和闭包都是用于执行代码的可调用对象，但它们在语法和用途上有相当的不同。下面我会详细解释每种可调用对象的特点和用法：
函数(Function)：
函数是Rust中最基本的可调用对象。
函数通常在全局作用域或模块中定义，并且可以通过名称来调用。
函数可以接受参数，并且可以返回一个值。
函数的定义以
fn关键字开头，如下所示：fn add(a: i32, b: i32) -> i32 {a + b}在调用函数时，你可以使用其名称，并传递适当的参数，如下所示：
let result = add(5, 3);
方法(Method)：
方法是与特定类型关联的函数。在Rust中，方法是面向对象编程的一部分。
方法是通过将函数与结构体、枚举、或者 trait 相关联来定义的。
方法使用
self参数来访问调用它们的实例的属性和行为。方法的定义以
impl关键字开始，如下所示：struct Rectangle {width: u32,height: u32,}impl Rectangle {fn area(&self) -> u32 {self.width * self.height}}在调用方法时，你首先创建一个实例，然后使用点号运算符调用方法，如下所示：
let rect = Rectangle { width: 10, height: 20 };let area = rect.area();
闭包(Closure)：
闭包是一个可以捕获其环境的匿名函数。它们类似于函数，但可以捕获局部变量和外部变量，使其具有一定的状态。
闭包可以存储在变量中，传递给其他函数或返回作为函数的结果。
闭包通常使用
||语法来定义，如下所示：let add_closure = |a, b| a + b;你可以像调用函数一样调用闭包，如下所示：
let result = add_closure(5, 3);闭包可以捕获外部变量，例如：
let x = 5;let closure = |y| x + y;let result = closure(3); // result 等于 8
这些是Rust中函数、方法和闭包的基本概念和用法。每种可调用对象都有其自己的用途和适用场景，根据需要选择合适的工具来编写代码。本章的重点则是函数的进阶用法和闭包的学习。
10.1 函数进阶
如同python支持泛型函数、高阶函数、匿名函数;C语言也支持泛型函数和函数指针一样，Rust中的函数支持许多进阶用法，这些用法可以帮助你编写更灵活、更高效的代码。以下是一些常见的函数进阶用法：
10.1.1 泛型函数(Generic Functions)
(在第14章，我们会进一步详细了解泛型函数)
使用泛型参数可以编写通用的函数，这些函数可以用于不同类型的数据。
通过在函数签名中使用尖括号 <T> 来声明泛型参数，并在函数体中使用这些参数来编写通用代码。
以下是一个更简单的例子，演示如何编写一个泛型函数 find_max 来查找任何类型的元素列表中的最大值：
fn find_max_and_report_letters(list: &[&str]) -> Option<f64> {if list.is_empty() {return None; // 如果列表为空，返回 None}let mut max = None; // 用 Option 来存储最大值let mut has_letters = false; // 用来标记是否包含字母for item in list.iter() {match item.parse::<f64>() {Ok(number) => {// 如果成功解析为浮点数if max.is_none() || number > max.unwrap() {max = Some(number);}}Err(_) => {// 解析失败，表示列表中不小心混入了字母，无法比较。把这个bool传给has_letters.has_letters = true;}}}if has_letters {println!("列表中包含字母。");}max // 返回找到的最大值作为 Option<f64>}fn main() {let data = vec!["3.5", "7.2", "1.8", "9.0", "4.7", "2.1", "A", "B"];let max_number = find_max_and_report_letters(&data);match max_number {Some(max) => println!("最大的数字是: {}", max),None => println!("没有找到有效的数字。"),}}
执行结果：
列表中包含字母。最大的数字是: 9
在这个例子中，find_max 函数接受一个泛型切片 list，并在其中查找最大值。首先，它检查列表是否为空，如果是，则返回 None。然后，它遍历列表中的每个元素，将当前最大值与元素进行比较，如果找到更大的元素，就更新 max，并且如果有字母还会汇报给我们。最后，函数返回找到的最大值作为 Option<&T>。
10.1.2 高阶函数(Higher-Order Functions)
高阶函数(Higher-Order Functions)是一种编程概念，指可以接受其他函数作为参数或者返回函数作为结果的函数, 它在Rust中有广泛的支持和应用。
以下是关于高阶函数在Rust中的详细介绍：
函数作为参数： 在Rust中，可以将函数作为参数传递给其他函数。这使得我们可以编写通用的函数，以便它们可以操作不同类型的函数。通常，这样的函数接受一个函数闭包(closure)作为参数，然后在其内部使用这个闭包来完成一些操作。
fn apply<F>(func: F, value: i32) -> i32whereF: Fn(i32) -> i32,{func(value)}fn double(x: i32) -> i32 {x * 2}fn main() {let result = apply(double, 5);println!("Result: {}", result);}返回函数： 类似地，你可以编写函数，以函数作为它们的返回值。这种函数通常被称为工厂函数，因为它们返回其他函数的实例。
fn create_multiplier(factor: i32) -> impl Fn(i32) -> i32 { //"impl Fn(i32) -> i32 " 是返回类型的标记，它用于指定闭包的类型签名。move |x| x * factor}fn main() {let multiply_by_3 = create_multiplier(3);let result = multiply_by_3(5);println!("Result: {}", result); // 输出 15}在上面的代码中，
move关键字用于定义一个闭包(匿名函数)，这个闭包捕获了外部的变量factor。在 Rust 中，闭包默认是对外部变量的借用(borrow)，但在这个例子中，使用move关键字表示闭包会拥有捕获的变量factor的所有权：move关键字的作用是将外部变量的所有权移动到闭包内部，这意味着闭包在内部拥有这个变量的控制权，不再依赖于外部的变量。这对于在闭包中捕获外部变量并在之后继续使用它们非常有用，尤其是当这些外部变量可能超出了其作用域时(如在异步编程中)。create_multiplier函数接受一个factor参数，它是一个整数。然后，它返回一个闭包，这个闭包接受一个整数x作为参数，并返回x * factor的结果。在
main函数中，我们首先调用create_multiplier(3)，这将返回一个闭包，这个闭包捕获了factor变量，其值为 3。然后，我们调用
multiply_by_3(5)，这实际上是调用了我们之前创建的闭包。闭包中的factor值是 3，所以5 * 3的结果是 15。最后，我们将结果打印到控制台，输出的结果是
15。迭代器和高阶函数： Rust的标准库提供了丰富的迭代器方法，这些方法允许你对集合(如数组、向量、迭代器等)进行高级操作，例如
map、filter、fold等。这些方法都可以接受函数闭包作为参数，使你能够非常灵活地处理数据。let numbers = vec![1, 2, 3, 4, 5];// 使用map高阶函数将每个数字加倍let doubled_numbers: Vec<i32> = numbers.iter().map(|x| x * 2).collect();// 使用filter高阶函数选择偶数let even_numbers: Vec<i32> = numbers.iter().filter(|x| x % 2 == 0).cloned().collect();
高阶函数使得在Rust中编写更具可读性和可维护性的代码变得更容易，同时也允许你以一种更加抽象的方式处理数据和逻辑。通过使用闭包和泛型，Rust的高阶函数提供了强大的工具，使得编程更加灵活和表达力强。
10.1.3 匿名函数(Anonymous Functions)
除了常规的函数定义，Rust还支持匿名函数，也就是闭包。 闭包可以在需要时定义，并且可以捕获其环境中的变量。
let add = |a, b| a + b;let result = add(5, 3); // result 等于 8
案例：计算投资组合的预期收益和风险
在金融领域，高阶函数可以用来处理投资组合(portfolio)的各种分析和优化问题。以下是一个示例，演示如何使用高阶函数来计算投资组合的收益和风险。
假设我们有一个投资组合，其中包含多个不同的资产，每个资产都有一个预期收益率和风险(标准差)率。我们可以定义一个高阶函数来计算投资组合的预期收益和风险，以及根据风险偏好优化资产配置。
struct Asset {expected_return: f64,risk: f64,}fn calculate_portfolio_metrics(assets: &[Asset], weights: &[f64]) -> (f64, f64) {let expected_return: f64 = assets.iter().zip(weights.iter()).map(|(asset, weight)| asset.expected_return * weight).sum::<f64>();let portfolio_risk: f64 = assets.iter().zip(weights.iter()).map(|(asset, weight)| asset.risk * asset.risk * weight * weight).sum::<f64>();(expected_return, portfolio_risk)}fn optimize_with_algorithm<F>(_objective_function: F, initial_weights: Vec<f64>) -> Vec<f64>whereF: Fn(Vec<f64>) -> f64,{// 这里简化为均匀分配权重的实现，实际中需要使用优化算法initial_weights}fn optimize_portfolio(assets: &[Asset], risk_preference: f64) -> Vec<f64> {let objective_function = |weights: Vec<f64>| -> f64 {let (expected_return, portfolio_risk) = calculate_portfolio_metrics(&assets, &weights);expected_return - risk_preference * portfolio_risk};let num_assets = assets.len();let initial_weights = vec![1.0 / num_assets as f64; num_assets];let optimized_weights = optimize_with_algorithm(objective_function, initial_weights);optimized_weights}fn main() {let asset1 = Asset {expected_return: 0.08,risk: 0.12,};let asset2 = Asset {expected_return: 0.12,risk: 0.18,};let assets = vec![asset1, asset2];let risk_preference = 2.0;let optimized_weights = optimize_portfolio(&assets, risk_preference);println!("Optimal Portfolio Weights: {:?}", optimized_weights);}
在这个示例中，我们使用高阶函数来计算投资组合的预期收益和风险，并定义了一个优化函数作为闭包。通过传递不同的风险偏好参数，我们可以优化资产配置，以在风险和回报之间找到最佳平衡点。这是金融领域中使用高阶函数进行投资组合分析和优化的一个简单示例。实际中，会有更多复杂的模型和算法用于处理这类问题。
补充学习：zip方法
在Rust中，zip 是一个迭代器适配器方法，它用于将两个迭代器逐个元素地配对在一起，生成一个新的迭代器，该迭代器返回一个元组，其中包含来自两个原始迭代器的对应元素。
zip 方法的签名如下：
fn zip<U>(self, other: U) -> Zip<Self, U::IntoIter>whereU: IntoIterator;
这个方法接受另一个可迭代对象 other 作为参数，并返回一个 Zip 迭代器，该迭代器产生一个元组，其中包含来自调用 zip 方法的迭代器和 other 迭代器的对应元素。
以下是一个简单的示例，演示如何使用 zip 方法：
fn main() {let numbers = vec![1, 2, 3];let letters = vec!['A', 'B', 'C'];let zipped = numbers.iter().zip(letters.iter());for (num, letter) in zipped {println!("Number: {}, Letter: {}", num, letter);}}
在这个示例中，我们有两个向量 numbers 和 letters，它们分别包含整数和字符。我们使用 zip方法将它们配对在一起，创建了一个新的迭代器 zipped。然后，我们可以使用 for 循环遍历 zipped 迭代器，每次迭代都会返回一个包含整数和字符的元组，允许我们同时访问两个向量的元素。
输出结果将会是：
Number: 1, Letter: ANumber: 2, Letter: BNumber: 3, Letter: C
zip 方法在处理多个迭代器并希望将它们一一匹配在一起时非常有用。这使得同时遍历多个集合变得更加方便。
10.2 闭包进阶
闭包是 Rust 中非常强大和灵活的概念，它们允许你将代码块封装为值，以便在程序中传递和使用。闭包通常用于以下几种场景：
匿名函数： 闭包允许你创建匿名函数，它们可以在需要的地方定义和使用，而不必命名为函数。 捕获环境： 闭包可以捕获其周围的变量和状态，可以在闭包内部引用外部作用域中的变量。 函数作为参数： 闭包可以作为函数的参数传递，从而可以将自定义行为注入到函数中。 迭代器： Rust 中的迭代器方法通常接受闭包作为参数，用于自定义元素处理逻辑。
以下是闭包的一般语法：
|参数1, 参数2| -> 返回类型 {// 闭包体// 可以使用参数1、参数2以及捕获的外部变量}
闭包参数可以根据需要包含零个或多个，并且可以指定返回类型。闭包体是代码块，它定义了闭包的行为。
闭包的种类：
Rust 中有三种主要类型的闭包，分别是：
FnOnce： 只能调用一次的闭包，通常会消耗（move）捕获的变量。 FnMut： 可以多次调用的闭包，通常会可变地借用捕获的变量。 Fn： 可以多次调用的闭包，通常会不可变地借用捕获的变量。
闭包的种类由闭包的行为和捕获的变量是否可变来决定。
示例1：
// 一个简单的闭包示例，计算两个数字的和let add = |x, y| x + y;let result = add(2, 3); // 调用闭包println!("Sum: {}", result);
示例2：
// 捕获外部变量的闭包示例let x = 10;let increment = |y| y + x;let result = increment(5); // 调用闭包println!("Result: {}", result);
示例3：
// 使用闭包作为参数的函数示例fn apply_operation<F>(a: i32, b: i32, operation: F) -> i32whereF: Fn(i32, i32) -> i32,{operation(a, b)}let sum = apply_operation(2, 3, |x, y| x + y);let product = apply_operation(2, 3, |x, y| x * y);println!("Sum: {}", sum);println!("Product: {}", product);
金融案例1：
假设我们有一个存储股票价格的向量，并希望计算这些价格的平均值。我们可以使用闭包来定义自定义的计算平均值逻辑。
fn main() {let stock_prices = vec![50.0, 55.0, 60.0, 65.0, 70.0];// 使用闭包计算平均值let calculate_average = |prices: &[f64]| {let sum: f64 = prices.iter().sum();sum / (prices.len() as f64)};let average_price = calculate_average(&stock_prices);println!("Average Stock Price: {:.2}", average_price);}
金融案例2：
假设我们有一个银行应用程序，需要根据不同的账户类型计算利息。我们可以使用闭包作为参数传递到函数中，根据不同的账户类型应用不同的利息计算逻辑。
fn main() {struct Account {balance: f64,account_type: &'static str,}let accounts = vec![Account { balance: 1000.0, account_type: "Savings" },Account { balance: 5000.0, account_type: "Checking" },Account { balance: 20000.0, account_type: "Fixed Deposit" },];// 使用闭包计算利息let calculate_interest = |balance: f64, account_type: &str| -> f64 {match account_type {"Savings" => balance * 0.03,"Checking" => balance * 0.01,"Fixed Deposit" => balance * 0.05,_ =>
接下来，让我们为 FnOnce 和 FnMut 也提供一个金融案例。
金融案例3（FnOnce）：
假设我们有一个账户管理应用程序，其中包含一个 Transaction 结构体表示交易记录。我们希望使用 FnOnce 闭包来处理每个交易，确保每笔交易只处理一次，以防止重复计算。
fn main() {struct Transaction {transaction_type: &'static str,amount: f64,}let transactions = vec![Transaction { transaction_type: "Deposit", amount: 100.0 },Transaction { transaction_type: "Withdrawal", amount: 50.0 },Transaction { transaction_type: "Deposit", amount: 200.0 },];// 定义处理交易的闭包let process_transaction = |transaction: Transaction| {match transaction.transaction_type {"Deposit" => println!("Processed deposit of ${:.2}", transaction.amount),"Withdrawal" => println!("Processed withdrawal of ${:.2}", transaction.amount),_ => println!("Invalid transaction type"),}};// 使用FnOnce闭包处理交易，每笔交易只能处理一次for transaction in transactions {process_transaction(transaction);}}
在这个示例中，我们有一个 Transaction 结构体表示交易记录，并定义了一个 process_transaction 闭包，用于处理每笔交易。由于 FnOnce 闭包只能调用一次，我们在循环中传递每个交易记录，并在每次迭代中使用 process_transaction 闭包处理交易。
金融案例4（FnMut）：
假设我们有一个股票监控应用程序，其中包含一个股票价格列表，我们需要周期性地更新股票价格。我们可以使用 FnMut 闭包来更新价格列表中的股票价格。
fn main() {let mut stock_prices = vec![50.0, 55.0, 60.0, 65.0, 70.0];// 定义更新股票价格的闭包let mut update_stock_prices = |prices: &mut Vec<f64>| {for price in prices.iter_mut() {// 模拟市场波动，更新价格let market_fluctuation = rand::random::<f64>() * 5.0 - 2.5;*price += market_fluctuation;}};// 使用FnMut闭包周期性地更新股票价格for _ in 0..5 {update_stock_prices(&mut stock_prices);println!("Updated Stock Prices: {:?}", stock_prices);}}
在这个示例中，我们有一个股票价格列表 stock_prices，并定义了一个 update_stock_prices 闭包，该闭包使用 FnMut 特性以可变方式更新价格列表中的股票价格。我们在循环中多次调用 update_stock_prices 闭包，模拟市场波动和价格更新。
Chapter 11 - 模块
在 Rust 中，模块(Modules)是一种组织和管理代码的方式，它允许你将相关的函数、结构体、枚举、常量等项组织成一个单独的单元。模块有助于代码的组织、可维护性和封装性，使得大型项目更容易管理和理解。
以下是关于 Rust 模块的重要概念和解释：
模块的定义： 模块可以在 Rust 代码中通过
mod关键字定义。一个模块可以包含其他模块、函数、结构体、枚举、常量和其他项。模块通常以一个包含相关功能的文件为单位进行组织。// 定义一个名为 `my_module` 的模块mod my_module {// 在模块内部可以包含其他项fn my_function() {println!("This is my function.");}}模块的嵌套： 你可以在一个模块内部定义其他模块，从而创建嵌套的模块结构，这有助于更细粒度地组织代码。
mod outer_module {mod inner_module {// ...}}访问项： 模块内部的项默认是私有的，如果要从外部访问模块内的项，需要使用
pub关键字来将它们标记为公共。mod my_module {pub fn my_public_function() {println!("This is a public function.");}}使用模块： 在其他文件中使用模块内的项需要使用
use关键字导入模块。// 导入模块use my_module::my_public_function;fn main() {// 调用模块内的函数my_public_function();}模块文件结构： Rust 鼓励按照文件和目录的结构来组织模块。每个模块通常位于一个单独的文件中，文件的结构和模块结构相对应。例如，一个名为
my_module的模块通常存储在一个名为my_module.rs的文件中。project/├── src/│ ├── main.rs│ ├── my_module.rs│ └── other_module.rs模块的可见性： 默认情况下，模块内的项对外是不可见的，除非它们被标记为
pub。这有助于封装代码，只有公共接口对外可见，内部实现细节被隐藏。模块的作用域： Rust 的模块系统具有词法作用域。这意味着模块和项的可见性是通过它们在代码中的位置来确定的。一个模块可以访问其父模块的项，但不能访问其子模块的项，除非它们被导入。
模块是 Rust 语言中的一个关键概念，它有助于构建模块化、可维护和可扩展的代码结构。通过合理使用模块，可以将代码分解为更小的、可重用的单元，提高代码的可读性和可维护性。
案例：软件工程：组织金融产品模块
在金融领域，使用 Rust 的模块系统可以很好地组织和管理不同类型的金融工具和计算。以下是一个示例，演示如何使用模块来组织不同类型的金融工具和相关计算。
假设我们有几种金融工具，例如股票(Stock)、债券(Bond)和期权(Option)，以及一些计算函数，如计算收益、风险等。我们可以使用模块来组织这些功能。
首先，创建一个 financial_instruments 模块，其中包含不同类型的金融工具定义：
// financial_instruments.rspub mod stock {pub struct Stock {// ...}impl Stock {pub fn new() -> Self {// 初始化股票Stock {// ...}}// 其他股票相关方te x t法}}pub mod bond {pub struct Bond {// ...}impl Bond {pub fn new() -> Self {// 初始化债券Bond {// ...}}// 其他债券相关方法}}pub mod option {pub struct Option {// ...}impl Option {pub fn new() -> Self {// 初始化期权Option {// ...}}// 其他期权相关方法}}
接下来，创建一个 calculations 模块，其中包含与金融工具相关的计算函数：
// calculations.rsuse crate::financial_instruments::{stock::Stock, bond::Bond, option::Option};pub fn calculate_stock_return(stock: &Stock) -> f64 {// 计算股票的收益// ...}pub fn calculate_bond_return(bond: &Bond) -> f64 {// 计算债券的收益// ...}pub fn calculate_option_risk(option: &Option) -> f64 {// 计算期权的风险// ...}
最后，在主程序中，你可以导入模块并使用定义的金融工具和计算函数：
// main.rsmod financial_instruments;mod calculations;use financial_instruments::{stock::Stock, bond::Bond, option::Option};use calculations::{calculate_stock_return, calculate_bond_return, calculate_option_risk};fn main() {let stock = Stock::new();let bond = Bond::new();let option = Option::new();let stock_return = calculate_stock_return(&stock);let bond_return = calculate_bond_return(&bond);let option_risk = calculate_option_risk(&option);println!("Stock Return: {}", stock_return);println!("Bond Return: {}", bond_return);println!("Option Risk: {}", option_risk);}
通过这种方式，你可以将不同类型的金融工具和相关计算函数封装在不同的模块中，使代码更有结构和组织性。这有助于提高代码的可维护性，使得在金融领域开发复杂应用程序更容易。
原文仓库：
https://github.com/arthur19q3/Cookbook-for-Rustaceans-in-Finance