Rust 类型系统进阶:关联类型、GAT 和 trait 约束的组合玩法

Qdrant 深度拆解:35K Star 的 Rust 向量数据库,是如何把 HNSW、Payload 过滤和量化压缩揉成一台机器 Qdrant 是基于 Rust 构建的向量数据库,以高效协同稠密向量(HNSW)、Payload 过滤与量化索引著称。其核心优势在于三者在查询中同步生效,兼顾召回率与性能。适用于 RAG、语义搜索、推荐系统及多租户场景,但不擅长事务或精确检索。架构分层清晰,写入经 WAL 保障一致性,检索通过分片与段并行加速。关键技术包括过滤感知 HNSW、ACORN 跨跳搜索、八类 Payload 索引、四档量化(如 TurboQuant、Product)及灵活多租户策略。最新版本 v1.20.1 强化了嵌套索引与重打分 阅读详情

Rust 类型系统进阶:关联类型、GAT 和 trait 约束的组合玩法


一、从"能用 trait"到"能设计 trait"

初学 Rust 的时候,trait 对我来说就是"Rust 的 interface"。定义一个行为,让不同 struct 实现它,完事。典型的用法大概长这样:

// 初学者眼中的 trait:就是 interface
trait Speaker {
    fn speak(&self) -> String;
}

struct Dog;
impl Speaker for Dog {
    fn speak(&self) -> String { "汪汪".to_string() }
}

struct Cat;
impl Speaker for Cat {
    fn speak(&self) -> String { "喵喵".to_string() }
}

够用。但当我开始设计 AI CLI 的插件系统时,问题来了:

一个数据源的 connect 方法返回的"连接"类型,对于 MySQL 是 MySqlConnection,对于 Redis 是 RedisConnection,对于 HTTP API 是 HttpClient。它们在 trait 定义时还没法确定具体类型,怎么搞?

这就是关联类型(Associated Types)的用武之地。而关联类型的进阶版本 GAT(Generic Associated Types)加上 trait 约束的组合,更是打开了类型系统的高级玩法。

这篇文章假设你已经知道基本的 trait 用法,我把重点放在"什么时候用关联类型而不是泛型参数"和"GAT 能解决什么泛型解决不了的问题"。


二、类型武器库全景

在定义 Trait 行为契约时,选择何种类型机制取决于返回类型在定义时是否确定。若能确定,直接使用具体类型即可。若不能确定,但每个实现(impl)只需对应一种类型,则应选用关联类型(Associated Type);若不能确定且需要泛型化支持,则考虑泛型参数。

对于关联类型,若其本身需要泛型参数,则升级为泛型关联类型(GAT);否则使用普通关联类型(type Item = ...)。对于泛型参数,若需要被 trait 约束,则添加约束条件(如 T: Display + Clone);否则使用无约束泛型。GAT 进一步细分为生命周期参数或类型参数两种形式,分别对应 type Ref<'a> where Self: 'a 和 type Output<T> where T: Clone。


三、关联类型:每个 impl 一个确定类型

什么时候用关联类型而不是泛型参数

核心区分:泛型参数让你的 trait 可以多次实现(一个 Parser<Json> 和一个 Parser<Xml>),关联类型让每个类型只能有一种实现方式(一个 Iterator 只有一个 Item 类型)。

/// 关联类型的典型用例:迭代器

/// 每个集合类型产生的迭代器 Item 类型是确定的
/// Vec 的 Item 永远是 i32,不会变成别的
pub trait MyIterator {
// 关联类型:每个实现者指定自己的 Item 类型
type Item;

fn next(&mut self) -> Option<Self::Item>;

}

/// 数据源 trait:连接类型和查询结果类型都是关联的
pub trait DataSource {
/// 连接对象类型 —— 每个数据库有自己独特的连接类型
type Connection;
/// 查询结果类型
type Row;
/// 错误类型
type Error: std::error::Error;

/// 建立连接,返回关联的连接类型
fn connect(&self, url: &str) -> Result<Self::Connection, Self::Error>;

/// 执行查询
fn query(
    &self,
    conn: &Self::Connection,
    sql: &str,
) -> Result<Vec<Self::Row>, Self::Error>;

}

// MySQL 数据源实现
struct MySqlSource;
impl DataSource for MySqlSource {
// MySQL 有自己特定的连接和行类型
type Connection = MySqlConnection;
type Row = MySqlRow;
type Error = MySqlError;

fn connect(&self, url: &str) -> Result<Self::Connection, Self::Error> {
    MySqlConnection::new(url)
}

fn query(
    &self,
    conn: &Self::Connection,
    sql: &str,
) -> Result<Vec<Self::Row>, Self::Error> {
    conn.execute(sql)
}

}

// 对比:如果不用关联类型而用泛型参数
// trait DataSource<Conn, Row, Err> —— 调用方每次都要写这三个参数
// fn process<D: DataSource<MySqlConnection, MySqlRow, MySqlError>>(ds: &D)
// 泛型签名会越来越长,而且一个类型可能被多次实现(语义上不必要)


### 关联类型的默认值

关联类型还可以有默认实现,类似 trait 的默认方法:

```rust
/// 带默认关联类型的 trait
pub trait Cache {
    /// 存储的键类型——默认是 String
    type Key = String;
    /// 存储的值类型——默认是 Vec<u8>
    type Value = Vec<u8>;

    fn get(&self, key: &Self::Key) -> Option<&Self::Value>;
    fn set(&mut self, key: Self::Key, value: Self::Value);
    fn delete(&mut self, key: &Self::Key) -> bool;
}

// 使用默认关联类型——无需指定 Key 和 Value
struct SimpleCache {
    data: std::collections::HashMap<String, Vec<u8>>,
}
impl Cache for SimpleCache {
    // Key 和 Value 使用默认值,不需要显式声明
    fn get(&self, key: &String) -> Option<&Vec<u8>> {
        self.data.get(key)
    }
    fn set(&mut self, key: String, value: Vec<u8>) {
        self.data.insert(key, value);
    }
    fn delete(&mut self, key: &String) -> bool {
        self.data.remove(key).is_some()
    }
}

生产实战经验:关联类型和 dyn Trait 不兼容

我在一个项目里设计了一个 Serializer trait,有一个关联类型 Output。然后我想用 Box<dyn Serializer> 来存储不同类型的序列化器,编译器直接报错:the value of the associated type must be specified。关联类型让 trait 本身变成了"不完整"的类型,不能作为 dyn Trait 使用。

// ❌ 有关联类型的 trait 不能用作 dyn Trait
trait Serializer {
    type Output;
    fn serialize(&self, data: &[u8]) -> Self::Output;
}
// let s: Box<dyn Serializer> = ...;  // 编译错误!

解决办法有两种:把关联类型改成泛型参数,让 trait 可以被动态分发:

// ✅ 用泛型参数代替关联类型
trait Serializer<Output> {
    fn serialize(&self, data: &[u8]) -> Output;
}
let s: Box<dyn Serializer<Vec<u8>>> = ...;  // OK

决策点是:如果 trait 需要动态分发(Box<dyn Trait>),用泛型参数;如果不需要,关联类型更优雅,因为它约束了每个实现者只能有一种 Output 类型,防止了逻辑错误。


---

## 四、GAT:让关联类型本身泛型化

### GAT 解决什么问题

普通关联类型的问题是:它不能有泛型参数。来看一个真实场景:

```rust
// 我想设计一个"图"的 trait
// 每个图实现都可以有自己的节点和边类型
// 但问题来了:我可能想用不同的方式来遍历图
// 比如:深度优先遍历器、广度优先遍历器
// 普通关联类型只能有一个 Walker

// 传统方式:用泛型 trait 参数
pub trait Graph<W> {
    fn walk(&self) -> W;
}
// 问题:同一个图不能用不同的 W 实现两次!

// GAT 的方式:
pub trait Graph {
    type Node;
    type Edge;
    // GAT:关联类型本身接受生命周期参数
    // 不同生命周期的借用会有不同的遍历器类型
    type Walker<'a>: Iterator<Item = &'a Self::Node>
    where
        Self: 'a;

    fn walk(&self) -> Self::Walker<'_>;
}

实战:用 GAT 设计 AI 模型抽象

/// AI 模型 trait —— 每个模型有不同的输入/输出类型
pub trait AiModel {
    /// 输入类型(文本、图像、音频等)
    type Input;
    /// 输出类型
    type Output;
    /// 配置类型
    type Config;

    // GAT:推理时的中间状态
    // 不同模型有不同的内部状态表示
    type HiddenState<'a>: std::fmt::Debug
    where
        Self: 'a;

    /// 加载模型配置
    fn load(config: Self::Config) -> Self;
    
    /// 前向传播 —— 返回中间状态
    fn forward(&self, input: &Self::Input) -> Self::HiddenState<'_>;
    
    /// 后处理 —— 将隐层状态转为最终输出
    fn decode(&self, hidden: &Self::HiddenState<'_>) -> Self::Output;
}

/// 语言模型实现
struct LlmModel {
    weights: Vec<f32>,
    config: LlmConfig,
}

#[derive(Debug)]
struct LlmHiddenState<'a> {
    /// 注意力层的缓存,持有对模型权重的借用
    attention_cache: &'a [f32],
    /// 当前生成的 logits
    logits: Vec<f32>,
}

impl AiModel for LlmModel {
    type Input = Vec<u32>;      // token IDs
    type Output = String;       // 生成的文本
    type Config = LlmConfig;

    // GAT:HiddenState 借用了 self 的数据(lifecycle 'a 保证安全)
    type HiddenState<'a> = LlmHiddenState<'a>
    where
        Self: 'a;

    fn load(config: Self::Config) -> Self {
        Self {
            weights: vec![0.0; config.hidden_size * config.vocab_size],
            config,
        }
    }

    fn forward(&self, input: &Self::Input) -> Self::HiddenState<'_> {
        let mut logits = vec![0.0f32; self.config.vocab_size];
        
        // 简化的前向传播:矩阵乘法
        for &token_id in input {
            let offset = token_id as usize * self.config.hidden_size;
            for i in 0..self.config.hidden_size {
                logits[i] += self.weights[offset + i];
            }
        }

        LlmHiddenState {
            attention_cache: &self.weights,  // 安全借用
            logits,
        }
    }

    fn decode(&self, hidden: &Self::HiddenState<'_>) -> Self::Output {
        // 取 logits 最大的 token
        let max_idx = hidden.logits.iter()
            .enumerate()
            .max_by(|(_, a), (_, b)| a.partial_cmp(b).unwrap())
            .map(|(idx, _)| idx)
            .unwrap_or(0);
        
        format!("token_{}", max_idx)
    }
}

多层 trait 约束组合

use std::fmt::Display;
use std::hash::Hash;
use std::ops::Add;

/// 复杂 trait 约束的组合示例
/// 定义一个可以被索引、比较和显示的集合类型
pub trait IndexedCollection {
    type Item: Display + Clone + PartialEq;
    type Index: Copy + Eq + Hash;

    /// 对集合做聚合操作
    /// 这里的组合约束:Item 必须能 Add 且结果也是 Item 类型
    fn aggregate<F>(&self, init: Self::Item, f: F) -> Self::Item
    where
        F: Fn(Self::Item, &Self::Item) -> Self::Item,
        Self::Item: Add<Output = Self::Item>;  // Item 必须支持加法

    fn get(&self, idx: Self::Index) -> Option<&Self::Item>;
}

// 组合使用多个 trait
pub trait Processable: IndexedCollection + Send + Sync
where
    // where 子句对关联类型施加额外约束
    <Self as IndexedCollection>::Item: Send + Sync,
{
    fn process_all(&self) -> Vec<String> {
        // 可以使用 IndexedCollection 的方法
        // 以及 Item: Display 的约束
        todo!()
    }
}

生产实战经验:GAT 的编译时间开销

GAT 让编译器的类型检查器需要做更多工作,编译时间会明显增加。我在一个项目里用 GAT 设计了一个 Storage trait,编译时间从 15 秒增加到了 45 秒。后来发现是因为 GAT 的 where 子句太复杂,编译器需要做大量的生命周期推断。简化 where 子句(把复杂约束挪到 trait 级 where 而不是 GAT 级 where)能把编译时间降到 25 秒左右,但依然比不用 GAT 慢。

如果你不是真的需要 GAT,别用。90% 的场景用普通关联类型就够了。

另一个坑是 GAT 和 async fn 的配合。在 Rust 1.75 之前,如果你想在 trait 里定义 async 函数并且让返回的 Future 借用 self,你需要用 GAT。但 Rust 1.75+ 已经支持 async fn in trait,不需要 GAT 了:

// Rust 1.75+:直接用 async fn in trait,不需要 GAT
pub trait AsyncModel {
    async fn forward(&self, input: &[u32]) -> Vec<f32>;
}

// 之前(Rust 1.74 及以下)需要 GAT
pub trait AsyncModelOld {
    type Future<'a>: Future<Output = Vec<f32>> + 'a where Self: 'a;
    fn forward<'a>(&'a self, input: &'a [u32]) -> Self::Future<'a>;
}

所以如果你用 Rust 1.75+,需要 GAT 的场景少了很多。只在真正需要"关联类型本身接受泛型参数"时才用 GAT。


五、总结

Rust 的类型系统有一个很微妙的特点:它不是底层概念很难,而是概念之间的关系很难。关联类型、GAT、trait 约束,单独拎出来都不难理解,但组合在一起使用时,限制和可能性同时增加。

三个实战建议:

  1. 能用关联类型就不要用泛型参数:关联类型让 trait 只能被实现一次,这是约束,但也是安全网。它防止了意外的多次实现导致的类型混乱。

  2. GAT 不是日常技能,是"紧急出口":90% 的场景用普通关联类型就够了。GAT 是当发现"这里真的需要一个泛型的关联类型"时才动用的最后手段。实际项目中,真正用到 GAT 的地方通常不超过 5 处。

  3. trait 约束写在 where 子句里,别堆在尖括号里:可读性差一个数量级。把复杂的约束挪到 where 子句,代码立刻清爽。

类型系统是 Rust 最强大的武器,也是让最多人放弃的障碍。但一旦跨过"被 borrow checker 追着跑"的阶段,进入"主动用类型系统表达业务约束"的阶段,写出的代码不再需要那么多运行时检查和单元测试——因为编译器已经帮忙做了。

落地建议:日常开发中,先确认当前 Rust 版本是否已支持 async fn in trait(1.75+)——这个特性消除了大量 GAT 的使用场景。设计 trait 时,默认用关联类型而非泛型参数,除非明确需要同一类型多次实现同一个 trait。如果编译时间已经较长,优先检查是否有不必要的 GAT 嵌套,把复杂约束从 GAT 级别提到 trait 级别可以减少编译器推断开销。

实战派指南:反激电源EMI滤波器设计,从理论计算到PCB布局避坑 本文详细解析了反激式开关电源EMI滤波器设计的全流程,从理论计算到PCB布局避坑,结合34W PD快充电源案例,系统介绍了共模与差模干扰的识别、关键元件选型、参数计算优化及PCB布局技巧,帮助工程师有效解决传导测试超标等常见问题。 阅读详情

相关推荐

向NCBI上传16S rDNA数据的操作详解

专门介绍向NCBI上传16S rDNA数据的方法不太多。因为自己有上传数据的需要,所以决定边摸索边写下操作流程。如果这篇博文交代了上传步骤以及一些描述文件属性的书写,帮到你的话,还请点赞收藏。

yue81560的博客 2万+

RustMark v0.4:内核可扩展性 — Rust Trait 系统与标准库 Trait 深度实战

核心痛点:Rust 没有类继承,如何实现代码复用与多态?Trait 系统提供了一套比传统 OOP 更强大、更安全的多态范式,但初学者常被关联类型、Trait Bound、impl Trait 等概念困住,更难以理解何时该用 Box、何时该用泛型。前置知识:需掌握 Rust 基础语法、所有权与借用(本系列第一篇)、枚举与模式匹配(第二篇)、泛型与集合(第三篇)。系列阶段:入门篇 第 5 篇(共 5 篇),RustMark 版本号 v0.4。收获能力。

我的博客 313

串行通信原理及实验仿真

1. 处理器与外部设备通信的两种方式: 并行通信和串行通信 并行通信是指数据的各个位用多条数据线同时进行传输 优点:传输速度快 缺点:占用引脚资源多 串行通信是将数据分成一位一位的形式在一条传输线上逐个传输 优点:通信线路简单,占用引脚资源少 缺点:传输速度慢 2. 串行通信的通信方式: 同步通信和异步通信 同步通信:带有时钟同步信号的数据传输;发送方和接收方在同一时钟的控制下,同步传输数据。 异步通信:不同时钟同步信号的数据传输。发送方和接收方使用各自的时钟控制数据的发送和接收过程。 3. 串行通

gemengxia的博客 4323

Rust生命周期与泛型的组合使用深度解析

生命周期与泛型的组合使用需要深厚的类型系统理解。关键原则包括:明确区分所有权和借用、优先使用生命周期省略、合理应用HRTB、控制泛型复杂度、利用类型擦除优化编译。Rust的学习曲线陡峭,但一旦掌握,你将拥有无与伦比的表达能力和性能保证。深入理解这些机制不仅让我们写出安全高效的代码,更培养了对内存模型和类型系统的深刻洞察,这是任何现代系统程序员的必备素养。

qq_74319491的博客 1110

MacOS下Mixly 2.0安装避坑指南:从Java环境到终端权限全解析

本文详细解析了在MacOS系统上安装Mixly 2.0时可能遇到的核心问题与解决方案。针对Java环境版本不兼容、MacOS Gatekeeper安全机制拦截以及终端权限不足三大常见障碍,提供了从检查并配置正确Java版本、安全设置绕过到彻底解决应用内部工具链权限的完整避坑指南,帮助用户顺利完成安装并正常使用。

weixin_29231725的博客 504

LIGGGHTS颗粒模拟入门:从DEM原理到工程实践

离散元法(DEM)是一种用于模拟颗粒物质行为的数值方法,其核心原理是通过计算每个颗粒的运动和相互作用来预测颗粒系统的宏观行为。该方法基于牛顿第二定律和接触力学模型,能够精确描述颗粒间的碰撞、摩擦和粘结等微观机制。在工程实践中,DEM技术为优化工业设备设计、预测材料流动和减少实验成本提供了重要价值。它广泛应用于制药造粒、矿石破碎、粉体输送和农业加工等领域,帮助工程师和研究人员深入理解颗粒系统的复杂动力学。LIGGGHTS作为一款基于LAMMPS的开源DEM软件,继承了其高效的并行计算架构,并针对颗粒模拟进行了

weixin_33979203的博客 420

零成本多态的边界:Rust Trait × 泛型 × 分发策略实战

围绕“抽象不牺牲性能”的目标,系统梳理 Rust 中三种常见分发路径:泛型单态化(静态分发)、`Box/Arc<dyn Trait>`(动态分发)与“枚举分发”。结合对象安全的判定规则与约束写法,解释为什么有些 API 无法被对象化,以及如何通过拆分接口、GAT、HRTB 等手段化解。针对“特化”这一热门话题,给出当前可用的稳定替代方案与工程落地模板,并用基准与火焰图对比不同分发策略的真实开销,帮助在插件系统、序列化后端、HTTP 中间件等场景做出可验证的选型。

努力分享一些人工智能、计算机视觉、影像等相关的知识干货! 1264

华为AR3260路由器NAT回流配置实战:从WEB界面到命令行的完整避坑指南

本文详细解析了华为AR3260路由器NAT回流(Hairpin NAT)的配置原理与实战方法。针对内网用户无法通过公网地址访问内部服务器的常见问题,文章不仅剖析了WEB界面配置的常见报错原因,更提供了清晰、可靠且一劳永逸的命令行(CLI)配置方案与排错指南,帮助企业网络工程师彻底解决内外网访问不一致的难题。

u6v7w8x的博客 874

泛型参数的使用

Rust泛型系统通过单态化实现零成本抽象,在编译期为每个类型生成专用代码,确保高性能但可能引发代码膨胀问题。生命周期参数独特地将借用关系编码到类型系统中,保障内存安全。Trait约束增强了类型安全性和错误提示,关联类型则优化了API设计。虽然原生不支持高阶类型,但通过GAT可模拟相关功能,提升抽象表达能力。const泛型支持编译期计算,实现更丰富的不变量检查。Rust泛型系统通过精确的类型控制,在系统编程中实现了性能与安全的完美平衡。

OIMIOQ的博客 649

【StreamSet】ETL之StreamSet之Pipelines的状态监听之WebHook钉钉篇

介绍下StreamSets的状态监听以及钉钉的webhook的互联,这位博友问的恰是时候,不久前我刚刚对接过钉钉的机器人,这次看到这个问题,对我来说,应该轻车熟路了,那就有了这篇博文,状态监听之钉钉篇。...

m0_54252387的博客 488

构建.NET网站:VSCode还是Visual Studio?揭开开发工具的选择之谜

选择VSCode还是Visual Studio,归根结底是取决于你的具体需求和偏好。🔍 这两款工具各有千秋,都能为你的.NET网站开发提供强大的支持。希望这篇文章能够帮助你更全面地了解这两款工具,做出明智的选择。

墨夶的博客 790

高阶 Trait 边界中的生命周期:原理、范式与深度实践

当我们谈 Rust 的“高阶 trait 边界”(Higher-Ranked Trait Bounds, HRTB)时,核心是这种。它让我们把“对任意借用都有效”的语义编码进类型系统,从而在抽象层面表达更强的可复用性与更安全的别名控制。本文从原理到实践深入拆解 HRTB 与生命周期的交互边界,展示它如何解决常见的抽象难题,并给出工程落地建议。💡。

2501_94030986的博客 826

从零到精通:BLDC电机驱动电路详解与设计思路

这套电机驱动电路从核心控制器到反馈采集模块,涉及了BLDC电机驱动的方方面面。每一个模块的设计和选择都需要综合考虑系统需求和实际使用环境。在实际应用中,很多细微的设计改进都会显著影响电机的运行性能。

weixin_43199439的博客 3109

RustMark v0.3:文件IO与集合 — Rust泛型、迭代器与集合选型深度实战

本文深入探讨了RustMark v0.3版本中泛型、迭代器与集合类型的实战应用。文章从泛型的单态化原理讲起,对比了命令式循环与迭代器的性能差异,分析了不同集合类型(Vec/HashMap/BTreeMap/VecDeque)的选型逻辑。重点展示了RustMark内核如何通过泛型缓冲区、文件IO栈和文本统计引擎实现文档处理能力,包括递归文件扫描、惰性求值和零分配优化等技术。最终构建的RustMark v0.3具备完整的文件加载、处理与统计分析功能,为后续版本奠定了数据处理基础。文章强调Rust的零成本抽象特性

我的博客 409

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

组网第63课:安全域划分——Trust/Untrust/DMZ、区域模型、与 VLAN 的关系

一组接口 + 一组策略 + 一条默认拒绝。一组接口:这个域包含哪些物理口、VLAN、子接口;一组策略:这个域到别的域放行什么、拒绝什么;一条默认拒绝:没写进策略的,一律不通。第三条最关键。没有默认拒绝,前面划的域全是装饰。

qq_36765170的博客 571

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

rust: Fan-out/Fan-in Pattern

本项目基于Rust实现珠宝行业全流程的扇出/扇入模式,采用DDD六层架构。通过ProcessRequestDto与ProcessResponseDto传输数据,将采购、设计、生产等12个业务阶段抽象为可并行执行的FanoutTask子任务。核心由JewelryFanoutFanin实现并行调度:先扇出至12个线程并发执行,再统一扇入汇总结果。系统集成日志(文件+控制台)、重试熔断、内存仓储及依赖注入容器,支持顺序与并发两种调度方式,确保高并发下任务可靠执行与可观测性。

Geovin Du Dream Park 162

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

Rust组织管理(AI回答)

你想做的事JS / Python 做法Rust 做法把一个文件纳入工程新建文件即可新建 xxx.rs 后,必须在入口写mod xxx;挂载对外暴露函数/结构体export(Python 默认全公开)默认全私有,必须显式加pub引入别处的函数use crate::模块名::函数名;找路径的基准词./ 或 ../(从 src 根出发)、(上一级 ../)、(当前级 ./)日常写项目:不要用 #[path],直接遵守默认规则——

yaoct的博客 153

自建 RustDesk 服务端后,做一个“装完就能连“的客户端

目前市面上的远程工具(如向日葵、toDesk等)免费版基本上都卡的不行,而且收费版好像也会卡。如果有云服务的话,可以基于 RustDesk 的 hbbs / hbbr 自己部署一套,不过会碰到一个问题:每台电脑装完客户端,都得手动去设置里填三样东西——ID 服务器、中继服务器、Key。填错一个就连不上,还得远程指导同事操作。这篇记录两种解决办法,以及云端编译的完整流程。内容基于 RustDesk 1.5.3 的源码。

风声的专栏 626

Rust LeetCode443 算法题解

LeetCode 443 字符串压缩:原地行程编码,用 start 标记组起点、next 扫描组边界、i 原地写出;长度 1 不写计数使编码不膨胀,写指针不越过读指针。时间 O(n),额外空间 O(1)。

weixin_43379230的博客 121

GitHub 热榜项目:日榜(2026-11-10)

本期共 11 个热门开源项目,合计新增 13,136 stars。榜单前三分别是 Anthropic 的 Agent Skills 仓库、Meta 开源的 React 设计系统 Astryx(+3,278)和用户名检索工具 sherlock(+4,267,本期涨星最多)。其余项目覆盖 DeepMind 的物理引擎 MuJoCo、Claude 官方示例集、自托管智能体记忆系统 GBrain、用 Rust 写的浏览器自动化 CLI、基于 WiFi 信号的人体感知平台 RuView、多市场股票分析工具,以及 Ho

u130130的博客 443

GitHub 今日推荐|HGhubX:Tauri 2 跨平台短剧客户端实战

Tauri 2 + Rust + React 构建的跨平台短剧观看客户端,实现 HLS 代理、AES 封面解密、多线路探测与会话隔离,覆盖桌面与移动全平台。

wfly blog 395

Rust 日志追踪实战:工业边缘场景下的 tracing

Rust 生态下:相比println!log,它提供结构化字段、span 上下文、异步友好和 OpenTelemetry 集成。本文从工程实战角度梳理 tracing 的用法与常见的坑。

ZenovaEdgeOS的博客 559

ARTCRAFT系列软件简单试用手记1

AI辅助开发推动开源重构热潮,ARTCRAFT系列以Rust重写经典软件,性能媲美C/C++。其Launcher支持多平台、多架构,可快速部署开源版Excel(GridCraft)与Word(WordCraft),启动速度远超Office 2016。界面类Office 2016,但暂不完善汉字字号与红头嵌套编辑。项目持续更新,主打“CraftAnything”理念——理解软件原理,自创版本,未来可期。

olegja3d的博客 211

Rust如何实现微服务网关的高并发与限流熔断机制

在现代互联网系统中,微服务架构已成为主流,而微服务网关则是整个系统的重要组成部分。当面对高并发、高可用性需求时,很多开发者对如何用 Rust 实现一个稳定可靠的网关存在疑惑,尤其是处理请求的幂等性、限流和熔断机制。本文将以 Rust 的实际案例为基础,结合生产环境中的具体经验,讲解如何设计和实现一个具备限流与熔断能力的微服务网关。

wuchangjian的专栏 115

第 1 讲:内存布局与所有权解剖——栈帧、胖指针与“移动/拷贝”在汇编层面的真实面目

看图最下面的(或者数组切片&[T]它在栈上占16 个字节,由(ptr, len)两个机器字组成。这就是系统编程里常说的胖指针(普通指针只有 8 字节地址,它胖了一倍,多带了一个 8 字节的长度或虚表指针)。痛点追问:C 语言里表示字符串切片只要一个 8 字节的char*,为什么 Rust 非要浪费双倍的栈空间搞成 16 字节?如果少掉len这一环会出什么乱子?回想一下 C 语言是怎么知道一个字符串在哪结束的:靠在内存末尾塞一个字节的\0求长度是 $O(N)$ 的苦力活:在 C 里调strlen(p)

yaoct的博客 168

Rust LeetCode334 算法题解

本文分析了 LeetCode 334 题“递增的三元子序列”的两种解法。暴力法(三重循环)时间复杂度为 O(n³),仅适用于小数据;最优解采用一次扫描贪心策略,维护 first(最小值)和 second(递增对第二元素的最小值),通过三个分支判断:若当前数大于 second,则存在三元递增子序列;否则更新 first 或 second。算法正确性基于不变式:first 始终为已遍历最小值,second 为可形成递增对的最小尾部。时间复杂度 O(n),空间复杂度 O(1),适用于大规模数据。

weixin_43379230的博客 342
上一篇: AI 时代的学习策略:用模型做知识索引,用实践做深度内化
下一篇: AI Agent 开发的最佳实践清单:20 条经验避免新人踩坑
第一程序员
博客等级 码龄1年 1万+粉丝 1822原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值