std::indirectly_movable_storable(3)

NAME
std::indirectly_movable_storable - std::indirectly_movable_storable

Synopsis
   Defined in header <iterator>
   template< class In, class Out >
   concept indirectly_movable_storable =
       std::indirectly_movable<In, Out> &&
       std::indirectly_writable<Out, std::iter_value_t<In>> &&
       std::movable<std::iter_value_t<In>> && (since C++20)
       std::constructible_from<std::iter_value_t<In>,
   std::iter_rvalue_reference_t<In>> &&
       std::assignable_from<std::iter_value_t<In>&,
   std::iter_rvalue_reference_t<In>>;
   The indirectly_movable_storable concept specifies the relationship between an
   indirectly_readable type and an indirectly_writable type. In addition to
   indirectly_movable, this concept specifies that the move from the
   indirectly_readable type can be performed via an intermediate object.
   Semantic requirements
   In and Out model std::indirectly_movable_storable<In, Out> only if given a
   dereferenceable value i of type In:
     * After the definition std::iter_value_t<In> obj(ranges::iter_move(i));, obj is
       equal to the value previously denoted by *i, and
     * if std::iter_rvalue_reference_t<In> is an rvalue reference type, *i is placed in
       a valid but unspecified state after the initialization of obj.
   Equality preservation
   Expressions declared in requires expressions of the standard library concepts are
   required to be equality-preserving (except where stated otherwise).

See also
   indirectly_movable specifies that values may be moved from an
   (C++20) indirectly_readable type to an indirectly_writable type
                        (concept)
                        specifies that values may be copied from an
   indirectly_copyable_storable indirectly_readable type to an indirectly_writable type
   (C++20) and that the copy may be performed via an intermediate
                        object
                        (concept)