【typenum】 16 无符号整数标记

原创 已于 2025-08-19 21:01:10 修改 · 3.5k 阅读 · 6 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#rust

于 2025-08-18 11:01:36 首次发布

一、源码

这段代码是 Rust 中用于实现编译时无符号整数的核心部分。它定义了一个 Unsigned trait 并为两种类型实现了该 trait：UTerm（表示零）和 UInt<U, B>（表示非零数字）。

  1. 定义（marker_traits.rs）
/// The **marker trait** for compile time unsigned integers.
///
/// # Example
/// ```rust
/// use typenum::{Unsigned, U3};
///
/// assert_eq!(U3::to_u32(), 3);
/// assert_eq!(U3::I32, 3);
/// ```
pub trait Unsigned: Sealed + Copy + Default + 'static {
    #[allow(missing_docs)]
    const U8: u8;
    #[allow(missing_docs)]
    const U16: u16;
    #[allow(missing_docs)]
    const U32: u32;
    #[allow(missing_docs)]
    const U64: u64;
    #[cfg(feature = "i128")]
    #[allow(missing_docs)]
    const U128: u128;
    #[allow(missing_docs)]
    const USIZE: usize;

    #[allow(missing_docs)]
    const I8: i8;
    #[allow(missing_docs)]
    const I16: i16;
    #[allow(missing_docs)]
    const I32: i32;
    #[allow(missing_docs)]
    const I64: i64;
    #[cfg(feature = "i128")]
    #[allow(missing_docs)]
    const I128: i128;
    #[allow(missing_docs)]
    const ISIZE: isize;

    #[allow(missing_docs)]
    fn to_u8() -> u8;
    #[allow(missing_docs)]
    fn to_u16() -> u16;
    #[allow(missing_docs)]
    fn to_u32() -> u32;
    #[allow(missing_docs)]
    fn to_u64() -> u64;
    #[cfg(feature = "i128")]
    #[allow(missing_docs)]
    fn to_u128() -> u128;
    #[allow(missing_docs)]
    fn to_usize() -> usize;

    #[allow(missing_docs)]
    fn to_i8() -> i8;
    #[allow(missing_docs)]
    fn to_i16() -> i16;
    #[allow(missing_docs)]
    fn to_i32() -> i32;
    #[allow(missing_docs)]
    fn to_i64() -> i64;
    #[cfg(feature = "i128")]
    #[allow(missing_docs)]
    fn to_i128() -> i128;
    #[allow(missing_docs)]
    fn to_isize() -> isize;
}
  1. 实现
impl Unsigned for UTerm {
    const U8: u8 = 0;
    const U16: u16 = 0;
    const U32: u32 = 0;
    const U64: u64 = 0;
    #[cfg(feature = "i128")]
    const U128: u128 = 0;
    const USIZE: usize = 0;

    const I8: i8 = 0;
    const I16: i16 = 0;
    const I32: i32 = 0;
    const I64: i64 = 0;
    #[cfg(feature = "i128")]
    const I128: i128 = 0;
    const ISIZE: isize = 0;

    #[inline]
    fn to_u8() -> u8 {
        0
    }
    #[inline]
    fn to_u16() -> u16 {
        0
    }
    #[inline]
    fn to_u32() -> u32 {
        0
    }
    #[inline]
    fn to_u64() -> u64 {
        0
    }
    #[cfg(feature = "i128")]
    #[inline]
    fn to_u128() -> u128 {
        0
    }
    #[inline]
    fn to_usize() -> usize {
        0
    }

    #[inline]
    fn to_i8() -> i8 {
        0
    }
    #[inline]
    fn to_i16() -> i16 {
        0
    }
    #[inline]
    fn to_i32() -> i32 {
        0
    }
    #[inline]
    fn to_i64() -> i64 {
        0
    }
    #[cfg(feature = "i128")]
    #[inline]
    fn to_i128() -> i128 {
        0
    }
    #[inline]
    fn to_isize() -> isize {
        0
    }
}

impl<U: Unsigned, B: Bit> Unsigned for UInt<U, B> {
    const U8: u8 = B::U8 | U::U8 << 1;
    const U16: u16 = B::U8 as u16 | U::U16 << 1;
    const U32: u32 = B::U8 as u32 | U::U32 << 1;
    const U64: u64 = B::U8 as u64 | U::U64 << 1;
    #[cfg(feature = "i128")]
    const U128: u128 = B::U8 as u128 | U::U128 << 1;
    const USIZE: usize = B::U8 as usize | U::USIZE << 1;

    const I8: i8 = B::U8 as i8 | U::I8 << 1;
    const I16: i16 = B::U8 as i16 | U::I16 << 1;
    const I32: i32 = B::U8 as i32 | U::I32 << 1;
    const I64: i64 = B::U8 as i64 | U::I64 << 1;
    #[cfg(feature = "i128")]
    const I128: i128 = B::U8 as i128 | U::I128 << 1;
    const ISIZE: isize = B::U8 as isize | U::ISIZE << 1;

    #[inline]
    fn to_u8() -> u8 {
        B::to_u8() | U::to_u8() << 1
    }
    #[inline]
    fn to_u16() -> u16 {
        u16::from(B::to_u8()) | U::to_u16() << 1
    }
    #[inline]
    fn to_u32() -> u32 {
        u32::from(B::to_u8()) | U::to_u32() << 1
    }
    #[inline]
    fn to_u64() -> u64 {
        u64::from(B::to_u8()) | U::to_u64() << 1
    }
    #[cfg(feature = "i128")]
    #[inline]
    fn to_u128() -> u128 {
        u128::from(B::to_u8()) | U::to_u128() << 1
    }
    #[inline]
    fn to_usize() -> usize {
        usize::from(B::to_u8()) | U::to_usize() << 1
    }

    #[inline]
    fn to_i8() -> i8 {
        B::to_u8() as i8 | U::to_i8() << 1
    }
    #[inline]
    fn to_i16() -> i16 {
        i16::from(B::to_u8()) | U::to_i16() << 1
    }
    #[inline]
    fn to_i32() -> i32 {
        i32::from(B::to_u8()) | U::to_i32() << 1
    }
    #[inline]
    fn to_i64() -> i64 {
        i64::from(B::to_u8()) | U::to_i64() << 1
    }
    #[cfg(feature = "i128")]
    #[inline]
    fn to_i128() -> i128 {
        i128::from(B::to_u8()) | U::to_i128() << 1
    }
    #[inline]
    fn to_isize() -> isize {
        B::to_u8() as isize | U::to_isize() << 1
    }
}

二、Unsigned Trait 定义

Unsigned 是一个标记 trait（marker trait），用于表示编译时的无符号整数。它要求实现者必须：

  • 实现 Sealed trait（防止外部实现）

  • 实现 Copy 和 Default

  • 具有 'static 生命周期

它定义了一系列关联常量和方法，用于将编译时数字转换为运行时数字：
关联常量：

  • U8, U16, U32, U64, U128, USIZE：对应各种无符号整数类型的值

  • I8, I16, I32, I64, I128, ISIZE：对应各种有符号整数类型的值

方法：

  • to_u8(), to_u16(), …, to_isize()：返回对应类型的值

三、UTerm 的实现

UTerm 表示数字 0，所以所有关联常量和方法都返回 0。

四、UInt<U, B> 的实现

UInt<U, B> 是一个类型级别的数字表示，其中：

  • U 是一个 Unsigned 类型，表示高位部分

  • B 是一个 Bit 类型（可以是 B0 或 B1），表示最低位

这种表示方法实际上是二进制表示。例如：

  • UInt<UTerm, B1> 表示 1

  • UInt<UInt<UTerm, B1>, B0> 表示 10（二进制）即 2（十进制）

实现细节：

对于每个关联常量和方法，计算方式都是：


B::U8 | U::U8 << 1

这相当于：

  1. 将高位部分 U 左移一位（相当于乘以 2）
  2. 加上最低位 B 的值

例如，对于数字 3（二进制 11）：

  • 表示为 UInt<UInt<UTerm, B1>, B1>

  • 计算 U8：B1::U8 | UInt<UTerm, B1>::U8 << 1 = 1 | (1 << 1) = 1 | 2 = 3

五、示例解释

文档中的示例：


use typenum::{Unsigned, U3};

assert_eq!(U3::to_u32(), 3);
assert_eq!(U3::I32, 3);

  • U3 实际上是 UInt<UInt<UTerm, B1>, B1>

  • 当调用 to_u32() 或访问 I32 时，会递归计算得到值 3

六、特点

这种设计允许在编译时进行数值计算，常用于：

  • 数组长度的类型级验证

  • 矩阵维度的类型级检查

  • 其他需要编译时数值计算的场景

七、性能

由于所有计算都在编译时完成，运行时没有任何开销。生成的代码就像直接使用了常量一样高效。

这种类型级别的数字表示是 Rust 泛型编程和类型系统强大能力的典型体现。

八、改进建议

  1. 移除 #[cfg(feature = “i128”)]
    由于 Rust 1.26+ 已经稳定支持 i128/u128，不再需要 feature gate 来控制其可用性，可以移除所有 #[cfg(feature = “i128”)] 条件编译。
  2. 合并 Unsigned 相关定义到 uint.rs
    UInt 结构体（表示非零无符号整数）和 UTerm（表示零）都是用于无符号整数计算，可以将它们的定义、Unsigned trait 及其实现放在同一个文件（如 uint.rs），而不是分散在 marker_traits.rs 和 uint.rs 中。
    其优点：

  • 减少文件跳转，提高可读性

  • 逻辑相关的代码放在一起，便于维护

  • 更符合 Rust 的模块化设计（类型 + trait + 实现放在一起）

  1. 提供 From 转换

允许从 UTerm 和 UInt 转换到基本整数类型，方便使用：


impl From<UTerm> for u8 {
    fn from(_: UTerm) -> u8 { 0 }
}

impl<U: Unsigned, B: Bit> From<UInt<U, B>> for u8 {
    fn from(n: UInt<U, B>) -> u8 {
        B::U8 | U::to_u8() << 1
    }
}

这样用户可以直接：

let x: u8 = U3::into();  // 而不是 U3::to_u8()
  1. 为 Unsigned 增加 ZERO 和 ONE 常量

由于无符号整数一定有 0 和 1，可以在 trait 中定义这两个常量，方便通用代码使用：


pub trait Unsigned: Sealed + Copy + Default + 'static {
    const ZERO: Self;
    const ONE: Self;
    // ...
}

然后分别在 UTerm 和 UInt 中实现：


impl Unsigned for UTerm {
    const ZERO: Self = UTerm;
    const ONE: Self = UInt<UTerm, B1>;  // 需要确保 UInt<UTerm, B1> 是 1
}

impl<U: Unsigned, B: Bit> Unsigned for UInt<U, B> {
    const ZERO: Self = UTerm;  // 可能需要调整，或提供 From<UTerm>
    const ONE: Self = UInt<UTerm, B1>;
}
2、探索 Rust 编程语言：特性、优势与实践
linux的博客
06-07 22
本文全面介绍了 Rust 编程语言的特性、优势及其实践应用。Rust 是一种现代的系统级编程语言，注重安全性、性能和并发编程。文章涵盖了 Rust 的起源背景、核心特性如编译时内存安全、零成本抽象和无畏并发，以及其在操作系统、Web 应用、嵌入式系统等领域的广泛应用。此外，还提供了 Rust 编译器的安装步骤、基础语法示例和综合练习，帮助开发者快速入门并掌握该语言的核心概念。
【rust】wsl2和云主机： ubutnu22.04 尝试编译 rustdesk-server
突围
04-14 881
rust
【typenum】 17 非零标记及改进建议
weixin_43219667的博客
08-17 436
标记 trait：没有方法或关联类型，仅用于类型分类作用：标识该类型代表非零值Sealed：这是一个密封 trait，防止外部类型实现注释说明：除了 B0、U0 和 Z0 外，所有数值类型都实现此 trait。
【typenum】 15 零标记及改进建议
weixin_43219667的博客
08-17 964
这里的 : Sealed 表示这个 trait 是一个密封 trait(sealed trait)，只能由当前 crate 中的类型实现，防止外部类型实现它。代码展示了一个 Rust 设计模式中的"标记 trait"(marker trait)的使用，以及它在三个不同类型中的实现。这种模式在 Rust 的类型系统中很常见，特别是在涉及类型级数字(如 typenum 库)或其他编译时验证的场景中。这个函数只能接受实现了 Zero 的类型(B0、UTerm 或 Z0)，并在编译时保证类型正确性。
【typenum】 4 标记特质（marker_traits.rs）
weixin_43219667的博客
05-12 696
NonZero 和 ZeroNonZero：标记非零类型。除 B0、U0 和 Z0 外，所有数字类型都实现此特质。Zero：标记零类型。只有 B0、U0 和 Z0 实现此特质。用途：用于编译时区分零和非零值（例如在类型级别除法中避免除零错误）。Ord用于类型级别的比较结果（Greater、Equal、Less）。to_ordering() 方法将类型转换为运行时的 Ordering 枚举值（Less、Equal、Greater）。Bit表示类型级别的位（0 或 1）。
C语言--经典100题
倚树探星的博客
11-06 1万+
1、题目：有1、2、3、4四个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？ /* 题目：有1、2、3、4四个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？ */ #include <stdio.h> int main(){ int arr[]={1,2,3,4}; // 创造三位数--三重循环 int n=0,result[256]; for(int i=1;i<5;i++){// i-百位,j-十位,k-个位
【unitrix数间混合计算】2.10 类型级千进制系统的必要性、实现细节与二进制调整
weixin_43219667的博客
08-10 967
领域精准性以类型系统直接编码物理世界的十进制本质，实现零误差的单位运算。工程实践性通过无符号二进制调整，平衡存储效率与计算性能。复用typenum等库的成熟模式，降低开发成本。未来扩展性支持更大基数（如兆进制10⁶）只需扩展位数。可结合Rust的const generics进一步简化类型定义。千进制类型系统通过精准的领域建模和严谨的底层设计，成为连接物理计算需求与计算机二进制世界的理想桥梁。
python基础之数据类型知识(1)
Gold_Master的博客
06-19 776
注释: 注解，解释，说明文字而已。 特征: 注释只是用于说明的文字不会影响内容本身。 作用: 1.用于添加说明文字，方便阅读 2.用于调试程序，排查错误 分类: 单行注释： # 多行注释： '''内容''' 或者 """内容""" 代码: print('hello world') print(123) print("你今年芳龄") 变量:变量就是可以改变的量 python的变量:和数...
【quantity】2 Unit 结构体（unit.rs）
weixin_43219667的博客
04-27 909
这段代码展示了一个强大的类型级物理单位系统实现，利用Rust的类型系统和typenum库在编译期保证物理量运算的正确性。这种设计模式在需要严格类型安全的科学计算、工程应用中非常有用。
Ethereal 使用手册
热门推荐
米菲的泰迪
12-21 1万+
Ethereal 用户手册 18094 for Ethereal 0.10.14 Ulf Lamping   Richard Sharpe NS Computer Software and Services P/L Ed Warnicke   版权所有 © 2004-2005 Ulf Lamping ,
typenum:在Rust中编译时间数字
05-14
当前支持位，无符号整数和有符号整数。 Typenum仅取决于libcore，因此适合在任何平台上使用！ 有关完整的文档，请转到。 输入 虽然typenum分为几个模块，但它们全部通过板条箱根重新导出，因此您可以use typenum:...
编译原理 词法分析程序
11-26
词法分析是编译过程中的一个重要步骤，其主要任务是从源代码中识别出一个个具有独立含义的符号（称为“记号”或“单词”）。这些符号包括关键字、标识符、常量以及操作符等。本篇将详细解析给定的词法分析程序代码，...
Rust库Typenum：编译时数字类型评估工具
该库提供了对位操作、无符号整数和有符号整数的支持，并且不依赖于标准库之外的组件，这意味着它可以在各种平台上使用而不受限制。Typenum通过其核心库libcore实现了类型级别的数字计算，libcore是Rust语言的核心库...
rust语言 (1.88) egui (0.32.1) 学习笔记（逐行注释）（十三）菜单、右键菜单
咸甜适中
08-24 229
EGUI菜单使用摘要 本文介绍了EGUI框架中菜单功能的实现方法，包括主菜单和右键菜单。主要内容： 主菜单结构：使用menu_button创建可嵌套的层级菜单，最终节点为按钮控件 菜单点击事件：通过按钮的clicked()方法处理菜单项点击 菜单复选框：在菜单中使用checkbox控件实现选项选择 右键菜单：使用context_menu为按钮和标签添加右键上下文菜单 当前存在一个问题：点击菜单项后菜单不会自动关闭，需要手动处理。
sfc_os!SfcValidateFileSignature函数分析之WINTRUST!SoftpubLoadMessage
linux-0.11调试教程
08-22 473
sfc_os!SfcValidateFileSignature函数分析之WINTRUST!SoftpubLoadMessage
深入理解 Rust Axum：两种依赖注入模式的实践与对比（二）
分享Java，Rust相关技术
08-23 908
本文探讨了如何在Rust的Axum框架中实现依赖注入。依赖注入是一种将依赖项传递给调用方的设计模式，能够避免重复创建昂贵对象、统一管理服务状态，并提高代码可测试性。作者介绍了Axum框架的特点，并重点讲解了通过State提取器在handlers之间共享状态的方法。文章提供了两种实现方式：基于Arc<dyn Trait>的动态分发和基于泛型的静态分发，并给出了用户管理模块的完整代码示例。这些方法可以帮助开发者构建更高效、可维护的WebSocket服务，类似于Java Spring框架中的单例Bea
flutter_rust_bridge的前世今生
lpfasd123的博客
08-21 505
是解决“Flutter + Rust”协作痛点的优秀工具，其开发背景契合了跨平台开发的实际需求。尽管存在学习门槛等挑战，但凭借技术优势和社区支持，它在高性能跨平台应用开发中的前景值得期待，尤其适合对性能、安全性有高要求的团队采用。
Rust Async 异步编程（五）：async/.await
ProgramNovice的博客
08-25 897
Rust Async 异步编程（五）：async/.await
rust语言 (1.88) egui (0.32.1) 学习笔记（逐行注释）（十九）子窗口
最新发布
咸甜适中
08-25 37
文章摘要 本文介绍了在Rust中使用egui库创建子窗口的方法show_viewport_immediate。主要内容包括： ViewportBuilder的常用配置方法：设置标题、默认大小、最小/最大值 主窗口创建示例，包含自定义窗口尺寸和字体设置 子窗口的两种控制方式：通过toggle_value或按钮点击切换显示 子窗口创建实现，包括唯一标识设置、标题配置和关闭请求处理 代码示例展示了如何创建带有主窗口和可切换子窗口的应用程序框架，支持中文显示和窗口大小控制。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

liuyuan77

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

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

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

打赏作者

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

抵扣说明：

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

余额充值