decltype(auto) as_stack(std::false_type) const {
     base_t::push();
     return stack::pop<T>(lua_state());
 }

 string_refs(StringSequence const & names)
   : base_t({})
   , m_storage(names.begin(), names.end())
 {
   static_cast<base_t&>(*this) = base_t(m_storage);
 }

 void reserve( std::size_t size)
 { base_.reserve( size); }

 bool empty() const
 { return base_.empty(); }

 std::pair< const_iterator, const_iterator > equal_range( key_type const& k) const
 {
     return std::equal_range(
             base_.begin(), base_.end(),
             k, comparator() );
 }

 std::size_t capacity() const
 { return base_.capacity(); }

 void erase( iterator const& i, iterator const& e)
 { base_.erase( i, e); }

 iterator end()
 { return base_.end(); }

 void push_back( fiber_base::ptr_t const& f)
 {
     BOOST_ASSERT( f);
     base_.push_back( f);
 }

 const_iterator begin() const
 { return base_.begin(); }

 bracket(output& out, const char* = nullptr) : out_(out)
 { out_("(").compact(); }

 bool is_stack(std::false_type) const {
     auto pp = stack::push_pop(*this);
     return stack::check<T>(lua_state(), -1, no_panic);
 }

 size_type size() const
 { return base_.size(); }

 void sort()
 { std::stable_sort( base_.begin(), base_.end(), comparator() ); }

 iterator lower_bound( key_type const& k)
 {
     return std::lower_bound(
             base_.begin(), base_.end(),
             k, comparator() );
 }

 const_iterator upper_bound( key_type const& k) const
 {
     return std::upper_bound(
             base_.begin(), base_.end(),
             k, comparator() );
 }

 void swap( container & other)
 { base_.swap( other); }