constant.h

#pragma once

#include <type_traits>
#include <utility>

namespace funcy
{
    template < class Type >
    struct Constant
    {
        constexpr Constant() = default;

        constexpr Constant( Type&& t_ ) noexcept( std::is_nothrow_move_constructible_v< Type > )
            : t( std::move( t_ ) )
        {
        }

        constexpr Constant( const Type& t_ ) noexcept(
            std::is_nothrow_copy_constructible_v< Type > )
            : t( t_ )
        {
        }

        constexpr const Type& operator()() const noexcept
        {
            return t;
        }

    private:
        Type t;
    };

    template < class Arg >
    auto const_ref( const Arg& x ) noexcept( std::is_nothrow_copy_constructible_v< Arg > )
    {
        return Constant< const Arg& >( x );
    }

    template < class Arg >
    constexpr auto constant( Arg&& x ) noexcept(
        (std::is_rvalue_reference_v< Arg > && std::is_nothrow_move_constructible_v< Arg >) ||
        (std::is_lvalue_reference_v< Arg > && std::is_nothrow_copy_constructible_v< Arg >))
    {
        return Constant( std::forward< Arg >( x ) );
    }
} // namespace funcy