Copied from https://www.reddit.com/r/rust/comments/6dz0xh/_/di6wvk9/

lib.rs

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

// Definition and impls for RefCounted
pub trait RefCounted: Clone {
    type Target;

    fn new(obj: Self::Target) -> Self;
    fn strong_count(this: &Self) -> usize;
}

impl<T> RefCounted for Rc<T> {
    type Target = T;

    fn new(obj: T) -> Rc<T> {
        Rc::new(obj)
    }

    fn strong_count(this: &Rc<T>) -> usize {
        Rc::strong_count(this)
    }
}

impl<T> RefCounted for Arc<T> {
    type Target = T;

    fn new(obj: T) -> Arc<T> {
        Arc::new(obj)
    }

    fn strong_count(this: &Arc<T>) -> usize {
        Arc::strong_count(this)
    }
}

// Avoid creating infinite types by using an additional trait to provide some
// indirection
trait RefCountedConstructor<T> {
    type RC: RefCounted<Target = T>;
}

enum RcConstructor {}

impl<T> RefCountedConstructor<T> for RcConstructor {
    type RC = Rc<T>;
}

enum ArcConstructor {}

impl<T> RefCountedConstructor<T> for ArcConstructor {
    type RC = Arc<T>;
}

// Actual definition and impl for Hello
struct Hello<T, RCC>
    where RCC: RefCountedConstructor<Hello<T, RCC>>
{
    val: T,
    next: Option<RCC::RC>,
}

impl<T, RCC> Hello<T, RCC>
    where RCC: RefCountedConstructor<Hello<T, RCC>>
{
    fn new(val: T) -> Hello<T, RCC> {
        Hello {
            val: val,
            next: None,
        }
    }

    fn set_next(&mut self, val: T) {
        self.next = Some(RCC::RC::new(Hello::new(val)));
    }
}

// It works!
fn main() {
    let mut hello_rc = Hello::<_, RcConstructor>::new(0);
    hello_rc.set_next(1);

    let mut hello_arc = Hello::<_, ArcConstructor>::new(0);
    hello_arc.set_next(1);
}