Skip to content
Cookbook for Rustaceans in Finance / Rust 量化金融开发指南

类型系统

在量化金融领域，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: 4
size of `b` in bytes: 4
size of `c` in bytes: 8
size of `d` in bytes: 4
size 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 中定义的。

让我们详细解释这些概念：

  1. Crate：在 Rust 中，crate 是最高级别的代码组织单元，可以看作是一个库或一个包。Rust 的标准库(Standard Library)也是一个 crate，通常被引用为 std。

  2. 模块：模块是用于组织和封装代码的逻辑单元。模块可以包含函数、结构体、枚举、常量等。在示例中，std crate 包含了一个名为 mem 的模块，而 mem 模块包含了 size_of_val 函数。

  3. 完整路径：在 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)。

  1. 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 进行类型转换可能会导致数据丢失或不确定行为，因此要谨慎使用。在程序设计之初，最好就能规划好变量数据的类型。

  2. From 和 Into trait：

    在量化金融领域，From 和 Into trait 可以用来实现自定义类型之间的转换，以便在处理金融数据和算法时更方便地操作不同的数据类型。下面让我们使用一个简单的例子来说明这两个 trait 在量化金融中的应用。

    假设我们有两种不同的金融工具类型：Stock(股票)和 Option(期权)。我们希望能够在这两种类型之间进行转换，以便在金融算法中更灵活地处理它们。

    首先，我们可以定义这两种类型的结构体：

    struct Stock {
        symbol: String,
        price: f64,
    }
    

    struct Option {
        symbol: String,
        strike_price: f64,
        expiration_date: String,
    }

    现在，让我们使用 From 和 Into trait 来实现类型之间的转换。

    从 Stock 到 Option 的转换：

    假设我们希望从一个股票创建一个对应的期权。我们可以实现 From trait 来定义如何从 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 的转换：

    如果我们希望从一个期权创建一个对应的股票，我们可以实现相反方向的转换，使用 From trait 或 Into trait 的逆操作。

    impl From<Option> for Stock {
        fn from(option: Option) -> Self {
            Stock {
                symbol: option.symbol,
                price: option.strike_price / 1.1, // 假设期权的行权价是股票价格的110%
            }
        }
    }

    或者，我们可以使用 Into trait 进行相反方向的转换：

    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 和 Into trait，我们可以自定义类型之间的转换逻辑，使得在量化金融算法中更容易地处理不同的金融工具类型，提高了代码的灵活性和可维护性。这有助于简化金融数据处理的代码，并使其更具可读性。

7.4 自动类型推断(Inference)

在Rust中，类型推断引擎非常强大，它不仅在初始化变量时考虑右值(r-value)的类型，还会分析变量之后的使用情况，以便更准确地推断类型。以下是一个更复杂的类型推断示例，我们将详细说明它的工作原理。

fn main() {
    let mut x = 5; // 变量 x 被初始化为整数 5
    x = 10; // 现在，将 x 更新为整数 10
    println!("x = {}", x);
}

在这个示例中，我们首先声明了一个变量 x，并将其初始化为整数5。然后，我们将 x 的值更改为整数10，并最后打印出 x 的值。

Rust的类型推断引擎如何工作：

  1. 变量初始化：当我们声明 x 并将其初始化为5时，Rust的类型推断引擎会根据右值的类型(这里是整数5)推断出 x 的类型为整数(i32)。
  2. 赋值操作：当我们执行 x = 10; 这行代码时，Rust不仅检查右值(整数10)的类型，还会考虑左值(变量 x)的类型。它发现 x 已经被推断为整数(i32)，所以它知道我们尝试将一个整数赋给 x，并且这是合法的。
  3. 打印：最后，我们使用 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.0
Option value: true

在这个示例中，我们定义了一个泛型结构体 FinancialInstrument<T>，它可以存储不同类型的金融工具的值。无论是股票还是期权，我们都可以使用相同的代码来创建和访问它们的值。

在 main 函数中，我们创建了一个股票(stock)和一个期权(option)，它们都使用了相同的泛型结构体 FinancialInstrument<T>。然后，我们使用 get_value 方法来访问它们的值，并打印出来。

但是,

在实际操作层面,这是一个非常好的反例,应该尽量避免,因为使用泛型把不同的金融工具归纳为FinancialInstrument, 会造成不必要的混淆。

在实际应用中使用泛型时需要考虑的建议：

  1. 合理使用泛型：只有在需要处理多种数据类型的情况下才使用泛型。如果只有一种或少数几种数据类型，那么可能不需要泛型，可以直接使用具体类型。
  2. 提供有意义的类型参数名称：为泛型参数选择有意义的名称，以便其他开发人员能够理解代码的含义。避免使用过于抽象的名称。
  3. 文档和注释：为使用泛型的代码提供清晰的文档和注释，解释泛型参数的作用和预期的数据类型。这有助于其他开发人员更容易理解代码。
  4. 测试和验证：确保使用泛型的代码经过充分的测试和验证，以确保其正确性和性能。泛型代码可能会引入更多的复杂性，因此需要额外的关注。
  5. 避免过度抽象：避免在不必要的地方使用泛型。如果一个特定的实现对于某个特定问题更加清晰和高效，不要强行使用泛型。

案例： 通用投资组合

承接上文，让我们看一个更合适的案例，其中泛型用于处理更具体的问题。考虑一个投资组合管理系统，其中有不同类型的资产(股票、债券、期权等)。我们可以使用泛型来实现一个通用的投资组合结构，但同时保留每种资产的具体类型：

// 定义一个泛型的资产结构
#[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: AAPL
Date: 2023-09-13
Price: $150
Volume: 10000


Bond Data:
Name: US Treasury Bond
Date: 2023-09-13
Price: $1000