From 36efc9163ca447907aa7dad76d7c0c53222d39d6 Mon Sep 17 00:00:00 2001
From: Vesa Karvonen <vesa.a.j.k@gmail.com>
Date: Sun, 14 Apr 2019 16:25:47 +0300
Subject: [PATCH] Functional basics

---
 NOTES.md                                |   4 +-
 README.md                               |  80 +++++++
 internals/testing/arithmetic_test.cpp   |  35 ++-
 internals/testing/comparison_test.cpp   |   6 +-
 internals/testing/compile_only_test.cpp |   2 +
 internals/testing/core_test.cpp         |  29 +++
 internals/testing/functional_test.cpp   |  67 ++++++
 internals/testing/logical_test.cpp      |  22 +-
 internals/testing/type_traits_test.cpp  |   8 +-
 internals/testing/value_test.cpp        |  18 +-
 provides/include/lax_v1/arithmetic.hpp  |  51 +++--
 provides/include/lax_v1/comparison.hpp  |  29 +--
 provides/include/lax_v1/core.hpp        | 245 +++++++++++++++++++++
 provides/include/lax_v1/force.hpp       |   3 -
 provides/include/lax_v1/functional.hpp  |  56 +++++
 provides/include/lax_v1/lax.hpp         |  10 +
 provides/include/lax_v1/lazify.hpp      |   4 -
 provides/include/lax_v1/logical.hpp     |  32 ++-
 provides/include/lax_v1/synopsis.hpp    | 273 ++++++++++++++++++++----
 provides/include/lax_v1/type.hpp        |   8 -
 provides/include/lax_v1/type_traits.hpp |  37 ++--
 provides/include/lax_v1/value.hpp       |  10 -
 22 files changed, 841 insertions(+), 188 deletions(-)
 create mode 100644 internals/testing/core_test.cpp
 create mode 100644 internals/testing/functional_test.cpp
 create mode 100644 provides/include/lax_v1/core.hpp
 delete mode 100644 provides/include/lax_v1/force.hpp
 create mode 100644 provides/include/lax_v1/functional.hpp
 create mode 100644 provides/include/lax_v1/lax.hpp
 delete mode 100644 provides/include/lax_v1/lazify.hpp
 delete mode 100644 provides/include/lax_v1/type.hpp
 delete mode 100644 provides/include/lax_v1/value.hpp

diff --git a/NOTES.md b/NOTES.md
index e7fadcc..d9d0bc8 100644
--- a/NOTES.md
+++ b/NOTES.md
@@ -1,8 +1,8 @@
 Apparently VC++ 2017 is not quite ready for
 
 ```c++
-template <auto v> struct value_t {
-  using eval = value_t;
+template <auto v> struct value_c {
+  using eval = value_c;
   using type = decltype(v);
   static constexpr auto value = v;
 };
diff --git a/README.md b/README.md
index abb0277..0d3e26a 100644
--- a/README.md
+++ b/README.md
@@ -3,3 +3,83 @@
 Non-strict template metaprogramming primitives for C++.
 
 See [`synopsis.hpp`](provides/include/lax_v1/synopsis.hpp) for the API.
+
+## <a id="contents"></a> [≡](#contents) [Contents](#contents)
+
+- [Legend](#legend)
+- [Glossary](#glossary)
+  - [Currying](#currying)
+  - [Meta expression](#meta-expression)
+  - [Meta function](#meta-function)
+  - [Meta value](#meta-value)
+  - [Non-strict evaluation](#non-strict-evaluation)
+- [Motivation](#motivation)
+- [References](#references)
+
+## <a id="legend"></a> [≡](#contents) [Legend](#legend)
+
+- `_m` [meta expression](#meta-expression) template
+- `_c` [meta value](#meta-value) or meta value template
+- `_p` primitive (internal type alias or meta expression template or class)
+- `_t` type alias (from C++11)
+- `_v` value constexpr (from C++17)
+
+## <a id="glossary"></a> [≡](#contents) [Glossary](#glossary)
+
+### <a id="currying"></a> [≡](#contents) [Currying](#currying)
+
+### <a id="meta-expression"></a> [≡](#contents) [Meta expression](#meta-expression)
+
+A lax meta expression is a type that is a subtype of a single
+[meta value](#meta-value) and includes no other members aside from those defined
+by that meta value.
+
+```c++
+using a_meta_expression = add_m<auto_c<1>, auto_c<2>>;
+struct also_a_meta_expression : a_meta_expression {};
+```
+
+Lax meta expression templates are typically [curried](#curried) and produce
+[meta functions](#meta-function) when partially applied.
+
+### <a id="meta-function"></a> [≡](#contents) [Meta function](#meta-function)
+
+A lax meta function is a [meta value](#meta-value) that has a static `arity`
+constant and an inner type template `template_m` that takes at least `arity`
+types as arguments and whose result is a [meta expression](#meta-expression).
+
+```c++
+struct a_meta_function_c {
+  using eval = a_meta_function_c;
+  static constexpr size_t arity = N;
+  template <class Actual_1, ..., class Actual_N>
+  struct template_m : a_meta_expression {};
+};
+```
+
+Lax higher-order meta functions take meta functions as arguments and use them
+via the `apply_m` [meta expression template](#meta-expression-template). Note
+that `template_m` need not support [currying](#currying) like
+[meta expression templates](#meta-expression-template), because `apply_m` takes
+care of that.
+
+### <a id="meta-value"></a> [≡](#contents) [Meta value](#meta-value)
+
+A lax meta value is a [meta expression](#meta-expression) whose inner `eval`
+type is an alias for the meta expression itself.
+
+```c++
+struct a_meta_value_c {
+  using eval = a_meta_value_c;
+  // and additional members depending on value
+};
+```
+
+Meta values also typically include additional static constants, types, or type
+templates.
+
+### <a id="non-strict-evaluation"></a> [≡](#contents) [Non-strict evaluation](#non-strict-evaluation)
+
+## <a id="motivation"></a> [≡](#contents) [Motivation](#motivation)
+
+## <a id="references"></a> [≡](#contents) [References](#references)
diff --git a/internals/testing/arithmetic_test.cpp b/internals/testing/arithmetic_test.cpp
index befe4fe..f726935 100644
--- a/internals/testing/arithmetic_test.cpp
+++ b/internals/testing/arithmetic_test.cpp
@@ -1,34 +1,29 @@
 #include "lax_v1/arithmetic.hpp"
-#include "lax_v1/force.hpp"
 
 #include "config.hpp"
 
 #include <type_traits>
 
-static_assert(
-    std::is_same_v<
-        lax::force_t<lax::add_m<lax::value_t<short, 1>, lax::value_t<long, 2>>>,
-        lax::value_t<long, 3>>);
+static_assert(std::is_same_v<lax::force_c<lax::adds_m<lax::value_c<short, 1>,
+                                                      lax::value_c<long, 2>>>,
+                             lax::value_c<long, 3>>);
 
 static_assert(
-    std::is_same_v<
-        lax::force_t<lax::mod_m<lax::value_t<int, 2>, lax::value_t<int, 2>>>,
-        lax::value_t<int, 0>>);
+    std::is_same_v<lax::force_c<lax::mod_m<lax::auto_c<2>, lax::auto_c<2>>>,
+                   lax::auto_c<0>>);
 
-static_assert(
-    std::is_same_v<
-        lax::force_t<lax::mul_m<lax::value_t<int, 1>, lax::value_t<short, 2>>>,
-        lax::value_t<int, 2>>);
+static_assert(std::is_same_v<
+              lax::force_c<lax::muls_m<lax::auto_c<1>, lax::value_c<short, 2>>>,
+              lax::auto_c<2>>);
 
 static_assert(
     std::is_same_v<
-        lax::force_t<lax::div_m<lax::value_t<short, 6>, lax::value_t<char, 2>>>,
-        lax::value_t<int, 3>>);
+        lax::force_c<lax::div_m<lax::value_c<short, 6>, lax::value_c<char, 2>>>,
+        lax::auto_c<3>>);
 
-static_assert(
-    std::is_same_v<
-        lax::force_t<lax::sub_m<lax::value_t<int, 3>, lax::value_t<char, 2>>>,
-        lax::value_t<int, 1>>);
+static_assert(std::is_same_v<
+              lax::force_c<lax::sub_m<lax::auto_c<3>, lax::value_c<char, 2>>>,
+              lax::auto_c<1>>);
 
-static_assert(std::is_same_v<lax::force_t<lax::neg_m<lax::value_t<short, 3>>>,
-                             lax::value_t<int, -3>>);
+static_assert(std::is_same_v<lax::force_c<lax::neg_m<lax::value_c<short, 3>>>,
+                             lax::auto_c<-3>>);
diff --git a/internals/testing/comparison_test.cpp b/internals/testing/comparison_test.cpp
index 300f174..0a24386 100644
--- a/internals/testing/comparison_test.cpp
+++ b/internals/testing/comparison_test.cpp
@@ -2,8 +2,6 @@
 
 #include "config.hpp"
 
-static_assert(
-    lax::value_of_v<lax::gt_m<lax::value_t<int, 2>, lax::value_t<int, 1>>>);
+static_assert(lax::gt_m<lax::auto_c<2>, lax::auto_c<1>>::value);
 
-static_assert(
-    !lax::value_of_v<lax::eq_m<lax::value_t<int, 2>, lax::value_t<int, 1>>>);
+static_assert(!lax::eq_m<lax::auto_c<2>, lax::auto_c<1>>::value);
diff --git a/internals/testing/compile_only_test.cpp b/internals/testing/compile_only_test.cpp
index 76e8197..bf79638 100644
--- a/internals/testing/compile_only_test.cpp
+++ b/internals/testing/compile_only_test.cpp
@@ -1 +1,3 @@
+#include "lax_v1/lax.hpp"
+
 int main() { return 0; }
diff --git a/internals/testing/core_test.cpp b/internals/testing/core_test.cpp
new file mode 100644
index 0000000..b00319b
--- /dev/null
+++ b/internals/testing/core_test.cpp
@@ -0,0 +1,29 @@
+#include "lax_v1/arithmetic.hpp"
+#include "lax_v1/core.hpp"
+#include "lax_v1/functional.hpp"
+#include "lax_v1/type_traits.hpp"
+
+#include "config.hpp"
+
+struct X;
+struct Y;
+struct Z;
+
+static_assert(
+    std::is_same_v<
+        lax::force_deep_c<
+            lax::seq_c<lax::add_m<>,
+                       lax::add_m<lax::add_m<lax::auto_c<1>, lax::auto_c<2>>>,
+                       lax::remove_pointer_m<lax::type_c<void *>>,
+                       lax::seq_c<lax::add_m<lax::auto_c<1>, lax::auto_c<2>>>,
+                       lax::fn_c<lax::seq_c<X, Y, Z>, lax::adds_m<X, Y, Z>>>>,
+        lax::seq_c<
+            lax::from_primitive_c<lax::add_p, 2>,
+            lax::closure_c<lax::from_primitive_c<lax::add_p, 2>,
+                           lax::add_m<lax::auto_c<1>, lax::auto_c<2>>>,
+            lax::type_c<void>,
+            lax::seq_c<lax::auto_c<3>>,
+            lax::function_c<
+                X,
+                lax::function_c<Y,
+                                lax::function_c<Z, lax::adds_m<X, Y, Z>>>>>>);
diff --git a/internals/testing/functional_test.cpp b/internals/testing/functional_test.cpp
new file mode 100644
index 0000000..227e2bb
--- /dev/null
+++ b/internals/testing/functional_test.cpp
@@ -0,0 +1,67 @@
+#include "lax_v1/arithmetic.hpp"
+#include "lax_v1/comparison.hpp"
+#include "lax_v1/functional.hpp"
+#include "lax_v1/type_traits.hpp"
+
+#include "config.hpp"
+
+static_assert(lax::apply_m<lax::compose_m<lax::neg_m<>, lax::neg_m<>>,
+                           lax::auto_c<2>>::value == 2);
+
+static_assert(lax::apply_m<lax::composes_m<lax::inc_m<>,
+                                           lax::neg_m<>,
+                                           lax::add_m<lax::auto_c<-1>>>,
+                           lax::auto_c<1>>::value == 1);
+
+static_assert(
+    lax::apply_m<
+        lax::pipes_m<lax::add_m<lax::auto_c<1>>, lax::neg_m<>, lax::dec_m<>>,
+        lax::auto_c<1>>::value == -3);
+
+static_assert(lax::thru_m<lax::auto_c<1>,
+                          lax::add_m<lax::auto_c<1>>,
+                          lax::neg_m<>,
+                          lax::add_m<lax::auto_c<-1>>,
+                          lax::eq_m<lax::auto_c<-3>>>::value == true);
+
+struct V;
+
+static_assert(lax::apply_m<lax::function_c<V, lax::add_m<V, lax::neg_m<V>>>,
+                           lax::auto_c<1>>::value == 0);
+
+static_assert(lax::thru_m<lax::type_c<short * [1]>,
+                          lax::remove_all_extents_m<>,
+                          lax::remove_pointer_m<>,
+                          lax::alignment_of_m<>>::value == alignof(short));
+
+static_assert(lax::thru_m<lax::auto_c<0>,
+                          lax::div_m<lax::auto_c<0>>,
+                          lax::constant_m<lax::auto_c<101>>>::value == 101);
+
+template <class T>
+using adhoc_t = lax::as_type_trait_t<
+    lax::pipe_m<lax::remove_all_extents_m<>, lax::remove_pointer_m<>>,
+    T>;
+
+static_assert(std::is_same_v<adhoc_t<int * [2][2]>, int>);
+
+template <class T>
+inline constexpr auto adhoc_v = lax::as_value_trait_v<
+    lax::pipe_m<lax::remove_all_extents_m<>, lax::alignment_of_m<>>,
+    T>;
+
+static_assert(adhoc_v<int * [2][2]> == alignof(int *));
+
+struct F;
+
+template <int value>
+inline constexpr auto factorial_v = lax::apply_m<
+    lax::fix_m<lax::fn_c<
+        lax::seq_c<F, V>,
+        lax::if_m<
+            lax::eq_m<lax::auto_c<0>, V>,
+            lax::auto_c<1>,
+            lax::mul_m<V, lax::apply_m<F, lax::sub_m<V, lax::auto_c<1>>>>>>>,
+    lax::auto_c<value>>::value;
+
+static_assert(factorial_v<5> == 120);
diff --git a/internals/testing/logical_test.cpp b/internals/testing/logical_test.cpp
index d5044c0..f76ecaa 100644
--- a/internals/testing/logical_test.cpp
+++ b/internals/testing/logical_test.cpp
@@ -2,14 +2,20 @@
 
 #include "config.hpp"
 
-static_assert(
-    lax::value_of_v<
-        lax::if_m<lax::and_m<>, lax::value_t<int, 1>, lax::value_t<int, 2>>> ==
-    1);
+static_assert(lax::if_m<lax::ands_m<>, lax::auto_c<1>, lax::auto_c<2>>::value ==
+              1);
+
+static_assert(lax::if_m<lax::ors_m<>, lax::auto_c<1>, lax::auto_c<2>>::value ==
+              2);
+
+static_assert(!lax::and_m<lax::false_c,
+                          lax::div_m<lax::auto_c<1>, lax::auto_c<0>>>::value);
 
 static_assert(
-    lax::value_of_v<
-        lax::if_m<lax::or_m<>, lax::value_t<int, 1>, lax::value_t<int, 2>>> ==
-    2);
+    lax::or_m<lax::true_c, lax::div_m<lax::auto_c<1>, lax::auto_c<0>>>::value);
+
+static_assert(lax::not_m<lax::false_c>::value);
 
-static_assert(lax::value_of_v<lax::not_m<lax::false_t>>);
+static_assert(lax::switch_m<lax::case_c<lax::false_c, lax::auto_c<2>>,
+                            lax::case_c<lax::true_c, lax::auto_c<1>>,
+                            lax::default_c<lax::auto_c<3>>>::value == 1);
diff --git a/internals/testing/type_traits_test.cpp b/internals/testing/type_traits_test.cpp
index 9499028..f6c5de4 100644
--- a/internals/testing/type_traits_test.cpp
+++ b/internals/testing/type_traits_test.cpp
@@ -4,23 +4,25 @@
 
 #include "config.hpp"
 
-static_assert(lax::value_of_v<lax::is_array_m<lax::type_t<int[2]>>>);
+static_assert(lax::is_array_m<lax::type_c<int[2]>>::value);
 
 template <class Value>
 struct is_stored_plain_m
     : lax::or_m<
           lax::and_m<
               lax::is_pointer_m<Value>,
-              lax::lte_m<lax::value_t<size_t, 2>,
+              lax::lte_m<lax::auto_c<2>,
                          lax::alignment_of_m<lax::remove_pointer_m<Value>>>>,
           lax::and_m<lax::is_array_m<Value>,
                      is_stored_plain_m<lax::remove_all_extents_m<Value>>>> {};
 
 template <class Value>
 static inline constexpr bool is_stored_plain_v =
-    lax::value_of_v<is_stored_plain_m<lax::type_t<Value>>>;
+    is_stored_plain_m<lax::type_c<Value>>::value;
 
 static_assert(!is_stored_plain_v<char>);
 static_assert(!is_stored_plain_v<char *>);
 static_assert(is_stored_plain_v<int *>);
 static_assert(is_stored_plain_v<int * [2]>);
+
+static_assert(!lax::is_same_m<lax::type_c<void>, lax::type_c<int>>::value);
diff --git a/internals/testing/value_test.cpp b/internals/testing/value_test.cpp
index 043c715..6a578f5 100644
--- a/internals/testing/value_test.cpp
+++ b/internals/testing/value_test.cpp
@@ -1,19 +1,19 @@
-#include "lax_v1/value.hpp"
+#include "lax_v1/core.hpp"
 
 #include "config.hpp"
 
 #include <type_traits>
 
-static_assert(std::is_same_v<lax::value_t<bool, true>::value_type, bool>);
+static_assert(std::is_same_v<lax::auto_c<true>::value_type, bool>);
 
-static_assert(std::is_same_v<lax::value_t<char, 'x'>::value_type, char>);
-static_assert(std::is_same_v<lax::value_t<short, 101>::value_type, short>);
-static_assert(std::is_same_v<lax::value_t<int, 101>::value_type, int>);
+static_assert(std::is_same_v<lax::auto_c<'x'>::value_type, char>);
+static_assert(std::is_same_v<lax::value_c<short, 101>::value_type, short>);
+static_assert(std::is_same_v<lax::auto_c<101>::value_type, int>);
 static_assert(
-    std::is_same_v<lax::value_t<unsigned, 101u>::value_type, unsigned>);
-static_assert(std::is_same_v<lax::value_t<long, 101l>::value_type, long>);
-static_assert(std::is_same_v<lax::value_t<unsigned long, 101ul>::value_type,
+    std::is_same_v<lax::value_c<unsigned, 101u>::value_type, unsigned>);
+static_assert(std::is_same_v<lax::value_c<long, 101l>::value_type, long>);
+static_assert(std::is_same_v<lax::value_c<unsigned long, 101ul>::value_type,
                              unsigned long>);
 static_assert(
-    std::is_same_v<lax::value_t<unsigned long long, 101ull>::value_type,
+    std::is_same_v<lax::value_c<unsigned long long, 101ull>::value_type,
                    unsigned long long>);
diff --git a/provides/include/lax_v1/arithmetic.hpp b/provides/include/lax_v1/arithmetic.hpp
index 361068e..118fe58 100644
--- a/provides/include/lax_v1/arithmetic.hpp
+++ b/provides/include/lax_v1/arithmetic.hpp
@@ -1,32 +1,29 @@
 #pragma once
 
-#include "lax_v1/value.hpp"
+#include "lax_v1/core.hpp"
 
 #include <type_traits>
 
-template <class Lhs, class Rhs>
-struct lax_v1::add_m
-    : value_t<std::common_type_t<value_type_of_t<Lhs>, value_type_of_t<Rhs>>,
-              value_of_v<Lhs> + value_of_v<Rhs>> {};
-
-template <class Lhs, class Rhs>
-struct lax_v1::div_m
-    : value_t<std::common_type_t<value_type_of_t<Lhs>, value_type_of_t<Rhs>>,
-              value_of_v<Lhs> / value_of_v<Rhs>> {};
-
-template <class Lhs, class Rhs>
-struct lax_v1::mod_m
-    : value_t<std::common_type_t<value_type_of_t<Lhs>, value_type_of_t<Rhs>>,
-              value_of_v<Lhs> % value_of_v<Rhs>> {};
-
-template <class Lhs, class Rhs>
-struct lax_v1::mul_m
-    : value_t<std::common_type_t<value_type_of_t<Lhs>, value_type_of_t<Rhs>>,
-              value_of_v<Lhs> * value_of_v<Rhs>> {};
-
-template <class Lhs, class Rhs>
-struct lax_v1::sub_m
-    : value_t<std::common_type_t<value_type_of_t<Lhs>, value_type_of_t<Rhs>>,
-              value_of_v<Lhs> - value_of_v<Rhs>> {};
-
-template <class Expr> struct lax_v1::neg_m : auto_t<-value_of_v<Expr>> {};
+#define LAX(name, op)                                                          \
+  namespace lax_v1 {                                                           \
+  template <class Lhs, class Rhs>                                              \
+  using name##_p = value_c<                                                    \
+      std::common_type_t<typename Lhs::value_type, typename Rhs::value_type>,  \
+      Lhs::value op Rhs::value>;                                               \
+  }                                                                            \
+  template <class... Exprs>                                                    \
+  struct lax_v1::name##_m : primitive_c<name##_p, 2, Exprs...> {};
+
+LAX(add, +)
+LAX(div, /)
+LAX(mod, %)
+LAX(mul, *)
+LAX(sub, -)
+#undef LAX
+
+namespace lax_v1 {
+template <class Expr> using neg_p = auto_c<-Expr::value>;
+} // namespace lax_v1
+
+template <class... Exprs>
+struct lax_v1::neg_m : primitive_c<neg_p, 1, Exprs...> {};
diff --git a/provides/include/lax_v1/comparison.hpp b/provides/include/lax_v1/comparison.hpp
index dfd1980..8548d30 100644
--- a/provides/include/lax_v1/comparison.hpp
+++ b/provides/include/lax_v1/comparison.hpp
@@ -1,18 +1,19 @@
 #pragma once
 
-#include "lax_v1/value.hpp"
+#include "lax_v1/core.hpp"
 
-template <class Lhs, class Rhs>
-struct lax_v1::eq_m : auto_t<(value_of_v<Lhs> == value_of_v<Rhs>)> {};
+#define LAX(name, op)                                                          \
+  namespace lax_v1 {                                                           \
+  template <class Lhs, class Rhs>                                              \
+  using name##_p = value_c<bool, (Lhs::value op Rhs::value)>;                  \
+  }                                                                            \
+  template <class... Exprs>                                                    \
+  struct lax_v1::name##_m : primitive_c<name##_p, 2, Exprs...> {};
 
-template <class Lhs, class Rhs>
-struct lax_v1::gt_m : auto_t<(value_of_v<Lhs>> value_of_v<Rhs>)> {};
-
-template <class Lhs, class Rhs>
-struct lax_v1::gte_m : auto_t<(value_of_v<Lhs> >= value_of_v<Rhs>)> {};
-
-template <class Lhs, class Rhs>
-struct lax_v1::lt_m : auto_t<(value_of_v<Lhs> < value_of_v<Rhs>)> {};
-
-template <class Lhs, class Rhs>
-struct lax_v1::lte_m : auto_t<(value_of_v<Lhs> <= value_of_v<Rhs>)> {};
+LAX(eq, ==)
+LAX(gt, >)
+LAX(gte, >=)
+LAX(lt, <)
+LAX(lte, <=)
+LAX(neq, !=)
+#undef LAX
diff --git a/provides/include/lax_v1/core.hpp b/provides/include/lax_v1/core.hpp
new file mode 100644
index 0000000..3426297
--- /dev/null
+++ b/provides/include/lax_v1/core.hpp
@@ -0,0 +1,245 @@
+#pragma once
+
+#include "lax_v1/synopsis.hpp"
+
+#include <type_traits>
+
+//
+
+namespace lax_v1 {
+class apply_private {
+  template <class Function, class... Actuals> friend struct apply_m;
+  template <class... Actuals> struct t { using eval = t; };
+  template <class Prefix, class Suffix> struct concat;
+  template <size_t n, class... Actuals> struct take_n;
+  template <size_t n, class... Actuals> struct drop_n;
+  template <class Function, class Actuals> struct apply_exact;
+  template <class Function, class Actuals> struct apply_rest;
+  template <class Function, class... Actuals> struct apply;
+};
+
+template <class Function, class... BoundActuals> struct closure_c {
+  using eval = closure_c;
+  static constexpr size_t arity = Function::arity - sizeof...(BoundActuals);
+  template <class... Actuals>
+  struct template_m
+      : force_c<typename Function::template template_m<BoundActuals...,
+                                                       Actuals...>> {};
+};
+} // namespace lax_v1
+
+//
+
+template <class WHNF> struct lax_v1::force_deep_from_whnf_m : WHNF {};
+
+template <class Type>
+struct lax_v1::force_deep_from_whnf_m<lax_v1::type_c<Type>> : type_c<Type> {};
+
+template <class Formals, class Expr>
+struct lax_v1::force_deep_from_whnf_m<lax_v1::function_c<Formals, Expr>>
+    : function_c<Formals, Expr> {};
+
+template <class Function, class... BoundActuals>
+struct lax_v1::force_deep_from_whnf_m<
+    lax_v1::closure_c<Function, BoundActuals...>>
+    : closure_c<Function, BoundActuals...> {};
+
+template <template <class... Formals> class Constructor, class... Actuals>
+struct lax_v1::force_deep_from_whnf_m<Constructor<Actuals...>>
+    : Constructor<force_deep_c<Actuals>...> {};
+
+//
+
+template <class Type> struct lax_v1::type_c {
+  using eval = type_c;
+  using type = Type;
+};
+
+//
+
+template <class Type, Type value>
+struct lax_v1::value_c : std::integral_constant<Type, value> {
+  using eval = value_c;
+};
+
+//
+
+namespace lax_v1 {
+template <class Cond, class Then, class Else>
+struct if_p : force_c<if_p<force_c<Cond>, Then, Else>> {};
+template <class Then, class Else>
+struct if_p<true_c, Then, Else> : force_c<Then> {};
+template <class Then, class Else>
+struct if_p<false_c, Then, Else> : force_c<Else> {};
+} // namespace lax_v1
+
+template <class... Exprs>
+struct lax_v1::if_m : primitive_c<if_p, 3, Exprs...> {};
+
+//
+
+template <class Consequent>
+struct lax_v1::switch_m<lax_v1::default_c<Consequent>> : force_c<Consequent> {};
+
+template <class Condition, class Consequent, class... Cases>
+struct lax_v1::switch_m<lax_v1::case_c<Condition, Consequent>, Cases...>
+    : force_c<if_p<Condition, Consequent, switch_m<Cases...>>> {};
+
+template <class Condition, class Consequent> struct lax_v1::case_c {
+  using eval = case_c;
+};
+
+template <class Consequent> struct lax_v1::default_c {
+  using eval = default_c;
+};
+
+//
+
+template <class Function, class... Actuals>
+struct lax_v1::apply_m
+    : force_c<if_p<value_c<bool, (sizeof...(Actuals) < Function::arity)>,
+                   closure_c<Function, Actuals...>,
+                   apply_private::apply<Function, Actuals...>>> {};
+
+template <class Function>
+struct lax_v1::apply_m<Function> : force_c<Function> {};
+
+//
+
+template <template <class... Formals> class Primitive, size_t arity_>
+struct lax_v1::from_primitive_c {
+  using eval = from_primitive_c;
+  static constexpr size_t arity = arity_;
+  template <class... Actuals>
+  struct template_m : force_c<Primitive<Actuals...>> {};
+};
+
+//
+
+template <template <class... Formals> class Trait, size_t arity_>
+struct lax_v1::from_type_trait_c {
+  using eval = from_type_trait_c;
+  static constexpr size_t arity = arity_;
+  template <class... Actuals>
+  struct template_m : type_c<type_of_t<Trait<type_of_t<Actuals>...>>> {};
+};
+
+//
+
+template <template <class... Formals> class Trait, size_t arity_, class Type>
+struct lax_v1::from_value_trait_c {
+  using eval = from_value_trait_c;
+  static constexpr size_t arity = arity_;
+  template <class... Actuals>
+  struct template_m : value_c<Type, Trait<type_of_t<Actuals>...>::value> {};
+};
+
+//
+
+template <class... Exprs> struct lax_v1::seq_c { using eval = seq_c; };
+
+//
+
+template <class... Prefix, class... Suffix>
+struct lax_v1::apply_private::concat<lax_v1::apply_private::t<Prefix...>,
+                                     lax_v1::apply_private::t<Suffix...>>
+    : t<Prefix..., Suffix...> {};
+
+template <class... Actuals>
+struct lax_v1::apply_private::take_n<0, Actuals...> : t<> {};
+
+template <size_t n, class Actual, class... Actuals>
+struct lax_v1::apply_private::take_n<n, Actual, Actuals...>
+    : force_c<concat<t<Actual>, force_c<take_n<n - 1, Actuals...>>>> {};
+
+template <class... Actuals>
+struct lax_v1::apply_private::drop_n<0, Actuals...> : t<Actuals...> {};
+
+template <size_t n, class Actual, class... Actuals>
+struct lax_v1::apply_private::drop_n<n, Actual, Actuals...>
+    : force_c<drop_n<n - 1, Actuals...>> {};
+
+template <class Function, class... Actuals>
+struct lax_v1::apply_private::apply_exact<Function,
+                                          lax_v1::apply_private::t<Actuals...>>
+    : force_c<typename Function::template template_m<Actuals...>> {};
+
+template <class Function, class Actual, class... Actuals>
+struct lax_v1::apply_private::
+    apply_rest<Function, lax_v1::apply_private::t<Actual, Actuals...>>
+    : force_c<apply_m<Function, Actual, Actuals...>> {};
+
+template <class Function>
+struct lax_v1::apply_private::apply_rest<Function, lax_v1::apply_private::t<>>
+    : force_c<Function> {};
+
+template <class Function, class... Actuals>
+struct lax_v1::apply_private::apply
+    : force_c<apply_rest<
+          apply_exact<Function, force_c<take_n<Function::arity, Actuals...>>>,
+          force_c<drop_n<Function::arity, Actuals...>>>> {};
+
+//
+
+template <class Empty, class Concat>
+struct lax_v1::nullary_variadic_m<Empty, Concat> : force_c<Empty> {};
+
+template <class Empty, class Concat, class Expr>
+struct lax_v1::nullary_variadic_m<Empty, Concat, Expr> : force_c<Expr> {};
+
+template <class Empty, class Concat, class Expr1, class Expr2, class... Exprs>
+struct lax_v1::nullary_variadic_m<Empty, Concat, Expr1, Expr2, Exprs...>
+    : force_c<apply_m<Concat,
+                      Expr1,
+                      nullary_variadic_m<Empty, Concat, Expr2, Exprs...>>> {};
+
+//
+
+namespace lax_v1 {
+class function_private {
+  template <class Formal, class Expr> friend struct function_c;
+  template <class Formal, class Actual, class Expr>
+  struct subst_m : type_c<Expr> {};
+  template <class Formal, class Actual, class Expr>
+  using subst_t = type_of_t<subst_m<Formal, Actual, Expr>>;
+};
+} // namespace lax_v1
+
+template <class Formal, class Expr> struct lax_v1::function_c {
+  using eval = function_c;
+  static constexpr size_t arity = 1;
+  template <class Actual>
+  struct template_m : function_private::subst_t<Formal, Actual, Expr> {};
+};
+
+template <class Formal1, class Formal2, class... Formals, class Expr>
+struct lax_v1::fn_c<lax_v1::seq_c<Formal1, Formal2, Formals...>, Expr>
+    : function_c<Formal1, force_c<fn_c<seq_c<Formal2, Formals...>, Expr>>> {};
+
+template <class Formal, class Expr>
+struct lax_v1::fn_c<lax_v1::seq_c<Formal>, Expr> : function_c<Formal, Expr> {};
+
+//
+
+template <class Formal, class Actual>
+struct lax_v1::function_private::subst_m<Formal, Actual, Formal>
+    : type_c<Actual> {};
+
+template <class Formal, class Actual, class Expr>
+struct lax_v1::function_private::
+    subst_m<Formal, Actual, lax_v1::function_c<Formal, Expr>>
+    : type_c<function_c<Formal, Expr>> {};
+
+template <class Formal,
+          class Actual,
+          template <class... Formals>
+          class Function,
+          class... Exprs>
+struct lax_v1::function_private::subst_m<Formal, Actual, Function<Exprs...>>
+    : type_c<Function<subst_t<Formal, Actual, Exprs>...>> {};
+
+template <class Formal, class Actual, class ReturnType, class... ParamTypes>
+struct lax_v1::function_private::
+    subst_m<Formal, Actual, ReturnType(ParamTypes...)>
+    : type_c<subst_t<Formal, Actual, ReturnType>(
+          subst_t<Formal, Actual, ParamTypes>...)> {};
diff --git a/provides/include/lax_v1/force.hpp b/provides/include/lax_v1/force.hpp
deleted file mode 100644
index f50b867..0000000
--- a/provides/include/lax_v1/force.hpp
+++ /dev/null
@@ -1,3 +0,0 @@
-#pragma once
-
-#include "lax_v1/synopsis.hpp"
diff --git a/provides/include/lax_v1/functional.hpp b/provides/include/lax_v1/functional.hpp
new file mode 100644
index 0000000..11898fd
--- /dev/null
+++ b/provides/include/lax_v1/functional.hpp
@@ -0,0 +1,56 @@
+#pragma once
+
+#include "lax_v1/core.hpp"
+
+//
+
+template <class... Exprs>
+struct lax_v1::identity_m : primitive_c<force_c, 1, Exprs...> {};
+
+//
+
+template <class... Exprs>
+struct lax_v1::constant_m : primitive_c<if_p, 3, true_c, Exprs...> {};
+
+//
+
+namespace lax_v1 {
+template <class Function1, class Function2> struct compose_p {
+  using eval = compose_p;
+  static constexpr size_t arity = 1;
+  template <class Expr>
+  struct template_m : force_c<apply_m<Function1, apply_m<Function2, Expr>>> {};
+};
+} // namespace lax_v1
+
+template <class... Functions>
+struct lax_v1::compose_m : primitive_c<compose_p, 2, Functions...> {};
+
+//
+
+namespace lax_v1 {
+template <class Function1, class Function2> struct pipe_p {
+  using eval = pipe_p;
+  static constexpr size_t arity = 1;
+  template <class Expr>
+  struct template_m : force_c<apply_m<Function2, apply_m<Function1, Expr>>> {};
+};
+} // namespace lax_v1
+
+template <class... Functions>
+struct lax_v1::pipe_m : primitive_c<pipe_p, 2, Functions...> {};
+
+//
+
+template <class Expr, class... Functions>
+struct lax_v1::thru_m : force_c<apply_m<pipes_m<Functions...>, Expr>> {};
+
+//
+
+namespace lax_v1 {
+template <class Function>
+struct fix_p : force_c<apply_m<force_c<Function>, fix_p<force_c<Function>>>> {};
+} // namespace lax_v1
+
+template <class... Function>
+struct lax_v1::fix_m : primitive_c<fix_p, 1, Function...> {};
diff --git a/provides/include/lax_v1/lax.hpp b/provides/include/lax_v1/lax.hpp
new file mode 100644
index 0000000..21b9990
--- /dev/null
+++ b/provides/include/lax_v1/lax.hpp
@@ -0,0 +1,10 @@
+#pragma once
+
+#include "lax_v1/arithmetic.hpp"
+#include "lax_v1/comparison.hpp"
+#include "lax_v1/config.hpp"
+#include "lax_v1/core.hpp"
+#include "lax_v1/functional.hpp"
+#include "lax_v1/logical.hpp"
+#include "lax_v1/synopsis.hpp"
+#include "lax_v1/type_traits.hpp"
diff --git a/provides/include/lax_v1/lazify.hpp b/provides/include/lax_v1/lazify.hpp
deleted file mode 100644
index 6f4670c..0000000
--- a/provides/include/lax_v1/lazify.hpp
+++ /dev/null
@@ -1,4 +0,0 @@
-#pragma once
-
-#include "lax_v1/type.hpp"
-#include "lax_v1/value.hpp"
diff --git a/provides/include/lax_v1/logical.hpp b/provides/include/lax_v1/logical.hpp
index b32b292..ff329af 100644
--- a/provides/include/lax_v1/logical.hpp
+++ b/provides/include/lax_v1/logical.hpp
@@ -1,26 +1,18 @@
 #pragma once
 
-#include "lax_v1/force.hpp"
-#include "lax_v1/value.hpp"
+#include "lax_v1/core.hpp"
 
-template <class Else> struct lax_v1::if_m<Else> : force_t<Else> {};
-template <class Cond, class Then, class... Elses>
-struct lax_v1::if_m<Cond, Then, Elses...>
-    : force_t<if_m<force_t<Cond>, Then, Elses...>> {};
-template <class Then, class... Elses>
-struct lax_v1::if_m<lax_v1::true_t, Then, Elses...> : force_t<Then> {};
-template <class Then, class... Elses>
-struct lax_v1::if_m<lax_v1::false_t, Then, Elses...> : force_t<if_m<Elses...>> {
-};
+namespace lax_v1 {
+template <class Expr> using not_p = value_c<bool, !Expr::value>;
+template <class Lhs, class Rhs> using and_p = force_c<if_p<Lhs, Rhs, false_c>>;
+template <class Lhs, class Rhs> using or_p = force_c<if_p<Lhs, true_c, Rhs>>;
+} // namespace lax_v1
 
-template <> struct lax_v1::and_m<> : true_t {};
-template <class Expr, class... Exprs>
-struct lax_v1::and_m<Expr, Exprs...>
-    : force_t<if_m<Expr, and_m<Exprs...>, false_t>> {};
+template <class... Exprs>
+struct lax_v1::and_m : primitive_c<and_p, 2, Exprs...> {};
 
-template <class Expr> struct lax_v1::not_m : auto_t<!value_of_v<Expr>> {};
+template <class... Exprs>
+struct lax_v1::or_m : primitive_c<or_p, 2, Exprs...> {};
 
-template <> struct lax_v1::or_m<> : false_t {};
-template <class Expr, class... Exprs>
-struct lax_v1::or_m<Expr, Exprs...>
-    : force_t<if_m<Expr, true_t, or_m<Exprs...>>> {};
+template <class... Exprs>
+struct lax_v1::not_m : primitive_c<not_p, 1, Exprs...> {};
diff --git a/provides/include/lax_v1/synopsis.hpp b/provides/include/lax_v1/synopsis.hpp
index e968d6e..e767ac9 100644
--- a/provides/include/lax_v1/synopsis.hpp
+++ b/provides/include/lax_v1/synopsis.hpp
@@ -1,76 +1,273 @@
 #pragma once
 
+#include <cstddef>
+
 namespace lax_v1 {
 
-// force.hpp ===================================================================
+// core.hpp ====================================================================
+
+/// Evaluates an expression to weak head normal form.
+template <class Expr> using force_c = typename Expr::eval;
 
-template <class Expr> using force_t = typename Expr::eval;
+/// Implementation detail of `force_deep_c`.
+template <class Expr> struct force_deep_from_whnf_m;
 
-// type.hpp ====================================================================
+/// Evaluates an expression to a normal form.
+template <class Expr>
+using force_deep_c = force_c<force_deep_from_whnf_m<force_c<Expr>>>;
 
-template <class T> struct type_t;
+// -----------------------------------------------------------------------------
 
+/// Wraps an arbitrary type as a meta value.
+template <class Type> struct type_c;
+
+/// The held type of an expression.
 template <class Expr> using type_of_t = typename Expr::type;
 
-// value.hpp ===================================================================
+// -----------------------------------------------------------------------------
 
-template <class Type, Type value> struct value_t;
+/// Wraps a constant value of given type as a meta value.
+template <class Type, Type value> struct value_c;
 
-template <class Expr> using value_type_of_t = typename Expr::value_type;
+/// `auto_c<v>` is shorthand for `value_t<decltype(v), v>`.
+template <auto value> using auto_c = value_c<decltype(value), value>;
 
-template <class Expr>
-inline constexpr value_type_of_t<Expr> value_of_v = Expr::value;
+/// The constant `true` value.
+using true_c = value_c<bool, true>;
+
+/// The constant `false` value.
+using false_c = value_c<bool, false>;
+
+// -----------------------------------------------------------------------------
+
+/// A ternary conditional expression.
+template <class... Exprs> struct if_m;
+
+// -----------------------------------------------------------------------------
+
+/// A multi legged conditional expression.
+template <class... Cases> struct switch_m;
+
+/// A conditional leg of a switch expression.
+template <class Condition, class Consequent> struct case_c;
+
+/// An unconditional leg of a switch expression.
+template <class Consequent> struct default_c;
+
+// -----------------------------------------------------------------------------
+
+/// Applies meta function class to actual arguments.
+template <class Function, class... Actuals> struct apply_m;
+
+// -----------------------------------------------------------------------------
+
+/// A primitive meta function template as a non-strict meta function class.
+template <template <class... Formals> class Primitive, size_t arity>
+struct from_primitive_c;
+
+/// A primitive meta function template as a non-strict meta function template.
+template <template <class... Formals> class Primitive,
+          size_t arity,
+          class... Actuals>
+using primitive_c =
+    force_c<apply_m<from_primitive_c<Primitive, arity>, Actuals...>>;
+
+// -----------------------------------------------------------------------------
+
+/// A type returning strict trait as a non-strict meta function class.
+template <template <class... Formals> class Trait, size_t arity>
+struct from_type_trait_c;
+
+/// A type returning strict trait as a non-strict meta function template.
+template <template <class... Formals> class Trait,
+          size_t arity,
+          class... Actuals>
+using type_trait_c =
+    force_c<apply_m<from_type_trait_c<Trait, arity>, Actuals...>>;
+
+// -----------------------------------------------------------------------------
+
+/// A value returning strict trait as a non-strict meta function class.
+template <template <class... Formals> class Trait, size_t arity, class Type>
+struct from_value_trait_c;
+
+/// A value returning strict trait as a non-strict meta function template.
+template <template <class... Formals> class Trait,
+          size_t arity,
+          class Type,
+          class... Actuals>
+using value_trait_c =
+    force_c<apply_m<from_value_trait_c<Trait, arity, Type>, Actuals...>>;
+
+// -----------------------------------------------------------------------------
+
+/// A non-strict meta function class as a strict type returning trait.
+template <class Function, class... Actuals>
+using as_type_trait_t = type_of_t<apply_m<Function, type_c<Actuals>...>>;
+
+/// A non-strict meta function class as a strict value returning trait.
+template <class Function, class... Actuals>
+inline constexpr auto as_value_trait_v =
+    apply_m<Function, type_c<Actuals>...>::value;
+
+// -----------------------------------------------------------------------------
+
+/// A binary meta function class with zero as a variadic meta function
+/// template.
+template <class Empty, class Concat, class... Exprs> struct nullary_variadic_m;
+
+// -----------------------------------------------------------------------------
+
+/// Holds a sequence.
+template <class... Values> struct seq_c;
+
+// -----------------------------------------------------------------------------
+
+/// Single argument meta function class expression.
+template <class Formal, class Expr> struct function_c;
 
-template <auto value> using auto_t = value_t<decltype(value), value>;
+/// Multi argument meta function class expression. `fn_c<seq_c<V1, ..., Vn>,
+/// Expr>` is equivalent to `function_c<V1, ..., function_c<Vn, Expr> ... >`.
+template <class Formals, class Expr> struct fn_c;
 
-using true_t = auto_t<true>;
-using false_t = auto_t<false>;
+// functional.hpp ==============================================================
+
+/// Fixed point of a meta function class.
+template <class... Function> struct fix_m;
+
+/// Identity meta function template returns its argument.
+template <class... Expr> struct identity_m;
+
+/// Constant meta function template always returns its first argument and
+/// ignores its second argument.
+template <class... Exprs> struct constant_m;
+
+/// Binary meta function class composition.  `apply_m<compose_m<F, G>, X>` is
+/// equivalent to `apply_m<F, apply_m<G, X>>`.
+template <class... Functions> struct compose_m;
+
+/// Binary meta function class reverse composition.  `apply_m<pipe_m<F, G>, X>`
+/// is equivalent to `apply_m<G, apply_m<F, X>>`.
+template <class... Functions> struct pipe_m;
+
+/// Passes given expression through the reverse composition of given meta
+/// function classes. `thru_m<X, F1, ..., Fn>` is equivalent to
+/// `apply_m<pipes_m<F1, ..., Fn>, X>`.
+template <class Expr, class... Functions> struct thru_m;
+
+// -----------------------------------------------------------------------------
+
+/// Variadic meta function class composition.
+template <class... Functions>
+using composes_m = nullary_variadic_m<identity_m<>, compose_m<>, Functions...>;
+
+/// Variadic meta function class reverse composition.
+template <class... Functions>
+using pipes_m = nullary_variadic_m<identity_m<>, pipe_m<>, Functions...>;
 
 // arithmetic.hpp ==============================================================
 
-template <class Lhs, class Rhs> struct add_m;
-template <class Lhs, class Rhs> struct div_m;
-template <class Lhs, class Rhs> struct mod_m;
-template <class Lhs, class Rhs> struct mul_m;
-template <class Lhs, class Rhs> struct sub_m;
+/// Binary arithmetic value addition (`+`).
+template <class... Exprs> struct add_m;
+
+/// Binary arithmetic value division (`/`).
+template <class... Exprs> struct div_m;
+
+/// Binary arithmetic value modulo (`%`).
+template <class... Exprs> struct mod_m;
+
+/// Binary arithmetic value multiplication (`*`).
+template <class... Exprs> struct mul_m;
+
+/// Binary arithmetic value subtraction (`-`).
+template <class... Exprs> struct sub_m;
+
+/// Unary arithmetic value negation (`-`).
+template <class... Expr> struct neg_m;
+
+// -----------------------------------------------------------------------------
+
+// Arithmetic increment value by 1.
+template <class... Expr> using inc_m = add_m<value_c<int, 1>, Expr...>;
+
+// Arithmetic decrement value by 1.
+template <class... Expr> using dec_m = add_m<value_c<int, -1>, Expr...>;
 
-template <class Expr> struct neg_m;
+// -----------------------------------------------------------------------------
+
+/// Variadic arithmetic value addition (`+`).
+template <class... Exprs>
+using adds_m = nullary_variadic_m<value_c<int, 0>, add_m<>, Exprs...>;
+
+/// Variadic arithmetic value multiplication (`*`).
+template <class... Exprs>
+using muls_m = nullary_variadic_m<value_c<int, 1>, mul_m<>, Exprs...>;
 
 // comparison.hpp ==============================================================
 
-template <class Lhs, class Rhs> struct eq_m;
-template <class Lhs, class Rhs> struct gt_m;
-template <class Lhs, class Rhs> struct gte_m;
-template <class Lhs, class Rhs> struct lt_m;
-template <class Lhs, class Rhs> struct lte_m;
+/// Binary equal to (`==`) value comparison.
+template <class... Exprs> struct eq_m;
 
-// logical.hpp =================================================================
+/// Binary greater than (`>`) value comparison.
+template <class... Exprs> struct gt_m;
 
-template <class... Exprs> struct if_m;
+/// Binary greater than or equal to (`>=`) value comparison.
+template <class... Exprs> struct gte_m;
+
+/// Binary less than (`<`) value comparison.
+template <class... Exprs> struct lt_m;
+
+/// Binary less than or equal to (`<=`) value comparison.
+template <class... Exprs> struct lte_m;
+
+/// Binary not equal to (`!=`) value comparison.
+template <class... Exprs> struct neq_m;
+
+// logical.hpp =================================================================
 
+/// Binary logical value conjunction (`&&`).
 template <class... Exprs> struct and_m;
+
+/// Binary logical value disjunction (`||`)).
 template <class... Exprs> struct or_m;
 
-template <class Expr> struct not_m;
+/// Unary logical value negation (`!`).
+template <class... Expr> struct not_m;
 
-// lazify.hpp ==================================================================
+// -----------------------------------------------------------------------------
 
-template <template <class... Formals> class Trait, class... Actuals>
-using lazify_type_trait_t = type_t<type_of_t<Trait<type_of_t<Actuals>...>>>;
+/// Variadic logical value conjunction.
+template <class... Exprs>
+using ands_m = nullary_variadic_m<true_c, and_m<>, Exprs...>;
 
-template <class Type, template <class... Formals> class Trait, class... Actuals>
-using lazify_value_trait_t =
-    value_t<Type, value_of_v<Trait<type_of_t<Actuals>...>>>;
+/// Variadic logical value disjunction.
+template <class... Exprs>
+using ors_m = nullary_variadic_m<false_c, or_m<>, Exprs...>;
 
 // type_traits.hpp =============================================================
 
-template <class TypeExpr> struct alignment_of_m;
+/// `std::alignment_of` as a non-strict meta function template.
+template <class... Expr> struct alignment_of_m;
+
+//
+
+/// `std::is_array` as a non-strict meta function template.
+template <class... Expr> struct is_array_m;
+
+/// `std::is_pointer` as a non-strict meta function template.
+template <class... Expr> struct is_pointer_m;
+
+//
+
+/// `std::is_same` as a non-strict meta function template.
+template <class... Exprs> struct is_same_m;
+
+//
 
-template <class TypeExpr> struct is_array_m;
-template <class TypeExpr> struct is_pointer_m;
-template <class LhsTypeExpr, class RhsTypeExpr> struct is_same_m;
+/// `std::remove_all_extents` as a non-strict meta function template.
+template <class... Expr> struct remove_all_extents_m;
 
-template <class TypeExpr> struct remove_all_extents_m;
-template <class TypeExpr> struct remove_pointer_m;
+/// `std::remove_pointer` as a non-strict meta function template.
+template <class... Expr> struct remove_pointer_m;
 
 } // namespace lax_v1
diff --git a/provides/include/lax_v1/type.hpp b/provides/include/lax_v1/type.hpp
deleted file mode 100644
index c53502c..0000000
--- a/provides/include/lax_v1/type.hpp
+++ /dev/null
@@ -1,8 +0,0 @@
-#pragma once
-
-#include "lax_v1/synopsis.hpp"
-
-template <class T> struct lax_v1::type_t {
-  using eval = type_t;
-  using type = T;
-};
diff --git a/provides/include/lax_v1/type_traits.hpp b/provides/include/lax_v1/type_traits.hpp
index 064afc5..c4c5423 100644
--- a/provides/include/lax_v1/type_traits.hpp
+++ b/provides/include/lax_v1/type_traits.hpp
@@ -1,30 +1,31 @@
 #pragma once
 
-#include "lax_v1/lazify.hpp"
+#include "lax_v1/core.hpp"
 
-#include <cstddef>
-#include <type_traits>
-
-template <class TypeExpr>
+template <class... Exprs>
 struct lax_v1::alignment_of_m
-    : lazify_value_trait_t<size_t, std::alignment_of, TypeExpr> {};
+    : value_trait_c<std::alignment_of, 1, size_t, Exprs...> {};
+
+//
 
-template <class TypeExpr>
-struct lax_v1::is_array_m
-    : lazify_value_trait_t<bool, std::is_array, TypeExpr> {};
+template <class... Exprs>
+struct lax_v1::is_array_m : value_trait_c<std::is_array, 1, bool, Exprs...> {};
 
-template <class TypeExpr>
+template <class... Exprs>
 struct lax_v1::is_pointer_m
-    : lazify_value_trait_t<bool, std::is_pointer, TypeExpr> {};
+    : value_trait_c<std::is_pointer, 1, bool, Exprs...> {};
+
+//
+
+template <class... Exprs>
+struct lax_v1::is_same_m : value_trait_c<std::is_same, 2, bool, Exprs...> {};
 
-template <class LhsTypeExpr, class RhsTypeExpr>
-struct lax_v1::is_same_m
-    : lazify_value_trait_t<bool, std::is_same, LhsTypeExpr, RhsTypeExpr> {};
+//
 
-template <class TypeExpr>
+template <class... Exprs>
 struct lax_v1::remove_all_extents_m
-    : lazify_type_trait_t<std::remove_all_extents, TypeExpr> {};
+    : type_trait_c<std::remove_all_extents, 1, Exprs...> {};
 
-template <class TypeExpr>
+template <class... Exprs>
 struct lax_v1::remove_pointer_m
-    : lazify_type_trait_t<std::remove_pointer, TypeExpr> {};
+    : type_trait_c<std::remove_pointer, 1, Exprs...> {};
diff --git a/provides/include/lax_v1/value.hpp b/provides/include/lax_v1/value.hpp
deleted file mode 100644
index f095220..0000000
--- a/provides/include/lax_v1/value.hpp
+++ /dev/null
@@ -1,10 +0,0 @@
-#pragma once
-
-#include "lax_v1/synopsis.hpp"
-
-#include <type_traits>
-
-template <class Type, Type value>
-struct lax_v1::value_t : std::integral_constant<Type, value> {
-  using eval = value_t;
-};