Add `into_unique` method to `Rc` and `Arc`

[A4-Tacks]

Proposal

Problem statement

For Rc/Arc, returns the Some(this), if the has exactly one strong reference.

Motivating examples or use cases

I created a UniqArc wrapper that allows unique Arc to be DerefMut like a Box,
But I can't stably convert some shared Arc into a UniqArc, similar Arc::try_unwrap(this).ok()

For the sized type, Arc::new(Arc::into_inner(this)?) can be used, but this requires reallocating an Arc,
And if it's an unsized type, I have no way at all

// If there is such a method:
// pub fn into_unique(this: Arc<T>) -> Option<Arc<T>> { ... }
// I can create:
impl<T: ?Sized> UniqArc<T> {
    pub fn consume_new(arc: Arc<T>) -> Option<Self> {
        let unique = Arc::into_unique(arc)?;
        Some(UniqArc(unique))
    }
}

Solution sketch

• Return None when there are other strong references
• Return Some(this) when there are no other strong references and no other weak references
• Dissociate weak references and return Some(this) when there are no other strong references but weak references

Partial implementation:

impl<T: ?Sized> Arc<T> {
    #[inline]
    pub fn into_unique(this: Self) -> Option<Self> {
        if this.inner().strong.fetch_sub(1, Release) != 1 {
            return;
        }

        // If there are outstanding weak references, it will be dissociated like make_mut
        todo!();

        this.inner().strong.fetch_add(1, Relaxed);

        Some(this)
    }
}

Alternatives

• What other designs have been considered and what is the rationale for not choosing them?

  • If Option<Weak<T>> is returned, additional upgrade costs will be required
  • If Option<*const T> is returned, it can easily lead to unnecessary unsafe code

• What is the impact of not doing this?

  • Unable to mutable on the last Arc instance stably without copying

• If this is a language proposal, could this be done in a library or macro instead?

  • The public methods of Rc/Arc seems insufficient to accomplish this

Links and related work

unique-rc

[jongiddy]

An alternative return value would be Result<Self, Self>, returning Ok<Self> if the Arc is now unique and Err<Self> if the Arc is still shared.

This allows the caller to continue with a shared Arc, possibly by cloning the inner value to create a new unique Arc.

[A4-Tacks]

An alternative return value would be Result<Self, Self>, returning Ok<Self> if the Arc is now unique and Err<Self> if the Arc is still shared.

There will be race condition like Arc::try_unwrap

[zachs18]

I think this would make sense as part of the unique_rc_arc feature (tracking issue), and thus into_unique should return Option<UniqueArc<T>>, or Result<UniqueArc<T>, Arc<T>> (maybe have the Result-returning one be called try_into_unique or something, like Arc::try_unwrap -> Result vs Arc::into_inner -> Option).

Also: we currently have make_mut and get_mut which have different behavior depending on whether there are other strong/weak counts, so it might make sense to consider the rest of the matrix here.

Status	&mut Arc<T> -> &mut T	Arc<T> -> UniqueArc<T>
fail if other strong or weak	get_mut	?
fail if other strong, disassociate weak	?	proposed into_unique IIUC
clone if other strong, disassociate weak	make_mut	?

(analogous for Rc, of course)

Also, looking at the current API of UniqueArc, you can get Weaks to the allocation (UniqueArc::downgrade), which only become "accessible" after the UniqueArc has been converted to an Arc, so maybe "disassociating" the Weaks isn't necessary in the Arc<T> -> UniqueArc<T> case? Though that would add the weirdness that it is possible for Weak::upgrade to succeed, then fail, then succeed, e.g. a particular execution of the following pair of threads could behave as described if so:

// thread 1
let weak = /* shared */;
let _ = weak.upgrade(); // returns `Some(_)`
let _ = weak.upgrade(); // returns `None`
let _ = weak.upgrade(); // returns `Some(_)`

// thread 2
let arc = /* shared */;
// thread 1 upgrade gets Some here
let uniq = Arc::into_unique_bikeshed_no_disassociate_weak(arc)
    .unwrap(); // succeeds, Weaks are "inaccessible" but not disassociated
// thread 1 upgrade gets None here
let arc = UniqueArc::into_arc(uniq); // the Weaks become "accessible" again
// thread 1 upgrade gets Some here

[A4-Tacks]

I think this would make sense as part of the unique_rc_arc feature (tracking issue), and thus into_unique should return Option<UniqueArc<T>>, or Result<UniqueArc<T>, Arc<T>> (maybe have the Result-returning one be called try_into_unique or something, like Arc::try_unwrap -> Result vs Arc::into_inner -> Option).

There should be a method that consume Arc<T> and returns Option<UniqueArc<T>>, otherwise it is difficult to stably create UniqueArc<T> from some shared Arc<T>

Also, if not dissociated Weak, it seems to become difficult to use