Add Iterator::try_collect()

Closes chromium#295

try_collect can collect from an iterator of `T: Try` into a container
C that supports FromIterator<T: Try> to create C<U>.

The actual Try types do not need to support FromIterator then, and this
replaces the need for Option or Result to implement FromIterator.

We needed to add another operation on Try types for this, which is to
convert from T: Try in an error state to U: Try in an error state, where
they have the same (or a convertible) error type. This new concept is
sus::ops::TryErrorConvertibleTo and it's accessed through
sus::ops::try_preserve_error().

The TryErrorConvertibleTo concept is implemented for Option, Result and
std::optional.

Author: danakj

sus/CMakeLists.txt

@@ -115,6 +115,7 @@ target_sources(subspace PUBLIC
     "iter/iterator.h"
     "iter/iterator_concept.h"
     "iter/iterator_defn.h"
+    "iter/iterator_impl.h"
     "iter/iterator_ref.h"
     "iter/once.h"
     "iter/product.h"
@@ -123,6 +124,7 @@ target_sources(subspace PUBLIC
     "iter/size_hint.h"
     "iter/size_hint_impl.h"
     "iter/successors.h"
+    "iter/try_from_iterator.h"
     "iter/zip.h"
     "macros/__private/compiler_bugs.h"
     "macros/assume.h"

sus/iter/from_iterator.h

@@ -50,9 +50,10 @@ concept FromIterator =
 /// typically called through calling `collect()` on an iterator. However this
 /// function can be preferrable for some readers, especially in generic template
 /// code.
-template <class ToType, ::sus::iter::IntoIteratorAny IntoIter>
-  requires(
-      FromIterator<ToType, typename IntoIteratorOutputType<IntoIter>::Item>)
+template <class ToType, IntoIteratorAny IntoIter>
+  requires(FromIterator<ToType,
+                        typename IntoIteratorOutputType<IntoIter>::Item> &&  //
+           ::sus::mem::IsMoveRef<IntoIter &&>)
 constexpr inline ToType from_iter(IntoIter&& into_iter) noexcept {
   return FromIteratorImpl<ToType>::from_iter(
       ::sus::move(into_iter).into_iter());

sus/iter/iterator.h

@@ -16,6 +16,7 @@
 
 // IWYU pragma: begin_exports
 #include "sus/iter/iterator_defn.h"
+#include "sus/iter/iterator_impl.h"
 
 // The usize formatting is in unsigned_integer_impl.h which has an include cycle
 // with usize->Array->Array iterators->SizeHint->usize. So the SizeHint

sus/iter/iterator_defn.h

@@ -927,6 +927,22 @@ class IteratorBase {
       ::sus::fn::FnMut<bool(const std::remove_reference_t<Item>&)> auto
           pred) && noexcept;
 
+  template <class C>
+    requires(::sus::ops::Try<C> &&  //
+             ::sus::ops::Try<ItemT> &&
+             // On failure the iterated failure is returned so it needs to be
+             // possible.
+             ::sus::ops::TryErrorConvertibleTo<ItemT, C> &&
+             FromIterator<::sus::ops::TryOutputType<C>,
+                          ::sus::ops::TryOutputType<ItemT>> &&  //
+             // Void can not be collected from or into.
+             !std::is_void_v<::sus::ops::TryOutputType<C>> &&  //
+             !std::is_void_v<::sus::ops::TryOutputType<ItemT>> &&
+             // We construct the output types of C, so it must not be holding
+             // a reference type.
+             !std::is_reference_v<::sus::ops::TryOutputType<C>>)
+  constexpr C try_collect() noexcept;
+
   /// This function acts like `fold()` but the closure returns a type that
   /// satisfies `sus::ops::Try` and which converts to the accumulator type on
   /// success through the Try concept. If the closure ever returns failure, the
@@ -1059,7 +1075,7 @@ class IteratorBase {
   /// sus::move(iter).collect<MyContainer<i32>>()
   /// ```
   template <FromIterator<ItemT> C>
-  constexpr FromIterator<ItemT> auto collect() && noexcept;
+  constexpr C collect() && noexcept;
 
   /// Transforms an iterator into a Vec.
   ///
@@ -1859,14 +1875,13 @@ constexpr std::weak_ordering IteratorBase<Iter, Item>::weak_cmp_by(
 
 template <class Iter, class Item>
 template <FromIterator<Item> C>
-constexpr FromIterator<Item> auto
-IteratorBase<Iter, Item>::collect() && noexcept {
+constexpr C IteratorBase<Iter, Item>::collect() && noexcept {
   return from_iter<C>(static_cast<Iter&&>(*this));
 }
 
 template <class Iter, class Item>
-::sus::containers::Vec<Item> constexpr IteratorBase<
-    Iter, Item>::collect_vec() && noexcept {
+constexpr ::sus::containers::Vec<Item>
+IteratorBase<Iter, Item>::collect_vec() && noexcept {
   return from_iter<::sus::containers::Vec<Item>>(static_cast<Iter&&>(*this));
 }
 

sus/iter/iterator_impl.h

@@ -0,0 +1,47 @@
+// Copyright 2022 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// IWYU pragma: private, include "sus/iter/iterator.h"
+// IWYU pragma: friend "sus/.*"
+#pragma once
+
+#include <type_traits>
+
+#include "sus/iter/try_from_iterator.h"
+
+namespace sus::iter {
+
+// Implementation of IteratorBase::try_collect has to live here to avoid
+// cyclical includes, as the impl of try_from_iter() needs to see IteratorBase
+// in order to make something that can be consumed by FromIterator.
+template <class Iter, class Item>
+template <class C>
+  requires(
+      ::sus::ops::Try<C> &&  //
+      ::sus::ops::Try<Item> &&
+      // On failure the iterated failure is returned so it needs to be possible.
+      ::sus::ops::TryErrorConvertibleTo<Item, C> &&
+      FromIterator<::sus::ops::TryOutputType<C>,
+                   ::sus::ops::TryOutputType<Item>> &&  //
+      // Void can not be collected from or into.
+      !std::is_void_v<::sus::ops::TryOutputType<C>> &&  //
+      !std::is_void_v<::sus::ops::TryOutputType<Item>> &&
+      // We construct the output types of C, so it must not be holding
+      // a reference type.
+      !std::is_reference_v<::sus::ops::TryOutputType<C>>)
+constexpr C IteratorBase<Iter, Item>::try_collect() noexcept {
+  return try_from_iter<C>(static_cast<Iter&&>(*this));
+}
+
+}  // namespace sus::iter

sus/iter/iterator_unittest.cc

@@ -33,10 +33,13 @@
 #include "sus/num/overflow_integer.h"
 #include "sus/ops/eq.h"
 #include "sus/prelude.h"
+#include "sus/test/no_copy_move.h"
 
 using sus::containers::Array;
 using sus::iter::IteratorBase;
 using sus::option::Option;
+using sus::result::Result;
+using sus::test::NoCopyMove;
 
 namespace sus::test::iter {
 
@@ -45,6 +48,10 @@ struct CollectSum {
   T sum;
 };
 
+struct CollectRefs {
+  sus::Vec<const NoCopyMove*> vec;
+};
+
 }  // namespace sus::test::iter
 
 template <class T>
@@ -57,6 +64,16 @@ struct sus::iter::FromIteratorImpl<sus::test::iter::CollectSum<T>> {
   }
 };
 
+template <>
+struct sus::iter::FromIteratorImpl<sus::test::iter::CollectRefs> {
+  static sus::test::iter::CollectRefs from_iter(
+      sus::iter::IntoIterator<const NoCopyMove&> auto iter) noexcept {
+    auto v = sus::Vec<const NoCopyMove*>();
+    for (const NoCopyMove& t : sus::move(iter).into_iter()) v.push(&t);
+    return sus::test::iter::CollectRefs(sus::move(v));
+  }
+};
+
 namespace {
 using namespace sus::test::iter;
 
@@ -460,6 +477,10 @@ TEST(Iterator, Collect) {
       ArrayIterator<i32, 5>::with_array(nums).collect<CollectSum<i32>>();
   EXPECT_EQ(collected.sum, 1 + 2 + 3 + 4 + 5);
 
+  auto from = sus::iter::from_iter<CollectSum<i32>>(
+      ArrayIterator<i32, 5>::with_array(nums));
+  EXPECT_EQ(from.sum, 1 + 2 + 3 + 4 + 5);
+
   static_assert(sus::Array<i32, 5>::with(1, 2, 3, 4, 5)
                     .into_iter()
                     .collect<CollectSum<i32>>()
@@ -481,6 +502,66 @@ TEST(Iterator, CollectVec) {
       sus::Vec<i32>::with(1, 2, 3, 4, 5));
 }
 
+TEST(Iterator, TryCollect) {
+  // Option.
+  {
+    auto collected = sus::Array<Option<i32>, 3>::with(
+                         ::sus::some(1), ::sus::some(2), ::sus::some(3))
+                         .into_iter()
+                         .try_collect<Option<Vec<i32>>>();
+    EXPECT_EQ(collected.is_some(), true);
+    EXPECT_EQ(collected.as_value(), sus::Vec<i32>::with(1, 2, 3));
+
+    auto it = sus::Array<Option<i32>, 3>::with(::sus::some(1), ::sus::none(),
+                                               ::sus::some(3))
+                  .into_iter();
+    auto up_to_none = it.try_collect<Option<Vec<i32>>>();
+    EXPECT_EQ(up_to_none, sus::none());
+    auto after_none = it.try_collect<Option<Vec<i32>>>();
+    EXPECT_EQ(after_none.as_value(), sus::Vec<i32>::with(3));
+
+    NoCopyMove n[3];
+    auto refs = sus::Array<Option<const NoCopyMove&>, 3>::with(
+                    ::sus::some(n[0]), ::sus::some(n[1]), ::sus::some(n[2]))
+                    .into_iter()
+                    .try_collect<Option<CollectRefs>>();
+    EXPECT_EQ(refs.is_some(), true);
+    EXPECT_EQ(refs.as_value().vec[0u], &n[0]);
+    EXPECT_EQ(refs.as_value().vec[1u], &n[1]);
+    EXPECT_EQ(refs.as_value().vec[2u], &n[2]);
+  }
+  // Result.
+  enum Error { ERROR };
+  {
+    auto collected = sus::Array<Result<i32, Error>, 3>::with(
+                         ::sus::ok(1), ::sus::ok(2), ::sus::ok(3))
+                         .into_iter()
+                         .try_collect<Result<Vec<i32>, Error>>();
+    EXPECT_EQ(collected.as_ok(), sus::Vec<i32>::with(1, 2, 3));
+
+    auto it = sus::Array<Result<i32, Error>, 3>::with(
+                  ::sus::ok(1), ::sus::err(ERROR), ::sus::ok(3))
+                  .into_iter();
+    auto up_to_err = it.try_collect<Result<Vec<i32>, Error>>();
+    EXPECT_EQ(up_to_err, sus::err(ERROR));
+    auto after_err = it.try_collect<Result<Vec<i32>, Error>>();
+    EXPECT_EQ(after_err.as_ok(), sus::Vec<i32>::with(3));
+  }
+
+  auto from = sus::iter::try_from_iter<Option<Vec<i32>>>(
+      sus::Array<Option<i32>, 3>::with(::sus::some(1), ::sus::some(2),
+                                       ::sus::some(3)));
+  EXPECT_EQ(from.as_value(), sus::Vec<i32>::with(1, 2, 3));
+
+  static_assert(
+      sus::Array<Option<i32>, 3>::with(sus::some(1), sus::some(2), sus::some(3))
+          .into_iter()
+          .try_collect<Option<Vec<i32>>>()
+          .unwrap()
+          .into_iter()
+          .sum() == 1 + 2 + 3);
+}
+
 TEST(Iterator, Rev) {
   i32 nums[5] = {1, 2, 3, 4, 5};
 

sus/iter/try_from_iterator.h

@@ -0,0 +1,108 @@
+// Copyright 2022 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <concepts>
+
+#include "sus/iter/from_iterator.h"
+#include "sus/iter/into_iterator.h"
+#include "sus/iter/iterator_defn.h"
+#include "sus/mem/move.h"
+#include "sus/ops/try.h"
+#include "sus/option/option.h"
+
+namespace sus::iter {
+
+namespace __private {
+
+template <class SourceIter>
+struct TryFromIteratorUnwrapper final
+    : public IteratorBase<
+          TryFromIteratorUnwrapper<SourceIter>,
+          ::sus::ops::TryOutputType<typename SourceIter::Item>> {
+  using FromItem = typename SourceIter::Item;
+  using Item = ::sus::ops::TryOutputType<FromItem>;
+
+  constexpr TryFromIteratorUnwrapper(SourceIter& iter,
+                                     ::sus::Option<FromItem>& failure)
+      : iter(iter), failure(failure) {}
+
+  constexpr ::sus::Option<Item> next() noexcept {
+    ::sus::option::Option<FromItem> input = iter.next();
+    if (input.is_some()) {
+      if (::sus::ops::try_is_success(input.as_value())) {
+        return ::sus::move(input).map(&::sus::ops::try_into_output<FromItem>);
+      } else {
+        failure = ::sus::move(input);
+      }
+    }
+    return ::sus::Option<Item>();
+  }
+
+  constexpr SizeHint size_hint() const noexcept {
+    return SizeHint(0u, iter.size_hint().upper);
+  }
+
+  SourceIter& iter;
+  ::sus::Option<FromItem>& failure;
+};
+
+}  // namespace __private
+
+/// Constructs `ToType` from a type that can be turned into an `Iterator` over
+/// elements of type `ItemType`.
+///
+/// If a failure value is seen in the iterator, then the failure value will be
+/// returned. Otherwise, the `ToType` success type (`TryOutputType<ToType>`) is
+/// constructed from the success values in the Iterator, and a
+/// success-representing `ToType` is returned containing that success type.
+///
+/// This is the other end of
+/// [`Iterator::try_collect()`](::sus::iter::IteratorBase::try_collect), and is
+/// typically called through calling `try_collect()` on an iterator. However
+/// this function can be preferrable for some readers, especially in generic
+/// template code.
+template <class ToType, IntoIteratorAny IntoIter, int&...,
+          class FromType = typename IntoIteratorOutputType<IntoIter>::Item>
+  requires(
+      ::sus::mem::IsMoveRef<IntoIter &&> &&  //
+      ::sus::ops::Try<ToType> &&             //
+      ::sus::ops::Try<FromType> &&
+      // On failure the iterated failure is returned so it needs to be possible.
+      ::sus::ops::TryErrorConvertibleTo<FromType, ToType> &&
+      // The success type from the iterator can be collected into the
+      // success type of the output.
+      FromIterator<::sus::ops::TryOutputType<ToType>,
+                   ::sus::ops::TryOutputType<FromType>> &&
+      // Void can not be collected from or into.
+      !std::is_void_v<::sus::ops::TryOutputType<ToType>> &&    //
+      !std::is_void_v<::sus::ops::TryOutputType<FromType>> &&  //
+      // We construct the output types of ToType, so it must not be holding a
+      // reference type.
+      !std::is_reference_v<::sus::ops::TryOutputType<ToType>>)
+constexpr inline ToType try_from_iter(IntoIter&& into_iter) noexcept {
+  auto&& iter = ::sus::move(into_iter).into_iter();
+  using SourceIter = std::remove_reference_t<decltype(iter)>;
+
+  ::sus::Option<typename SourceIter::Item> failure;
+  auto out = ::sus::ops::try_from_output<ToType>(  //
+      from_iter<::sus::ops::TryOutputType<ToType>>(
+          __private::TryFromIteratorUnwrapper<SourceIter>(iter, failure)));
+  if (failure.is_some())
+    out = ::sus::ops::try_preserve_error<ToType>(::sus::move(failure).unwrap());
+  return out;
+}
+
+}  // namespace sus::iter