diff --git a/build/CMakeLists.txt b/build/CMakeLists.txt
index c16c1d2d..52d95818 100644
--- a/build/CMakeLists.txt
+++ b/build/CMakeLists.txt
@@ -119,10 +119,15 @@ add_executable(axis_test
 target_link_libraries(axis_test ${LIBRARIES})
 add_test(axis_test axis_test)
 
-add_executable(dynamic_storage_test
-               ../test/dynamic_storage_test.cpp)
-target_link_libraries(dynamic_storage_test ${LIBRARIES})
-add_test(dynamic_storage_test dynamic_storage_test)
+add_executable(adaptive_storage_test
+               ../test/adaptive_storage_test.cpp)
+target_link_libraries(adaptive_storage_test ${LIBRARIES})
+add_test(adaptive_storage_test dynamic_storage_test)
+
+add_executable(container_storage_test
+               ../test/container_storage_test.cpp)
+target_link_libraries(container_storage_test ${LIBRARIES})
+add_test(container_storage_test dynamic_storage_test)
 
 add_executable(detail_test
                ../test/detail_test.cpp)
diff --git a/include/boost/histogram/detail/mpl.hpp b/include/boost/histogram/detail/meta.hpp
similarity index 54%
rename from include/boost/histogram/detail/mpl.hpp
rename to include/boost/histogram/detail/meta.hpp
index 133d6ae2..e13b831e 100644
--- a/include/boost/histogram/detail/mpl.hpp
+++ b/include/boost/histogram/detail/meta.hpp
@@ -4,8 +4,8 @@
 // (See accompanying file LICENSE_1_0.txt
 // or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef _BOOST_HISTOGRAM_DETAIL_MPL_HPP_
-#define _BOOST_HISTOGRAM_DETAIL_MPL_HPP_
+#ifndef _BOOST_HISTOGRAM_DETAIL_META_HPP_
+#define _BOOST_HISTOGRAM_DETAIL_META_HPP_
 
 #include <type_traits>
 #include <iterator>
@@ -19,6 +19,13 @@ namespace boost {
 namespace histogram {
 namespace detail {
 
+template <typename T,
+          typename = decltype(std::declval<T&>().size()),
+          typename = decltype(std::declval<T&>().increase(0)),
+          typename = decltype(std::declval<T&>().value(0)),
+          typename = decltype(std::declval<T&>().variance(0))>
+struct is_storage {};
+
 template <typename T,
           typename = decltype(*std::declval<T&>()),
           typename = decltype(++std::declval<T&>())>
@@ -50,38 +57,25 @@ struct intersection {
     >::type;
 };
 
-template <typename T>
-struct is_dynamic_storage {
-    typedef char one;
-    typedef long two;
-
-    template<typename U,
-             typename = decltype(std::declval<U&>().increase(0, 0.0))>
-    struct BetterMatch {};
-    template<typename U> static one Test(BetterMatch<U>*);
-    template<typename U> static two Test(...);
-    static constexpr bool value = sizeof(Test<T>(0)) == sizeof(one);
-};
-
-// prefer dynamic over static storage, choose 
-// static_storage with larger capacity
-template <typename Storage1,
-          typename Storage2>
-struct select_storage {
-    using type = typename std::conditional<
-        (is_dynamic_storage<Storage1>::value ||
-         is_dynamic_storage<Storage2>::value),
-        typename std::conditional<
-            is_dynamic_storage<Storage1>::value,
-            Storage1, Storage2
-        >::type,
-        typename std::conditional<
-            (std::numeric_limits<typename Storage1::value_t>::max() >
-             std::numeric_limits<typename Storage2::value_t>::max()),
-            Storage1, Storage2
-        >::type
-    >::type;
-};
+// // prefer dynamic over static storage, choose 
+// // static_storage with larger capacity
+// template <typename Storage1,
+//           typename Storage2>
+// struct select_storage {
+//     using type = typename std::conditional<
+//         (is_dynamic_storage<Storage1>::value ||
+//          is_dynamic_storage<Storage2>::value),
+//         typename std::conditional<
+//             is_dynamic_storage<Storage1>::value,
+//             Storage1, Storage2
+//         >::type,
+//         typename std::conditional<
+//             (std::numeric_limits<typename Storage1::value_t>::max() >
+//              std::numeric_limits<typename Storage2::value_t>::max()),
+//             Storage1, Storage2
+//         >::type
+//     >::type;
+// };
 
 }
 }
diff --git a/include/boost/histogram/dynamic_histogram.hpp b/include/boost/histogram/dynamic_histogram.hpp
index 4af62ea8..d3ca86c8 100644
--- a/include/boost/histogram/dynamic_histogram.hpp
+++ b/include/boost/histogram/dynamic_histogram.hpp
@@ -13,41 +13,37 @@
 #include <boost/mpl/empty.hpp>
 #include <boost/variant.hpp>
 #include <boost/histogram/axis.hpp>
-#include <boost/histogram/static_storage.hpp>
-#include <boost/histogram/dynamic_storage.hpp>
 #include <boost/histogram/utility.hpp>
-#include <boost/histogram/detail/mpl.hpp>
+#include <boost/histogram/detail/meta.hpp>
 #include <boost/histogram/detail/utility.hpp>
 #include <boost/histogram/detail/axis_visitor.hpp>
+#include <boost/histogram/storage/adaptive_storage.hpp>
 #include <cstddef>
-#include <array>
 #include <vector>
 #include <type_traits>
 #include <stdexcept>
 #include <algorithm>
-#include <utility>
 #include <iterator>
 
 namespace boost {
 namespace histogram {
 
-template <typename Storage=dynamic_storage, typename Axes=default_axes>
+template <typename Axes=default_axes, typename Storage=adaptive_storage>
 class dynamic_histogram
 {
   static_assert(!mpl::empty<Axes>::value, "at least one axis required");
 
 public:
-  using axis_t = typename make_variant_over<Axes>::type;
-  using axes_t = std::vector<axis_t>;
-  using value_t = typename Storage::value_t;
-  using variance_t = typename Storage::variance_t;
+  using axis_type = typename make_variant_over<Axes>::type;
+  using axes_type = std::vector<axis_type>;
+  using value_type = typename Storage::value_type;
 
   dynamic_histogram() = default;
 
   template <typename... Axes1>
   explicit
   dynamic_histogram(const Axes1&... axes) :
-    axes_({axis_t(axes)...})
+    axes_({axis_type(axes)...})
   {
     storage_ = Storage(field_count());
   }
@@ -61,31 +57,31 @@ public:
   }
 
   explicit
-  dynamic_histogram(const axes_t& axes) :
+  dynamic_histogram(const axes_type& axes) :
     axes_(axes)
   {
     storage_ = Storage(field_count());
   }
 
   explicit
-  dynamic_histogram(axes_t&& axes) :
+  dynamic_histogram(axes_type&& axes) :
     axes_(std::move(axes))
   {
     storage_ = Storage(field_count());
   }
 
-  template <typename OtherStorage, typename OtherAxes>
-  dynamic_histogram(const dynamic_histogram<OtherStorage, OtherAxes>& other) :
+  template <typename OtherAxes, typename OtherStorage>
+  dynamic_histogram(const dynamic_histogram<OtherAxes, OtherStorage>& other) :
     axes_(other.axes_.begin(), other.axes_.end()), storage_(other.storage_)
   {}
 
-  template <typename OtherStorage, typename OtherAxes>
-  dynamic_histogram(dynamic_histogram<OtherStorage, OtherAxes>&& other) :
+  template <typename OtherAxes, typename OtherStorage>
+  dynamic_histogram(dynamic_histogram<OtherAxes, OtherStorage>&& other) :
     axes_(std::move(other.axes_)), storage_(std::move(other.storage_))
   {}
 
-  template <typename OtherStorage, typename OtherAxes>
-  dynamic_histogram& operator=(const dynamic_histogram<OtherStorage, OtherAxes>& other)
+  template <typename OtherAxes, typename OtherStorage>
+  dynamic_histogram& operator=(const dynamic_histogram<OtherAxes, OtherStorage>& other)
   {
     if (static_cast<const void*>(this) != static_cast<const void*>(&other)) {
       axes_ = other.axes_;
@@ -94,16 +90,16 @@ public:
     return *this;
   }
 
-  template <typename OtherStorage, typename OtherAxes>
-  dynamic_histogram& operator=(dynamic_histogram<OtherStorage, OtherAxes>&& other)
+  template <typename OtherAxes, typename OtherStorage>
+  dynamic_histogram& operator=(dynamic_histogram<OtherAxes, OtherStorage>&& other)
   {
     axes_ = std::move(other.axes_);
     storage_ = std::move(other.storage_);
     return *this;
   }
 
-  template <typename OtherStorage, typename OtherAxes>
-  bool operator==(const dynamic_histogram<OtherStorage, OtherAxes>& other) const
+  template <typename OtherAxes, typename OtherStorage>
+  bool operator==(const dynamic_histogram<OtherAxes, OtherStorage>& other) const
   {
     if (mpl::empty<
           typename detail::intersection<Axes, OtherAxes>::type
@@ -118,8 +114,8 @@ public:
     return true;
   }
 
-  template <typename OtherStorage, typename OtherAxes>
-  dynamic_histogram& operator+=(const dynamic_histogram<OtherStorage, OtherAxes>& other)
+  template <template <class, class> class Histogram, typename OtherAxes, typename OtherStorage>
+  dynamic_histogram& operator+=(const Histogram<OtherAxes, OtherStorage>& other)
   {
     static_assert(!mpl::empty<typename detail::intersection<Axes, OtherAxes>::type>::value,
                   "histograms lack common axes types");
@@ -133,8 +129,8 @@ public:
     return *this;
   }
 
-  template <typename... Vs>
-  void fill(Vs... values)
+  template <typename... Values>
+  void fill(Values... values)
   {
     BOOST_ASSERT_MSG(sizeof...(values) == dim(),
                      "number of arguments does not match histogram dimension");
@@ -163,25 +159,25 @@ public:
     fill(std::begin(values), std::end(values));
   }
 
-  template <typename... Args>
-  void wfill(Args... args)
+  template <typename... Values>
+  void wfill(double w, Values... values)
   {
-    static_assert(std::is_same<Storage, dynamic_storage>::value,
-                  "wfill only supported for dynamic_storage");
-    BOOST_ASSERT_MSG((sizeof...(args) - 1) == dim(),
+    static_assert(std::is_same<Storage, adaptive_storage>::value,
+                  "wfill only supported for adaptive_storage");
+    BOOST_ASSERT_MSG(sizeof...(values) == dim(),
                      "number of arguments does not match histogram dimension");
     detail::linearize_x lin;
-    const double w = windex_impl(lin, args...);
+    index_impl(lin, values...);
     if (lin.stride)
       storage_.increase(lin.out, w);
   }
 
   template <typename Iterator,
             typename = detail::is_iterator<Iterator>>
-  void wfill(Iterator begin, Iterator end, double w)
+  void wfill(double w, Iterator begin, Iterator end)
   {
-    static_assert(std::is_same<Storage, dynamic_storage>::value,
-                  "wfill only supported for dynamic_storage");
+    static_assert(std::is_same<Storage, adaptive_storage>::value,
+                  "wfill only supported for adaptive_storage");
     BOOST_ASSERT_MSG(std::distance(begin, end) == dim(),
                      "iterator range does not match histogram dimension");
     detail::linearize_x lin;
@@ -192,13 +188,13 @@ public:
 
   template <typename Sequence,
             typename = detail::is_sequence<Sequence>>
-  void wfill(const Sequence& values, double w)
+  void wfill(double w, const Sequence& values)
   {
-    wfill(std::begin(values), std::end(values), w);
+    wfill(w, std::begin(values), std::end(values));
   }
 
   template <typename... Indices>
-  value_t value(Indices... indices) const
+  value_type value(Indices... indices) const
   {
     BOOST_ASSERT_MSG(sizeof...(indices) == dim(),
                      "number of arguments does not match histogram dimension");
@@ -211,7 +207,7 @@ public:
 
   template <typename Iterator,
             typename = detail::is_iterator<Iterator>>
-  value_t value(Iterator begin, Iterator end) const
+  value_type value(Iterator begin, Iterator end) const
   {
     BOOST_ASSERT_MSG(std::distance(begin, end) == dim(),
                      "iterator range does not match histogram dimension");
@@ -225,13 +221,13 @@ public:
 
   template <typename Sequence,
             typename = detail::is_sequence<Sequence>>
-  value_t value(const Sequence& indices) const
+  value_type value(const Sequence& indices) const
   {
     return value(std::begin(indices), std::end(indices));
   }
 
   template <typename... Indices>
-  variance_t variance(Indices... indices) const
+  value_type variance(Indices... indices) const
   {
     BOOST_ASSERT_MSG(sizeof...(indices) == dim(),
                      "number of arguments does not match histogram dimension");
@@ -244,7 +240,7 @@ public:
 
   template <typename Iterator,
             typename = detail::is_iterator<Iterator>>
-  variance_t variance(Iterator begin, Iterator end) const
+  value_type variance(Iterator begin, Iterator end) const
   {
     BOOST_ASSERT_MSG(std::distance(begin, end) == dim(),
                      "iterator range does not match histogram dimension");
@@ -257,7 +253,7 @@ public:
 
   template <typename Sequence,
             typename = detail::is_sequence<Sequence>>
-  variance_t variance(const Sequence& indices) const
+  value_type variance(const Sequence& indices) const
   {
     return variance(std::begin(indices), std::end(indices));
   }
@@ -268,12 +264,6 @@ public:
   /// Total number of bins in the histogram (including underflow/overflow)
   std::size_t size() const { return storage_.size(); }
 
-  /// Access to internal data (used by Python bindings)
-  const void* data() const { return storage_.data(); }
-
-  /// Memory used by a bin in bytes
-  unsigned depth() const { return storage_.depth(); }
-
   /// Sum of all counts in the histogram
   double sum() const
   {
@@ -284,20 +274,20 @@ public:
   }
 
   /// Return axis \a i
-  const axis_t& axis(unsigned i = 0) const {
+  const axis_type& axis(unsigned i = 0) const {
     BOOST_ASSERT_MSG(i < dim(), "axis index out of range");
     return axes_[i];
   }
 
   /// Return axis \a i (added for conformity with static_histogram interface)
   template <unsigned N = 0u>
-  const axis_t& axis() const {
+  const axis_type& axis() const {
     BOOST_ASSERT_MSG(N < dim(), "axis index out of range");
     return axes_[N];
   }
 
 private:
-  axes_t axes_;
+  axes_type axes_;
   Storage storage_;
 
   std::size_t field_count() const
@@ -328,20 +318,6 @@ private:
   template <typename Linearize>
   void index_impl(Linearize& lin) const {}
 
-  template <typename Linearize, typename First, typename... Rest>
-  double windex_impl(Linearize& lin, First first, Rest... rest) const
-  {
-    lin.set(first);
-    apply_visitor(lin, axes_[dim() - sizeof...(Rest)]);
-    return windex_impl(lin, rest...);
-  }
-
-  template <typename Linearize, typename Last>
-  double windex_impl(Linearize& lin, Last last) const
-  {
-    return last;
-  }
-
   template <typename Linearize, typename Iterator>
   void iter_args_impl(Linearize& lin,
                       Iterator begin,
@@ -355,38 +331,16 @@ private:
     }
   }
 
-  template <typename OtherStorage, typename OtherAxes>
+  template <typename OtherAxes, typename OtherStorage>
   friend class dynamic_histogram;
 
-  friend struct python_access;
+  friend struct storage_access;
 
-  template <typename Archiv, typename OtherStorage, typename OtherAxes>
-  friend void serialize(Archiv&, dynamic_histogram<OtherStorage, OtherAxes>&, unsigned);
+  template <typename Archiv, typename OtherAxes, typename OtherStorage>
+  friend void serialize(Archiv&, dynamic_histogram<OtherAxes, OtherStorage>&, unsigned);
 };
 
 
-// when adding different histogram types, use a safe return type
-template <typename Storage1,
-          typename Storage2,
-          typename Axes1,
-          typename Axes2>
-inline
-dynamic_histogram<
-  typename detail::select_storage<Storage1, Storage2>::type,
-  typename detail::intersection<Axes1, Axes2>::type
->
-operator+(const dynamic_histogram<Storage1, Axes1>& a,
-          const dynamic_histogram<Storage2, Axes2>& b)
-{
-  dynamic_histogram<
-    typename detail::select_storage<Storage1, Storage2>::type,
-    typename detail::intersection<Axes1, Axes2>::type
-  > tmp = a;
-  tmp += b;
-  return tmp;
-}
-
-
 template <typename... Axes>
 inline
 dynamic_histogram<>
@@ -398,10 +352,10 @@ make_dynamic_histogram(const Axes&... axes)
 
 template <typename Storage, typename... Axes>
 inline
-dynamic_histogram<Storage>
+dynamic_histogram<default_axes, Storage>
 make_dynamic_histogram_with(const Axes&... axes)
 {
-  return dynamic_histogram<Storage>(axes...);
+  return dynamic_histogram<default_axes, Storage>(axes...);
 }
 
 
diff --git a/include/boost/histogram/serialization.hpp b/include/boost/histogram/serialization.hpp
index bb43f715..f5011d67 100644
--- a/include/boost/histogram/serialization.hpp
+++ b/include/boost/histogram/serialization.hpp
@@ -9,8 +9,8 @@
 
 #include <boost/histogram/static_histogram.hpp>
 #include <boost/histogram/dynamic_histogram.hpp>
-#include <boost/histogram/static_storage.hpp>
-#include <boost/histogram/dynamic_storage.hpp>
+#include <boost/histogram/storage/container_storage.hpp>
+#include <boost/histogram/storage/adaptive_storage.hpp>
 #include <boost/histogram/detail/utility.hpp>
 #include <boost/histogram/detail/weight.hpp>
 #include <boost/histogram/detail/tiny_string.hpp>
@@ -50,19 +50,14 @@ inline void serialize(Archive& ar, tiny_string& s, unsigned version)
 
 }
 
-template <class Archive, typename T>
-inline void serialize(Archive& ar, static_storage<T> & store, unsigned version)
+template <class Archive, typename Container>
+inline void serialize(Archive& ar, container_storage<Container> & store, unsigned version)
 {
-  ar & store.size_;
-  if (Archive::is_loading::value) {
-    delete [] store.data_;
-    store.data_ = new T[store.size_];
-  }
-  ar & serialization::make_array(store.data_, store.size_);
+  ar & store.c_;
 }
 
 template <class Archive>
-inline void serialize(Archive& ar, dynamic_storage & store, unsigned version)
+inline void serialize(Archive& ar, adaptive_storage & store, unsigned version)
 {
   auto& b = store.buffer_;
   if (Archive::is_loading::value)
diff --git a/include/boost/histogram/static_histogram.hpp b/include/boost/histogram/static_histogram.hpp
index 4d4f6b53..942cb738 100644
--- a/include/boost/histogram/static_histogram.hpp
+++ b/include/boost/histogram/static_histogram.hpp
@@ -21,25 +21,23 @@
 #include <boost/fusion/container/vector/convert.hpp>
 #include <boost/fusion/include/as_vector.hpp>
 #include <boost/histogram/axis.hpp>
-#include <boost/histogram/static_storage.hpp>
-#include <boost/histogram/dynamic_storage.hpp>
 #include <boost/histogram/detail/utility.hpp>
 #include <boost/histogram/detail/axis_visitor.hpp>
-#include <boost/histogram/detail/mpl.hpp>
+#include <boost/histogram/detail/meta.hpp>
+#include <boost/histogram/storage/adaptive_storage.hpp>
 #include <type_traits>
 
 namespace boost {
 namespace histogram {
 
-template <typename Storage, typename Axes>
+template <typename Axes, typename Storage>
 class static_histogram
 {
   static_assert(!mpl::empty<Axes>::value, "at least one axis required");
 
 public:
-  using axes_t = typename fusion::result_of::as_vector<Axes>::type;
-  using value_t = typename Storage::value_t;
-  using variance_t = typename Storage::variance_t;
+  using axes_type = typename fusion::result_of::as_vector<Axes>::type;
+  using value_type = typename Storage::value_type;
 
   static_histogram() = default;
 
@@ -57,18 +55,18 @@ public:
   static_histogram& operator=(static_histogram&& other) = default;
 
   template <typename OtherStorage>
-  static_histogram(const static_histogram<OtherStorage, Axes>& other) :
+  static_histogram(const static_histogram<Axes, OtherStorage>& other) :
     axes_(other.axes_), storage_(other.storage_)
   {}
 
   template <typename OtherStorage>
-  static_histogram(static_histogram<OtherStorage, Axes>&& other) :
+  static_histogram(static_histogram<Axes, OtherStorage>&& other) :
     axes_(std::move(other.axes_)),
     storage_(std::move(other.storage_))
   {}
 
   template <typename OtherStorage>
-  static_histogram& operator=(const static_histogram<OtherStorage, Axes>& other)
+  static_histogram& operator=(const static_histogram<Axes, OtherStorage>& other)
   {
     if (static_cast<const void*>(this) != static_cast<const void*>(&other)) {
       axes_ = other.axes_;
@@ -78,7 +76,7 @@ public:
   }
 
   template <typename OtherStorage>
-  static_histogram& operator=(static_histogram<OtherStorage, Axes>&& other)
+  static_histogram& operator=(static_histogram<Axes, OtherStorage>&& other)
   {
     axes_ = std::move(other.axes_);
     storage_ = std::move(other.storage_);
@@ -86,7 +84,7 @@ public:
   }
 
   template <typename OtherStorage>
-  bool operator==(const static_histogram<OtherStorage, Axes>& other) const
+  bool operator==(const static_histogram<Axes, OtherStorage>& other) const
   {
     if (!axes_equal_to(other.axes_))
       return false;
@@ -100,7 +98,7 @@ public:
   }
 
   template <typename OtherStorage>
-  static_histogram& operator+=(const static_histogram<OtherStorage, Axes>& other)
+  static_histogram& operator+=(const static_histogram<Axes, OtherStorage>& other)
   {
     if (!axes_equal_to(other.axes_))
       throw std::logic_error("axes of histograms differ");
@@ -108,8 +106,8 @@ public:
     return *this;
   }
 
-  template <typename... Vs>
-  void fill(Vs... values)
+  template <typename... Values>
+  void fill(Values... values)
   {
     static_assert(sizeof...(values) == dim(),
                   "number of arguments does not match histogram dimension");
@@ -138,25 +136,25 @@ public:
     fill(std::begin(values), std::end(values));
   }
 
-  template <typename... Args>
-  void wfill(Args... args)
+  template <typename... Values>
+  void wfill(double w, Values... values)
   {
-    static_assert(std::is_same<Storage, dynamic_storage>::value,
-                  "wfill only supported for dynamic_storage");
-    static_assert(sizeof...(args) == (dim() + 1),
+    static_assert(std::is_same<Storage, adaptive_storage>::value,
+                  "wfill only supported for adaptive_storage");
+    static_assert(sizeof...(values) == dim(),
                   "number of arguments does not match histogram dimension");
     detail::linearize_x lin;
-    const double w = windex_impl(lin, args...);
+    index_impl(lin, values...);
     if (lin.stride)
       storage_.increase(lin.out, w);
   }
 
   template <typename Iterator,
             typename = detail::is_iterator<Iterator>>
-  void wfill(Iterator begin, Iterator end, double w)
+  void wfill(double w, Iterator begin, Iterator end)
   {
-    static_assert(std::is_same<Storage, dynamic_storage>::value,
-                  "wfill only supported for dynamic_storage");
+    static_assert(std::is_same<Storage, adaptive_storage>::value,
+                  "wfill only supported for adaptive_storage");
     BOOST_ASSERT_MSG(std::distance(begin, end) == dim(),
                      "iterator range does not match histogram dimension");
     detail::linearize_x lin;
@@ -167,13 +165,13 @@ public:
 
   template <typename Sequence,
             typename = detail::is_sequence<Sequence>>
-  void wfill(const Sequence& values, double w)
+  void wfill(double w, const Sequence& values)
   {
-    wfill(std::begin(values), std::end(values), w);
+    wfill(w, std::begin(values), std::end(values));
   }
 
   template <typename... Args>
-  value_t value(Args... args) const
+  value_type value(Args... args) const
   {
     static_assert(sizeof...(args) == dim(),
                   "number of arguments does not match histogram dimension");
@@ -186,7 +184,7 @@ public:
 
   template <typename Iterator,
             typename = detail::is_iterator<Iterator>>
-  value_t value(Iterator begin, Iterator end) const
+  value_type value(Iterator begin, Iterator end) const
   {
     BOOST_ASSERT_MSG(std::distance(begin, end) == dim(),
                      "iterator range does not match histogram dimension");
@@ -198,18 +196,18 @@ public:
 
   template <typename Sequence,
             typename = detail::is_sequence<Sequence>>
-  value_t value(const Sequence& indices) const
+  value_type value(const Sequence& indices) const
   {
     return value(std::begin(indices), std::end(indices));
   }
 
-  template <typename... Args>
-  variance_t variance(Args... args) const
+  template <typename... Indices>
+  value_type variance(Indices... indices) const
   {
-    static_assert(sizeof...(args) == dim(),
+    static_assert(sizeof...(indices) == dim(),
                   "number of arguments does not match histogram dimension");
     detail::linearize lin;
-    index_impl(lin, args...);
+    index_impl(lin, indices...);
     if (lin.stride == 0)
       throw std::out_of_range("invalid index");
     return storage_.variance(lin.out);
@@ -217,7 +215,7 @@ public:
 
   template <typename Iterator,
             typename = detail::is_iterator<Iterator>>
-  variance_t variance(Iterator begin, Iterator end) const
+  value_type variance(Iterator begin, Iterator end) const
   {
     BOOST_ASSERT_MSG(std::distance(begin, end) == dim(),
                      "iterator range does not match histogram dimension");
@@ -234,34 +232,28 @@ public:
   /// Total number of bins in the histogram (including underflow/overflow)
   std::size_t size() const { return storage_.size(); }
 
-  /// Access to internal data (used by Python bindings)
-  const void* data() const { return storage_.data(); }
-
-  /// Memory used by a bin in bytes
-  unsigned depth() const { return storage_.depth(); }
-
   /// Sum of all counts in the histogram
   double sum() const
   {
     double result = 0.0;
-    for (decltype(size()) i = 0, n = size(); i < n; ++i)
+    for (std::size_t i = 0, n = size(); i < n; ++i)
       result += storage_.value(i);
     return result;
   }
 
   template <unsigned N = 0>
   typename std::add_const<
-    typename fusion::result_of::value_at_c<axes_t, N>::type
+    typename fusion::result_of::value_at_c<axes_type, N>::type
   >::type&
   axis() const
   {
-    static_assert(N < fusion::result_of::size<axes_t>::value,
+    static_assert(N < fusion::result_of::size<axes_type>::value,
                   "axis index out of range");
     return fusion::at_c<N>(axes_);
   }
 
 private:
-  axes_t axes_;
+  axes_type axes_;
   Storage storage_;
 
   struct field_counter {
@@ -282,7 +274,7 @@ private:
     return false;
   }
 
-  bool axes_equal_to(const axes_t& other_axes) const {
+  bool axes_equal_to(const axes_type& other_axes) const {
     return axes_ == other_axes;
   }
 
@@ -297,23 +289,9 @@ private:
   template <typename Linearize>
   void index_impl(Linearize&) const {} // stop recursion
 
-  template <typename Linearize, typename First, typename... Rest>
-  double windex_impl(Linearize& lin, First first, Rest... rest) const
-  {
-    lin.set(first);
-    lin(fusion::at_c<(dim() - sizeof...(Rest))>(axes_));
-    return windex_impl(lin, rest...);
-  }
-
-  template <typename Linearize, typename Last>
-  double windex_impl(Linearize& lin, Last last) const
-  {
-    return last;
-  }
-
   template <typename Linearize, typename Iterator, unsigned N=0>
   struct iter_args_impl {
-    static void apply(Linearize& lin, const axes_t& axes, Iterator iter) {
+    static void apply(Linearize& lin, const axes_type& axes, Iterator iter) {
       lin.set(*iter);
       lin(fusion::at_c<N>(axes));
       iter_args_impl<Linearize, Iterator, N+1>::apply(lin, axes, ++iter);
@@ -322,10 +300,10 @@ private:
 
   template <typename Linearize, typename Iterator>
   struct iter_args_impl<Linearize, Iterator, dim()> {
-    static void apply(Linearize&, const axes_t&, Iterator) {}
+    static void apply(Linearize&, const axes_type&, Iterator) {}
   };
 
-  template <typename OtherStorage, typename OtherAxes>
+  template <typename OtherAxes, typename OtherStorage>
   friend class static_histogram;
 
   template <class Archive, class OtherStorage, class OtherAxes>
@@ -333,42 +311,23 @@ private:
 };
 
 
-// when adding different histogram types, use a safe return type
-template <typename Storage1,
-          typename Storage2,
-          typename Axes>
-inline
-static_histogram<
-  typename detail::select_storage<Storage1, Storage2>::type, Axes
->
-operator+(const static_histogram<Storage1, Axes>& a,
-          const static_histogram<Storage2, Axes>& b)
-{
-  static_histogram<
-    typename detail::select_storage<Storage1, Storage2>::type, Axes
-  > tmp = a;
-  tmp += b;
-  return tmp;
-}
-
-
 /// default static type factory
 template <typename... Axes>
 inline
-static_histogram<dynamic_storage, mpl::vector<Axes...>>
+static_histogram<mpl::vector<Axes...>, adaptive_storage>
 make_static_histogram(const Axes&... axes)
 {
-  return static_histogram<dynamic_storage, mpl::vector<Axes...>>(axes...);
+  return static_histogram<mpl::vector<Axes...>, adaptive_storage>(axes...);
 }
 
 
 /// static type factory with variable storage type
 template <typename Storage, typename... Axes>
 inline
-static_histogram<Storage, mpl::vector<Axes...>>
+static_histogram<mpl::vector<Axes...>, Storage>
 make_static_histogram_with(const Axes&... axes)
 {
-  return static_histogram<Storage, mpl::vector<Axes...>>(axes...);
+  return static_histogram<mpl::vector<Axes...>, Storage>(axes...);
 }
 
 }
diff --git a/include/boost/histogram/static_storage.hpp b/include/boost/histogram/static_storage.hpp
deleted file mode 100644
index 9a77cdb9..00000000
--- a/include/boost/histogram/static_storage.hpp
+++ /dev/null
@@ -1,136 +0,0 @@
-// Copyright 2015-2016 Hans Dembinski
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt
-// or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef _BOOST_HISTOGRAM_STATIC_STORAGE_HPP_
-#define _BOOST_HISTOGRAM_STATIC_STORAGE_HPP_
-
-#include <algorithm>
-
-namespace boost {
-namespace histogram {
-
-  template <typename T>
-  class static_storage {
-  public:
-    using value_t = T;
-    using variance_t = T;
-
-    static_storage() : size_(0), data_(nullptr) {}
-
-    explicit static_storage(std::size_t n) :
-      size_(n)
-    {
-      alloc();
-      std::fill(data_, data_ + size_, T(0));
-    }
-
-    static_storage(const static_storage<T>& other) :
-      size_(other.size_)
-    {
-      alloc();
-      std::copy(other.data_, other.data_ + size_, data_);
-    }
-
-    template <typename OtherStorage,
-              typename = typename OtherStorage::value_t>
-    static_storage(const OtherStorage& other) :
-      size_(other.size())
-    {
-      alloc();
-      for (decltype(size_) i = 0; i < size_; ++i)
-        data_[i] = other.value(i);
-    }
-
-    template <typename OtherStorage,
-              typename = typename OtherStorage::value_t>
-    static_storage& operator=(const OtherStorage& other)
-    {
-      if (static_cast<const void*>(this) != static_cast<const void*>(&other)) {
-        delete [] data_;
-        size_ = other.size();
-        alloc();
-        for (decltype(size_) i = 0; i < size_; ++i)
-          data_[i] = other.value(i);        
-      }
-      return *this;
-    }
-
-    static_storage(static_storage<T>&& other) :
-      static_storage()
-    {
-      std::swap(size_, other.size_);
-      std::swap(data_, other.data_);
-    }
-
-    static_storage& operator=(static_storage<T>&& other)
-    {
-      if (this != &other) {
-        delete [] data_;
-        size_ = other.size_;
-        data_ = other.data_;
-        other.size_ = 0;
-        other.data_ = nullptr;
-      }
-      return *this;
-    }
-
-    template <typename OtherStorage,
-              typename = typename OtherStorage::value_t>
-    static_storage(OtherStorage&& other) :
-      static_storage(static_cast<const OtherStorage&>(other))
-    {
-      other = OtherStorage();
-    }
-
-    template <typename OtherStorage,
-              typename = typename OtherStorage::value_t>
-    static_storage& operator=(OtherStorage&& other)
-    {
-      delete [] data_;
-      size_ = other.size();
-      alloc();
-      for (decltype(size_) i = 0, n = size(); i < n; ++i)
-        data_[i] = other.value(i);        
-      other = OtherStorage();
-      return *this;
-    }
-
-    ~static_storage() { delete [] data_; }
-
-    std::size_t size() const { return size_; }
-    constexpr unsigned depth() const { return sizeof(T); }
-    const T* data() const { return data_; }
-    void increase(std::size_t i) { ++(data_[i]); }
-    value_t value(std::size_t i) const { return data_[i]; }
-    variance_t variance(std::size_t i) const { return data_[i]; }
-
-    template <typename OtherStorage,
-              typename = typename OtherStorage::value_t>
-    void operator+=(const OtherStorage& other)
-    {
-      for (decltype(size_) i = 0, n = size(); i < n; ++i)
-        data_[i] += other.value(i);
-    }
-
-  private:
-    std::size_t size_;
-    T* data_;
-
-    inline void alloc() {
-      if (size_ == 0)
-        data_ = nullptr;
-      else
-        data_ = new T[size_];
-    }
-
-    template <typename Archive, typename U>
-    friend void serialize(Archive&, static_storage<U>&, unsigned);
-  };
-
-}
-}
-
-#endif
diff --git a/include/boost/histogram/dynamic_storage.hpp b/include/boost/histogram/storage/adaptive_storage.hpp
similarity index 75%
rename from include/boost/histogram/dynamic_storage.hpp
rename to include/boost/histogram/storage/adaptive_storage.hpp
index 95ed5dd5..f78bb6f0 100644
--- a/include/boost/histogram/dynamic_storage.hpp
+++ b/include/boost/histogram/storage/adaptive_storage.hpp
@@ -4,11 +4,11 @@
 // (See accompanying file LICENSE_1_0.txt
 // or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef _BOOST_HISTOGRAM_DYNAMIC_STORAGE_HPP_
-#define _BOOST_HISTOGRAM_DYNAMIC_STORAGE_HPP_
+#ifndef _BOOST_HISTOGRAM_STORAGE_ADAPTIVE_HPP_
+#define _BOOST_HISTOGRAM_STORAGE_ADAPTIVE_HPP_
 
 #include <boost/histogram/detail/weight.hpp>
-#include <boost/histogram/detail/mpl.hpp>
+#include <boost/histogram/detail/meta.hpp>
 #include <boost/assert.hpp>
 #include <boost/mpl/map.hpp>
 #include <boost/mpl/pair.hpp>
@@ -94,7 +94,7 @@ namespace detail {
   template <typename Buffer, typename TO>
   struct add_impl {
     static void apply(Buffer& b, const Buffer& o) {
-      for (decltype(b.size_) i = 0; i < b.size_; ++i) {
+      for (std::size_t i = 0; i < b.size_; ++i) {
         const auto oi = o.template at<TO>(i);
         switch (b.type_.id_) {
           case -1: b.template at<weight_t>(i) += oi; break;
@@ -113,7 +113,7 @@ namespace detail {
   struct add_impl<Buffer, weight_t> {
     static void apply(Buffer& b, const Buffer& o) {
       b.wconvert();
-      for (decltype(b.size_) i = 0; i < b.size_; ++i)
+      for (std::size_t i = 0; i < b.size_; ++i)
         b.template at<weight_t>(i) += o.template at<weight_t>(i);
     }
   };
@@ -122,8 +122,7 @@ namespace detail {
   struct buffer
   {
     explicit buffer(std::size_t s = 0) :
-      size_(s),
-      ptr_(nullptr)
+      size_(s), ptr_(nullptr)
     {}
 
     buffer(const buffer& o) :
@@ -293,67 +292,85 @@ namespace detail {
 
 } // NS detail
 
-class dynamic_storage
+class adaptive_storage
 {
 public:
-  using value_t = double;
-  using variance_t = double;
+  using value_type = double;
 
   explicit
-  dynamic_storage(std::size_t s) :
+  adaptive_storage(std::size_t s) :
     buffer_(s)
   {}
 
-  dynamic_storage() = default;
-  dynamic_storage(const dynamic_storage&) = default;
-  dynamic_storage& operator=(const dynamic_storage&) = default;
-  dynamic_storage(dynamic_storage&&) = default;
-  dynamic_storage& operator=(dynamic_storage&&) = default;
+  adaptive_storage() = default;
+  adaptive_storage(const adaptive_storage&) = default;
+  adaptive_storage& operator=(const adaptive_storage&) = default;
+  adaptive_storage(adaptive_storage&&) = default;
+  adaptive_storage& operator=(adaptive_storage&&) = default;
 
-  template <typename T,
-            template <typename> class Storage,
-            typename = detail::is_standard_integral<T>>
-  dynamic_storage(const Storage<T>& o) :
+  template <typename OtherStorage,
+            typename = detail::is_standard_integral<typename OtherStorage::value_type>>
+  adaptive_storage(const OtherStorage& o) :
     buffer_(o.size())
   {
+    using T = typename OtherStorage::value_type;
     using U = detail::storage_type<T>;
     buffer_.create<U>();
-    std::copy(o.data(), o.data() + o.size(), &buffer_.at<U>(0));
+    for (std::size_t i = 0; i < buffer_.size_; ++i)
+      buffer_.at<U>(i) = o.value(i);
   }
 
-  template <typename T,
-            template <typename> class Storage,
-            typename = detail::is_standard_integral<T>>
-  dynamic_storage& operator=(const Storage<T>& o)
+  template <typename OtherStorage,
+            typename = detail::is_standard_integral<typename OtherStorage::value_type>>
+  adaptive_storage& operator=(const OtherStorage& o)
   {
+    using T = typename OtherStorage::value_type;
     buffer_.destroy_any();
     buffer_.size_ = o.size();
     using U = detail::storage_type<T>;
     buffer_.create<U>();
-    std::copy(o.data(), o.data() + o.size(), &buffer_.at<U>(0));
+    for (std::size_t i = 0; i < buffer_.size_; ++i)
+      buffer_.at<U>(i) = o.value(i);
     return *this;
   }
 
   std::size_t size() const { return buffer_.size_; }
-  unsigned depth() const { return buffer_.type_.depth_; }
-  const void* data() const { return buffer_.ptr_; }
   void increase(std::size_t i);
   void increase(std::size_t i, double w);
-  value_t value(std::size_t i) const;
-  variance_t variance(std::size_t i) const;
-  dynamic_storage& operator+=(const dynamic_storage&);
+  value_type value(std::size_t i) const;
+  value_type variance(std::size_t i) const;
+  adaptive_storage& operator+=(const adaptive_storage&);
+  template <typename OtherStorage,
+            typename = detail::is_storage<OtherStorage>>
+  void operator+=(const OtherStorage& other)
+  {
+    using B = decltype(buffer_);
+    using TO = typename OtherStorage::value_type;
+    for (std::size_t i = 0; i < buffer_.size_; ++i) {
+      const auto oi = other.value(i);
+      switch (buffer_.type_.id_) {
+        case -1: buffer_.template at<detail::weight_t>(i) += oi; break;
+        case 0: buffer_.template initialize<uint8_t>(); // fall through
+        case 1: detail::add_one_impl<B, uint8_t, TO>::apply(buffer_, i, oi); break;
+        case 2: detail::add_one_impl<B, uint16_t, TO>::apply(buffer_, i, oi); break;
+        case 3: detail::add_one_impl<B, uint32_t, TO>::apply(buffer_, i, oi); break;
+        case 4: detail::add_one_impl<B, uint64_t, TO>::apply(buffer_, i, oi); break;
+        case 5: detail::add_one_impl<B, detail::mp_int, TO>::apply(buffer_, i, oi); break;
+      }
+    }
+  }
 
 private:
   detail::buffer<std::allocator> buffer_;
 
-  friend struct python_access;
+  friend struct storage_access;
 
   template <class Archive>
-  friend void serialize(Archive&, dynamic_storage&, unsigned);
+  friend void serialize(Archive&, adaptive_storage&, unsigned);
 };
 
 inline
-void dynamic_storage::increase(std::size_t i)
+void adaptive_storage::increase(std::size_t i)
 {
   switch (buffer_.type_.id_) {
     case -1: ++(buffer_.at<detail::weight_t>(i)); break;
@@ -367,29 +384,30 @@ void dynamic_storage::increase(std::size_t i)
 }
 
 inline
-void dynamic_storage::increase(std::size_t i, double w)
+void adaptive_storage::increase(std::size_t i, double w)
 {
   buffer_.wconvert();
   buffer_.at<detail::weight_t>(i).add_weight(w);
 }
 
 inline
-dynamic_storage& dynamic_storage::operator+=(const dynamic_storage& o)
+adaptive_storage& adaptive_storage::operator+=(const adaptive_storage& o)
 {
+  using B = decltype(buffer_);
   switch (o.buffer_.type_.id_) {
-    case -1: detail::add_impl<decltype(buffer_), detail::weight_t>::apply(buffer_, o.buffer_); break;
+    case -1: detail::add_impl<B, detail::weight_t>::apply(buffer_, o.buffer_); break;
     case 0: break;
-    case 1: detail::add_impl<decltype(buffer_), uint8_t>::apply(buffer_, o.buffer_); break;
-    case 2: detail::add_impl<decltype(buffer_), uint16_t>::apply(buffer_, o.buffer_); break;
-    case 3: detail::add_impl<decltype(buffer_), uint32_t>::apply(buffer_, o.buffer_); break;
-    case 4: detail::add_impl<decltype(buffer_), uint64_t>::apply(buffer_, o.buffer_); break;
-    case 5: detail::add_impl<decltype(buffer_), detail::mp_int>::apply(buffer_, o.buffer_); break;
+    case 1: detail::add_impl<B, uint8_t>::apply(buffer_, o.buffer_); break;
+    case 2: detail::add_impl<B, uint16_t>::apply(buffer_, o.buffer_); break;
+    case 3: detail::add_impl<B, uint32_t>::apply(buffer_, o.buffer_); break;
+    case 4: detail::add_impl<B, uint64_t>::apply(buffer_, o.buffer_); break;
+    case 5: detail::add_impl<B, detail::mp_int>::apply(buffer_, o.buffer_); break;
   }
   return *this;
 }
 
 inline
-dynamic_storage::value_t dynamic_storage::value(std::size_t i) const
+adaptive_storage::value_type adaptive_storage::value(std::size_t i) const
 {
   switch (buffer_.type_.id_) {
     case -1: return buffer_.at<detail::weight_t>(i).w;
@@ -404,7 +422,7 @@ dynamic_storage::value_t dynamic_storage::value(std::size_t i) const
 }
 
 inline
-dynamic_storage::variance_t dynamic_storage::variance(std::size_t i) const
+adaptive_storage::value_type adaptive_storage::variance(std::size_t i) const
 {
   switch (buffer_.type_.id_) {
     case -1: return buffer_.at<detail::weight_t>(i).w2;
@@ -418,7 +436,7 @@ dynamic_storage::variance_t dynamic_storage::variance(std::size_t i) const
   return 0.0;
 }
 
-}
-}
+} // NS histogram
+} // NS boost
 
 #endif
diff --git a/include/boost/histogram/storage/container_storage.hpp b/include/boost/histogram/storage/container_storage.hpp
new file mode 100644
index 00000000..34300ff5
--- /dev/null
+++ b/include/boost/histogram/storage/container_storage.hpp
@@ -0,0 +1,92 @@
+// Copyright 2015-2016 Hans Dembinski
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef _BOOST_HISTOGRAM_STORAGE_CONTAINER_HPP_
+#define _BOOST_HISTOGRAM_STORAGE_CONTAINER_HPP_
+
+#include <algorithm>
+#include <cstddef>
+
+namespace boost {
+namespace histogram {
+
+namespace detail {
+  template <typename Container>
+  void init(Container& c, unsigned s) {
+    if (c.size() != s) {
+      c = Container(s, typename Container::value_type(0));
+    } else {
+      std::fill(c.begin(), c.end(), typename Container::value_type(0));      
+    }
+  }
+
+  // template signature of both std::array and boost::array
+  template <template <class, std::size_t> class Array, typename T, std::size_t N>
+  void init(Array<T, N>& c, unsigned) {
+    std::fill(c.begin(), c.end(), typename Array<T, N>::value_type(0));
+  }
+}
+
+template <typename Container>
+class container_storage {
+public:
+  using value_type = typename Container::value_type;
+
+  container_storage() : c_() {}
+
+  explicit container_storage(std::size_t s)
+  {
+    detail::init(c_, s);
+  }
+
+  container_storage(const container_storage&) = default;
+  container_storage& operator=(const container_storage&) = default;
+  container_storage(container_storage&&) = default;
+  container_storage& operator=(container_storage&&) = default;
+
+  template <typename OtherStorage,
+            typename = detail::is_storage<OtherStorage>>
+  container_storage(const OtherStorage& other)
+  {
+    detail::init(c_, other.size());
+    for (std::size_t i = 0; i < c_.size(); ++i)
+      c_[i] = other.value(i);
+  }
+
+  template <typename OtherStorage,
+            typename = detail::is_storage<OtherStorage>>
+  container_storage& operator=(const OtherStorage& other)
+  {
+    detail::init(c_, other.size());
+    for (std::size_t i = 0; i < c_.size(); ++i)
+      c_[i] = other.value(i);
+    return *this;
+  }
+
+  std::size_t size() const { return c_.size(); }
+  void increase(std::size_t i) { ++(c_[i]); }
+  value_type value(std::size_t i) const { return c_[i]; }
+  value_type variance(std::size_t i) const { return c_[i]; }
+
+  template <typename OtherStorage,
+            typename = detail::is_storage<OtherStorage>>
+  void operator+=(const OtherStorage& other)
+  {
+    for (std::size_t i = 0; i < c_.size(); ++i)
+      c_[i] += other.value(i);
+  }
+
+private:
+  Container c_;
+
+  template <typename Archive, typename C>
+  friend void serialize(Archive&, container_storage<C>&, unsigned);
+};
+
+} // NS histogram
+} // NS boost
+
+#endif
diff --git a/src/python/histogram.cpp b/src/python/histogram.cpp
index 4cc8210b..0239ee5f 100644
--- a/src/python/histogram.cpp
+++ b/src/python/histogram.cpp
@@ -53,7 +53,7 @@ histogram_init(python::tuple args, python::dict kwargs) {
   }
 
   // normal constructor
-  dynamic_histogram<>::axes_t axes;
+  dynamic_histogram<>::axes_type axes;
   for (unsigned i = 1, n = len(args); i < n; ++i) {
     object pa = args[i];
     extract<regular_axis> er(pa);
@@ -143,7 +143,7 @@ histogram_fill(python::tuple args, python::dict kwargs) {
           for (unsigned i = 0; i < dims[0]; ++i) {
             double* v = reinterpret_cast<double*>(PyArray_GETPTR1(a, i) );
             double* w = reinterpret_cast<double*>(PyArray_GETPTR1(aw, i));
-            self.wfill(v, v+self.dim(), *w);
+            self.wfill(*w, v, v+self.dim());
           }
 
           Py_DECREF(aw);
@@ -179,7 +179,7 @@ histogram_fill(python::tuple args, python::dict kwargs) {
 
   } else {
     const double w = extract<double>(ow);
-    self.wfill(v, v+self.dim(), w);
+    self.wfill(w, v, v+self.dim());
   }
 
   return object();
@@ -229,7 +229,7 @@ histogram_variance(python::tuple args, python::dict kwargs) {
   return object(self.variance(idx + 0, idx + self.dim()));
 }
 
-struct python_access {
+struct storage_access {
   static
   python::dict
   array_interface(dynamic_histogram<>& self) {
@@ -272,7 +272,7 @@ void register_histogram()
   docstring_options dopt(true, true, false);
 
   // used to pass arguments from raw python init to specialized C++ constructor
-  class_<dynamic_histogram<>::axes_t>("axes_t", no_init);
+  class_<dynamic_histogram<>::axes_type>("axes", no_init);
 
   class_<dynamic_histogram<>, boost::shared_ptr<dynamic_histogram<>>>("histogram",
     "N-dimensional histogram for real-valued data.",
@@ -282,9 +282,9 @@ void register_histogram()
        "\nPass one or more axis objects to define"
        "\nthe dimensions of the dynamic_histogram<>.")
     // shadowed C++ ctors
-    .def(init<const dynamic_histogram<>::axes_t&>())
+    .def(init<const dynamic_histogram<>::axes_type&>())
     .add_property("__array_interface__",
-        &python_access::array_interface)
+        &storage_access::array_interface)
     .add_property("dim", &dynamic_histogram<>::dim,
        "dimensions of the histogram (number of axes)")
     .def("axis", histogram_axis,
@@ -301,7 +301,6 @@ void register_histogram()
        "\nbe a 2d-array of shape (m, n), where m is"
        "\nthe number of tuples, and optionally"
        "\nanother a second 1d-array w of shape (n,).")
-    .add_property("depth", &dynamic_histogram<>::depth)
     .add_property("sum", &dynamic_histogram<>::sum)
     .def("value", raw_function(histogram_value),
        ":param int args: indices of the bin"
@@ -311,10 +310,9 @@ void register_histogram()
        "\n:return: variance estimate for the bin")
     .def(self == self)
     .def(self += self)
-    .def(self + self)
     .def_pickle(serialization_suite<dynamic_histogram<>>())
     ;
 }
 
-}
-}
+} // NS histogram
+} // NS boost
diff --git a/test/dynamic_storage_test.cpp b/test/adaptive_storage_test.cpp
similarity index 51%
rename from test/dynamic_storage_test.cpp
rename to test/adaptive_storage_test.cpp
index 90d4d63d..abf66684 100644
--- a/test/dynamic_storage_test.cpp
+++ b/test/adaptive_storage_test.cpp
@@ -4,16 +4,14 @@
 // (See accompanying file LICENSE_1_0.txt
 // or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#define BOOST_TEST_MODULE dynamic_storage_test
+#define BOOST_TEST_MODULE adaptive_storage_test
 #include <boost/test/unit_test.hpp>
 #include <boost/test/test_tools.hpp>
-#include <boost/histogram/dynamic_storage.hpp>
-#include <boost/histogram/static_storage.hpp>
-#include <boost/histogram/utility.hpp>
+#include <boost/histogram/storage/adaptive_storage.hpp>
+#include <boost/histogram/storage/container_storage.hpp>
 #include <boost/histogram/detail/utility.hpp>
-#include <sstream>
-#include <string>
 #include <limits>
+#include <tuple>
 using namespace boost::histogram;
 
 template <typename Storage1, typename Storage2>
@@ -21,12 +19,34 @@ bool operator==(const Storage1& a, const Storage2& b)
 {
     if (a.size() != b.size())
         return false;
-    return boost::histogram::detail::storage_content_equal(a, b);
+    return detail::storage_content_equal(a, b);
+}
+
+namespace boost {
+namespace histogram {
+
+struct storage_access {
+    template <typename T>
+    static std::tuple<adaptive_storage, double>
+    max_minus_one() {
+        const auto tmax = std::numeric_limits<T>::max();
+        adaptive_storage s(1);
+        s.increase(0);
+        while (s.value(0) < 0.1 * tmax)
+            s += s;
+        static_cast<T*>(s.buffer_.ptr_)[0] = tmax - 1;
+        const double v = tmax - 1;
+        BOOST_CHECK_EQUAL(s.value(0), v);
+        return std::tie(s, v);
+    }
+};
+
+}
 }
 
 BOOST_AUTO_TEST_CASE(equal_operator)
 {
-    dynamic_storage a(1), b(1), c(1), d(2);
+    adaptive_storage a(1), b(1), c(1), d(2);
     a.increase(0);
     b.increase(0);
     c.increase(0);
@@ -39,53 +59,47 @@ BOOST_AUTO_TEST_CASE(equal_operator)
 }
 
 template <typename T>
-void dynamic_storage_increase_and_grow_impl()
+void increase_and_grow_impl()
 {
-    dynamic_storage n(1);
-    BOOST_CHECK_EQUAL(n.value(0), 0.0);
+    adaptive_storage s; double v;
+    std::tie(s, v) = storage_access::max_minus_one<T>();
+
+    auto n = s;
     n.increase(0);
-    while (n.depth() != sizeof(T))
-        n += n;
-    const auto tmax = std::numeric_limits<T>::max();
-    void* buf = const_cast<void*>(n.data());
-    static_cast<T*>(buf)[0] = tmax - 1;
+    n.increase(0);
+
     auto n2 = n;
-    BOOST_CHECK_EQUAL(n.value(0), double(tmax - 1));
-    BOOST_CHECK_EQUAL(n2.value(0), double(tmax - 1));
-    n.increase(0);
-    n.increase(0);
-    dynamic_storage x(1);
+    adaptive_storage x(1);
     x.increase(0);
     n2 += x;
     n2 += x;
-    double v = tmax;
+
     ++v;
     BOOST_CHECK_EQUAL(n.value(0), v);
     BOOST_CHECK_EQUAL(n2.value(0), v);
 }
 
-BOOST_AUTO_TEST_CASE(dynamic_storage_increase_and_grow)
+BOOST_AUTO_TEST_CASE(increase_and_grow)
 {
-    dynamic_storage_increase_and_grow_impl<uint8_t>();
-    dynamic_storage_increase_and_grow_impl<uint16_t>();
-    dynamic_storage_increase_and_grow_impl<uint32_t>();
-    dynamic_storage_increase_and_grow_impl<uint64_t>();
+    increase_and_grow_impl<uint8_t>();
+    increase_and_grow_impl<uint16_t>();
+    increase_and_grow_impl<uint32_t>();
+    increase_and_grow_impl<uint64_t>();
 }
 
-BOOST_AUTO_TEST_CASE(dynamic_storage_add_and_grow)
+BOOST_AUTO_TEST_CASE(add_and_grow)
 {
-    dynamic_storage a(1);
+    adaptive_storage a(1);
     a.increase(0);
     double x = 1.0;
-    dynamic_storage y(1);
-    BOOST_CHECK_EQUAL(y.depth(), 0);
+    adaptive_storage y(1);
     BOOST_CHECK_EQUAL(y.value(0), 0.0);
     a += y;
     BOOST_CHECK_EQUAL(a.value(0), x);
     for (unsigned i = 0; i < 80; ++i) {
         a += a;
         x += x;
-        dynamic_storage b(1);
+        adaptive_storage b(1);
         b += a;
         BOOST_CHECK_EQUAL(a.value(0), x);
         BOOST_CHECK_EQUAL(a.variance(0), x);
@@ -94,7 +108,7 @@ BOOST_AUTO_TEST_CASE(dynamic_storage_add_and_grow)
         b.increase(0, 0.0);
         BOOST_CHECK_EQUAL(b.value(0), x);
         BOOST_CHECK_EQUAL(b.variance(0), x);
-        dynamic_storage c(1);
+        adaptive_storage c(1);
         c.increase(0, 0.0);
         c += a;
         BOOST_CHECK_EQUAL(c.value(0), x);
@@ -102,9 +116,9 @@ BOOST_AUTO_TEST_CASE(dynamic_storage_add_and_grow)
     }
 }
 
-BOOST_AUTO_TEST_CASE(dynamic_storage_equality)
+BOOST_AUTO_TEST_CASE(equality)
 {
-    dynamic_storage a(1), b(1), c(1);
+    adaptive_storage a(2), b(2), c(2);
     BOOST_CHECK(a == b);
     a.increase(0);
     BOOST_CHECK(!(a == b));
@@ -113,39 +127,36 @@ BOOST_AUTO_TEST_CASE(dynamic_storage_equality)
 }
 
 template <typename T>
-void convert_static_storage_impl() {
-    dynamic_storage a(2), b(2);
-    static_storage<T> s(2);
+void convert_container_storage_impl() {
+    adaptive_storage a(2), b(2), c(2);
+    container_storage<std::vector<T>> s(2);
     a.increase(0);
-    b.increase(0, 1.0);
+    c.increase(0, 1.0);
     s.increase(0);
     for (unsigned i = 0; i < (8 * sizeof(T) - 1); ++i)
         s += s;
     a = s;
     b = s;
+    c = s;
     BOOST_CHECK(a == s);
-    BOOST_CHECK(s == a);
     BOOST_CHECK(b == s);
-    BOOST_CHECK(s == b);
-    a = dynamic_storage(2);
-    b = dynamic_storage(2);
+    BOOST_CHECK(c == s);
+    a = adaptive_storage(2);
+    b = adaptive_storage(2);
     BOOST_CHECK(a == b);
     a += s;
     BOOST_CHECK(a == s);
-    BOOST_CHECK(s == a);
-    dynamic_storage c(s);
-    BOOST_CHECK(c == s);
-    BOOST_CHECK(s == c);
-    dynamic_storage d;
-    d = std::move(s); // cannot move, uses copy
+    adaptive_storage d(s);
     BOOST_CHECK(d == s);
-    BOOST_CHECK(s == d);
+    adaptive_storage e;
+    e = s;
+    BOOST_CHECK(e == s);
 }
 
-BOOST_AUTO_TEST_CASE(convert_static_storage)
+BOOST_AUTO_TEST_CASE(convert_container_storage)
 {
-    convert_static_storage_impl<uint8_t>();
-    convert_static_storage_impl<uint16_t>();
-    convert_static_storage_impl<uint32_t>();
-    convert_static_storage_impl<uint64_t>();
+    convert_container_storage_impl<uint8_t>();
+    convert_container_storage_impl<uint16_t>();
+    convert_container_storage_impl<uint32_t>();
+    convert_container_storage_impl<uint64_t>();
 }
diff --git a/test/check/speed_cpp.cpp b/test/check/speed_cpp.cpp
index af802e8e..3710c49b 100644
--- a/test/check/speed_cpp.cpp
+++ b/test/check/speed_cpp.cpp
@@ -6,6 +6,8 @@
 
 #include <boost/histogram/static_histogram.hpp>
 #include <boost/histogram/dynamic_histogram.hpp>
+#include <boost/histogram/storage/container_storage.hpp>
+#include <boost/histogram/storage/adaptive_storage.hpp>
 #include <boost/histogram/axis.hpp>
 
 #include <random>
@@ -113,27 +115,29 @@ int main() {
 #if HISTOGRAM_TYPE == 1
       compare_1d<
         static_histogram<
-          static_storage<int>,
-          mpl::vector<regular_axis>
+          mpl::vector<regular_axis>,
+          container_storage<std::vector<int>>
         >
       >(12000000, itype)
 #elif HISTOGRAM_TYPE == 2
       compare_1d<
         static_histogram<
-          dynamic_storage,
-          mpl::vector<regular_axis>
+          mpl::vector<regular_axis>,
+          adaptive_storage
         >
       >(12000000, itype)
 #elif HISTOGRAM_TYPE == 3
       compare_1d<
         dynamic_histogram<
-          static_storage<int>
+          default_axes,
+          container_storage<std::vector<int>>
         >
       >(12000000, itype)
 #elif HISTOGRAM_TYPE == 4
       compare_1d<
         dynamic_histogram<
-          dynamic_storage
+          default_axes,
+          adaptive_storage
         >
       >(12000000, itype)
 #endif
@@ -144,27 +148,29 @@ int main() {
 #if HISTOGRAM_TYPE == 1
       compare_3d<
         static_histogram<
-          static_storage<int>,
-          mpl::vector<regular_axis, regular_axis, regular_axis>
+          mpl::vector<regular_axis, regular_axis, regular_axis>,
+          container_storage<std::vector<int>>
         >
       >(4000000, itype)
 #elif HISTOGRAM_TYPE == 2
       compare_3d<
         static_histogram<
-          dynamic_storage,
-          mpl::vector<regular_axis, regular_axis, regular_axis>
+          mpl::vector<regular_axis, regular_axis, regular_axis>,
+          adaptive_storage
         >
       >(4000000, itype)
 #elif HISTOGRAM_TYPE == 3
       compare_3d<
         dynamic_histogram<
-          static_storage<int>
+          default_axes,
+          container_storage<std::vector<int>>
         >
       >(4000000, itype)
 #elif HISTOGRAM_TYPE == 4
       compare_3d<
         dynamic_histogram<
-          dynamic_storage
+          default_axes,
+          adaptive_storage
         >
       >(4000000, itype)
 #endif
@@ -175,29 +181,31 @@ int main() {
 #if HISTOGRAM_TYPE == 1
       compare_6d<
         static_histogram<
-          static_storage<int>,
           mpl::vector<regular_axis, regular_axis, regular_axis,
-                      regular_axis, regular_axis, regular_axis>
+                      regular_axis, regular_axis, regular_axis>,
+          container_storage<std::vector<int>>
         >
       >(2000000, itype)
 #elif HISTOGRAM_TYPE == 2
       compare_6d<
         static_histogram<
-          dynamic_storage,
           mpl::vector<regular_axis, regular_axis, regular_axis,
-                      regular_axis, regular_axis, regular_axis>
+                      regular_axis, regular_axis, regular_axis>,
+          adaptive_storage
         >
       >(2000000, itype)
 #elif HISTOGRAM_TYPE == 3
       compare_6d<
         dynamic_histogram<
-          static_storage<int>
+          default_axes,
+          container_storage<std::vector<int>>
         >
       >(2000000, itype)
 #elif HISTOGRAM_TYPE == 4
       compare_6d<
         dynamic_histogram<
-          dynamic_storage
+          default_axes,
+          adaptive_storage
         >
       >(2000000, itype)
 #endif
diff --git a/test/container_storage_test.cpp b/test/container_storage_test.cpp
new file mode 100644
index 00000000..91e37e14
--- /dev/null
+++ b/test/container_storage_test.cpp
@@ -0,0 +1,121 @@
+// Copyright 2015-2016 Hans Dembinski
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#define BOOST_TEST_MODULE container_storage_test
+#include <boost/test/unit_test.hpp>
+#include <boost/test/test_tools.hpp>
+#include <boost/histogram/storage/adaptive_storage.hpp>
+#include <boost/histogram/storage/container_storage.hpp>
+#include <boost/histogram/detail/meta.hpp>
+#include <boost/histogram/detail/utility.hpp>
+#include <limits>
+#include <vector>
+#include <deque>
+#include <array>
+#include <boost/array.hpp>
+using namespace boost::histogram;
+
+template <typename Storage1, typename Storage2>
+bool operator==(const Storage1& a, const Storage2& b)
+{
+    if (a.size() != b.size())
+        return false;
+    return detail::storage_content_equal(a, b);
+}
+
+BOOST_AUTO_TEST_CASE(ctor)
+{
+    container_storage<std::vector<unsigned>> a(1);
+    BOOST_CHECK_EQUAL(a.size(), 1);
+    BOOST_CHECK_EQUAL(a.value(0), 0);
+    container_storage<std::deque<unsigned>> b(1);
+    BOOST_CHECK_EQUAL(b.size(), 1);
+    BOOST_CHECK_EQUAL(b.value(0), 0);
+    container_storage<std::array<unsigned, 1>> c(1);
+    BOOST_CHECK_EQUAL(c.size(), 1);
+    BOOST_CHECK_EQUAL(c.value(0), 0);
+    container_storage<boost::array<unsigned, 1>> d(1);
+    BOOST_CHECK_EQUAL(d.size(), 1);
+    BOOST_CHECK_EQUAL(d.value(0), 0);
+}
+
+BOOST_AUTO_TEST_CASE(increase)
+{
+    container_storage<std::vector<unsigned>> a(1), b(1);
+    container_storage<std::vector<unsigned char>> c(1), d(2);
+    a.increase(0);
+    b.increase(0);
+    c.increase(0); c.increase(0);
+    d.increase(0);
+    BOOST_CHECK_EQUAL(a.value(0), 1.0);
+    BOOST_CHECK_EQUAL(b.value(0), 1.0);
+    BOOST_CHECK_EQUAL(c.value(0), 2.0);
+    BOOST_CHECK_EQUAL(d.value(0), 1.0);
+    BOOST_CHECK_EQUAL(d.value(1), 0.0);
+    BOOST_CHECK(a == a);
+    BOOST_CHECK(a == b);
+    BOOST_CHECK(!(a == c));
+    BOOST_CHECK(!(a == d));
+
+    container_storage<std::array<unsigned, 2>> e;
+    e.increase(0);
+    BOOST_CHECK(d == e);
+    e.increase(1);
+    BOOST_CHECK(!(d == e));
+}
+
+BOOST_AUTO_TEST_CASE(copy)
+{
+    container_storage<std::vector<unsigned>> a(1);
+    a.increase(0);
+    decltype(a) b(2);
+    BOOST_CHECK(!(a == b));
+    b = a;
+    BOOST_CHECK(a == b);
+    BOOST_CHECK_EQUAL(b.size(), 1);
+    BOOST_CHECK_EQUAL(b.value(0), 1.0);
+
+    decltype(a) c(a);
+    BOOST_CHECK(a == c);
+    BOOST_CHECK_EQUAL(c.size(), 1);
+    BOOST_CHECK_EQUAL(c.value(0), 1.0);
+
+    container_storage<std::vector<unsigned char>> d(2);
+    BOOST_CHECK(!(a == d));
+    d = a;
+    BOOST_CHECK(a == d);
+    decltype(d) e(a);
+    BOOST_CHECK(a == e);
+
+    container_storage<std::array<unsigned, 1>> f;
+    BOOST_CHECK(!(a == f));
+    f = a;
+    BOOST_CHECK(f == a);
+    decltype(f) g(a);
+    BOOST_CHECK(g == a);
+
+    container_storage<std::array<unsigned char, 1>> h;
+    BOOST_CHECK(!(h == f));
+    h = f;
+    BOOST_CHECK(h == f);
+    decltype(h) i(f);
+    BOOST_CHECK(i == f);
+}
+
+BOOST_AUTO_TEST_CASE(move)
+{
+    container_storage<std::vector<unsigned>> a(1);
+    a.increase(0);
+    decltype(a) b;
+    BOOST_CHECK(!(a == b));
+    b = std::move(a);
+    BOOST_CHECK_EQUAL(a.size(), 0);
+    BOOST_CHECK_EQUAL(b.size(), 1);
+    BOOST_CHECK_EQUAL(b.value(0), 1.0);
+    decltype(a) c(std::move(b));
+    BOOST_CHECK_EQUAL(c.size(), 1);
+    BOOST_CHECK_EQUAL(c.value(0), 1.0);
+}
diff --git a/test/dynamic_histogram_test.cpp b/test/dynamic_histogram_test.cpp
index 22b37482..8d3d371a 100644
--- a/test/dynamic_histogram_test.cpp
+++ b/test/dynamic_histogram_test.cpp
@@ -9,77 +9,99 @@
 #include <boost/test/test_tools.hpp>
 #include <boost/mpl/vector.hpp>
 #include <boost/histogram/dynamic_histogram.hpp>
-#include <boost/histogram/dynamic_storage.hpp>
-#include <boost/histogram/static_storage.hpp>
 #include <boost/histogram/utility.hpp>
 #include <boost/histogram/axis_ostream_operators.hpp>
 #include <boost/histogram/serialization.hpp>
+#include <boost/histogram/storage/adaptive_storage.hpp>
+#include <boost/histogram/storage/container_storage.hpp>
 #include <boost/archive/text_oarchive.hpp>
 #include <boost/archive/text_iarchive.hpp>
 #include <limits>
 #include <sstream>
 #include <array>
+#include <vector>
 
 using namespace boost::histogram;
 namespace mpl = boost::mpl;
 
 BOOST_AUTO_TEST_CASE(init_0)
 {
-    auto h = dynamic_histogram<dynamic_storage>();
+    auto h = dynamic_histogram<default_axes, adaptive_storage>();
     BOOST_CHECK_EQUAL(h.dim(), 0);
     BOOST_CHECK_EQUAL(h.size(), 0);
-    auto h2 = dynamic_histogram<static_storage<int>>();
+    auto h2 = dynamic_histogram<
+        default_axes,
+        container_storage<std::vector<unsigned>>
+    >();
     BOOST_CHECK(h2 == h);
 }
 
 BOOST_AUTO_TEST_CASE(init_1)
 {
-    auto h = dynamic_histogram<dynamic_storage>(regular_axis{3, -1, 1});
+    auto h = dynamic_histogram<
+        default_axes,
+        adaptive_storage
+    >(regular_axis{3, -1, 1});
     BOOST_CHECK_EQUAL(h.dim(), 1);
     BOOST_CHECK_EQUAL(h.size(), 5);
     BOOST_CHECK_EQUAL(shape(h.axis(0)), 5);
-    auto h2 = dynamic_histogram<static_storage<int>>(regular_axis{3, -1, 1});
+    auto h2 = dynamic_histogram<
+        default_axes,
+        container_storage<std::vector<unsigned>>
+    >(regular_axis{3, -1, 1});
     BOOST_CHECK(h2 == h);
 }
 
 BOOST_AUTO_TEST_CASE(init_2)
 {
-    auto h = dynamic_histogram<dynamic_storage>(regular_axis{3, -1, 1},
-                                        integer_axis{-1, 1});
+    auto h = dynamic_histogram<
+        default_axes,
+        adaptive_storage
+    >(regular_axis{3, -1, 1}, integer_axis{-1, 1});
     BOOST_CHECK_EQUAL(h.dim(), 2);
     BOOST_CHECK_EQUAL(h.size(), 25);
     BOOST_CHECK_EQUAL(shape(h.axis(0)), 5);
     BOOST_CHECK_EQUAL(shape(h.axis(1)), 5);
-    auto h2 = dynamic_histogram<static_storage<int>>(regular_axis{3, -1, 1},
-                                             integer_axis{-1, 1});
+    auto h2 = dynamic_histogram<
+        default_axes,
+        container_storage<std::vector<unsigned>>
+    >(regular_axis{3, -1, 1}, integer_axis{-1, 1});
     BOOST_CHECK(h2 == h);
 }
 
 BOOST_AUTO_TEST_CASE(init_3)
 {
-    auto h = dynamic_histogram<dynamic_storage>(regular_axis{3, -1, 1},
-                                        integer_axis{-1, 1},
-                                        polar_axis{3});
+    auto h = dynamic_histogram<
+        default_axes,
+        adaptive_storage
+    >(regular_axis{3, -1, 1}, integer_axis{-1, 1}, polar_axis{3});
     BOOST_CHECK_EQUAL(h.dim(), 3);
     BOOST_CHECK_EQUAL(h.size(), 75);
-    auto h2 = dynamic_histogram<static_storage<int>>(regular_axis{3, -1, 1},
-                                             integer_axis{-1, 1},
-                                             polar_axis{3});
+    auto h2 = dynamic_histogram<
+        default_axes,
+        container_storage<std::vector<unsigned>>
+    >(regular_axis{3, -1, 1}, integer_axis{-1, 1}, polar_axis{3});
     BOOST_CHECK(h2 == h);
 }
 
 BOOST_AUTO_TEST_CASE(init_4)
 {
-    auto h = dynamic_histogram<dynamic_storage>(regular_axis{3, -1, 1},
-                                        integer_axis{-1, 1},
-                                        polar_axis{3},
-                                        variable_axis{-1, 0, 1});
+    auto h = dynamic_histogram<
+        default_axes,
+        adaptive_storage
+    >(regular_axis{3, -1, 1},
+      integer_axis{-1, 1},
+      polar_axis{3},
+      variable_axis{-1, 0, 1});
     BOOST_CHECK_EQUAL(h.dim(), 4);
     BOOST_CHECK_EQUAL(h.size(), 300);
-    auto h2 = dynamic_histogram<static_storage<int>>(regular_axis{3, -1, 1},
-                                             integer_axis{-1, 1},
-                                             polar_axis{3},
-                                             variable_axis{-1, 0, 1});
+    auto h2 = dynamic_histogram<
+        default_axes,
+        container_storage<std::vector<unsigned>>
+    >(regular_axis{3, -1, 1},
+      integer_axis{-1, 1},
+      polar_axis{3},
+      variable_axis{-1, 0, 1});
     BOOST_CHECK(h2 == h);
 }
 
@@ -102,19 +124,22 @@ BOOST_AUTO_TEST_CASE(init_5)
 
 BOOST_AUTO_TEST_CASE(copy_ctor)
 {
-    auto h = make_dynamic_histogram_with<dynamic_storage>(integer_axis(0, 1),
+    auto h = make_dynamic_histogram_with<adaptive_storage>(integer_axis(0, 1),
                                                           integer_axis(0, 2));
     h.fill(0, 0);
     auto h2 = decltype(h)(h);
     BOOST_CHECK(h2 == h);
-    auto h3 = dynamic_histogram<static_storage<int>>(h);
+    auto h3 = dynamic_histogram<
+        default_axes,
+        container_storage<std::vector<unsigned>>
+    >(h);
     BOOST_CHECK(h3 == h);
 }
 
 BOOST_AUTO_TEST_CASE(copy_assign)
 {
-    auto h = make_dynamic_histogram_with<dynamic_storage>(integer_axis(0, 1),
-                                                          integer_axis(0, 2));
+    auto h = make_dynamic_histogram_with<adaptive_storage>(integer_axis(0, 1),
+                                                           integer_axis(0, 2));
     h.fill(0, 0);
     auto h2 = decltype(h)();
     BOOST_CHECK(!(h == h2));
@@ -123,43 +148,26 @@ BOOST_AUTO_TEST_CASE(copy_assign)
     // test self-assign
     h2 = h2;
     BOOST_CHECK(h == h2);
-    auto h3 = dynamic_histogram<static_storage<int>>();
+    auto h3 = dynamic_histogram<
+        default_axes,
+        container_storage<std::vector<unsigned>>
+    >();
     h3 = h;
     BOOST_CHECK(h == h3);
 }
 
-BOOST_AUTO_TEST_CASE(move_ctor)
+BOOST_AUTO_TEST_CASE(move)
 {
     auto h = make_dynamic_histogram(integer_axis(0, 1),
                                     integer_axis(0, 2));
     h.fill(0, 0);
     const auto href = h;
-    auto h2 = decltype(h)(std::move(h));
+    decltype(h) h2(std::move(h));
     BOOST_CHECK_EQUAL(h.dim(), 0);
     BOOST_CHECK_EQUAL(h.sum(), 0);
     BOOST_CHECK_EQUAL(h.size(), 0);
     BOOST_CHECK(h2 == href);
-    auto h3 = dynamic_histogram<static_storage<int>>(std::move(h2));
-    BOOST_CHECK_EQUAL(h2.dim(), 0);
-    BOOST_CHECK_EQUAL(h2.sum(), 0);
-    BOOST_CHECK_EQUAL(h2.size(), 0);
-    BOOST_CHECK(h3 == href);
-}
-
-BOOST_AUTO_TEST_CASE(move_assign)
-{
-    auto h = make_dynamic_histogram(integer_axis(0, 1),
-                                    integer_axis(0, 2));
-    h.fill(0.0, 0.0);
-    auto href = h;
-    auto h2 = decltype(h)();
-    h2 = std::move(h);
-    BOOST_CHECK(h2 == href);
-    BOOST_CHECK_EQUAL(h.dim(), 0);
-    BOOST_CHECK_EQUAL(h.sum(), 0);
-    BOOST_CHECK_EQUAL(h.size(), 0);
-    auto h3 = dynamic_histogram<static_storage<int>>();
-    h3 = std::move(h2);
+    decltype(h) h3 = std::move(h2);
     BOOST_CHECK_EQUAL(h2.dim(), 0);
     BOOST_CHECK_EQUAL(h2.sum(), 0);
     BOOST_CHECK_EQUAL(h2.size(), 0);
@@ -168,20 +176,24 @@ BOOST_AUTO_TEST_CASE(move_assign)
 
 BOOST_AUTO_TEST_CASE(equal_compare)
 {
-    auto a = dynamic_histogram<dynamic_storage>(integer_axis(0, 1));
-    auto b = dynamic_histogram<dynamic_storage>(integer_axis(0, 1),
-                                                integer_axis(0, 2));
+    auto a = dynamic_histogram<
+        default_axes,
+        adaptive_storage
+    >(integer_axis(0, 1));
+    auto b = dynamic_histogram<
+        default_axes,
+        adaptive_storage>(integer_axis(0, 1), integer_axis(0, 2));
     BOOST_CHECK(!(a == b));
     BOOST_CHECK(!(b == a));
     auto c = dynamic_histogram<
-            static_storage<int>,
-            mpl::vector<integer_axis>
-        >(integer_axis(0, 1));
+        mpl::vector<integer_axis>,
+        container_storage<std::vector<unsigned>>
+    >(integer_axis(0, 1));
     BOOST_CHECK(!(b == c));
     BOOST_CHECK(!(c == b));
     BOOST_CHECK(a == c);
     BOOST_CHECK(c == a);
-    auto d = dynamic_histogram<dynamic_storage>(regular_axis(2, 0, 1));
+    auto d = make_dynamic_histogram(regular_axis(2, 0, 1));
     BOOST_CHECK(!(c == d));
     BOOST_CHECK(!(d == c));
     c.fill(0);
@@ -251,10 +263,10 @@ BOOST_AUTO_TEST_CASE(d1w)
 {
     auto h = make_dynamic_histogram(regular_axis(2, -1, 1));
     h.fill(0);
-    h.wfill(-1.0, 2.0);
+    h.wfill(2, -1.0);
     h.fill(-1.0);
     h.fill(-2.0);
-    h.wfill(10.0, 5.0);
+    h.wfill(5, 10);
 
     BOOST_CHECK_EQUAL(h.sum(), 10);
 
@@ -325,9 +337,9 @@ BOOST_AUTO_TEST_CASE(d2w)
     auto h = make_dynamic_histogram(regular_axis(2, -1, 1),
                                     integer_axis(-1, 1, nullptr, false));
     h.fill(-1, 0);       // -> 0, 1
-    h.wfill(-1, -1, 10); // -> 0, 0
-    h.wfill(-1, -10, 5); // is ignored
-    h.wfill(-10, 0, 7);  // -> -1, 1
+    h.wfill(10, -1, -1); // -> 0, 0
+    h.wfill(5, -1, -10); // is ignored
+    h.wfill(7, -10, 0);  // -> -1, 1
 
     BOOST_CHECK_EQUAL(h.sum(), 18);
 
@@ -373,7 +385,7 @@ BOOST_AUTO_TEST_CASE(d3w)
         for (auto j = 0; j < bins(h.axis(1)); ++j)
             for (auto k = 0; k < bins(h.axis(2)); ++k)
     {
-        h.wfill(i, j, k, i+j+k);
+        h.wfill(i+j+k, i, j, k);
     }
 
     for (auto i = 0; i < bins(h.axis(0)); ++i)
@@ -387,19 +399,19 @@ BOOST_AUTO_TEST_CASE(add_0)
     auto a = make_dynamic_histogram(integer_axis(-1, 1));
     auto b = make_dynamic_histogram(regular_axis(3, -1, 1));
     auto c = make_dynamic_histogram(regular_axis(3, -1.1, 1));
-    BOOST_CHECK_THROW(a + b, std::logic_error);
-    BOOST_CHECK_THROW(b + c, std::logic_error);
+    BOOST_CHECK_THROW(a += b, std::logic_error);
+    BOOST_CHECK_THROW(b += c, std::logic_error);
 }
 
 BOOST_AUTO_TEST_CASE(add_1)
 {
     auto a = dynamic_histogram<
-            dynamic_storage,
-            mpl::vector<integer_axis>
+            mpl::vector<integer_axis>,
+            adaptive_storage
         >(integer_axis(-1, 1));
     auto b = dynamic_histogram<
-            static_storage<int>,
-            mpl::vector<integer_axis, regular_axis>
+            mpl::vector<integer_axis, regular_axis>,
+            container_storage<std::vector<unsigned>>
         >(integer_axis(-1, 1));
     a.fill(-1);
     b.fill(1);
@@ -410,7 +422,8 @@ BOOST_AUTO_TEST_CASE(add_1)
     BOOST_CHECK_EQUAL(c.value(1), 0);
     BOOST_CHECK_EQUAL(c.value(2), 1);
     BOOST_CHECK_EQUAL(c.value(3), 0);
-    auto d = a + b;
+    auto d = b;
+    d += a;
     BOOST_CHECK_EQUAL(d.value(-1), 0);
     BOOST_CHECK_EQUAL(d.value(0), 1);
     BOOST_CHECK_EQUAL(d.value(1), 0);
@@ -424,7 +437,7 @@ BOOST_AUTO_TEST_CASE(add_2)
     auto b = make_dynamic_histogram(integer_axis(-1, 1));
 
     a.fill(0);
-    b.wfill(-1, 3);
+    b.wfill(3, -1);
     auto c = a;
     c += b;
     BOOST_CHECK_EQUAL(c.value(-1), 0);
@@ -432,7 +445,8 @@ BOOST_AUTO_TEST_CASE(add_2)
     BOOST_CHECK_EQUAL(c.value(1), 1);
     BOOST_CHECK_EQUAL(c.value(2), 0);
     BOOST_CHECK_EQUAL(c.value(3), 0);    
-    auto d = a + b;
+    auto d = b;
+    d += a;
     BOOST_CHECK_EQUAL(d.value(-1), 0);
     BOOST_CHECK_EQUAL(d.value(0), 3);
     BOOST_CHECK_EQUAL(d.value(1), 1);
@@ -442,20 +456,19 @@ BOOST_AUTO_TEST_CASE(add_2)
 
 BOOST_AUTO_TEST_CASE(add_3)
 {
-    auto a = make_dynamic_histogram_with<static_storage<char>>(integer_axis(-1, 1));
-    auto b = make_dynamic_histogram_with<static_storage<int>>(integer_axis(-1, 1));
+    auto a = make_dynamic_histogram_with<container_storage<std::vector<char>>>(integer_axis(-1, 1));
+    auto b = make_dynamic_histogram_with<container_storage<std::vector<unsigned>>>(integer_axis(-1, 1));
     a.fill(-1);
     b.fill(1);
     auto c = a;
     c += b;
-    BOOST_CHECK_EQUAL(c.depth(), sizeof(char));
     BOOST_CHECK_EQUAL(c.value(-1), 0);
     BOOST_CHECK_EQUAL(c.value(0), 1);
     BOOST_CHECK_EQUAL(c.value(1), 0);
     BOOST_CHECK_EQUAL(c.value(2), 1);
     BOOST_CHECK_EQUAL(c.value(3), 0);
-    auto d = a + b;
-    BOOST_CHECK_EQUAL(d.depth(), sizeof(int));
+    auto d = b;
+    d += a;
     BOOST_CHECK_EQUAL(d.value(-1), 0);
     BOOST_CHECK_EQUAL(d.value(0), 1);
     BOOST_CHECK_EQUAL(d.value(1), 0);
diff --git a/test/python_suite_test.py.in b/test/python_suite_test.py.in
index 2eaad0bc..76a85d5f 100755
--- a/test/python_suite_test.py.in
+++ b/test/python_suite_test.py.in
@@ -329,7 +329,6 @@ class histogramest(unittest.TestCase):
         self.assertEqual(h.dim, 1)
         self.assertEqual(h.axis(0), integer_axis(-1, 1))
         self.assertEqual(h.axis(0).shape, 5)
-        self.assertEqual(h.depth, 0)
         self.assertEqual(histogram(integer_axis(-1, 1, uoflow=False)).axis(0).shape, 3)
         self.assertNotEqual(h, histogram(regular_axis(1, -1, 1)))
         self.assertNotEqual(h, histogram(integer_axis(-1, 2)))
@@ -362,10 +361,8 @@ class histogramest(unittest.TestCase):
             h.fill(1)
             h.fill(10)
         self.assertEqual(h0.sum, 6)
-        self.assertEqual(h0.depth, 1)
         self.assertEqual(h0.axis(0).shape, 3)
         self.assertEqual(h1.sum, 8)
-        self.assertEqual(h1.depth, 1)
         self.assertEqual(h1.axis(0).shape, 5)
 
         for h in (h0, h1):
@@ -385,9 +382,7 @@ class histogramest(unittest.TestCase):
         h.fill(1)
         for i in range(255):
             h.fill(0)
-        self.assertEqual(h.depth, 1)
         h.fill(0)
-        self.assertEqual(h.depth, 2)
         for i in range(1000-256):
             h.fill(0)
         self.assertEqual(h.value(-1), 0)
@@ -439,9 +434,7 @@ class histogramest(unittest.TestCase):
                  [0, 1, 0, 0, 0, 0],
                  [0, 0, 0, 0, 0, 0]]
 
-            h2 = h + h
             h += h
-            self.assertEqual(h, h2)
 
             for i in range(-uoflow, h.axis(0).bins + uoflow):
                 for j in range(-uoflow, h.axis(1).bins + uoflow):
@@ -472,13 +465,14 @@ class histogramest(unittest.TestCase):
                  [0, 1, 0, 0, 0, 0],
                  [0, 0, 0, 0, 0, 0]]
 
-            hw = histogram(integer_axis(-1, 1, uoflow=uoflow),
+            h2 = histogram(integer_axis(-1, 1, uoflow=uoflow),
                            regular_axis(4, -2, 2, uoflow=uoflow))
-            hw.fill(0, 0, w=0)
+            h2.fill(0, 0, w=0)
 
-            h2 = h + hw
+            h2 += h
+            h2 += h
             h += h
-            self.assertNotEqual(h, h2)
+            self.assertEqual(h, h2)
 
             for i in range(-uoflow, h.axis(0).bins + uoflow):
                 for j in range(-uoflow, h.axis(1).bins + uoflow):
diff --git a/test/static_histogram_test.cpp b/test/static_histogram_test.cpp
index 8bd41742..e3de2691 100644
--- a/test/static_histogram_test.cpp
+++ b/test/static_histogram_test.cpp
@@ -8,8 +8,8 @@
 #include <boost/test/unit_test.hpp>
 #include <boost/test/test_tools.hpp>
 #include <boost/histogram/static_histogram.hpp>
-#include <boost/histogram/dynamic_storage.hpp>
-#include <boost/histogram/static_storage.hpp>
+#include <boost/histogram/storage/container_storage.hpp>
+#include <boost/histogram/storage/adaptive_storage.hpp>
 #include <boost/histogram/utility.hpp>
 #include <boost/histogram/axis_ostream_operators.hpp>
 #include <boost/histogram/serialization.hpp>
@@ -17,6 +17,7 @@
 #include <boost/archive/text_iarchive.hpp>
 #include <limits>
 #include <sstream>
+#include <vector>
 
 using namespace boost::histogram;
 namespace mpl = boost::mpl;
@@ -24,54 +25,54 @@ namespace mpl = boost::mpl;
 BOOST_AUTO_TEST_CASE(init_0)
 {
     auto h = static_histogram<
-      dynamic_storage,
-      mpl::vector<integer_axis>
+      mpl::vector<integer_axis>,
+      adaptive_storage
     >();
     BOOST_CHECK_EQUAL(h.dim(), 1);
     BOOST_CHECK_EQUAL(h.size(), 0);
     auto h2 = static_histogram<
-      static_storage<int>,
-      mpl::vector<integer_axis>
+      mpl::vector<integer_axis>,
+      container_storage<std::vector<unsigned>>
     >();
     BOOST_CHECK(h2 == h);
     auto h3 = static_histogram<
-      dynamic_storage,
-      mpl::vector<regular_axis>
+      mpl::vector<regular_axis>,
+      adaptive_storage
     >();
     BOOST_CHECK(!(h3 == h));
 }
 
 BOOST_AUTO_TEST_CASE(init_1)
 {
-    auto h = make_static_histogram_with<dynamic_storage>(regular_axis{3, -1, 1});
+    auto h = make_static_histogram_with<adaptive_storage>(regular_axis{3, -1, 1});
     BOOST_CHECK_EQUAL(h.dim(), 1);
     BOOST_CHECK_EQUAL(h.size(), 5);
     BOOST_CHECK_EQUAL(shape(h.axis<0>()), 5);
-    auto h2 = make_static_histogram_with<static_storage<int>>(regular_axis{3, -1, 1});
+    auto h2 = make_static_histogram_with<container_storage<std::vector<unsigned>>>(regular_axis{3, -1, 1});
     BOOST_CHECK(h2 == h);
 }
 
 BOOST_AUTO_TEST_CASE(init_2)
 {
-    auto h = make_static_histogram_with<dynamic_storage>(regular_axis{3, -1, 1},
+    auto h = make_static_histogram_with<adaptive_storage>(regular_axis{3, -1, 1},
                                                          integer_axis{-1, 1});
     BOOST_CHECK_EQUAL(h.dim(), 2);
     BOOST_CHECK_EQUAL(h.size(), 25);
     BOOST_CHECK_EQUAL(shape(h.axis<0>()), 5);
     BOOST_CHECK_EQUAL(shape(h.axis<1>()), 5);
-    auto h2 = make_static_histogram_with<static_storage<int>>(regular_axis{3, -1, 1},
+    auto h2 = make_static_histogram_with<container_storage<std::vector<unsigned>>>(regular_axis{3, -1, 1},
                                                               integer_axis{-1, 1});
     BOOST_CHECK(h2 == h);
 }
 
 BOOST_AUTO_TEST_CASE(init_3)
 {
-    auto h = make_static_histogram_with<dynamic_storage>(regular_axis{3, -1, 1},
+    auto h = make_static_histogram_with<adaptive_storage>(regular_axis{3, -1, 1},
                                                          integer_axis{-1, 1},
                                                          polar_axis{3});
     BOOST_CHECK_EQUAL(h.dim(), 3);
     BOOST_CHECK_EQUAL(h.size(), 75);
-    auto h2 = make_static_histogram_with<static_storage<int>>(regular_axis{3, -1, 1},
+    auto h2 = make_static_histogram_with<container_storage<std::vector<unsigned>>>(regular_axis{3, -1, 1},
                                                               integer_axis{-1, 1},
                                                               polar_axis{3});
     BOOST_CHECK(h2 == h);
@@ -79,13 +80,13 @@ BOOST_AUTO_TEST_CASE(init_3)
 
 BOOST_AUTO_TEST_CASE(init_4)
 {
-    auto h = make_static_histogram_with<dynamic_storage>(regular_axis{3, -1, 1},
+    auto h = make_static_histogram_with<adaptive_storage>(regular_axis{3, -1, 1},
                                                          integer_axis{-1, 1},
                                                          polar_axis{3},
                                                          variable_axis{-1, 0, 1});
     BOOST_CHECK_EQUAL(h.dim(), 4);
     BOOST_CHECK_EQUAL(h.size(), 300);
-    auto h2 = make_static_histogram_with<static_storage<int>>(regular_axis{3, -1, 1},
+    auto h2 = make_static_histogram_with<container_storage<std::vector<unsigned>>>(regular_axis{3, -1, 1},
                                                               integer_axis{-1, 1},
                                                               polar_axis{3},
                                                               variable_axis{-1, 0, 1});
@@ -94,14 +95,14 @@ BOOST_AUTO_TEST_CASE(init_4)
 
 BOOST_AUTO_TEST_CASE(init_5)
 {
-    auto h = make_static_histogram_with<dynamic_storage>(regular_axis{3, -1, 1},
+    auto h = make_static_histogram_with<adaptive_storage>(regular_axis{3, -1, 1},
                                                          integer_axis{-1, 1},
                                                          polar_axis{3},
                                                          variable_axis{-1, 0, 1},
                                                          category_axis{"A", "B", "C"});
     BOOST_CHECK_EQUAL(h.dim(), 5);
     BOOST_CHECK_EQUAL(h.size(), 900);
-    auto h2 = make_static_histogram_with<static_storage<int>>(regular_axis{3, -1, 1},
+    auto h2 = make_static_histogram_with<container_storage<std::vector<unsigned>>>(regular_axis{3, -1, 1},
                                                               integer_axis{-1, 1},
                                                               polar_axis{3},
                                                               variable_axis{-1, 0, 1},
@@ -117,8 +118,8 @@ BOOST_AUTO_TEST_CASE(copy_ctor)
     auto h2 = decltype(h)(h);
     BOOST_CHECK(h2 == h);
     auto h3 = static_histogram<
-      static_storage<int>,
-      mpl::vector<integer_axis, integer_axis>
+      mpl::vector<integer_axis, integer_axis>,
+      container_storage<std::vector<unsigned>>
     >(h);
     BOOST_CHECK(h3 == h);
 }
@@ -136,50 +137,25 @@ BOOST_AUTO_TEST_CASE(copy_assign)
     h2 = h2;
     BOOST_CHECK(h == h2);
     auto h3 = static_histogram<
-      static_storage<int>,
-      mpl::vector<integer_axis, integer_axis>
+      mpl::vector<integer_axis, integer_axis>,
+      container_storage<std::vector<unsigned>>
     >();
     h3 = h;
     BOOST_CHECK(h == h3);
 }
 
-BOOST_AUTO_TEST_CASE(move_ctor)
+BOOST_AUTO_TEST_CASE(move)
 {
     auto h = make_static_histogram(integer_axis(0, 1),
                                    integer_axis(0, 2));
     h.fill(0, 0);
     const auto href = h;
-    auto h2 = decltype(h)(std::move(h));
+    decltype(h) h2(std::move(h));
     BOOST_CHECK_EQUAL(h.dim(), 2);
     BOOST_CHECK_EQUAL(h.sum(), 0);
     BOOST_CHECK_EQUAL(h.size(), 0);
     BOOST_CHECK(h2 == href);
-    auto h3 = static_histogram<
-      static_storage<int>,
-      mpl::vector<integer_axis, integer_axis>
-    >(std::move(h2));
-    BOOST_CHECK_EQUAL(h2.dim(), 2);
-    BOOST_CHECK_EQUAL(h2.sum(), 0);
-    BOOST_CHECK_EQUAL(h2.size(), 0);
-    BOOST_CHECK(h3 == href);
-}
-
-BOOST_AUTO_TEST_CASE(move_assign)
-{
-    auto h = make_static_histogram(integer_axis(0, 1),
-                                   integer_axis(0, 2));
-    h.fill(0.0, 0.0);
-    auto href = h;
-    auto h2 = decltype(h)();
-    h2 = std::move(h);
-    BOOST_CHECK(h2 == href);
-    BOOST_CHECK_EQUAL(h.dim(), 2);
-    BOOST_CHECK_EQUAL(h.sum(), 0);
-    BOOST_CHECK_EQUAL(h.size(), 0);
-    auto h3 = static_histogram<
-      static_storage<int>,
-      mpl::vector<integer_axis, integer_axis>
-    >();
+    decltype(h) h3;
     h3 = std::move(h2);
     BOOST_CHECK_EQUAL(h2.dim(), 2);
     BOOST_CHECK_EQUAL(h2.sum(), 0);
@@ -268,10 +244,10 @@ BOOST_AUTO_TEST_CASE(d1w)
 {
     auto h = make_static_histogram(regular_axis(2, -1, 1));
     h.fill(0);
-    h.wfill(-1.0, 2.0);
+    h.wfill(2.0, -1.0);
     h.fill(-1.0);
     h.fill(-2.0);
-    h.wfill(10.0, 5.0);
+    h.wfill(5.0, 10.0);
 
     BOOST_CHECK_EQUAL(h.sum(), 10);
 
@@ -342,9 +318,9 @@ BOOST_AUTO_TEST_CASE(d2w)
     auto h = make_static_histogram(regular_axis(2, -1, 1),
                                    integer_axis(-1, 1, nullptr, false));
     h.fill(-1, 0);       // -> 0, 1
-    h.wfill(-1, -1, 10); // -> 0, 0
-    h.wfill(-1, -10, 5); // is ignored
-    h.wfill(-10, 0, 7);  // -> -1, 1
+    h.wfill(10, -1, -1); // -> 0, 0
+    h.wfill(5, -1, -10); // is ignored
+    h.wfill(7, -10, 0);  // -> -1, 1
 
     BOOST_CHECK_EQUAL(h.sum(), 18);
 
@@ -390,7 +366,7 @@ BOOST_AUTO_TEST_CASE(d3w)
         for (auto j = 0; j < bins(h.axis<1>()); ++j)
             for (auto k = 0; k < bins(h.axis<2>()); ++k)
     {
-        h.wfill(i, j, k, i+j+k);
+        h.wfill(i+j+k, i, j, k);
     }
 
     for (auto i = 0; i < bins(h.axis<0>()); ++i)
@@ -402,10 +378,10 @@ BOOST_AUTO_TEST_CASE(d3w)
 BOOST_AUTO_TEST_CASE(add_1)
 {
     auto a = make_static_histogram_with<
-      dynamic_storage
+      adaptive_storage
     >(integer_axis(-1, 1));
     auto b = make_static_histogram_with<
-      static_storage<int>
+      container_storage<std::vector<unsigned>>
     >(integer_axis(-1, 1));
     a.fill(-1);
     b.fill(1);
@@ -416,7 +392,8 @@ BOOST_AUTO_TEST_CASE(add_1)
     BOOST_CHECK_EQUAL(c.value(1), 0);
     BOOST_CHECK_EQUAL(c.value(2), 1);
     BOOST_CHECK_EQUAL(c.value(3), 0);
-    auto d = a + b;
+    auto d = a;
+    d += b;
     BOOST_CHECK_EQUAL(d.value(-1), 0);
     BOOST_CHECK_EQUAL(d.value(0), 1);
     BOOST_CHECK_EQUAL(d.value(1), 0);
@@ -427,14 +404,14 @@ BOOST_AUTO_TEST_CASE(add_1)
 BOOST_AUTO_TEST_CASE(add_2)
 {
     auto a = make_static_histogram_with<
-      dynamic_storage
+      adaptive_storage
     >(integer_axis(-1, 1));
     auto b = make_static_histogram_with<
-      dynamic_storage
+      adaptive_storage
     >(integer_axis(-1, 1));
 
     a.fill(0);
-    b.wfill(-1, 3);
+    b.wfill(3, -1);
     auto c = a;
     c += b;
     BOOST_CHECK_EQUAL(c.value(-1), 0);
@@ -442,7 +419,8 @@ BOOST_AUTO_TEST_CASE(add_2)
     BOOST_CHECK_EQUAL(c.value(1), 1);
     BOOST_CHECK_EQUAL(c.value(2), 0);
     BOOST_CHECK_EQUAL(c.value(3), 0);    
-    auto d = a + b;
+    auto d = a;
+    d += b;
     BOOST_CHECK_EQUAL(d.value(-1), 0);
     BOOST_CHECK_EQUAL(d.value(0), 3);
     BOOST_CHECK_EQUAL(d.value(1), 1);
@@ -453,23 +431,22 @@ BOOST_AUTO_TEST_CASE(add_2)
 BOOST_AUTO_TEST_CASE(add_3)
 {
     auto a = make_static_histogram_with<
-      static_storage<char>
+      container_storage<std::vector<char>>
     >(integer_axis(-1, 1));
     auto b = make_static_histogram_with<
-      static_storage<int>
+      container_storage<std::vector<unsigned>>
     >(integer_axis(-1, 1));
     a.fill(-1);
     b.fill(1);
     auto c = a;
     c += b;
-    BOOST_CHECK_EQUAL(c.depth(), sizeof(char));
     BOOST_CHECK_EQUAL(c.value(-1), 0);
     BOOST_CHECK_EQUAL(c.value(0), 1);
     BOOST_CHECK_EQUAL(c.value(1), 0);
     BOOST_CHECK_EQUAL(c.value(2), 1);
     BOOST_CHECK_EQUAL(c.value(3), 0);
-    auto d = a + b;
-    BOOST_CHECK_EQUAL(d.depth(), sizeof(int));
+    auto d = a;
+    d += b;
     BOOST_CHECK_EQUAL(d.value(-1), 0);
     BOOST_CHECK_EQUAL(d.value(0), 1);
     BOOST_CHECK_EQUAL(d.value(1), 0);
@@ -493,7 +470,7 @@ BOOST_AUTO_TEST_CASE(doc_example_0)
     h.fill(1.7);
     h.fill(2.0);  // put in overflow bin, bin interval is semi-open
     h.fill(20.0); // put in overflow bin
-    h.wfill(0.1, 5.0); // fill with a weighted entry, weight is 5.0
+    h.wfill(5.0, 0.1); // fill with a weighted entry, weight is 5.0
 
     std::ostringstream os1;
     // access histogram counts