Rust中是否存在ChildArc/映射Arc？Arc<Self> trait枚举实现问题

一、类似ChildArc的子Arc机制实现 #

Rust标准库目前没有提供Arc::map这类直接从父Arc生成指向内部字段的子Arc的API，但可以通过以下两种方式实现需求：

1. 手动unsafe封装（无第三方依赖） #

通过自定义结构体持有父Arc和内部字段的裸指针，确保子结构体存活时父Arc不会被释放，从而保证内部引用的合法性。这种实现是安全的，因为父Arc的生命周期完全由子结构体管控：

use std::sync::Arc;
use std::ops::Deref;

struct A {}
struct Base {
    a: A,
}

// 自定义子Arc类型，持有父Arc和内部字段的指针
struct ArcA {
    parent: Arc<Base>,
    ptr: *const A,
}

impl ArcA {
    fn new(parent: Arc<Base>) -> Self {
        let ptr = &parent.a as *const A;
        ArcA { parent, ptr }
    }
}

// 实现Deref，让ArcA可以像Arc<A>一样被解引用
impl Deref for ArcA {
    type Target = A;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.ptr }
    }
}

// 实现Clone，复用父Arc的引用计数
impl Clone for ArcA {
    fn clone(&self) -> Self {
        ArcA {
            parent: self.parent.clone(),
            ptr: self.ptr,
        }
    }
}

// 使用示例
fn get_a(b: Arc<Base>) -> ArcA {
    ArcA::new(b)
}

fn method_that_needs_a(a: ArcA) {
    // 直接解引用使用内部的A实例
    let _a_ref: &A = &*a;
}

fn main() {
    let b = Arc::new(Base { a: A {} });
    let a = get_a(b);
    method_that_needs_a(a);
}

2. 使用第三方库 #

可以直接使用社区维护的child-arc crate，它封装了上述逻辑，无需手动写unsafe代码：

use child_arc::ChildArc;
use std::sync::Arc;

struct A {}
struct Base {
    a: A,
}

fn get_a(b: Arc<Base>) -> ChildArc<A> {
    ChildArc::new(b, |base| &base.a)
}

fn method_that_needs_a(a: ChildArc<A>) {
    // ChildArc实现了Deref，可以直接当作&A使用
    let _a_ref: &A = &*a;
}

二、接收Arc的Trait的枚举兼容方案 #

针对你定义的trait T和枚举AnyT的问题，核心矛盾是枚举存储的子类型实例无法直接满足test方法对Arc<Self>的参数要求，以下是三种可行解决方案：

1. 枚举存储Arc包裹的子类型 #

直接让枚举变体存储Arc<Impl1OfT>这类已被Arc包裹的实例，这样可以直接clone后调用test方法：

use std::sync::Arc;

trait T {
    fn test(self: Arc<Self>);
}

// 示例实现类型
struct Impl1OfT;
impl T for Impl1OfT {
    fn test(self: Arc<Self>) {
        println!("Impl1 test executed");
    }
}

struct Impl2OfT;
impl T for Impl2OfT {
    fn test(self: Arc<Self>) {
        println!("Impl2 test executed");
    }
}

// 枚举存储Arc包裹的子类型
enum AnyT {
    T1(Arc<Impl1OfT>),
    T2(Arc<Impl2OfT>),
}

impl T for AnyT {
    fn test(self: Arc<Self>) {
        match &*self {
            AnyT::T1(t) => t.clone().test(),
            AnyT::T2(t) => t.clone().test(),
        }
    }
}

// 使用示例
fn main() {
    let any_t = AnyT::T1(Arc::new(Impl1OfT));
    Arc::new(any_t).test();
}

2. 枚举存储值并通过Clone创建Arc（不推荐） #

如果必须存储子类型的值而非Arc，可以在调用test时clone值并包裹成Arc，但要求子类型实现Clone，且会创建新的Arc实例（与原AnyT的Arc无关）：

use std::sync::Arc;

trait T {
    fn test(self: Arc<Self>);
}

#[derive(Clone)]
struct Impl1OfT;
impl T for Impl1OfT {
    fn test(self: Arc<Self>) {
        println!("Impl1 test executed");
    }
}

#[derive(Clone)]
struct Impl2OfT;
impl T for Impl2OfT {
    fn test(self: Arc<Self>) {
        println!("Impl2 test executed");
    }
}

enum AnyT {
    T1(Impl1OfT),
    T2(Impl2OfT),
}

impl T for AnyT {
    fn test(self: Arc<Self>) {
        match self.as_ref() {
            AnyT::T1(t) => Arc::new(t.clone()).test(),
            AnyT::T2(t) => Arc::new(t.clone()).test(),
        }
    }
}

3. 使用动态分发Trait Object（更简洁） #

如果不需要枚举的强类型匹配，可以直接使用Arc<dyn T>作为统一类型，利用Rust的动态分发特性兼容所有实现了T的类型，无需枚举：

use std::sync::Arc;

// 要求T实现Sync+Send以满足Arc的线程安全要求
trait T: Sync + Send {
    fn test(self: Arc<Self>);
}

struct Impl1OfT;
impl T for Impl1OfT {
    fn test(self: Arc<Self>) {
        println!("Impl1 test executed");
    }
}

struct Impl2OfT;
impl T for Impl2OfT {
    fn test(self: Arc<Self>) {
        println!("Impl2 test executed");
    }
}

// 使用示例
fn main() {
    let t1: Arc<dyn T> = Arc::new(Impl1OfT);
    t1.clone().test();
    
    let t2: Arc<dyn T> = Arc::new(Impl2OfT);
    t2.clone().test();
}

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