std::experimental::ranges::tagged<Base,Tags...>::operator=

From cppreference.com
 
 
Experimental
Technical Specification
Filesystem library (filesystem TS)
Library fundamentals (library fundamentals TS)
Library fundamentals 2 (library fundamentals TS v2)
Library fundamentals 3 (library fundamentals TS v3)
Extensions for parallelism (parallelism TS)
Extensions for parallelism 2 (parallelism TS v2)
Extensions for concurrency (concurrency TS)
Extensions for concurrency 2 (concurrency TS v2)
Concepts (concepts TS)
Ranges (ranges TS)
Reflection (reflection TS)
Mathematical special functions (special functions TR)
Experimental Non-TS
Pattern Matching
Linear Algebra
std::execution
Contracts
2D Graphics
 
 
General utilities library
Utility components
Function objects
Metaprogramming and type traits
Tagged pairs and tuples
                          
tag specifiers
                                      
                          
 
 
tagged &operator=( tagged&& that ) = default;
(1)
tagged &operator=( const tagged& that ) = default;
(2)
template< class Other >

    requires Assignable<Base&, Other>
constexpr tagged& operator=( ranges::tagged<Other, Tags...>&& that )

    noexcept(std::is_nothrow_assignable<Base&, Other>::value);
(3)
template< class Other >

    requires Assignable<Base&, const Other&>

constexpr tagged& operator=( const ranges::tagged<Other, Tags...>& that );
(4)
template< class U >

    requires Assignable<Base&, U> && !Same<std::decay_t<U>, tagged>

constexpr tagged& operator=( U&& that ) noexcept(std::is_nothrow_assignable<Base&, U>::value);
(5)

Assigns the contents of that to *this.

1,2) tagged has defaulted copy and move assignment operators that invoke the corresponding assignment operator of Base.
3) Converting move assignment from a different tagged specialization with matching tags. Equivalent to static_cast<Base&>(*this) = static_cast<Other&&>(that);.
4) Converting copy assignment from a different tagged specialization with matching tags. Equivalent to static_cast<Base&>(*this) = static_cast<const Other&>(that);.
5) Assigns that to the Base subobject. Equivalent to static_cast<Base&>(*this) = std::forward<U>(that);.

Return value

*this.