Fully qualified syntax on chained methods to avoid name collision warning

Consider the following simple rust program:

use itertools::Itertools;

fn main() {
    let my_vec = vec!['a', 'b', 'c', 'd'];

    let my_string: String = my_vec.iter().intersperse(&' ').collect();

    println!("My string: {my_string}");
}

This code compiles but yields the following warning:

warning: a method with this name may be added to the standard library in the future
 --> src/main.rs:6:43
  |
6 |     let my_string: String = my_vec.iter().intersperse(&' ').collect();
  |                                           ^^^^^^^^^^^
  |
  = warning: once this associated item is added to the standard library, the ambiguity may cause an error or change in behavior!
  = note: for more information, see issue #48919 <https://github.com/rust-lang/rust/issues/48919>
  = help: call with fully qualified syntax `itertools::Itertools::intersperse(...)` to keep using the current method
  = note: `#[warn(unstable_name_collisions)]` on by default

The compiler suggests to use a Fully Qualified Syntax to resolve this warning. I can't however figure out how to use this syntax with chained methods, as used in the example.

Solution

An associated function with a self parameter is simply a function that takes a parameter of type Self.

In the case of the intersperse function, it takes an impl Itertools as the first parameter.

You can rewrite your code like this with the fully qualified path:

let my_string: String = itertools::Itertools::intersperse(
    my_vec.iter(), &' '
).collect();

Where you pass my_vec.iter() as the first parameter to intersperse.

Alternatively, you could create a blanket trait around this specific function to preserve the ideal readability of the original code. In a dedicated file (e.g. itersperse_wrapper.rs), place the following definition:

use itertools::Itertools;

pub trait IntersperseWrapper
where
    Self: Iterator + Sized,
    Self::Item: Clone,
{
    #[inline]
    fn itertools_intersperse(self, separator: Self::Item) -> itertools::Intersperse<Self> {
        Itertools::intersperse(self, separator)
    }
}

impl<T> IntersperseWrapper for T
where
    T: Iterator,
    T::Item: Clone,
{}

Then in your main file you can use the itertools_intersperse wrapper, preventing the warning while maintaining linear readability.

mod intersperse_wrapper;

use intersperse_wrapper::IntersperseWrapper;
use itertools::Itertools;

fn main() {
    // Input vector
    let my_vec = vec!['a', 'b', 'c', 'd'];

    // Create string using the wrapper
    let string_using_wrapper: String = my_vec
        .iter()
        .itertools_intersperse(&' ')
        .collect();

    // Create string using fully qualified syntax
    let string_using_fully_qualified_syntax: String = Itertools::intersperse(
        my_vec.iter(), &' '
        ).collect();

    assert_eq!(string_using_wrapper, "a b c d");
    assert_eq!(string_using_fully_qualified_syntax, "a b c d");
    assert_eq!(string_using_wrapper, string_using_fully_qualified_syntax);
}