如何在Rust中用动态分发实现无状态不可变单例？

需要实现一批实现同一trait的无状态不可变单例，通过虚方法做动态分发，类似Scala中的sealed trait+单例对象模式，避免大量match分支。

Scala参考实现 #

sealed trait Kind {
  def name(): String
}

object A extends Kind {
  def name() = "A"
}

object B extends Kind {
  def name() = "B"
}

def use(x: Kind) = {
  println(s"Kind is ${x.name()}")
}

def main() = {
  use(A)
}

注：上述Scala示例仅分配2个对象，传递的是A的引用（简单指针）。

尝试的Rust代码（效果不佳） #

trait Kind {
  fn name(&self) -> String;
}

struct A;
struct B;

impl Kind for A {
  fn name(&self) -> String { String::from("A") }
}

impl Kind for B {
  fn name(&self) -> String { String::from("B") }
}

// 编译不通过，无法创建全局Box<dyn Kind>常量
//const A: Box<dyn Kind> = Box::new(A{});

fn use(x: Box<dyn Kind>) {
  println!("Kind is {}", x.name());
}

fn main() {
  use(Box::new(A{}));
}

补充说明 #

• 曾担忧每次调用use创建新Box会带来开销（后续更新：了解到Box是胖指针，可在寄存器传递，该担忧不成立）
• 尝试lazy_static!时遇到类型匹配问题：

lazy_static! {
    static ref WIN: Box<dyn Named + Send + Sync> = Box::new(platform::Win{});
}

fn main() {
  foo(WIN); // 编译失败：类型不匹配
  foo(&WIN); // 编译通过，但不确定是否避免了重复创建Box
}

• 明确需求：单例不可变、无状态，用动态分发避免庞大match分支，询问思路是否正确及更好替代方案

思路确认：你的方向是正确的 #

动态分发（dyn Trait）确实是Rust中避免大量match分支、实现类似Scala模式的合理选择，尤其当类型数量多且需要处理编译时未知类型时。

优化实现方案 #

1. 编译期常量单例+引用传递（最优无分配方案）

利用无状态结构体可作为编译期常量的特性，直接传递引用，完全避免运行时分配：

trait Kind {
    // 返回&'static str替代String，避免不必要的内存分配
    fn name(&self) -> &'static str;
}

// 无状态结构体可派生Copy/Clone，方便复用
#[derive(Debug, Clone, Copy)]
struct A;
#[derive(Debug, Clone, Copy)]
struct B;

impl Kind for A {
    fn name(&self) -> &'static str { "A" }
}

impl Kind for B {
    fn name(&self) -> &'static str { "B" }
}

// 定义全局编译期常量单例
const INSTANCE_A: A = A;
const INSTANCE_B: B = B;

// 接收&dyn Kind作为参数，直接传递单例引用
fn use_kind(x: &dyn Kind) {
    println!("Kind is {}", x.name());
}

fn main() {
    use_kind(&INSTANCE_A);
    use_kind(&INSTANCE_B);
}

说明：这里的单例是编译期初始化，传递的引用就是简单指针，和Scala的行为完全一致，无任何运行时开销。

2. 运行时初始化单例（用lazy_static）

如果单例需要运行时初始化（比如依赖环境变量、动态资源），可以用lazy_static!封装&dyn Trait：

use lazy_static::lazy_static;

trait Kind {
    fn name(&self) -> &'static str;
}

struct A;
struct B;

impl Kind for A {
    fn name(&self) -> &'static str { "A" }
}

impl Kind for B {
    fn name(&self) -> &'static str { "B" }
}

lazy_static! {
    // 直接存储&'static dyn Kind，避免Box的额外开销
    pub static ref INSTANCE_A: &'static dyn Kind = &A;
    pub static ref INSTANCE_B: &'static dyn Kind = &B;
}

fn use_kind(x: &dyn Kind) {
    println!("Kind is {}", x.name());
}

fn main() {
    use_kind(INSTANCE_A);
    use_kind(INSTANCE_B);
}

说明：lazy_static!会在第一次访问时初始化单例，之后复用同一个引用，完全避免重复分配。

3. 替代方案：枚举封装+静态分发

如果所有类型编译时已知且数量有限，可以用枚举封装，为枚举实现trait，既保留可区分联合特性，又能避免动态分发开销：

trait Kind {
    fn name(&self) -> &'static str;
}

enum KindEnum {
    A,
    B,
}

impl Kind for KindEnum {
    fn name(&self) -> &'static str {
        match self {
            KindEnum::A => "A",
            KindEnum::B => "B",
        }
    }
}

// 用impl Kind做静态分发，性能略高于动态分发
fn use_kind(x: impl Kind) {
    println!("Kind is {}", x.name());
}

fn main() {
    use_kind(KindEnum::A);
    use_kind(KindEnum::B);
}

说明：这种方式适合类型数量不多的场景，若类型过多，match分支会变得冗长。

关键注意点 #

• 无状态单例优先用const/static定义，避免运行时分配
• 传递&dyn Trait而非Box<dyn Trait>，减少内存管理开销
• 返回固定字符串时用&'static str替代String，避免重复内存分配

内容的提问来源于stack exchange，提问作者Marcin Wisnicki