More general Unifiable

[philippeitis]

I'd like to be able to use Unifiable with AsRef<str> (or even more generally, AsRef<[u8]>) and IntoIterator types. The particular case where this comes up for me is in trying to provide a minimally allocating interface to Rust's string methods, such as splitn. The current interface either requires me to implement a copy of the Unifiable methods for slices (which is undesirable, and liable to break in future versions of this crate), or requires me to collect everything into a vector, which allocates for no good reason.

Ideally, such a change would allow something like this:

[1u64].unify(term);
std::iter::once("Hello world!").unify(term);
term.unify("hello world".splitn(5, " "));

I have a partially working copy of such a feature - however, the impl of Unifiable for Arc causes errors when implementing the methods for AsRef<[u8]> and IntoIterator - as seen below:

error[E0119]: conflicting implementations of trait `term::Unifiable` for type `std::sync::Arc<_>`
   --> swipl/src/term.rs:808:1
    |
808 | unsafe impl<S: AsRef<[u8]>> Unifiable for S {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `std::sync::Arc<_>`
    |
   ::: swipl/src/blob.rs:527:1
    |
527 | unsafe impl<T: ArcBlob> Unifiable for Arc<T> {
    | -------------------------------------------- first implementation here

error[E0119]: conflicting implementations of trait `term::Unifiable` for type `std::sync::Arc<_>`
   --> swipl/src/term.rs:916:1
    |
916 | / unsafe impl<'a, T, I> Unifiable for I
917 | | where
918 | |     T: Unifiable,
919 | |     I: IntoIterator<Item=T>,
...   |
964 | |     }
965 | | }
    | |_^ conflicting implementation for `std::sync::Arc<_>`
    |
   ::: swipl/src/blob.rs:527:1
    |
527 |   unsafe impl<T: ArcBlob> Unifiable for Arc<T> {
    |   -------------------------------------------- first implementation here
    |
    = note: upstream crates may add a new impl of trait `std::iter::Iterator` for type `std::sync::Arc<_>` in future versions
    = note: upstream crates may add a new impl of trait `std::iter::Iterator` for type `std::sync::Arc<_>` in future versions

Given that you'd obviously still want to support Unifiable for Arc<T>, I'm not sure what the best solution is here.

[matko]

I wonder if the generality of unify is not the problem here.
The blanket implementation for Arc<T> is to support blobs. It doesn't mean that every Arc<T> is supported by that implementation, only those that actually are blob types. But since there's a possibility that something is both an Arc and also an IntoIterator or an AsRef, rust doesn't allow the implementations to coexist.

Maybe blob unification should be more explicit, for example with a unify_blob instead of unify. That way, there wouldn't be this blanket implementation, and we could provide implementations for AsRef and IntoIterator (and even Arc itself for the case where the inner is not a blob).

I'll give it some thought.