Clean up type traits

Author: taehyounpark

README.md

@@ -1,6 +1,6 @@
 # Queryosity
 
-![Version](https://img.shields.io/badge/Version-0.3.0-blue.svg)
+![Version](https://img.shields.io/badge/Version-0.3.1-blue.svg)
 ![C++ Standard](https://img.shields.io/badge/C++-17-blue.svg)
 [![Ubuntu](https://github.com/taehyounpark/analogical/actions/workflows/ubuntu.yml/badge.svg?branch=master)](https://github.com/taehyounpark/analogical/actions/workflows/ubuntu.yml)
 [![macOS](https://github.com/taehyounpark/analogical/actions/workflows/macos.yml/badge.svg?branch=master)](https://github.com/taehyounpark/analogical/actions/workflows/macos.yml)
@@ -88,7 +88,7 @@ cmake --build .
 cmake --install .
 ```
 ```cmake
-find_package(queryosity 0.3.0 REQUIRED)
+find_package(queryosity 0.3.1 REQUIRED)
 ...
 add_library(Analysis ...)
 ...

include/queryosity/.clang-format

@@ -200,35 +200,13 @@ template <typename Fn> struct deduce_equation;
 
 template <typename Ret, typename... Args>
 struct deduce_equation<std::function<Ret(Args...)>> {
-  using type = column::equation<std::decay_t<Ret>(
-      std::remove_const_t<std::remove_reference_t<Args>>...)>;
+  using type = column::equation<std::decay_t<Ret>(std::decay_t<Args>...)>;
 };
 
 template <typename Fn>
 using equation_t = typename deduce_equation<
     typename column::expression<Fn>::function_type>::type;
 
-// evaluate traits
-template <typename T, typename = void> struct evaluator_traits;
-
-template <typename T>
-struct evaluator_traits<T,
-                        typename std::enable_if_t<
-                            queryosity::column::template is_definition_v<T>>> {
-  using evaluator_type = typename column::template evaluator<T>;
-};
-
-template <typename Fn>
-struct evaluator_traits<
-    Fn, typename std::enable_if_t<
-            !queryosity::column::template is_definition_v<Fn>>> {
-  using evaluator_type = typename queryosity::column::template evaluator<
-      queryosity::column::template equation_t<Fn>>;
-};
-
-template <typename T>
-using evaluator_t = typename evaluator_traits<T>::evaluator_type;
-
 template <typename T> using evaluated_t = typename T::evaluated_type;
 
 template <typename T>

include/queryosity/interface/column.h

@@ -10,7 +10,9 @@
 
 namespace queryosity {
 
-class column::computation {
+namespace column {
+
+class computation {
 
 public:
   computation() = default;
@@ -28,14 +30,14 @@ class column::computation {
 
   template <typename Def, typename... Args>
   auto define(Args const &...vars) const
-      -> std::unique_ptr<queryosity::column::template evaluator_t<Def>>;
+      -> std::unique_ptr<evaluator<Def>>;
 
   template <typename Ret, typename... Args>
   auto equate(std::function<Ret(Args...)> fn) const -> std::unique_ptr<
-      queryosity::column::template evaluator_t<std::function<Ret(Args...)>>>;
+      evaluator<equation<std::decay_t<Ret>(std::decay_t<Args>...)>>>;
 
   template <typename Def, typename... Cols>
-  auto evaluate(column::evaluator<Def> &calc, Cols const &...cols) -> Def *;
+  auto evaluate(evaluator<Def> &calc, Cols const &...cols) -> Def *;
 
 protected:
   template <typename Col> auto add_column(std::unique_ptr<Col> col) -> Col *;
@@ -44,6 +46,8 @@ class column::computation {
   std::vector<std::unique_ptr<column::node>> m_columns;
 };
 
+}
+
 } // namespace queryosity
 
 #include "column_conversion.h"
@@ -77,21 +81,21 @@ auto queryosity::column::computation::convert(Col const &col)
 
 template <typename Def, typename... Args>
 auto queryosity::column::computation::define(Args const &...args) const
-    -> std::unique_ptr<queryosity::column::template evaluator_t<Def>> {
-  return std::make_unique<column::evaluator<Def>>(args...);
+    -> std::unique_ptr<evaluator<Def>> {
+  return std::make_unique<evaluator<Def>>(args...);
 }
 
 template <typename Ret, typename... Args>
 auto queryosity::column::computation::equate(std::function<Ret(Args...)> fn)
     const -> std::unique_ptr<
-        queryosity::column::template evaluator_t<std::function<Ret(Args...)>>> {
+      evaluator<equation<std::decay_t<Ret>(std::decay_t<Args>...)>>> {
   return std::make_unique<
-      queryosity::column::template evaluator_t<std::function<Ret(Args...)>>>(
+      evaluator<equation<std::decay_t<Ret>(std::decay_t<Args>...)>>>(
       fn);
 }
 
 template <typename Def, typename... Cols>
-auto queryosity::column::computation::evaluate(column::evaluator<Def> &calc,
+auto queryosity::column::computation::evaluate(evaluator<Def> &calc,
                                                Cols const &...cols) -> Def * {
   auto defn = calc._evaluate(cols...);
   return this->add_column(std::move(defn));

include/queryosity/interface/column_computation.h

@@ -70,7 +70,7 @@ template <typename Def> class column::definition {
   auto _define(dataflow &df) const;
 
 protected:
-  std::function<todo<evaluator_t<Def>>(dataflow &)> m_define;
+  std::function<todo<evaluator<Def>>(dataflow &)> m_define;
 };
 
 } // namespace queryosity

include/queryosity/interface/column_definition.h

@@ -29,7 +29,7 @@ class equation<Out(Ins...)> : public definition<Out(Ins...)> {
 };
 
 template <typename Fn>
-auto make_equation(Fn fn) -> std::unique_ptr<column::template equation_t<Fn>>;
+auto make_equation(Fn fn) -> std::unique_ptr<column::equation_t<Fn>>;
 
 } // namespace column
 
@@ -47,6 +47,6 @@ Out queryosity::column::equation<Out(Ins...)>::evaluate(
 
 template <typename Fn>
 auto queryosity::column::make_equation(Fn fn)
-    -> std::unique_ptr<queryosity::column::template equation_t<Fn>> {
-  return std::make_unique<queryosity::column::template equation_t<Fn>>(fn);
+    -> std::unique_ptr<queryosity::column::equation_t<Fn>> {
+  return std::make_unique<queryosity::column::equation_t<Fn>>(fn);
 }