From 7bc9bd8016f13717336a692465bab51130f462cc Mon Sep 17 00:00:00 2001
From: Hans Dembinski <hans.dembinski@gmail.com>
Date: Wed, 29 Mar 2017 21:15:43 +0200
Subject: [PATCH] polishing

---
 include/boost/histogram/axis.hpp              |  14 +-
 include/boost/histogram/detail/weight.hpp     |  30 +-
 include/boost/histogram/histogram.hpp         |   5 +-
 .../histogram/histogram_dynamic_impl.hpp      | 319 ------------------
 include/boost/histogram/histogram_fwd.hpp     |   7 +-
 .../histogram/histogram_ostream_operators.hpp |   2 +-
 .../boost/histogram/histogram_static_impl.hpp | 231 -------------
 include/boost/histogram/serialization.hpp     |   4 +-
 .../histogram/storage/adaptive_storage.hpp    |  63 ++--
 .../histogram/storage/container_storage.hpp   |  20 +-
 src/python/histogram.cpp                      |   2 +-
 test/adaptive_storage_test.cpp                |   6 +-
 test/dynamic_histogram_test.cpp               |  62 ++--
 test/static_histogram_test.cpp                |  36 +-
 14 files changed, 128 insertions(+), 673 deletions(-)
 delete mode 100644 include/boost/histogram/histogram_dynamic_impl.hpp
 delete mode 100644 include/boost/histogram/histogram_static_impl.hpp

diff --git a/include/boost/histogram/axis.hpp b/include/boost/histogram/axis.hpp
index 543ae218..e13ab04c 100644
--- a/include/boost/histogram/axis.hpp
+++ b/include/boost/histogram/axis.hpp
@@ -11,6 +11,7 @@
 #include <boost/iterator/iterator_facade.hpp>
 #include <boost/math/constants/constants.hpp>
 #include <boost/mpl/vector.hpp>
+#include <boost/operators.hpp>
 #include <boost/utility/string_ref.hpp>
 #include <cmath>
 #include <limits>
@@ -192,7 +193,8 @@ private:
  * Very fast. Binning is a O(1) operation.
  */
 template <typename RealType = double>
-class regular_axis : public axis_base<true> {
+class regular_axis : public axis_base<true>,
+                     boost::operators<regular_axis<RealType>> {
 public:
   using value_type = RealType;
   using const_iterator = axis_iterator<regular_axis>;
@@ -265,7 +267,8 @@ private:
  * bins for this axis. Binning is a O(1) operation.
  */
 template <typename RealType = double>
-class circular_axis : public axis_base<false> {
+class circular_axis : public axis_base<false>,
+                      boost::operators<regular_axis<RealType>> {
 public:
   using value_type = RealType;
   using const_iterator = axis_iterator<circular_axis>;
@@ -326,7 +329,8 @@ private:
  * and the problem domain allows it, prefer a regular_axis.
  */
 template <typename RealType = double>
-class variable_axis : public axis_base<true> {
+class variable_axis : public axis_base<true>,
+                      boost::operators<variable_axis<RealType>> {
 public:
   using value_type = RealType;
   using const_iterator = axis_iterator<variable_axis>;
@@ -416,7 +420,7 @@ private:
  * Binning is a O(1) operation. This axis operates
  * faster than a regular_axis.
  */
-class integer_axis : public axis_base<true> {
+class integer_axis : public axis_base<true>, boost::operators<integer_axis> {
 public:
   using value_type = int;
   using const_iterator = axis_iterator<integer_axis>;
@@ -475,7 +479,7 @@ private:
  * There are no underflow/overflow bins for this axis.
  * Binning is a O(1) operation.
  */
-class category_axis : public axis_base<false> {
+class category_axis : public axis_base<false>, boost::operators<category_axis> {
 public:
   using value_type = const std::string &;
   using const_iterator = axis_iterator<category_axis>;
diff --git a/include/boost/histogram/detail/weight.hpp b/include/boost/histogram/detail/weight.hpp
index bfd6a8a7..ed14ac9d 100644
--- a/include/boost/histogram/detail/weight.hpp
+++ b/include/boost/histogram/detail/weight.hpp
@@ -7,14 +7,12 @@
 #ifndef _BOOST_HISTOGRAM_DETAIL_WEIGHT_HPP_
 #define _BOOST_HISTOGRAM_DETAIL_WEIGHT_HPP_
 
-#include <boost/operators.hpp>
-
 namespace boost {
 namespace histogram {
 namespace detail {
 
 /// Used by nstore to hold a sum of weighted counts and a variance estimate
-struct weight : boost::operators<weight> {
+struct weight {
   double w, w2;
   weight() = default;
   weight(const weight &) = default;
@@ -22,9 +20,9 @@ struct weight : boost::operators<weight> {
   weight &operator=(const weight &) = default;
   weight &operator=(weight &&) = default;
 
-  weight &operator+=(const weight &o) {
-    w += o.w;
-    w2 += o.w2;
+  weight &operator+=(const weight &rhs) {
+    w += rhs.w;
+    w2 += rhs.w2;
     return *this;
   }
   weight &operator++() {
@@ -32,7 +30,17 @@ struct weight : boost::operators<weight> {
     ++w2;
     return *this;
   }
-  bool operator==(const weight &o) const { return w == o.w && w2 == o.w2; }
+
+  bool operator==(const weight &rhs) const {
+    return w == rhs.w && w2 == rhs.w2;
+  }
+  bool operator!=(const weight &rhs) const { return !operator==(rhs); }
+  template <typename T> bool operator==(const T &rhs) const {
+    return w == static_cast<double>(rhs) && w2 == static_cast<double>(rhs);
+  }
+  template <typename T> bool operator!=(const T &rhs) const {
+    return !operator==(rhs);
+  }
 
   weight &add_weight(double t) {
     w += t;
@@ -55,18 +63,10 @@ struct weight : boost::operators<weight> {
   }
 };
 
-template <typename T> bool operator==(const weight &w, const T &t) {
-  return w.w == static_cast<double>(t) && w.w2 == static_cast<double>(t);
-}
-
 template <typename T> bool operator==(const T &t, const weight &w) {
   return w == t;
 }
 
-template <typename T> bool operator!=(const weight &w, const T &t) {
-  return !(w == t);
-}
-
 template <typename T> bool operator!=(const T &t, const weight &w) {
   return !(w == t);
 }
diff --git a/include/boost/histogram/histogram.hpp b/include/boost/histogram/histogram.hpp
index 9518bbda..e47a6e67 100644
--- a/include/boost/histogram/histogram.hpp
+++ b/include/boost/histogram/histogram.hpp
@@ -7,8 +7,7 @@
 #ifndef _BOOST_HISTOGRAM_HISTOGRAM_HPP_
 #define _BOOST_HISTOGRAM_HISTOGRAM_HPP_
 
-#include <boost/histogram/histogram_fwd.hpp>
-#include <boost/histogram/histogram_dynamic_impl.hpp>
-#include <boost/histogram/histogram_static_impl.hpp>
+#include <boost/histogram/histogram_impl_static.hpp>
+#include <boost/histogram/histogram_impl_dynamic.hpp>
 
 #endif
diff --git a/include/boost/histogram/histogram_dynamic_impl.hpp b/include/boost/histogram/histogram_dynamic_impl.hpp
deleted file mode 100644
index 36c15e88..00000000
--- a/include/boost/histogram/histogram_dynamic_impl.hpp
+++ /dev/null
@@ -1,319 +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_HISTOGRAM_DYNAMIC_IMPL_HPP_
-#define _BOOST_HISTOGRAM_HISTOGRAM_DYNAMIC_IMPL_HPP_
-
-#include <algorithm>
-#include <boost/assert.hpp>
-#include <boost/config.hpp>
-#include <boost/histogram/axis.hpp>
-#include <boost/histogram/detail/axis_visitor.hpp>
-#include <boost/histogram/detail/meta.hpp>
-#include <boost/histogram/detail/utility.hpp>
-#include <boost/histogram/histogram_fwd.hpp>
-#include <boost/mpl/empty.hpp>
-#include <boost/mpl/vector.hpp>
-#include <boost/variant.hpp>
-#include <cstddef>
-#include <iterator>
-#include <stdexcept>
-#include <type_traits>
-#include <vector>
-
-namespace boost {
-namespace histogram {
-
-template <typename Axes, typename Storage>
-class histogram<true, Axes, Storage> {
-  static_assert(!mpl::empty<Axes>::value, "at least one axis required");
-  using size_pair = std::pair<std::size_t, std::size_t>;
-
-public:
-  using axis_type = typename make_variant_over<Axes>::type;
-  using value_type = typename Storage::value_type;
-
-private:
-  using axes_type = std::vector<axis_type>;
-
-public:
-  histogram() = default;
-
-  template <typename... Axes1>
-  explicit histogram(const Axes1 &... axes) : axes_({axis_type(axes)...}) {
-    storage_ = Storage(field_count());
-  }
-
-  template <typename Iterator, typename = detail::is_iterator<Iterator>>
-  histogram(Iterator axes_begin, Iterator axes_end)
-      : axes_(std::distance(axes_begin, axes_end)) {
-    std::copy(axes_begin, axes_end, axes_.begin());
-    storage_ = Storage(field_count());
-  }
-
-  template <typename A, typename S>
-  explicit histogram(const histogram<true, A, S> &other)
-      : axes_(other.axes_.begin(), other.axes_.end()),
-        storage_(other.storage_) {}
-
-  template <typename A, typename S>
-  explicit histogram(histogram<true, A, S> &&other)
-      : axes_(std::move(other.axes_)), storage_(std::move(other.storage_)) {}
-
-  template <typename A, typename S>
-  histogram &operator=(const histogram<true, A, S> &other) {
-    if (static_cast<const void *>(this) != static_cast<const void *>(&other)) {
-      axes_ = other.axes_;
-      storage_ = other.storage_;
-    }
-    return *this;
-  }
-
-  template <typename A, typename S>
-  histogram &operator=(histogram<true, A, S> &&other) {
-    if (static_cast<const void *>(this) != static_cast<const void *>(&other)) {
-      axes_ = std::move(other.axes_);
-      storage_ = std::move(other.storage_);
-    }
-    return *this;
-  }
-
-  template <typename A, typename S>
-  bool operator==(const histogram<true, A, S> &other) const {
-    if (mpl::empty<
-            typename detail::intersection<Axes, A>::type>::value) {
-      return false;
-    }
-    if (dim() != other.dim()) {
-      return false;
-    }
-    if (!axes_equal_to(other.axes_)) {
-      return false;
-    }
-    if (!(storage_ == other.storage_)) {
-      return false;
-    }
-    return true;
-  }
-
-  template <bool D, typename A, typename S>
-  histogram &operator+=(const histogram<D, A, S> &other) {
-    static_assert(
-        !mpl::empty<typename detail::intersection<Axes, A>::type>::value,
-        "histograms lack common axes types");
-    if (dim() != other.dim()) {
-      throw std::logic_error("dimensions of histograms differ");
-    }
-    if (size() != other.size()) {
-      throw std::logic_error("sizes of histograms differ");
-    }
-    if (!axes_equal_to(other.axes_)) {
-      throw std::logic_error("axes of histograms differ");
-    }
-    storage_ += other.storage_;
-    return *this;
-  }
-
-  template <typename... Values> void fill(Values... values) {
-    BOOST_ASSERT_MSG(sizeof...(values) == dim(),
-                     "number of arguments does not match histogram dimension");
-    const auto p =
-        apply_lin<detail::xlin, Values...>(size_pair(0, 1), values...);
-    if (p.second) {
-      storage_.increase(p.first);
-    }
-  }
-
-  template <typename Iterator, typename = detail::is_iterator<Iterator>>
-  void fill(Iterator begin, Iterator end) {
-    BOOST_ASSERT_MSG(std::distance(begin, end) == dim(),
-                     "number of arguments does not match histogram dimension");
-    const auto p = apply_lin_iter<detail::xlin>(size_pair(0, 1), begin);
-    if (p.second) {
-      storage_.increase(p.first);
-    }
-  }
-
-  template <typename... Values> void wfill(value_type w, Values... values) {
-    BOOST_ASSERT_MSG(sizeof...(values) == dim(),
-                     "number of arguments does not match histogram dimension");
-    const auto p =
-        apply_lin<detail::xlin, Values...>(size_pair(0, 1), values...);
-    if (p.second) {
-      storage_.increase(p.first, w);
-    }
-  }
-
-  template <typename Iterator, typename = detail::is_iterator<Iterator>>
-  void wfill(value_type w, Iterator begin, Iterator end) {
-    BOOST_ASSERT_MSG(std::distance(begin, end) == dim(),
-                     "number of arguments does not match histogram dimension");
-    const auto p = apply_lin_iter<detail::xlin>(size_pair(0, 1), begin);
-    if (p.second) {
-      storage_.increase(p.first, w);
-    }
-  }
-
-  template <typename... Indices> value_type value(Indices... indices) const {
-    BOOST_ASSERT_MSG(sizeof...(indices) == dim(),
-                     "number of arguments does not match histogram dimension");
-    const auto p =
-        apply_lin<detail::lin, Indices...>(size_pair(0, 1), indices...);
-    if (p.second == 0) {
-      throw std::out_of_range("invalid index");
-    }
-    return storage_.value(p.first);
-  }
-
-  template <typename Iterator, typename = detail::is_iterator<Iterator>>
-  value_type value(Iterator begin, Iterator end) const {
-    BOOST_ASSERT_MSG(std::distance(begin, end) == dim(),
-                     "number of arguments does not match histogram dimension");
-    const auto p = apply_lin_iter<detail::lin>(size_pair(0, 1), begin);
-    if (p.second == 0) {
-      throw std::out_of_range("invalid index");
-    }
-    return storage_.value(p.first);
-  }
-
-  template <typename... Indices> value_type variance(Indices... indices) const {
-    static_assert(detail::has_variance<Storage>::value,
-                  "Storage lacks variance support");
-    BOOST_ASSERT_MSG(sizeof...(indices) == dim(),
-                     "number of arguments does not match histogram dimension");
-    const auto p =
-        apply_lin<detail::lin, Indices...>(size_pair(0, 1), indices...);
-    if (p.second == 0) {
-      throw std::out_of_range("invalid index");
-    }
-    return storage_.variance(p.first);
-  }
-
-  template <typename Iterator, typename = detail::is_iterator<Iterator>>
-  value_type variance(Iterator begin, Iterator end) const {
-    static_assert(detail::has_variance<Storage>::value,
-                  "Storage lacks variance support");
-    BOOST_ASSERT_MSG(std::distance(begin, end) == dim(),
-                     "number of arguments does not match histogram dimension");
-    const auto p = apply_lin_iter<detail::lin>(size_pair(0, 1), begin);
-    if (p.second == 0) {
-      throw std::out_of_range("invalid index");
-    }
-    return storage_.variance(p.first);
-  }
-
-  /// Number of axes (dimensions) of histogram
-  unsigned dim() const { return axes_.size(); }
-
-  /// Total number of bins in the histogram (including underflow/overflow)
-  std::size_t size() const { return storage_.size(); }
-
-  /// Sum of all counts in the histogram
-  double sum() const {
-    double result = 0.0;
-    for (std::size_t i = 0, n = size(); i < n; ++i) {
-      result += storage_.value(i);
-    }
-    return result;
-  }
-
-  /// Return axis \a i
-  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_type &axis() const {
-    BOOST_ASSERT_MSG(N < dim(), "axis index out of range");
-    return axes_[N];
-  }
-
-  /// Apply unary functor/function to each axis
-  template <typename Unary> void for_each_axis(Unary &unary) const {
-    for (const auto &a : axes_) {
-      apply_visitor(detail::unary_visitor<Unary>(unary), a);
-    }
-  }
-
-private:
-  axes_type axes_;
-  Storage storage_;
-
-  std::size_t field_count() const {
-    detail::field_count fc;
-    for (const auto &a : axes_) {
-      apply_visitor(fc, a);
-    }
-    return fc.value;
-  }
-
-  template <typename A>
-  bool axes_equal_to(const A &other_axes) const {
-    detail::cmp_axis ca;
-    for (unsigned i = 0; i < dim(); ++i) {
-      if (!apply_visitor(ca, axes_[i], other_axes[i])) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  template <template <class, class> class Lin, typename Value>
-  struct lin_visitor : public static_visitor<size_pair> {
-    mutable size_pair pa;
-    const Value &val;
-    lin_visitor(const size_pair &p, const Value &v) : pa(p), val(v) {}
-    template <typename A> size_pair operator()(const A &a) const {
-      Lin<A, Value>::apply(pa.first, pa.second, a, val);
-      return pa;
-    }
-  };
-
-  template <template <class, class> class Lin, typename First, typename... Rest>
-  size_pair apply_lin(size_pair &&p, const First &first,
-                      const Rest &... rest) const {
-    p = apply_visitor(lin_visitor<Lin, First>(p, first),
-                      axes_[dim() - 1 - sizeof...(Rest)]);
-    return apply_lin<Lin, Rest...>(std::move(p), rest...);
-  }
-
-  template <template <class, class> class Lin>
-  size_pair apply_lin(size_pair &&p) const {
-    return p;
-  }
-
-  template <template <class, class> class Lin, typename Iterator>
-  size_pair apply_lin_iter(size_pair &&p, Iterator iter) const {
-    for (const auto &a : axes_) {
-      p = apply_visitor(lin_visitor<Lin, decltype(*iter)>(p, *iter), a);
-      ++iter;
-    }
-    return p;
-  }
-
-  friend struct storage_access;
-
-  template <bool D, typename A, typename S> friend class histogram;
-
-  template <typename Archiv, typename A, typename S>
-  friend void serialize(Archiv &, histogram<true, A, S> &, unsigned);
-};
-
-template <typename... Axes>
-inline histogram<true, default_axes> make_dynamic_histogram(Axes &&... axes) {
-  return histogram<true, default_axes>(std::forward<Axes>(axes)...);
-}
-
-template <typename Storage, typename... Axes>
-inline histogram<true, default_axes, Storage>
-make_dynamic_histogram_with(Axes &&... axes) {
-  return histogram<true, default_axes, Storage>(std::forward<Axes>(axes)...);
-}
-} // namespace histogram
-} // namespace boost
-
-#endif
diff --git a/include/boost/histogram/histogram_fwd.hpp b/include/boost/histogram/histogram_fwd.hpp
index f996ea42..5788b13a 100644
--- a/include/boost/histogram/histogram_fwd.hpp
+++ b/include/boost/histogram/histogram_fwd.hpp
@@ -12,7 +12,12 @@
 namespace boost {
 namespace histogram {
 
-template <bool Dynamic, class Axes, class Storage = adaptive_storage<>>
+enum type {
+    Static,
+    Dynamic,
+};
+
+template <type, class Axes, class Storage = adaptive_storage<>>
 class histogram;
 
 } // namespace histogram
diff --git a/include/boost/histogram/histogram_ostream_operators.hpp b/include/boost/histogram/histogram_ostream_operators.hpp
index 16f926a2..65d9fd0d 100644
--- a/include/boost/histogram/histogram_ostream_operators.hpp
+++ b/include/boost/histogram/histogram_ostream_operators.hpp
@@ -24,7 +24,7 @@ struct axis_ostream_visitor {
 };
 } // namespace detail
 
-template <bool D, typename A, typename S>
+template <type D, typename A, typename S>
 inline std::ostream &operator<<(std::ostream &os, const histogram<D, A, S> &h) {
   os << "histogram(";
   detail::axis_ostream_visitor sh(os);
diff --git a/include/boost/histogram/histogram_static_impl.hpp b/include/boost/histogram/histogram_static_impl.hpp
deleted file mode 100644
index 8221b0bc..00000000
--- a/include/boost/histogram/histogram_static_impl.hpp
+++ /dev/null
@@ -1,231 +0,0 @@
-// Copyright 2015-2017 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_HISTOGRAM_STATIC_IMPL_HPP_
-#define _BOOST_HISTOGRAM_HISTOGRAM_STATIC_IMPL_HPP_
-
-#include <boost/config.hpp>
-#include <boost/fusion/adapted/mpl.hpp>
-#include <boost/fusion/algorithm.hpp>
-#include <boost/fusion/container/vector/convert.hpp>
-#include <boost/fusion/include/algorithm.hpp>
-#include <boost/fusion/include/as_vector.hpp>
-#include <boost/fusion/include/comparison.hpp>
-#include <boost/fusion/include/mpl.hpp>
-#include <boost/fusion/include/sequence.hpp>
-#include <boost/fusion/sequence.hpp>
-#include <boost/fusion/sequence/comparison.hpp>
-#include <boost/histogram/axis.hpp>
-#include <boost/histogram/detail/axis_visitor.hpp>
-#include <boost/histogram/detail/meta.hpp>
-#include <boost/histogram/detail/utility.hpp>
-#include <boost/histogram/histogram_fwd.hpp>
-#include <boost/histogram/storage/adaptive_storage.hpp>
-#include <boost/mpl/empty.hpp>
-#include <boost/mpl/vector.hpp>
-#include <type_traits>
-
-namespace boost {
-namespace histogram {
-
-template <typename Axes, typename Storage>
-class histogram<false, Axes, Storage> {
-  static_assert(!mpl::empty<Axes>::value, "at least one axis required");
-  using size_pair = std::pair<std::size_t, std::size_t>;
-  using axes_size = typename fusion::result_of::size<Axes>::type;
-
-public:
-  using value_type = typename Storage::value_type;
-
-private:
-  using axes_type = typename fusion::result_of::as_vector<Axes>::type;
-
-public:
-  histogram() = default;
-
-  template <typename... Axes1>
-  explicit histogram(const Axes1 &... axes) : axes_(axes...) {
-    storage_ = Storage(field_count());
-  }
-
-  histogram(const histogram &other) = default;
-  histogram(histogram &&other) = default;
-  histogram &operator=(const histogram &other) = default;
-  histogram &operator=(histogram &&other) = default;
-
-  template <typename S>
-  explicit histogram(const histogram<false, Axes, S> &other)
-      : axes_(other.axes_), storage_(other.storage_) {}
-
-  template <typename S>
-  explicit histogram(histogram<false, Axes, S> &&other)
-      : axes_(std::move(other.axes_)), storage_(std::move(other.storage_)) {}
-
-  template <typename S>
-  histogram &operator=(const histogram<false, Axes, S> &other) {
-    if (static_cast<const void *>(this) != static_cast<const void *>(&other)) {
-      axes_ = other.axes_;
-      storage_ = other.storage_;
-    }
-    return *this;
-  }
-
-  template <typename S>
-  histogram &operator=(histogram<false, Axes, S> &&other) {
-    if (static_cast<const void *>(this) != static_cast<const void *>(&other)) {
-      axes_ = std::move(other.axes_);
-      storage_ = std::move(other.storage_);
-    }
-    return *this;
-  }
-
-  template <typename A, typename S>
-  bool operator==(const histogram<false, A, S> &other) const {
-    if (!axes_equal_to(other.axes_)) {
-      return false;
-    }
-    return storage_ == other.storage_;
-  }
-
-  template <typename S>
-  histogram &operator+=(const histogram<false, Axes, S> &other) {
-    if (!axes_equal_to(other.axes_)) {
-      throw std::logic_error("axes of histograms differ");
-    }
-    storage_ += other.storage_;
-    return *this;
-  }
-
-  template <typename... Values> void fill(Values... values) {
-    static_assert(sizeof...(values) == axes_size::value,
-                  "number of arguments does not match histogram dimension");
-    const auto p =
-        apply_lin<detail::xlin, Values...>(size_pair(0, 1), values...);
-    if (p.second) {
-      storage_.increase(p.first);
-    }
-  }
-
-  template <typename... Values> void wfill(value_type w, Values... values) {
-    static_assert(sizeof...(values) == axes_size::value,
-                  "number of arguments does not match histogram dimension");
-    const auto p =
-        apply_lin<detail::xlin, Values...>(size_pair(0, 1), values...);
-    if (p.second) {
-      storage_.increase(p.first, w);
-    }
-  }
-
-  template <typename... Indices> value_type value(Indices... indices) const {
-    static_assert(sizeof...(indices) == axes_size::value,
-                  "number of arguments does not match histogram dimension");
-    const auto p =
-        apply_lin<detail::lin, Indices...>(size_pair(0, 1), indices...);
-    if (p.second == 0) {
-      throw std::out_of_range("invalid index");
-    }
-    return storage_.value(p.first);
-  }
-
-  template <typename... Indices> value_type variance(Indices... indices) const {
-    static_assert(detail::has_variance<Storage>::value,
-                  "Storage lacks variance support");
-    static_assert(sizeof...(indices) == axes_size::value,
-                  "number of arguments does not match histogram dimension");
-    const auto p =
-        apply_lin<detail::lin, Indices...>(size_pair(0, 1), indices...);
-    if (p.second == 0) {
-      throw std::out_of_range("invalid index");
-    }
-    return storage_.variance(p.first);
-  }
-
-  /// Number of axes (dimensions) of histogram
-  constexpr unsigned dim() const { return axes_size::value; }
-
-  /// Total number of bins in the histogram (including underflow/overflow)
-  std::size_t size() const { return storage_.size(); }
-
-  /// Sum of all counts in the histogram
-  double sum() const {
-    double result = 0.0;
-    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_type, N>::type>::type &
-  axis() const {
-    static_assert(N < axes_size::value, "axis index out of range");
-    return fusion::at_c<N>(axes_);
-  }
-
-  /// Apply unary functor/function to each axis
-  template <typename Unary> void for_each_axis(Unary &unary) const {
-    fusion::for_each(axes_, unary);
-  }
-
-private:
-  axes_type axes_;
-  Storage storage_;
-
-  std::size_t field_count() const {
-    detail::field_count fc;
-    fusion::for_each(axes_, fc);
-    return fc.value;
-  }
-
-  template <typename A> bool axes_equal_to(const A & /*unused*/) const {
-    return false;
-  }
-
-  bool axes_equal_to(const axes_type &other_axes) const {
-    return axes_ == other_axes;
-  }
-
-  template <template <class, class> class Lin, typename First, typename... Rest>
-  size_pair apply_lin(size_pair &&p, const First &x,
-                      const Rest &... rest) const {
-    Lin<typename fusion::result_of::value_at_c<
-            axes_type, (axes_size::value - 1 - sizeof...(Rest))>::type,
-        First>::apply(p.first, p.second,
-                      fusion::at_c<(axes_size::value - 1 - sizeof...(Rest))>(
-                          axes_),
-                      x);
-    return apply_lin<Lin, Rest...>(std::move(p), rest...);
-  }
-
-  template <template <class, class> class Lin>
-  size_pair apply_lin(size_pair &&p) const {
-    return p;
-  }
-
-  template <bool D, typename A, typename S> friend class histogram;
-
-  template <class Archive, class S, class A>
-  friend void serialize(Archive &, histogram<false, S, A> &, unsigned);
-};
-
-/// default static type factory
-template <typename... Axes>
-inline histogram<false, mpl::vector<Axes...>>
-make_static_histogram(const Axes &... axes) {
-  return histogram<false, mpl::vector<Axes...>>(axes...);
-}
-
-/// static type factory with variable storage type
-template <typename Storage, typename... Axes>
-inline histogram<false, mpl::vector<Axes...>, Storage>
-make_static_histogram_with(const Axes &... axes) {
-  return histogram<false, mpl::vector<Axes...>, Storage>(axes...);
-}
-} // namespace histogram
-} // namespace boost
-
-#endif
diff --git a/include/boost/histogram/serialization.hpp b/include/boost/histogram/serialization.hpp
index dc6774b5..c9c31352 100644
--- a/include/boost/histogram/serialization.hpp
+++ b/include/boost/histogram/serialization.hpp
@@ -177,7 +177,7 @@ template <typename Archive> struct serialize_helper {
 } // namespace
 
 template <class Archive, class S, class A>
-inline void serialize(Archive &ar, histogram<false, S, A> &h,
+inline void serialize(Archive &ar, histogram<Static, S, A> &h,
                       unsigned /* version */) {
   serialize_helper<Archive> sh(ar);
   fusion::for_each(h.axes_, sh);
@@ -185,7 +185,7 @@ inline void serialize(Archive &ar, histogram<false, S, A> &h,
 }
 
 template <class Archive, class S, class A>
-inline void serialize(Archive &ar, histogram<true, S, A> &h,
+inline void serialize(Archive &ar, histogram<Dynamic, S, A> &h,
                       unsigned /* version */) {
   ar &h.axes_;
   ar &h.storage_;
diff --git a/include/boost/histogram/storage/adaptive_storage.hpp b/include/boost/histogram/storage/adaptive_storage.hpp
index ff6279f5..39b5f753 100644
--- a/include/boost/histogram/storage/adaptive_storage.hpp
+++ b/include/boost/histogram/storage/adaptive_storage.hpp
@@ -15,7 +15,6 @@
 #include <boost/multiprecision/cpp_int.hpp>
 #include <boost/variant.hpp>
 #include <limits>
-#include <memory>
 #include <type_traits>
 
 // forward declaration for serialization workaround
@@ -94,15 +93,18 @@ private:
   void create() {
     if (size) {
       ptr = Allocator<T>::allocate(size);
-      if (!std::is_pod<T>::value)
+      if (!std::is_pod<T>::value) {
         new (ptr) T[size];
+      }
     }
   }
   void destroy() {
     if (size) {
-      if (!std::is_pod<T>::value)
-        for (auto it = begin(); it != end(); ++it)
+      if (!std::is_pod<T>::value) {
+        for (auto it = begin(); it != end(); ++it) {
           it->~T();
+        }
+      }
       Allocator<T>::deallocate(ptr, size);
     }
   }
@@ -150,26 +152,24 @@ public:
   adaptive_storage(adaptive_storage &&) = default;
   adaptive_storage &operator=(adaptive_storage &&) = default;
 
-  template <typename OtherStorage, typename = detail::is_storage<OtherStorage>>
-  explicit adaptive_storage(const OtherStorage &rhs)
-      : buffer_(array<void>(rhs.size())) {
+  template <typename S, typename = detail::is_storage<S>>
+  explicit adaptive_storage(const S &rhs) : buffer_(array<void>(rhs.size())) {
     for (std::size_t i = 0, n = rhs.size(); i < n; ++i) {
-      apply_visitor(assign_visitor<typename OtherStorage::value_type>(
-                        i, rhs.value(i), buffer_),
-                    buffer_);
+      apply_visitor(
+          assign_visitor<typename S::value_type>(i, rhs.value(i), buffer_),
+          buffer_);
     }
   }
 
-  template <typename OtherStorage>
-  adaptive_storage &operator=(const OtherStorage &rhs) {
+  template <typename S> adaptive_storage &operator=(const S &rhs) {
     if (static_cast<const void *>(this) != static_cast<const void *>(&rhs)) {
       if (size() != rhs.size()) {
         buffer_ = array<void>(rhs.size());
       }
       for (std::size_t i = 0, n = rhs.size(); i < n; ++i) {
-        apply_visitor(assign_visitor<typename OtherStorage::value_type>(
-                          i, rhs.value(i), buffer_),
-                      buffer_);
+        apply_visitor(
+            assign_visitor<typename S::value_type>(i, rhs.value(i), buffer_),
+            buffer_);
       }
     }
     return *this;
@@ -193,22 +193,20 @@ public:
     return apply_visitor(variance_visitor(i), buffer_);
   }
 
-  template <typename OtherStorage>
-  adaptive_storage &operator+=(const OtherStorage &rhs) {
+  template <typename S> adaptive_storage &operator+=(const S &rhs) {
     for (std::size_t i = 0, n = rhs.size(); i < n; ++i)
-      apply_visitor(add_visitor<typename OtherStorage::value_type>(
-                        i, rhs.value(i), buffer_),
-                    buffer_);
+      apply_visitor(
+          add_visitor<typename S::value_type>(i, rhs.value(i), buffer_),
+          buffer_);
     return *this;
   }
 
-  bool operator==(const adaptive_storage &o) const {
-    return apply_visitor(bicmp_visitor(), buffer_, o.buffer_);
+  bool operator==(const adaptive_storage &rhs) const {
+    return apply_visitor(bicmp_visitor(), buffer_, rhs.buffer_);
   }
 
-  template <typename OtherStorage>
-  bool operator==(const OtherStorage &o) const {
-    return apply_visitor(cmp_visitor<OtherStorage>(o), buffer_);
+  template <typename S> bool operator==(const S &rhs) const {
+    return apply_visitor(cmp_visitor<S>(rhs), buffer_);
   }
 
 private:
@@ -241,7 +239,9 @@ private:
       (*this)(get<array<uint8_t>>(buffer));
     }
 
-    void operator()(array<mp_int> &b) const { b[idx] = static_cast<mp_int>(value); }
+    void operator()(array<mp_int> &b) const {
+      b[idx] = static_cast<mp_int>(value);
+    }
 
     void operator()(array<weight> &b) const { b[idx] = value; }
   };
@@ -402,10 +402,9 @@ private:
     }
   };
 
-  template <typename OtherStorage>
-  struct cmp_visitor : public static_visitor<bool> {
-    const OtherStorage &os;
-    cmp_visitor(const OtherStorage &o) : os(o) {}
+  template <typename S> struct cmp_visitor : public static_visitor<bool> {
+    const S &os;
+    cmp_visitor(const S &o) : os(o) {}
 
     template <typename Array> bool operator()(const Array &b) const {
       if (b.size != os.size())
@@ -457,8 +456,8 @@ private:
   template <class Archive> void serialize(Archive &, unsigned);
 };
 
-template <template <class> class Allocator, typename OtherStorage>
-bool operator==(const OtherStorage &a, const adaptive_storage<Allocator> &b) {
+template <template <class> class Allocator, typename S>
+bool operator==(const S &a, const adaptive_storage<Allocator> &b) {
   return b == a;
 }
 
diff --git a/include/boost/histogram/storage/container_storage.hpp b/include/boost/histogram/storage/container_storage.hpp
index 3d00d0b2..78533099 100644
--- a/include/boost/histogram/storage/container_storage.hpp
+++ b/include/boost/histogram/storage/container_storage.hpp
@@ -70,27 +70,21 @@ public:
     }
   }
 
+  template <typename C> bool operator==(const container_storage<C> &rhs) {
+    return container_.size() == rhs.container_.size() &&
+           std::equal(container_.begin(), container_.end(),
+                      rhs.container_.begin());
+  }
+
 private:
   Container container_;
 
-  template <typename Container1, typename Container2>
-  friend bool operator==(const container_storage<Container1> &,
-                         const container_storage<Container2> &);
+  template <typename C> friend class container_storage;
 
   template <typename Archive, typename C>
   friend void serialize(Archive &, container_storage<C> &, unsigned);
 };
 
-template <typename Container1, typename Container2>
-bool operator==(const container_storage<Container1> &a,
-                const container_storage<Container2> &b) {
-  if (a.container_.size() != b.container_.size()) {
-    return false;
-  }
-  return std::equal(a.container_.begin(), a.container_.end(),
-                    b.container_.begin());
-}
-
 } // namespace histogram
 } // namespace boost
 
diff --git a/src/python/histogram.cpp b/src/python/histogram.cpp
index f71eaead..ab70f0fb 100644
--- a/src/python/histogram.cpp
+++ b/src/python/histogram.cpp
@@ -29,7 +29,7 @@
 namespace boost {
 namespace histogram {
 
-using dynamic_histogram = histogram<true, default_axes, adaptive_storage<>>;
+using dynamic_histogram = histogram<Dynamic, default_axes, adaptive_storage<>>;
 
 #ifdef HAVE_NUMPY
 auto array_cast = [](python::handle<>& h) {
diff --git a/test/adaptive_storage_test.cpp b/test/adaptive_storage_test.cpp
index 914abe65..ef06fbcd 100644
--- a/test/adaptive_storage_test.cpp
+++ b/test/adaptive_storage_test.cpp
@@ -209,6 +209,7 @@ template <typename T> void convert_container_storage_impl() {
     t += t;
   auto d = aref;
   d = t;
+  BOOST_TEST(d == t);
 
   auto e = aref;
   e = s;
@@ -231,7 +232,10 @@ template <typename T> void convert_container_storage_impl() {
 
   container_storage<std::vector<uint8_t>> u(2);
   u.increase(0);
-  BOOST_TEST(!(aref == u));
+  auto h = aref;
+  BOOST_TEST(!(h == u));
+  h = u;
+  BOOST_TEST(h == u);
 }
 
 template <> void convert_container_storage_impl<void>() {
diff --git a/test/dynamic_histogram_test.cpp b/test/dynamic_histogram_test.cpp
index 03cf85d3..153861fc 100644
--- a/test/dynamic_histogram_test.cpp
+++ b/test/dynamic_histogram_test.cpp
@@ -27,61 +27,61 @@ int main() {
 
   // init_0
   {
-    auto h = histogram<true, default_axes>();
+    auto h = histogram<Dynamic, default_axes>();
     BOOST_TEST_EQ(h.dim(), 0u);
     BOOST_TEST_EQ(h.size(), 0u);
-    auto h2 = histogram<true, default_axes,
+    auto h2 = histogram<Dynamic, default_axes,
                         container_storage<std::vector<unsigned>>>();
     BOOST_TEST(h2 == h);
   }
 
   // init_1
   {
-    auto h = histogram<true, default_axes>(regular_axis<>{3, -1, 1});
+    auto h = histogram<Dynamic, default_axes>(regular_axis<>{3, -1, 1});
     BOOST_TEST_EQ(h.dim(), 1u);
     BOOST_TEST_EQ(h.size(), 5u);
     BOOST_TEST_EQ(shape(h.axis(0)), 5);
     auto h2 =
-        histogram<true, default_axes, container_storage<std::vector<unsigned>>>(
+        histogram<Dynamic, default_axes, container_storage<std::vector<unsigned>>>(
             regular_axis<>{3, -1, 1});
     BOOST_TEST(h2 == h);
   }
 
   // init_2
   {
-    auto h = histogram<true, default_axes>(regular_axis<>{3, -1, 1},
+    auto h = histogram<Dynamic, default_axes>(regular_axis<>{3, -1, 1},
                                            integer_axis{-1, 1});
     BOOST_TEST_EQ(h.dim(), 2u);
     BOOST_TEST_EQ(h.size(), 25u);
     BOOST_TEST_EQ(shape(h.axis(0)), 5);
     BOOST_TEST_EQ(shape(h.axis(1)), 5);
     auto h2 =
-        histogram<true, default_axes, container_storage<std::vector<unsigned>>>(
+        histogram<Dynamic, default_axes, container_storage<std::vector<unsigned>>>(
             regular_axis<>{3, -1, 1}, integer_axis{-1, 1});
     BOOST_TEST(h2 == h);
   }
 
   // init_3
   {
-    auto h = histogram<true, default_axes>(
+    auto h = histogram<Dynamic, default_axes>(
         regular_axis<>{3, -1, 1}, integer_axis{-1, 1}, circular_axis<>{3});
     BOOST_TEST_EQ(h.dim(), 3u);
     BOOST_TEST_EQ(h.size(), 75u);
     auto h2 =
-        histogram<true, default_axes, container_storage<std::vector<unsigned>>>(
+        histogram<Dynamic, default_axes, container_storage<std::vector<unsigned>>>(
             regular_axis<>{3, -1, 1}, integer_axis{-1, 1}, circular_axis<>{3});
     BOOST_TEST(h2 == h);
   }
 
   // init_4
   {
-    auto h = histogram<true, default_axes>(
+    auto h = histogram<Dynamic, default_axes>(
         regular_axis<>{3, -1, 1}, integer_axis{-1, 1}, circular_axis<>{3},
         variable_axis<>{-1, 0, 1});
     BOOST_TEST_EQ(h.dim(), 4u);
     BOOST_TEST_EQ(h.size(), 300u);
     auto h2 =
-        histogram<true, default_axes, container_storage<std::vector<unsigned>>>(
+        histogram<Dynamic, default_axes, container_storage<std::vector<unsigned>>>(
             regular_axis<>{3, -1, 1}, integer_axis{-1, 1}, circular_axis<>{3},
             variable_axis<>{-1, 0, 1});
     BOOST_TEST(h2 == h);
@@ -102,10 +102,10 @@ int main() {
 
   // init_6
   {
-    auto v = std::vector<histogram<true, default_axes>::axis_type>();
+    auto v = std::vector<histogram<Dynamic, default_axes>::axis_type>();
     v.push_back(regular_axis<>(100, -1, 1));
     v.push_back(integer_axis(1, 6));
-    auto h = histogram<true, default_axes>(v.begin(), v.end());
+    auto h = histogram<Dynamic, default_axes>(v.begin(), v.end());
     BOOST_TEST_EQ(h.axis(0), v[0]);
     BOOST_TEST_EQ(h.axis(1), v[1]);
   }
@@ -118,7 +118,7 @@ int main() {
     auto h2 = decltype(h)(h);
     BOOST_TEST(h2 == h);
     auto h3 =
-        histogram<true, default_axes, container_storage<std::vector<unsigned>>>(
+        histogram<Dynamic, default_axes, container_storage<std::vector<unsigned>>>(
             h);
     BOOST_TEST(h3 == h);
   }
@@ -129,13 +129,13 @@ int main() {
         integer_axis(0, 1), integer_axis(0, 2));
     h.fill(0, 0);
     auto h2 = decltype(h)();
-    BOOST_TEST(!(h == h2));
+    BOOST_TEST(h != h2);
     h2 = h;
     BOOST_TEST(h == h2);
     // test self-assign
     h2 = h2;
     BOOST_TEST(h == h2);
-    auto h3 = histogram<true, default_axes,
+    auto h3 = histogram<Dynamic, default_axes,
                         container_storage<std::vector<unsigned>>>();
     h3 = h;
     BOOST_TEST(h == h3);
@@ -160,30 +160,30 @@ int main() {
 
   // equal_compare
   {
-    auto a = histogram<true, default_axes>(integer_axis(0, 1));
+    auto a = histogram<Dynamic, default_axes>(integer_axis(0, 1));
     auto b =
-        histogram<true, default_axes>(integer_axis(0, 1), integer_axis(0, 2));
-    BOOST_TEST(!(a == b));
-    BOOST_TEST(!(b == a));
+        histogram<Dynamic, default_axes>(integer_axis(0, 1), integer_axis(0, 2));
+    BOOST_TEST(a != b);
+    BOOST_TEST(b != a);
     auto c =
-        histogram<true, mpl::vector<integer_axis>,
+        histogram<Dynamic, mpl::vector<integer_axis>,
                   container_storage<std::vector<unsigned>>>(integer_axis(0, 1));
-    BOOST_TEST(!(b == c));
-    BOOST_TEST(!(c == b));
+    BOOST_TEST(b != c);
+    BOOST_TEST(c != b);
     BOOST_TEST(a == c);
     BOOST_TEST(c == a);
     auto d = make_dynamic_histogram(regular_axis<>(2, 0, 1));
-    BOOST_TEST(!(c == d));
-    BOOST_TEST(!(d == c));
+    BOOST_TEST(c != d);
+    BOOST_TEST(d != c);
     c.fill(0);
-    BOOST_TEST(!(a == c));
-    BOOST_TEST(!(c == a));
+    BOOST_TEST(a != c);
+    BOOST_TEST(c != a);
     a.fill(0);
     BOOST_TEST(a == c);
     BOOST_TEST(c == a);
     a.fill(0);
-    BOOST_TEST(!(a == c));
-    BOOST_TEST(!(c == a));
+    BOOST_TEST(a != c);
+    BOOST_TEST(c != a);
   }
 
   // d1
@@ -385,8 +385,8 @@ int main() {
 
   // add_1
   {
-    auto a = histogram<true, mpl::vector<integer_axis>>(integer_axis(-1, 1));
-    auto b = histogram<true, mpl::vector<integer_axis, regular_axis<>>,
+    auto a = histogram<Dynamic, mpl::vector<integer_axis>>(integer_axis(-1, 1));
+    auto b = histogram<Dynamic, mpl::vector<integer_axis, regular_axis<>>,
                        container_storage<std::vector<unsigned>>>(
         integer_axis(-1, 1));
     a.fill(-1);
@@ -494,7 +494,7 @@ int main() {
       buf = os.str();
     }
     auto b = make_dynamic_histogram();
-    BOOST_TEST(!(a == b));
+    BOOST_TEST(a != b);
     {
       std::istringstream is(buf);
       boost::archive::text_iarchive ia(is);
diff --git a/test/static_histogram_test.cpp b/test/static_histogram_test.cpp
index bee70c11..0a95975b 100644
--- a/test/static_histogram_test.cpp
+++ b/test/static_histogram_test.cpp
@@ -24,15 +24,15 @@ int main() {
 
   // init_0
   {
-    auto h = histogram<false, mpl::vector<integer_axis>, adaptive_storage<>>();
+    auto h = histogram<Static, mpl::vector<integer_axis>, adaptive_storage<>>();
     BOOST_TEST_EQ(h.dim(), 1);
     BOOST_TEST_EQ(h.size(), 0);
-    auto h2 = histogram<false, mpl::vector<integer_axis>,
+    auto h2 = histogram<Static, mpl::vector<integer_axis>,
                         container_storage<std::vector<unsigned>>>();
     BOOST_TEST(h2 == h);
     auto h3 =
-        histogram<false, mpl::vector<regular_axis<>>, adaptive_storage<>>();
-    BOOST_TEST(!(h3 == h));
+        histogram<Static, mpl::vector<regular_axis<>>, adaptive_storage<>>();
+    BOOST_TEST(h3 != h);
   }
 
   // init_1
@@ -108,7 +108,7 @@ int main() {
     h.fill(0, 0);
     auto h2 = decltype(h)(h);
     BOOST_TEST(h2 == h);
-    auto h3 = histogram<false, mpl::vector<integer_axis, integer_axis>,
+    auto h3 = histogram<Static, mpl::vector<integer_axis, integer_axis>,
                         container_storage<std::vector<unsigned>>>(h);
     BOOST_TEST(h3 == h);
   }
@@ -118,13 +118,13 @@ int main() {
     auto h = make_static_histogram(integer_axis(0, 1), integer_axis(0, 2));
     h.fill(0, 0);
     auto h2 = decltype(h)();
-    BOOST_TEST(!(h == h2));
+    BOOST_TEST(h != h2);
     h2 = h;
     BOOST_TEST(h == h2);
     // test self-assign
     h2 = h2;
     BOOST_TEST(h == h2);
-    auto h3 = histogram<false, mpl::vector<integer_axis, integer_axis>,
+    auto h3 = histogram<Static, mpl::vector<integer_axis, integer_axis>,
                         container_storage<std::vector<unsigned>>>();
     h3 = h;
     BOOST_TEST(h == h3);
@@ -152,25 +152,25 @@ int main() {
   {
     auto a = make_static_histogram(integer_axis(0, 1));
     auto b = make_static_histogram(integer_axis(0, 1), integer_axis(0, 2));
-    BOOST_TEST(!(a == b));
-    BOOST_TEST(!(b == a));
+    BOOST_TEST(a != b);
+    BOOST_TEST(b != a);
     auto c = make_static_histogram(integer_axis(0, 1));
-    BOOST_TEST(!(b == c));
-    BOOST_TEST(!(c == b));
+    BOOST_TEST(b != c);
+    BOOST_TEST(c != b);
     BOOST_TEST(a == c);
     BOOST_TEST(c == a);
     auto d = make_static_histogram(regular_axis<>(2, 0, 1));
-    BOOST_TEST(!(c == d));
-    BOOST_TEST(!(d == c));
+    BOOST_TEST(c != d);
+    BOOST_TEST(d != c);
     c.fill(0);
-    BOOST_TEST(!(a == c));
-    BOOST_TEST(!(c == a));
+    BOOST_TEST(a != c);
+    BOOST_TEST(c != a);
     a.fill(0);
     BOOST_TEST(a == c);
     BOOST_TEST(c == a);
     a.fill(0);
-    BOOST_TEST(!(a == c));
-    BOOST_TEST(!(c == a));
+    BOOST_TEST(a != c);
+    BOOST_TEST(c != a);
   }
 
   // d1
@@ -526,7 +526,7 @@ int main() {
       buf = os.str();
     }
     auto b = decltype(a)();
-    BOOST_TEST(!(a == b));
+    BOOST_TEST(a != b);
     {
       std::istringstream is(buf);
       boost::archive::text_iarchive ia(is);