Skip to content

Commit

Permalink
Rename .*_results() -> .*_ok()
Browse files Browse the repository at this point in the history
  • Loading branch information
@gin-ahirsch
gin-ahirsch committed Mar 23, 2020
1 parent 46ec717 commit 4bd644c
Show file tree
Hide file tree
Showing 2 changed files with 56 additions and 36 deletions.
45 changes: 24 additions & 21 deletions src/adaptors/mod.rs
View file
Expand Up @@ -1068,27 +1068,30 @@ where
I::Item: Into<R>,
{}

/// An iterator adapter to apply a transformation within a nested `Result`.
#[deprecated(note="Use MapOk instead", since="0.10")]
pub type MapResults<I, F> = MapOk<I, F>;

/// An iterator adapter to apply a transformation within a nested `Result::Ok`.
///
/// See [`.map_results()`](../trait.Itertools.html#method.map_results) for more information.
/// See [`.map_ok()`](../trait.Itertools.html#method.map_ok) for more information.
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
pub struct MapResults<I, F> {
pub struct MapOk<I, F> {
iter: I,
f: F
}

/// Create a new `MapResults` iterator.
pub fn map_results<I, F, T, U, E>(iter: I, f: F) -> MapResults<I, F>
/// Create a new `MapOk` iterator.
pub fn map_ok<I, F, T, U, E>(iter: I, f: F) -> MapOk<I, F>
where I: Iterator<Item = Result<T, E>>,
F: FnMut(T) -> U,
{
MapResults {
MapOk {
iter: iter,
f: f,
}
}

impl<I, F, T, U, E> Iterator for MapResults<I, F>
impl<I, F, T, U, E> Iterator for MapOk<I, F>
where I: Iterator<Item = Result<T, E>>,
F: FnMut(T) -> U,
{
Expand Down Expand Up @@ -1117,27 +1120,27 @@ impl<I, F, T, U, E> Iterator for MapResults<I, F>
}
}

/// An iterator adapter to filter values within a nested `Result`.
/// An iterator adapter to filter values within a nested `Result::Ok`.
///
/// See [`.filter_results()`](../trait.Itertools.html#method.filter_results) for more information.
/// See [`.filter_ok()`](../trait.Itertools.html#method.filter_ok) for more information.
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
pub struct FilterResults<I, F> {
pub struct FilterOk<I, F> {
iter: I,
f: F
}

/// Create a new `FilterResults` iterator.
pub fn filter_results<I, F, T, E>(iter: I, f: F) -> FilterResults<I, F>
/// Create a new `FilterOk` iterator.
pub fn filter_ok<I, F, T, E>(iter: I, f: F) -> FilterOk<I, F>
where I: Iterator<Item = Result<T, E>>,
F: FnMut(&T) -> bool,
{
FilterResults {
FilterOk {
iter: iter,
f: f,
}
}

impl<I, F, T, E> Iterator for FilterResults<I, F>
impl<I, F, T, E> Iterator for FilterOk<I, F>
where I: Iterator<Item = Result<T, E>>,
F: FnMut(&T) -> bool,
{
Expand Down Expand Up @@ -1180,11 +1183,11 @@ impl<I, F, T, E> Iterator for FilterResults<I, F>
}
}

/// An iterator adapter to filter and apply a transformation on values within a nested `Result`.
/// An iterator adapter to filter and apply a transformation on values within a nested `Result::Ok`.
///
/// See [`.filter_map_results()`](../trait.Itertools.html#method.filter_map_results) for more information.
/// See [`.filter_map_ok()`](../trait.Itertools.html#method.filter_map_ok) for more information.
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
pub struct FilterMapResults<I, F> {
pub struct FilterMapOk<I, F> {
iter: I,
f: F
}
Expand All @@ -1197,18 +1200,18 @@ fn transpose_result<T, E>(result: Result<Option<T>, E>) -> Option<Result<T, E>>
}
}

/// Create a new `FilterResults` iterator.
pub fn filter_map_results<I, F, T, U, E>(iter: I, f: F) -> FilterMapResults<I, F>
/// Create a new `FilterOk` iterator.
pub fn filter_map_ok<I, F, T, U, E>(iter: I, f: F) -> FilterMapOk<I, F>
where I: Iterator<Item = Result<T, E>>,
F: FnMut(T) -> Option<U>,
{
FilterMapResults {
FilterMapOk {
iter: iter,
f: f,
}
}

impl<I, F, T, U, E> Iterator for FilterMapResults<I, F>
impl<I, F, T, U, E> Iterator for FilterMapOk<I, F>
where I: Iterator<Item = Result<T, E>>,
F: FnMut(T) -> Option<U>,
{
Expand Down
47 changes: 32 additions & 15 deletions src/lib.rs
View file
Expand Up @@ -82,12 +82,13 @@ pub mod structs {
DedupBy,
Interleave,
InterleaveShortest,
FilterMapResults,
FilterResults,
FilterMapOk,
FilterOk,
Product,
PutBack,
Batching,
MapInto,
MapOk,
MapResults,
Merge,
MergeBy,
Expand Down Expand Up @@ -696,6 +697,14 @@ pub trait Itertools : Iterator {
adaptors::map_into(self)
}

#[deprecated(note="Use .map_ok() instead", since="0.10")]
fn map_results<F, T, U, E>(self, f: F) -> MapOk<Self, F>
where Self: Iterator<Item = Result<T, E>> + Sized,
F: FnMut(T) -> U,
{
self.map_ok(f)
}

/// Return an iterator adaptor that applies the provided closure
/// to every `Result::Ok` value. `Result::Err` values are
/// unchanged.
Expand All @@ -704,14 +713,14 @@ pub trait Itertools : Iterator {
/// use itertools::Itertools;
///
/// let input = vec![Ok(41), Err(false), Ok(11)];
/// let it = input.into_iter().map_results(|i| i + 1);
/// let it = input.into_iter().map_ok(|i| i + 1);
/// itertools::assert_equal(it, vec![Ok(42), Err(false), Ok(12)]);
/// ```
fn map_results<F, T, U, E>(self, f: F) -> MapResults<Self, F>
fn map_ok<F, T, U, E>(self, f: F) -> MapOk<Self, F>
where Self: Iterator<Item = Result<T, E>> + Sized,
F: FnMut(T) -> U,
{
adaptors::map_results(self, f)
adaptors::map_ok(self, f)
}

/// Return an iterator adaptor that filters every `Result::Ok`
Expand All @@ -722,14 +731,14 @@ pub trait Itertools : Iterator {
/// use itertools::Itertools;
///
/// let input = vec![Ok(22), Err(false), Ok(11)];
/// let it = input.into_iter().filter_results(|&i| i > 20);
/// let it = input.into_iter().filter_ok(|&i| i > 20);
/// itertools::assert_equal(it, vec![Ok(22), Err(false)]);
/// ```
fn filter_results<F, T, E>(self, f: F) -> FilterResults<Self, F>
fn filter_ok<F, T, E>(self, f: F) -> FilterOk<Self, F>
where Self: Iterator<Item = Result<T, E>> + Sized,
F: FnMut(&T) -> bool,
{
adaptors::filter_results(self, f)
adaptors::filter_ok(self, f)
}

/// Return an iterator adaptor that filters and transforms every
Expand All @@ -740,14 +749,14 @@ pub trait Itertools : Iterator {
/// use itertools::Itertools;
///
/// let input = vec![Ok(22), Err(false), Ok(11)];
/// let it = input.into_iter().filter_map_results(|i| if i > 20 { Some(i * 2) } else { None });
/// let it = input.into_iter().filter_map_ok(|i| if i > 20 { Some(i * 2) } else { None });
/// itertools::assert_equal(it, vec![Ok(44), Err(false)]);
/// ```
fn filter_map_results<F, T, U, E>(self, f: F) -> FilterMapResults<Self, F>
fn filter_map_ok<F, T, U, E>(self, f: F) -> FilterMapOk<Self, F>
where Self: Iterator<Item = Result<T, E>> + Sized,
F: FnMut(T) -> Option<U>,
{
adaptors::filter_map_results(self, f)
adaptors::filter_map_ok(self, f)
}

/// Return an iterator adaptor that merges the two base iterators in
Expand Down Expand Up @@ -1699,6 +1708,14 @@ pub trait Itertools : Iterator {
format::new_format(self, sep, format)
}

#[deprecated(note="Use .fold_ok() instead", since="0.10")]
fn fold_results<A, E, B, F>(&mut self, mut start: B, mut f: F) -> Result<B, E>
where Self: Iterator<Item = Result<A, E>>,
F: FnMut(B, A) -> B
{
self.fold_ok(start, f)
}

/// Fold `Result` values from an iterator.
///
/// Only `Ok` values are folded. If no error is encountered, the folded
Expand Down Expand Up @@ -1731,17 +1748,17 @@ pub trait Itertools : Iterator {
/// assert_eq!(
/// values.iter()
/// .map(Ok::<_, ()>)
/// .fold_results(0, Add::add),
/// .fold_ok(0, Add::add),
/// Ok(3)
/// );
/// assert!(
/// values.iter()
/// .map(|&x| if x >= 0 { Ok(x) } else { Err("Negative number") })
/// .fold_results(0, Add::add)
/// .fold_ok(0, Add::add)
/// .is_err()
/// );
/// ```
fn fold_results<A, E, B, F>(&mut self, mut start: B, mut f: F) -> Result<B, E>
fn fold_ok<A, E, B, F>(&mut self, mut start: B, mut f: F) -> Result<B, E>
where Self: Iterator<Item = Result<A, E>>,
F: FnMut(B, A) -> B
{
Expand All @@ -1760,7 +1777,7 @@ pub trait Itertools : Iterator {
/// value is returned inside `Some`. Otherwise, the operation terminates
/// and returns `None`. No iterator elements are consumed after the `None`.
///
/// This is the `Option` equivalent to `fold_results`.
/// This is the `Option` equivalent to `fold_ok`.
///
/// ```
/// use std::ops::Add;
Expand Down

0 comments on commit 4bd644c

Please sign in to comment.