Header file range/v3/distance.hpp

#include <range/v3/range_fwd.hpp>

#include <range/v3/size.hpp>

#include <range/v3/begin_end.hpp>

#include <range/v3/range_traits.hpp>

#include <range/v3/range_concepts.hpp>

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

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

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

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

namespace ranges
{
    inline namespace v3
    {
        struct enumerate_fn;
        
        inline namespace 
        {
            constexpr auto& enumerate = static_const<enumerate_fn>::value;
        }
        
        struct distance_fn
        : ranges::v3::iter_distance_fn
        {
            using iter_distance_fn::operator();
            
            template <typename Rng, typename D = range_difference_t<Rng>, int _concept_requires_84 = 42, typename std::enable_if<(_concept_requires_84==43)||(Integral<D>()&&Range<Rng>()), int>::type=0>
            D operator()(Rng&& rng, D d = 0) const;
        };
        
        inline namespace 
        {
            constexpr auto& distance = static_const<distance_fn>::value;
        }
        
        struct distance_compare_fn
        : ranges::v3::iter_distance_compare_fn
        {
            using iter_distance_compare_fn::operator();
            
            template <typename Rng, int _concept_requires_129 = 42, typename std::enable_if<(_concept_requires_129==43)||(Range<Rng>()), int>::type=0>
            int operator()(Rng&& rng, range_difference_t<Rng> n) const;
        };
        
        inline namespace 
        {
            constexpr auto& distance_compare = static_const<distance_compare_fn>::value;
        }
    }
}

Class ranges::v3::enumerate_fn

struct enumerate_fn
: ranges::v3::iter_enumerate_fn
{
    using iter_enumerate_fn::operator();
    
    template <typename Rng, typename D = range_difference_t<Rng>, typename I = range_iterator_t<Rng>, int _concept_requires_53 = 42, typename std::enable_if<(_concept_requires_53==43)||(Integral<D>()&&Range<Rng>()), int>::type=0>
    std::pair<D, I> operator()(Rng&& rng, D d = 0) const;
};

@{


Variable ranges::v3::enumerate

constexpr auto& enumerate = static_const<enumerate_fn>::value;

enumerate_fn


Variable ranges::v3::distance

constexpr auto& distance = static_const<distance_fn>::value;

distance_fn


Variable ranges::v3::distance_compare

constexpr auto& distance_compare = static_const<distance_compare_fn>::value;

distance_compare_fn