您可以使用 * 泛型关联类型 *（GAT）和族模式：

trait Family {
    type Container<T>;
}

struct A;
struct B;

struct Bar<T: Family> {
    a: T::Container<A>,
    b: T::Container<B>,
}

字符串
然后可以定义两个族：

struct BoxFamily;
impl Family for BoxFamily {
    type Container<T> = Box<T>;
}

struct VecFamily;
impl Family for VecFamily {
    type Container<T> = Vec<T>;
}

型
并使用它：

let boxes: Bar<BoxFamily> = Bar {
    a: Box::new(A),
    b: Box::new(B),
};

let vecs: Bar<VecFamily> = Bar {
    a: vec![A, A],
    b: vec![B],
};

型
（Playground）
正如你所看到的，它比人们所希望的要稍微复杂一些：你不能只说Bar<Vec>，例如，但必须通过额外的家庭类型。但它有效！
有关包含有关该主题的更多一般信息的较旧答案（在GAT存在之前），请单击here。

在某种程度上，Rust * 确实 * 有看起来很像HKT的东西（请参阅Lukas的回答，以了解它们是什么），尽管有一些可以说是笨拙的语法。
首先，您需要为所需的指针类型定义接口，这可以使用泛型trait来完成。举例来说：

trait SharedPointer<T>: Clone {
    fn new(v: T) -> Self;
    // more, eg: fn get(&self) -> &T;
}

字符串
加上一个泛型trait，它定义了一个关联的类型，这是你真正想要的类型，它必须实现你的接口：

trait Param<T> {
    type Pointer: SharedPointer<T>;
}

型
接下来，我们为我们感兴趣的类型实现该接口：

impl<T> SharedPointer<T> for Rc<T> {
    fn new(v: T) -> Self {
        Rc::new(v)
    }
}
impl<T> SharedPointer<T> for Arc<T> {
    fn new(v: T) -> Self {
        Arc::new(v)
    }
}

型
并定义一些实现上述Param trait的虚拟类型。这是关键部分;我们可以有一个类型（RcParam），它为任何T实现了Param<T>，包括能够提供一个类型，这意味着我们模拟了一个更高级的类型。

struct RcParam;
struct ArcParam;

impl<T> Param<T> for RcParam {
    type Pointer = Rc<T>;
}

impl<T> Param<T> for ArcParam {
    type Pointer = Arc<T>;
}

型
最后，我们可以使用它：

struct A;
struct B;

struct Foo<P: Param<A> + Param<B>> {
    a: <P as Param<A>>::Pointer,
    b: <P as Param<B>>::Pointer,
}

impl<P: Param<A> + Param<B>> Foo<P> {
    fn new(a: A, b: B) -> Foo<P> {
        Foo {
            a: <P as Param<A>>::Pointer::new(a),
            b: <P as Param<B>>::Pointer::new(b),
        }
    }
}

fn main() {
    // Look ma, we're using a generic smart pointer type!
    let foo = Foo::<RcParam>::new(A, B);
    let afoo = Foo::<ArcParam>::new(A, B);
}

型
Playground