Header file range/v3/view/zip_with.hpp

#include <meta/meta.hpp>

#include <range/v3/range_fwd.hpp>

#include <range/v3/begin_end.hpp>

#include <range/v3/range_traits.hpp>

#include <range/v3/range_concepts.hpp>

#include <range/v3/view_facade.hpp>

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

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

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

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

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

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

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

namespace ranges
{
    inline namespace v3
    {
        namespace detail
        {
            struct 
            {
                template <typename T, typename U>
                bool operator()(T const& t, U const& u) const;
            };
            
            constexpr anonymous-type{} equal_to;
            
            struct 
            {
                template <typename T>
                void operator()(T& t) const;
            };
            
            constexpr anonymous-type{} dec;
            
            struct 
            {
                template <typename T>
                void operator()(T& t) const;
            };
            
            constexpr anonymous-type{} inc;
            
            struct 
            {
                template <typename T, typename D>
                void operator()(T& t, D d) const;
            };
            
            constexpr anonymous-type{} advance_;
            
            struct 
            {
                template <typename T>
                constexpr decltype(u-t) operator()(T const& t, T const& u) const;
            };
            
            constexpr anonymous-type{} distance_to;
            
            struct 
            {
                template <typename T, typename U>
                constexpr decltype(true?t:u) operator()(T const& t, U const& u) const;
            };
            
            constexpr anonymous-type{} min_;
            
            struct 
            {
                template <typename T, typename U>
                constexpr decltype(true?u:t) operator()(T const& t, U const& u) const;
            };
            
            constexpr anonymous-type{} max_;
            
            template <typename State, typename Value>
            using zip_cardinality = std::integral_constant<cardinality, State::value>=0||Value::value>=0?(State::value>=0&&Value::value>=0?min_(State::value, Value::value):finite):State::value==finite||Value::value==finite?finite:State::value==unknown||Value::value==unknown?unknown:infinite>;
        }
        
        template <typename Fun, typename ... Rngs>
        struct iter_zip_with_view;
        
        template <typename Fun, typename ... Rngs>
        struct zip_with_view
        : iter_zip_with_view<indirected<Fun>, Rngs...>
        {
            zip_with_view() = default;
            
            explicit zip_with_view(Rngs... rngs);
            
            explicit zip_with_view(Fun fun, Rngs... rngs);
        };
        
        namespace view
        {
            struct iter_zip_with_fn
            {
                template <typename Fun, typename ... Rngs>
                using Concept = meta::and_<meta::and_<InputRange<Rngs>...>, Callable<Fun, range_iterator_t<Rngs>...>, Callable<Fun, copy_tag, range_iterator_t<Rngs>...>, Callable<Fun, move_tag, range_iterator_t<Rngs>...>>;
                
                template <typename ... Rngs, typename Fun, int _concept_requires_321 = 42, typename std::enable_if<(_concept_requires_321==43)||(Concept<Fun, Rngs>()), int>::type ... = 0>
                iter_zip_with_view<Fun, all_t<Rngs>...> operator()(Fun fun, Rngs&&... rngs) const;
                
                template <typename Fun, typename ... Rngs, int _concept_requires_332 = 42, typename std::enable_if<(_concept_requires_332==43)||(!Concept<Fun, Rngs>()), int>::type ... = 0>
                void operator()(Fun, Rngs&&...) const;
            };
            
            inline namespace 
            {
                constexpr auto& iter_zip_with = static_const<iter_zip_with_fn>::value;
            }
            
            struct zip_with_fn
            {
                template <typename Fun, typename ... Rngs>
                using Concept = meta::and_<meta::and_<InputRange<Rngs>...>, Callable<Fun, range_reference_t<Rngs>&&...>>;
                
                template <typename ... Rngs, typename Fun, int _concept_requires_366 = 42, typename std::enable_if<(_concept_requires_366==43)||(Concept<Fun, Rngs>()), int>::type ... = 0>
                zip_with_view<Fun, all_t<Rngs>...> operator()(Fun fun, Rngs&&... rngs) const;
                
                template <typename Fun, typename ... Rngs, int _concept_requires_377 = 42, typename std::enable_if<(_concept_requires_377==43)||(!Concept<Fun, Rngs>()), int>::type ... = 0>
                void operator()(Fun, Rngs&&...) const;
            };
            
            inline namespace 
            {
                constexpr auto& zip_with = static_const<zip_with_fn>::value;
            }
        }
    }
}

Class template ranges::v3::iter_zip_with_view<Fun, Rngs...>

template <typename Fun, typename ... Rngs>
struct iter_zip_with_view
: view_facade<iter_zip_with_view<Fun, Rngs...>, meta::fold<meta::list<range_cardinality<Rngs>...>, std::integral_constant<cardinality, infinite>, meta::quote<detail::zip_cardinality> >::value>
{
    iter_zip_with_view() = default;
    
    explicit iter_zip_with_view(Rngs... rngs);
    
    explicit iter_zip_with_view(Fun fun, Rngs... rngs);
    
    template <int _concept_requires_282 = 42, typename std::enable_if<(_concept_requires_282==43)||(meta::and_c<(bool)SizedRange<Rngs>()>::value), int>::type ... = 0>
    constexpr size_type_ size() const;
};

@{