make container consumable if possible

#include <utility>
#include <iterator>
#include <type_traits>

template< typename container, bool = std::is_const< std::remove_reference_t< container > >::value >
struct consumable_container;

template< typename container >
struct consumable_container< container, false >
{

    consumable_container(container && _container) noexcept
        : container_(std::forward< container >(_container))
    { ; }

    auto
    begin() noexcept
    {
        return std::make_move_iterator(std::begin(container_));
    }

    auto
    end() noexcept
    {
        return std::make_move_iterator(std::end(container_));
    }

private :

    container container_;

};

template< typename container >
struct consumable_container< container, true >
{

    static_assert(!std::is_rvalue_reference< container >::value);

    consumable_container(container && _container) noexcept
        : container_(std::forward< container >(_container))
    { ; }

    auto
    begin() const noexcept
    {
        return std::cbegin(container_);
    }

    auto
    end() const noexcept
    {
        return std::cend(container_);
    }

private :

    container container_;

};

template< typename container >
consumable_container< container >
move_if_not_const(container && _container) noexcept
{
    return std::forward< container >(_container);
}

#include <list>

template< typename container >
auto
transform_to_list(container && _container) noexcept
{
    static_assert(std::is_reference< container >::value || !std::is_const< container >::value);
    std::list< typename std::remove_reference_t< container >::value_type > list_;
    for (auto && value_ : move_if_not_const(std::forward< container >(_container))) {
        list_.push_back(std::forward< decltype(value_) >(value_));
    }
    return list_;
}

#include <iostream>

struct A
{

    A() { std::cout << __PRETTY_FUNCTION__ << std::endl; }
    ~A() { std::cout << __PRETTY_FUNCTION__ << std::endl; }

    A(A const &) { std::cout << __PRETTY_FUNCTION__ << std::endl; }
    A(A &) { std::cout << __PRETTY_FUNCTION__ << std::endl; }
    A(A &&) { std::cout << __PRETTY_FUNCTION__ << std::endl; }

    A & operator = (A const &) { std::cout << __PRETTY_FUNCTION__ << std::endl; return *this; }
    A & operator = (A &) { std::cout << __PRETTY_FUNCTION__ << std::endl; return *this; }
    A & operator = (A &&) { std::cout << __PRETTY_FUNCTION__ << std::endl; return *this; }

};

#include <deque>
#include <forward_list>
#include <vector>

#include <cstdlib>

int
main()
{
    {
        std::deque< A > const deque_(1);
        std::list< A > ld_ = transform_to_list(deque_);
    }
    std::cout << std::endl;
    {
        std::forward_list< A > forward_list_;
        forward_list_.push_front(A{});
        std::list< A > ls_ = transform_to_list(forward_list_);
    }
    std::cout << std::endl;
    {
        std::vector< A > vector_;
        vector_.push_back(A{});
        std::list< A > lv_ = transform_to_list(std::move(vector_));
    }
    return EXIT_SUCCESS;
}