From e5f5a748b06fba194b32d9a8d7c1cddfb01e7add Mon Sep 17 00:00:00 2001
From: matt rice <ratmice@gmail.com>
Date: Sun, 26 Nov 2023 10:18:26 -0800
Subject: [PATCH] rename to `lend_refs` & `lend_refs_mut`

---
 .../{into_lending_refs.rs => lend_refs.rs}           | 12 ++++++------
 .../{into_lending_refs_mut.rs => lend_refs_mut.rs}   | 12 ++++++------
 src/to_lending/mod.rs                                |  8 ++++----
 src/traits/to_lending_iterator.rs                    | 10 +++++-----
 4 files changed, 21 insertions(+), 21 deletions(-)
 rename src/to_lending/{into_lending_refs.rs => lend_refs.rs} (79%)
 rename src/to_lending/{into_lending_refs_mut.rs => lend_refs_mut.rs} (77%)

diff --git a/src/to_lending/into_lending_refs.rs b/src/to_lending/lend_refs.rs
similarity index 79%
rename from src/to_lending/into_lending_refs.rs
rename to src/to_lending/lend_refs.rs
index 39600e0..53eb116 100644
--- a/src/to_lending/into_lending_refs.rs
+++ b/src/to_lending/lend_refs.rs
@@ -2,18 +2,18 @@ use crate::LendingIterator;
 
 /// A lending iterator that given an iterator, lends
 /// references to the given iterator's items.
-pub struct IntoLendingRefs<I: Iterator> {
+pub struct LendRefs<I: Iterator> {
     item: Option<I::Item>,
     iter: I,
 }
 
-impl<I: Iterator> IntoLendingRefs<I> {
-    pub(crate) fn new(iter: I) -> IntoLendingRefs<I> {
-        IntoLendingRefs { item: None, iter }
+impl<I: Iterator> LendRefs<I> {
+    pub(crate) fn new(iter: I) -> LendRefs<I> {
+        LendRefs { item: None, iter }
     }
 }
 
-impl<I> LendingIterator for IntoLendingRefs<I>
+impl<I> LendingIterator for LendRefs<I>
 where
     I: Iterator,
 {
@@ -50,6 +50,6 @@ mod test {
 
     fn test_helper() -> impl for<'a> LendingIterator<Item<'a> = &'a Foo> {
         let w = W { x: Foo(0) };
-        std::iter::once(Foo(0)).into_lending_refs().chain(w)
+        std::iter::once(Foo(0)).lend_refs().chain(w)
     }
 }
diff --git a/src/to_lending/into_lending_refs_mut.rs b/src/to_lending/lend_refs_mut.rs
similarity index 77%
rename from src/to_lending/into_lending_refs_mut.rs
rename to src/to_lending/lend_refs_mut.rs
index c1bc9d8..e22bbca 100644
--- a/src/to_lending/into_lending_refs_mut.rs
+++ b/src/to_lending/lend_refs_mut.rs
@@ -2,18 +2,18 @@ use crate::LendingIterator;
 
 /// A lending iterator that given an iterator, lends
 /// mutable references to the given iterator's items.
-pub struct IntoLendingRefsMut<I: Iterator> {
+pub struct LendRefsMut<I: Iterator> {
     item: Option<I::Item>,
     iter: I,
 }
 
-impl<I: Iterator> IntoLendingRefsMut<I> {
-    pub(crate) fn new(iter: I) -> IntoLendingRefsMut<I> {
-        IntoLendingRefsMut { item: None, iter }
+impl<I: Iterator> LendRefsMut<I> {
+    pub(crate) fn new(iter: I) -> LendRefsMut<I> {
+        LendRefsMut { item: None, iter }
     }
 }
 
-impl<I: Iterator> LendingIterator for IntoLendingRefsMut<I> {
+impl<I: Iterator> LendingIterator for LendRefsMut<I> {
     type Item<'a> = &'a mut I::Item where Self: 'a;
 
     fn next(&mut self) -> Option<Self::Item<'_>> {
@@ -51,6 +51,6 @@ mod test {
 
     fn test_helper() -> impl for<'a> LendingIterator<Item<'a> = &'a mut Foo> {
         let w = W { x: Foo(0) };
-        std::iter::once(Foo(0)).into_lending_refs_mut().chain(w)
+        std::iter::once(Foo(0)).lend_refs_mut().chain(w)
     }
 }
diff --git a/src/to_lending/mod.rs b/src/to_lending/mod.rs
index a2a4ff2..86ffceb 100644
--- a/src/to_lending/mod.rs
+++ b/src/to_lending/mod.rs
@@ -1,10 +1,10 @@
 mod into_lending;
-mod into_lending_refs;
-mod into_lending_refs_mut;
+mod lend_refs;
+mod lend_refs_mut;
 mod windows;
 mod windows_mut;
 pub use self::into_lending::IntoLending;
-pub use self::into_lending_refs::IntoLendingRefs;
-pub use self::into_lending_refs_mut::IntoLendingRefsMut;
+pub use self::lend_refs::LendRefs;
+pub use self::lend_refs_mut::LendRefsMut;
 pub use self::windows::Windows;
 pub use self::windows_mut::WindowsMut;
diff --git a/src/traits/to_lending_iterator.rs b/src/traits/to_lending_iterator.rs
index e3deaef..0147f83 100644
--- a/src/traits/to_lending_iterator.rs
+++ b/src/traits/to_lending_iterator.rs
@@ -1,4 +1,4 @@
-use crate::{IntoLending, IntoLendingRefs, IntoLendingRefsMut, Windows, WindowsMut};
+use crate::{IntoLending, LendRefs, LendRefsMut, Windows, WindowsMut};
 
 /// An extension trait for iterators that allows turning them into lending iterators (over windows of elements).
 pub trait ToLendingIterator: IntoIterator {
@@ -38,20 +38,20 @@ pub trait ToLendingIterator: IntoIterator {
 
     /// Turns this iterator into a lending iterator that lends references
     /// to the iterator's items.
-    fn into_lending_refs(self) -> IntoLendingRefs<Self::IntoIter>
+    fn lend_refs(self) -> LendRefs<Self::IntoIter>
     where
         Self: Sized,
     {
-        IntoLendingRefs::new(self.into_iter())
+        LendRefs::new(self.into_iter())
     }
 
     /// Turns this iterator into a lending iterator that lends mutable references
     /// to the iterator's items.
-    fn into_lending_refs_mut(self) -> IntoLendingRefsMut<Self::IntoIter>
+    fn lend_refs_mut(self) -> LendRefsMut<Self::IntoIter>
     where
         Self: Sized,
     {
-        IntoLendingRefsMut::new(self.into_iter())
+        LendRefsMut::new(self.into_iter())
     }
 }