Header file range/v3/view/drop.hpp

#include <meta/meta.hpp>

#include <range/v3/range_fwd.hpp>

#include <range/v3/range_traits.hpp>

#include <range/v3/range_concepts.hpp>

#include <range/v3/view_interface.hpp>

#include <range/v3/iterator_range.hpp>

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

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

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

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

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

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

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

namespace ranges
{
    inline namespace v3
    {
        template <typename Rng>
        struct drop_view;
        
        namespace view
        {
            struct drop_fn
            {
                template <typename Rng, int _concept_requires_182 = 42, typename std::enable_if<(_concept_requires_182==43)||(InputRange<Rng>()), int>::type=0>
                decltype(drop_fn::invoke_(std::forward<Rng>(rng), n, range_concept<Rng>{})) operator()(Rng&& rng, range_difference_t<Rng> n) const;
                
                template <typename Rng, typename T, int _concept_requires_190 = 42, typename std::enable_if<(_concept_requires_190==43)||(!(InputRange<Rng>()&&Integral<T>())), int>::type=0>
                void operator()(Rng&&, T) const;
            };
            
            inline namespace 
            {
                constexpr auto& drop = static_const<view<drop_fn>>::value;
            }
        }
    }
}

Class template ranges::v3::drop_view<Rng>

template <typename Rng>
struct drop_view
: view_interface<drop_view<Rng>, is_finite<Rng>::value ? finite : range_cardinality<Rng>::value>
{
    drop_view() = default;
    
    drop_view(drop_view&& that);
    
    drop_view(drop_view const& that);
    
    drop_view(Rng rng, difference_type_ n);
    
    drop_view& operator=(drop_view&& that);
    
    drop_view& operator=(drop_view const& that);
    
    range_iterator_t<Rng> begin();
    
    range_sentinel_t<Rng> end();
    
    template <typename BaseRng = Rng, int _concept_requires_110 = 42, typename std::enable_if<(_concept_requires_110==43)||(RandomAccessRange<BaseRng const>()), int>::type=0>
    range_iterator_t<BaseRng const> begin() const;
    
    template <typename BaseRng = Rng, int _concept_requires_116 = 42, typename std::enable_if<(_concept_requires_116==43)||(RandomAccessRange<BaseRng const>()), int>::type=0>
    range_sentinel_t<BaseRng const> end() const;
    
    template <int _concept_requires_121 = 42, typename std::enable_if<(_concept_requires_121==43)||(SizedRange<Rng const>()), int>::type=0>
    range_size_t<Rng> size() const;
    
    template <int _concept_requires_128 = 42, typename std::enable_if<(_concept_requires_128==43)||(SizedRange<Rng>()), int>::type=0>
    range_size_t<Rng> size();
    
    Rng& base();
    
    Rng const& base() const;
};

@{