diff --git a/CMakeLists.txt b/CMakeLists.txt
index 90e3493..4374aa2 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -42,6 +42,9 @@ target_compile_options(
   $<$<CONFIG:Debug>:-O0> $<$<CONFIG:Debug>:-ggdb3> 
 )
 
+find_package(Threads REQUIRED)
+target_link_libraries(queryosity INTERFACE Threads::Threads)
+
 if (QUERYOSITY_INSTALL)
   include(CMakePackageConfigHelpers)
   include(GNUInstallDirs)
@@ -88,14 +91,7 @@ if (QUERYOSITY_INSTALL)
 
 endif()
 
-if (QUERYOSITY_TESTS OR QUERYOSITY_EXAMPLES)
-
-  # boost
-  find_package(Boost REQUIRED)
-  include_directories(${Boost_INCLUDE_DIRS})
-  link_directories(${Boost_LIBRARY_DIRS})
-
-
+if (QUERYOSITY_EXTENSIONS OR QUERYOSITY_TESTS OR QUERYOSITY_EXAMPLES)
   add_subdirectory("extensions")
 endif()
 
diff --git a/README.md b/README.md
index 5d4dbce..39dc136 100644
--- a/README.md
+++ b/README.md
@@ -38,7 +38,7 @@ namespace query = qty::query;
 
 using json = qty::json;
 using h1d = qty::hist::hist<double>;
-using linax = qty::hist::axis::linear;
+using linax = qty::hist::axis::regular;
 
 int main() {
 
diff --git a/docs/pages/example.md b/docs/pages/example.md
index 4bd7b11..21c1d06 100644
--- a/docs/pages/example.md
+++ b/docs/pages/example.md
@@ -21,7 +21,7 @@ namespace query = qty::query;
 
 using json = qty::json;
 using h1d = qty::hist::hist<double>;
-using linax = qty::hist::axis::linear;
+using linax = qty::hist::axis::regular;
 
 int main() {
 
diff --git a/docs/pages/guide.md b/docs/pages/guide.md
index 1c14762..eaedd55 100644
--- a/docs/pages/guide.md
+++ b/docs/pages/guide.md
@@ -162,7 +162,7 @@ Subsequently, the plan can be filled with input columns and booked at a selectio
 @cpp
 using h1d = qty::hist::hist<double>;
 using h2d = qty::hist::hist<double,double>;
-using linax = qty::hist::axis::linear;
+using linax = qty::hist::axis::regular;
 
 // instantiate a 1d histogram query filled with x over all entries
 auto q = df.make(query::plan<h1d>(linax(100,0.0,1.0))).fill(x).book(inclusive);
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
new file mode 100644
index 0000000..297245f
--- /dev/null
+++ b/examples/CMakeLists.txt
@@ -0,0 +1,8 @@
+if (QUERYOSITY_EXAMPLES)
+
+  add_executable(example-hello_world ./example-hello_world.cxx)
+  target_compile_features(example-hello_world PUBLIC cxx_std_17)
+  target_link_libraries(example-hello_world queryosity::extensions pthread ${Boost_LIBRARIES})
+  add_test(NAME example-hello_world COMMAND example-hello_world)
+
+endif()
diff --git a/examples/example-hello_world.cxx b/examples/example-hello_world.cxx
new file mode 100644
index 0000000..c09cd14
--- /dev/null
+++ b/examples/example-hello_world.cxx
@@ -0,0 +1,47 @@
+#include "queryosity/json.h"
+#include "queryosity/hist.h"
+
+#include "queryosity.h"
+
+#include <fstream>
+#include <vector>
+#include <sstream>
+
+using dataflow = qty::dataflow;
+namespace multithread = qty::multithread;
+namespace dataset = qty::dataset;
+namespace column = qty::column;
+namespace query = qty::query;
+
+using json = qty::json;
+using h1d = qty::hist::hist<double>;
+using linax = qty::hist::axis::regular;
+
+int main()
+{
+
+	dataflow df(multithread::enable(10));
+
+	std::ifstream data("data.json");
+	auto [x, w] = df.read(
+			dataset::input<json>(data),
+			dataset::column<std::vector<double>>("x_nom"),
+			dataset::column<double>("w_nom"));
+
+	auto zero = df.define(column::constant(0));
+	auto x0 = x[zero];
+
+	auto sel = df.weight(w).filter(
+			column::expression([](std::vector<double> const &v)
+												 { return v.size(); }),
+			x);
+
+	auto h_x0_w = df.make(
+											query::plan<h1d>(linax(100, 0.0, 1.0)))
+										.fill(x0)
+										.book(sel)
+										.result();
+
+	// std::ostringstream os; os << *h_x0_w;
+	// std::cout << os.str() << std::endl;
+}
\ No newline at end of file
diff --git a/extensions/CMakeLists.txt b/extensions/CMakeLists.txt
index 3456f2b..c3588a8 100644
--- a/extensions/CMakeLists.txt
+++ b/extensions/CMakeLists.txt
@@ -17,6 +17,10 @@ target_compile_options(
   $<$<CONFIG:Debug>:-O0> $<$<CONFIG:Debug>:-ggdb3> 
 )
 
+# boost::histogram
+find_package(Boost REQUIRED)
+
+# nlohmann::json
 include(FetchContent)
 FetchContent_Declare(json URL https://github.com/nlohmann/json/releases/download/v3.11.3/json.tar.xz)
 FetchContent_MakeAvailable(json)
@@ -26,7 +30,7 @@ FetchContent_MakeAvailable(csv)
 
 target_include_directories(
   queryosity_extensions 
-  PUBLIC ${CMAKE_CURRENT_SOURCE_DIR} 
+  PUBLIC ${CMAKE_CURRENT_SOURCE_DIR} ${Boost_INCLUDE_DIRS}
 )
 include(ExternalProject)
 
diff --git a/extensions/queryosity/col.h b/extensions/queryosity/col.h
deleted file mode 100644
index 4a6bd2c..0000000
--- a/extensions/queryosity/col.h
+++ /dev/null
@@ -1,45 +0,0 @@
-#pragma once
-
-#include <unordered_map>
-#include <variant>
-
-#include "queryosity.h"
-
-namespace queryosity {
-
-template <typename T>
-class col : public queryosity::query::definition<std::vector<T>(T)> {
-
-public:
-  col() = default;
-  ~col() = default;
-
-  virtual void fill(queryosity::column::observable<T>, double) override;
-  virtual std::vector<T> result() const override;
-  virtual std::vector<T>
-  merge(std::vector<std::vector<T>> const &results) const override;
-
-protected:
-  std::vector<T> m_result;
-};
-
-} // namespace queryosity
-
-template <typename T>
-void queryosity::col<T>::fill(queryosity::column::observable<T> x, double) {
-  m_result.push_back(x.value());
-}
-
-template <typename T> std::vector<T> queryosity::col<T>::result() const {
-  return m_result;
-}
-
-template <typename T>
-std::vector<T>
-queryosity::col<T>::merge(std::vector<std::vector<T>> const &results) const {
-  std::vector<T> merged;
-  for (const auto &result : results) {
-    merged.insert(merged.end(), result.begin(), result.end());
-  }
-  return merged;
-}
\ No newline at end of file
diff --git a/include/queryosity.h b/include/queryosity.h
index db153d7..d65072f 100644
--- a/include/queryosity.h
+++ b/include/queryosity.h
@@ -16,6 +16,7 @@
 
 #include "queryosity/query_aggregation.h"
 #include "queryosity/query_definition.h"
+#include "queryosity/query_series.h"
 
 #include "queryosity/dataflow.h"
 
diff --git a/include/queryosity/dataflow.h b/include/queryosity/dataflow.h
index 2a46046..76ee80c 100644
--- a/include/queryosity/dataflow.h
+++ b/include/queryosity/dataflow.h
@@ -134,8 +134,8 @@ class dataflow {
    * @return Varied lazy column.
    */
   template <typename Fn, typename... Cols>
-  auto define(column::expression<Fn> const &expr, Cols const &...cols)
-      -> typename lazy<column::equation_t<Fn>>::varied;
+  auto define(column::expression<Fn> const &expr, Cols const &...cols) ->
+      typename lazy<column::equation_t<Fn>>::varied;
 
   /**
    * @brief Define a custom column.
@@ -158,8 +158,8 @@ class dataflow {
    * @return Varied lazy column.
    */
   template <typename Def, typename... Cols>
-  auto define(column::definition<Def> const &defn, Cols const &...cols)
-      -> typename lazy<Def>::varied;
+  auto define(column::definition<Def> const &defn, Cols const &...cols) ->
+      typename lazy<Def>::varied;
 
   /**
    * @brief Initiate a cutflow.
@@ -245,10 +245,14 @@ class dataflow {
       -> lazy<column::conversion<To, column::value_t<Col>>>;
 
   template <typename Def, typename... Args> auto _define(Args &&...args);
-  template <typename Def> auto _define(column::definition<Def> const &defn) -> todo<column::evaluator<Def>>;
+  template <typename Def>
+  auto _define(column::definition<Def> const &defn)
+      -> todo<column::evaluator<Def>>;
 
   template <typename Fn> auto _equate(Fn fn);
-  template <typename Fn> auto _equate(column::expression<Fn> const &expr) -> todo<column::evaluator<column::equation_t<Fn>>> ;
+  template <typename Fn>
+  auto _equate(column::expression<Fn> const &expr)
+      -> todo<column::evaluator<column::equation_t<Fn>>>;
 
   template <typename Sel, typename Col>
   auto _select(lazy<Col> const &col) -> lazy<selection::node>;
@@ -416,8 +420,8 @@ auto queryosity::dataflow::define(
 
 template <typename Def, typename... Cols>
 auto queryosity::dataflow::define(
-    queryosity::column::definition<Def> const &defn, Cols const &...cols)
-    -> typename lazy<Def>::varied {
+    queryosity::column::definition<Def> const &defn, Cols const &...cols) ->
+    typename lazy<Def>::varied {
   return this->_define(defn).template evaluate(cols...);
 }
 
@@ -430,8 +434,8 @@ auto queryosity::dataflow::define(
 
 template <typename Fn, typename... Cols>
 auto queryosity::dataflow::define(
-    queryosity::column::expression<Fn> const &expr, Cols const &...cols)
-    -> typename lazy<column::equation_t<Fn>>::varied {
+    queryosity::column::expression<Fn> const &expr, Cols const &...cols) ->
+    typename lazy<column::equation_t<Fn>>::varied {
   return this->_equate(expr).template evaluate(cols...);
 }
 
@@ -609,13 +613,13 @@ auto queryosity::dataflow::_define(Args &&...args) {
 
 template <typename Def>
 auto queryosity::dataflow::_define(
-    queryosity::column::definition<Def> const &defn) -> todo<column::evaluator<Def>>  {
+    queryosity::column::definition<Def> const &defn)
+    -> todo<column::evaluator<Def>> {
   return defn._define(*this);
 }
 
-template <typename Fn> auto queryosity::dataflow::_equate(Fn fn){
-  return todo<column::evaluator<
-      typename column::equation_t<Fn>>>(
+template <typename Fn> auto queryosity::dataflow::_equate(Fn fn) {
+  return todo<column::evaluator<typename column::equation_t<Fn>>>(
       *this,
       ensemble::invoke(
           [fn](dataset::player *plyr) { return plyr->template equate(fn); },
@@ -624,7 +628,8 @@ template <typename Fn> auto queryosity::dataflow::_equate(Fn fn){
 
 template <typename Fn>
 auto queryosity::dataflow::_equate(
-    queryosity::column::expression<Fn> const &expr) -> todo<column::evaluator<column::equation_t<Fn>>> {
+    queryosity::column::expression<Fn> const &expr)
+    -> todo<column::evaluator<column::equation_t<Fn>>> {
   return expr._equate(*this);
 }
 
diff --git a/include/queryosity/lazy.h b/include/queryosity/lazy.h
index 7e3ecad..e8a3480 100644
--- a/include/queryosity/lazy.h
+++ b/include/queryosity/lazy.h
@@ -10,133 +10,146 @@
 #include "detail.h"
 #include "systematic_resolver.h"
 
-namespace queryosity {
-
-// mixin class to conditionally add a member variable
-template <typename Action, typename Enable = void>
-struct result_if_aggregation {};
-
-// Specialization for types satisfying is_query
-template <typename Action>
-struct result_if_aggregation<
-    Action, std::enable_if_t<query::is_aggregation_v<Action>>> {
-  using result_type = decltype(std::declval<Action>().result());
-  result_if_aggregation() : m_merged(false) {}
-  virtual ~result_if_aggregation() = default;
-
-protected:
-  result_type m_result;
-  bool m_merged;
-};
-
-/**
- * @ingroup api
- * @brief Lazy action over dataset.
- * @tparam Action Action to be performed.
- */
-template <typename Action>
-class lazy : public dataflow::node,
-             public ensemble::slotted<Action>,
-             public systematic::resolver<lazy<Action>>,
-             public result_if_aggregation<Action> {
-
-public:
-  class varied;
-
-public:
-  using action_type = Action;
-
-public:
-  friend class dataflow;
-  template <typename> friend class lazy;
-
-public:
-  lazy(dataflow &df, std::vector<Action *> const &slots)
-      : dataflow::node(df), m_slots(slots) {}
-
-  template <typename Derived>
-  lazy(dataflow &df, std::vector<Derived *> const &slots);
-  template <typename Derived>
-  lazy(dataflow &df, std::vector<std::unique_ptr<Derived>> const &slots);
-
-  lazy(const lazy &) = default;
-  lazy &operator=(const lazy &) = default;
-
-  lazy(lazy &&) = default;
-  lazy &operator=(lazy &&) = default;
-
-  virtual ~lazy() = default;
-
-  virtual std::vector<Action *> const &get_slots() const override;
-
-  virtual void set_variation(const std::string &var_name, lazy var) override;
-
-  virtual lazy &nominal() override;
-  virtual lazy &variation(const std::string &var_name) override;
-  virtual lazy const &nominal() const override;
-  virtual lazy const &variation(const std::string &var_name) const override;
-
-  virtual bool has_variation(const std::string &var_name) const override;
-  virtual std::set<std::string> get_variation_names() const override;
-
-  template <typename To, typename V = Action,
-            std::enable_if_t<queryosity::is_column_v<V>, bool> = false>
-  auto to() const -> lazy<column::valued<To>>;
-
-  template <typename Col> auto filter(lazy<Col> const &col) const;
-  template <typename Col> auto weight(lazy<Col> const &col) const;
-
-  template <typename Col> auto filter(Col const &col) const;
-  template <typename Col> auto weight(Col const &col) const;
-
-  template <typename Expr, typename... Cols>
-  auto filter(queryosity::column::expression<Expr> const &expr,
-              Cols const &...cols) const;
-
-  template <typename Expr, typename... Cols>
-  auto weight(queryosity::column::expression<Expr> const &expr,
-              Cols const &...cols) const;
-
-  template <typename Agg> auto book(Agg &&agg) const;
-  template <typename... Aggs> auto book(Aggs &&...aggs) const;
-
-  template <typename V = Action,
-            std::enable_if_t<queryosity::query::is_aggregation_v<V>,
-                             bool> = false>
-  auto result() -> decltype(std::declval<V>().result());
-
-  template <typename V = Action,
-            std::enable_if_t<queryosity::query::is_aggregation_v<V>,
-                             bool> = false>
-  auto operator->() -> decltype(std::declval<V>().result()) {
-    return this->result();
-  }
+namespace queryosity
+{
+
+  // mixin class to conditionally add a member variable
+  template <typename Action, typename Enable = void>
+  struct result_if_aggregation
+  {
+  };
+
+  // Specialization for types satisfying is_query
+  template <typename Action>
+  struct result_if_aggregation<
+      Action, std::enable_if_t<query::is_aggregation_v<Action>>>
+  {
+    using result_type = decltype(std::declval<Action>().result());
+    result_if_aggregation() : m_merged(false) {}
+    virtual ~result_if_aggregation() = default;
+
+  protected:
+    result_type m_result;
+    bool m_merged;
+  };
+
+  /**
+   * @ingroup api
+   * @brief Lazy action over dataset.
+   * @tparam Action Action to be performed.
+   */
+  template <typename Action>
+  class lazy : public dataflow::node,
+               public ensemble::slotted<Action>,
+               public systematic::resolver<lazy<Action>>,
+               public result_if_aggregation<Action>
+  {
+
+  public:
+    class varied;
+
+  public:
+    using action_type = Action;
+
+  public:
+    friend class dataflow;
+    template <typename>
+    friend class lazy;
+
+  public:
+    lazy(dataflow &df, std::vector<Action *> const &slots)
+        : dataflow::node(df), m_slots(slots) {}
+
+    template <typename Derived>
+    lazy(dataflow &df, std::vector<Derived *> const &slots);
+    template <typename Derived>
+    lazy(dataflow &df, std::vector<std::unique_ptr<Derived>> const &slots);
+
+    lazy(const lazy &) = default;
+    lazy &operator=(const lazy &) = default;
+
+    lazy(lazy &&) = default;
+    lazy &operator=(lazy &&) = default;
+
+    virtual ~lazy() = default;
+
+    virtual std::vector<Action *> const &get_slots() const override;
+
+    virtual void set_variation(const std::string &var_name, lazy var) override;
+
+    virtual lazy &nominal() override;
+    virtual lazy &variation(const std::string &var_name) override;
+    virtual lazy const &nominal() const override;
+    virtual lazy const &variation(const std::string &var_name) const override;
+
+    virtual bool has_variation(const std::string &var_name) const override;
+    virtual std::set<std::string> get_variation_names() const override;
+
+    template <typename To, typename V = Action,
+              std::enable_if_t<queryosity::is_column_v<V>, bool> = false>
+    auto to() const -> lazy<column::valued<To>>;
+
+    template <typename Col>
+    auto filter(lazy<Col> const &col) const;
+    template <typename Col>
+    auto weight(lazy<Col> const &col) const;
+
+    template <typename Col>
+    auto filter(Col const &col) const;
+    template <typename Col>
+    auto weight(Col const &col) const;
+
+    template <typename Expr, typename... Cols>
+    auto filter(queryosity::column::expression<Expr> const &expr,
+                Cols const &...cols) const;
+
+    template <typename Expr, typename... Cols>
+    auto weight(queryosity::column::expression<Expr> const &expr,
+                Cols const &...cols) const;
+
+    template <typename Agg>
+    auto book(Agg &&agg) const;
+    template <typename... Aggs>
+    auto book(Aggs &&...aggs) const;
+
+    template <typename V = Action,
+              std::enable_if_t<queryosity::query::is_aggregation_v<V>,
+                               bool> = false>
+    auto result() -> decltype(std::declval<V>().result());
+
+    template <typename V = Action,
+              std::enable_if_t<queryosity::query::is_aggregation_v<V>,
+                               bool> = false>
+    auto operator->() -> decltype(std::declval<V>().result())
+    {
+      return this->result();
+    }
 
-  DEFINE_LAZY_UNARY_OP(logical_not, !)
-  DEFINE_LAZY_UNARY_OP(minus, -)
-  DEFINE_LAZY_BINARY_OP(equality, ==)
-  DEFINE_LAZY_BINARY_OP(inequality, !=)
-  DEFINE_LAZY_BINARY_OP(addition, +)
-  DEFINE_LAZY_BINARY_OP(subtraction, -)
-  DEFINE_LAZY_BINARY_OP(multiplication, *)
-  DEFINE_LAZY_BINARY_OP(division, /)
-  DEFINE_LAZY_BINARY_OP(logical_or, ||)
-  DEFINE_LAZY_BINARY_OP(logical_and, &&)
-  DEFINE_LAZY_BINARY_OP(greater_than, >)
-  DEFINE_LAZY_BINARY_OP(less_than, <)
-  DEFINE_LAZY_BINARY_OP(greater_than_or_equal_to, >=)
-  DEFINE_LAZY_BINARY_OP(less_than_or_equal_to, <=)
-  DEFINE_LAZY_INDEX_OP()
-
-protected:
-  template <typename V = Action,
-            std::enable_if_t<queryosity::query::is_aggregation_v<V>,
-                             bool> = false>
-  void merge_results();
-
-protected:
-  std::vector<Action *> m_slots;
-};
+    DEFINE_LAZY_UNARY_OP(logical_not, !)
+    DEFINE_LAZY_UNARY_OP(minus, -)
+    DEFINE_LAZY_BINARY_OP(equality, ==)
+    DEFINE_LAZY_BINARY_OP(inequality, !=)
+    DEFINE_LAZY_BINARY_OP(addition, +)
+    DEFINE_LAZY_BINARY_OP(subtraction, -)
+    DEFINE_LAZY_BINARY_OP(multiplication, *)
+    DEFINE_LAZY_BINARY_OP(division, /)
+    DEFINE_LAZY_BINARY_OP(logical_or, ||)
+    DEFINE_LAZY_BINARY_OP(logical_and, &&)
+    DEFINE_LAZY_BINARY_OP(greater_than, >)
+    DEFINE_LAZY_BINARY_OP(less_than, <)
+    DEFINE_LAZY_BINARY_OP(greater_than_or_equal_to, >=)
+    DEFINE_LAZY_BINARY_OP(less_than_or_equal_to, <=)
+    DEFINE_LAZY_INDEX_OP()
+
+  protected:
+    template <typename V = Action,
+              std::enable_if_t<queryosity::query::is_aggregation_v<V>,
+                               bool> = false>
+    void merge_results();
+
+  protected:
+    std::vector<Action *> m_slots;
+  };
 
 } // namespace queryosity
 
@@ -148,10 +161,12 @@ template <typename Action>
 template <typename Derived>
 queryosity::lazy<Action>::lazy(dataflow &df,
                                std::vector<Derived *> const &slots)
-    : dataflow::node(df) {
+    : dataflow::node(df)
+{
   m_slots.clear();
   m_slots.reserve(slots.size());
-  for (auto slot : slots) {
+  for (auto slot : slots)
+  {
     m_slots.push_back(static_cast<Action *>(slot));
   }
 }
@@ -160,57 +175,68 @@ template <typename Action>
 template <typename Derived>
 queryosity::lazy<Action>::lazy(
     dataflow &df, std::vector<std::unique_ptr<Derived>> const &slots)
-    : dataflow::node(df) {
+    : dataflow::node(df)
+{
   m_slots.clear();
   m_slots.reserve(slots.size());
-  for (auto const &slot : slots) {
+  for (auto const &slot : slots)
+  {
     m_slots.push_back(static_cast<Action *>(slot.get()));
   }
 }
 
 template <typename Action>
-std::vector<Action *> const &queryosity::lazy<Action>::get_slots() const {
+std::vector<Action *> const &queryosity::lazy<Action>::get_slots() const
+{
   return this->m_slots;
 }
 
 template <typename Action>
-void queryosity::lazy<Action>::set_variation(const std::string &, lazy) {
+void queryosity::lazy<Action>::set_variation(const std::string &, lazy)
+{
   // should never be called
   throw std::logic_error("cannot set variation to a nominal-only action");
 }
 
-template <typename Action> auto queryosity::lazy<Action>::nominal() -> lazy & {
+template <typename Action>
+auto queryosity::lazy<Action>::nominal() -> lazy &
+{
   // this is nominal
   return *this;
 }
 
 template <typename Action>
-auto queryosity::lazy<Action>::variation(const std::string &) -> lazy & {
+auto queryosity::lazy<Action>::variation(const std::string &) -> lazy &
+{
   // propagation of variations must occur "transparently"
   return *this;
 }
 
 template <typename Action>
-auto queryosity::lazy<Action>::nominal() const -> lazy const & {
+auto queryosity::lazy<Action>::nominal() const -> lazy const &
+{
   // this is nominal
   return *this;
 }
 
 template <typename Action>
 auto queryosity::lazy<Action>::variation(const std::string &) const
-    -> lazy const & {
+    -> lazy const &
+{
   // propagation of variations must occur "transparently"
   return *this;
 }
 
 template <typename Action>
-std::set<std::string> queryosity::lazy<Action>::get_variation_names() const {
+std::set<std::string> queryosity::lazy<Action>::get_variation_names() const
+{
   // no variations to list
   return std::set<std::string>();
 }
 
 template <typename Action>
-bool queryosity::lazy<Action>::has_variation(const std::string &) const {
+bool queryosity::lazy<Action>::has_variation(const std::string &) const
+{
   // always false
   return false;
 }
@@ -218,11 +244,15 @@ bool queryosity::lazy<Action>::has_variation(const std::string &) const {
 template <typename Action>
 template <typename To, typename V,
           std::enable_if_t<queryosity::is_column_v<V>, bool>>
-auto queryosity::lazy<Action>::to() const -> lazy<column::valued<To>> {
+auto queryosity::lazy<Action>::to() const -> lazy<column::valued<To>>
+{
   if constexpr (std::is_same_v<To, column::value_t<V>> ||
-                std::is_base_of_v<To, column::value_t<V>>) {
+                std::is_base_of_v<To, column::value_t<V>>)
+  {
     return lazy<column::valued<To>>(*this->m_df, this->get_slots());
-  } else {
+  }
+  else
+  {
     return lazy<column::valued<To>>(
         *this->m_df, this->m_df->template _convert<To>(*this).get_slots());
   }
@@ -230,10 +260,14 @@ auto queryosity::lazy<Action>::to() const -> lazy<column::valued<To>> {
 
 template <typename Action>
 template <typename Col>
-auto queryosity::lazy<Action>::filter(lazy<Col> const &col) const {
-  if constexpr (std::is_base_of_v<selection::node, Action>) {
+auto queryosity::lazy<Action>::filter(lazy<Col> const &col) const
+{
+  if constexpr (std::is_base_of_v<selection::node, Action>)
+  {
     return this->m_df->template _select<selection::cut>(*this, col);
-  } else {
+  }
+  else
+  {
     static_assert(std::is_base_of_v<selection::node, Action>,
                   "filter must be called from a selection");
   }
@@ -241,10 +275,14 @@ auto queryosity::lazy<Action>::filter(lazy<Col> const &col) const {
 
 template <typename Action>
 template <typename Col>
-auto queryosity::lazy<Action>::weight(lazy<Col> const &col) const {
-  if constexpr (std::is_base_of_v<selection::node, Action>) {
+auto queryosity::lazy<Action>::weight(lazy<Col> const &col) const
+{
+  if constexpr (std::is_base_of_v<selection::node, Action>)
+  {
     return this->m_df->template _select<selection::weight>(*this, col);
-  } else {
+  }
+  else
+  {
     static_assert(std::is_base_of_v<selection::node, Action>,
                   "filter must be called from a selection");
   }
@@ -252,15 +290,20 @@ auto queryosity::lazy<Action>::weight(lazy<Col> const &col) const {
 
 template <typename Action>
 template <typename Col>
-auto queryosity::lazy<Action>::filter(Col const &col) const {
-  if constexpr (std::is_base_of_v<selection::node, Action>) {
+auto queryosity::lazy<Action>::filter(Col const &col) const
+{
+  if constexpr (std::is_base_of_v<selection::node, Action>)
+  {
     using varied_type = typename lazy<selection::node>::varied;
     auto syst = varied_type(this->filter(col.nominal()));
-    for (auto const &var_name : col.get_variation_names()) {
+    for (auto const &var_name : col.get_variation_names())
+    {
       syst.set_variation(var_name, this->filter(col.variation(var_name)));
     }
     return syst;
-  } else {
+  }
+  else
+  {
     static_assert(std::is_base_of_v<selection::node, Action>,
                   "filter must be called from a selection");
   }
@@ -268,15 +311,20 @@ auto queryosity::lazy<Action>::filter(Col const &col) const {
 
 template <typename Action>
 template <typename Col>
-auto queryosity::lazy<Action>::weight(Col const &col) const {
-  if constexpr (std::is_base_of_v<selection::node, Action>) {
+auto queryosity::lazy<Action>::weight(Col const &col) const
+{
+  if constexpr (std::is_base_of_v<selection::node, Action>)
+  {
     using varied_type = typename lazy<selection::node>::varied;
     auto syst = varied_type(this->weight(col.nominal()));
-    for (auto const &var_name : col.get_variation_names()) {
+    for (auto const &var_name : col.get_variation_names())
+    {
       syst.set_variation(var_name, this->weight(col.variation(var_name)));
     }
     return syst;
-  } else {
+  }
+  else
+  {
     static_assert(std::is_base_of_v<selection::node, Action>,
                   "weight must be called from a selection");
   }
@@ -286,11 +334,15 @@ template <typename Action>
 template <typename Expr, typename... Cols>
 auto queryosity::lazy<Action>::filter(
     queryosity::column::expression<Expr> const &expr,
-    Cols const &...cols) const {
-  if constexpr (std::is_base_of_v<selection::node, Action>) {
+    Cols const &...cols) const
+{
+  if constexpr (std::is_base_of_v<selection::node, Action>)
+  {
     auto col = this->m_df->define(expr, cols...);
     return this->filter(col);
-  } else {
+  }
+  else
+  {
     static_assert(std::is_base_of_v<selection::node, Action>,
                   "filter must be called from a selection");
   }
@@ -300,11 +352,15 @@ template <typename Action>
 template <typename Expr, typename... Cols>
 auto queryosity::lazy<Action>::weight(
     queryosity::column::expression<Expr> const &expr,
-    Cols const &...cols) const {
-  if constexpr (std::is_base_of_v<selection::node, Action>) {
+    Cols const &...cols) const
+{
+  if constexpr (std::is_base_of_v<selection::node, Action>)
+  {
     auto col = this->m_df->define(expr, cols...);
     return this->weight(col);
-  } else {
+  }
+  else
+  {
     static_assert(std::is_base_of_v<selection::node, Action>,
                   "filter must be called from a selection");
   }
@@ -312,7 +368,8 @@ auto queryosity::lazy<Action>::weight(
 
 template <typename Action>
 template <typename Agg>
-auto queryosity::lazy<Action>::book(Agg &&agg) const {
+auto queryosity::lazy<Action>::book(Agg &&agg) const
+{
   static_assert(std::is_base_of_v<selection::node, Action>,
                 "book must be called from a selection");
   return agg.book(*this);
@@ -320,7 +377,8 @@ auto queryosity::lazy<Action>::book(Agg &&agg) const {
 
 template <typename Action>
 template <typename... Aggs>
-auto queryosity::lazy<Action>::book(Aggs &&...aggs) const {
+auto queryosity::lazy<Action>::book(Aggs &&...aggs) const
+{
   static_assert(std::is_base_of_v<selection::node, Action>,
                 "book must be called from a selection");
   return std::make_tuple((aggs.book(*this), ...));
@@ -331,7 +389,8 @@ template <
     typename V,
     std::enable_if_t<queryosity::query::is_aggregation_v<V>, bool>>
 auto queryosity::lazy<Action>::result()
-    -> decltype(std::declval<V>().result()) {
+    -> decltype(std::declval<V>().result())
+{
   this->m_df->analyze();
   this->merge_results();
   return this->m_result;
@@ -341,18 +400,23 @@ template <typename Action>
 template <
     typename V,
     std::enable_if_t<queryosity::query::is_aggregation_v<V>, bool> e>
-void queryosity::lazy<Action>::merge_results() {
+void queryosity::lazy<Action>::merge_results()
+{
   if (this->m_merged)
     return;
   auto model = this->get_slot(0);
   using result_type = decltype(model->result());
   const auto nslots = this->size();
-  if (nslots == 1) {
+  if (nslots == 1)
+  {
     this->m_result = model->result();
-  } else {
+  }
+  else
+  {
     std::vector<result_type> results;
     results.reserve(nslots);
-    for (size_t islot = 0; islot < nslots; ++islot) {
+    for (size_t islot = 0; islot < nslots; ++islot)
+    {
       results.push_back(std::move(this->get_slot(islot)->result()));
     }
     this->m_result = model->merge(results);
diff --git a/include/queryosity/lazy_varied.h b/include/queryosity/lazy_varied.h
index b3e9719..bd3dd01 100644
--- a/include/queryosity/lazy_varied.h
+++ b/include/queryosity/lazy_varied.h
@@ -71,13 +71,13 @@ class lazy<Act>::varied : public dataflow::node,
             std::enable_if_t<queryosity::is_selection_v<V>, bool> = false>
   auto book(Aggs &&...aggs);
 
-  template <typename V = Act,
-            std::enable_if_t<queryosity::query::is_aggregation_v<V>,
-                             bool> = false>
+  template <
+      typename V = Act,
+      std::enable_if_t<queryosity::query::is_aggregation_v<V>, bool> = false>
   auto operator[](const std::string &var_name) -> lazy<V> &;
-  template <typename V = Act,
-            std::enable_if_t<queryosity::query::is_aggregation_v<V>,
-                             bool> = false>
+  template <
+      typename V = Act,
+      std::enable_if_t<queryosity::query::is_aggregation_v<V>, bool> = false>
   auto operator[](const std::string &var_name) const -> lazy<V> const &;
 
   DECLARE_LAZY_VARIED_UNARY_OP(-)
@@ -244,9 +244,8 @@ auto queryosity::lazy<Act>::varied::book(Aggs &&...aggs) {
 }
 
 template <typename Act>
-template <
-    typename V,
-    std::enable_if_t<queryosity::query::is_aggregation_v<V>, bool>>
+template <typename V,
+          std::enable_if_t<queryosity::query::is_aggregation_v<V>, bool>>
 auto queryosity::lazy<Act>::varied::operator[](const std::string &var_name)
     -> lazy<V> & {
   if (!this->has_variation(var_name)) {
@@ -256,9 +255,8 @@ auto queryosity::lazy<Act>::varied::operator[](const std::string &var_name)
 }
 
 template <typename Act>
-template <
-    typename V,
-    std::enable_if_t<queryosity::query::is_aggregation_v<V>, bool>>
+template <typename V,
+          std::enable_if_t<queryosity::query::is_aggregation_v<V>, bool>>
 auto queryosity::lazy<Act>::varied::operator[](
     const std::string &var_name) const -> lazy<V> const & {
   if (!this->has_variation(var_name)) {
diff --git a/include/queryosity/query_series.h b/include/queryosity/query_series.h
new file mode 100644
index 0000000..7c8f717
--- /dev/null
+++ b/include/queryosity/query_series.h
@@ -0,0 +1,65 @@
+#pragma once
+
+#include "query_definition.h"
+
+#include <vector>
+
+namespace queryosity {
+
+namespace query {
+
+template <typename T>
+class series : public queryosity::query::definition<std::vector<T>(T)> {
+
+public:
+  series() = default;
+  ~series() = default;
+
+  virtual void initialize(unsigned int, unsigned long long,
+                          unsigned long long) override;
+  virtual void fill(queryosity::column::observable<T>, double) override;
+  virtual void finalize(unsigned int) override;
+  virtual std::vector<T> result() const override;
+  virtual std::vector<T>
+  merge(std::vector<std::vector<T>> const &results) const override;
+
+protected:
+  std::vector<T> m_result;
+};
+
+} // namespace query
+
+} // namespace queryosity
+
+template <typename T>
+void queryosity::query::series<T>::initialize(unsigned int,
+                                            unsigned long long begin,
+                                            unsigned long long end) {
+  m_result.reserve(end - begin);
+}
+
+template <typename T>
+void queryosity::query::series<T>::fill(queryosity::column::observable<T> x,
+                                        double) {
+  m_result.push_back(x.value());
+}
+
+template <typename T>
+void queryosity::query::series<T>::finalize(unsigned int) {
+  m_result.resize(m_result.size());
+}
+
+template <typename T>
+std::vector<T> queryosity::query::series<T>::result() const {
+  return m_result;
+}
+
+template <typename T>
+std::vector<T> queryosity::query::series<T>::merge(
+    std::vector<std::vector<T>> const &results) const {
+  std::vector<T> merged;
+  for (const auto &result : results) {
+    merged.insert(merged.end(), result.begin(), result.end());
+  }
+  return merged;
+}
\ No newline at end of file
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 845c53b..81b44cd 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -1,11 +1,4 @@
 if (QUERYOSITY_TESTS)
-
-  find_package(Threads REQUIRED)
-
-  find_package(Boost REQUIRED)
-  include_directories(${Boost_INCLUDE_DIRS})
-  link_directories(${Boost_LIBRARY_DIRS})
-
   #add_executable(test-definition ./test-definition.cxx)
   #target_compile_features(test-definition PUBLIC cxx_std_17)
   #target_link_libraries(test-definition queryosity::extensions pthread ${Boost_LIBRARIES})
diff --git a/tests/test-multithreading.cxx b/tests/test-multithreading.cxx
index 33513e6..7dcc590 100644
--- a/tests/test-multithreading.cxx
+++ b/tests/test-multithreading.cxx
@@ -1,15 +1,13 @@
 #define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
 #include "doctest.h"
 
-#include <random>
-#include <unordered_map>
+#include <nlohmann/json.hpp>
+#include "queryosity/json.h"
 
 #include "queryosity.h"
 
-#include <nlohmann/json.hpp>
-
-#include "queryosity/col.h"
-#include "queryosity/json.h"
+#include <random>
+#include <unordered_map>
 
 using dataflow = qty::dataflow;
 namespace multithread = qty::multithread;
@@ -34,7 +32,7 @@ std::vector<int> get_queryosity_result(const nlohmann::json &random_data,
   auto entry_value = ds.read(dataset::column<int>("value"));
   auto all = df.define(column::constant<bool>(true));
   auto incl = df.filter(all);
-  auto col = df.make(query::plan<qty::col<int>>());
+  auto col = df.make(query::plan<query::series<int>>());
   col = col.fill(entry_value);
   return incl.book(col).result();
 }