Header file range/v3/view/zip.hpp

#include <meta/meta.hpp>

#include <range/v3/range_fwd.hpp>

#include <range/v3/utility/iterator_concepts.hpp>

#include <range/v3/utility/iterator_traits.hpp>

#include <range/v3/utility/iterator.hpp>

#include <range/v3/utility/common_tuple.hpp>

#include <range/v3/view/zip_with.hpp>

namespace ranges
{
    inline namespace v3
    {
        namespace detail
        {
            struct indirect_zip_fn_
            {
                template <typename ... Its, int _concept_requires_40 = 42, typename std::enable_if<(_concept_requires_40==43)||(meta::and_<Readable<Its>>()&&sizeof...(Its)!=2), int>::type ... = 0>
                std::tuple<iterator_value_t<Its>...> operator()(copy_tag, Its...) const;
                
                template <typename ... Its, int _concept_requires_46 = 42, typename std::enable_if<(_concept_requires_46==43)||(meta::and_<Readable<Its>>()&&sizeof...(Its)!=2), int>::type ... = 0>
                decltype(common_tuple<iterator_reference_t<Its>...>{*its...}) operator()(Its const&... its) const noexcept(meta::and_c<noexcept(iterator_reference_t<Its>(*its))...>::value);
                
                template <typename ... Its, int _concept_requires_56 = 42, typename std::enable_if<(_concept_requires_56==43)||(meta::and_<Readable<Its>>()&&sizeof...(Its)!=2), int>::type ... = 0>
                decltype(common_tuple<iterator_rvalue_reference_t<Its>...>{iter_move(its)...}) operator()(move_tag, Its const&... its) const noexcept(meta::and_c<noexcept(iterator_rvalue_reference_t<Its>(iter_move(its)))...>::value);
                
                template <typename It1, typename It2, int _concept_requires_67 = 42, typename std::enable_if<(_concept_requires_67==43)||(Readable<It1>()&&Readable<It2>()), int>::type=0>
                std::pair<iterator_value_t<It1>, iterator_value_t<It2>> operator()(copy_tag, It1, It2) const;
                
                template <typename It1, typename It2, int _concept_requires_73 = 42, typename std::enable_if<(_concept_requires_73==43)||(Readable<It1>()&&Readable<It2>()), int>::type=0>
                decltype(common_pair<iterator_reference_t<It1>, iterator_reference_t<It2>>{*it1, *it2}) operator()(It1 const& it1, It2 const& it2) const noexcept(noexcept(iterator_reference_t<It1>(*it1))&&noexcept(iterator_reference_t<It2>(*it2)));
                
                template <typename It1, typename It2, int _concept_requires_84 = 42, typename std::enable_if<(_concept_requires_84==43)||(Readable<It1>()&&Readable<It2>()), int>::type=0>
                decltype(common_pair<iterator_rvalue_reference_t<It1>, iterator_rvalue_reference_t<It2>>{iter_move(it1), iter_move(it2)}) operator()(move_tag, It1 const& it1, It2 const& it2) const noexcept(noexcept(iterator_rvalue_reference_t<It1>(iter_move(it1)))&&noexcept(iterator_rvalue_reference_t<It2>(iter_move(it2))));
            };
        }
        
        template <typename ... Rngs>
        struct zip_view;
        
        namespace view
        {
            struct zip_fn
            {
                template <typename ... Rngs>
                using Concept = meta::and_<InputRange<Rngs>...>;
                
                template <typename ... Rngs, int _concept_requires_118 = 42, typename std::enable_if<(_concept_requires_118==43)||(Concept<Rngs>()), int>::type ... = 0>
                zip_view<all_t<Rngs>...> operator()(Rngs&&... rngs) const;
                
                template <typename ... Rngs, int _concept_requires_127 = 42, typename std::enable_if<(_concept_requires_127==43)||(!Concept<Rngs>()), int>::type ... = 0>
                void operator()(Rngs&&...) const;
            };
            
            inline namespace 
            {
                constexpr auto& zip = static_const<zip_fn>::value;
            }
        }
    }
}

Class template ranges::v3::zip_view<Rngs...>

template <typename ... Rngs>
struct zip_view
: iter_zip_with_view<detail::indirect_zip_fn_, Rngs...>
{
    zip_view() = default;
    
    explicit zip_view(Rngs... rngs);
};

@{