Add method links in docs of free functions

Author: tranzystorekk

src/adaptors/mod.rs

@@ -481,7 +481,7 @@ pub type Merge<I, J> = MergeBy<I, J, MergeLte>;
 
 /// Create an iterator that merges elements in `i` and `j`.
 ///
-/// [`IntoIterator`] enabled version of `i.merge(j)`.
+/// [`IntoIterator`] enabled version of [`Itertools::merge`](crate::Itertools::merge).
 ///
 /// ```
 /// use itertools::merge;

src/concat_impl.rs

@@ -2,7 +2,7 @@ use crate::Itertools;
 
 /// Combine all an iterator's elements into one element by using [`Extend`].
 ///
-/// [`IntoIterator`]-enabled version of `.concat()`
+/// [`IntoIterator`]-enabled version of [`Itertools::concat`].
 ///
 /// This combinator will extend the first item with each of the rest of the
 /// items of the iterator. If the iterator is empty, the default value of

src/free.rs

@@ -37,7 +37,7 @@ pub use crate::rciter_impl::rciter;
 
 /// Iterate `iterable` with a running index.
 ///
-/// [`IntoIterator`] enabled version of `.enumerate()`.
+/// [`IntoIterator`] enabled version of [`Iterator::enumerate`].
 ///
 /// ```
 /// use itertools::enumerate;
@@ -54,7 +54,7 @@ pub fn enumerate<I>(iterable: I) -> iter::Enumerate<I::IntoIter>
 
 /// Iterate `iterable` in reverse.
 ///
-/// [`IntoIterator`] enabled version of `.rev()`.
+/// [`IntoIterator`] enabled version of [`Iterator::rev`].
 ///
 /// ```
 /// use itertools::rev;
@@ -72,7 +72,7 @@ pub fn rev<I>(iterable: I) -> iter::Rev<I::IntoIter>
 
 /// Iterate `i` and `j` in lock step.
 ///
-/// [`IntoIterator`] enabled version of `i.zip(j)`.
+/// [`IntoIterator`] enabled version of [`Iterator::zip`].
 ///
 /// ```
 /// use itertools::zip;
@@ -91,7 +91,7 @@ pub fn zip<I, J>(i: I, j: J) -> Zip<I::IntoIter, J::IntoIter>
 
 /// Create an iterator that first iterates `i` and then `j`.
 ///
-/// `IntoIterator` enabled version of `i.chain(j)`.
+/// [`IntoIterator`] enabled version of [`Iterator::chain`].
 ///
 /// ```
 /// use itertools::chain;
@@ -109,7 +109,7 @@ pub fn chain<I, J>(i: I, j: J) -> iter::Chain<<I as IntoIterator>::IntoIter, <J
 
 /// Create an iterator that clones each element from &T to T
 ///
-/// [`IntoIterator`] enabled version of `i.cloned()`.
+/// [`IntoIterator`] enabled version of [`Iterator::cloned`].
 ///
 /// ```
 /// use itertools::cloned;
@@ -125,7 +125,7 @@ pub fn cloned<'a, I, T: 'a>(iterable: I) -> iter::Cloned<I::IntoIter>
 
 /// Perform a fold operation over the iterable.
 ///
-/// [`IntoIterator`] enabled version of `i.fold(init, f)`
+/// [`IntoIterator`] enabled version of [`Iterator::fold`].
 ///
 /// ```
 /// use itertools::fold;
@@ -141,7 +141,7 @@ pub fn fold<I, B, F>(iterable: I, init: B, f: F) -> B
 
 /// Test whether the predicate holds for all elements in the iterable.
 ///
-/// [`IntoIterator`] enabled version of `i.all(f)`
+/// [`IntoIterator`] enabled version of [`Iterator::all`].
 ///
 /// ```
 /// use itertools::all;
@@ -157,7 +157,7 @@ pub fn all<I, F>(iterable: I, f: F) -> bool
 
 /// Test whether the predicate holds for any elements in the iterable.
 ///
-/// [`IntoIterator`] enabled version of `i.any(f)`
+/// [`IntoIterator`] enabled version of [`Iterator::any`].
 ///
 /// ```
 /// use itertools::any;
@@ -173,7 +173,7 @@ pub fn any<I, F>(iterable: I, f: F) -> bool
 
 /// Return the maximum value of the iterable.
 ///
-/// [`IntoIterator`] enabled version of `i.max()`.
+/// [`IntoIterator`] enabled version of [`Iterator::max`].
 ///
 /// ```
 /// use itertools::max;
@@ -189,7 +189,7 @@ pub fn max<I>(iterable: I) -> Option<I::Item>
 
 /// Return the minimum value of the iterable.
 ///
-/// [`IntoIterator`] enabled version of `i.min()`.
+/// [`IntoIterator`] enabled version of [`Iterator::min`].
 ///
 /// ```
 /// use itertools::min;
@@ -206,7 +206,7 @@ pub fn min<I>(iterable: I) -> Option<I::Item>
 
 /// Combine all iterator elements into one String, seperated by `sep`.
 ///
-/// [`IntoIterator`] enabled version of `iterable.join(sep)`.
+/// [`IntoIterator`] enabled version of [`Itertools::join`].
 ///
 /// ```
 /// use itertools::join;

src/lib.rs

@@ -3371,7 +3371,7 @@ impl<T: ?Sized> Itertools for T where T: Iterator { }
 /// `false` otherwise.
 ///
 /// This is an [`IntoIterator`] enabled function that is similar to the standard
-/// library method `Iterator::eq`.
+/// library method [`Iterator::eq`].
 ///
 /// ```
 /// assert!(itertools::equal(vec![1, 2, 3], 1..4));
@@ -3396,7 +3396,7 @@ pub fn equal<I, J>(a: I, b: J) -> bool
 }
 
 /// Assert that two iterables produce equal sequences, with the same
-/// semantics as *equal(a, b)*.
+/// semantics as [`equal(a, b)`](equal).
 ///
 /// **Panics** on assertion failure with a message that shows the
 /// two iteration elements.

src/zip_eq_impl.rs

@@ -14,7 +14,7 @@ pub struct ZipEq<I, J> {
 ///
 /// **Panics** if the iterators are not of the same length.
 ///
-/// [`IntoIterator`] enabled version of `i.zip_eq(j)`.
+/// [`IntoIterator`] enabled version of [`Itertools::zip_eq`](crate::Itertools::zip_eq).
 ///
 /// ```
 /// use itertools::zip_eq;