创建一个在另一个通用结构上通用的结构

Question

I am trying to create a struct in Rust that is itself generic with respect to other generic structs. That's pretty confusing so hopefully this example will makes things clearer:

use std::ops::Deref;
use std::rc::Rc;

struct Foo<T: Deref> {
    val: T<i32>,
    other: i32,
}

impl<T> Foo<T> {
    pub fn new(&self, val: T<i32>, other: i32) -> Self {
        Foo {val: val, other: other}
    }
}

fn main() {
    let foo = Foo::new(Rc::new(0), 0);
}

playground

I would like to be able to create a Foo object by calling new with either Rc<i32> objects or Arc<i32> objects depending on whether I need thread safety or not. I get the following error when I try this though: error[E0109]: type parameters are not allowed on this type , as the compiler complains about the i32 in val: T<i32>, . Is this possible in Rust? If so, can I safely call methods on i32 assuming it will auto dereference it?

Answer 1

That syntax doesn't make sense, but this version compiles:

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

struct Foo<T> {
    val: T,
    other: i32,
}

impl<T> Foo<T>
    where T: Deref<Target = i32>
{
    pub fn new(val: T, other: i32) -> Self {
        Foo {
            val: val,
            other: other,
        }
    }
}

fn main() {
    let foo = Foo::new(Rc::new(0), 0);
    let foo = Foo::new(Arc::new(0), 0);
}

Note how the trait bounds read: T: Deref<Target = i32> "Any T that implements Deref with a Target of an i32 ".

You can then implement methods that dereference val :

fn sum(&self) -> i32 {
    *self.val + self.other
}

---

In general, the concept of something like

struct Foo<T> {
    val: T<i32>,
}

Wouldn't prove useful. Just because something is parameterized over a i32 doesn't mean you can do anything with that i32 . Likewise, a type could be parameterized with something besides an i32 (or not at all) and still give you access to an i32 .