Header file range/v3/action/push_front.hpp

#include <meta/meta.hpp>

#include <range/v3/range_fwd.hpp>

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

#include <range/v3/action/insert.hpp>

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

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

namespace ranges
{
    inline namespace v3
    {
        namespace adl_push_front_detail
        {
            template <typename Cont, typename T, int _concept_requires_33 = 42, typename std::enable_if<(_concept_requires_33==43)||(LvalueContainerLike<Cont>()&&Constructible<range_value_t<Cont>, T&&>()), int>::type=0>
            decltype((void)unwrap_reference(cont).push_front(std::forward<T>(t))) push_front(Cont&& cont, T&& t);
            
            template <typename Cont, typename Rng, int _concept_requires_41 = 42, typename std::enable_if<(_concept_requires_41==43)||(LvalueContainerLike<Cont>()&&Range<Rng>()), int>::type=0>
            decltype((void)ranges::insert(cont, begin(cont), std::forward<Rng>(rng))) push_front(Cont&& cont, Rng&& rng);
            
            struct push_front_fn
            {
                struct ConceptImpl
                {
                    template <typename Rng, typename T>
                    decltype(concepts::valid_expr(concepts::model_of<concepts::InputRange, Rng>(), concepts::is_true(meta::or_<Constructible<range_value_t<Rng>, T&&>, Range<T&&>>()), ((void)push_front(rng, concepts::val<T>()), 42))) requires_(Rng&& rng, T&&);
                };
                
                template <typename Rng, typename Fun>
                using Concept = concepts::models<ConceptImpl, Rng, Fun>;
                
                template <typename Rng, typename T, int _concept_requires_76 = 42, typename std::enable_if<(_concept_requires_76==43)||(Concept<Rng, T>()), int>::type=0>
                Rng operator()(Rng&& rng, T&& t) const;
                
                template <typename Rng, typename T, int _concept_requires_85 = 42, typename std::enable_if<(_concept_requires_85==43)||(!Concept<Rng, T>()), int>::type=0>
                void operator()(Rng&&, T&&) const;
            };
        }
        
        namespace action
        {
            inline namespace 
            {
                constexpr auto& push_front = static_const<with_braced_init_args<action<adl_push_front_detail::push_front_fn>>>::value;
            }
        }
        
        using action::push_front;
    }
}