itertools

Prepare v0.13.0 release (#937)

chore: Release itertools version 0.12.1

chore: Release itertools version 0.12.0

chore: Release itertools version 0.11.0

• Maintenance

• Add EitherOrBoth::or and EitherOrBoth::or_else (#593)
  • Add min_set, max_set et al. (#613, #323)
  • Use either/use_std (#628)
  • Documentation fixes (#612, #625, #632, #633, #634, #638)
  • Code maintenance (#623, #624, #627, #630)

(cargo-release) itertools version 0.10.3

(cargo-release) itertools version 0.10.1

• Increase minimum supported Rust version to 1.32.0
  • Improve macro hygiene (#507)
  • Add Itertools::powerset (#335)
  • Add Itertools::sorted_unstable, Itertools::sorted_unstable_by, and Itertools::sorted_unstable_by_key (#494)
  • Implement Error for ExactlyOneError (#484)
  • Undeprecate Itertools::fold_while (#476)
  • Tuple-related adapters work for tuples of arity up to 12 (#475)
  • use_alloc feature for users who have alloc, but not std (#474)
  • Add Itertools::k_smallest (#473)
  • Add Itertools::into_grouping_map and GroupingMap (#465)
  • Add Itertools::into_grouping_map_by and GroupingMapBy (#465)
  • Add Itertools::counts (#468)
  • Add implementation of DoubleEndedIterator for Unique (#442)
  • Add implementation of DoubleEndedIterator for UniqueBy (#442)
  • Add implementation of DoubleEndedIterator for Zip (#346)
  • Add Itertools::multipeek (#435)
  • Add Itertools::dedup_with_count and DedupWithCount (#423)
  • Add Itertools::dedup_by_with_count and DedupByWithCount (#423)
  • Add Itertools::intersperse_with and IntersperseWith (#381)
  • Add Itertools::filter_ok and FilterOk (#377)
  • Add Itertools::filter_map_ok and FilterMapOk (#377)
  • Deprecate Itertools::fold_results, use Itertools::fold_ok instead (#377)
  • Deprecate Itertools::map_results, use Itertools::map_ok instead (#377)
  • Deprecate FoldResults, use FoldOk instead (#377)
  • Deprecate MapResults, use MapOk instead (#377)
  • Add Itertools::circular_tuple_windows and CircularTupleWindows (#350)
  • Add peek_nth and PeekNth (#303)

• Fix potential overflow in MergeJoinBy::size_hint (#385)
  • Add derive(Clone) where possible (#382)
  • Add try_collect method (#394)
  • Add HomogeneousTuple trait (#389)
  • Fix combinations(0) and combinations_with_replacement(0) (#383)
  • Don't require ParitalEq to the Item of DedupBy (#397)
  • Implement missing specializations on the PutBack adaptor and on the MergeJoinBy iterator (#372)
  • Add position_* methods (#412)
  • Derive Hash for EitherOrBoth (#417)
  • Increase minimum supported Rust version to 1.32.0

• Use slice::iter instead of into_iter to avoid future breakage (#378, by @LukasKalbertodt)

• Added a .exactly_one() iterator method that, on success, extracts the single value of an iterator ; by @Xaeroxe

  • Added combinatory iterator adaptors:

    • .permutations(k):

      [0, 1, 2].iter().permutations(2) yields

      [
        vec![0, 1],
        vec![0, 2],
        vec![1, 0],
        vec![1, 2],
        vec![2, 0],
        vec![2, 1],
      ]
      

      ; by @tobz1000

    • .combinations_with_replacement(k):

      [0, 1, 2].iter().combinations_with_replacement(2) yields

      [
        vec![0, 0],
        vec![0, 1],
        vec![0, 2],
        vec![1, 1],
        vec![1, 2],
        vec![2, 2],
      ]
      

      ; by @tommilligan

    • For reference, these methods join the already existing .combinations(k):

      [0, 1, 2].iter().combinations(2) yields

      [
        vec![0, 1],
        vec![0, 2],
        vec![1, 2],
      ]
      

  • Improved the performance of .fold()-based internal iteration for the .intersperse() iterator ; by @jswrenn

  • Added .dedup_by(), .merge_by() and .kmerge_by() adaptors that work like .dedup(), .merge() and .kmerge(), but taking an additional custom comparison closure parameter. ; by @phimuemue

  • Improved the performance of .all_equal() ; by @fyrchik

  • Loosened the bounds on .partition_map() to take just a FnMut closure rather than a Fn closure, and made its implementation use internal iteration for better performance ; by @danielhenrymantilla

  • Added convenience methods to EitherOrBoth elements yielded from the .zip_longest() iterator adaptor ; by @Avi-D-coder

  • Added .sum1() and .product1() iterator methods that respectively try to return the sum and the product of the elements of an iterator when it is not empty, otherwise they return None ; by @Emerentius

• Added new adaptor .map_into() for conversions using Into by @vorner
  • Improved Itertools docs by @JohnHeitmann
  • The return type of .sorted_by_by_key() is now an iterator, not a Vec.
  • The return type of the izip!(x, y) macro with exactly two arguments is now the usual Iterator::zip.
  • Remove .flatten() in favour of std's .flatten()
  • Deprecate .foreach() in favour of std's .for_each()
  • Deprecate .step() in favour of std's .step_by()
  • Deprecate repeat_call in favour of std's repeat_with
  • Deprecate .fold_while() in favour of std's .try_fold()
  • Require Rust 1.24 as minimal version.

• Add convenience methods to EitherOrBoth, making it more similar to Option and Either by @jethrogb

• No changes.

• New inclusion policy: See the readme about suggesting features for std before accepting them in itertools.
  • The FoldWhile type now implements Eq and PartialEq by @jturner314

• Add new iterator method .tree_fold1() which is like .fold1() except items are combined in a tree structure (see its docs). By @scottmcm
  • Add more Debug impls by @phimuemue: KMerge, KMergeBy, MergeJoinBy, ConsTuples, Intersperse, ProcessResults, RcIter, Tee, TupleWindows, Tee, ZipLongest, ZipEq, Zip.

• Add new iterator method .into_group_map() -> HashMap<K, Vec<V>> which turns an iterator of (K, V) elements into such a hash table, where values are grouped by key. By @tobz1000
  • Add new free function flatten for the .flatten() adaptor. NOTE: recent Rust nightlies have Iterator::flatten and thus a clash with our flatten adaptor. One workaround is to use the itertools flatten free function.

• Add new adaptor .multi_cartesian_product() which is an n-ary product iterator by @tobz1000
  • Add new method .sorted_by_key() by @Xion
  • Provide simpler and faster .count() for .unique() and .unique_by()

• .multipeek() now implements PeekingNext, by @nicopap.

• Add new adaptor .update() by @lucasem; this adaptor is used to modify an element before passing it on in an iterator chain.

• Add new method .collect_tuple() by @matklad; it makes a tuple out of the iterator's elements if the number of them matches exactly.
  • Implement fold and collect for .map_results() which means it reuses the code of the standard .map() for these methods.

• Add new adaptor .merge_join_by by @srijs; a heterogeneous merge join for two ordered sequences.

• Iterator adaptors and iterators in itertools now use the same must_use reminder that the standard library adaptors do, by @matematikaedit and @bluss “iterator adaptors are lazy and do nothing unless consumed”.

• Faster izip!() by @krdln
  • izip!() is now a wrapper for repeated regular .zip() and a single .map(). This means it optimizes as well as the standard library .zip() it uses. Note: multizip and izip!() are now different! The former has a named type but the latter optimizes better.
  • Faster .unique()
  • no_std support, which is opt-in!
    • Many lovable features are still there without std, like izip!() or .format() or .merge(), but not those that use collections.
  • Trait bounds were required up front instead of just on the type: group_by's PartialEq by @Phlosioneer and repeat_call's FnMut.
  • Removed deprecated constructor Zip::new — use izip!() or multizip()

• Fix bug in .cartesian_product()'s fold (which only was visible for unfused iterators).

• Add specific fold implementations for .cartesian_product() and cons_tuples(), which improves their performance in fold, foreach, and iterator consumers derived from them.

• Add iterator adaptor .positions(predicate) by @tmccombs

• Add function process_results which can “lift” a function of the regular values of an iterator so that it can process the Ok values from an iterator of Results instead, by @shepmaster
  • Add iterator method .concat() which combines all iterator elements into a single collection using the Extend trait, by @srijs

• Better size hint testing and subsequent size hint bugfixes by @rkarp. Fixes bugs in product, interleave_shortest size hints.
  • New iterator method .all_equal() by @phimuemue

• Deprecated names were removed in favour of their replacements
  • .flatten() does not implement double ended iteration anymore
  • .fold_while() uses &mut self and returns FoldWhile<T>, for composability #168
  • .foreach() and .fold1() use self, like .fold() does.
  • .combinations(0) now produces a single empty vector. #174

• Add itertools method .kmerge_by() (and corresponding free function)
  • Relaxed trait requirement of .kmerge() and .minmax() to PartialOrd.

• Add multipeek method .reset_peek()
  • Add categories

• Add iterator adaptor .peeking_take_while() and its trait PeekingNext.

• Add iterator adaptor .with_position()
  • Fix multipeek's performance for long peeks by using VecDeque.

• Add .map_results()

• Many more adaptors now implement Debug
  • Add free function constructor repeat_n. RepeatN::new is now deprecated.

• Add infinite generator function iterate, that takes a seed and a closure.

• Special-cased .fold() for flatten and put back. .foreach() now uses fold on the iterator, to pick up any iterator specific loop implementation.
  • .combinations(n) asserts up front that n != 0, instead of running into an error on the second iterator element.

• Add .tuples::<T>() that iterates by two, three or four elements at a time (where T is a tuple type).
  • Add .tuple_windows::<T>() that iterates using a window of the two, three or four most recent elements.
  • Add .next_tuple::<T>() method, that picks the next two, three or four elements in one go.
  • .interleave() now has an accurate size hint.

• Workaround module/function name clash that made racer crash on completing itertools. Only internal changes needed.

• Release announcement
  • Renamed:
    • combinations is now tuple_combinations
    • combinations_n to combinations
    • group_by_lazy, chunks_lazy to group_by, chunks
    • Unfold::new to unfold()
    • RepeatCall::new to repeat_call()
    • Zip::new to multizip
    • PutBack::new, PutBackN::new to put_back, put_back_n
    • PutBack::with_value is now a builder setter, not a constructor
    • MultiPeek::new, .multipeek() to multipeek()
    • format to format_with and format_default to format
    • .into_rc() to rciter
    • Partition enum is now Either
  • Module reorganization:
    • All iterator structs are under itertools::structs but also reexported to the top level, for backwards compatibility
    • All free functions are reexported at the root, itertools::free will be removed in the next version
  • Removed:
    • ZipSlices, use .zip() instead
    • .enumerate_from(), ZipTrusted, due to being unstable
    • .mend_slices(), moved to crate odds
    • Stride, StrideMut, moved to crate odds
    • linspace(), moved to crate itertools-num
    • .sort_by(), use .sorted_by()
    • .is_empty_hint(), use .size_hint()
    • .dropn(), use .dropping()
    • .map_fn(), use .map()
    • .slice(), use .take() / .skip()
    • helper traits in misc
    • new constructors on iterator structs, use Itertools trait or free functions instead
    • itertools::size_hint is now private
  • Behaviour changes:
    • format and format_with helpers now panic if you try to format them more than once.
    • repeat_call is not double ended anymore
  • New features:
    • tuple flattening iterator is constructible with cons_tuples
    • itertools reexports Either from the either crate. Either<L, R> is an iterator when L, R are.
    • MinMaxResult now implements Copy and Clone
    • tuple_combinations supports 1-4 tuples of combinations (previously just 2)

• Add .minmax_by()
  • Add itertools::free::cloned
  • Add itertools::free::rciter
  • Improve .step(n) slightly to take advantage of specialized Fuse better.

• Only changes related to the "unstable" crate feature. This feature is more or less deprecated.
  • Use deprecated warnings when unstable is enabled. .enumerate_from() will be removed imminently since it's using a deprecated libstd trait.

• Fix bug in .kmerge() that caused it to often produce the wrong order #134

• Improve precision of the interleave_shortest adaptor's size hint (it is now computed exactly when possible).

• Fixup on top of the workaround in 0.4.14. A function in itertools::free was removed by mistake and now it is added back again.

• Workaround an upstream regression in a Rust nightly build that broke compilation of of itertools::free::{interleave, merge}

• Add .minmax() and .minmax_by_key(), iterator methods for finding both minimum and maximum in one scan.
  • Add .format_default(), a simpler version of .format() (lazy formatting for iterators).

• Add .zip_eq(), an adaptor like .zip() except it ensures iterators of inequal length don't pass silently (instead it panics).
  • Add .fold_while(), an iterator method that is a fold that can short-circuit.
  • Add .partition_map(), an iterator method that can separate elements into two collections.

• Add .get() for Stride{,Mut} and .get_mut() for StrideMut

• Improve performance of .kmerge()

• Add k-ary merge adaptor .kmerge()
  • Fix a bug in .islice() with ranges a..b where a > b.

• Implement Clone, Debug for Linspace

• Add function diff_with() that compares two iterators
  • Add .combinations_n(), an n-ary combinations iterator
  • Add methods PutBack::with_value and PutBack::into_parts.

• Add method .sorted()
  • Add module itertools::free with free function variants of common iterator adaptors and methods. For example enumerate(iterable), rev(iterable), and so on.