From 9413cace9423b822e37b94f35e61560816a1ecd5 Mon Sep 17 00:00:00 2001
From: Bruno Dutra <brunocodutra@gmail.com>
Date: Mon, 5 Sep 2016 23:33:41 -0300
Subject: [PATCH 1/7] clean up for consistency

---
 include/metal/list/range.hpp        |  35 ++++----
 include/metal/list/sort.hpp         |  24 ++----
 include/metal/list/transform.hpp    |   1 +
 include/metal/map/map.hpp           |   2 +-
 test/include/test/expressions.hpp   |  22 ++---
 test/include/test/lambda.hpp        |   4 +-
 test/include/test/numbers.hpp       |   4 +-
 test/include/test/sequences.hpp     |   4 +-
 test/include/test/values.hpp        |   4 +-
 test/src/metal.cpp                  |  56 ++++++-------
 test/src/metal/lambda/apply.cpp     |  92 ++++++++++-----------
 test/src/metal/lambda/arg.cpp       |   4 +-
 test/src/metal/lambda/bind.cpp      |  72 ++++++++--------
 test/src/metal/lambda/invoke.cpp    |  68 ++++++++--------
 test/src/metal/lambda/lambda.cpp    |   8 +-
 test/src/metal/lambda/partial.cpp   |  70 ++++++++--------
 test/src/metal/lambda/quote.cpp     |  22 ++---
 test/src/metal/list/all.cpp         |  78 +++++++++---------
 test/src/metal/list/any.cpp         |  80 +++++++++---------
 test/src/metal/list/append.cpp      |  72 ++++++++--------
 test/src/metal/list/at.cpp          |  88 ++++++++++----------
 test/src/metal/list/back.cpp        |  12 +--
 test/src/metal/list/contains.cpp    |  88 ++++++++++----------
 test/src/metal/list/copy.cpp        |  86 ++++++++++----------
 test/src/metal/list/copy_if.cpp     |  86 ++++++++++----------
 test/src/metal/list/count.cpp       |  90 ++++++++++----------
 test/src/metal/list/count_if.cpp    |  86 ++++++++++----------
 test/src/metal/list/drop.cpp        |  68 ++++++++--------
 test/src/metal/list/empty.cpp       |  12 +--
 test/src/metal/list/erase.cpp       |  74 ++++++++---------
 test/src/metal/list/find.cpp        |  90 ++++++++++----------
 test/src/metal/list/find_if.cpp     |  86 ++++++++++----------
 test/src/metal/list/flatten.cpp     |  12 +--
 test/src/metal/list/fold_left.cpp   |  86 ++++++++++----------
 test/src/metal/list/fold_right.cpp  |  86 ++++++++++----------
 test/src/metal/list/front.cpp       |  12 +--
 test/src/metal/list/indices.cpp     |  14 ++--
 test/src/metal/list/insert.cpp      | 100 +++++++++++------------
 test/src/metal/list/join.cpp        |  74 ++++++++---------
 test/src/metal/list/list.cpp        |  15 ++--
 test/src/metal/list/none.cpp        |  80 +++++++++---------
 test/src/metal/list/partition.cpp   |  86 ++++++++++----------
 test/src/metal/list/prepend.cpp     |  72 ++++++++--------
 test/src/metal/list/range.cpp       |  78 +++++++++---------
 test/src/metal/list/remove.cpp      |  86 ++++++++++----------
 test/src/metal/list/remove_if.cpp   |  86 ++++++++++----------
 test/src/metal/list/replace.cpp     | 104 ++++++++++++------------
 test/src/metal/list/replace_if.cpp  | 122 ++++++++++++++--------------
 test/src/metal/list/reverse.cpp     |  14 ++--
 test/src/metal/list/rotate.cpp      |  84 +++++++++----------
 test/src/metal/list/size.cpp        |  12 +--
 test/src/metal/list/slice.cpp       | 104 ++++++++++++------------
 test/src/metal/list/sort.cpp        |  84 +++++++++----------
 test/src/metal/list/splice.cpp      |  82 +++++++++----------
 test/src/metal/list/take.cpp        |  82 +++++++++----------
 test/src/metal/list/transform.cpp   |  76 ++++++++---------
 test/src/metal/list/transpose.cpp   |  12 +--
 test/src/metal/map/at_key.cpp       |  84 +++++++++----------
 test/src/metal/map/erase_key.cpp    |  82 +++++++++----------
 test/src/metal/map/has_key.cpp      |  86 ++++++++++----------
 test/src/metal/map/keys.cpp         |  10 +--
 test/src/metal/map/map.cpp          |  14 ++--
 test/src/metal/map/order.cpp        |  84 +++++++++----------
 test/src/metal/map/values.cpp       |  10 +--
 test/src/metal/number/add.cpp       |  68 ++++++++--------
 test/src/metal/number/and.cpp       |  70 ++++++++--------
 test/src/metal/number/dec.cpp       |  10 +--
 test/src/metal/number/div.cpp       |  68 ++++++++--------
 test/src/metal/number/enumerate.cpp |  94 ++++++++++-----------
 test/src/metal/number/greater.cpp   |  82 +++++++++----------
 test/src/metal/number/if.cpp        |  68 ++++++++--------
 test/src/metal/number/inc.cpp       |  10 +--
 test/src/metal/number/less.cpp      |  82 +++++++++----------
 test/src/metal/number/max.cpp       |  68 ++++++++--------
 test/src/metal/number/min.cpp       |  68 ++++++++--------
 test/src/metal/number/mod.cpp       |  68 ++++++++--------
 test/src/metal/number/mul.cpp       |  68 ++++++++--------
 test/src/metal/number/neg.cpp       |  10 +--
 test/src/metal/number/not.cpp       |  10 +--
 test/src/metal/number/number.cpp    |   8 +-
 test/src/metal/number/or.cpp        |  70 ++++++++--------
 test/src/metal/number/pow.cpp       |  70 ++++++++--------
 test/src/metal/number/sub.cpp       |  68 ++++++++--------
 test/src/metal/pair/first.cpp       |  10 +--
 test/src/metal/pair/pair.cpp        |  86 ++++++++++----------
 test/src/metal/pair/second.cpp      |  10 +--
 test/src/metal/value/distinct.cpp   |  58 ++++++-------
 test/src/metal/value/same.cpp       |  58 ++++++-------
 test/src/metal/value/value.cpp      |  16 ++--
 89 files changed, 2457 insertions(+), 2462 deletions(-)

diff --git a/include/metal/list/range.hpp b/include/metal/list/range.hpp
index 82b6094c..6a401629 100644
--- a/include/metal/list/range.hpp
+++ b/include/metal/list/range.hpp
@@ -9,10 +9,10 @@
 
 #include <metal/list/size.hpp>
 #include <metal/number/if.hpp>
-#include <metal/number/max.hpp>
-#include <metal/number/min.hpp>
+#include <metal/number/or.hpp>
+#include <metal/number/not.hpp>
 #include <metal/number/number.hpp>
-#include <metal/value/same.hpp>
+#include <metal/number/greater.hpp>
 
 namespace metal
 {
@@ -32,8 +32,8 @@ namespace metal
     template<typename seq, typename beg, typename end>
     using range = detail::range<
         seq,
-        if_<same<min<max<number<0>, beg>, size<seq>>, beg>, beg>,
-        if_<same<min<max<number<0>, end>, size<seq>>, end>, end>
+        if_<not_<or_<greater<number<0>, beg>, greater<beg, size<seq>>>>, beg>,
+        if_<not_<or_<greater<number<0>, end>, greater<end, size<seq>>>>, end>
     >;
 }
 
@@ -42,6 +42,8 @@ namespace metal
 #include <metal/list/reverse.hpp>
 #include <metal/number/enumerate.hpp>
 #include <metal/number/sub.hpp>
+#include <metal/number/max.hpp>
+#include <metal/number/min.hpp>
 #include <metal/value/value.hpp>
 
 #include <metal/detail/declptr.hpp>
@@ -53,14 +55,11 @@ namespace metal
         template<typename> using void_ = void;
 
         template<typename, typename>
-        struct _skip
+        struct _skip_impl
         {};
 
-        template<typename seq, typename _>
-        using skip = typename _skip<seq, _>::type;
-
         template<typename... vals, typename... _>
-        struct _skip<list<vals...>, list<_...>>
+        struct _skip_impl<list<vals...>, list<_...>>
         {
             template<typename... tail>
             static list<tail...> impl(void_<_>*..., value<tail>*...);
@@ -68,6 +67,9 @@ namespace metal
             using type = decltype(impl(declptr<value<vals>>()...));
         };
 
+        template<typename seq, typename num>
+        using skip = typename _skip_impl<seq, enumerate<number<0>, num>>::type;
+
         template<typename seq, typename beg, typename end>
         struct _range
         {
@@ -82,17 +84,16 @@ namespace metal
             >;
         };
 
-        template<typename seq, typename n>
-        struct _range<seq, number<0>, n>
+        template<typename seq, typename num>
+        struct _range<seq, number<0>, num>
         {
-            using type =
-                skip<rotate<seq, n>, enumerate<number<0>, sub<size<seq>, n>>>;
+            using type = skip<rotate<seq, num>, sub<size<seq>, num>>;
         };
 
-        template<typename seq, typename n>
-        struct _range<seq, n, size<seq>>
+        template<typename seq, typename num>
+        struct _range<seq, num, size<seq>>
         {
-            using type = skip<seq, enumerate<number<0>, n>>;
+            using type = skip<seq, num>;
         };
 
         template<typename seq>
diff --git a/include/metal/list/sort.hpp b/include/metal/list/sort.hpp
index 83a6e9a0..d121825c 100644
--- a/include/metal/list/sort.hpp
+++ b/include/metal/list/sort.hpp
@@ -7,18 +7,12 @@
 
 #include <metal/config.hpp>
 
-#include <metal/lambda/lambda.hpp>
-#include <metal/number/if.hpp>
-
 namespace metal
 {
     namespace detail
     {
         template<typename seq, typename lbd>
         struct _sort;
-
-        template<typename seq, typename lbd>
-        using sort = typename _sort<seq, lbd>::type;
     }
 
     /// \ingroup list
@@ -26,7 +20,7 @@ namespace metal
     /// ### Description
     /// ...
     template<typename seq, typename lbd>
-    using sort = detail::sort<seq, if_<is_lambda<lbd>, lbd>>;
+    using sort = typename detail::_sort<seq, lbd>::type;
 }
 
 #include <metal/list/list.hpp>
@@ -34,8 +28,10 @@ namespace metal
 #include <metal/list/size.hpp>
 #include <metal/list/range.hpp>
 #include <metal/lambda/invoke.hpp>
+#include <metal/lambda/lambda.hpp>
 #include <metal/number/number.hpp>
 #include <metal/number/div.hpp>
+#include <metal/number/if.hpp>
 
 namespace metal
 {
@@ -108,16 +104,14 @@ namespace metal
         {};
 
         template<typename x, typename lbd>
-        struct _sort<list<x>, lbd>
-        {
-            using type = list<x>;
-        };
+        struct _sort<list<x>, lbd> :
+            _if_<is_lambda<lbd>, list<x>>
+        {};
 
         template<typename lbd>
-        struct _sort<list<>, lbd>
-        {
-            using type = list<>;
-        };
+        struct _sort<list<>, lbd> :
+            _if_<is_lambda<lbd>, list<>>
+        {};
     }
 }
 
diff --git a/include/metal/list/transform.hpp b/include/metal/list/transform.hpp
index e3e1ce9b..674b8e21 100644
--- a/include/metal/list/transform.hpp
+++ b/include/metal/list/transform.hpp
@@ -36,6 +36,7 @@ namespace metal
 
 #include <metal/list/at.hpp>
 #include <metal/list/list.hpp>
+#include <metal/list/indices.hpp>
 #include <metal/lambda/bind.hpp>
 #include <metal/lambda/apply.hpp>
 #include <metal/lambda/invoke.hpp>
diff --git a/include/metal/map/map.hpp b/include/metal/map/map.hpp
index 6c7d6e8c..913992a1 100644
--- a/include/metal/map/map.hpp
+++ b/include/metal/map/map.hpp
@@ -62,7 +62,7 @@ namespace metal
     >;
 }
 
-#include <metal/list/list.hpp>
+#include <metal/number/number.hpp>
 #include <metal/value/distinct.hpp>
 
 namespace metal
diff --git a/test/include/test/expressions.hpp b/test/include/test/expressions.hpp
index 23ba1ab9..d835c3f6 100644
--- a/test/include/test/expressions.hpp
+++ b/test/include/test/expressions.hpp
@@ -20,20 +20,20 @@ namespace test
 
     template<typename... _>
     using expr0 =
-        typename std::enable_if<length<_...>::value == 0, NUM(0)>::type;
+        typename std::enable_if<length<_...>::value == 0, NUMBER(0)>::type;
 
     template<typename... _>
     using expr1 =
-        typename std::enable_if<length<_...>::value == 1, NUM(1)>::type;
-
-    template<SCAN(ENUM(2, typename NIL))> using expr2  = NUM(2);
-    template<SCAN(ENUM(3, typename NIL))> using expr3  = NUM(3);
-    template<SCAN(ENUM(4, typename NIL))> using expr4  = NUM(4);
-    template<SCAN(ENUM(5, typename NIL))> using expr5  = NUM(5);
-    template<SCAN(ENUM(6, typename NIL))> using expr6  = NUM(6);
-    template<SCAN(ENUM(7, typename NIL))> using expr7  = NUM(7);
-    template<SCAN(ENUM(8, typename NIL))> using expr8  = NUM(8);
-    template<SCAN(ENUM(9, typename NIL))> using expr9  = NUM(9);
+        typename std::enable_if<length<_...>::value == 1, NUMBER(1)>::type;
+
+    template<SCAN(ENUM(2, typename NIL))> using expr2  = NUMBER(2);
+    template<SCAN(ENUM(3, typename NIL))> using expr3  = NUMBER(3);
+    template<SCAN(ENUM(4, typename NIL))> using expr4  = NUMBER(4);
+    template<SCAN(ENUM(5, typename NIL))> using expr5  = NUMBER(5);
+    template<SCAN(ENUM(6, typename NIL))> using expr6  = NUMBER(6);
+    template<SCAN(ENUM(7, typename NIL))> using expr7  = NUMBER(7);
+    template<SCAN(ENUM(8, typename NIL))> using expr8  = NUMBER(8);
+    template<SCAN(ENUM(9, typename NIL))> using expr9  = NUMBER(9);
 }
 
 #define EXPR(...) CAT(test::expr, __VA_ARGS__)
diff --git a/test/include/test/lambda.hpp b/test/include/test/lambda.hpp
index 95dedb64..c47c0ca8 100644
--- a/test/include/test/lambda.hpp
+++ b/test/include/test/lambda.hpp
@@ -8,7 +8,7 @@
 #include "test/expressions.hpp"
 #include "test/preprocessor.hpp"
 
-#define LBD(...) metal::lambda<EXPR(__VA_ARGS__)>
-#define LBDS(N) ENUM(N, LBD)
+#define LAMBDA(...) metal::lambda<EXPR(__VA_ARGS__)>
+#define LAMBDAS(N) ENUM(N, LAMBDA)
 
 #endif
diff --git a/test/include/test/numbers.hpp b/test/include/test/numbers.hpp
index d2059192..e2494545 100644
--- a/test/include/test/numbers.hpp
+++ b/test/include/test/numbers.hpp
@@ -33,8 +33,8 @@ namespace test
 #define FACT_9 FACT_7*9
 #define FACT(N) (CAT(FACT_, N))
 
-#define NUM(N) CAT(test::num, N)
-#define NUMS(N) ENUM(N, NUM)
+#define NUMBER(N) CAT(test::num, N)
+#define NUMBERS(N) ENUM(N, NUMBER)
 
 #define BOOL(B) metal::number<(B)>
 #define TRUE BOOL(true)
diff --git a/test/include/test/sequences.hpp b/test/include/test/sequences.hpp
index d6de8dfd..3386ac8b 100644
--- a/test/include/test/sequences.hpp
+++ b/test/include/test/sequences.hpp
@@ -9,10 +9,10 @@
 #include "test/numbers.hpp"
 #include "test/preprocessor.hpp"
 
-#define PAIR(N) metal::list<NUM(N), VAL(N)>
+#define PAIR(N) metal::list<NUMBER(N), VALUE(N)>
 #define PAIRS(N) ENUM(N, PAIR)
 
-#define LIST(N) metal::list<VALS(N)>
+#define LIST(N) metal::list<VALUES(N)>
 #define LISTS(N) ENUM(N, LIST)
 
 #define MAP(N) metal::list<PAIRS(N)>
diff --git a/test/include/test/values.hpp b/test/include/test/values.hpp
index 53fd1ca3..f70192cc 100644
--- a/test/include/test/values.hpp
+++ b/test/include/test/values.hpp
@@ -21,7 +21,7 @@ namespace test
     enum  val9 {type};
 }
 
-#define VAL(N) CAT(test::val, N)
-#define VALS(N) ENUM(N, VAL)
+#define VALUE(N) CAT(test::val, N)
+#define VALUES(N) ENUM(N, VALUE)
 
 #endif
diff --git a/test/src/metal.cpp b/test/src/metal.cpp
index 8929eee4..38cfa438 100644
--- a/test/src/metal.cpp
+++ b/test/src/metal.cpp
@@ -7,43 +7,43 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::not_<metal::not_<NUM(N)>>), (BOOL(!!N))); \
-    CHECK((metal::not_<metal::and_<NUM(M), NUM(N)>>), (metal::or_<metal::not_<NUM(M)>, metal::not_<NUM(N)>>)); \
-    CHECK((metal::not_<metal::or_<NUM(M), NUM(N)>>), (metal::and_<metal::not_<NUM(M)>, metal::not_<NUM(N)>>)); \
-    CHECK((metal::neg<metal::neg<NUM(N)>>), (NUM(N))); \
-    CHECK((metal::inc<metal::dec<NUM(N)>>), (NUM(N))); \
-    CHECK((metal::dec<metal::inc<NUM(N)>>), (NUM(N))); \
-    CHECK((metal::same<metal::add<NUM(0) COMMA(N) ENUM(N, NUM FIX(M))>, metal::mul<NUM(M), NUM(N)>>), (TRUE)); \
-    CHECK((metal::same<metal::mul<NUM(1) COMMA(N) ENUM(N, NUM FIX(M))>, metal::pow<NUM(M), NUM(N)>>), (TRUE)); \
-    CHECK((metal::same<metal::add<NUMS(INC(N))>, metal::div<metal::mul<NUM(N), metal::inc<NUM(N)>>, NUM(2)>>), (TRUE)); \
-    CHECK((metal::same<metal::sub<NUM(M), metal::mul<metal::div<NUM(M), NUM(INC(N))>, NUM(INC(N))>>, metal::mod<NUM(M), NUM(INC(N))>>), (TRUE)); \
-    CHECK((metal::same<metal::mod<metal::pow<NUM(INC(M)), NUM(INC(N))>, NUM(INC(M))>, NUM(0)>), (TRUE)); \
-    CHECK((metal::same<NUM(M), NUM(N)>), (metal::not_<metal::or_<metal::less<NUM(M), NUM(N)>, metal::greater<NUM(M), NUM(N)>>>)); \
-    CHECK((metal::less<NUM(M), NUM(N)>), (metal::greater<NUM(N), NUM(M)>)); \
-    CHECK((metal::if_<NUM(M), BOOL(!!N), FALSE>), (metal::and_<NUM(M), NUM(N)>)); \
-    CHECK((metal::if_<NUM(M), TRUE, BOOL(!!N)>), (metal::or_<NUM(M), NUM(N)>)); \
-    CHECK((metal::at<LIST(INF), metal::find<LIST(INF), VAL(M)>>), (VAL(M))); \
-    CHECK((metal::insert<LIST(M), NUM(M), VAL(N)>), (metal::append<LIST(M), VAL(N)>)); \
-    CHECK((metal::insert<LIST(M), NUM(0), VAL(N)>), (metal::prepend<LIST(M), VAL(N)>)); \
-    CHECK((metal::erase<LIST(INF), NUM(M), NUM(INF)>), (metal::take<LIST(INF), NUM(M)>)); \
-    CHECK((metal::erase<LIST(INF), NUM(0), NUM(M)>), (metal::drop<LIST(INF), NUM(M)>)); \
-    CHECK((metal::slice<LIST(M), NUM(0), metal::size<LIST(M)>>), (LIST(M))); \
-    CHECK((metal::take<LIST(INF), NUM(M)>), (metal::reverse<metal::drop<metal::reverse<LIST(INF)>, NUM(CMPL(M))>>)); \
-    CHECK((metal::rotate<LIST(INF), NUM(M)>), (metal::join<metal::drop<LIST(INF), NUM(M)>, metal::take<LIST(INF), NUM(M)>>)); \
-    CHECK((metal::sort<metal::list<NUMS(M)>, metal::lambda<metal::greater>>), (metal::reverse<metal::list<NUMS(M)>>)); \
-    CHECK((metal::same<metal::enumerate<NUM(M), NUM(N), NUM(0)>>), (TRUE)); \
+    CHECK((metal::not_<metal::not_<NUMBER(N)>>), (BOOL(!!N))); \
+    CHECK((metal::not_<metal::and_<NUMBER(M), NUMBER(N)>>), (metal::or_<metal::not_<NUMBER(M)>, metal::not_<NUMBER(N)>>)); \
+    CHECK((metal::not_<metal::or_<NUMBER(M), NUMBER(N)>>), (metal::and_<metal::not_<NUMBER(M)>, metal::not_<NUMBER(N)>>)); \
+    CHECK((metal::neg<metal::neg<NUMBER(N)>>), (NUMBER(N))); \
+    CHECK((metal::inc<metal::dec<NUMBER(N)>>), (NUMBER(N))); \
+    CHECK((metal::dec<metal::inc<NUMBER(N)>>), (NUMBER(N))); \
+    CHECK((metal::same<metal::add<NUMBER(0) COMMA(N) ENUM(N, NUMBER FIX(M))>, metal::mul<NUMBER(M), NUMBER(N)>>), (TRUE)); \
+    CHECK((metal::same<metal::mul<NUMBER(1) COMMA(N) ENUM(N, NUMBER FIX(M))>, metal::pow<NUMBER(M), NUMBER(N)>>), (TRUE)); \
+    CHECK((metal::same<metal::add<NUMBERS(INC(N))>, metal::div<metal::mul<NUMBER(N), metal::inc<NUMBER(N)>>, NUMBER(2)>>), (TRUE)); \
+    CHECK((metal::same<metal::sub<NUMBER(M), metal::mul<metal::div<NUMBER(M), NUMBER(INC(N))>, NUMBER(INC(N))>>, metal::mod<NUMBER(M), NUMBER(INC(N))>>), (TRUE)); \
+    CHECK((metal::same<metal::mod<metal::pow<NUMBER(INC(M)), NUMBER(INC(N))>, NUMBER(INC(M))>, NUMBER(0)>), (TRUE)); \
+    CHECK((metal::same<NUMBER(M), NUMBER(N)>), (metal::not_<metal::or_<metal::less<NUMBER(M), NUMBER(N)>, metal::greater<NUMBER(M), NUMBER(N)>>>)); \
+    CHECK((metal::less<NUMBER(M), NUMBER(N)>), (metal::greater<NUMBER(N), NUMBER(M)>)); \
+    CHECK((metal::if_<NUMBER(M), BOOL(!!N), FALSE>), (metal::and_<NUMBER(M), NUMBER(N)>)); \
+    CHECK((metal::if_<NUMBER(M), TRUE, BOOL(!!N)>), (metal::or_<NUMBER(M), NUMBER(N)>)); \
+    CHECK((metal::at<LIST(INF), metal::find<LIST(INF), VALUE(M)>>), (VALUE(M))); \
+    CHECK((metal::insert<LIST(M), NUMBER(M), VALUE(N)>), (metal::append<LIST(M), VALUE(N)>)); \
+    CHECK((metal::insert<LIST(M), NUMBER(0), VALUE(N)>), (metal::prepend<LIST(M), VALUE(N)>)); \
+    CHECK((metal::erase<LIST(INF), NUMBER(M), NUMBER(INF)>), (metal::take<LIST(INF), NUMBER(M)>)); \
+    CHECK((metal::erase<LIST(INF), NUMBER(0), NUMBER(M)>), (metal::drop<LIST(INF), NUMBER(M)>)); \
+    CHECK((metal::slice<LIST(M), NUMBER(0), metal::size<LIST(M)>>), (LIST(M))); \
+    CHECK((metal::take<LIST(INF), NUMBER(M)>), (metal::reverse<metal::drop<metal::reverse<LIST(INF)>, NUMBER(CMPL(M))>>)); \
+    CHECK((metal::rotate<LIST(INF), NUMBER(M)>), (metal::join<metal::drop<LIST(INF), NUMBER(M)>, metal::take<LIST(INF), NUMBER(M)>>)); \
+    CHECK((metal::sort<metal::list<NUMBERS(M)>, metal::lambda<metal::greater>>), (metal::reverse<metal::list<NUMBERS(M)>>)); \
+    CHECK((metal::same<metal::enumerate<NUMBER(M), NUMBER(N), NUMBER(0)>>), (TRUE)); \
     CHECK((metal::flatten<metal::transpose<metal::list<LIST(M)>>>), (LIST(M))); \
     CHECK((metal::flatten<metal::fold_left<LIST(M), metal::list<>, metal::lambda<metal::list>>>), (LIST(M))); \
     CHECK((metal::fold_left<LIST(M), metal::list<>, metal::lambda<metal::prepend>>), (metal::fold_right<LIST(M), metal::list<>, metal::lambda<metal::append>>)); \
-    CHECK((metal::range<LIST(M), metal::size<LIST(M)>, NUM(0)>), (metal::reverse<LIST(M)>)); \
+    CHECK((metal::range<LIST(M), metal::size<LIST(M)>, NUMBER(0)>), (metal::reverse<LIST(M)>)); \
     CHECK((metal::transform<metal::bind<metal::lambda<metal::at>, metal::quote<LIST(M)>, metal::_1>, metal::indices<LIST(M)>>), (LIST(M))); \
     CHECK((metal::transpose<metal::transpose<MAP(INC(M))>>), (MAP(INC(M)))); \
     CHECK((metal::transform<metal::bind<metal::lambda<metal::first>, metal::_1>, MAP(M)>), (metal::keys<MAP(M)>)); \
     CHECK((metal::transform<metal::bind<metal::lambda<metal::second>, metal::_1>, MAP(M)>), (metal::values<MAP(M)>)); \
     CHECK((metal::first<metal::transpose<MAP(INC(M))>>), (metal::keys<MAP(INC(M))>)); \
     CHECK((metal::second<metal::transpose<MAP(INC(M))>>), (metal::values<MAP(INC(M))>)); \
-    CHECK((metal::at<MAP(INF), metal::order<MAP(INF), NUM(N)>>), (PAIR(N))); \
-    CHECK((metal::has_key<metal::erase_key<metal::list<PAIRS(INF)>, NUM(M)>, NUM(M)>), (FALSE)); \
+    CHECK((metal::at<MAP(INF), metal::order<MAP(INF), NUMBER(N)>>), (PAIR(N))); \
+    CHECK((metal::has_key<metal::erase_key<MAP(INF), NUMBER(M)>, NUMBER(N)>), (BOOL(M != N))); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/lambda/apply.cpp b/test/src/metal/lambda/apply.cpp
index c266b905..c9930cdb 100644
--- a/test/src/metal/lambda/apply.cpp
+++ b/test/src/metal/lambda/apply.cpp
@@ -11,61 +11,61 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, VAL(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, VAL(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, VAL(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, VAL(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, VAL(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, VAL(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, VAL(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, NUM(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, NUM(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, NUM(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, NUM(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, NUM(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, NUM(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, NUM(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, PAIR(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, PAIR(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, VALUE(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, VALUE(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, VALUE(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, VALUE(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, VALUE(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, VALUE(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, VALUE(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, NUMBER(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, NUMBER(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, NUMBER(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, NUMBER(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, NUMBER(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, NUMBER(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, NUMBER(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, PAIR(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, PAIR(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::apply>, PAIR(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::apply>, PAIR(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::apply>, PAIR(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, PAIR(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, PAIR(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, LIST(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, LIST(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, PAIR(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, PAIR(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, LIST(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, LIST(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::apply>, LIST(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::apply>, LIST(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::apply>, LIST(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, LIST(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, LIST(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, MAP(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, MAP(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, LIST(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, LIST(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, MAP(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, MAP(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::apply>, MAP(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::apply>, MAP(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::apply>, MAP(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, MAP(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, MAP(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, LBD(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, LBD(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, LBD(M), PAIR(N)>), (BOOL(M == 2))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, LBD(M), LIST(N)>), (BOOL(M == N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, LBD(M), MAP(N)>), (BOOL(M == N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, LBD(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, LBD(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, LBD(_), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, LBD(_), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, LBD(_), PAIR(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, LBD(_), LIST(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, LBD(_), MAP(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, LBD(_), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::apply>, LBD(_), LBD(_)>), (FALSE)); \
-    CHECK((metal::apply<LBD(2), PAIR(M)>), (EXPR(2)<NUM(M), VAL(M)>)); \
-    CHECK((metal::apply<LBD(_), PAIR(M)>), (EXPR(_)<NUM(M), VAL(M)>)); \
-    CHECK((metal::apply<LBD(M), LIST(M)>), (EXPR(M)<VALS(M)>)); \
-    CHECK((metal::apply<LBD(_), LIST(M)>), (EXPR(_)<VALS(M)>)); \
-    CHECK((metal::apply<LBD(M), MAP(M)>), (EXPR(M)<PAIRS(M)>)); \
-    CHECK((metal::apply<LBD(_), MAP(M)>), (EXPR(_)<PAIRS(M)>)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, MAP(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, MAP(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, LAMBDA(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, LAMBDA(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, LAMBDA(M), PAIR(N)>), (BOOL(M == 2))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, LAMBDA(M), LIST(N)>), (BOOL(M == N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, LAMBDA(M), MAP(N)>), (BOOL(M == N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, LAMBDA(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, LAMBDA(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, LAMBDA(_), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, LAMBDA(_), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, LAMBDA(_), PAIR(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, LAMBDA(_), LIST(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, LAMBDA(_), MAP(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, LAMBDA(_), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::apply>, LAMBDA(_), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::apply<LAMBDA(2), PAIR(M)>), (EXPR(2)<NUMBER(M), VALUE(M)>)); \
+    CHECK((metal::apply<LAMBDA(_), PAIR(M)>), (EXPR(_)<NUMBER(M), VALUE(M)>)); \
+    CHECK((metal::apply<LAMBDA(M), LIST(M)>), (EXPR(M)<VALUES(M)>)); \
+    CHECK((metal::apply<LAMBDA(_), LIST(M)>), (EXPR(_)<VALUES(M)>)); \
+    CHECK((metal::apply<LAMBDA(M), MAP(M)>), (EXPR(M)<PAIRS(M)>)); \
+    CHECK((metal::apply<LAMBDA(_), MAP(M)>), (EXPR(_)<PAIRS(M)>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/lambda/arg.cpp b/test/src/metal/lambda/arg.cpp
index e77feb24..2574a7e9 100644
--- a/test/src/metal/lambda/arg.cpp
+++ b/test/src/metal/lambda/arg.cpp
@@ -13,8 +13,8 @@
 #define MATRIX(M, N) \
     CHECK((metal::arg<INC(M)>), (CAT(metal::_, INC(M)))); \
     CHECK((metal::is_lambda<metal::arg<INC(M)>>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::arg<INC(M)> COMMA(N) VALS(N)>), (BOOL(M < N))); \
-    CHECK((metal::invoke<metal::arg<INC(M)>, VALS(INC(M))>), (VAL(M))); \
+    CHECK((metal::is_invocable<metal::arg<INC(M)> COMMA(N) VALUES(N)>), (BOOL(M < N))); \
+    CHECK((metal::invoke<metal::arg<INC(M)>, VALUES(INC(M))>), (VALUE(M))); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/lambda/bind.cpp b/test/src/metal/lambda/bind.cpp
index 2302fd97..f94eb6a7 100644
--- a/test/src/metal/lambda/bind.cpp
+++ b/test/src/metal/lambda/bind.cpp
@@ -11,51 +11,51 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::bind>, VAL(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::bind>, VAL(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::bind>, VAL(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::bind>, VAL(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::bind>, VAL(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::bind>, VAL(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::bind>, NUM(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::bind>, NUM(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::bind>, NUM(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::bind>, NUM(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::bind>, NUM(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::bind>, NUM(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::bind>, PAIR(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::bind>, PAIR(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::bind>, VALUE(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::bind>, VALUE(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::bind>, VALUE(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::bind>, VALUE(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::bind>, VALUE(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::bind>, VALUE(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::bind>, NUMBER(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::bind>, NUMBER(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::bind>, NUMBER(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::bind>, NUMBER(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::bind>, NUMBER(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::bind>, NUMBER(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::bind>, PAIR(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::bind>, PAIR(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::bind>, PAIR(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::bind>, PAIR(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::bind>, PAIR(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::bind>, PAIR(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::bind>, LIST(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::bind>, LIST(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::bind>, PAIR(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::bind>, LIST(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::bind>, LIST(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::bind>, LIST(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::bind>, LIST(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::bind>, LIST(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::bind>, LIST(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::bind>, MAP(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::bind>, MAP(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::bind>, LIST(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::bind>, MAP(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::bind>, MAP(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::bind>, MAP(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::bind>, MAP(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::bind>, MAP(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::bind>, MAP(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::bind>, LBD(M) COMMA(N) VALS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::bind>, LBD(M) COMMA(N) NUMS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::bind>, LBD(M) COMMA(N) PAIRS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::bind>, LBD(M) COMMA(N) LISTS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::bind>, LBD(M) COMMA(N) MAPS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::bind>, LBD(M) COMMA(N) LBDS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::bind>, LBD(_) COMMA(N) VALS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::bind>, LBD(_) COMMA(N) NUMS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::bind>, LBD(_) COMMA(N) PAIRS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::bind>, LBD(_) COMMA(N) LISTS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::bind>, LBD(_) COMMA(N) MAPS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::bind>, LBD(_) COMMA(N) LBDS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::bind<LBD(M) COMMA(N) ENUM(N, LBD FIX(M))> COMMA(N) VALS(N)>), (BOOL(M == N))); \
-    CHECK((metal::invoke<metal::bind<LBD(M) COMMA(M) ENUM(M, LBD FIX(N))> COMMA(N) VALS(N)>), (EXPR(M)<ENUM(M, NUM FIX(N))>)); \
-    CHECK((metal::invoke<metal::bind<LBD(_) COMMA(M) ENUM(M, LBD FIX(N))> COMMA(N) VALS(N)>), (EXPR(_)<ENUM(M, NUM FIX(N))>)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::bind>, MAP(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::bind>, LAMBDA(M) COMMA(N) VALUES(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::bind>, LAMBDA(M) COMMA(N) NUMBERS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::bind>, LAMBDA(M) COMMA(N) PAIRS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::bind>, LAMBDA(M) COMMA(N) LISTS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::bind>, LAMBDA(M) COMMA(N) MAPS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::bind>, LAMBDA(M) COMMA(N) LAMBDAS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::bind>, LAMBDA(_) COMMA(N) VALUES(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::bind>, LAMBDA(_) COMMA(N) NUMBERS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::bind>, LAMBDA(_) COMMA(N) PAIRS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::bind>, LAMBDA(_) COMMA(N) LISTS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::bind>, LAMBDA(_) COMMA(N) MAPS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::bind>, LAMBDA(_) COMMA(N) LAMBDAS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::bind<LAMBDA(M) COMMA(N) ENUM(N, LAMBDA FIX(M))> COMMA(N) VALUES(N)>), (BOOL(M == N))); \
+    CHECK((metal::invoke<metal::bind<LAMBDA(M) COMMA(M) ENUM(M, LAMBDA FIX(N))> COMMA(N) VALUES(N)>), (EXPR(M)<ENUM(M, NUMBER FIX(N))>)); \
+    CHECK((metal::invoke<metal::bind<LAMBDA(_) COMMA(M) ENUM(M, LAMBDA FIX(N))> COMMA(N) VALUES(N)>), (EXPR(_)<ENUM(M, NUMBER FIX(N))>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/lambda/invoke.cpp b/test/src/metal/lambda/invoke.cpp
index dcb2eded..8fabf251 100644
--- a/test/src/metal/lambda/invoke.cpp
+++ b/test/src/metal/lambda/invoke.cpp
@@ -10,46 +10,46 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<VAL(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<VAL(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<VAL(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<VAL(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<VAL(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<VAL(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<NUM(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<NUM(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<NUM(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<NUM(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<NUM(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<NUM(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<PAIR(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<PAIR(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<VALUE(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<VALUE(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<VALUE(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<VALUE(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<VALUE(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<VALUE(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<NUMBER(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<NUMBER(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<NUMBER(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<NUMBER(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<NUMBER(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<NUMBER(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<PAIR(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<PAIR(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<PAIR(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<PAIR(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<PAIR(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<PAIR(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<MAP(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<MAP(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<PAIR(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<MAP(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<MAP(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<MAP(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<MAP(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<MAP(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<MAP(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<LBD(M) COMMA(N) VALS(N)>), (BOOL(M == N))); \
-    CHECK((metal::is_invocable<LBD(M) COMMA(N) NUMS(N)>), (BOOL(M == N))); \
-    CHECK((metal::is_invocable<LBD(M) COMMA(N) PAIRS(N)>), (BOOL(M == N))); \
-    CHECK((metal::is_invocable<LBD(M) COMMA(N) LISTS(N)>), (BOOL(M == N))); \
-    CHECK((metal::is_invocable<LBD(M) COMMA(N) MAPS(N)>), (BOOL(M == N))); \
-    CHECK((metal::is_invocable<LBD(M) COMMA(N) LBDS(N)>), (BOOL(M == N))); \
-    CHECK((metal::is_invocable<LBD(_) COMMA(N) VALS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<LBD(_) COMMA(N) NUMS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<LBD(_) COMMA(N) PAIRS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<LBD(_) COMMA(N) LISTS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<LBD(_) COMMA(N) MAPS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<LBD(_) COMMA(N) LBDS(N)>), (TRUE)); \
-    CHECK((metal::invoke<LBD(M) COMMA(M) VALS(M)>), (EXPR(M)<VALS(M)>)); \
-    CHECK((metal::invoke<LBD(_) COMMA(M) VALS(M)>), (EXPR(_)<VALS(M)>)); \
-    CHECK((metal::invoke<LBD(M) COMMA(M) LBDS(M)>), (EXPR(M)<LBDS(M)>)); \
-    CHECK((metal::invoke<LBD(_) COMMA(M) LBDS(M)>), (EXPR(_)<LBDS(M)>)); \
+    CHECK((metal::is_invocable<MAP(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<LAMBDA(M) COMMA(N) VALUES(N)>), (BOOL(M == N))); \
+    CHECK((metal::is_invocable<LAMBDA(M) COMMA(N) NUMBERS(N)>), (BOOL(M == N))); \
+    CHECK((metal::is_invocable<LAMBDA(M) COMMA(N) PAIRS(N)>), (BOOL(M == N))); \
+    CHECK((metal::is_invocable<LAMBDA(M) COMMA(N) LISTS(N)>), (BOOL(M == N))); \
+    CHECK((metal::is_invocable<LAMBDA(M) COMMA(N) MAPS(N)>), (BOOL(M == N))); \
+    CHECK((metal::is_invocable<LAMBDA(M) COMMA(N) LAMBDAS(N)>), (BOOL(M == N))); \
+    CHECK((metal::is_invocable<LAMBDA(_) COMMA(N) VALUES(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<LAMBDA(_) COMMA(N) NUMBERS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<LAMBDA(_) COMMA(N) PAIRS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<LAMBDA(_) COMMA(N) LISTS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<LAMBDA(_) COMMA(N) MAPS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<LAMBDA(_) COMMA(N) LAMBDAS(N)>), (TRUE)); \
+    CHECK((metal::invoke<LAMBDA(M) COMMA(M) VALUES(M)>), (EXPR(M)<VALUES(M)>)); \
+    CHECK((metal::invoke<LAMBDA(_) COMMA(M) VALUES(M)>), (EXPR(_)<VALUES(M)>)); \
+    CHECK((metal::invoke<LAMBDA(M) COMMA(M) LAMBDAS(M)>), (EXPR(M)<LAMBDAS(M)>)); \
+    CHECK((metal::invoke<LAMBDA(_) COMMA(M) LAMBDAS(M)>), (EXPR(_)<LAMBDAS(M)>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/lambda/lambda.cpp b/test/src/metal/lambda/lambda.cpp
index 006a5356..447721fe 100644
--- a/test/src/metal/lambda/lambda.cpp
+++ b/test/src/metal/lambda/lambda.cpp
@@ -9,13 +9,13 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_lambda<VAL(N)>), (FALSE)); \
-    CHECK((metal::is_lambda<NUM(N)>), (FALSE)); \
+    CHECK((metal::is_lambda<VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_lambda<NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_lambda<PAIR(N)>), (FALSE)); \
     CHECK((metal::is_lambda<LIST(N)>), (FALSE)); \
     CHECK((metal::is_lambda<MAP(N)>), (FALSE)); \
-    CHECK((metal::is_lambda<LBD(N)>), (TRUE)); \
-    CHECK((metal::is_lambda<LBD(_)>), (TRUE)); \
+    CHECK((metal::is_lambda<LAMBDA(N)>), (TRUE)); \
+    CHECK((metal::is_lambda<LAMBDA(_)>), (TRUE)); \
     CHECK((metal::is_lambda<metal::lambda<metal::is_lambda>>), (TRUE)); \
     CHECK((metal::is_lambda<metal::lambda<metal::is_lambda>>), (TRUE)); \
 /**/
diff --git a/test/src/metal/lambda/partial.cpp b/test/src/metal/lambda/partial.cpp
index e597395b..f77113e4 100644
--- a/test/src/metal/lambda/partial.cpp
+++ b/test/src/metal/lambda/partial.cpp
@@ -12,50 +12,50 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::partial>, VAL(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partial>, VAL(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partial>, VAL(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partial>, VAL(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partial>, VAL(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partial>, VAL(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partial>, NUM(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partial>, NUM(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partial>, NUM(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partial>, NUM(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partial>, NUM(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partial>, NUM(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partial>, PAIR(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partial>, PAIR(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partial>, VALUE(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partial>, VALUE(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partial>, VALUE(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partial>, VALUE(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partial>, VALUE(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partial>, VALUE(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partial>, NUMBER(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partial>, NUMBER(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partial>, NUMBER(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partial>, NUMBER(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partial>, NUMBER(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partial>, NUMBER(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partial>, PAIR(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partial>, PAIR(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::partial>, PAIR(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::partial>, PAIR(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::partial>, PAIR(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partial>, PAIR(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partial>, LIST(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partial>, LIST(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partial>, PAIR(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partial>, LIST(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partial>, LIST(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::partial>, LIST(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::partial>, LIST(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::partial>, LIST(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partial>, LIST(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partial>, MAP(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partial>, MAP(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partial>, LIST(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partial>, MAP(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partial>, MAP(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::partial>, MAP(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::partial>, MAP(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::partial>, MAP(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partial>, MAP(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partial>, LBD(M) COMMA(N) VALS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partial>, LBD(M) COMMA(N) NUMS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partial>, LBD(M) COMMA(N) PAIRS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partial>, LBD(M) COMMA(N) LISTS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partial>, LBD(M) COMMA(N) MAPS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partial>, LBD(M) COMMA(N) LBDS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partial>, LBD(_) COMMA(N) VALS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partial>, LBD(_) COMMA(N) NUMS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partial>, LBD(_) COMMA(N) PAIRS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partial>, LBD(_) COMMA(N) LISTS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partial>, LBD(_) COMMA(N) MAPS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partial>, LBD(_) COMMA(N) LBDS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::partial<LBD(M) COMMA(N) ENUM(N, LBD FIX(M))> COMMA(N) VALS(N)>), (BOOL(M == 2*N))); \
-    CHECK((metal::invoke<metal::partial<LBD(_) COMMA(M) ENUM(M, LBD FIX(N))> COMMA(CMPL(M)) VALS(CMPL(M))>), (EXPR(_)<ENUM(M, LBD FIX(N)) COMMA(AND(M, CMPL(M))) VALS(CMPL(M))>)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partial>, MAP(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partial>, LAMBDA(M) COMMA(N) VALUES(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partial>, LAMBDA(M) COMMA(N) NUMBERS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partial>, LAMBDA(M) COMMA(N) PAIRS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partial>, LAMBDA(M) COMMA(N) LISTS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partial>, LAMBDA(M) COMMA(N) MAPS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partial>, LAMBDA(M) COMMA(N) LAMBDAS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partial>, LAMBDA(_) COMMA(N) VALUES(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partial>, LAMBDA(_) COMMA(N) NUMBERS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partial>, LAMBDA(_) COMMA(N) PAIRS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partial>, LAMBDA(_) COMMA(N) LISTS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partial>, LAMBDA(_) COMMA(N) MAPS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partial>, LAMBDA(_) COMMA(N) LAMBDAS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::partial<LAMBDA(M) COMMA(N) ENUM(N, LAMBDA FIX(M))> COMMA(N) VALUES(N)>), (BOOL(M == 2*N))); \
+    CHECK((metal::invoke<metal::partial<LAMBDA(_) COMMA(M) ENUM(M, LAMBDA FIX(N))> COMMA(CMPL(M)) VALUES(CMPL(M))>), (EXPR(_)<ENUM(M, LAMBDA FIX(N)) COMMA(AND(M, CMPL(M))) VALUES(CMPL(M))>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/lambda/quote.cpp b/test/src/metal/lambda/quote.cpp
index 8738542c..6fe3cea3 100644
--- a/test/src/metal/lambda/quote.cpp
+++ b/test/src/metal/lambda/quote.cpp
@@ -11,20 +11,20 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::quote>, VAL(M)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::quote>, NUM(M)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::quote>, VALUE(M)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::quote>, NUMBER(M)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::quote>, PAIR(M)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::quote>, LIST(M)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::quote>, MAP(M)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::quote>, LBD(M)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::quote>, LBD(_)>), (TRUE)); \
-    CHECK((metal::invoke<metal::quote<VAL(M)> COMMA(N) VALS(N)>), (VAL(M))); \
-    CHECK((metal::invoke<metal::quote<NUM(M)> COMMA(N) VALS(N)>), (NUM(M))); \
-    CHECK((metal::invoke<metal::quote<PAIR(M)> COMMA(N) VALS(N)>), (PAIR(M))); \
-    CHECK((metal::invoke<metal::quote<LIST(M)> COMMA(N) VALS(N)>), (LIST(M))); \
-    CHECK((metal::invoke<metal::quote<MAP(M)> COMMA(N) VALS(N)>), (MAP(M))); \
-    CHECK((metal::invoke<metal::quote<LBD(M)> COMMA(N) VALS(N)>), (LBD(M))); \
-    CHECK((metal::invoke<metal::quote<LBD(_)> COMMA(N) VALS(N)>), (LBD(_))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::quote>, LAMBDA(M)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::quote>, LAMBDA(_)>), (TRUE)); \
+    CHECK((metal::invoke<metal::quote<VALUE(M)> COMMA(N) VALUES(N)>), (VALUE(M))); \
+    CHECK((metal::invoke<metal::quote<NUMBER(M)> COMMA(N) VALUES(N)>), (NUMBER(M))); \
+    CHECK((metal::invoke<metal::quote<PAIR(M)> COMMA(N) VALUES(N)>), (PAIR(M))); \
+    CHECK((metal::invoke<metal::quote<LIST(M)> COMMA(N) VALUES(N)>), (LIST(M))); \
+    CHECK((metal::invoke<metal::quote<MAP(M)> COMMA(N) VALUES(N)>), (MAP(M))); \
+    CHECK((metal::invoke<metal::quote<LAMBDA(M)> COMMA(N) VALUES(N)>), (LAMBDA(M))); \
+    CHECK((metal::invoke<metal::quote<LAMBDA(_)> COMMA(N) VALUES(N)>), (LAMBDA(_))); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/list/all.cpp b/test/src/metal/list/all.cpp
index 447071c0..da0122a3 100644
--- a/test/src/metal/list/all.cpp
+++ b/test/src/metal/list/all.cpp
@@ -12,54 +12,54 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, VAL(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, VAL(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, VAL(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, VAL(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, VAL(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, VAL(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, NUM(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, NUM(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, NUM(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, NUM(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, NUM(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, NUM(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, NUM(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, PAIR(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, PAIR(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, VALUE(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, VALUE(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, VALUE(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, VALUE(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, VALUE(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, VALUE(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, NUMBER(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, NUMBER(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, NUMBER(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, NUMBER(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, NUMBER(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, NUMBER(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, NUMBER(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, PAIR(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, PAIR(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::all>, PAIR(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::all>, PAIR(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::all>, PAIR(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, PAIR(M), LBD(N)>), (BOOL(N == 1))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, PAIR(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, LIST(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, LIST(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, PAIR(M), LAMBDA(N)>), (BOOL(N == 1))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, PAIR(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, LIST(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, LIST(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::all>, LIST(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::all>, LIST(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::all>, LIST(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, LIST(M), LBD(N)>), (BOOL(!M || N == 1))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, LIST(M), LBD(_)>), (BOOL(!M))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, MAP(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, MAP(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, LIST(M), LAMBDA(N)>), (BOOL(!M || N == 1))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, LIST(M), LAMBDA(_)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, MAP(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, MAP(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::all>, MAP(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::all>, MAP(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::all>, MAP(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, MAP(M), LBD(N)>), (BOOL(!M || N == 1))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, MAP(M), LBD(_)>), (BOOL(!M))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, LBD(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, LBD(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, LBD(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, LBD(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, LBD(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, LBD(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, LBD(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, LBD(_), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, LBD(_), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, LBD(_), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, LBD(_), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, LBD(_), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, LBD(_), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::all>, LBD(_), LBD(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, MAP(M), LAMBDA(N)>), (BOOL(!M || N == 1))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, MAP(M), LAMBDA(_)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, LAMBDA(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, LAMBDA(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, LAMBDA(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, LAMBDA(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, LAMBDA(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, LAMBDA(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, LAMBDA(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, LAMBDA(_), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, LAMBDA(_), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, LAMBDA(_), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, LAMBDA(_), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, LAMBDA(_), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, LAMBDA(_), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::all>, LAMBDA(_), LAMBDA(_)>), (FALSE)); \
     CHECK((metal::all<PAIR(M), metal::lambda<metal::is_number>>), (FALSE)); \
     CHECK((metal::all<LIST(M), metal::lambda<metal::is_number>>), (BOOL(!M))); \
     CHECK((metal::all<MAP(M), metal::lambda<metal::is_number>>), (BOOL(!M))); \
diff --git a/test/src/metal/list/any.cpp b/test/src/metal/list/any.cpp
index 38456f89..b224b853 100644
--- a/test/src/metal/list/any.cpp
+++ b/test/src/metal/list/any.cpp
@@ -12,55 +12,55 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, VAL(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, VAL(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, VAL(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, VAL(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, VAL(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, VAL(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, VAL(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, NUM(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, NUM(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, NUM(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, NUM(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, NUM(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, NUM(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, NUM(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, PAIR(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, PAIR(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, VALUE(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, VALUE(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, VALUE(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, VALUE(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, VALUE(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, VALUE(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, VALUE(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, NUMBER(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, NUMBER(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, NUMBER(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, NUMBER(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, NUMBER(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, NUMBER(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, NUMBER(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, PAIR(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, PAIR(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::any>, PAIR(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::any>, PAIR(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::any>, PAIR(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, PAIR(M), LBD(N)>), (BOOL(N == 1))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, PAIR(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, LIST(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, LIST(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, PAIR(M), LAMBDA(N)>), (BOOL(N == 1))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, PAIR(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, LIST(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, LIST(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::any>, LIST(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::any>, LIST(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::any>, LIST(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, LIST(M), LBD(N)>), (BOOL(!M || N == 1))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, LIST(M), LBD(_)>), (BOOL(!M))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, MAP(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, MAP(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, LIST(M), LAMBDA(N)>), (BOOL(!M || N == 1))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, LIST(M), LAMBDA(_)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, MAP(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, MAP(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::any>, MAP(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::any>, MAP(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::any>, MAP(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, MAP(M), LBD(N)>), (BOOL(!M || N == 1))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, MAP(M), LBD(_)>), (BOOL(!M))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, LBD(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, LBD(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, LBD(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, LBD(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, LBD(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, LBD(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, LBD(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, LBD(_), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, LBD(_), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, LBD(_), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, LBD(_), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, LBD(_), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, LBD(_), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::any>, LBD(_), LBD(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, MAP(M), LAMBDA(N)>), (BOOL(!M || N == 1))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, MAP(M), LAMBDA(_)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, LAMBDA(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, LAMBDA(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, LAMBDA(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, LAMBDA(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, LAMBDA(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, LAMBDA(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, LAMBDA(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, LAMBDA(_), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, LAMBDA(_), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, LAMBDA(_), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, LAMBDA(_), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, LAMBDA(_), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, LAMBDA(_), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::any>, LAMBDA(_), LAMBDA(_)>), (FALSE)); \
     CHECK((metal::any<PAIR(M), metal::lambda<metal::is_number>>), (TRUE)); \
     CHECK((metal::any<LIST(M), metal::lambda<metal::is_number>>), (FALSE)); \
     CHECK((metal::any<MAP(M), metal::lambda<metal::is_number>>), (FALSE)); \
diff --git a/test/src/metal/list/append.cpp b/test/src/metal/list/append.cpp
index 4b179ad2..39009ef5 100644
--- a/test/src/metal/list/append.cpp
+++ b/test/src/metal/list/append.cpp
@@ -11,51 +11,51 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::append>, VAL(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::append>, VAL(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::append>, VAL(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::append>, VAL(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::append>, VAL(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::append>, VAL(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::append>, NUM(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::append>, NUM(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::append>, NUM(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::append>, NUM(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::append>, NUM(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::append>, NUM(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::append>, PAIR(M) COMMA(N) VALS(N)>), (BOOL(N > 0))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::append>, PAIR(M) COMMA(N) NUMS(N)>), (BOOL(N > 0))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::append>, VALUE(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::append>, VALUE(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::append>, VALUE(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::append>, VALUE(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::append>, VALUE(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::append>, VALUE(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::append>, NUMBER(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::append>, NUMBER(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::append>, NUMBER(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::append>, NUMBER(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::append>, NUMBER(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::append>, NUMBER(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::append>, PAIR(M) COMMA(N) VALUES(N)>), (BOOL(N > 0))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::append>, PAIR(M) COMMA(N) NUMBERS(N)>), (BOOL(N > 0))); \
     CHECK((metal::is_invocable<metal::lambda<metal::append>, PAIR(M) COMMA(N) PAIRS(N)>), (BOOL(N > 0))); \
     CHECK((metal::is_invocable<metal::lambda<metal::append>, PAIR(M) COMMA(N) LISTS(N)>), (BOOL(N > 0))); \
     CHECK((metal::is_invocable<metal::lambda<metal::append>, PAIR(M) COMMA(N) MAPS(N)>), (BOOL(N > 0))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::append>, PAIR(M) COMMA(N) LBDS(N)>), (BOOL(N > 0))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::append>, LIST(M) COMMA(N) VALS(N)>), (BOOL(N > 0))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::append>, LIST(M) COMMA(N) NUMS(N)>), (BOOL(N > 0))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::append>, PAIR(M) COMMA(N) LAMBDAS(N)>), (BOOL(N > 0))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::append>, LIST(M) COMMA(N) VALUES(N)>), (BOOL(N > 0))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::append>, LIST(M) COMMA(N) NUMBERS(N)>), (BOOL(N > 0))); \
     CHECK((metal::is_invocable<metal::lambda<metal::append>, LIST(M) COMMA(N) PAIRS(N)>), (BOOL(N > 0))); \
     CHECK((metal::is_invocable<metal::lambda<metal::append>, LIST(M) COMMA(N) LISTS(N)>), (BOOL(N > 0))); \
     CHECK((metal::is_invocable<metal::lambda<metal::append>, LIST(M) COMMA(N) MAPS(N)>), (BOOL(N > 0))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::append>, LIST(M) COMMA(N) LBDS(N)>), (BOOL(N > 0))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::append>, MAP(M) COMMA(N) VALS(N)>), (BOOL(N > 0))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::append>, MAP(M) COMMA(N) NUMS(N)>), (BOOL(N > 0))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::append>, LIST(M) COMMA(N) LAMBDAS(N)>), (BOOL(N > 0))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::append>, MAP(M) COMMA(N) VALUES(N)>), (BOOL(N > 0))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::append>, MAP(M) COMMA(N) NUMBERS(N)>), (BOOL(N > 0))); \
     CHECK((metal::is_invocable<metal::lambda<metal::append>, MAP(M) COMMA(N) PAIRS(N)>), (BOOL(N > 0))); \
     CHECK((metal::is_invocable<metal::lambda<metal::append>, MAP(M) COMMA(N) LISTS(N)>), (BOOL(N > 0))); \
     CHECK((metal::is_invocable<metal::lambda<metal::append>, MAP(M) COMMA(N) MAPS(N)>), (BOOL(N > 0))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::append>, MAP(M) COMMA(N) LBDS(N)>), (BOOL(N > 0))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::append>, LBD(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::append>, LBD(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::append>, LBD(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::append>, LBD(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::append>, LBD(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::append>, LBD(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::append>, LBD(_) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::append>, LBD(_) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::append>, LBD(_) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::append>, LBD(_) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::append>, LBD(_) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::append>, LBD(_) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::append<PAIR(M), VALS(INC(N))>), (metal::list<NUM(M), VAL(M), VALS(INC(N))>)); \
-    CHECK((metal::append<LIST(M), VALS(INC(N))>), (metal::list<VALS(M) COMMA(M) VALS(INC(N))>)); \
-    CHECK((metal::append<MAP(M), VALS(INC(N))>), (metal::list<PAIRS(M) COMMA(M) VALS(INC(N))>)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::append>, MAP(M) COMMA(N) LAMBDAS(N)>), (BOOL(N > 0))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::append>, LAMBDA(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::append>, LAMBDA(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::append>, LAMBDA(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::append>, LAMBDA(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::append>, LAMBDA(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::append>, LAMBDA(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::append>, LAMBDA(_) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::append>, LAMBDA(_) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::append>, LAMBDA(_) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::append>, LAMBDA(_) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::append>, LAMBDA(_) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::append>, LAMBDA(_) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::append<PAIR(M), VALUES(INC(N))>), (metal::list<NUMBER(M), VALUE(M), VALUES(INC(N))>)); \
+    CHECK((metal::append<LIST(M), VALUES(INC(N))>), (metal::list<VALUES(M) COMMA(M) VALUES(INC(N))>)); \
+    CHECK((metal::append<MAP(M), VALUES(INC(N))>), (metal::list<PAIRS(M) COMMA(M) VALUES(INC(N))>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/list/at.cpp b/test/src/metal/list/at.cpp
index 9545c9fe..849045d4 100644
--- a/test/src/metal/list/at.cpp
+++ b/test/src/metal/list/at.cpp
@@ -11,59 +11,59 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, VAL(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, VAL(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, VAL(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, VAL(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, VAL(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, VAL(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, VAL(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, NUM(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, NUM(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, NUM(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, NUM(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, NUM(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, NUM(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, NUM(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, PAIR(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, PAIR(M), NUM(N)>), (BOOL(N < 2))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, VALUE(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, VALUE(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, VALUE(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, VALUE(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, VALUE(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, VALUE(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, VALUE(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, NUMBER(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, NUMBER(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, NUMBER(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, NUMBER(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, NUMBER(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, NUMBER(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, NUMBER(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, PAIR(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, PAIR(M), NUMBER(N)>), (BOOL(N < 2))); \
     CHECK((metal::is_invocable<metal::lambda<metal::at>, PAIR(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::at>, PAIR(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::at>, PAIR(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, PAIR(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, PAIR(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, LIST(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, LIST(M), NUM(N)>), (BOOL(M > N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, PAIR(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, PAIR(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, LIST(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, LIST(M), NUMBER(N)>), (BOOL(M > N))); \
     CHECK((metal::is_invocable<metal::lambda<metal::at>, LIST(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::at>, LIST(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::at>, LIST(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, LIST(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, LIST(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, MAP(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, MAP(M), NUM(N)>), (BOOL(M > N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, LIST(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, LIST(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, MAP(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, MAP(M), NUMBER(N)>), (BOOL(M > N))); \
     CHECK((metal::is_invocable<metal::lambda<metal::at>, MAP(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::at>, MAP(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::at>, MAP(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, MAP(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, MAP(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, LBD(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, LBD(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, LBD(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, LBD(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, LBD(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, LBD(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, LBD(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, LBD(_), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, LBD(_), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, LBD(_), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, LBD(_), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, LBD(_), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, LBD(_), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at>, LBD(_), LBD(_)>), (FALSE)); \
-    CHECK((metal::at<PAIR(M), NUM(0)>), (NUM(M))); \
-    CHECK((metal::at<PAIR(M), NUM(1)>), (VAL(M))); \
-    CHECK((metal::at<LIST(INF), NUM(M)>), (VAL(M))); \
-    CHECK((metal::at<MAP(INF), NUM(M)>), (PAIR(M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, MAP(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, MAP(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, LAMBDA(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, LAMBDA(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, LAMBDA(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, LAMBDA(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, LAMBDA(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, LAMBDA(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, LAMBDA(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, LAMBDA(_), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, LAMBDA(_), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, LAMBDA(_), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, LAMBDA(_), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, LAMBDA(_), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, LAMBDA(_), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at>, LAMBDA(_), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::at<PAIR(M), NUMBER(0)>), (NUMBER(M))); \
+    CHECK((metal::at<PAIR(M), NUMBER(1)>), (VALUE(M))); \
+    CHECK((metal::at<LIST(INF), NUMBER(M)>), (VALUE(M))); \
+    CHECK((metal::at<MAP(INF), NUMBER(M)>), (PAIR(M))); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/list/back.cpp b/test/src/metal/list/back.cpp
index 2c53cfe9..77541e90 100644
--- a/test/src/metal/list/back.cpp
+++ b/test/src/metal/list/back.cpp
@@ -11,15 +11,15 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::back>, VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::back>, NUM(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::back>, VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::back>, NUMBER(M)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::back>, PAIR(M)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::back>, LIST(M)>), (BOOL(M > 0))); \
     CHECK((metal::is_invocable<metal::lambda<metal::back>, MAP(M)>), (BOOL(M > 0))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::back>, LBD(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::back>, LBD(_)>), (FALSE)); \
-    CHECK((metal::back<PAIR(M)>), (VAL(M))); \
-    CHECK((metal::back<LIST(INC(M))>), (VAL(M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::back>, LAMBDA(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::back>, LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::back<PAIR(M)>), (VALUE(M))); \
+    CHECK((metal::back<LIST(INC(M))>), (VALUE(M))); \
     CHECK((metal::back<MAP(INC(M))>), (PAIR(M))); \
 /**/
 
diff --git a/test/src/metal/list/contains.cpp b/test/src/metal/list/contains.cpp
index 00db2124..26be8cf4 100644
--- a/test/src/metal/list/contains.cpp
+++ b/test/src/metal/list/contains.cpp
@@ -11,60 +11,60 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, VAL(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, VAL(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, VAL(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, VAL(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, VAL(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, VAL(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, VAL(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, NUM(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, NUM(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, NUM(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, NUM(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, NUM(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, NUM(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, NUM(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, PAIR(M), VAL(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, PAIR(M), NUM(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, VALUE(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, VALUE(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, VALUE(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, VALUE(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, VALUE(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, VALUE(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, VALUE(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, NUMBER(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, NUMBER(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, NUMBER(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, NUMBER(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, NUMBER(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, NUMBER(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, NUMBER(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, PAIR(M), VALUE(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, PAIR(M), NUMBER(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::contains>, PAIR(M), PAIR(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::contains>, PAIR(M), LIST(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::contains>, PAIR(M), MAP(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, PAIR(M), LBD(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, PAIR(M), LBD(_)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, LIST(M), VAL(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, LIST(M), NUM(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, PAIR(M), LAMBDA(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, PAIR(M), LAMBDA(_)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, LIST(M), VALUE(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, LIST(M), NUMBER(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::contains>, LIST(M), PAIR(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::contains>, LIST(M), LIST(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::contains>, LIST(M), MAP(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, LIST(M), LBD(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, LIST(M), LBD(_)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, MAP(M), VAL(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, MAP(M), NUM(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, LIST(M), LAMBDA(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, LIST(M), LAMBDA(_)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, MAP(M), VALUE(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, MAP(M), NUMBER(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::contains>, MAP(M), PAIR(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::contains>, MAP(M), LIST(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::contains>, MAP(M), MAP(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, MAP(M), LBD(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, MAP(M), LBD(_)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, LBD(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, LBD(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, LBD(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, LBD(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, LBD(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, LBD(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, LBD(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, LBD(_), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, LBD(_), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, LBD(_), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, LBD(_), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, LBD(_), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::contains>, LBD(_), LBD(_)>), (FALSE)); \
-    CHECK((metal::contains<PAIR(M), VAL(N)>), (BOOL(M == N))); \
-    CHECK((metal::contains<PAIR(M), NUM(N)>), (BOOL(M == N))); \
-    CHECK((metal::contains<LIST(M), VAL(N)>), (BOOL(M > N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, MAP(M), LAMBDA(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, MAP(M), LAMBDA(_)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, LAMBDA(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, LAMBDA(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, LAMBDA(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, LAMBDA(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, LAMBDA(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, LAMBDA(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, LAMBDA(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, LAMBDA(_), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, LAMBDA(_), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, LAMBDA(_), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, LAMBDA(_), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, LAMBDA(_), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::contains>, LAMBDA(_), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::contains<PAIR(M), VALUE(N)>), (BOOL(M == N))); \
+    CHECK((metal::contains<PAIR(M), NUMBER(N)>), (BOOL(M == N))); \
+    CHECK((metal::contains<LIST(M), VALUE(N)>), (BOOL(M > N))); \
     CHECK((metal::contains<MAP(M), PAIR(N)>), (BOOL(M > N))); \
-    CHECK((metal::contains<metal::list<VALS(M) COMMA(M) VAL(N)>, VAL(N)>), (TRUE)); \
-    CHECK((metal::contains<metal::list<ENUM(M, VAL FIX(N))>, VAL(N)>), (BOOL(M > 0))); \
+    CHECK((metal::contains<metal::list<VALUES(M) COMMA(M) VALUE(N)>, VALUE(N)>), (TRUE)); \
+    CHECK((metal::contains<metal::list<ENUM(M, VALUE FIX(N))>, VALUE(N)>), (BOOL(M > 0))); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/list/copy.cpp b/test/src/metal/list/copy.cpp
index c6ef6e79..b76bb85f 100644
--- a/test/src/metal/list/copy.cpp
+++ b/test/src/metal/list/copy.cpp
@@ -10,58 +10,58 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, VAL(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, VAL(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, VAL(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, VAL(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, VAL(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, VAL(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, VAL(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, NUM(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, NUM(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, NUM(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, NUM(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, NUM(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, NUM(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, NUM(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, PAIR(M), VAL(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, PAIR(M), NUM(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, VALUE(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, VALUE(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, VALUE(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, VALUE(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, VALUE(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, VALUE(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, VALUE(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, NUMBER(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, NUMBER(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, NUMBER(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, NUMBER(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, NUMBER(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, NUMBER(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, NUMBER(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, PAIR(M), VALUE(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, PAIR(M), NUMBER(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::copy>, PAIR(M), PAIR(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::copy>, PAIR(M), LIST(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::copy>, PAIR(M), MAP(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, PAIR(M), LBD(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, PAIR(M), LBD(_)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, LIST(M), VAL(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, LIST(M), NUM(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, PAIR(M), LAMBDA(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, PAIR(M), LAMBDA(_)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, LIST(M), VALUE(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, LIST(M), NUMBER(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::copy>, LIST(M), PAIR(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::copy>, LIST(M), LIST(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::copy>, LIST(M), MAP(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, LIST(M), LBD(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, LIST(M), LBD(_)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, MAP(M), VAL(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, MAP(M), NUM(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, LIST(M), LAMBDA(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, LIST(M), LAMBDA(_)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, MAP(M), VALUE(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, MAP(M), NUMBER(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::copy>, MAP(M), PAIR(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::copy>, MAP(M), LIST(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::copy>, MAP(M), MAP(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, MAP(M), LBD(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, MAP(M), LBD(_)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, LBD(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, LBD(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, LBD(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, LBD(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, LBD(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, LBD(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, LBD(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, LBD(_), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, LBD(_), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, LBD(_), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, LBD(_), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, LBD(_), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, LBD(_), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy>, LBD(_), LBD(_)>), (FALSE)); \
-    CHECK((metal::copy<PAIR(M), VAL(N)>), (std::conditional_t<M == N, metal::list<VAL(M)>, metal::list<>>)); \
-    CHECK((metal::copy<PAIR(M), NUM(N)>), (std::conditional_t<M == N, metal::list<NUM(M)>, metal::list<>>)); \
-    CHECK((metal::copy<metal::list<VALS(M) COMMA(AND(M, N)) ENUM(N, VAL FIX(M))>, VAL(M)>), (metal::list<ENUM(N, VAL FIX(M))>)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, MAP(M), LAMBDA(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, MAP(M), LAMBDA(_)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, LAMBDA(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, LAMBDA(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, LAMBDA(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, LAMBDA(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, LAMBDA(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, LAMBDA(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, LAMBDA(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, LAMBDA(_), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, LAMBDA(_), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, LAMBDA(_), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, LAMBDA(_), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, LAMBDA(_), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, LAMBDA(_), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy>, LAMBDA(_), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::copy<PAIR(M), VALUE(N)>), (std::conditional_t<M == N, metal::list<VALUE(M)>, metal::list<>>)); \
+    CHECK((metal::copy<PAIR(M), NUMBER(N)>), (std::conditional_t<M == N, metal::list<NUMBER(M)>, metal::list<>>)); \
+    CHECK((metal::copy<metal::list<VALUES(M) COMMA(AND(M, N)) ENUM(N, VALUE FIX(M))>, VALUE(M)>), (metal::list<ENUM(N, VALUE FIX(M))>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/list/copy_if.cpp b/test/src/metal/list/copy_if.cpp
index 4dd0b28f..838a8473 100644
--- a/test/src/metal/list/copy_if.cpp
+++ b/test/src/metal/list/copy_if.cpp
@@ -12,62 +12,62 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, VAL(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, VAL(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, VAL(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, VAL(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, VAL(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, VAL(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, VAL(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, NUM(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, NUM(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, NUM(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, NUM(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, NUM(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, NUM(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, NUM(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, PAIR(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, PAIR(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, VALUE(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, VALUE(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, VALUE(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, VALUE(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, VALUE(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, VALUE(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, VALUE(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, NUMBER(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, NUMBER(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, NUMBER(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, NUMBER(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, NUMBER(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, NUMBER(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, NUMBER(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, PAIR(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, PAIR(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, PAIR(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, PAIR(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, PAIR(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, PAIR(M), LBD(N)>), (BOOL(N == 1))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, PAIR(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LIST(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LIST(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, PAIR(M), LAMBDA(N)>), (BOOL(N == 1))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, PAIR(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LIST(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LIST(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LIST(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LIST(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LIST(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LIST(M), LBD(N)>), (BOOL(!M || N == 1))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LIST(M), LBD(_)>), (BOOL(!M))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, MAP(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, MAP(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LIST(M), LAMBDA(N)>), (BOOL(!M || N == 1))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LIST(M), LAMBDA(_)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, MAP(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, MAP(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, MAP(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, MAP(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, MAP(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, MAP(M), LBD(N)>), (BOOL(!M || N == 1))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, MAP(M), LBD(_)>), (BOOL(!M))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LBD(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LBD(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LBD(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LBD(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LBD(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LBD(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LBD(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LBD(_), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LBD(_), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LBD(_), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LBD(_), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LBD(_), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LBD(_), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LBD(_), LBD(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, MAP(M), LAMBDA(N)>), (BOOL(!M || N == 1))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, MAP(M), LAMBDA(_)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LAMBDA(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LAMBDA(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LAMBDA(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LAMBDA(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LAMBDA(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LAMBDA(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LAMBDA(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LAMBDA(_), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LAMBDA(_), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LAMBDA(_), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LAMBDA(_), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LAMBDA(_), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LAMBDA(_), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::copy_if>, LAMBDA(_), LAMBDA(_)>), (FALSE)); \
     CHECK((metal::copy_if<LIST(M), metal::lambda<metal::is_number>>), (LIST(0))); \
     CHECK((metal::copy_if<LIST(M), metal::lambda<metal::is_pair>>), (LIST(0))); \
     CHECK((metal::copy_if<MAP(M), metal::lambda<metal::is_pair>>), (MAP(M))); \
     CHECK((metal::copy_if<LIST(M), metal::lambda<metal::is_lambda>>), (LIST(0))); \
-    CHECK((metal::copy_if<metal::list<ENUM(M, FWD, NUM, PAIR, LBD)>, metal::lambda<metal::is_number>>), (metal::list<NUMS(M)>)); \
-    CHECK((metal::copy_if<metal::list<ENUM(M, FWD, NUM, PAIR, LBD)>, metal::lambda<metal::is_pair>>), (metal::list<PAIRS(M)>)); \
-    CHECK((metal::copy_if<metal::list<ENUM(M, FWD, NUM, PAIR, LBD)>, metal::lambda<metal::is_lambda>>), (metal::list<LBDS(M)>)); \
+    CHECK((metal::copy_if<metal::list<ENUM(M, FWD, NUMBER, PAIR, LAMBDA)>, metal::lambda<metal::is_number>>), (metal::list<NUMBERS(M)>)); \
+    CHECK((metal::copy_if<metal::list<ENUM(M, FWD, NUMBER, PAIR, LAMBDA)>, metal::lambda<metal::is_pair>>), (metal::list<PAIRS(M)>)); \
+    CHECK((metal::copy_if<metal::list<ENUM(M, FWD, NUMBER, PAIR, LAMBDA)>, metal::lambda<metal::is_lambda>>), (metal::list<LAMBDAS(M)>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/list/count.cpp b/test/src/metal/list/count.cpp
index b860e505..833eeff9 100644
--- a/test/src/metal/list/count.cpp
+++ b/test/src/metal/list/count.cpp
@@ -11,61 +11,61 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, VAL(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, VAL(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, VAL(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, VAL(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, VAL(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, VAL(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, VAL(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, NUM(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, NUM(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, NUM(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, NUM(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, NUM(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, NUM(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, NUM(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, PAIR(M), VAL(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, PAIR(M), NUM(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, VALUE(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, VALUE(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, VALUE(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, VALUE(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, VALUE(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, VALUE(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, VALUE(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, NUMBER(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, NUMBER(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, NUMBER(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, NUMBER(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, NUMBER(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, NUMBER(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, NUMBER(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, PAIR(M), VALUE(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, PAIR(M), NUMBER(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::count>, PAIR(M), PAIR(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::count>, PAIR(M), LIST(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::count>, PAIR(M), MAP(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, PAIR(M), LBD(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, PAIR(M), LBD(_)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, LIST(M), VAL(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, LIST(M), NUM(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, PAIR(M), LAMBDA(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, PAIR(M), LAMBDA(_)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, LIST(M), VALUE(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, LIST(M), NUMBER(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::count>, LIST(M), PAIR(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::count>, LIST(M), LIST(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::count>, LIST(M), MAP(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, LIST(M), LBD(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, LIST(M), LBD(_)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, MAP(M), VAL(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, MAP(M), NUM(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, LIST(M), LAMBDA(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, LIST(M), LAMBDA(_)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, MAP(M), VALUE(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, MAP(M), NUMBER(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::count>, MAP(M), PAIR(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::count>, MAP(M), LIST(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::count>, MAP(M), MAP(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, MAP(M), LBD(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, MAP(M), LBD(_)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, LBD(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, LBD(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, LBD(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, LBD(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, LBD(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, LBD(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, LBD(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, LBD(_), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, LBD(_), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, LBD(_), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, LBD(_), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, LBD(_), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, LBD(_), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count>, LBD(_), LBD(_)>), (FALSE)); \
-    CHECK((metal::count<PAIR(M), VAL(N)>), (metal::number<M == N>)); \
-    CHECK((metal::count<PAIR(M), NUM(N)>), (metal::number<M == N>)); \
-    CHECK((metal::count<LIST(M), VAL(N)>), (metal::number<(M > N)>)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, MAP(M), LAMBDA(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, MAP(M), LAMBDA(_)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, LAMBDA(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, LAMBDA(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, LAMBDA(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, LAMBDA(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, LAMBDA(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, LAMBDA(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, LAMBDA(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, LAMBDA(_), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, LAMBDA(_), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, LAMBDA(_), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, LAMBDA(_), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, LAMBDA(_), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, LAMBDA(_), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count>, LAMBDA(_), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::count<PAIR(M), VALUE(N)>), (metal::number<M == N>)); \
+    CHECK((metal::count<PAIR(M), NUMBER(N)>), (metal::number<M == N>)); \
+    CHECK((metal::count<LIST(M), VALUE(N)>), (metal::number<(M > N)>)); \
     CHECK((metal::count<MAP(M), PAIR(N)>), (metal::number<(M > N)>)); \
-    CHECK((metal::count<metal::list<VALS(M) COMMA(M) VAL(N)>, VAL(N)>), (metal::number<1 + (M > N)>)); \
-    CHECK((metal::count<metal::list<ENUM(M, VAL FIX(N))>, VAL(N)>), (metal::number<M>)); \
+    CHECK((metal::count<metal::list<VALUES(M) COMMA(M) VALUE(N)>, VALUE(N)>), (metal::number<1 + (M > N)>)); \
+    CHECK((metal::count<metal::list<ENUM(M, VALUE FIX(N))>, VALUE(N)>), (metal::number<M>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/list/count_if.cpp b/test/src/metal/list/count_if.cpp
index b669dd39..919cd91d 100644
--- a/test/src/metal/list/count_if.cpp
+++ b/test/src/metal/list/count_if.cpp
@@ -12,55 +12,55 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, VAL(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, VAL(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, VAL(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, VAL(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, VAL(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, VAL(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, VAL(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, NUM(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, NUM(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, NUM(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, NUM(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, NUM(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, NUM(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, NUM(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, PAIR(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, PAIR(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, VALUE(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, VALUE(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, VALUE(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, VALUE(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, VALUE(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, VALUE(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, VALUE(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, NUMBER(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, NUMBER(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, NUMBER(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, NUMBER(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, NUMBER(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, NUMBER(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, NUMBER(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, PAIR(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, PAIR(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::count_if>, PAIR(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::count_if>, PAIR(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::count_if>, PAIR(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, PAIR(M), LBD(N)>), (BOOL(N == 1))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, PAIR(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LIST(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LIST(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, PAIR(M), LAMBDA(N)>), (BOOL(N == 1))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, PAIR(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LIST(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LIST(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LIST(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LIST(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LIST(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LIST(M), LBD(N)>), (BOOL(!M || N == 1))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LIST(M), LBD(_)>), (BOOL(!M))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, MAP(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, MAP(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LIST(M), LAMBDA(N)>), (BOOL(!M || N == 1))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LIST(M), LAMBDA(_)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, MAP(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, MAP(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::count_if>, MAP(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::count_if>, MAP(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::count_if>, MAP(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, MAP(M), LBD(N)>), (BOOL(!M || N == 1))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, MAP(M), LBD(_)>), (BOOL(!M))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LBD(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LBD(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LBD(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LBD(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LBD(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LBD(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LBD(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LBD(_), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LBD(_), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LBD(_), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LBD(_), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LBD(_), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LBD(_), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LBD(_), LBD(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, MAP(M), LAMBDA(N)>), (BOOL(!M || N == 1))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, MAP(M), LAMBDA(_)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LAMBDA(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LAMBDA(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LAMBDA(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LAMBDA(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LAMBDA(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LAMBDA(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LAMBDA(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LAMBDA(_), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LAMBDA(_), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LAMBDA(_), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LAMBDA(_), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LAMBDA(_), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LAMBDA(_), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::count_if>, LAMBDA(_), LAMBDA(_)>), (FALSE)); \
     CHECK((metal::count_if<PAIR(M), metal::lambda<metal::is_number>>), (metal::number<1>)); \
     CHECK((metal::count_if<LIST(M), metal::lambda<metal::is_number>>), (metal::number<0>)); \
     CHECK((metal::count_if<MAP(M), metal::lambda<metal::is_number>>), (metal::number<0>)); \
@@ -70,9 +70,9 @@
     CHECK((metal::count_if<PAIR(M), metal::lambda<metal::is_lambda>>), (metal::number<0>)); \
     CHECK((metal::count_if<LIST(M), metal::lambda<metal::is_lambda>>), (metal::number<0>)); \
     CHECK((metal::count_if<MAP(M), metal::lambda<metal::is_lambda>>), (metal::number<0>)); \
-    CHECK((metal::count_if<metal::list<ENUM(M, FWD, NUM, PAIR, LBD)>, metal::lambda<metal::is_number>>), (metal::number<M>)); \
-    CHECK((metal::count_if<metal::list<ENUM(M, FWD, NUM, PAIR, LBD)>, metal::lambda<metal::is_pair>>), (metal::number<M>)); \
-    CHECK((metal::count_if<metal::list<ENUM(M, FWD, NUM, PAIR, LBD)>, metal::lambda<metal::is_lambda>>), (metal::number<M>)); \
+    CHECK((metal::count_if<metal::list<ENUM(M, FWD, NUMBER, PAIR, LAMBDA)>, metal::lambda<metal::is_number>>), (metal::number<M>)); \
+    CHECK((metal::count_if<metal::list<ENUM(M, FWD, NUMBER, PAIR, LAMBDA)>, metal::lambda<metal::is_pair>>), (metal::number<M>)); \
+    CHECK((metal::count_if<metal::list<ENUM(M, FWD, NUMBER, PAIR, LAMBDA)>, metal::lambda<metal::is_lambda>>), (metal::number<M>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/list/drop.cpp b/test/src/metal/list/drop.cpp
index 4f12d21e..525e7c8c 100644
--- a/test/src/metal/list/drop.cpp
+++ b/test/src/metal/list/drop.cpp
@@ -11,49 +11,49 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::drop>, VAL(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::drop>, VAL(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::drop>, VAL(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::drop>, VAL(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::drop>, VAL(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::drop>, VAL(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::drop>, VAL(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::drop>, NUM(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::drop>, NUM(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::drop>, NUM(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::drop>, NUM(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::drop>, NUM(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::drop>, NUM(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::drop>, NUM(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::drop>, PAIR(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::drop>, PAIR(M), NUM(N)>), (BOOL(N < 3))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::drop>, VALUE(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::drop>, VALUE(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::drop>, VALUE(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::drop>, VALUE(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::drop>, VALUE(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::drop>, VALUE(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::drop>, VALUE(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::drop>, NUMBER(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::drop>, NUMBER(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::drop>, NUMBER(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::drop>, NUMBER(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::drop>, NUMBER(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::drop>, NUMBER(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::drop>, NUMBER(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::drop>, PAIR(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::drop>, PAIR(M), NUMBER(N)>), (BOOL(N < 3))); \
     CHECK((metal::is_invocable<metal::lambda<metal::drop>, PAIR(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::drop>, PAIR(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::drop>, PAIR(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::drop>, PAIR(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::drop>, PAIR(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::drop>, LIST(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::drop>, LIST(M), NUM(N)>), (BOOL(M >= N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::drop>, PAIR(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::drop>, PAIR(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::drop>, LIST(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::drop>, LIST(M), NUMBER(N)>), (BOOL(M >= N))); \
     CHECK((metal::is_invocable<metal::lambda<metal::drop>, LIST(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::drop>, LIST(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::drop>, LIST(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::drop>, LIST(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::drop>, LIST(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::drop>, MAP(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::drop>, MAP(M), NUM(N)>), (BOOL(M >= N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::drop>, LIST(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::drop>, LIST(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::drop>, MAP(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::drop>, MAP(M), NUMBER(N)>), (BOOL(M >= N))); \
     CHECK((metal::is_invocable<metal::lambda<metal::drop>, MAP(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::drop>, MAP(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::drop>, MAP(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::drop>, MAP(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::drop>, MAP(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::drop>, LBD(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::drop>, LBD(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::drop>, LBD(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::drop>, LBD(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::drop>, LBD(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::drop>, LBD(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::drop>, LBD(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::drop<metal::list<VALS(M) COMMA(AND(M, N)) VALS(N)>, NUM(M)>), (LIST(N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::drop>, MAP(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::drop>, MAP(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::drop>, LAMBDA(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::drop>, LAMBDA(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::drop>, LAMBDA(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::drop>, LAMBDA(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::drop>, LAMBDA(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::drop>, LAMBDA(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::drop>, LAMBDA(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::drop<metal::list<VALUES(M) COMMA(AND(M, N)) VALUES(N)>, NUMBER(M)>), (LIST(N))); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/list/empty.cpp b/test/src/metal/list/empty.cpp
index e202aaf1..b83a7f73 100644
--- a/test/src/metal/list/empty.cpp
+++ b/test/src/metal/list/empty.cpp
@@ -11,18 +11,18 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::empty>, VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::empty>, NUM(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::empty>, VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::empty>, NUMBER(M)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::empty>, PAIR(M)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::empty>, LIST(M)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::empty>, MAP(M)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::empty>, LBD(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::empty>, LBD(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::empty>, LAMBDA(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::empty>, LAMBDA(_)>), (FALSE)); \
     CHECK((metal::empty<PAIR(M)>), (FALSE)); \
     CHECK((metal::empty<LIST(M)>), (BOOL(!M))); \
     CHECK((metal::empty<MAP(M)>), (BOOL(!M))); \
-    CHECK((metal::empty<metal::list<VALS(M) COMMA(AND(M, N)) VALS(N)>>), (BOOL(!M && !N))); \
-    CHECK((metal::empty<metal::list<ENUM(M, VAL FIX(N))>>), (BOOL(!M))); \
+    CHECK((metal::empty<metal::list<VALUES(M) COMMA(AND(M, N)) VALUES(N)>>), (BOOL(!M && !N))); \
+    CHECK((metal::empty<metal::list<ENUM(M, VALUE FIX(N))>>), (BOOL(!M))); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/list/erase.cpp b/test/src/metal/list/erase.cpp
index 78e16d17..50873621 100644
--- a/test/src/metal/list/erase.cpp
+++ b/test/src/metal/list/erase.cpp
@@ -11,52 +11,52 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase>, VAL(M), VAL(0), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase>, VAL(M), NUM(0), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase>, VAL(M), PAIR(0), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase>, VAL(M), LIST(0), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase>, VAL(M), MAP(0), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase>, VAL(M), LBD(0), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase>, NUM(M), VAL(0), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase>, NUM(M), NUM(0), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase>, NUM(M), PAIR(0), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase>, NUM(M), LIST(0), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase>, NUM(M), MAP(0), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase>, NUM(M), LBD(0), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase>, PAIR(M), VAL(0), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase>, PAIR(M), NUM(0), NUM(N)>), (BOOL(N < 3))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase>, VALUE(M), VALUE(0), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase>, VALUE(M), NUMBER(0), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase>, VALUE(M), PAIR(0), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase>, VALUE(M), LIST(0), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase>, VALUE(M), MAP(0), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase>, VALUE(M), LAMBDA(0), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase>, NUMBER(M), VALUE(0), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase>, NUMBER(M), NUMBER(0), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase>, NUMBER(M), PAIR(0), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase>, NUMBER(M), LIST(0), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase>, NUMBER(M), MAP(0), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase>, NUMBER(M), LAMBDA(0), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase>, PAIR(M), VALUE(0), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase>, PAIR(M), NUMBER(0), NUMBER(N)>), (BOOL(N < 3))); \
     CHECK((metal::is_invocable<metal::lambda<metal::erase>, PAIR(M), PAIR(0), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::erase>, PAIR(M), LIST(0), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::erase>, PAIR(M), MAP(0), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase>, PAIR(M), LBD(0), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase>, LIST(M), VAL(0), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase>, LIST(M), NUM(0), NUM(N)>), (BOOL(M >= N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase>, PAIR(M), LAMBDA(0), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase>, LIST(M), VALUE(0), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase>, LIST(M), NUMBER(0), NUMBER(N)>), (BOOL(M >= N))); \
     CHECK((metal::is_invocable<metal::lambda<metal::erase>, LIST(M), PAIR(0), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::erase>, LIST(M), LIST(0), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::erase>, LIST(M), MAP(0), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase>, LIST(M), LBD(0), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase>, MAP(M), VAL(0), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase>, MAP(M), NUM(0), NUM(N)>), (BOOL(M >= N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase>, LIST(M), LAMBDA(0), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase>, MAP(M), VALUE(0), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase>, MAP(M), NUMBER(0), NUMBER(N)>), (BOOL(M >= N))); \
     CHECK((metal::is_invocable<metal::lambda<metal::erase>, MAP(M), PAIR(0), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::erase>, MAP(M), LIST(0), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::erase>, MAP(M), MAP(0), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase>, MAP(M), LBD(0), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase>, LBD(M), VAL(0), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase>, LBD(M), NUM(0), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase>, LBD(M), PAIR(0), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase>, LBD(M), LIST(0), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase>, LBD(M), MAP(0), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase>, LBD(M), LBD(0), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase>, LBD(_), VAL(0), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase>, LBD(_), NUM(0), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase>, LBD(_), PAIR(0), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase>, LBD(_), LIST(0), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase>, LBD(_), MAP(0), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase>, LBD(_), LBD(0), LBD(N)>), (FALSE)); \
-    CHECK((metal::erase<LIST(INF), NUM(M)>), (metal::erase<LIST(INF), NUM(M), NUM(INC(M))>)); \
-    CHECK((metal::erase<LIST(INF), NUM(M), NUM(N)>), (metal::erase<LIST(INF), NUM(N), NUM(M)>)); \
-    CHECK((metal::erase<LIST(M), NUM(0), NUM(M)>), (LIST(0))); \
-    CHECK((metal::erase<LIST(INF), NUM(INF), NUM(M)>), (LIST(M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase>, MAP(M), LAMBDA(0), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase>, LAMBDA(M), VALUE(0), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase>, LAMBDA(M), NUMBER(0), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase>, LAMBDA(M), PAIR(0), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase>, LAMBDA(M), LIST(0), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase>, LAMBDA(M), MAP(0), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase>, LAMBDA(M), LAMBDA(0), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase>, LAMBDA(_), VALUE(0), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase>, LAMBDA(_), NUMBER(0), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase>, LAMBDA(_), PAIR(0), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase>, LAMBDA(_), LIST(0), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase>, LAMBDA(_), MAP(0), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase>, LAMBDA(_), LAMBDA(0), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::erase<LIST(INF), NUMBER(M)>), (metal::erase<LIST(INF), NUMBER(M), NUMBER(INC(M))>)); \
+    CHECK((metal::erase<LIST(INF), NUMBER(M), NUMBER(N)>), (metal::erase<LIST(INF), NUMBER(N), NUMBER(M)>)); \
+    CHECK((metal::erase<LIST(M), NUMBER(0), NUMBER(M)>), (LIST(0))); \
+    CHECK((metal::erase<LIST(INF), NUMBER(INF), NUMBER(M)>), (LIST(M))); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/list/find.cpp b/test/src/metal/list/find.cpp
index 6e94d146..88122562 100644
--- a/test/src/metal/list/find.cpp
+++ b/test/src/metal/list/find.cpp
@@ -11,61 +11,61 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, VAL(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, VAL(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, VAL(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, VAL(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, VAL(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, VAL(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, VAL(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, NUM(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, NUM(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, NUM(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, NUM(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, NUM(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, NUM(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, NUM(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, PAIR(M), VAL(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, PAIR(M), NUM(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, VALUE(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, VALUE(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, VALUE(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, VALUE(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, VALUE(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, VALUE(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, VALUE(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, NUMBER(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, NUMBER(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, NUMBER(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, NUMBER(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, NUMBER(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, NUMBER(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, NUMBER(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, PAIR(M), VALUE(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, PAIR(M), NUMBER(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::find>, PAIR(M), PAIR(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::find>, PAIR(M), LIST(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::find>, PAIR(M), MAP(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, PAIR(M), LBD(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, PAIR(M), LBD(_)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, LIST(M), VAL(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, LIST(M), NUM(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, PAIR(M), LAMBDA(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, PAIR(M), LAMBDA(_)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, LIST(M), VALUE(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, LIST(M), NUMBER(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::find>, LIST(M), PAIR(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::find>, LIST(M), LIST(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::find>, LIST(M), MAP(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, LIST(M), LBD(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, LIST(M), LBD(_)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, MAP(M), VAL(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, MAP(M), NUM(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, LIST(M), LAMBDA(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, LIST(M), LAMBDA(_)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, MAP(M), VALUE(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, MAP(M), NUMBER(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::find>, MAP(M), PAIR(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::find>, MAP(M), LIST(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::find>, MAP(M), MAP(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, MAP(M), LBD(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, MAP(M), LBD(_)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, LBD(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, LBD(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, LBD(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, LBD(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, LBD(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, LBD(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, LBD(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, LBD(_), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, LBD(_), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, LBD(_), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, LBD(_), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, LBD(_), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, LBD(_), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find>, LBD(_), LBD(_)>), (FALSE)); \
-    CHECK((metal::find<PAIR(M), VAL(N)>), (metal::number<M == N ? 1 : 2>)); \
-    CHECK((metal::find<PAIR(M), NUM(N)>), (metal::number<M == N ? 0 : 2>)); \
-    CHECK((metal::find<LIST(M), VAL(N)>), (metal::number<(M > N) ? N : M>)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, MAP(M), LAMBDA(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, MAP(M), LAMBDA(_)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, LAMBDA(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, LAMBDA(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, LAMBDA(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, LAMBDA(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, LAMBDA(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, LAMBDA(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, LAMBDA(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, LAMBDA(_), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, LAMBDA(_), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, LAMBDA(_), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, LAMBDA(_), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, LAMBDA(_), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, LAMBDA(_), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find>, LAMBDA(_), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::find<PAIR(M), VALUE(N)>), (metal::number<M == N ? 1 : 2>)); \
+    CHECK((metal::find<PAIR(M), NUMBER(N)>), (metal::number<M == N ? 0 : 2>)); \
+    CHECK((metal::find<LIST(M), VALUE(N)>), (metal::number<(M > N) ? N : M>)); \
     CHECK((metal::find<MAP(M), PAIR(N)>), (metal::number<(M > N) ? N : M>)); \
-    CHECK((metal::find<metal::list<VALS(M) COMMA(M) VAL(N)>, VAL(N)>), (metal::number<(M > N) ? N : M>)); \
-    CHECK((metal::find<metal::list<ENUM(M, VAL FIX(N))>, VAL(N)>), (metal::number<0>)); \
+    CHECK((metal::find<metal::list<VALUES(M) COMMA(M) VALUE(N)>, VALUE(N)>), (metal::number<(M > N) ? N : M>)); \
+    CHECK((metal::find<metal::list<ENUM(M, VALUE FIX(N))>, VALUE(N)>), (metal::number<0>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/list/find_if.cpp b/test/src/metal/list/find_if.cpp
index 1891e822..98317bac 100644
--- a/test/src/metal/list/find_if.cpp
+++ b/test/src/metal/list/find_if.cpp
@@ -12,55 +12,55 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, VAL(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, VAL(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, VAL(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, VAL(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, VAL(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, VAL(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, VAL(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, NUM(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, NUM(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, NUM(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, NUM(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, NUM(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, NUM(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, NUM(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, PAIR(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, PAIR(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, VALUE(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, VALUE(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, VALUE(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, VALUE(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, VALUE(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, VALUE(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, VALUE(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, NUMBER(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, NUMBER(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, NUMBER(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, NUMBER(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, NUMBER(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, NUMBER(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, NUMBER(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, PAIR(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, PAIR(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::find_if>, PAIR(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::find_if>, PAIR(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::find_if>, PAIR(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, PAIR(M), LBD(N)>), (BOOL(N == 1))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, PAIR(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LIST(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LIST(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, PAIR(M), LAMBDA(N)>), (BOOL(N == 1))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, PAIR(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LIST(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LIST(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LIST(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LIST(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LIST(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LIST(M), LBD(N)>), (BOOL(!M || N == 1))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LIST(M), LBD(_)>), (BOOL(!M))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, MAP(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, MAP(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LIST(M), LAMBDA(N)>), (BOOL(!M || N == 1))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LIST(M), LAMBDA(_)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, MAP(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, MAP(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::find_if>, MAP(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::find_if>, MAP(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::find_if>, MAP(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, MAP(M), LBD(N)>), (BOOL(!M || N == 1))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, MAP(M), LBD(_)>), (BOOL(!M))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LBD(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LBD(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LBD(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LBD(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LBD(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LBD(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LBD(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LBD(_), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LBD(_), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LBD(_), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LBD(_), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LBD(_), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LBD(_), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LBD(_), LBD(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, MAP(M), LAMBDA(N)>), (BOOL(!M || N == 1))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, MAP(M), LAMBDA(_)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LAMBDA(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LAMBDA(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LAMBDA(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LAMBDA(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LAMBDA(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LAMBDA(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LAMBDA(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LAMBDA(_), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LAMBDA(_), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LAMBDA(_), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LAMBDA(_), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LAMBDA(_), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LAMBDA(_), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::find_if>, LAMBDA(_), LAMBDA(_)>), (FALSE)); \
     CHECK((metal::find_if<PAIR(M), metal::lambda<metal::is_number>>), (metal::number<0>)); \
     CHECK((metal::find_if<LIST(M), metal::lambda<metal::is_number>>), (metal::number<M>)); \
     CHECK((metal::find_if<MAP(M), metal::lambda<metal::is_number>>), (metal::number<M>)); \
@@ -70,9 +70,9 @@
     CHECK((metal::find_if<PAIR(M), metal::lambda<metal::is_lambda>>), (metal::number<2>)); \
     CHECK((metal::find_if<LIST(M), metal::lambda<metal::is_lambda>>), (metal::number<M>)); \
     CHECK((metal::find_if<MAP(M), metal::lambda<metal::is_lambda>>), (metal::number<M>)); \
-    CHECK((metal::find_if<metal::list<ENUM(M, FWD, NUM, PAIR, LBD)>, metal::lambda<metal::is_number>>), (metal::number<0>)); \
-    CHECK((metal::find_if<metal::list<ENUM(M, FWD, NUM, PAIR, LBD)>, metal::lambda<metal::is_pair>>), (metal::number<M ? 1 : 0>)); \
-    CHECK((metal::find_if<metal::list<ENUM(M, FWD, NUM, PAIR, LBD)>, metal::lambda<metal::is_lambda>>), (metal::number<M ? 2 : 0>)); \
+    CHECK((metal::find_if<metal::list<ENUM(M, FWD, NUMBER, PAIR, LAMBDA)>, metal::lambda<metal::is_number>>), (metal::number<0>)); \
+    CHECK((metal::find_if<metal::list<ENUM(M, FWD, NUMBER, PAIR, LAMBDA)>, metal::lambda<metal::is_pair>>), (metal::number<M ? 1 : 0>)); \
+    CHECK((metal::find_if<metal::list<ENUM(M, FWD, NUMBER, PAIR, LAMBDA)>, metal::lambda<metal::is_lambda>>), (metal::number<M ? 2 : 0>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/list/flatten.cpp b/test/src/metal/list/flatten.cpp
index 56fb228d..2da68984 100644
--- a/test/src/metal/list/flatten.cpp
+++ b/test/src/metal/list/flatten.cpp
@@ -12,17 +12,17 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::flatten>, VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::flatten>, NUM(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::flatten>, VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::flatten>, NUMBER(M)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::flatten>, PAIR(M)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::flatten>, LIST(M)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::flatten>, MAP(M)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::flatten>, LBD(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::flatten>, LBD(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::flatten>, LAMBDA(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::flatten>, LAMBDA(_)>), (FALSE)); \
     CHECK((metal::flatten<PAIR(M)>), (PAIR(M))); \
     CHECK((metal::flatten<LIST(M)>), (LIST(M))); \
-    CHECK((metal::flatten<MAP(M)>), (metal::list<ENUM(M, FWD, NUM, VAL)>)); \
-    CHECK((metal::flatten<metal::enumerate<NUM(0), metal::number<100*M>, NUM(N)>>), (metal::enumerate<NUM(0), metal::number<100*M>, NUM(N)>)); \
+    CHECK((metal::flatten<MAP(M)>), (metal::list<ENUM(M, FWD, NUMBER, VALUE)>)); \
+    CHECK((metal::flatten<metal::enumerate<NUMBER(0), metal::number<100*M>, NUMBER(N)>>), (metal::enumerate<NUMBER(0), metal::number<100*M>, NUMBER(N)>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/list/fold_left.cpp b/test/src/metal/list/fold_left.cpp
index c46c0481..853bc5b0 100644
--- a/test/src/metal/list/fold_left.cpp
+++ b/test/src/metal/list/fold_left.cpp
@@ -11,60 +11,60 @@
 
 #include "test.hpp"
 
-#define TAB(N, ...) EXPR(_)<__VA_ARGS__, VAL(N)>
+#define TAB(N, ...) EXPR(_)<__VA_ARGS__, VALUE(N)>
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, VAL(M), VAL(N), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, VAL(M), VAL(N), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, VAL(M), VAL(N), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, VAL(M), VAL(N), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, VAL(M), VAL(N), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, VAL(M), VAL(N), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, VAL(M), VAL(N), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, NUM(M), NUM(N), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, NUM(M), NUM(N), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, NUM(M), NUM(N), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, NUM(M), NUM(N), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, NUM(M), NUM(N), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, NUM(M), NUM(N), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, NUM(M), NUM(N), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, PAIR(M), PAIR(N), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, PAIR(M), PAIR(N), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, VALUE(M), VALUE(N), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, VALUE(M), VALUE(N), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, VALUE(M), VALUE(N), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, VALUE(M), VALUE(N), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, VALUE(M), VALUE(N), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, VALUE(M), VALUE(N), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, VALUE(M), VALUE(N), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, NUMBER(M), NUMBER(N), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, NUMBER(M), NUMBER(N), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, NUMBER(M), NUMBER(N), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, NUMBER(M), NUMBER(N), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, NUMBER(M), NUMBER(N), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, NUMBER(M), NUMBER(N), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, NUMBER(M), NUMBER(N), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, PAIR(M), PAIR(N), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, PAIR(M), PAIR(N), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, PAIR(M), PAIR(N), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, PAIR(M), PAIR(N), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, PAIR(M), PAIR(N), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, PAIR(M), PAIR(N), LBD(N)>), (BOOL(N == 2))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, PAIR(M), PAIR(N), LBD(_)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LIST(M), LIST(N), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LIST(M), LIST(N), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, PAIR(M), PAIR(N), LAMBDA(N)>), (BOOL(N == 2))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, PAIR(M), PAIR(N), LAMBDA(_)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LIST(M), LIST(N), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LIST(M), LIST(N), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LIST(M), LIST(N), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LIST(M), LIST(N), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LIST(M), LIST(N), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LIST(M), LIST(N), LBD(N)>), (BOOL(!M || N == 2))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LIST(M), LIST(N), LBD(_)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, MAP(M), MAP(N), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, MAP(M), MAP(N), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LIST(M), LIST(N), LAMBDA(N)>), (BOOL(!M || N == 2))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LIST(M), LIST(N), LAMBDA(_)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, MAP(M), MAP(N), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, MAP(M), MAP(N), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, MAP(M), MAP(N), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, MAP(M), MAP(N), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, MAP(M), MAP(N), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, MAP(M), MAP(N), LBD(N)>), (BOOL(!M || N == 2))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, MAP(M), MAP(N), LBD(_)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LBD(M), LBD(N), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LBD(M), LBD(N), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LBD(M), LBD(N), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LBD(M), LBD(N), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LBD(M), LBD(N), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LBD(M), LBD(N), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LBD(M), LBD(N), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LBD(_), LBD(N), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LBD(_), LBD(N), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LBD(_), LBD(N), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LBD(_), LBD(N), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LBD(_), LBD(N), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LBD(_), LBD(N), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LBD(_), LBD(N), LBD(_)>), (FALSE)); \
-    CHECK((metal::fold_left<LIST(M), VAL(N), LBD(_)>), (FOLD(M, TAB, VAL(N)))); \
-    CHECK((metal::fold_left<metal::enumerate<NUM(0), metal::number<100*M>, NUM(N)>, NUM(2), LBD(2)>), (NUM(2))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, MAP(M), MAP(N), LAMBDA(N)>), (BOOL(!M || N == 2))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, MAP(M), MAP(N), LAMBDA(_)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LAMBDA(M), LAMBDA(N), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LAMBDA(M), LAMBDA(N), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LAMBDA(M), LAMBDA(N), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LAMBDA(M), LAMBDA(N), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LAMBDA(M), LAMBDA(N), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LAMBDA(M), LAMBDA(N), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LAMBDA(M), LAMBDA(N), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LAMBDA(_), LAMBDA(N), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LAMBDA(_), LAMBDA(N), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LAMBDA(_), LAMBDA(N), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LAMBDA(_), LAMBDA(N), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LAMBDA(_), LAMBDA(N), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LAMBDA(_), LAMBDA(N), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_left>, LAMBDA(_), LAMBDA(N), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::fold_left<LIST(M), VALUE(N), LAMBDA(_)>), (FOLD(M, TAB, VALUE(N)))); \
+    CHECK((metal::fold_left<metal::enumerate<NUMBER(0), metal::number<100*M>, NUMBER(N)>, NUMBER(2), LAMBDA(2)>), (NUMBER(2))); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/list/fold_right.cpp b/test/src/metal/list/fold_right.cpp
index 3a56f890..f8d61d68 100644
--- a/test/src/metal/list/fold_right.cpp
+++ b/test/src/metal/list/fold_right.cpp
@@ -11,60 +11,60 @@
 
 #include "test.hpp"
 
-#define TAB(N, ...) EXPR(_)<__VA_ARGS__, VAL(N)>
+#define TAB(N, ...) EXPR(_)<__VA_ARGS__, VALUE(N)>
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, VAL(M), VAL(N), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, VAL(M), VAL(N), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, VAL(M), VAL(N), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, VAL(M), VAL(N), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, VAL(M), VAL(N), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, VAL(M), VAL(N), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, VAL(M), VAL(N), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, NUM(M), NUM(N), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, NUM(M), NUM(N), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, NUM(M), NUM(N), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, NUM(M), NUM(N), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, NUM(M), NUM(N), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, NUM(M), NUM(N), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, NUM(M), NUM(N), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, PAIR(M), PAIR(N), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, PAIR(M), PAIR(N), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, VALUE(M), VALUE(N), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, VALUE(M), VALUE(N), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, VALUE(M), VALUE(N), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, VALUE(M), VALUE(N), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, VALUE(M), VALUE(N), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, VALUE(M), VALUE(N), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, VALUE(M), VALUE(N), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, NUMBER(M), NUMBER(N), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, NUMBER(M), NUMBER(N), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, NUMBER(M), NUMBER(N), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, NUMBER(M), NUMBER(N), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, NUMBER(M), NUMBER(N), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, NUMBER(M), NUMBER(N), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, NUMBER(M), NUMBER(N), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, PAIR(M), PAIR(N), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, PAIR(M), PAIR(N), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, PAIR(M), PAIR(N), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, PAIR(M), PAIR(N), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, PAIR(M), PAIR(N), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, PAIR(M), PAIR(N), LBD(N)>), (BOOL(N == 2))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, PAIR(M), PAIR(N), LBD(_)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LIST(M), LIST(N), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LIST(M), LIST(N), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, PAIR(M), PAIR(N), LAMBDA(N)>), (BOOL(N == 2))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, PAIR(M), PAIR(N), LAMBDA(_)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LIST(M), LIST(N), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LIST(M), LIST(N), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LIST(M), LIST(N), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LIST(M), LIST(N), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LIST(M), LIST(N), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LIST(M), LIST(N), LBD(N)>), (BOOL(!M || N == 2))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LIST(M), LIST(N), LBD(_)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, MAP(M), MAP(N), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, MAP(M), MAP(N), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LIST(M), LIST(N), LAMBDA(N)>), (BOOL(!M || N == 2))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LIST(M), LIST(N), LAMBDA(_)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, MAP(M), MAP(N), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, MAP(M), MAP(N), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, MAP(M), MAP(N), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, MAP(M), MAP(N), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, MAP(M), MAP(N), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, MAP(M), MAP(N), LBD(N)>), (BOOL(!M || N == 2))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, MAP(M), MAP(N), LBD(_)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LBD(M), LBD(N), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LBD(M), LBD(N), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LBD(M), LBD(N), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LBD(M), LBD(N), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LBD(M), LBD(N), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LBD(M), LBD(N), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LBD(M), LBD(N), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LBD(_), LBD(N), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LBD(_), LBD(N), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LBD(_), LBD(N), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LBD(_), LBD(N), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LBD(_), LBD(N), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LBD(_), LBD(N), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LBD(_), LBD(N), LBD(_)>), (FALSE)); \
-    CHECK((metal::fold_right<LIST(M), VAL(N), LBD(_)>), (REFOLD(M, TAB, VAL(N)))); \
-    CHECK((metal::fold_right<metal::enumerate<NUM(0), metal::number<100*M>, NUM(N)>, NUM(2), LBD(2)>), (NUM(2))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, MAP(M), MAP(N), LAMBDA(N)>), (BOOL(!M || N == 2))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, MAP(M), MAP(N), LAMBDA(_)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LAMBDA(M), LAMBDA(N), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LAMBDA(M), LAMBDA(N), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LAMBDA(M), LAMBDA(N), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LAMBDA(M), LAMBDA(N), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LAMBDA(M), LAMBDA(N), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LAMBDA(M), LAMBDA(N), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LAMBDA(M), LAMBDA(N), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LAMBDA(_), LAMBDA(N), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LAMBDA(_), LAMBDA(N), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LAMBDA(_), LAMBDA(N), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LAMBDA(_), LAMBDA(N), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LAMBDA(_), LAMBDA(N), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LAMBDA(_), LAMBDA(N), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::fold_right>, LAMBDA(_), LAMBDA(N), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::fold_right<LIST(M), VALUE(N), LAMBDA(_)>), (REFOLD(M, TAB, VALUE(N)))); \
+    CHECK((metal::fold_right<metal::enumerate<NUMBER(0), metal::number<100*M>, NUMBER(N)>, NUMBER(2), LAMBDA(2)>), (NUMBER(2))); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/list/front.cpp b/test/src/metal/list/front.cpp
index f3850c07..743b65d6 100644
--- a/test/src/metal/list/front.cpp
+++ b/test/src/metal/list/front.cpp
@@ -11,15 +11,15 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::front>, VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::front>, NUM(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::front>, VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::front>, NUMBER(M)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::front>, PAIR(M)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::front>, LIST(M)>), (BOOL(M > 0))); \
     CHECK((metal::is_invocable<metal::lambda<metal::front>, MAP(M)>), (BOOL(M > 0))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::front>, LBD(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::front>, LBD(_)>), (FALSE)); \
-    CHECK((metal::front<PAIR(M)>), (NUM(M))); \
-    CHECK((metal::front<LIST(INC(M))>), (VAL(0))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::front>, LAMBDA(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::front>, LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::front<PAIR(M)>), (NUMBER(M))); \
+    CHECK((metal::front<LIST(INC(M))>), (VALUE(0))); \
     CHECK((metal::front<MAP(INC(M))>), (PAIR(0))); \
 /**/
 
diff --git a/test/src/metal/list/indices.cpp b/test/src/metal/list/indices.cpp
index 2baf8f26..0b536bf2 100644
--- a/test/src/metal/list/indices.cpp
+++ b/test/src/metal/list/indices.cpp
@@ -11,16 +11,16 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::indices>, VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::indices>, NUM(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::indices>, VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::indices>, NUMBER(M)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::indices>, PAIR(M)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::indices>, LIST(M)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::indices>, MAP(M)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::indices>, LBD(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::indices>, LBD(_)>), (FALSE)); \
-    CHECK((metal::indices<PAIR(M)>), (metal::list<NUMS(2)>)); \
-    CHECK((metal::indices<LIST(M)>), (metal::list<NUMS(M)>)); \
-    CHECK((metal::indices<MAP(M)>), (metal::list<NUMS(M)>)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::indices>, LAMBDA(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::indices>, LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::indices<PAIR(M)>), (metal::list<NUMBERS(2)>)); \
+    CHECK((metal::indices<LIST(M)>), (metal::list<NUMBERS(M)>)); \
+    CHECK((metal::indices<MAP(M)>), (metal::list<NUMBERS(M)>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/list/insert.cpp b/test/src/metal/list/insert.cpp
index 0a0a0b9a..48b90b2b 100644
--- a/test/src/metal/list/insert.cpp
+++ b/test/src/metal/list/insert.cpp
@@ -11,56 +11,56 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, VAL(M), VAL(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, VAL(M), NUM(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, VAL(M), PAIR(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, VAL(M), LIST(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, VAL(M), MAP(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, VAL(M), LBD(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, VAL(M), LBD(_), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, NUM(M), VAL(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, NUM(M), NUM(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, NUM(M), PAIR(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, NUM(M), LIST(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, NUM(M), MAP(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, NUM(M), LBD(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, NUM(M), LBD(_), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, PAIR(M), VAL(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, PAIR(M), NUM(N), VAL(M)>), (BOOL(N < 3))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, PAIR(M), PAIR(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, PAIR(M), LIST(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, PAIR(M), MAP(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, PAIR(M), LBD(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, PAIR(M), LBD(_), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LIST(M), VAL(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LIST(M), NUM(N), VAL(M)>), (BOOL(M >= N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LIST(M), PAIR(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LIST(M), LIST(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LIST(M), MAP(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LIST(M), LBD(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LIST(M), LBD(_), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, MAP(M), VAL(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, MAP(M), NUM(N), VAL(M)>), (BOOL(M >= N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, MAP(M), PAIR(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, MAP(M), LIST(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, MAP(M), MAP(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, MAP(M), LBD(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, MAP(M), LBD(_), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LBD(M), VAL(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LBD(M), NUM(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LBD(M), PAIR(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LBD(M), LIST(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LBD(M), MAP(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LBD(M), LBD(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LBD(M), LBD(_), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LBD(_), VAL(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LBD(_), NUM(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LBD(_), PAIR(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LBD(_), LIST(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LBD(_), MAP(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LBD(_), LBD(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LBD(_), LBD(_), VAL(M)>), (FALSE)); \
-    CHECK((metal::insert<metal::list<VALS(M) COMMA(AND(M, CMPL(M))) VALS(CMPL(M))>, NUM(M), NUM(N)>), (metal::list<VALS(M) COMMA(M) NUM(N) COMMA(CMPL(M)) VALS(CMPL(M))>)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, VALUE(M), VALUE(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, VALUE(M), NUMBER(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, VALUE(M), PAIR(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, VALUE(M), LIST(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, VALUE(M), MAP(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, VALUE(M), LAMBDA(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, VALUE(M), LAMBDA(_), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, NUMBER(M), VALUE(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, NUMBER(M), NUMBER(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, NUMBER(M), PAIR(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, NUMBER(M), LIST(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, NUMBER(M), MAP(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, NUMBER(M), LAMBDA(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, NUMBER(M), LAMBDA(_), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, PAIR(M), VALUE(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, PAIR(M), NUMBER(N), VALUE(M)>), (BOOL(N < 3))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, PAIR(M), PAIR(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, PAIR(M), LIST(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, PAIR(M), MAP(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, PAIR(M), LAMBDA(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, PAIR(M), LAMBDA(_), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LIST(M), VALUE(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LIST(M), NUMBER(N), VALUE(M)>), (BOOL(M >= N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LIST(M), PAIR(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LIST(M), LIST(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LIST(M), MAP(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LIST(M), LAMBDA(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LIST(M), LAMBDA(_), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, MAP(M), VALUE(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, MAP(M), NUMBER(N), VALUE(M)>), (BOOL(M >= N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, MAP(M), PAIR(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, MAP(M), LIST(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, MAP(M), MAP(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, MAP(M), LAMBDA(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, MAP(M), LAMBDA(_), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LAMBDA(M), VALUE(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LAMBDA(M), NUMBER(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LAMBDA(M), PAIR(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LAMBDA(M), LIST(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LAMBDA(M), MAP(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LAMBDA(M), LAMBDA(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LAMBDA(M), LAMBDA(_), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LAMBDA(_), VALUE(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LAMBDA(_), NUMBER(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LAMBDA(_), PAIR(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LAMBDA(_), LIST(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LAMBDA(_), MAP(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LAMBDA(_), LAMBDA(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::insert>, LAMBDA(_), LAMBDA(_), VALUE(M)>), (FALSE)); \
+    CHECK((metal::insert<metal::list<VALUES(M) COMMA(AND(M, CMPL(M))) VALUES(CMPL(M))>, NUMBER(M), NUMBER(N)>), (metal::list<VALUES(M) COMMA(M) NUMBER(N) COMMA(CMPL(M)) VALUES(CMPL(M))>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/list/join.cpp b/test/src/metal/list/join.cpp
index daa106ab..f6588073 100644
--- a/test/src/metal/list/join.cpp
+++ b/test/src/metal/list/join.cpp
@@ -11,52 +11,52 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::join>, VAL(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::join>, VAL(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::join>, VAL(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::join>, VAL(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::join>, VAL(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::join>, VAL(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::join>, NUM(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::join>, NUM(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::join>, NUM(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::join>, NUM(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::join>, NUM(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::join>, NUM(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::join>, PAIR(M) COMMA(N) VALS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::join>, PAIR(M) COMMA(N) NUMS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::join>, VALUE(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::join>, VALUE(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::join>, VALUE(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::join>, VALUE(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::join>, VALUE(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::join>, VALUE(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::join>, NUMBER(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::join>, NUMBER(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::join>, NUMBER(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::join>, NUMBER(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::join>, NUMBER(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::join>, NUMBER(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::join>, PAIR(M) COMMA(N) VALUES(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::join>, PAIR(M) COMMA(N) NUMBERS(N)>), (BOOL(!N))); \
     CHECK((metal::is_invocable<metal::lambda<metal::join>, PAIR(M) COMMA(N) PAIRS(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::join>, PAIR(M) COMMA(N) LISTS(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::join>, PAIR(M) COMMA(N) MAPS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::join>, PAIR(M) COMMA(N) LBDS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::join>, LIST(M) COMMA(N) VALS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::join>, LIST(M) COMMA(N) NUMS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::join>, PAIR(M) COMMA(N) LAMBDAS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::join>, LIST(M) COMMA(N) VALUES(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::join>, LIST(M) COMMA(N) NUMBERS(N)>), (BOOL(!N))); \
     CHECK((metal::is_invocable<metal::lambda<metal::join>, LIST(M) COMMA(N) PAIRS(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::join>, LIST(M) COMMA(N) LISTS(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::join>, LIST(M) COMMA(N) MAPS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::join>, LIST(M) COMMA(N) LBDS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::join>, MAP(M) COMMA(N) VALS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::join>, MAP(M) COMMA(N) NUMS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::join>, LIST(M) COMMA(N) LAMBDAS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::join>, MAP(M) COMMA(N) VALUES(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::join>, MAP(M) COMMA(N) NUMBERS(N)>), (BOOL(!N))); \
     CHECK((metal::is_invocable<metal::lambda<metal::join>, MAP(M) COMMA(N) PAIRS(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::join>, MAP(M) COMMA(N) LISTS(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::join>, MAP(M) COMMA(N) MAPS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::join>, MAP(M) COMMA(N) LBDS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::join>, LBD(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::join>, LBD(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::join>, LBD(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::join>, LBD(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::join>, LBD(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::join>, LBD(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::join>, LBD(_) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::join>, LBD(_) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::join>, LBD(_) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::join>, LBD(_) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::join>, LBD(_) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::join>, LBD(_) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::join<PAIR(M) COMMA(N) PAIRS(N)>), (metal::list<NUM(M), VAL(M) COMMA(N) ENUM(N, FWD, NUM, VAL)>)); \
-    CHECK((metal::join<PAIR(M) COMMA(N) LISTS(N)>), (metal::list<NUM(M), VAL(M) ENUM(N, VALS)>)); \
-    CHECK((metal::join<PAIR(M) COMMA(N) MAPS(N)>), (metal::list<NUM(M), VAL(M) ENUM(N, PAIRS)>)); \
-    CHECK((metal::join<ENUM(M, LIST FIX(INC(N))) COMMA(M) ENUM(INC(N), LIST FIX(0))>), (metal::list<ENUM(M, VALS FIX(INC(N)))>)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::join>, MAP(M) COMMA(N) LAMBDAS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::join>, LAMBDA(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::join>, LAMBDA(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::join>, LAMBDA(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::join>, LAMBDA(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::join>, LAMBDA(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::join>, LAMBDA(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::join>, LAMBDA(_) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::join>, LAMBDA(_) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::join>, LAMBDA(_) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::join>, LAMBDA(_) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::join>, LAMBDA(_) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::join>, LAMBDA(_) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::join<PAIR(M) COMMA(N) PAIRS(N)>), (metal::list<NUMBER(M), VALUE(M) COMMA(N) ENUM(N, FWD, NUMBER, VALUE)>)); \
+    CHECK((metal::join<PAIR(M) COMMA(N) LISTS(N)>), (metal::list<NUMBER(M), VALUE(M) ENUM(N, VALUES)>)); \
+    CHECK((metal::join<PAIR(M) COMMA(N) MAPS(N)>), (metal::list<NUMBER(M), VALUE(M) ENUM(N, PAIRS)>)); \
+    CHECK((metal::join<ENUM(M, LIST FIX(INC(N))) COMMA(M) ENUM(INC(N), LIST FIX(0))>), (metal::list<ENUM(M, VALUES FIX(INC(N)))>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/list/list.cpp b/test/src/metal/list/list.cpp
index 88b22795..9c1159b6 100644
--- a/test/src/metal/list/list.cpp
+++ b/test/src/metal/list/list.cpp
@@ -10,20 +10,19 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::list> COMMA(N) VALS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::list> COMMA(N) NUMS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::list> COMMA(N) VALUES(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::list> COMMA(N) NUMBERS(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::list> COMMA(N) PAIRS(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::list> COMMA(N) LISTS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::list> COMMA(N) LISTS(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::list> COMMA(N) MAPS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::list> COMMA(N) LBDS(N)>), (TRUE)); \
-    CHECK((metal::is_list<VAL(N)>), (FALSE)); \
-    CHECK((metal::is_list<NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::list> COMMA(N) LAMBDAS(N)>), (TRUE)); \
+    CHECK((metal::is_list<VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_list<NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_list<PAIR(N)>), (TRUE)); \
     CHECK((metal::is_list<LIST(N)>), (TRUE)); \
     CHECK((metal::is_list<MAP(N)>), (TRUE)); \
-    CHECK((metal::is_list<LBD(N)>), (FALSE)); \
-    CHECK((metal::is_list<LBD(_)>), (FALSE)); \
+    CHECK((metal::is_list<LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_list<LAMBDA(_)>), (FALSE)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/list/none.cpp b/test/src/metal/list/none.cpp
index 49bcf6a5..68d70e36 100644
--- a/test/src/metal/list/none.cpp
+++ b/test/src/metal/list/none.cpp
@@ -12,55 +12,55 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, VAL(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, VAL(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, VAL(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, VAL(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, VAL(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, VAL(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, VAL(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, NUM(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, NUM(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, NUM(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, NUM(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, NUM(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, NUM(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, NUM(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, PAIR(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, PAIR(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, VALUE(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, VALUE(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, VALUE(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, VALUE(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, VALUE(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, VALUE(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, VALUE(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, NUMBER(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, NUMBER(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, NUMBER(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, NUMBER(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, NUMBER(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, NUMBER(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, NUMBER(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, PAIR(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, PAIR(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::none>, PAIR(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::none>, PAIR(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::none>, PAIR(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, PAIR(M), LBD(N)>), (BOOL(N == 1))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, PAIR(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, LIST(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, LIST(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, PAIR(M), LAMBDA(N)>), (BOOL(N == 1))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, PAIR(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, LIST(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, LIST(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::none>, LIST(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::none>, LIST(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::none>, LIST(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, LIST(M), LBD(N)>), (BOOL(!M || N == 1))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, LIST(M), LBD(_)>), (BOOL(!M))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, MAP(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, MAP(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, LIST(M), LAMBDA(N)>), (BOOL(!M || N == 1))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, LIST(M), LAMBDA(_)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, MAP(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, MAP(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::none>, MAP(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::none>, MAP(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::none>, MAP(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, MAP(M), LBD(N)>), (BOOL(!M || N == 1))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, MAP(M), LBD(_)>), (BOOL(!M))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, LBD(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, LBD(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, LBD(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, LBD(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, LBD(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, LBD(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, LBD(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, LBD(_), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, LBD(_), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, LBD(_), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, LBD(_), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, LBD(_), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, LBD(_), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::none>, LBD(_), LBD(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, MAP(M), LAMBDA(N)>), (BOOL(!M || N == 1))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, MAP(M), LAMBDA(_)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, LAMBDA(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, LAMBDA(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, LAMBDA(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, LAMBDA(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, LAMBDA(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, LAMBDA(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, LAMBDA(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, LAMBDA(_), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, LAMBDA(_), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, LAMBDA(_), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, LAMBDA(_), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, LAMBDA(_), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, LAMBDA(_), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::none>, LAMBDA(_), LAMBDA(_)>), (FALSE)); \
     CHECK((metal::none<PAIR(M), metal::lambda<metal::is_number>>), (FALSE)); \
     CHECK((metal::none<LIST(M), metal::lambda<metal::is_number>>), (TRUE)); \
     CHECK((metal::none<MAP(M), metal::lambda<metal::is_number>>), (TRUE)); \
diff --git a/test/src/metal/list/partition.cpp b/test/src/metal/list/partition.cpp
index 12b97ea8..d98b64d8 100644
--- a/test/src/metal/list/partition.cpp
+++ b/test/src/metal/list/partition.cpp
@@ -12,61 +12,61 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, VAL(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, VAL(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, VAL(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, VAL(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, VAL(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, VAL(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, VAL(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, NUM(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, NUM(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, NUM(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, NUM(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, NUM(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, NUM(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, NUM(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, PAIR(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, PAIR(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, VALUE(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, VALUE(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, VALUE(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, VALUE(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, VALUE(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, VALUE(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, VALUE(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, NUMBER(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, NUMBER(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, NUMBER(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, NUMBER(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, NUMBER(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, NUMBER(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, NUMBER(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, PAIR(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, PAIR(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::partition>, PAIR(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::partition>, PAIR(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::partition>, PAIR(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, PAIR(M), LBD(N)>), (BOOL(N == 1))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, PAIR(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, LIST(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, LIST(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, PAIR(M), LAMBDA(N)>), (BOOL(N == 1))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, PAIR(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, LIST(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, LIST(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::partition>, LIST(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::partition>, LIST(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::partition>, LIST(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, LIST(M), LBD(N)>), (BOOL(!M || N == 1))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, LIST(M), LBD(_)>), (BOOL(!M))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, MAP(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, MAP(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, LIST(M), LAMBDA(N)>), (BOOL(!M || N == 1))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, LIST(M), LAMBDA(_)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, MAP(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, MAP(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::partition>, MAP(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::partition>, MAP(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::partition>, MAP(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, MAP(M), LBD(N)>), (BOOL(!M || N == 1))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, MAP(M), LBD(_)>), (BOOL(!M))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, LBD(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, LBD(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, LBD(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, LBD(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, LBD(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, LBD(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, LBD(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, LBD(_), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, LBD(_), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, LBD(_), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, LBD(_), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, LBD(_), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, LBD(_), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::partition>, LBD(_), LBD(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, MAP(M), LAMBDA(N)>), (BOOL(!M || N == 1))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, MAP(M), LAMBDA(_)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, LAMBDA(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, LAMBDA(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, LAMBDA(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, LAMBDA(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, LAMBDA(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, LAMBDA(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, LAMBDA(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, LAMBDA(_), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, LAMBDA(_), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, LAMBDA(_), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, LAMBDA(_), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, LAMBDA(_), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, LAMBDA(_), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::partition>, LAMBDA(_), LAMBDA(_)>), (FALSE)); \
     CHECK((metal::partition<LIST(M), metal::lambda<metal::is_number>>), (metal::pair<LIST(0), LIST(M)>)); \
     CHECK((metal::partition<LIST(M), metal::lambda<metal::is_pair>>), (metal::pair<LIST(0), LIST(M)>)); \
     CHECK((metal::partition<LIST(M), metal::lambda<metal::is_lambda>>), (metal::pair<LIST(0), LIST(M)>)); \
-    CHECK((metal::partition<metal::list<ENUM(M, FWD, NUM, PAIR, LBD)>, metal::lambda<metal::is_number>>), (metal::pair<metal::list<NUMS(M)>, metal::list<ENUM(M, FWD, PAIR, LBD)>>)); \
-    CHECK((metal::partition<metal::list<ENUM(M, FWD, NUM, PAIR, LBD)>, metal::lambda<metal::is_pair>>), (metal::pair<metal::list<PAIRS(M)>, metal::list<ENUM(M, FWD, NUM, LBD)>>)); \
-    CHECK((metal::partition<metal::list<ENUM(M, FWD, NUM, PAIR, LBD)>, metal::lambda<metal::is_lambda>>), (metal::pair<metal::list<LBDS(M)>, metal::list<ENUM(M, FWD, NUM, PAIR)>>)); \
+    CHECK((metal::partition<metal::list<ENUM(M, FWD, NUMBER, PAIR, LAMBDA)>, metal::lambda<metal::is_number>>), (metal::pair<metal::list<NUMBERS(M)>, metal::list<ENUM(M, FWD, PAIR, LAMBDA)>>)); \
+    CHECK((metal::partition<metal::list<ENUM(M, FWD, NUMBER, PAIR, LAMBDA)>, metal::lambda<metal::is_pair>>), (metal::pair<metal::list<PAIRS(M)>, metal::list<ENUM(M, FWD, NUMBER, LAMBDA)>>)); \
+    CHECK((metal::partition<metal::list<ENUM(M, FWD, NUMBER, PAIR, LAMBDA)>, metal::lambda<metal::is_lambda>>), (metal::pair<metal::list<LAMBDAS(M)>, metal::list<ENUM(M, FWD, NUMBER, PAIR)>>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/list/prepend.cpp b/test/src/metal/list/prepend.cpp
index abc4cfa5..acb6510f 100644
--- a/test/src/metal/list/prepend.cpp
+++ b/test/src/metal/list/prepend.cpp
@@ -11,51 +11,51 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, VAL(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, VAL(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, VAL(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, VAL(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, VAL(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, VAL(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, NUM(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, NUM(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, NUM(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, NUM(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, NUM(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, NUM(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, PAIR(M) COMMA(N) VALS(N)>), (BOOL(N > 0))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, PAIR(M) COMMA(N) NUMS(N)>), (BOOL(N > 0))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, VALUE(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, VALUE(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, VALUE(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, VALUE(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, VALUE(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, VALUE(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, NUMBER(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, NUMBER(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, NUMBER(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, NUMBER(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, NUMBER(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, NUMBER(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, PAIR(M) COMMA(N) VALUES(N)>), (BOOL(N > 0))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, PAIR(M) COMMA(N) NUMBERS(N)>), (BOOL(N > 0))); \
     CHECK((metal::is_invocable<metal::lambda<metal::prepend>, PAIR(M) COMMA(N) PAIRS(N)>), (BOOL(N > 0))); \
     CHECK((metal::is_invocable<metal::lambda<metal::prepend>, PAIR(M) COMMA(N) LISTS(N)>), (BOOL(N > 0))); \
     CHECK((metal::is_invocable<metal::lambda<metal::prepend>, PAIR(M) COMMA(N) MAPS(N)>), (BOOL(N > 0))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, PAIR(M) COMMA(N) LBDS(N)>), (BOOL(N > 0))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, LIST(M) COMMA(N) VALS(N)>), (BOOL(N > 0))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, LIST(M) COMMA(N) NUMS(N)>), (BOOL(N > 0))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, PAIR(M) COMMA(N) LAMBDAS(N)>), (BOOL(N > 0))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, LIST(M) COMMA(N) VALUES(N)>), (BOOL(N > 0))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, LIST(M) COMMA(N) NUMBERS(N)>), (BOOL(N > 0))); \
     CHECK((metal::is_invocable<metal::lambda<metal::prepend>, LIST(M) COMMA(N) PAIRS(N)>), (BOOL(N > 0))); \
     CHECK((metal::is_invocable<metal::lambda<metal::prepend>, LIST(M) COMMA(N) LISTS(N)>), (BOOL(N > 0))); \
     CHECK((metal::is_invocable<metal::lambda<metal::prepend>, LIST(M) COMMA(N) MAPS(N)>), (BOOL(N > 0))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, LIST(M) COMMA(N) LBDS(N)>), (BOOL(N > 0))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, MAP(M) COMMA(N) VALS(N)>), (BOOL(N > 0))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, MAP(M) COMMA(N) NUMS(N)>), (BOOL(N > 0))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, LIST(M) COMMA(N) LAMBDAS(N)>), (BOOL(N > 0))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, MAP(M) COMMA(N) VALUES(N)>), (BOOL(N > 0))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, MAP(M) COMMA(N) NUMBERS(N)>), (BOOL(N > 0))); \
     CHECK((metal::is_invocable<metal::lambda<metal::prepend>, MAP(M) COMMA(N) PAIRS(N)>), (BOOL(N > 0))); \
     CHECK((metal::is_invocable<metal::lambda<metal::prepend>, MAP(M) COMMA(N) LISTS(N)>), (BOOL(N > 0))); \
     CHECK((metal::is_invocable<metal::lambda<metal::prepend>, MAP(M) COMMA(N) MAPS(N)>), (BOOL(N > 0))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, MAP(M) COMMA(N) LBDS(N)>), (BOOL(N > 0))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, LBD(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, LBD(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, LBD(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, LBD(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, LBD(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, LBD(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, LBD(_) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, LBD(_) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, LBD(_) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, LBD(_) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, LBD(_) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, LBD(_) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::prepend<PAIR(M), VAL(INC(N))>), (metal::list<VAL(INC(N)), NUM(M), VAL(M)>)); \
-    CHECK((metal::prepend<LIST(M), VAL(INC(N))>), (metal::list<VAL(INC(N)) COMMA(M) VALS(M)>)); \
-    CHECK((metal::prepend<MAP(M), VAL(INC(N))>), (metal::list<VAL(INC(N)) COMMA(M) PAIRS(M)>)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, MAP(M) COMMA(N) LAMBDAS(N)>), (BOOL(N > 0))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, LAMBDA(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, LAMBDA(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, LAMBDA(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, LAMBDA(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, LAMBDA(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, LAMBDA(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, LAMBDA(_) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, LAMBDA(_) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, LAMBDA(_) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, LAMBDA(_) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, LAMBDA(_) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::prepend>, LAMBDA(_) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::prepend<PAIR(M), VALUE(INC(N))>), (metal::list<VALUE(INC(N)), NUMBER(M), VALUE(M)>)); \
+    CHECK((metal::prepend<LIST(M), VALUE(INC(N))>), (metal::list<VALUE(INC(N)) COMMA(M) VALUES(M)>)); \
+    CHECK((metal::prepend<MAP(M), VALUE(INC(N))>), (metal::list<VALUE(INC(N)) COMMA(M) PAIRS(M)>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/list/range.cpp b/test/src/metal/list/range.cpp
index 2801ae0d..1afd447c 100644
--- a/test/src/metal/list/range.cpp
+++ b/test/src/metal/list/range.cpp
@@ -11,54 +11,54 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::range>, VAL(M), VAL(0), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::range>, VAL(M), NUM(0), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::range>, VAL(M), PAIR(0), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::range>, VAL(M), LIST(0), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::range>, VAL(M), MAP(0), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::range>, VAL(M), LBD(0), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::range>, NUM(M), VAL(0), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::range>, NUM(M), NUM(0), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::range>, NUM(M), PAIR(0), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::range>, NUM(M), LIST(0), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::range>, NUM(M), MAP(0), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::range>, NUM(M), LBD(0), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::range>, PAIR(M), VAL(0), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::range>, PAIR(M), NUM(0), NUM(N)>), (BOOL(N < 3))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::range>, VALUE(M), VALUE(0), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::range>, VALUE(M), NUMBER(0), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::range>, VALUE(M), PAIR(0), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::range>, VALUE(M), LIST(0), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::range>, VALUE(M), MAP(0), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::range>, VALUE(M), LAMBDA(0), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::range>, NUMBER(M), VALUE(0), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::range>, NUMBER(M), NUMBER(0), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::range>, NUMBER(M), PAIR(0), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::range>, NUMBER(M), LIST(0), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::range>, NUMBER(M), MAP(0), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::range>, NUMBER(M), LAMBDA(0), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::range>, PAIR(M), VALUE(0), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::range>, PAIR(M), NUMBER(0), NUMBER(N)>), (BOOL(N < 3))); \
     CHECK((metal::is_invocable<metal::lambda<metal::range>, PAIR(M), PAIR(0), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::range>, PAIR(M), LIST(0), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::range>, PAIR(M), MAP(0), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::range>, PAIR(M), LBD(0), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::range>, LIST(M), VAL(0), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::range>, LIST(M), NUM(0), NUM(N)>), (BOOL(M >= N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::range>, PAIR(M), LAMBDA(0), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::range>, LIST(M), VALUE(0), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::range>, LIST(M), NUMBER(0), NUMBER(N)>), (BOOL(M >= N))); \
     CHECK((metal::is_invocable<metal::lambda<metal::range>, LIST(M), PAIR(0), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::range>, LIST(M), LIST(0), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::range>, LIST(M), MAP(0), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::range>, LIST(M), LBD(0), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::range>, MAP(M), VAL(0), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::range>, MAP(M), NUM(0), NUM(N)>), (BOOL(M >= N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::range>, LIST(M), LAMBDA(0), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::range>, MAP(M), VALUE(0), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::range>, MAP(M), NUMBER(0), NUMBER(N)>), (BOOL(M >= N))); \
     CHECK((metal::is_invocable<metal::lambda<metal::range>, MAP(M), PAIR(0), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::range>, MAP(M), LIST(0), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::range>, MAP(M), MAP(0), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::range>, MAP(M), LBD(0), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::range>, LBD(M), VAL(0), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::range>, LBD(M), NUM(0), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::range>, LBD(M), PAIR(0), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::range>, LBD(M), LIST(0), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::range>, LBD(M), MAP(0), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::range>, LBD(M), LBD(0), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::range>, LBD(_), VAL(0), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::range>, LBD(_), NUM(0), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::range>, LBD(_), PAIR(0), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::range>, LBD(_), LIST(0), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::range>, LBD(_), MAP(0), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::range>, LBD(_), LBD(0), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::range>, LIST(INF), NUM(M), NUM(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::range>, MAP(INF), NUM(M), NUM(N)>), (TRUE)); \
-    CHECK((metal::range<LIST(M), NUM(0), NUM(M)>), (LIST(M))); \
-    CHECK((metal::range<LIST(M), NUM(M), NUM(0)>), (metal::list<RENUM(M, VAL)>)); \
-    CHECK((metal::range<LIST(INF), NUM(M), NUM(INC(M))>), (metal::list<VAL(M)>)); \
-    CHECK((metal::range<LIST(INF), NUM(INC(M)), NUM(M)>), (metal::list<VAL(M)>)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::range>, MAP(M), LAMBDA(0), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::range>, LAMBDA(M), VALUE(0), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::range>, LAMBDA(M), NUMBER(0), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::range>, LAMBDA(M), PAIR(0), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::range>, LAMBDA(M), LIST(0), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::range>, LAMBDA(M), MAP(0), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::range>, LAMBDA(M), LAMBDA(0), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::range>, LAMBDA(_), VALUE(0), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::range>, LAMBDA(_), NUMBER(0), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::range>, LAMBDA(_), PAIR(0), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::range>, LAMBDA(_), LIST(0), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::range>, LAMBDA(_), MAP(0), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::range>, LAMBDA(_), LAMBDA(0), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::range>, LIST(INF), NUMBER(M), NUMBER(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::range>, MAP(INF), NUMBER(M), NUMBER(N)>), (TRUE)); \
+    CHECK((metal::range<LIST(M), NUMBER(0), NUMBER(M)>), (LIST(M))); \
+    CHECK((metal::range<LIST(M), NUMBER(M), NUMBER(0)>), (metal::list<RENUM(M, VALUE)>)); \
+    CHECK((metal::range<LIST(INF), NUMBER(M), NUMBER(INC(M))>), (metal::list<VALUE(M)>)); \
+    CHECK((metal::range<LIST(INF), NUMBER(INC(M)), NUMBER(M)>), (metal::list<VALUE(M)>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/list/remove.cpp b/test/src/metal/list/remove.cpp
index a787f320..0086de5d 100644
--- a/test/src/metal/list/remove.cpp
+++ b/test/src/metal/list/remove.cpp
@@ -11,58 +11,58 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, VAL(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, VAL(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, VAL(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, VAL(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, VAL(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, VAL(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, VAL(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, NUM(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, NUM(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, NUM(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, NUM(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, NUM(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, NUM(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, NUM(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, PAIR(M), VAL(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, PAIR(M), NUM(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, VALUE(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, VALUE(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, VALUE(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, VALUE(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, VALUE(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, VALUE(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, VALUE(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, NUMBER(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, NUMBER(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, NUMBER(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, NUMBER(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, NUMBER(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, NUMBER(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, NUMBER(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, PAIR(M), VALUE(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, PAIR(M), NUMBER(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::remove>, PAIR(M), PAIR(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::remove>, PAIR(M), LIST(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::remove>, PAIR(M), MAP(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, PAIR(M), LBD(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, PAIR(M), LBD(_)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, LIST(M), VAL(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, LIST(M), NUM(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, PAIR(M), LAMBDA(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, PAIR(M), LAMBDA(_)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, LIST(M), VALUE(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, LIST(M), NUMBER(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::remove>, LIST(M), PAIR(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::remove>, LIST(M), LIST(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::remove>, LIST(M), MAP(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, LIST(M), LBD(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, LIST(M), LBD(_)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, MAP(M), VAL(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, MAP(M), NUM(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, LIST(M), LAMBDA(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, LIST(M), LAMBDA(_)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, MAP(M), VALUE(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, MAP(M), NUMBER(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::remove>, MAP(M), PAIR(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::remove>, MAP(M), LIST(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::remove>, MAP(M), MAP(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, MAP(M), LBD(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, MAP(M), LBD(_)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, LBD(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, LBD(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, LBD(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, LBD(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, LBD(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, LBD(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, LBD(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, LBD(_), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, LBD(_), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, LBD(_), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, LBD(_), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, LBD(_), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, LBD(_), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove>, LBD(_), LBD(_)>), (FALSE)); \
-    CHECK((metal::remove<PAIR(M), VAL(N)>), (std::conditional_t<M == N, metal::list<NUM(M)>, PAIR(M)>)); \
-    CHECK((metal::remove<PAIR(M), NUM(N)>), (std::conditional_t<M == N, metal::list<VAL(M)>, PAIR(M)>)); \
-    CHECK((metal::remove<metal::list<VALS(M) COMMA(AND(M, N)) ENUM(N, VAL FIX(M))>, VAL(M)>), (LIST(M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, MAP(M), LAMBDA(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, MAP(M), LAMBDA(_)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, LAMBDA(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, LAMBDA(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, LAMBDA(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, LAMBDA(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, LAMBDA(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, LAMBDA(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, LAMBDA(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, LAMBDA(_), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, LAMBDA(_), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, LAMBDA(_), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, LAMBDA(_), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, LAMBDA(_), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, LAMBDA(_), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove>, LAMBDA(_), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::remove<PAIR(M), VALUE(N)>), (std::conditional_t<M == N, metal::list<NUMBER(M)>, PAIR(M)>)); \
+    CHECK((metal::remove<PAIR(M), NUMBER(N)>), (std::conditional_t<M == N, metal::list<VALUE(M)>, PAIR(M)>)); \
+    CHECK((metal::remove<metal::list<VALUES(M) COMMA(AND(M, N)) ENUM(N, VALUE FIX(M))>, VALUE(M)>), (LIST(M))); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/list/remove_if.cpp b/test/src/metal/list/remove_if.cpp
index 7a3d2aab..6d6b97a3 100644
--- a/test/src/metal/list/remove_if.cpp
+++ b/test/src/metal/list/remove_if.cpp
@@ -12,58 +12,58 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, VAL(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, VAL(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, VAL(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, VAL(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, VAL(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, VAL(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, VAL(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, NUM(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, NUM(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, NUM(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, NUM(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, NUM(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, NUM(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, NUM(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, PAIR(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, PAIR(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, VALUE(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, VALUE(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, VALUE(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, VALUE(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, VALUE(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, VALUE(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, VALUE(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, NUMBER(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, NUMBER(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, NUMBER(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, NUMBER(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, NUMBER(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, NUMBER(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, NUMBER(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, PAIR(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, PAIR(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, PAIR(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, PAIR(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, PAIR(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, PAIR(M), LBD(N)>), (BOOL(N == 1))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, PAIR(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LIST(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LIST(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, PAIR(M), LAMBDA(N)>), (BOOL(N == 1))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, PAIR(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LIST(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LIST(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LIST(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LIST(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LIST(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LIST(M), LBD(N)>), (BOOL(!M || N == 1))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LIST(M), LBD(_)>), (BOOL(!M))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, MAP(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, MAP(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LIST(M), LAMBDA(N)>), (BOOL(!M || N == 1))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LIST(M), LAMBDA(_)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, MAP(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, MAP(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, MAP(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, MAP(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, MAP(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, MAP(M), LBD(N)>), (BOOL(!M || N == 1))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, MAP(M), LBD(_)>), (BOOL(!M))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LBD(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LBD(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LBD(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LBD(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LBD(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LBD(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LBD(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LBD(_), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LBD(_), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LBD(_), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LBD(_), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LBD(_), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LBD(_), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LBD(_), LBD(_)>), (FALSE)); \
-    CHECK((metal::remove_if<metal::list<ENUM(M, FWD, NUM, PAIR, LBD)>, metal::lambda<metal::is_number>>), (metal::list<ENUM(M, FWD, PAIR, LBD)>)); \
-    CHECK((metal::remove_if<metal::list<ENUM(M, FWD, NUM, PAIR, LBD)>, metal::lambda<metal::is_pair>>), (metal::list<ENUM(M, FWD, NUM, LBD)>)); \
-    CHECK((metal::remove_if<metal::list<ENUM(M, FWD, NUM, PAIR, LBD)>, metal::lambda<metal::is_lambda>>), (metal::list<ENUM(M, FWD, NUM, PAIR)>)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, MAP(M), LAMBDA(N)>), (BOOL(!M || N == 1))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, MAP(M), LAMBDA(_)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LAMBDA(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LAMBDA(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LAMBDA(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LAMBDA(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LAMBDA(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LAMBDA(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LAMBDA(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LAMBDA(_), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LAMBDA(_), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LAMBDA(_), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LAMBDA(_), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LAMBDA(_), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LAMBDA(_), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::remove_if>, LAMBDA(_), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::remove_if<metal::list<ENUM(M, FWD, NUMBER, PAIR, LAMBDA)>, metal::lambda<metal::is_number>>), (metal::list<ENUM(M, FWD, PAIR, LAMBDA)>)); \
+    CHECK((metal::remove_if<metal::list<ENUM(M, FWD, NUMBER, PAIR, LAMBDA)>, metal::lambda<metal::is_pair>>), (metal::list<ENUM(M, FWD, NUMBER, LAMBDA)>)); \
+    CHECK((metal::remove_if<metal::list<ENUM(M, FWD, NUMBER, PAIR, LAMBDA)>, metal::lambda<metal::is_lambda>>), (metal::list<ENUM(M, FWD, NUMBER, PAIR)>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/list/replace.cpp b/test/src/metal/list/replace.cpp
index 80f4145e..7a59d43c 100644
--- a/test/src/metal/list/replace.cpp
+++ b/test/src/metal/list/replace.cpp
@@ -11,58 +11,58 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, VAL(M), VAL(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, VAL(M), NUM(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, VAL(M), PAIR(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, VAL(M), LIST(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, VAL(M), MAP(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, VAL(M), LBD(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, VAL(M), LBD(_), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, NUM(M), VAL(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, NUM(M), NUM(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, NUM(M), PAIR(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, NUM(M), LIST(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, NUM(M), MAP(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, NUM(M), LBD(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, NUM(M), LBD(_), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, PAIR(M), VAL(N), VAL(M)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, PAIR(M), NUM(N), VAL(M)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, PAIR(M), PAIR(N), VAL(M)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, PAIR(M), LIST(N), VAL(M)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, PAIR(M), MAP(N), VAL(M)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, PAIR(M), LBD(N), VAL(M)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, PAIR(M), LBD(_), VAL(M)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LIST(M), VAL(N), VAL(M)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LIST(M), NUM(N), VAL(M)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LIST(M), PAIR(N), VAL(M)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LIST(M), LIST(N), VAL(M)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LIST(M), MAP(N), VAL(M)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LIST(M), LBD(N), VAL(M)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LIST(M), LBD(_), VAL(M)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, MAP(M), VAL(N), VAL(M)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, MAP(M), NUM(N), VAL(M)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, MAP(M), PAIR(N), VAL(M)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, MAP(M), LIST(N), VAL(M)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, MAP(M), MAP(N), VAL(M)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, MAP(M), LBD(N), VAL(M)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, MAP(M), LBD(_), VAL(M)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LBD(M), VAL(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LBD(M), NUM(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LBD(M), PAIR(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LBD(M), LIST(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LBD(M), MAP(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LBD(M), LBD(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LBD(M), LBD(_), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LBD(_), VAL(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LBD(_), NUM(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LBD(_), PAIR(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LBD(_), LIST(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LBD(_), MAP(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LBD(_), LBD(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LBD(_), LBD(_), VAL(M)>), (FALSE)); \
-    CHECK((metal::replace<PAIR(M), VAL(N), NUM(N)>), (metal::list<NUM(M), std::conditional_t<M == N, NUM(N), VAL(M)>>)); \
-    CHECK((metal::replace<PAIR(M), NUM(N), VAL(N)>), (metal::list<std::conditional_t<M == N, VAL(N), NUM(M)>, VAL(M)>)); \
-    CHECK((metal::replace<metal::list<VALS(M) COMMA(AND(M, CMPL(M))) ENUM(CMPL(M), NUM FIX(N))>, NUM(N), VAL(N)>), (metal::list<VALS(M) COMMA(AND(M, CMPL(M))) ENUM(CMPL(M), VAL FIX(N))>)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, VALUE(M), VALUE(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, VALUE(M), NUMBER(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, VALUE(M), PAIR(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, VALUE(M), LIST(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, VALUE(M), MAP(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, VALUE(M), LAMBDA(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, VALUE(M), LAMBDA(_), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, NUMBER(M), VALUE(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, NUMBER(M), NUMBER(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, NUMBER(M), PAIR(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, NUMBER(M), LIST(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, NUMBER(M), MAP(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, NUMBER(M), LAMBDA(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, NUMBER(M), LAMBDA(_), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, PAIR(M), VALUE(N), VALUE(M)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, PAIR(M), NUMBER(N), VALUE(M)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, PAIR(M), PAIR(N), VALUE(M)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, PAIR(M), LIST(N), VALUE(M)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, PAIR(M), MAP(N), VALUE(M)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, PAIR(M), LAMBDA(N), VALUE(M)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, PAIR(M), LAMBDA(_), VALUE(M)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LIST(M), VALUE(N), VALUE(M)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LIST(M), NUMBER(N), VALUE(M)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LIST(M), PAIR(N), VALUE(M)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LIST(M), LIST(N), VALUE(M)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LIST(M), MAP(N), VALUE(M)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LIST(M), LAMBDA(N), VALUE(M)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LIST(M), LAMBDA(_), VALUE(M)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, MAP(M), VALUE(N), VALUE(M)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, MAP(M), NUMBER(N), VALUE(M)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, MAP(M), PAIR(N), VALUE(M)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, MAP(M), LIST(N), VALUE(M)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, MAP(M), MAP(N), VALUE(M)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, MAP(M), LAMBDA(N), VALUE(M)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, MAP(M), LAMBDA(_), VALUE(M)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LAMBDA(M), VALUE(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LAMBDA(M), NUMBER(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LAMBDA(M), PAIR(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LAMBDA(M), LIST(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LAMBDA(M), MAP(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LAMBDA(M), LAMBDA(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LAMBDA(M), LAMBDA(_), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LAMBDA(_), VALUE(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LAMBDA(_), NUMBER(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LAMBDA(_), PAIR(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LAMBDA(_), LIST(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LAMBDA(_), MAP(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LAMBDA(_), LAMBDA(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace>, LAMBDA(_), LAMBDA(_), VALUE(M)>), (FALSE)); \
+    CHECK((metal::replace<PAIR(M), VALUE(N), NUMBER(N)>), (metal::list<NUMBER(M), std::conditional_t<M == N, NUMBER(N), VALUE(M)>>)); \
+    CHECK((metal::replace<PAIR(M), NUMBER(N), VALUE(N)>), (metal::list<std::conditional_t<M == N, VALUE(N), NUMBER(M)>, VALUE(M)>)); \
+    CHECK((metal::replace<metal::list<VALUES(M) COMMA(AND(M, CMPL(M))) ENUM(CMPL(M), NUMBER FIX(N))>, NUMBER(N), VALUE(N)>), (metal::list<VALUES(M) COMMA(AND(M, CMPL(M))) ENUM(CMPL(M), VALUE FIX(N))>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/list/replace_if.cpp b/test/src/metal/list/replace_if.cpp
index b8ea8ae3..942f93fa 100644
--- a/test/src/metal/list/replace_if.cpp
+++ b/test/src/metal/list/replace_if.cpp
@@ -12,67 +12,67 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, VAL(M), VAL(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, VAL(M), NUM(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, VAL(M), PAIR(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, VAL(M), LIST(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, VAL(M), MAP(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, VAL(M), LBD(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, VAL(M), LBD(_), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, NUM(M), VAL(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, NUM(M), NUM(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, NUM(M), PAIR(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, NUM(M), LIST(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, NUM(M), MAP(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, NUM(M), LBD(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, NUM(M), LBD(_), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, PAIR(M), VAL(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, PAIR(M), NUM(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, PAIR(M), PAIR(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, PAIR(M), LIST(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, PAIR(M), MAP(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, PAIR(M), LBD(N), VAL(M)>), (BOOL(N == 1))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, PAIR(M), LBD(_), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LIST(M), VAL(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LIST(M), NUM(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LIST(M), PAIR(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LIST(M), LIST(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LIST(M), MAP(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LIST(M), LBD(N), VAL(M)>), (BOOL(!M || N == 1))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LIST(M), LBD(_), VAL(M)>), (BOOL(!M))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, MAP(M), VAL(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, MAP(M), NUM(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, MAP(M), PAIR(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, MAP(M), LIST(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, MAP(M), MAP(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, MAP(M), LBD(N), VAL(M)>), (BOOL(!M || N == 1))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, MAP(M), LBD(_), VAL(M)>), (BOOL(!M))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LBD(M), VAL(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LBD(M), NUM(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LBD(M), PAIR(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LBD(M), LIST(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LBD(M), MAP(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LBD(M), LBD(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LBD(M), LBD(_), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LBD(_), VAL(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LBD(_), NUM(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LBD(_), PAIR(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LBD(_), LIST(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LBD(_), MAP(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LBD(_), LBD(N), VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LBD(_), LBD(_), VAL(M)>), (FALSE)); \
-    CHECK((metal::replace_if<PAIR(M), metal::lambda<metal::is_number>, VAL(N)>), (metal::list<VAL(N), VAL(M)>)); \
-    CHECK((metal::replace_if<LIST(M), metal::lambda<metal::is_number>, VAL(N)>), (LIST(M))); \
-    CHECK((metal::replace_if<MAP(M), metal::lambda<metal::is_number>, VAL(N)>), (MAP(M))); \
-    CHECK((metal::replace_if<PAIR(M), metal::lambda<metal::is_pair>, VAL(N)>), (PAIR(M))); \
-    CHECK((metal::replace_if<LIST(M), metal::lambda<metal::is_pair>, VAL(N)>), (LIST(M))); \
-    CHECK((metal::replace_if<MAP(M), metal::lambda<metal::is_pair>, VAL(N)>), (metal::list<ENUM(M, VAL FIX(N))>)); \
-    CHECK((metal::replace_if<PAIR(M), metal::lambda<metal::is_lambda>, VAL(N)>), (PAIR(M))); \
-    CHECK((metal::replace_if<LIST(M), metal::lambda<metal::is_lambda>, VAL(N)>), (LIST(M))); \
-    CHECK((metal::replace_if<MAP(M), metal::lambda<metal::is_lambda>, VAL(N)>), (MAP(M))); \
-    CHECK((metal::replace_if<metal::list<ENUM(M, FWD, NUM, PAIR, LBD)>, metal::lambda<metal::is_number>, VAL(N)>), (metal::list<ENUM(M, FWD, VAL(N) NIL, PAIR, LBD)>)); \
-    CHECK((metal::replace_if<metal::list<ENUM(M, FWD, NUM, PAIR, LBD)>, metal::lambda<metal::is_pair>, VAL(N)>), (metal::list<ENUM(M, FWD, NUM, VAL(N) NIL, LBD)>)); \
-    CHECK((metal::replace_if<metal::list<ENUM(M, FWD, NUM, PAIR, LBD)>, metal::lambda<metal::is_lambda>, VAL(N)>), (metal::list<ENUM(M, FWD, NUM, PAIR, VAL(N) NIL)>)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, VALUE(M), VALUE(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, VALUE(M), NUMBER(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, VALUE(M), PAIR(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, VALUE(M), LIST(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, VALUE(M), MAP(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, VALUE(M), LAMBDA(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, VALUE(M), LAMBDA(_), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, NUMBER(M), VALUE(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, NUMBER(M), NUMBER(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, NUMBER(M), PAIR(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, NUMBER(M), LIST(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, NUMBER(M), MAP(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, NUMBER(M), LAMBDA(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, NUMBER(M), LAMBDA(_), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, PAIR(M), VALUE(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, PAIR(M), NUMBER(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, PAIR(M), PAIR(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, PAIR(M), LIST(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, PAIR(M), MAP(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, PAIR(M), LAMBDA(N), VALUE(M)>), (BOOL(N == 1))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, PAIR(M), LAMBDA(_), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LIST(M), VALUE(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LIST(M), NUMBER(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LIST(M), PAIR(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LIST(M), LIST(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LIST(M), MAP(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LIST(M), LAMBDA(N), VALUE(M)>), (BOOL(!M || N == 1))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LIST(M), LAMBDA(_), VALUE(M)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, MAP(M), VALUE(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, MAP(M), NUMBER(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, MAP(M), PAIR(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, MAP(M), LIST(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, MAP(M), MAP(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, MAP(M), LAMBDA(N), VALUE(M)>), (BOOL(!M || N == 1))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, MAP(M), LAMBDA(_), VALUE(M)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LAMBDA(M), VALUE(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LAMBDA(M), NUMBER(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LAMBDA(M), PAIR(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LAMBDA(M), LIST(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LAMBDA(M), MAP(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LAMBDA(M), LAMBDA(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LAMBDA(M), LAMBDA(_), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LAMBDA(_), VALUE(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LAMBDA(_), NUMBER(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LAMBDA(_), PAIR(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LAMBDA(_), LIST(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LAMBDA(_), MAP(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LAMBDA(_), LAMBDA(N), VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::replace_if>, LAMBDA(_), LAMBDA(_), VALUE(M)>), (FALSE)); \
+    CHECK((metal::replace_if<PAIR(M), metal::lambda<metal::is_number>, VALUE(N)>), (metal::list<VALUE(N), VALUE(M)>)); \
+    CHECK((metal::replace_if<LIST(M), metal::lambda<metal::is_number>, VALUE(N)>), (LIST(M))); \
+    CHECK((metal::replace_if<MAP(M), metal::lambda<metal::is_number>, VALUE(N)>), (MAP(M))); \
+    CHECK((metal::replace_if<PAIR(M), metal::lambda<metal::is_pair>, VALUE(N)>), (PAIR(M))); \
+    CHECK((metal::replace_if<LIST(M), metal::lambda<metal::is_pair>, VALUE(N)>), (LIST(M))); \
+    CHECK((metal::replace_if<MAP(M), metal::lambda<metal::is_pair>, VALUE(N)>), (metal::list<ENUM(M, VALUE FIX(N))>)); \
+    CHECK((metal::replace_if<PAIR(M), metal::lambda<metal::is_lambda>, VALUE(N)>), (PAIR(M))); \
+    CHECK((metal::replace_if<LIST(M), metal::lambda<metal::is_lambda>, VALUE(N)>), (LIST(M))); \
+    CHECK((metal::replace_if<MAP(M), metal::lambda<metal::is_lambda>, VALUE(N)>), (MAP(M))); \
+    CHECK((metal::replace_if<metal::list<ENUM(M, FWD, NUMBER, PAIR, LAMBDA)>, metal::lambda<metal::is_number>, VALUE(N)>), (metal::list<ENUM(M, FWD, VALUE(N) NIL, PAIR, LAMBDA)>)); \
+    CHECK((metal::replace_if<metal::list<ENUM(M, FWD, NUMBER, PAIR, LAMBDA)>, metal::lambda<metal::is_pair>, VALUE(N)>), (metal::list<ENUM(M, FWD, NUMBER, VALUE(N) NIL, LAMBDA)>)); \
+    CHECK((metal::replace_if<metal::list<ENUM(M, FWD, NUMBER, PAIR, LAMBDA)>, metal::lambda<metal::is_lambda>, VALUE(N)>), (metal::list<ENUM(M, FWD, NUMBER, PAIR, VALUE(N) NIL)>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/list/reverse.cpp b/test/src/metal/list/reverse.cpp
index 5d6afd1e..f1703991 100644
--- a/test/src/metal/list/reverse.cpp
+++ b/test/src/metal/list/reverse.cpp
@@ -12,17 +12,17 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::reverse>, VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::reverse>, NUM(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::reverse>, VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::reverse>, NUMBER(M)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::reverse>, PAIR(M)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::reverse>, LIST(M)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::reverse>, MAP(M)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::reverse>, LBD(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::reverse>, LBD(_)>), (FALSE)); \
-    CHECK((metal::reverse<PAIR(M)>), (metal::list<VAL(M), NUM(M)>)); \
-    CHECK((metal::reverse<LIST(M)>), (metal::list<RENUM(M, VAL)>)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::reverse>, LAMBDA(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::reverse>, LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::reverse<PAIR(M)>), (metal::list<VALUE(M), NUMBER(M)>)); \
+    CHECK((metal::reverse<LIST(M)>), (metal::list<RENUM(M, VALUE)>)); \
     CHECK((metal::reverse<MAP(M)>), (metal::list<RENUM(M, PAIR)>)); \
-    CHECK((metal::reverse<metal::enumerate<NUM(0), metal::number<100*M>, NUM(N)>>), (metal::enumerate<metal::number<(100*M - 1)*N>, metal::number<-100*M>, NUM(N)>)); \
+    CHECK((metal::reverse<metal::enumerate<NUMBER(0), metal::number<100*M>, NUMBER(N)>>), (metal::enumerate<metal::number<(100*M - 1)*N>, metal::number<-100*M>, NUMBER(N)>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/list/rotate.cpp b/test/src/metal/list/rotate.cpp
index 017cf602..5ed16207 100644
--- a/test/src/metal/list/rotate.cpp
+++ b/test/src/metal/list/rotate.cpp
@@ -12,59 +12,59 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, VAL(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, VAL(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, VAL(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, VAL(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, VAL(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, VAL(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, VAL(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, NUM(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, NUM(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, NUM(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, NUM(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, NUM(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, NUM(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, NUM(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, PAIR(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, PAIR(M), NUM(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, VALUE(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, VALUE(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, VALUE(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, VALUE(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, VALUE(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, VALUE(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, VALUE(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, NUMBER(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, NUMBER(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, NUMBER(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, NUMBER(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, NUMBER(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, NUMBER(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, NUMBER(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, PAIR(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, PAIR(M), NUMBER(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::rotate>, PAIR(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::rotate>, PAIR(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::rotate>, PAIR(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, PAIR(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, PAIR(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LIST(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LIST(M), NUM(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, PAIR(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, PAIR(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LIST(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LIST(M), NUMBER(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LIST(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LIST(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LIST(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LIST(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LIST(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, MAP(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, MAP(M), NUM(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LIST(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LIST(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, MAP(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, MAP(M), NUMBER(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::rotate>, MAP(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::rotate>, MAP(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::rotate>, MAP(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, MAP(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, MAP(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LBD(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LBD(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LBD(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LBD(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LBD(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LBD(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LBD(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LBD(_), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LBD(_), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LBD(_), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LBD(_), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LBD(_), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LBD(_), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LBD(_), LBD(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, MAP(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, MAP(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LAMBDA(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LAMBDA(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LAMBDA(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LAMBDA(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LAMBDA(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LAMBDA(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LAMBDA(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LAMBDA(_), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LAMBDA(_), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LAMBDA(_), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LAMBDA(_), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LAMBDA(_), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LAMBDA(_), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::rotate>, LAMBDA(_), LAMBDA(_)>), (FALSE)); \
     CHECK((metal::rotate<LIST(M), metal::number<M*N>>), (LIST(M))); \
     CHECK((metal::rotate<LIST(INF), metal::number<M + N*INF>>), (metal::rotate<LIST(INF), metal::number<M - N*INF>>)); \
-    CHECK((metal::rotate<metal::list<VALS(M) COMMA(AND(M, N)) VALS(N)>, NUM(M)>), (metal::list<VALS(N) COMMA(AND(M, N)) VALS(M)>)); \
-    CHECK((metal::rotate<metal::rotate<metal::enumerate<NUM(0), metal::number<100*M>>, metal::number<100*N>>, metal::number<-100*N>>), (metal::enumerate<NUM(0), metal::number<100*M>>)); \
+    CHECK((metal::rotate<metal::list<VALUES(M) COMMA(AND(M, N)) VALUES(N)>, NUMBER(M)>), (metal::list<VALUES(N) COMMA(AND(M, N)) VALUES(M)>)); \
+    CHECK((metal::rotate<metal::rotate<metal::enumerate<NUMBER(0), metal::number<100*M>>, metal::number<100*N>>, metal::number<-100*N>>), (metal::enumerate<NUMBER(0), metal::number<100*M>>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/list/size.cpp b/test/src/metal/list/size.cpp
index 233b1225..c748b8c4 100644
--- a/test/src/metal/list/size.cpp
+++ b/test/src/metal/list/size.cpp
@@ -11,18 +11,18 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::size>, VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::size>, NUM(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::size>, VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::size>, NUMBER(M)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::size>, PAIR(M)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::size>, LIST(M)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::size>, MAP(M)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::size>, LBD(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::size>, LBD(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::size>, LAMBDA(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::size>, LAMBDA(_)>), (FALSE)); \
     CHECK((metal::size<PAIR(M)>), (metal::number<2>)); \
     CHECK((metal::size<LIST(M)>), (metal::number<M>)); \
     CHECK((metal::size<MAP(M)>), (metal::number<M>)); \
-    CHECK((metal::size<metal::list<VALS(M) COMMA(AND(M, N)) VALS(N)>>), (metal::number<M + N>)); \
-    CHECK((metal::size<metal::list<ENUM(M, VAL FIX(N))>>), (metal::number<M>)); \
+    CHECK((metal::size<metal::list<VALUES(M) COMMA(AND(M, N)) VALUES(N)>>), (metal::number<M + N>)); \
+    CHECK((metal::size<metal::list<ENUM(M, VALUE FIX(N))>>), (metal::number<M>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/list/slice.cpp b/test/src/metal/list/slice.cpp
index 37b7946c..fe8a2b7a 100644
--- a/test/src/metal/list/slice.cpp
+++ b/test/src/metal/list/slice.cpp
@@ -11,58 +11,58 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, VAL(M), VAL(0), VAL(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, VAL(M), NUM(0), NUM(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, VAL(M), PAIR(0), PAIR(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, VAL(M), LIST(0), LIST(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, VAL(M), MAP(0), MAP(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, VAL(M), LBD(0), LBD(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, VAL(M), LBD(M), LBD(_), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, NUM(M), VAL(0), VAL(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, NUM(M), NUM(0), NUM(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, NUM(M), PAIR(0), PAIR(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, NUM(M), LIST(0), LIST(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, NUM(M), MAP(0), MAP(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, NUM(M), LBD(0), LBD(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, NUM(M), LBD(M), LBD(_), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, PAIR(M), VAL(0), VAL(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, PAIR(M), NUM(0), NUM(N), NUM(1)>), (BOOL(N < 3))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, PAIR(M), PAIR(0), PAIR(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, PAIR(M), LIST(0), LIST(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, PAIR(M), MAP(0), MAP(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, PAIR(M), LBD(0), LBD(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, PAIR(M), LBD(M), LBD(_), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LIST(M), VAL(0), VAL(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LIST(M), NUM(0), NUM(N), NUM(1)>), (BOOL(M >= N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LIST(M), PAIR(0), PAIR(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LIST(M), LIST(0), LIST(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LIST(M), MAP(0), MAP(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LIST(M), LBD(0), LBD(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LIST(M), LBD(M), LBD(_), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, MAP(M), VAL(0), VAL(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, MAP(M), NUM(0), NUM(N), NUM(1)>), (BOOL(M >= N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, MAP(M), PAIR(0), PAIR(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, MAP(M), LIST(0), LIST(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, MAP(M), MAP(0), MAP(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, MAP(M), LBD(0), LBD(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, MAP(M), LBD(M), LBD(_), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LBD(M), VAL(0), VAL(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LBD(M), NUM(0), NUM(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LBD(M), PAIR(0), PAIR(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LBD(M), LIST(0), LIST(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LBD(M), MAP(0), MAP(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LBD(M), LBD(0), LBD(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LBD(M), LBD(M), LBD(_), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LBD(_), VAL(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LBD(_), NUM(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LBD(_), PAIR(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LBD(_), LIST(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LBD(_), MAP(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LBD(_), LBD(N), NUM(1)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LBD(_), LBD(_), NUM(1)>), (FALSE)); \
-    CHECK((metal::slice<LIST(INF), NUM(0), NUM(M)>), (LIST(M))); \
-    CHECK((metal::slice<LIST(INF), NUM(M), NUM(N), NUM(0)>), (metal::list<ENUM(N, VAL FIX(M))>)); \
-    CHECK((metal::slice<LIST(INF), NUM(M), NUM(M), metal::number<-1>>), (metal::list<RENUM(M, VAL LIFT(INC))>)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, VALUE(M), VALUE(0), VALUE(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, VALUE(M), NUMBER(0), NUMBER(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, VALUE(M), PAIR(0), PAIR(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, VALUE(M), LIST(0), LIST(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, VALUE(M), MAP(0), MAP(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, VALUE(M), LAMBDA(0), LAMBDA(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, VALUE(M), LAMBDA(M), LAMBDA(_), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, NUMBER(M), VALUE(0), VALUE(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, NUMBER(M), NUMBER(0), NUMBER(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, NUMBER(M), PAIR(0), PAIR(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, NUMBER(M), LIST(0), LIST(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, NUMBER(M), MAP(0), MAP(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, NUMBER(M), LAMBDA(0), LAMBDA(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, NUMBER(M), LAMBDA(M), LAMBDA(_), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, PAIR(M), VALUE(0), VALUE(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, PAIR(M), NUMBER(0), NUMBER(N), NUMBER(1)>), (BOOL(N < 3))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, PAIR(M), PAIR(0), PAIR(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, PAIR(M), LIST(0), LIST(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, PAIR(M), MAP(0), MAP(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, PAIR(M), LAMBDA(0), LAMBDA(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, PAIR(M), LAMBDA(M), LAMBDA(_), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LIST(M), VALUE(0), VALUE(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LIST(M), NUMBER(0), NUMBER(N), NUMBER(1)>), (BOOL(M >= N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LIST(M), PAIR(0), PAIR(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LIST(M), LIST(0), LIST(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LIST(M), MAP(0), MAP(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LIST(M), LAMBDA(0), LAMBDA(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LIST(M), LAMBDA(M), LAMBDA(_), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, MAP(M), VALUE(0), VALUE(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, MAP(M), NUMBER(0), NUMBER(N), NUMBER(1)>), (BOOL(M >= N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, MAP(M), PAIR(0), PAIR(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, MAP(M), LIST(0), LIST(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, MAP(M), MAP(0), MAP(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, MAP(M), LAMBDA(0), LAMBDA(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, MAP(M), LAMBDA(M), LAMBDA(_), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LAMBDA(M), VALUE(0), VALUE(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LAMBDA(M), NUMBER(0), NUMBER(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LAMBDA(M), PAIR(0), PAIR(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LAMBDA(M), LIST(0), LIST(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LAMBDA(M), MAP(0), MAP(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LAMBDA(M), LAMBDA(0), LAMBDA(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LAMBDA(M), LAMBDA(M), LAMBDA(_), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LAMBDA(_), VALUE(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LAMBDA(_), NUMBER(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LAMBDA(_), PAIR(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LAMBDA(_), LIST(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LAMBDA(_), MAP(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LAMBDA(_), LAMBDA(N), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::slice>, LAMBDA(_), LAMBDA(_), NUMBER(1)>), (FALSE)); \
+    CHECK((metal::slice<LIST(INF), NUMBER(0), NUMBER(M)>), (LIST(M))); \
+    CHECK((metal::slice<LIST(INF), NUMBER(M), NUMBER(N), NUMBER(0)>), (metal::list<ENUM(N, VALUE FIX(M))>)); \
+    CHECK((metal::slice<LIST(INF), NUMBER(M), NUMBER(M), metal::number<-1>>), (metal::list<RENUM(M, VALUE LIFT(INC))>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/list/sort.cpp b/test/src/metal/list/sort.cpp
index 57fe69c4..7391aa38 100644
--- a/test/src/metal/list/sort.cpp
+++ b/test/src/metal/list/sort.cpp
@@ -13,57 +13,57 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, VAL(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, VAL(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, VAL(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, VAL(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, VAL(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, VAL(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, NUM(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, NUM(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, NUM(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, NUM(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, NUM(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, NUM(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, NUM(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, PAIR(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, PAIR(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, VALUE(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, VALUE(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, VALUE(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, VALUE(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, VALUE(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, VALUE(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, NUMBER(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, NUMBER(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, NUMBER(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, NUMBER(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, NUMBER(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, NUMBER(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, NUMBER(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, PAIR(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, PAIR(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::sort>, PAIR(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::sort>, PAIR(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::sort>, PAIR(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, PAIR(M), LBD(N)>), (BOOL(N == 2))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, PAIR(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, LIST(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, LIST(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, PAIR(M), LAMBDA(N)>), (BOOL(N == 2))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, PAIR(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, LIST(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, LIST(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::sort>, LIST(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::sort>, LIST(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::sort>, LIST(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, LIST(M), LBD(N)>), (BOOL(N == 2 || M < 2))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, LIST(M), LBD(_)>), (BOOL(M < 2))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, MAP(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, MAP(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, LIST(M), LAMBDA(N)>), (BOOL(N == 2 || M < 2))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, LIST(M), LAMBDA(_)>), (BOOL(M < 2))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, MAP(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, MAP(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::sort>, MAP(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::sort>, MAP(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::sort>, MAP(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, MAP(M), LBD(N)>), (BOOL(N == 2 || M < 2))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, MAP(M), LBD(_)>), (BOOL(M < 2))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, LBD(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, LBD(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, LBD(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, LBD(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, LBD(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, LBD(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, LBD(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, LBD(_), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, LBD(_), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, LBD(_), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, LBD(_), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, LBD(_), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, LBD(_), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sort>, LBD(_), LBD(_)>), (FALSE)); \
-    CHECK((metal::sort<metal::list<NUMS(M)>, metal::lambda<metal::greater>>), (metal::list<RENUM(M, NUM)>)); \
-    CHECK((metal::sort<metal::list<NUMS(M)>, metal::lambda<metal::less>>), (metal::list<NUMS(M)>)); \
-    CHECK((metal::sort<metal::list<ENUM(INC(N), NUMS FIX(INC(M)))>, metal::lambda<metal::less>>), (metal::list<ENUM(INC(M), FWD, RENUM(INC(N), NUM NIL))>)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, MAP(M), LAMBDA(N)>), (BOOL(N == 2 || M < 2))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, MAP(M), LAMBDA(_)>), (BOOL(M < 2))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, LAMBDA(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, LAMBDA(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, LAMBDA(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, LAMBDA(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, LAMBDA(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, LAMBDA(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, LAMBDA(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, LAMBDA(_), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, LAMBDA(_), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, LAMBDA(_), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, LAMBDA(_), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, LAMBDA(_), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, LAMBDA(_), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sort>, LAMBDA(_), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::sort<metal::list<NUMBERS(M)>, metal::lambda<metal::greater>>), (metal::list<RENUM(M, NUMBER)>)); \
+    CHECK((metal::sort<metal::list<NUMBERS(M)>, metal::lambda<metal::less>>), (metal::list<NUMBERS(M)>)); \
+    CHECK((metal::sort<metal::list<ENUM(INC(N), NUMBERS FIX(INC(M)))>, metal::lambda<metal::less>>), (metal::list<ENUM(INC(M), FWD, RENUM(INC(N), NUMBER NIL))>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/list/splice.cpp b/test/src/metal/list/splice.cpp
index 30a267b3..fb7401bd 100644
--- a/test/src/metal/list/splice.cpp
+++ b/test/src/metal/list/splice.cpp
@@ -11,56 +11,56 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, VAL(M), VAL(N), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, VAL(M), NUM(N), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, VAL(M), PAIR(N), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, VAL(M), LIST(N), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, VAL(M), MAP(N), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, VAL(M), LBD(N), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, VAL(M), LBD(_), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, NUM(M), VAL(N), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, NUM(M), NUM(N), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, NUM(M), PAIR(N), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, NUM(M), LIST(N), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, NUM(M), MAP(N), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, NUM(M), LBD(N), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, NUM(M), LBD(_), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, PAIR(M), VAL(N), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, PAIR(M), NUM(N), PAIR(N)>), (BOOL(N < 3))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, VALUE(M), VALUE(N), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, VALUE(M), NUMBER(N), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, VALUE(M), PAIR(N), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, VALUE(M), LIST(N), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, VALUE(M), MAP(N), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, VALUE(M), LAMBDA(N), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, VALUE(M), LAMBDA(_), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, NUMBER(M), VALUE(N), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, NUMBER(M), NUMBER(N), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, NUMBER(M), PAIR(N), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, NUMBER(M), LIST(N), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, NUMBER(M), MAP(N), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, NUMBER(M), LAMBDA(N), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, NUMBER(M), LAMBDA(_), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, PAIR(M), VALUE(N), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, PAIR(M), NUMBER(N), PAIR(N)>), (BOOL(N < 3))); \
     CHECK((metal::is_invocable<metal::lambda<metal::splice>, PAIR(M), PAIR(N), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::splice>, PAIR(M), LIST(N), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::splice>, PAIR(M), MAP(N), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, PAIR(M), LBD(N), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, PAIR(M), LBD(_), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, LIST(M), VAL(N), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, LIST(M), NUM(N), LIST(N)>), (BOOL(M >= N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, PAIR(M), LAMBDA(N), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, PAIR(M), LAMBDA(_), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, LIST(M), VALUE(N), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, LIST(M), NUMBER(N), LIST(N)>), (BOOL(M >= N))); \
     CHECK((metal::is_invocable<metal::lambda<metal::splice>, LIST(M), PAIR(N), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::splice>, LIST(M), LIST(N), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::splice>, LIST(M), MAP(N), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, LIST(M), LBD(N), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, LIST(M), LBD(_), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, MAP(M), VAL(N), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, MAP(M), NUM(N), MAP(N)>), (BOOL(M >= N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, LIST(M), LAMBDA(N), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, LIST(M), LAMBDA(_), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, MAP(M), VALUE(N), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, MAP(M), NUMBER(N), MAP(N)>), (BOOL(M >= N))); \
     CHECK((metal::is_invocable<metal::lambda<metal::splice>, MAP(M), PAIR(N), MAP(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::splice>, MAP(M), LIST(N), MAP(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::splice>, MAP(M), MAP(N), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, MAP(M), LBD(N), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, MAP(M), LBD(_), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, LBD(M), VAL(N), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, LBD(M), NUM(N), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, LBD(M), PAIR(N), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, LBD(M), LIST(N), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, LBD(M), MAP(N), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, LBD(M), LBD(N), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, LBD(M), LBD(_), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, LBD(_), VAL(N), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, LBD(_), NUM(N), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, LBD(_), PAIR(N), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, LBD(_), LIST(N), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, LBD(_), MAP(N), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, LBD(_), LBD(N), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::splice>, LBD(_), LBD(_), LBD(N)>), (FALSE)); \
-    CHECK((metal::splice<metal::list<VALS(M) COMMA(AND(M, CMPL(M))) VALS(CMPL(M))>, NUM(M), PAIR(N)>), (metal::list<VALS(M) COMMA(M) NUM(N), VAL(N) COMMA(CMPL(M)) VALS(CMPL(M))>)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, MAP(M), LAMBDA(N), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, MAP(M), LAMBDA(_), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, LAMBDA(M), VALUE(N), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, LAMBDA(M), NUMBER(N), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, LAMBDA(M), PAIR(N), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, LAMBDA(M), LIST(N), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, LAMBDA(M), MAP(N), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, LAMBDA(M), LAMBDA(N), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, LAMBDA(M), LAMBDA(_), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, LAMBDA(_), VALUE(N), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, LAMBDA(_), NUMBER(N), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, LAMBDA(_), PAIR(N), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, LAMBDA(_), LIST(N), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, LAMBDA(_), MAP(N), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, LAMBDA(_), LAMBDA(N), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::splice>, LAMBDA(_), LAMBDA(_), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::splice<metal::list<VALUES(M) COMMA(AND(M, CMPL(M))) VALUES(CMPL(M))>, NUMBER(M), PAIR(N)>), (metal::list<VALUES(M) COMMA(M) NUMBER(N), VALUE(N) COMMA(CMPL(M)) VALUES(CMPL(M))>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/list/take.cpp b/test/src/metal/list/take.cpp
index fe80c6b7..4a3af364 100644
--- a/test/src/metal/list/take.cpp
+++ b/test/src/metal/list/take.cpp
@@ -11,56 +11,56 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, VAL(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, VAL(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, VAL(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, VAL(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, VAL(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, VAL(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, VAL(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, NUM(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, NUM(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, NUM(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, NUM(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, NUM(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, NUM(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, NUM(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, PAIR(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, PAIR(M), NUM(N)>), (BOOL(N < 3))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, VALUE(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, VALUE(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, VALUE(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, VALUE(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, VALUE(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, VALUE(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, VALUE(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, NUMBER(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, NUMBER(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, NUMBER(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, NUMBER(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, NUMBER(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, NUMBER(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, NUMBER(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, PAIR(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, PAIR(M), NUMBER(N)>), (BOOL(N < 3))); \
     CHECK((metal::is_invocable<metal::lambda<metal::take>, PAIR(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::take>, PAIR(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::take>, PAIR(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, PAIR(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, PAIR(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, LIST(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, LIST(M), NUM(N)>), (BOOL(M >= N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, PAIR(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, PAIR(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, LIST(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, LIST(M), NUMBER(N)>), (BOOL(M >= N))); \
     CHECK((metal::is_invocable<metal::lambda<metal::take>, LIST(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::take>, LIST(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::take>, LIST(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, LIST(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, LIST(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, MAP(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, MAP(M), NUM(N)>), (BOOL(M >= N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, LIST(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, LIST(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, MAP(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, MAP(M), NUMBER(N)>), (BOOL(M >= N))); \
     CHECK((metal::is_invocable<metal::lambda<metal::take>, MAP(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::take>, MAP(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::take>, MAP(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, MAP(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, MAP(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, LBD(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, LBD(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, LBD(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, LBD(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, LBD(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, LBD(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, LBD(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, LBD(_), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, LBD(_), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, LBD(_), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, LBD(_), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, LBD(_), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, LBD(_), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::take>, LBD(_), LBD(_)>), (FALSE)); \
-    CHECK((metal::take<metal::list<VALS(M) COMMA(AND(M, N)) VALS(N)>, NUM(M)>), (LIST(M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, MAP(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, MAP(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, LAMBDA(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, LAMBDA(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, LAMBDA(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, LAMBDA(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, LAMBDA(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, LAMBDA(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, LAMBDA(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, LAMBDA(_), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, LAMBDA(_), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, LAMBDA(_), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, LAMBDA(_), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, LAMBDA(_), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, LAMBDA(_), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::take>, LAMBDA(_), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::take<metal::list<VALUES(M) COMMA(AND(M, N)) VALUES(N)>, NUMBER(M)>), (LIST(M))); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/list/transform.cpp b/test/src/metal/list/transform.cpp
index cd3f47e8..db7abf1d 100644
--- a/test/src/metal/list/transform.cpp
+++ b/test/src/metal/list/transform.cpp
@@ -11,53 +11,53 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::transform>, VAL(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::transform>, VAL(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::transform>, VAL(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::transform>, VAL(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::transform>, VAL(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::transform>, VAL(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::transform>, NUM(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::transform>, NUM(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::transform>, NUM(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::transform>, NUM(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::transform>, NUM(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::transform>, NUM(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::transform>, PAIR(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::transform>, PAIR(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transform>, VALUE(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transform>, VALUE(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transform>, VALUE(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transform>, VALUE(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transform>, VALUE(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transform>, VALUE(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transform>, NUMBER(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transform>, NUMBER(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transform>, NUMBER(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transform>, NUMBER(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transform>, NUMBER(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transform>, NUMBER(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transform>, PAIR(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transform>, PAIR(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::transform>, PAIR(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::transform>, PAIR(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::transform>, PAIR(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::transform>, PAIR(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::transform>, LIST(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::transform>, LIST(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transform>, PAIR(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transform>, LIST(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transform>, LIST(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::transform>, LIST(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::transform>, LIST(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::transform>, LIST(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::transform>, LIST(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::transform>, MAP(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::transform>, MAP(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transform>, LIST(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transform>, MAP(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transform>, MAP(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::transform>, MAP(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::transform>, MAP(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::transform>, MAP(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::transform>, MAP(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::transform>, LBD(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::transform>, LBD(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::transform>, LBD(M) COMMA(N) PAIRS(N)>), (BOOL(M == N && N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::transform>, LBD(M) COMMA(N) LISTS(N)>), (BOOL(N == 1))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::transform>, LBD(M) COMMA(N) MAPS(N)>), (BOOL(N == 1))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::transform>, LBD(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::transform>, LBD(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::transform>, LBD(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::transform>, LBD(_) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::transform>, LBD(_) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::transform>, LBD(_) COMMA(N) PAIRS(N)>), (BOOL(N > 0))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::transform>, LBD(_) COMMA(N) LISTS(N)>), (BOOL(N == 1))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::transform>, LBD(_) COMMA(N) MAPS(N)>), (BOOL(N == 1))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::transform>, LBD(_) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::transform<LBD(INC(M)), PAIRS(INC(M))>), (metal::list<EXPR(INC(M))<NUMS(INC(M))>, EXPR(INC(M))<VALS(INC(M))>>)); \
-    CHECK((metal::transform<LBD(INC(M)), ENUM(INC(M), LIST FIX(N))>), (metal::list<ENUM(N, NUM FIX(INC(M)))>)); \
-    CHECK((metal::transform<LBD(_), PAIRS(INC(M))>), (metal::list<EXPR(_)<NUMS(INC(M))>, EXPR(_)<VALS(INC(M))>>)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transform>, MAP(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transform>, LAMBDA(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transform>, LAMBDA(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transform>, LAMBDA(M) COMMA(N) PAIRS(N)>), (BOOL(M == N && N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transform>, LAMBDA(M) COMMA(N) LISTS(N)>), (BOOL(N == 1))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transform>, LAMBDA(M) COMMA(N) MAPS(N)>), (BOOL(N == 1))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transform>, LAMBDA(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transform>, LAMBDA(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transform>, LAMBDA(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transform>, LAMBDA(_) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transform>, LAMBDA(_) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transform>, LAMBDA(_) COMMA(N) PAIRS(N)>), (BOOL(N > 0))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transform>, LAMBDA(_) COMMA(N) LISTS(N)>), (BOOL(N == 1))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transform>, LAMBDA(_) COMMA(N) MAPS(N)>), (BOOL(N == 1))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transform>, LAMBDA(_) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::transform<LAMBDA(INC(M)), PAIRS(INC(M))>), (metal::list<EXPR(INC(M))<NUMBERS(INC(M))>, EXPR(INC(M))<VALUES(INC(M))>>)); \
+    CHECK((metal::transform<LAMBDA(INC(M)), ENUM(INC(M), LIST FIX(N))>), (metal::list<ENUM(N, NUMBER FIX(INC(M)))>)); \
+    CHECK((metal::transform<LAMBDA(_), PAIRS(INC(M))>), (metal::list<EXPR(_)<NUMBERS(INC(M))>, EXPR(_)<VALUES(INC(M))>>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/list/transpose.cpp b/test/src/metal/list/transpose.cpp
index aea0a5a8..891147ed 100644
--- a/test/src/metal/list/transpose.cpp
+++ b/test/src/metal/list/transpose.cpp
@@ -13,15 +13,15 @@
 #define SEQ(N, ...) metal::list<FWD(N, __VA_ARGS__)>
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::transpose>, VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::transpose>, NUM(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transpose>, VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transpose>, NUMBER(M)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::transpose>, PAIR(M)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::transpose>, LIST(M)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::transpose>, MAP(M)>), (BOOL(M > 0))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::transpose>, LBD(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::transpose>, LBD(_)>), (FALSE)); \
-    CHECK((metal::transpose<MAP(INC(M))>), (metal::list<metal::list<NUMS(INC(M))>, metal::list<VALS(INC(M))>>)); \
-    CHECK((metal::transpose<metal::list<ENUM(INC(M), LIST FIX(N))>>), (metal::list<ENUM(N, SEQ, RENUM(INC(M), VAL NIL))>)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transpose>, LAMBDA(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::transpose>, LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::transpose<MAP(INC(M))>), (metal::list<metal::list<NUMBERS(INC(M))>, metal::list<VALUES(INC(M))>>)); \
+    CHECK((metal::transpose<metal::list<ENUM(INC(M), LIST FIX(N))>>), (metal::list<ENUM(N, SEQ, RENUM(INC(M), VALUE NIL))>)); \
 
 /**/
 
diff --git a/test/src/metal/map/at_key.cpp b/test/src/metal/map/at_key.cpp
index 69b0ab4a..9a404ed7 100644
--- a/test/src/metal/map/at_key.cpp
+++ b/test/src/metal/map/at_key.cpp
@@ -11,57 +11,57 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, VAL(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, VAL(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, VAL(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, VAL(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, VAL(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, VAL(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, VAL(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, NUM(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, NUM(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, NUM(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, NUM(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, NUM(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, NUM(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, NUM(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, PAIR(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, PAIR(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, VALUE(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, VALUE(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, VALUE(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, VALUE(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, VALUE(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, VALUE(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, VALUE(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, NUMBER(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, NUMBER(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, NUMBER(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, NUMBER(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, NUMBER(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, NUMBER(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, NUMBER(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, PAIR(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, PAIR(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::at_key>, PAIR(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::at_key>, PAIR(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::at_key>, PAIR(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, PAIR(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, PAIR(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LIST(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LIST(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, PAIR(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, PAIR(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LIST(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LIST(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LIST(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LIST(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LIST(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LIST(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LIST(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, MAP(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, MAP(M), NUM(N)>), (BOOL(M > N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LIST(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LIST(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, MAP(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, MAP(M), NUMBER(N)>), (BOOL(M > N))); \
     CHECK((metal::is_invocable<metal::lambda<metal::at_key>, MAP(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::at_key>, MAP(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::at_key>, MAP(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, MAP(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, MAP(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LBD(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LBD(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LBD(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LBD(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LBD(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LBD(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LBD(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LBD(_), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LBD(_), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LBD(_), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LBD(_), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LBD(_), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LBD(_), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LBD(_), LBD(_)>), (FALSE)); \
-    CHECK((metal::at_key<MAP(INC(N)), NUM(N)>), (VAL(N))); \
-    CHECK((metal::at_key<metal::list<PAIRS(N) COMMA(N) metal::list<NUM(N), LBD(N)>>, NUM(N)>), (LBD(N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, MAP(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, MAP(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LAMBDA(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LAMBDA(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LAMBDA(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LAMBDA(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LAMBDA(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LAMBDA(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LAMBDA(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LAMBDA(_), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LAMBDA(_), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LAMBDA(_), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LAMBDA(_), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LAMBDA(_), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LAMBDA(_), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::at_key>, LAMBDA(_), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::at_key<MAP(INC(N)), NUMBER(N)>), (VALUE(N))); \
+    CHECK((metal::at_key<metal::list<PAIRS(N) COMMA(N) metal::list<NUMBER(N), LAMBDA(N)>>, NUMBER(N)>), (LAMBDA(N))); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/map/erase_key.cpp b/test/src/metal/map/erase_key.cpp
index 5f14430d..5aa1cfae 100644
--- a/test/src/metal/map/erase_key.cpp
+++ b/test/src/metal/map/erase_key.cpp
@@ -12,56 +12,56 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, VAL(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, VAL(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, VAL(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, VAL(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, VAL(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, VAL(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, VAL(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, NUM(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, NUM(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, NUM(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, NUM(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, NUM(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, NUM(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, NUM(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, PAIR(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, PAIR(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, VALUE(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, VALUE(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, VALUE(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, VALUE(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, VALUE(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, VALUE(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, VALUE(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, NUMBER(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, NUMBER(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, NUMBER(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, NUMBER(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, NUMBER(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, NUMBER(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, NUMBER(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, PAIR(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, PAIR(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, PAIR(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, PAIR(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, PAIR(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, PAIR(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, PAIR(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LIST(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LIST(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, PAIR(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, PAIR(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LIST(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LIST(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LIST(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LIST(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LIST(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LIST(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LIST(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, MAP(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, MAP(M), NUM(N)>), (BOOL(M > N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LIST(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LIST(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, MAP(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, MAP(M), NUMBER(N)>), (BOOL(M > N))); \
     CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, MAP(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, MAP(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, MAP(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, MAP(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, MAP(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LBD(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LBD(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LBD(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LBD(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LBD(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LBD(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LBD(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LBD(_), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LBD(_), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LBD(_), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LBD(_), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LBD(_), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LBD(_), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LBD(_), LBD(_)>), (FALSE)); \
-    CHECK((metal::erase_key<MAP(INF), NUM(N)>), (metal::erase<MAP(INF), NUM(N)>)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, MAP(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, MAP(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LAMBDA(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LAMBDA(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LAMBDA(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LAMBDA(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LAMBDA(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LAMBDA(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LAMBDA(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LAMBDA(_), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LAMBDA(_), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LAMBDA(_), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LAMBDA(_), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LAMBDA(_), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LAMBDA(_), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::erase_key>, LAMBDA(_), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::erase_key<MAP(INF), NUMBER(N)>), (metal::erase<MAP(INF), NUMBER(N)>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/map/has_key.cpp b/test/src/metal/map/has_key.cpp
index 523056f3..98146d7f 100644
--- a/test/src/metal/map/has_key.cpp
+++ b/test/src/metal/map/has_key.cpp
@@ -11,58 +11,58 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, VAL(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, VAL(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, VAL(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, VAL(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, VAL(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, VAL(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, VAL(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, NUM(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, NUM(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, NUM(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, NUM(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, NUM(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, NUM(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, NUM(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, PAIR(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, PAIR(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, VALUE(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, VALUE(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, VALUE(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, VALUE(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, VALUE(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, VALUE(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, VALUE(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, NUMBER(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, NUMBER(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, NUMBER(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, NUMBER(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, NUMBER(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, NUMBER(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, NUMBER(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, PAIR(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, PAIR(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::has_key>, PAIR(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::has_key>, PAIR(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::has_key>, PAIR(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, PAIR(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, PAIR(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LIST(M), VAL(N)>), (BOOL(!M))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LIST(M), NUM(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, PAIR(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, PAIR(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LIST(M), VALUE(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LIST(M), NUMBER(N)>), (BOOL(!M))); \
     CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LIST(M), PAIR(N)>), (BOOL(!M))); \
     CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LIST(M), LIST(N)>), (BOOL(!M))); \
     CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LIST(M), MAP(N)>), (BOOL(!M))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LIST(M), LBD(N)>), (BOOL(!M))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LIST(M), LBD(_)>), (BOOL(!M))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, MAP(M), VAL(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, MAP(M), NUM(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LIST(M), LAMBDA(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LIST(M), LAMBDA(_)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, MAP(M), VALUE(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, MAP(M), NUMBER(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::has_key>, MAP(M), PAIR(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::has_key>, MAP(M), LIST(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::has_key>, MAP(M), MAP(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, MAP(M), LBD(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, MAP(M), LBD(_)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LBD(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LBD(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LBD(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LBD(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LBD(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LBD(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LBD(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LBD(_), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LBD(_), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LBD(_), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LBD(_), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LBD(_), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LBD(_), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LBD(_), LBD(_)>), (FALSE)); \
-    CHECK((metal::has_key<MAP(M), NUM(N)>), (BOOL(M > N))); \
-    CHECK((metal::has_key<MAP(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::has_key<metal::list<PAIRS(N) COMMA(N) metal::list<NUM(N), LBD(N)>>, NUM(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, MAP(M), LAMBDA(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, MAP(M), LAMBDA(_)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LAMBDA(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LAMBDA(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LAMBDA(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LAMBDA(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LAMBDA(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LAMBDA(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LAMBDA(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LAMBDA(_), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LAMBDA(_), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LAMBDA(_), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LAMBDA(_), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LAMBDA(_), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LAMBDA(_), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::has_key>, LAMBDA(_), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::has_key<MAP(M), NUMBER(N)>), (BOOL(M > N))); \
+    CHECK((metal::has_key<MAP(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::has_key<metal::list<PAIRS(N) COMMA(N) metal::list<NUMBER(N), LAMBDA(N)>>, NUMBER(N)>), (TRUE)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/map/keys.cpp b/test/src/metal/map/keys.cpp
index 030875b5..5bb33f90 100644
--- a/test/src/metal/map/keys.cpp
+++ b/test/src/metal/map/keys.cpp
@@ -11,14 +11,14 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::keys>, VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::keys>, NUM(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::keys>, VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::keys>, NUMBER(M)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::keys>, PAIR(M)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::keys>, LIST(M)>), (BOOL(!M))); \
     CHECK((metal::is_invocable<metal::lambda<metal::keys>, MAP(M)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::keys>, LBD(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::keys>, LBD(_)>), (FALSE)); \
-    CHECK((metal::keys<MAP(M)>), (metal::list<NUMS(M)>)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::keys>, LAMBDA(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::keys>, LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::keys<MAP(M)>), (metal::list<NUMBERS(M)>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/map/map.cpp b/test/src/metal/map/map.cpp
index f60b0af4..701bfd79 100644
--- a/test/src/metal/map/map.cpp
+++ b/test/src/metal/map/map.cpp
@@ -11,20 +11,20 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::map> COMMA(N) VALS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::map> COMMA(N) NUMS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::map> COMMA(N) VALUES(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::map> COMMA(N) NUMBERS(N)>), (BOOL(!N))); \
     CHECK((metal::is_invocable<metal::lambda<metal::map> COMMA(N) PAIRS(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::map> COMMA(N) LISTS(N)>), (BOOL(!N))); \
     CHECK((metal::is_invocable<metal::lambda<metal::map> COMMA(N) MAPS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::map> COMMA(N) LBDS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::map> COMMA(N) LAMBDAS(N)>), (BOOL(!N))); \
     CHECK((metal::is_invocable<metal::lambda<metal::map>, PAIR(M) COMMA(N) PAIRS(N)>), (BOOL(M >= N))); \
-    CHECK((metal::is_map<VAL(N)>), (FALSE)); \
-    CHECK((metal::is_map<NUM(N)>), (FALSE)); \
+    CHECK((metal::is_map<VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_map<NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_map<PAIR(N)>), (FALSE)); \
     CHECK((metal::is_map<LIST(N)>), (BOOL(!N))); \
     CHECK((metal::is_map<MAP(N)>), (TRUE)); \
-    CHECK((metal::is_map<LBD(N)>), (FALSE)); \
-    CHECK((metal::is_map<LBD(_)>), (FALSE)); \
+    CHECK((metal::is_map<LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_map<LAMBDA(_)>), (FALSE)); \
     CHECK((metal::is_map<metal::list<PAIR(N) COMMA(M) PAIRS(M)>>), (BOOL(N >= M))); \
 /**/
 
diff --git a/test/src/metal/map/order.cpp b/test/src/metal/map/order.cpp
index 60386123..09b2c3a3 100644
--- a/test/src/metal/map/order.cpp
+++ b/test/src/metal/map/order.cpp
@@ -11,57 +11,57 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, VAL(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, VAL(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, VAL(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, VAL(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, VAL(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, VAL(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, VAL(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, NUM(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, NUM(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, NUM(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, NUM(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, NUM(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, NUM(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, NUM(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, PAIR(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, PAIR(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, VALUE(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, VALUE(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, VALUE(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, VALUE(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, VALUE(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, VALUE(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, VALUE(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, NUMBER(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, NUMBER(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, NUMBER(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, NUMBER(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, NUMBER(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, NUMBER(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, NUMBER(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, PAIR(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, PAIR(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::order>, PAIR(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::order>, PAIR(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::order>, PAIR(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, PAIR(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, PAIR(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, LIST(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, LIST(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, PAIR(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, PAIR(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, LIST(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, LIST(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::order>, LIST(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::order>, LIST(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::order>, LIST(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, LIST(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, LIST(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, MAP(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, MAP(M), NUM(N)>), (BOOL(M > N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, LIST(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, LIST(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, MAP(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, MAP(M), NUMBER(N)>), (BOOL(M > N))); \
     CHECK((metal::is_invocable<metal::lambda<metal::order>, MAP(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::order>, MAP(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::order>, MAP(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, MAP(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, MAP(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, LBD(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, LBD(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, LBD(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, LBD(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, LBD(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, LBD(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, LBD(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, LBD(_), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, LBD(_), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, LBD(_), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, LBD(_), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, LBD(_), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, LBD(_), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::order>, LBD(_), LBD(_)>), (FALSE)); \
-    CHECK((metal::order<MAP(INC(N)), NUM(N)>), (metal::number<N>)); \
-    CHECK((metal::order<metal::list<PAIRS(N) COMMA(N) metal::list<NUM(N), LBD(N)>>, NUM(N)>), (metal::number<N>)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, MAP(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, MAP(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, LAMBDA(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, LAMBDA(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, LAMBDA(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, LAMBDA(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, LAMBDA(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, LAMBDA(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, LAMBDA(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, LAMBDA(_), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, LAMBDA(_), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, LAMBDA(_), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, LAMBDA(_), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, LAMBDA(_), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, LAMBDA(_), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::order>, LAMBDA(_), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::order<MAP(INC(N)), NUMBER(N)>), (metal::number<N>)); \
+    CHECK((metal::order<metal::list<PAIRS(N) COMMA(N) metal::list<NUMBER(N), LAMBDA(N)>>, NUMBER(N)>), (metal::number<N>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/map/values.cpp b/test/src/metal/map/values.cpp
index 10ef0b74..47efc0a1 100644
--- a/test/src/metal/map/values.cpp
+++ b/test/src/metal/map/values.cpp
@@ -11,14 +11,14 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::values>, VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::values>, NUM(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::values>, VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::values>, NUMBER(M)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::values>, PAIR(M)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::values>, LIST(M)>), (BOOL(!M))); \
     CHECK((metal::is_invocable<metal::lambda<metal::values>, MAP(M)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::values>, LBD(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::values>, LBD(_)>), (FALSE)); \
-    CHECK((metal::values<MAP(M)>), (metal::list<VALS(M)>)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::values>, LAMBDA(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::values>, LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::values<MAP(M)>), (metal::list<VALUES(M)>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/number/add.cpp b/test/src/metal/number/add.cpp
index fcc15e88..6313fbcf 100644
--- a/test/src/metal/number/add.cpp
+++ b/test/src/metal/number/add.cpp
@@ -11,49 +11,49 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::add>, VAL(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::add>, VAL(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::add>, VAL(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::add>, VAL(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::add>, VAL(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::add>, VAL(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::add>, NUM(M) COMMA(N) VALS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::add>, NUM(M) COMMA(N) NUMS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::add>, NUM(M) COMMA(N) PAIRS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::add>, NUM(M) COMMA(N) LISTS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::add>, NUM(M) COMMA(N) MAPS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::add>, NUM(M) COMMA(N) LBDS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::add>, PAIR(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::add>, PAIR(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add>, VALUE(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add>, VALUE(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add>, VALUE(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add>, VALUE(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add>, VALUE(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add>, VALUE(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add>, NUMBER(M) COMMA(N) VALUES(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add>, NUMBER(M) COMMA(N) NUMBERS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add>, NUMBER(M) COMMA(N) PAIRS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add>, NUMBER(M) COMMA(N) LISTS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add>, NUMBER(M) COMMA(N) MAPS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add>, NUMBER(M) COMMA(N) LAMBDAS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add>, PAIR(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add>, PAIR(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::add>, PAIR(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::add>, PAIR(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::add>, PAIR(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::add>, PAIR(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::add>, LIST(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::add>, LIST(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add>, PAIR(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add>, LIST(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add>, LIST(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::add>, LIST(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::add>, LIST(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::add>, LIST(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::add>, LIST(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::add>, MAP(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::add>, MAP(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add>, LIST(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add>, MAP(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add>, MAP(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::add>, MAP(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::add>, MAP(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::add>, MAP(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::add>, MAP(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::add>, LBD(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::add>, LBD(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::add>, LBD(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::add>, LBD(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::add>, LBD(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::add>, LBD(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::add>, LBD(_) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::add>, LBD(_) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::add>, LBD(_) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::add>, LBD(_) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::add>, LBD(_) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::add>, LBD(_) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::add<NUM(M) COMMA(N) NUMS(N)>), (metal::number<N*(N - 1)/2 + M>)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add>, MAP(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add>, LAMBDA(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add>, LAMBDA(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add>, LAMBDA(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add>, LAMBDA(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add>, LAMBDA(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add>, LAMBDA(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add>, LAMBDA(_) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add>, LAMBDA(_) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add>, LAMBDA(_) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add>, LAMBDA(_) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add>, LAMBDA(_) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add>, LAMBDA(_) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::add<NUMBER(M) COMMA(N) NUMBERS(N)>), (metal::number<N*(N - 1)/2 + M>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/number/and.cpp b/test/src/metal/number/and.cpp
index fb2d609f..bded892c 100644
--- a/test/src/metal/number/and.cpp
+++ b/test/src/metal/number/and.cpp
@@ -11,50 +11,50 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::and_>, VAL(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::and_>, VAL(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::and_>, VAL(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::and_>, VAL(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::and_>, VAL(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::and_>, VAL(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::and_>, NUM(M) COMMA(N) VALS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::and_>, NUM(M) COMMA(N) NUMS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::and_>, NUM(M) COMMA(N) PAIRS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::and_>, NUM(M) COMMA(N) LISTS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::and_>, NUM(M) COMMA(N) MAPS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::and_>, NUM(M) COMMA(N) LBDS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::and_>, PAIR(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::and_>, PAIR(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_>, VALUE(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_>, VALUE(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_>, VALUE(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_>, VALUE(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_>, VALUE(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_>, VALUE(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_>, NUMBER(M) COMMA(N) VALUES(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_>, NUMBER(M) COMMA(N) NUMBERS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_>, NUMBER(M) COMMA(N) PAIRS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_>, NUMBER(M) COMMA(N) LISTS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_>, NUMBER(M) COMMA(N) MAPS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_>, NUMBER(M) COMMA(N) LAMBDAS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_>, PAIR(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_>, PAIR(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::and_>, PAIR(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::and_>, PAIR(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::and_>, PAIR(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::and_>, PAIR(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::and_>, LIST(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::and_>, LIST(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_>, PAIR(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_>, LIST(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_>, LIST(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::and_>, LIST(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::and_>, LIST(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::and_>, LIST(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::and_>, LIST(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::and_>, MAP(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::and_>, MAP(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_>, LIST(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_>, MAP(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_>, MAP(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::and_>, MAP(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::and_>, MAP(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::and_>, MAP(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::and_>, MAP(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::and_>, LBD(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::and_>, LBD(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::and_>, LBD(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::and_>, LBD(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::and_>, LBD(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::and_>, LBD(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::and_>, LBD(_) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::and_>, LBD(_) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::and_>, LBD(_) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::and_>, LBD(_) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::and_>, LBD(_) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::and_>, LBD(_) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::and_<NUM(M) COMMA(N) NUMS(N)>), (BOOL(M && !N))); \
-    CHECK((metal::and_<ENUM(N, NUM FIX(M))>), (BOOL(M || !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_>, MAP(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_>, LAMBDA(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_>, LAMBDA(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_>, LAMBDA(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_>, LAMBDA(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_>, LAMBDA(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_>, LAMBDA(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_>, LAMBDA(_) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_>, LAMBDA(_) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_>, LAMBDA(_) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_>, LAMBDA(_) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_>, LAMBDA(_) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_>, LAMBDA(_) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::and_<NUMBER(M) COMMA(N) NUMBERS(N)>), (BOOL(M && !N))); \
+    CHECK((metal::and_<ENUM(N, NUMBER FIX(M))>), (BOOL(M || !N))); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/number/dec.cpp b/test/src/metal/number/dec.cpp
index e38e3cbe..75ae0b08 100644
--- a/test/src/metal/number/dec.cpp
+++ b/test/src/metal/number/dec.cpp
@@ -11,14 +11,14 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::dec>, VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::dec>, NUM(M)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::dec>, VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::dec>, NUMBER(M)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::dec>, PAIR(M)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::dec>, LIST(M)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::dec>, MAP(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::dec>, LBD(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::dec>, LBD(_)>), (FALSE)); \
-    CHECK((metal::dec<NUM(M)>), (metal::number<M - 1>)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::dec>, LAMBDA(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::dec>, LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::dec<NUMBER(M)>), (metal::number<M - 1>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/number/div.cpp b/test/src/metal/number/div.cpp
index 0906e1d2..d118f73d 100644
--- a/test/src/metal/number/div.cpp
+++ b/test/src/metal/number/div.cpp
@@ -11,49 +11,49 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::div>, VAL(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::div>, VAL(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::div>, VAL(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::div>, VAL(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::div>, VAL(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::div>, VAL(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::div>, NUM(M) COMMA(N) VALS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::div>, NUM(M) COMMA(N) NUMS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::div>, NUM(M) COMMA(N) PAIRS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::div>, NUM(M) COMMA(N) LISTS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::div>, NUM(M) COMMA(N) MAPS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::div>, NUM(M) COMMA(N) LBDS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::div>, PAIR(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::div>, PAIR(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div>, VALUE(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div>, VALUE(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div>, VALUE(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div>, VALUE(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div>, VALUE(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div>, VALUE(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div>, NUMBER(M) COMMA(N) VALUES(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div>, NUMBER(M) COMMA(N) NUMBERS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div>, NUMBER(M) COMMA(N) PAIRS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div>, NUMBER(M) COMMA(N) LISTS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div>, NUMBER(M) COMMA(N) MAPS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div>, NUMBER(M) COMMA(N) LAMBDAS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div>, PAIR(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div>, PAIR(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::div>, PAIR(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::div>, PAIR(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::div>, PAIR(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::div>, PAIR(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::div>, LIST(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::div>, LIST(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div>, PAIR(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div>, LIST(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div>, LIST(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::div>, LIST(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::div>, LIST(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::div>, LIST(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::div>, LIST(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::div>, MAP(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::div>, MAP(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div>, LIST(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div>, MAP(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div>, MAP(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::div>, MAP(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::div>, MAP(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::div>, MAP(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::div>, MAP(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::div>, LBD(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::div>, LBD(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::div>, LBD(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::div>, LBD(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::div>, LBD(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::div>, LBD(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::div>, LBD(_) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::div>, LBD(_) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::div>, LBD(_) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::div>, LBD(_) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::div>, LBD(_) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::div>, LBD(_) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::div<metal::number<FACT(M)> COMMA(N) ENUM(N, NUM LIFT(INC))>), (metal::number<FACT(M)/FACT(N)>)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div>, MAP(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div>, LAMBDA(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div>, LAMBDA(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div>, LAMBDA(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div>, LAMBDA(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div>, LAMBDA(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div>, LAMBDA(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div>, LAMBDA(_) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div>, LAMBDA(_) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div>, LAMBDA(_) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div>, LAMBDA(_) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div>, LAMBDA(_) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div>, LAMBDA(_) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::div<metal::number<FACT(M)> COMMA(N) ENUM(N, NUMBER LIFT(INC))>), (metal::number<FACT(M)/FACT(N)>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/number/enumerate.cpp b/test/src/metal/number/enumerate.cpp
index cf023375..7eac2d2b 100644
--- a/test/src/metal/number/enumerate.cpp
+++ b/test/src/metal/number/enumerate.cpp
@@ -13,63 +13,63 @@
 #define ENTRY(N, A, B) metal::number<A*N + B>
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, VAL(M), VAL(N), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, VAL(M), NUM(N), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, VAL(M), PAIR(N), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, VAL(M), LIST(N), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, VAL(M), MAP(N), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, VAL(M), LBD(N), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, VAL(M), LBD(_), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, NUM(M), VAL(N), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, NUM(M), NUM(N), NUM(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, NUM(M), PAIR(N), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, NUM(M), LIST(N), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, NUM(M), MAP(N), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, NUM(M), LBD(N), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, NUM(M), LBD(_), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, PAIR(M), VAL(N), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, PAIR(M), NUM(N), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, VALUE(M), VALUE(N), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, VALUE(M), NUMBER(N), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, VALUE(M), PAIR(N), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, VALUE(M), LIST(N), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, VALUE(M), MAP(N), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, VALUE(M), LAMBDA(N), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, VALUE(M), LAMBDA(_), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, NUMBER(M), VALUE(N), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, NUMBER(M), NUMBER(N), NUMBER(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, NUMBER(M), PAIR(N), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, NUMBER(M), LIST(N), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, NUMBER(M), MAP(N), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, NUMBER(M), LAMBDA(N), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, NUMBER(M), LAMBDA(_), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, PAIR(M), VALUE(N), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, PAIR(M), NUMBER(N), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, PAIR(M), PAIR(N), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, PAIR(M), LIST(N), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, PAIR(M), MAP(N), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, PAIR(M), LBD(N), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, PAIR(M), LBD(_), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LIST(M), VAL(N), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LIST(M), NUM(N), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, PAIR(M), LAMBDA(N), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, PAIR(M), LAMBDA(_), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LIST(M), VALUE(N), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LIST(M), NUMBER(N), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LIST(M), PAIR(N), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LIST(M), LIST(N), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LIST(M), MAP(N), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LIST(M), LBD(N), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LIST(M), LBD(_), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, MAP(M), VAL(N), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, MAP(M), NUM(N), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LIST(M), LAMBDA(N), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LIST(M), LAMBDA(_), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, MAP(M), VALUE(N), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, MAP(M), NUMBER(N), MAP(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, MAP(M), PAIR(N), MAP(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, MAP(M), LIST(N), MAP(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, MAP(M), MAP(N), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, MAP(M), LBD(N), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, MAP(M), LBD(_), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LBD(M), VAL(N), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LBD(M), NUM(N), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LBD(M), PAIR(N), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LBD(M), LIST(N), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LBD(M), MAP(N), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LBD(M), LBD(N), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LBD(M), LBD(_), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LBD(_), VAL(N), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LBD(_), NUM(N), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LBD(_), PAIR(N), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LBD(_), LIST(N), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LBD(_), MAP(N), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LBD(_), LBD(N), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LBD(_), LBD(_), LBD(N)>), (FALSE)); \
-    CHECK((metal::enumerate<NUM(M), NUM(N)>), (metal::list<ENUM(N, ENTRY, 1, M)>)); \
-    CHECK((metal::enumerate<NUM(M), NUM(N), NUM(M)>), (metal::list<ENUM(N, ENTRY, M, M)>)); \
-    CHECK((metal::enumerate<NUM(M), metal::number<-N>, metal::number<-M>>), (metal::list<ENUM(N, ENTRY, M, M)>)); \
-    CHECK((metal::enumerate<metal::number<-M>, NUM(N)>), (metal::list<ENUM(N, ENTRY, 1, -M)>)); \
-    CHECK((metal::enumerate<metal::number<-M>, NUM(N), NUM(M)>), (metal::list<ENUM(N, ENTRY, M, -M)>)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, MAP(M), LAMBDA(N), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, MAP(M), LAMBDA(_), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LAMBDA(M), VALUE(N), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LAMBDA(M), NUMBER(N), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LAMBDA(M), PAIR(N), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LAMBDA(M), LIST(N), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LAMBDA(M), MAP(N), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LAMBDA(M), LAMBDA(N), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LAMBDA(M), LAMBDA(_), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LAMBDA(_), VALUE(N), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LAMBDA(_), NUMBER(N), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LAMBDA(_), PAIR(N), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LAMBDA(_), LIST(N), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LAMBDA(_), MAP(N), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LAMBDA(_), LAMBDA(N), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::enumerate>, LAMBDA(_), LAMBDA(_), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::enumerate<NUMBER(M), NUMBER(N)>), (metal::list<ENUM(N, ENTRY, 1, M)>)); \
+    CHECK((metal::enumerate<NUMBER(M), NUMBER(N), NUMBER(M)>), (metal::list<ENUM(N, ENTRY, M, M)>)); \
+    CHECK((metal::enumerate<NUMBER(M), metal::number<-N>, metal::number<-M>>), (metal::list<ENUM(N, ENTRY, M, M)>)); \
+    CHECK((metal::enumerate<metal::number<-M>, NUMBER(N)>), (metal::list<ENUM(N, ENTRY, 1, -M)>)); \
+    CHECK((metal::enumerate<metal::number<-M>, NUMBER(N), NUMBER(M)>), (metal::list<ENUM(N, ENTRY, M, -M)>)); \
     CHECK((metal::enumerate<metal::number<-M>, metal::number<-N>>), (metal::list<ENUM(N, ENTRY, -1, -M)>)); \
-    CHECK((metal::enumerate<metal::number<-M>, metal::number<-N>, NUM(M)>), (metal::list<ENUM(N, ENTRY, -M, -M)>)); \
-    CHECK((metal::enumerate<metal::number<-M>, NUM(N), metal::number<-M>>), (metal::list<ENUM(N, ENTRY, -M, -M)>)); \
+    CHECK((metal::enumerate<metal::number<-M>, metal::number<-N>, NUMBER(M)>), (metal::list<ENUM(N, ENTRY, -M, -M)>)); \
+    CHECK((metal::enumerate<metal::number<-M>, NUMBER(N), metal::number<-M>>), (metal::list<ENUM(N, ENTRY, -M, -M)>)); \
     CHECK((metal::enumerate<metal::number<-M>, metal::number<-N>, metal::number<-M>>), (metal::list<ENUM(N, ENTRY, M, -M)>)); \
 /**/
 
diff --git a/test/src/metal/number/greater.cpp b/test/src/metal/number/greater.cpp
index 2a6d63b6..037cb5dd 100644
--- a/test/src/metal/number/greater.cpp
+++ b/test/src/metal/number/greater.cpp
@@ -11,56 +11,56 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, VAL(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, VAL(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, VAL(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, VAL(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, VAL(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, VAL(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, VAL(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, NUM(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, NUM(M), NUM(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, NUM(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, NUM(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, NUM(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, NUM(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, NUM(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, PAIR(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, PAIR(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, VALUE(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, VALUE(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, VALUE(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, VALUE(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, VALUE(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, VALUE(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, VALUE(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, NUMBER(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, NUMBER(M), NUMBER(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, NUMBER(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, NUMBER(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, NUMBER(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, NUMBER(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, NUMBER(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, PAIR(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, PAIR(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::greater>, PAIR(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::greater>, PAIR(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::greater>, PAIR(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, PAIR(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, PAIR(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, LIST(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, LIST(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, PAIR(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, PAIR(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, LIST(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, LIST(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::greater>, LIST(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::greater>, LIST(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::greater>, LIST(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, LIST(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, LIST(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, MAP(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, MAP(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, LIST(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, LIST(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, MAP(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, MAP(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::greater>, MAP(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::greater>, MAP(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::greater>, MAP(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, MAP(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, MAP(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, LBD(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, LBD(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, LBD(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, LBD(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, LBD(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, LBD(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, LBD(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, LBD(_), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, LBD(_), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, LBD(_), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, LBD(_), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, LBD(_), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, LBD(_), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::greater>, LBD(_), LBD(_)>), (FALSE)); \
-    CHECK((metal::greater<NUM(M), NUM(N)>), (BOOL(M > N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, MAP(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, MAP(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, LAMBDA(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, LAMBDA(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, LAMBDA(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, LAMBDA(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, LAMBDA(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, LAMBDA(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, LAMBDA(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, LAMBDA(_), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, LAMBDA(_), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, LAMBDA(_), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, LAMBDA(_), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, LAMBDA(_), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, LAMBDA(_), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::greater>, LAMBDA(_), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::greater<NUMBER(M), NUMBER(N)>), (BOOL(M > N))); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/number/if.cpp b/test/src/metal/number/if.cpp
index 02d50213..770b0b6f 100644
--- a/test/src/metal/number/if.cpp
+++ b/test/src/metal/number/if.cpp
@@ -11,49 +11,49 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::if_>, VAL(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::if_>, VAL(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::if_>, VAL(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::if_>, VAL(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::if_>, VAL(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::if_>, VAL(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::if_>, NUM(M) COMMA(N) VALS(N)>), (BOOL((M && N) || (!M && N == 2)))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::if_>, NUM(M) COMMA(N) NUMS(N)>), (BOOL((M && N) ||(!M && N > 1)))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::if_>, NUM(M) COMMA(N) PAIRS(N)>), (BOOL((M && N) || (!M && N == 2)))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::if_>, NUM(M) COMMA(N) LISTS(N)>), (BOOL((M && N) || (!M && N == 2)))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::if_>, NUM(M) COMMA(N) MAPS(N)>), (BOOL((M && N) || (!M && N == 2)))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::if_>, NUM(M) COMMA(N) LBDS(N)>), (BOOL((M && N) || (!M && N == 2)))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::if_>, PAIR(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::if_>, PAIR(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, VALUE(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, VALUE(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, VALUE(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, VALUE(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, VALUE(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, VALUE(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, NUMBER(M) COMMA(N) VALUES(N)>), (BOOL((M && N) || (!M && N == 2)))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, NUMBER(M) COMMA(N) NUMBERS(N)>), (BOOL((M && N) ||(!M && N > 1)))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, NUMBER(M) COMMA(N) PAIRS(N)>), (BOOL((M && N) || (!M && N == 2)))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, NUMBER(M) COMMA(N) LISTS(N)>), (BOOL((M && N) || (!M && N == 2)))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, NUMBER(M) COMMA(N) MAPS(N)>), (BOOL((M && N) || (!M && N == 2)))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, NUMBER(M) COMMA(N) LAMBDAS(N)>), (BOOL((M && N) || (!M && N == 2)))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, PAIR(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, PAIR(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::if_>, PAIR(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::if_>, PAIR(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::if_>, PAIR(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::if_>, PAIR(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::if_>, LIST(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::if_>, LIST(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, PAIR(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, LIST(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, LIST(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::if_>, LIST(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::if_>, LIST(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::if_>, LIST(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::if_>, LIST(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::if_>, MAP(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::if_>, MAP(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, LIST(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, MAP(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, MAP(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::if_>, MAP(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::if_>, MAP(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::if_>, MAP(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::if_>, MAP(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::if_>, LBD(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::if_>, LBD(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::if_>, LBD(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::if_>, LBD(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::if_>, LBD(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::if_>, LBD(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::if_>, LBD(_) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::if_>, LBD(_) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::if_>, LBD(_) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::if_>, LBD(_) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::if_>, LBD(_) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::if_>, LBD(_) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::if_<ENUM(M, NUM FIX(0)) COMMA(M) NUM(N), TRUE, FALSE>), (BOOL(!(M % 2) && N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, MAP(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, LAMBDA(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, LAMBDA(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, LAMBDA(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, LAMBDA(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, LAMBDA(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, LAMBDA(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, LAMBDA(_) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, LAMBDA(_) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, LAMBDA(_) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, LAMBDA(_) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, LAMBDA(_) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, LAMBDA(_) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::if_<ENUM(M, NUMBER FIX(0)) COMMA(M) NUMBER(N), TRUE, FALSE>), (BOOL(!(M % 2) && N))); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/number/inc.cpp b/test/src/metal/number/inc.cpp
index c4685a83..85362bd7 100644
--- a/test/src/metal/number/inc.cpp
+++ b/test/src/metal/number/inc.cpp
@@ -11,14 +11,14 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::inc>, VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::inc>, NUM(M)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::inc>, VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::inc>, NUMBER(M)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::inc>, PAIR(M)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::inc>, LIST(M)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::inc>, MAP(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::inc>, LBD(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::inc>, LBD(_)>), (FALSE)); \
-    CHECK((metal::inc<NUM(M)>), (metal::number<M + 1>)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::inc>, LAMBDA(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::inc>, LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::inc<NUMBER(M)>), (metal::number<M + 1>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/number/less.cpp b/test/src/metal/number/less.cpp
index 85703c94..62ecf49c 100644
--- a/test/src/metal/number/less.cpp
+++ b/test/src/metal/number/less.cpp
@@ -11,56 +11,56 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, VAL(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, VAL(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, VAL(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, VAL(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, VAL(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, VAL(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, VAL(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, NUM(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, NUM(M), NUM(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, NUM(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, NUM(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, NUM(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, NUM(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, NUM(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, PAIR(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, PAIR(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, VALUE(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, VALUE(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, VALUE(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, VALUE(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, VALUE(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, VALUE(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, VALUE(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, NUMBER(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, NUMBER(M), NUMBER(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, NUMBER(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, NUMBER(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, NUMBER(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, NUMBER(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, NUMBER(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, PAIR(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, PAIR(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::less>, PAIR(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::less>, PAIR(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::less>, PAIR(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, PAIR(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, PAIR(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, LIST(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, LIST(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, PAIR(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, PAIR(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, LIST(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, LIST(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::less>, LIST(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::less>, LIST(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::less>, LIST(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, LIST(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, LIST(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, MAP(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, MAP(M), NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, LIST(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, LIST(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, MAP(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, MAP(M), NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::less>, MAP(M), PAIR(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::less>, MAP(M), LIST(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::less>, MAP(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, MAP(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, MAP(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, LBD(M), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, LBD(M), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, LBD(M), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, LBD(M), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, LBD(M), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, LBD(M), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, LBD(M), LBD(_)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, LBD(_), VAL(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, LBD(_), NUM(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, LBD(_), PAIR(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, LBD(_), LIST(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, LBD(_), MAP(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, LBD(_), LBD(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::less>, LBD(_), LBD(_)>), (FALSE)); \
-    CHECK((metal::less<NUM(M), NUM(N)>), (BOOL(M < N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, MAP(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, MAP(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, LAMBDA(M), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, LAMBDA(M), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, LAMBDA(M), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, LAMBDA(M), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, LAMBDA(M), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, LAMBDA(M), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, LAMBDA(M), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, LAMBDA(_), VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, LAMBDA(_), NUMBER(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, LAMBDA(_), PAIR(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, LAMBDA(_), LIST(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, LAMBDA(_), MAP(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, LAMBDA(_), LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::less>, LAMBDA(_), LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::less<NUMBER(M), NUMBER(N)>), (BOOL(M < N))); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/number/max.cpp b/test/src/metal/number/max.cpp
index 9d916f25..3c8ac827 100644
--- a/test/src/metal/number/max.cpp
+++ b/test/src/metal/number/max.cpp
@@ -11,49 +11,49 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::max>, VAL(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::max>, VAL(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::max>, VAL(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::max>, VAL(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::max>, VAL(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::max>, VAL(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::max>, NUM(M) COMMA(N) VALS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::max>, NUM(M) COMMA(N) NUMS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::max>, NUM(M) COMMA(N) PAIRS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::max>, NUM(M) COMMA(N) LISTS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::max>, NUM(M) COMMA(N) MAPS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::max>, NUM(M) COMMA(N) LBDS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::max>, PAIR(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::max>, PAIR(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max>, VALUE(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max>, VALUE(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max>, VALUE(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max>, VALUE(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max>, VALUE(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max>, VALUE(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max>, NUMBER(M) COMMA(N) VALUES(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max>, NUMBER(M) COMMA(N) NUMBERS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max>, NUMBER(M) COMMA(N) PAIRS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max>, NUMBER(M) COMMA(N) LISTS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max>, NUMBER(M) COMMA(N) MAPS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max>, NUMBER(M) COMMA(N) LAMBDAS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max>, PAIR(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max>, PAIR(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::max>, PAIR(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::max>, PAIR(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::max>, PAIR(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::max>, PAIR(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::max>, LIST(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::max>, LIST(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max>, PAIR(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max>, LIST(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max>, LIST(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::max>, LIST(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::max>, LIST(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::max>, LIST(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::max>, LIST(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::max>, MAP(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::max>, MAP(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max>, LIST(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max>, MAP(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max>, MAP(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::max>, MAP(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::max>, MAP(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::max>, MAP(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::max>, MAP(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::max>, LBD(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::max>, LBD(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::max>, LBD(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::max>, LBD(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::max>, LBD(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::max>, LBD(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::max>, LBD(_) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::max>, LBD(_) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::max>, LBD(_) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::max>, LBD(_) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::max>, LBD(_) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::max>, LBD(_) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::max<NUM(M) COMMA(N) NUMS(N)>), (metal::number<(M >= N) ? M : N - 1>)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max>, MAP(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max>, LAMBDA(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max>, LAMBDA(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max>, LAMBDA(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max>, LAMBDA(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max>, LAMBDA(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max>, LAMBDA(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max>, LAMBDA(_) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max>, LAMBDA(_) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max>, LAMBDA(_) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max>, LAMBDA(_) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max>, LAMBDA(_) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max>, LAMBDA(_) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::max<NUMBER(M) COMMA(N) NUMBERS(N)>), (metal::number<(M >= N) ? M : N - 1>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/number/min.cpp b/test/src/metal/number/min.cpp
index e440b963..5e213636 100644
--- a/test/src/metal/number/min.cpp
+++ b/test/src/metal/number/min.cpp
@@ -11,49 +11,49 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::min>, VAL(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::min>, VAL(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::min>, VAL(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::min>, VAL(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::min>, VAL(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::min>, VAL(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::min>, NUM(M) COMMA(N) VALS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::min>, NUM(M) COMMA(N) NUMS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::min>, NUM(M) COMMA(N) PAIRS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::min>, NUM(M) COMMA(N) LISTS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::min>, NUM(M) COMMA(N) MAPS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::min>, NUM(M) COMMA(N) LBDS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::min>, PAIR(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::min>, PAIR(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min>, VALUE(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min>, VALUE(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min>, VALUE(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min>, VALUE(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min>, VALUE(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min>, VALUE(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min>, NUMBER(M) COMMA(N) VALUES(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min>, NUMBER(M) COMMA(N) NUMBERS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min>, NUMBER(M) COMMA(N) PAIRS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min>, NUMBER(M) COMMA(N) LISTS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min>, NUMBER(M) COMMA(N) MAPS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min>, NUMBER(M) COMMA(N) LAMBDAS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min>, PAIR(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min>, PAIR(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::min>, PAIR(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::min>, PAIR(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::min>, PAIR(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::min>, PAIR(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::min>, LIST(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::min>, LIST(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min>, PAIR(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min>, LIST(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min>, LIST(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::min>, LIST(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::min>, LIST(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::min>, LIST(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::min>, LIST(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::min>, MAP(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::min>, MAP(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min>, LIST(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min>, MAP(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min>, MAP(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::min>, MAP(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::min>, MAP(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::min>, MAP(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::min>, MAP(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::min>, LBD(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::min>, LBD(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::min>, LBD(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::min>, LBD(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::min>, LBD(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::min>, LBD(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::min>, LBD(_) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::min>, LBD(_) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::min>, LBD(_) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::min>, LBD(_) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::min>, LBD(_) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::min>, LBD(_) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::min<NUM(M) COMMA(N) NUMS(N)>), (metal::number<N ? 0 : M>)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min>, MAP(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min>, LAMBDA(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min>, LAMBDA(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min>, LAMBDA(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min>, LAMBDA(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min>, LAMBDA(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min>, LAMBDA(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min>, LAMBDA(_) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min>, LAMBDA(_) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min>, LAMBDA(_) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min>, LAMBDA(_) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min>, LAMBDA(_) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min>, LAMBDA(_) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::min<NUMBER(M) COMMA(N) NUMBERS(N)>), (metal::number<N ? 0 : M>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/number/mod.cpp b/test/src/metal/number/mod.cpp
index 946fd7c5..7ee4e839 100644
--- a/test/src/metal/number/mod.cpp
+++ b/test/src/metal/number/mod.cpp
@@ -11,49 +11,49 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::mod>, VAL(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mod>, VAL(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mod>, VAL(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mod>, VAL(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mod>, VAL(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mod>, VAL(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mod>, NUM(M) COMMA(N) VALS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mod>, NUM(M) COMMA(N) NUMS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mod>, NUM(M) COMMA(N) PAIRS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mod>, NUM(M) COMMA(N) LISTS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mod>, NUM(M) COMMA(N) MAPS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mod>, NUM(M) COMMA(N) LBDS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mod>, PAIR(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mod>, PAIR(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod>, VALUE(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod>, VALUE(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod>, VALUE(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod>, VALUE(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod>, VALUE(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod>, VALUE(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod>, NUMBER(M) COMMA(N) VALUES(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod>, NUMBER(M) COMMA(N) NUMBERS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod>, NUMBER(M) COMMA(N) PAIRS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod>, NUMBER(M) COMMA(N) LISTS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod>, NUMBER(M) COMMA(N) MAPS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod>, NUMBER(M) COMMA(N) LAMBDAS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod>, PAIR(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod>, PAIR(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::mod>, PAIR(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::mod>, PAIR(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::mod>, PAIR(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mod>, PAIR(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mod>, LIST(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mod>, LIST(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod>, PAIR(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod>, LIST(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod>, LIST(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::mod>, LIST(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::mod>, LIST(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::mod>, LIST(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mod>, LIST(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mod>, MAP(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mod>, MAP(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod>, LIST(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod>, MAP(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod>, MAP(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::mod>, MAP(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::mod>, MAP(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::mod>, MAP(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mod>, MAP(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mod>, LBD(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mod>, LBD(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mod>, LBD(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mod>, LBD(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mod>, LBD(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mod>, LBD(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mod>, LBD(_) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mod>, LBD(_) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mod>, LBD(_) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mod>, LBD(_) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mod>, LBD(_) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mod>, LBD(_) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::mod<NUM(M) COMMA(N) ENUM(N, NUM LIFT(INC))>), (metal::number<IF(N)(0, M)>)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod>, MAP(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod>, LAMBDA(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod>, LAMBDA(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod>, LAMBDA(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod>, LAMBDA(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod>, LAMBDA(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod>, LAMBDA(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod>, LAMBDA(_) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod>, LAMBDA(_) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod>, LAMBDA(_) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod>, LAMBDA(_) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod>, LAMBDA(_) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod>, LAMBDA(_) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::mod<NUMBER(M) COMMA(N) ENUM(N, NUMBER LIFT(INC))>), (metal::number<IF(N)(0, M)>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/number/mul.cpp b/test/src/metal/number/mul.cpp
index 9267599a..d52d5599 100644
--- a/test/src/metal/number/mul.cpp
+++ b/test/src/metal/number/mul.cpp
@@ -11,49 +11,49 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::mul>, VAL(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mul>, VAL(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mul>, VAL(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mul>, VAL(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mul>, VAL(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mul>, VAL(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mul>, NUM(M) COMMA(N) VALS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mul>, NUM(M) COMMA(N) NUMS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mul>, NUM(M) COMMA(N) PAIRS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mul>, NUM(M) COMMA(N) LISTS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mul>, NUM(M) COMMA(N) MAPS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mul>, NUM(M) COMMA(N) LBDS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mul>, PAIR(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mul>, PAIR(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul>, VALUE(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul>, VALUE(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul>, VALUE(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul>, VALUE(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul>, VALUE(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul>, VALUE(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul>, NUMBER(M) COMMA(N) VALUES(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul>, NUMBER(M) COMMA(N) NUMBERS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul>, NUMBER(M) COMMA(N) PAIRS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul>, NUMBER(M) COMMA(N) LISTS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul>, NUMBER(M) COMMA(N) MAPS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul>, NUMBER(M) COMMA(N) LAMBDAS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul>, PAIR(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul>, PAIR(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::mul>, PAIR(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::mul>, PAIR(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::mul>, PAIR(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mul>, PAIR(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mul>, LIST(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mul>, LIST(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul>, PAIR(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul>, LIST(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul>, LIST(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::mul>, LIST(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::mul>, LIST(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::mul>, LIST(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mul>, LIST(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mul>, MAP(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mul>, MAP(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul>, LIST(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul>, MAP(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul>, MAP(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::mul>, MAP(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::mul>, MAP(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::mul>, MAP(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mul>, MAP(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mul>, LBD(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mul>, LBD(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mul>, LBD(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mul>, LBD(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mul>, LBD(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mul>, LBD(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mul>, LBD(_) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mul>, LBD(_) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mul>, LBD(_) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mul>, LBD(_) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mul>, LBD(_) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::mul>, LBD(_) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::mul<NUM(M) COMMA(N) ENUM(N, NUM LIFT(INC))>), (metal::number<M*FACT(N)>)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul>, MAP(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul>, LAMBDA(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul>, LAMBDA(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul>, LAMBDA(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul>, LAMBDA(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul>, LAMBDA(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul>, LAMBDA(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul>, LAMBDA(_) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul>, LAMBDA(_) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul>, LAMBDA(_) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul>, LAMBDA(_) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul>, LAMBDA(_) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul>, LAMBDA(_) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::mul<NUMBER(M) COMMA(N) ENUM(N, NUMBER LIFT(INC))>), (metal::number<M*FACT(N)>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/number/neg.cpp b/test/src/metal/number/neg.cpp
index c4d8093e..545f59a9 100644
--- a/test/src/metal/number/neg.cpp
+++ b/test/src/metal/number/neg.cpp
@@ -11,14 +11,14 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::neg>, VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::neg>, NUM(M)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::neg>, VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::neg>, NUMBER(M)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::neg>, PAIR(M)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::neg>, LIST(M)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::neg>, MAP(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::neg>, LBD(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::neg>, LBD(_)>), (FALSE)); \
-    CHECK((metal::neg<NUM(M)>), (metal::number<-M>)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::neg>, LAMBDA(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::neg>, LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::neg<NUMBER(M)>), (metal::number<-M>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/number/not.cpp b/test/src/metal/number/not.cpp
index 67a5ac72..6c7a27fd 100644
--- a/test/src/metal/number/not.cpp
+++ b/test/src/metal/number/not.cpp
@@ -11,14 +11,14 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::not_>, VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::not_>, NUM(M)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::not_>, VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::not_>, NUMBER(M)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::not_>, PAIR(M)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::not_>, LIST(M)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::not_>, MAP(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::not_>, LBD(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::not_>, LBD(_)>), (FALSE)); \
-    CHECK((metal::not_<NUM(M)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::not_>, LAMBDA(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::not_>, LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::not_<NUMBER(M)>), (BOOL(!M))); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/number/number.cpp b/test/src/metal/number/number.cpp
index 525dbdc4..a1b02fdf 100644
--- a/test/src/metal/number/number.cpp
+++ b/test/src/metal/number/number.cpp
@@ -9,13 +9,13 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_number<VAL(M)>), (FALSE)); \
-    CHECK((metal::is_number<NUM(M)>), (TRUE)); \
+    CHECK((metal::is_number<VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_number<NUMBER(M)>), (TRUE)); \
     CHECK((metal::is_number<PAIR(M)>), (FALSE)); \
     CHECK((metal::is_number<LIST(M)>), (FALSE)); \
     CHECK((metal::is_number<MAP(M)>), (FALSE)); \
-    CHECK((metal::is_number<LBD(M)>), (FALSE)); \
-    CHECK((metal::is_number<LBD(_)>), (FALSE)); \
+    CHECK((metal::is_number<LAMBDA(M)>), (FALSE)); \
+    CHECK((metal::is_number<LAMBDA(_)>), (FALSE)); \
     CHECK((metal::is_number<metal::number<M>>), (TRUE)); \
     CHECK((metal::is_number<metal::number<-M>>), (TRUE)); \
     CHECK((metal::is_number<metal::false_>), (TRUE)); \
diff --git a/test/src/metal/number/or.cpp b/test/src/metal/number/or.cpp
index acbbb61f..de8bc78b 100644
--- a/test/src/metal/number/or.cpp
+++ b/test/src/metal/number/or.cpp
@@ -11,50 +11,50 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::or_>, VAL(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::or_>, VAL(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::or_>, VAL(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::or_>, VAL(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::or_>, VAL(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::or_>, VAL(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::or_>, NUM(M) COMMA(N) VALS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::or_>, NUM(M) COMMA(N) NUMS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::or_>, NUM(M) COMMA(N) PAIRS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::or_>, NUM(M) COMMA(N) LISTS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::or_>, NUM(M) COMMA(N) MAPS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::or_>, NUM(M) COMMA(N) LBDS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::or_>, PAIR(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::or_>, PAIR(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_>, VALUE(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_>, VALUE(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_>, VALUE(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_>, VALUE(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_>, VALUE(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_>, VALUE(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_>, NUMBER(M) COMMA(N) VALUES(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_>, NUMBER(M) COMMA(N) NUMBERS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_>, NUMBER(M) COMMA(N) PAIRS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_>, NUMBER(M) COMMA(N) LISTS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_>, NUMBER(M) COMMA(N) MAPS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_>, NUMBER(M) COMMA(N) LAMBDAS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_>, PAIR(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_>, PAIR(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::or_>, PAIR(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::or_>, PAIR(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::or_>, PAIR(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::or_>, PAIR(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::or_>, LIST(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::or_>, LIST(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_>, PAIR(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_>, LIST(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_>, LIST(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::or_>, LIST(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::or_>, LIST(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::or_>, LIST(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::or_>, LIST(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::or_>, MAP(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::or_>, MAP(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_>, LIST(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_>, MAP(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_>, MAP(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::or_>, MAP(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::or_>, MAP(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::or_>, MAP(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::or_>, MAP(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::or_>, LBD(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::or_>, LBD(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::or_>, LBD(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::or_>, LBD(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::or_>, LBD(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::or_>, LBD(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::or_>, LBD(_) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::or_>, LBD(_) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::or_>, LBD(_) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::or_>, LBD(_) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::or_>, LBD(_) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::or_>, LBD(_) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::or_<NUM(M) COMMA(N) NUMS(N)>), (BOOL(M || N > 1))); \
-    CHECK((metal::or_<ENUM(N, NUM FIX(M))>), (BOOL(N && M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_>, MAP(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_>, LAMBDA(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_>, LAMBDA(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_>, LAMBDA(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_>, LAMBDA(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_>, LAMBDA(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_>, LAMBDA(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_>, LAMBDA(_) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_>, LAMBDA(_) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_>, LAMBDA(_) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_>, LAMBDA(_) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_>, LAMBDA(_) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_>, LAMBDA(_) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::or_<NUMBER(M) COMMA(N) NUMBERS(N)>), (BOOL(M || N > 1))); \
+    CHECK((metal::or_<ENUM(N, NUMBER FIX(M))>), (BOOL(N && M))); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/number/pow.cpp b/test/src/metal/number/pow.cpp
index 9be0debd..895a4083 100644
--- a/test/src/metal/number/pow.cpp
+++ b/test/src/metal/number/pow.cpp
@@ -11,50 +11,50 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::pow>, VAL(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pow>, VAL(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pow>, VAL(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pow>, VAL(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pow>, VAL(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pow>, VAL(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pow>, NUM(M) COMMA(N) VALS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pow>, NUM(M) COMMA(N) NUMS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pow>, NUM(M) COMMA(N) PAIRS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pow>, NUM(M) COMMA(N) LISTS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pow>, NUM(M) COMMA(N) MAPS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pow>, NUM(M) COMMA(N) LBDS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pow>, PAIR(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pow>, PAIR(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow>, VALUE(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow>, VALUE(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow>, VALUE(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow>, VALUE(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow>, VALUE(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow>, VALUE(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow>, NUMBER(M) COMMA(N) VALUES(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow>, NUMBER(M) COMMA(N) NUMBERS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow>, NUMBER(M) COMMA(N) PAIRS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow>, NUMBER(M) COMMA(N) LISTS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow>, NUMBER(M) COMMA(N) MAPS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow>, NUMBER(M) COMMA(N) LAMBDAS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow>, PAIR(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow>, PAIR(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::pow>, PAIR(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::pow>, PAIR(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::pow>, PAIR(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pow>, PAIR(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pow>, LIST(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pow>, LIST(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow>, PAIR(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow>, LIST(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow>, LIST(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::pow>, LIST(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::pow>, LIST(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::pow>, LIST(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pow>, LIST(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pow>, MAP(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pow>, MAP(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow>, LIST(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow>, MAP(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow>, MAP(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::pow>, MAP(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::pow>, MAP(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::pow>, MAP(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pow>, MAP(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pow>, LBD(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pow>, LBD(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pow>, LBD(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pow>, LBD(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pow>, LBD(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pow>, LBD(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pow>, LBD(_) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pow>, LBD(_) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pow>, LBD(_) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pow>, LBD(_) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pow>, LBD(_) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pow>, LBD(_) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pow>, NUM(M), metal::number<-N>>), (BOOL(M || !N))); \
-    CHECK((metal::pow<NUM(M) COMMA(N) NUMS(N)>), (metal::number<IF(N)(1, M)>)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow>, MAP(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow>, LAMBDA(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow>, LAMBDA(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow>, LAMBDA(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow>, LAMBDA(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow>, LAMBDA(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow>, LAMBDA(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow>, LAMBDA(_) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow>, LAMBDA(_) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow>, LAMBDA(_) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow>, LAMBDA(_) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow>, LAMBDA(_) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow>, LAMBDA(_) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow>, NUMBER(M), metal::number<-N>>), (BOOL(M || !N))); \
+    CHECK((metal::pow<NUMBER(M) COMMA(N) NUMBERS(N)>), (metal::number<IF(N)(1, M)>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/number/sub.cpp b/test/src/metal/number/sub.cpp
index 7d3c5762..fde6848f 100644
--- a/test/src/metal/number/sub.cpp
+++ b/test/src/metal/number/sub.cpp
@@ -11,49 +11,49 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::sub>, VAL(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sub>, VAL(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sub>, VAL(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sub>, VAL(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sub>, VAL(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sub>, VAL(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sub>, NUM(M) COMMA(N) VALS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sub>, NUM(M) COMMA(N) NUMS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sub>, NUM(M) COMMA(N) PAIRS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sub>, NUM(M) COMMA(N) LISTS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sub>, NUM(M) COMMA(N) MAPS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sub>, NUM(M) COMMA(N) LBDS(N)>), (BOOL(!N))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sub>, PAIR(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sub>, PAIR(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub>, VALUE(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub>, VALUE(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub>, VALUE(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub>, VALUE(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub>, VALUE(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub>, VALUE(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub>, NUMBER(M) COMMA(N) VALUES(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub>, NUMBER(M) COMMA(N) NUMBERS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub>, NUMBER(M) COMMA(N) PAIRS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub>, NUMBER(M) COMMA(N) LISTS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub>, NUMBER(M) COMMA(N) MAPS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub>, NUMBER(M) COMMA(N) LAMBDAS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub>, PAIR(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub>, PAIR(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::sub>, PAIR(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::sub>, PAIR(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::sub>, PAIR(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sub>, PAIR(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sub>, LIST(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sub>, LIST(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub>, PAIR(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub>, LIST(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub>, LIST(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::sub>, LIST(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::sub>, LIST(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::sub>, LIST(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sub>, LIST(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sub>, MAP(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sub>, MAP(M) COMMA(N) NUMS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub>, LIST(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub>, MAP(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub>, MAP(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::sub>, MAP(M) COMMA(N) PAIRS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::sub>, MAP(M) COMMA(N) LISTS(N)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::sub>, MAP(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sub>, MAP(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sub>, LBD(M) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sub>, LBD(M) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sub>, LBD(M) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sub>, LBD(M) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sub>, LBD(M) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sub>, LBD(M) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sub>, LBD(_) COMMA(N) VALS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sub>, LBD(_) COMMA(N) NUMS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sub>, LBD(_) COMMA(N) PAIRS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sub>, LBD(_) COMMA(N) LISTS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sub>, LBD(_) COMMA(N) MAPS(N)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::sub>, LBD(_) COMMA(N) LBDS(N)>), (FALSE)); \
-    CHECK((metal::sub<NUM(M) COMMA(N) NUMS(N)>), (metal::number<N*(1 - N)/2 + M>)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub>, MAP(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub>, LAMBDA(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub>, LAMBDA(M) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub>, LAMBDA(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub>, LAMBDA(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub>, LAMBDA(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub>, LAMBDA(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub>, LAMBDA(_) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub>, LAMBDA(_) COMMA(N) NUMBERS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub>, LAMBDA(_) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub>, LAMBDA(_) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub>, LAMBDA(_) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub>, LAMBDA(_) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::sub<NUMBER(M) COMMA(N) NUMBERS(N)>), (metal::number<N*(1 - N)/2 + M>)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/pair/first.cpp b/test/src/metal/pair/first.cpp
index f353d9cf..fbdfe7fd 100644
--- a/test/src/metal/pair/first.cpp
+++ b/test/src/metal/pair/first.cpp
@@ -11,14 +11,14 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::first>, VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::first>, NUM(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::first>, VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::first>, NUMBER(M)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::first>, PAIR(M)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::first>, LIST(M)>), (BOOL(M == 2))); \
     CHECK((metal::is_invocable<metal::lambda<metal::first>, MAP(M)>), (BOOL(M == 2))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::first>, LBD(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::first>, LBD(_)>), (FALSE)); \
-    CHECK((metal::first<PAIR(M)>), (NUM(M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::first>, LAMBDA(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::first>, LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::first<PAIR(M)>), (NUMBER(M))); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/pair/pair.cpp b/test/src/metal/pair/pair.cpp
index 7a8dc580..e6576fb6 100644
--- a/test/src/metal/pair/pair.cpp
+++ b/test/src/metal/pair/pair.cpp
@@ -11,61 +11,61 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, VAL(M), VAL(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, VAL(M), NUM(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, VAL(M), PAIR(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, VAL(M), LIST(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, VAL(M), MAP(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, VAL(M), LBD(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, VAL(M), LBD(_)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, NUM(M), VAL(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, NUM(M), NUM(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, NUM(M), PAIR(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, NUM(M), LIST(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, NUM(M), MAP(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, NUM(M), LBD(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, NUM(M), LBD(_)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, PAIR(M), VAL(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, PAIR(M), NUM(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, VALUE(M), VALUE(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, VALUE(M), NUMBER(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, VALUE(M), PAIR(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, VALUE(M), LIST(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, VALUE(M), MAP(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, VALUE(M), LAMBDA(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, VALUE(M), LAMBDA(_)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, NUMBER(M), VALUE(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, NUMBER(M), NUMBER(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, NUMBER(M), PAIR(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, NUMBER(M), LIST(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, NUMBER(M), MAP(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, NUMBER(M), LAMBDA(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, NUMBER(M), LAMBDA(_)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, PAIR(M), VALUE(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, PAIR(M), NUMBER(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::pair>, PAIR(M), PAIR(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::pair>, PAIR(M), LIST(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::pair>, PAIR(M), MAP(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, PAIR(M), LBD(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, PAIR(M), LBD(_)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, LIST(M), VAL(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, LIST(M), NUM(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, PAIR(M), LAMBDA(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, PAIR(M), LAMBDA(_)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, LIST(M), VALUE(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, LIST(M), NUMBER(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::pair>, LIST(M), PAIR(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::pair>, LIST(M), LIST(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::pair>, LIST(M), MAP(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, LIST(M), LBD(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, LIST(M), LBD(_)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, MAP(M), VAL(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, MAP(M), NUM(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, LIST(M), LAMBDA(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, LIST(M), LAMBDA(_)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, MAP(M), VALUE(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, MAP(M), NUMBER(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::pair>, MAP(M), PAIR(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::pair>, MAP(M), LIST(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::pair>, MAP(M), MAP(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, MAP(M), LBD(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, MAP(M), LBD(_)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, LBD(M), VAL(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, LBD(M), NUM(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, LBD(M), PAIR(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, LBD(M), LIST(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, LBD(M), MAP(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, LBD(M), LBD(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, LBD(M), LBD(_)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, LBD(_), NUM(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, LBD(_), PAIR(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, LBD(_), LIST(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, LBD(_), MAP(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, LBD(_), LBD(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::pair>, LBD(_), LBD(_)>), (TRUE)); \
-    CHECK((metal::is_pair<VAL(N)>), (FALSE)); \
-    CHECK((metal::is_pair<NUM(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, MAP(M), LAMBDA(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, MAP(M), LAMBDA(_)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, LAMBDA(M), VALUE(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, LAMBDA(M), NUMBER(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, LAMBDA(M), PAIR(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, LAMBDA(M), LIST(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, LAMBDA(M), MAP(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, LAMBDA(M), LAMBDA(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, LAMBDA(M), LAMBDA(_)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, LAMBDA(_), NUMBER(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, LAMBDA(_), PAIR(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, LAMBDA(_), LIST(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, LAMBDA(_), MAP(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, LAMBDA(_), LAMBDA(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pair>, LAMBDA(_), LAMBDA(_)>), (TRUE)); \
+    CHECK((metal::is_pair<VALUE(N)>), (FALSE)); \
+    CHECK((metal::is_pair<NUMBER(N)>), (FALSE)); \
     CHECK((metal::is_pair<PAIR(N)>), (TRUE)); \
     CHECK((metal::is_pair<LIST(N)>), (BOOL(N == 2))); \
     CHECK((metal::is_pair<MAP(N)>), (BOOL(N == 2))); \
-    CHECK((metal::is_pair<LBD(N)>), (FALSE)); \
-    CHECK((metal::is_pair<LBD(_)>), (FALSE)); \
+    CHECK((metal::is_pair<LAMBDA(N)>), (FALSE)); \
+    CHECK((metal::is_pair<LAMBDA(_)>), (FALSE)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/pair/second.cpp b/test/src/metal/pair/second.cpp
index 03270b45..9034732d 100644
--- a/test/src/metal/pair/second.cpp
+++ b/test/src/metal/pair/second.cpp
@@ -11,14 +11,14 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::second>, VAL(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::second>, NUM(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::second>, VALUE(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::second>, NUMBER(M)>), (FALSE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::second>, PAIR(M)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::second>, LIST(M)>), (BOOL(M == 2))); \
     CHECK((metal::is_invocable<metal::lambda<metal::second>, MAP(M)>), (BOOL(M == 2))); \
-    CHECK((metal::is_invocable<metal::lambda<metal::second>, LBD(M)>), (FALSE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::second>, LBD(_)>), (FALSE)); \
-    CHECK((metal::second<PAIR(M)>), (VAL(M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::second>, LAMBDA(M)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::second>, LAMBDA(_)>), (FALSE)); \
+    CHECK((metal::second<PAIR(M)>), (VALUE(M))); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/value/distinct.cpp b/test/src/metal/value/distinct.cpp
index 69732bec..ff985746 100644
--- a/test/src/metal/value/distinct.cpp
+++ b/test/src/metal/value/distinct.cpp
@@ -11,44 +11,44 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) VALS(M) COMMA(AND(M, N)) VALS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) VALS(M) COMMA(AND(M, N)) NUMS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) VALS(M) COMMA(AND(M, N)) PAIRS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) VALS(M) COMMA(AND(M, N)) LISTS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) VALS(M) COMMA(AND(M, N)) MAPS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) VALS(M) COMMA(AND(M, N)) LBDS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) NUMS(M) COMMA(AND(M, N)) VALS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) NUMS(M) COMMA(AND(M, N)) NUMS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) NUMS(M) COMMA(AND(M, N)) PAIRS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) NUMS(M) COMMA(AND(M, N)) LISTS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) NUMS(M) COMMA(AND(M, N)) MAPS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) NUMS(M) COMMA(AND(M, N)) LBDS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) PAIRS(M) COMMA(AND(M, N)) VALS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) PAIRS(M) COMMA(AND(M, N)) NUMS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) VALUES(M) COMMA(AND(M, N)) VALUES(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) VALUES(M) COMMA(AND(M, N)) NUMBERS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) VALUES(M) COMMA(AND(M, N)) PAIRS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) VALUES(M) COMMA(AND(M, N)) LISTS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) VALUES(M) COMMA(AND(M, N)) MAPS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) VALUES(M) COMMA(AND(M, N)) LAMBDAS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) NUMBERS(M) COMMA(AND(M, N)) VALUES(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) NUMBERS(M) COMMA(AND(M, N)) NUMBERS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) NUMBERS(M) COMMA(AND(M, N)) PAIRS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) NUMBERS(M) COMMA(AND(M, N)) LISTS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) NUMBERS(M) COMMA(AND(M, N)) MAPS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) NUMBERS(M) COMMA(AND(M, N)) LAMBDAS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) PAIRS(M) COMMA(AND(M, N)) VALUES(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) PAIRS(M) COMMA(AND(M, N)) NUMBERS(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) PAIRS(M) COMMA(AND(M, N)) PAIRS(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) PAIRS(M) COMMA(AND(M, N)) LISTS(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) PAIRS(M) COMMA(AND(M, N)) MAPS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) PAIRS(M) COMMA(AND(M, N)) LBDS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) LISTS(M) COMMA(AND(M, N)) VALS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) LISTS(M) COMMA(AND(M, N)) NUMS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) PAIRS(M) COMMA(AND(M, N)) LAMBDAS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) LISTS(M) COMMA(AND(M, N)) VALUES(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) LISTS(M) COMMA(AND(M, N)) NUMBERS(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) LISTS(M) COMMA(AND(M, N)) PAIRS(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) LISTS(M) COMMA(AND(M, N)) LISTS(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) LISTS(M) COMMA(AND(M, N)) MAPS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) LISTS(M) COMMA(AND(M, N)) LBDS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) MAPS(M) COMMA(AND(M, N)) VALS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) MAPS(M) COMMA(AND(M, N)) NUMS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) LISTS(M) COMMA(AND(M, N)) LAMBDAS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) MAPS(M) COMMA(AND(M, N)) VALUES(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) MAPS(M) COMMA(AND(M, N)) NUMBERS(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) MAPS(M) COMMA(AND(M, N)) PAIRS(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) MAPS(M) COMMA(AND(M, N)) LISTS(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) MAPS(M) COMMA(AND(M, N)) MAPS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) MAPS(M) COMMA(AND(M, N)) LBDS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) LBDS(M) COMMA(AND(M, N)) VALS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) LBDS(M) COMMA(AND(M, N)) NUMS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) LBDS(M) COMMA(AND(M, N)) PAIRS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) LBDS(M) COMMA(AND(M, N)) LISTS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) LBDS(M) COMMA(AND(M, N)) MAPS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) LBDS(M) COMMA(AND(M, N)) LBDS(N)>), (TRUE)); \
-    CHECK((metal::distinct<VALS(M) COMMA(AND(M, N)) VALS(N)>), (BOOL(!M || !N))); \
-    CHECK((metal::distinct<ENUM(M, VAL FIX(N))>), (BOOL(M < 2))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) MAPS(M) COMMA(AND(M, N)) LAMBDAS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) LAMBDAS(M) COMMA(AND(M, N)) VALUES(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) LAMBDAS(M) COMMA(AND(M, N)) NUMBERS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) LAMBDAS(M) COMMA(AND(M, N)) PAIRS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) LAMBDAS(M) COMMA(AND(M, N)) LISTS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) LAMBDAS(M) COMMA(AND(M, N)) MAPS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::distinct> COMMA(OR(M, N)) LAMBDAS(M) COMMA(AND(M, N)) LAMBDAS(N)>), (TRUE)); \
+    CHECK((metal::distinct<VALUES(M) COMMA(AND(M, N)) VALUES(N)>), (BOOL(!M || !N))); \
+    CHECK((metal::distinct<ENUM(M, VALUE FIX(N))>), (BOOL(M < 2))); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/value/same.cpp b/test/src/metal/value/same.cpp
index 495daee9..14a8ea70 100644
--- a/test/src/metal/value/same.cpp
+++ b/test/src/metal/value/same.cpp
@@ -11,44 +11,44 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) VALS(M) COMMA(AND(M, N)) VALS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) VALS(M) COMMA(AND(M, N)) NUMS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) VALS(M) COMMA(AND(M, N)) PAIRS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) VALS(M) COMMA(AND(M, N)) LISTS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) VALS(M) COMMA(AND(M, N)) MAPS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) VALS(M) COMMA(AND(M, N)) LBDS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) NUMS(M) COMMA(AND(M, N)) VALS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) NUMS(M) COMMA(AND(M, N)) NUMS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) NUMS(M) COMMA(AND(M, N)) PAIRS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) NUMS(M) COMMA(AND(M, N)) LISTS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) NUMS(M) COMMA(AND(M, N)) MAPS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) NUMS(M) COMMA(AND(M, N)) LBDS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) PAIRS(M) COMMA(AND(M, N)) VALS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) PAIRS(M) COMMA(AND(M, N)) NUMS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) VALUES(M) COMMA(AND(M, N)) VALUES(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) VALUES(M) COMMA(AND(M, N)) NUMBERS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) VALUES(M) COMMA(AND(M, N)) PAIRS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) VALUES(M) COMMA(AND(M, N)) LISTS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) VALUES(M) COMMA(AND(M, N)) MAPS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) VALUES(M) COMMA(AND(M, N)) LAMBDAS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) NUMBERS(M) COMMA(AND(M, N)) VALUES(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) NUMBERS(M) COMMA(AND(M, N)) NUMBERS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) NUMBERS(M) COMMA(AND(M, N)) PAIRS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) NUMBERS(M) COMMA(AND(M, N)) LISTS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) NUMBERS(M) COMMA(AND(M, N)) MAPS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) NUMBERS(M) COMMA(AND(M, N)) LAMBDAS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) PAIRS(M) COMMA(AND(M, N)) VALUES(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) PAIRS(M) COMMA(AND(M, N)) NUMBERS(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) PAIRS(M) COMMA(AND(M, N)) PAIRS(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) PAIRS(M) COMMA(AND(M, N)) LISTS(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) PAIRS(M) COMMA(AND(M, N)) MAPS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) PAIRS(M) COMMA(AND(M, N)) LBDS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) LISTS(M) COMMA(AND(M, N)) VALS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) LISTS(M) COMMA(AND(M, N)) NUMS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) PAIRS(M) COMMA(AND(M, N)) LAMBDAS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) LISTS(M) COMMA(AND(M, N)) VALUES(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) LISTS(M) COMMA(AND(M, N)) NUMBERS(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) LISTS(M) COMMA(AND(M, N)) PAIRS(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) LISTS(M) COMMA(AND(M, N)) LISTS(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) LISTS(M) COMMA(AND(M, N)) MAPS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) LISTS(M) COMMA(AND(M, N)) LBDS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) MAPS(M) COMMA(AND(M, N)) VALS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) MAPS(M) COMMA(AND(M, N)) NUMS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) LISTS(M) COMMA(AND(M, N)) LAMBDAS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) MAPS(M) COMMA(AND(M, N)) VALUES(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) MAPS(M) COMMA(AND(M, N)) NUMBERS(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) MAPS(M) COMMA(AND(M, N)) PAIRS(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) MAPS(M) COMMA(AND(M, N)) LISTS(N)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) MAPS(M) COMMA(AND(M, N)) MAPS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) MAPS(M) COMMA(AND(M, N)) LBDS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) LBDS(M) COMMA(AND(M, N)) VALS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) LBDS(M) COMMA(AND(M, N)) NUMS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) LBDS(M) COMMA(AND(M, N)) PAIRS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) LBDS(M) COMMA(AND(M, N)) LISTS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) LBDS(M) COMMA(AND(M, N)) MAPS(N)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) LBDS(M) COMMA(AND(M, N)) LBDS(N)>), (TRUE)); \
-    CHECK((metal::same<VALS(M) COMMA(AND(M, N)) VALS(N)>), (BOOL(M < 2 && N < 2))); \
-    CHECK((metal::same<ENUM(M, VAL FIX(N))>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) MAPS(M) COMMA(AND(M, N)) LAMBDAS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) LAMBDAS(M) COMMA(AND(M, N)) VALUES(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) LAMBDAS(M) COMMA(AND(M, N)) NUMBERS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) LAMBDAS(M) COMMA(AND(M, N)) PAIRS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) LAMBDAS(M) COMMA(AND(M, N)) LISTS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) LAMBDAS(M) COMMA(AND(M, N)) MAPS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::same> COMMA(OR(M, N)) LAMBDAS(M) COMMA(AND(M, N)) LAMBDAS(N)>), (TRUE)); \
+    CHECK((metal::same<VALUES(M) COMMA(AND(M, N)) VALUES(N)>), (BOOL(M < 2 && N < 2))); \
+    CHECK((metal::same<ENUM(M, VALUE FIX(N))>), (TRUE)); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/src/metal/value/value.cpp b/test/src/metal/value/value.cpp
index 48621816..4f0dceae 100644
--- a/test/src/metal/value/value.cpp
+++ b/test/src/metal/value/value.cpp
@@ -11,20 +11,20 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    CHECK((metal::is_invocable<metal::lambda<metal::value>, VAL(M)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::value>, NUM(M)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::value>, VALUE(M)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::value>, NUMBER(M)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::value>, PAIR(M)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::value>, LIST(M)>), (TRUE)); \
     CHECK((metal::is_invocable<metal::lambda<metal::value>, MAP(M)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::value>, LBD(M)>), (TRUE)); \
-    CHECK((metal::is_invocable<metal::lambda<metal::value>, LBD(_)>), (TRUE)); \
-    CHECK((metal::is_value<VAL(N)>), (TRUE)); \
-    CHECK((metal::is_value<NUM(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::value>, LAMBDA(M)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::value>, LAMBDA(_)>), (TRUE)); \
+    CHECK((metal::is_value<VALUE(N)>), (TRUE)); \
+    CHECK((metal::is_value<NUMBER(N)>), (TRUE)); \
     CHECK((metal::is_value<PAIR(N)>), (TRUE)); \
     CHECK((metal::is_value<LIST(N)>), (TRUE)); \
     CHECK((metal::is_value<MAP(N)>), (TRUE)); \
-    CHECK((metal::is_value<LBD(N)>), (TRUE)); \
-    CHECK((metal::is_value<LBD(_)>), (TRUE)); \
+    CHECK((metal::is_value<LAMBDA(N)>), (TRUE)); \
+    CHECK((metal::is_value<LAMBDA(_)>), (TRUE)); \
     CHECK((metal::value<>), (metal::nil)); \
 /**/
 

From 6538eb47435d1fdac64ed2bc701cee7c1de7a88e Mon Sep 17 00:00:00 2001
From: Bruno Dutra <brunocodutra@gmail.com>
Date: Tue, 6 Sep 2016 22:19:24 -0300
Subject: [PATCH 2/7] implement fold_right explicitly as a reversed fold_left

---
 include/metal/detail/fold_cons.hpp | 156 -------------------------
 include/metal/list/fold_left.hpp   | 175 +++++++++++++++++++++++++----
 include/metal/list/fold_right.hpp  | 132 +---------------------
 3 files changed, 156 insertions(+), 307 deletions(-)
 delete mode 100644 include/metal/detail/fold_cons.hpp

diff --git a/include/metal/detail/fold_cons.hpp b/include/metal/detail/fold_cons.hpp
deleted file mode 100644
index 41dcd271..00000000
--- a/include/metal/detail/fold_cons.hpp
+++ /dev/null
@@ -1,156 +0,0 @@
-// Copyright Bruno Dutra 2015-2016
-// Distributed under the Boost Software License, Version 1.0.
-// See accompanying file LICENSE.txt or copy at http://boost.org/LICENSE_1_0.txt
-
-#ifndef METAL_DETAIL_FOLD_CONS_HPP
-#define METAL_DETAIL_FOLD_CONS_HPP
-
-#include <metal/list/list.hpp>
-#include <metal/lambda/lambda.hpp>
-#include <metal/number/number.hpp>
-#include <metal/value/value.hpp>
-
-namespace metal
-{
-    namespace detail
-    {
-        template<typename cons, typename state, typename lbd, typename = true_>
-        struct _fold_cons
-        {};
-
-        template<
-            typename _00, typename _01, typename _02, typename _03,
-            typename _04, typename _05, typename _06, typename _07,
-            typename _08, typename _09, typename _10, typename _11,
-            typename _12, typename _13, typename _14, typename _15,
-            typename _16, typename _17, typename _18, typename _19,
-            typename _20, typename _21, typename _22, typename _23,
-            typename _24, typename _25, typename _26, typename _27,
-            typename _28, typename _29, typename _30, typename _31,
-            typename _32, typename _33, typename _34, typename _35,
-            typename _36, typename _37, typename _38, typename _39,
-            typename _40, typename _41, typename _42, typename _43,
-            typename _44, typename _45, typename _46, typename _47,
-            typename _48, typename _49, typename _50, typename _51,
-            typename _52, typename _53, typename _54, typename _55,
-            typename _56, typename _57, typename _58, typename _59,
-            typename _60, typename _61, typename _62, typename _63,
-            typename _64, typename _65, typename _66, typename _67,
-            typename _68, typename _69, typename _70, typename _71,
-            typename _72, typename _73, typename _74, typename _75,
-            typename _76, typename _77, typename _78, typename _79,
-            typename _80, typename _81, typename _82, typename _83,
-            typename _84, typename _85, typename _86, typename _87,
-            typename _88, typename _89, typename _90, typename _91,
-            typename _92, typename _93, typename _94, typename _95,
-            typename _96, typename _97, typename _98, typename _99,
-            typename tail,
-            typename state, template<typename...> class expr
-        >
-        struct _fold_cons<
-            list<
-                _00, _01, _02, _03, _04, _05, _06, _07, _08, _09,
-                _10, _11, _12, _13, _14, _15, _16, _17, _18, _19,
-                _20, _21, _22, _23, _24, _25, _26, _27, _28, _29,
-                _30, _31, _32, _33, _34, _35, _36, _37, _38, _39,
-                _40, _41, _42, _43, _44, _45, _46, _47, _48, _49,
-                _50, _51, _52, _53, _54, _55, _56, _57, _58, _59,
-                _60, _61, _62, _63, _64, _65, _66, _67, _68, _69,
-                _70, _71, _72, _73, _74, _75, _76, _77, _78, _79,
-                _80, _81, _82, _83, _84, _85, _86, _87, _88, _89,
-                _90, _91, _92, _93, _94, _95, _96, _97, _98, _99, tail
-            >,
-            state,
-            lambda<expr>,
-            is_value<
-                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<
-                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<
-                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<
-                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<
-                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<
-                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<
-                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<
-                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<
-                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<
-                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<state,
-                    _00>, _01>, _02>, _03>, _04>, _05>, _06>, _07>, _08>, _09>,
-                    _10>, _11>, _12>, _13>, _14>, _15>, _16>, _17>, _18>, _19>,
-                    _20>, _21>, _22>, _23>, _24>, _25>, _26>, _27>, _28>, _29>,
-                    _30>, _31>, _32>, _33>, _34>, _35>, _36>, _37>, _38>, _39>,
-                    _40>, _41>, _42>, _43>, _44>, _45>, _46>, _47>, _48>, _49>,
-                    _50>, _51>, _52>, _53>, _54>, _55>, _56>, _57>, _58>, _59>,
-                    _60>, _61>, _62>, _63>, _64>, _65>, _66>, _67>, _68>, _69>,
-                    _70>, _71>, _72>, _73>, _74>, _75>, _76>, _77>, _78>, _79>,
-                    _80>, _81>, _82>, _83>, _84>, _85>, _86>, _87>, _88>, _89>,
-                    _90>, _91>, _92>, _93>, _94>, _95>, _96>, _97>, _98>, _99>
-            >
-        > :
-            _fold_cons<
-                tail,
-                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<
-                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<
-                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<
-                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<
-                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<
-                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<
-                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<
-                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<
-                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<
-                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<state,
-                    _00>, _01>, _02>, _03>, _04>, _05>, _06>, _07>, _08>, _09>,
-                    _10>, _11>, _12>, _13>, _14>, _15>, _16>, _17>, _18>, _19>,
-                    _20>, _21>, _22>, _23>, _24>, _25>, _26>, _27>, _28>, _29>,
-                    _30>, _31>, _32>, _33>, _34>, _35>, _36>, _37>, _38>, _39>,
-                    _40>, _41>, _42>, _43>, _44>, _45>, _46>, _47>, _48>, _49>,
-                    _50>, _51>, _52>, _53>, _54>, _55>, _56>, _57>, _58>, _59>,
-                    _60>, _61>, _62>, _63>, _64>, _65>, _66>, _67>, _68>, _69>,
-                    _70>, _71>, _72>, _73>, _74>, _75>, _76>, _77>, _78>, _79>,
-                    _80>, _81>, _82>, _83>, _84>, _85>, _86>, _87>, _88>, _89>,
-                    _90>, _91>, _92>, _93>, _94>, _95>, _96>, _97>, _98>, _99>,
-                lambda<expr>
-            >
-        {};
-
-        template<
-            typename _00, typename _01, typename _02, typename _03,
-            typename _04, typename _05, typename _06, typename _07,
-            typename _08, typename _09, typename tail,
-            typename state, template<typename...> class expr
-        >
-        struct _fold_cons<
-            list<_00, _01, _02, _03, _04, _05, _06, _07, _08, _09, tail>,
-            state,
-            lambda<expr>,
-            is_value<
-                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<state,
-                    _00>, _01>, _02>, _03>, _04>, _05>, _06>, _07>, _08>, _09>
-            >
-        > :
-            _fold_cons<
-                tail,
-                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<state,
-                    _00>, _01>, _02>, _03>, _04>, _05>, _06>, _07>, _08>, _09>,
-                lambda<expr>
-            >
-        {};
-
-        template<
-            typename head, typename tail,
-            typename state, template<typename...> class expr
-        >
-        struct _fold_cons<list<head, tail>, state, lambda<expr>,
-            is_value<expr<state, head>>
-        > :
-            _fold_cons<tail, expr<state, head>, lambda<expr>>
-        {};
-
-        template<typename state, template<typename...> class expr>
-        struct _fold_cons<list<>, state, lambda<expr>>
-        {
-            using type = state;
-        };
-    }
-}
-
-#endif
-
diff --git a/include/metal/list/fold_left.hpp b/include/metal/list/fold_left.hpp
index 47a25e5d..8cf0c7f1 100644
--- a/include/metal/list/fold_left.hpp
+++ b/include/metal/list/fold_left.hpp
@@ -24,21 +24,157 @@ namespace metal
 }
 
 #include <metal/list/list.hpp>
+#include <metal/lambda/lambda.hpp>
 #include <metal/number/number.hpp>
-
-#include <metal/detail/fold_cons.hpp>
+#include <metal/value/value.hpp>
 
 namespace metal
 {
     namespace detail
     {
+        template<typename cons, typename state, typename lbd, typename = true_>
+        struct _fold_left_impl
+        {};
+
+        template<
+            typename _00, typename _01, typename _02, typename _03,
+            typename _04, typename _05, typename _06, typename _07,
+            typename _08, typename _09, typename _10, typename _11,
+            typename _12, typename _13, typename _14, typename _15,
+            typename _16, typename _17, typename _18, typename _19,
+            typename _20, typename _21, typename _22, typename _23,
+            typename _24, typename _25, typename _26, typename _27,
+            typename _28, typename _29, typename _30, typename _31,
+            typename _32, typename _33, typename _34, typename _35,
+            typename _36, typename _37, typename _38, typename _39,
+            typename _40, typename _41, typename _42, typename _43,
+            typename _44, typename _45, typename _46, typename _47,
+            typename _48, typename _49, typename _50, typename _51,
+            typename _52, typename _53, typename _54, typename _55,
+            typename _56, typename _57, typename _58, typename _59,
+            typename _60, typename _61, typename _62, typename _63,
+            typename _64, typename _65, typename _66, typename _67,
+            typename _68, typename _69, typename _70, typename _71,
+            typename _72, typename _73, typename _74, typename _75,
+            typename _76, typename _77, typename _78, typename _79,
+            typename _80, typename _81, typename _82, typename _83,
+            typename _84, typename _85, typename _86, typename _87,
+            typename _88, typename _89, typename _90, typename _91,
+            typename _92, typename _93, typename _94, typename _95,
+            typename _96, typename _97, typename _98, typename _99,
+            typename tail,
+            typename state, template<typename...> class expr
+        >
+        struct _fold_left_impl<
+            list<
+                _00, _01, _02, _03, _04, _05, _06, _07, _08, _09,
+                _10, _11, _12, _13, _14, _15, _16, _17, _18, _19,
+                _20, _21, _22, _23, _24, _25, _26, _27, _28, _29,
+                _30, _31, _32, _33, _34, _35, _36, _37, _38, _39,
+                _40, _41, _42, _43, _44, _45, _46, _47, _48, _49,
+                _50, _51, _52, _53, _54, _55, _56, _57, _58, _59,
+                _60, _61, _62, _63, _64, _65, _66, _67, _68, _69,
+                _70, _71, _72, _73, _74, _75, _76, _77, _78, _79,
+                _80, _81, _82, _83, _84, _85, _86, _87, _88, _89,
+                _90, _91, _92, _93, _94, _95, _96, _97, _98, _99, tail
+            >,
+            state,
+            lambda<expr>,
+            is_value<
+                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<
+                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<
+                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<
+                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<
+                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<
+                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<
+                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<
+                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<
+                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<
+                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<state,
+                    _00>, _01>, _02>, _03>, _04>, _05>, _06>, _07>, _08>, _09>,
+                    _10>, _11>, _12>, _13>, _14>, _15>, _16>, _17>, _18>, _19>,
+                    _20>, _21>, _22>, _23>, _24>, _25>, _26>, _27>, _28>, _29>,
+                    _30>, _31>, _32>, _33>, _34>, _35>, _36>, _37>, _38>, _39>,
+                    _40>, _41>, _42>, _43>, _44>, _45>, _46>, _47>, _48>, _49>,
+                    _50>, _51>, _52>, _53>, _54>, _55>, _56>, _57>, _58>, _59>,
+                    _60>, _61>, _62>, _63>, _64>, _65>, _66>, _67>, _68>, _69>,
+                    _70>, _71>, _72>, _73>, _74>, _75>, _76>, _77>, _78>, _79>,
+                    _80>, _81>, _82>, _83>, _84>, _85>, _86>, _87>, _88>, _89>,
+                    _90>, _91>, _92>, _93>, _94>, _95>, _96>, _97>, _98>, _99>
+            >
+        > :
+            _fold_left_impl<
+                tail,
+                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<
+                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<
+                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<
+                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<
+                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<
+                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<
+                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<
+                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<
+                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<
+                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<state,
+                    _00>, _01>, _02>, _03>, _04>, _05>, _06>, _07>, _08>, _09>,
+                    _10>, _11>, _12>, _13>, _14>, _15>, _16>, _17>, _18>, _19>,
+                    _20>, _21>, _22>, _23>, _24>, _25>, _26>, _27>, _28>, _29>,
+                    _30>, _31>, _32>, _33>, _34>, _35>, _36>, _37>, _38>, _39>,
+                    _40>, _41>, _42>, _43>, _44>, _45>, _46>, _47>, _48>, _49>,
+                    _50>, _51>, _52>, _53>, _54>, _55>, _56>, _57>, _58>, _59>,
+                    _60>, _61>, _62>, _63>, _64>, _65>, _66>, _67>, _68>, _69>,
+                    _70>, _71>, _72>, _73>, _74>, _75>, _76>, _77>, _78>, _79>,
+                    _80>, _81>, _82>, _83>, _84>, _85>, _86>, _87>, _88>, _89>,
+                    _90>, _91>, _92>, _93>, _94>, _95>, _96>, _97>, _98>, _99>,
+                lambda<expr>
+            >
+        {};
+
+        template<
+            typename _00, typename _01, typename _02, typename _03,
+            typename _04, typename _05, typename _06, typename _07,
+            typename _08, typename _09, typename tail,
+            typename state, template<typename...> class expr
+        >
+        struct _fold_left_impl<
+            list<_00, _01, _02, _03, _04, _05, _06, _07, _08, _09, tail>,
+            state,
+            lambda<expr>,
+            is_value<
+                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<state,
+                    _00>, _01>, _02>, _03>, _04>, _05>, _06>, _07>, _08>, _09>
+            >
+        > :
+            _fold_left_impl<
+                tail,
+                expr<expr<expr<expr<expr<expr<expr<expr<expr<expr<state,
+                    _00>, _01>, _02>, _03>, _04>, _05>, _06>, _07>, _08>, _09>,
+                lambda<expr>
+            >
+        {};
+
+        template<
+            typename head, typename tail,
+            typename state, template<typename...> class expr
+        >
+        struct _fold_left_impl<list<head, tail>, state, lambda<expr>,
+            is_value<expr<state, head>>
+        > :
+            _fold_left_impl<tail, expr<state, head>, lambda<expr>>
+        {};
+
+        template<typename state, template<typename...> class expr>
+        struct _fold_left_impl<list<>, state, lambda<expr>>
+        {
+            using type = state;
+        };
+
         template<int_ n>
-        struct _cons_left_impl :
-            _cons_left_impl<(n >= 100) ? 100 : (n >= 10) ? 10 : (n >= 1)>
+        struct _cons_impl :
+            _cons_impl<(n >= 100) ? 100 : (n >= 10) ? 10 : (n >= 1)>
         {};
 
         template<>
-        struct _cons_left_impl<100>
+        struct _cons_impl<100>
         {
             template<
                 typename _00, typename _01, typename _02, typename _03,
@@ -79,14 +215,12 @@ namespace metal
                 _70, _71, _72, _73, _74, _75, _76, _77, _78, _79,
                 _80, _81, _82, _83, _84, _85, _86, _87, _88, _89,
                 _90, _91, _92, _93, _94, _95, _96, _97, _98, _99,
-                typename _cons_left_impl<
-                    sizeof...(tail)
-                >::template type<tail...>
+                typename _cons_impl<sizeof...(tail)>::template type<tail...>
             >;
         };
 
         template<>
-        struct _cons_left_impl<10>
+        struct _cons_impl<10>
         {
             template<
                 typename _00, typename _01, typename _02, typename _03,
@@ -95,41 +229,36 @@ namespace metal
             >
             using type = list<
                 _00, _01, _02, _03, _04, _05, _06, _07, _08, _09,
-                typename _cons_left_impl<
-                    sizeof...(tail)
-                >::template type<tail...>
+                typename _cons_impl<sizeof...(tail)>::template type<tail...>
             >;
         };
 
         template<>
-        struct _cons_left_impl<1>
+        struct _cons_impl<1>
         {
             template<typename head, typename... tail>
             using type = list<
                 head,
-                typename _cons_left_impl<
-                    sizeof...(tail)
-                >::template type<tail...>
+                typename _cons_impl<sizeof...(tail)>::template type<tail...>
             >;
         };
 
         template<>
-        struct _cons_left_impl<0>
+        struct _cons_impl<0>
         {
             template<typename...>
             using type = list<>;
         };
 
         template<typename... vals>
-        struct _cons_left
+        struct _cons
         {
-            using type = typename _cons_left_impl<
-                sizeof...(vals)
-            >::template type<vals...>;
+            using type =
+                typename _cons_impl<sizeof...(vals)>::template type<vals...>;
         };
 
         template<typename... vals>
-        using cons_left = typename _cons_left<vals...>::type;
+        using cons = typename _cons<vals...>::type;
 
         template<typename seq, typename state, typename lbd>
         struct _fold_left
@@ -137,7 +266,7 @@ namespace metal
 
         template<typename... vals, typename state, typename lbd>
         struct _fold_left<list<vals...>, state, lbd> :
-            _fold_cons<cons_left<vals...>, state, lbd>
+            _fold_left_impl<cons<vals...>, state, lbd>
         {};
     }
 }
diff --git a/include/metal/list/fold_right.hpp b/include/metal/list/fold_right.hpp
index ff2e6cc5..fa32a053 100644
--- a/include/metal/list/fold_right.hpp
+++ b/include/metal/list/fold_right.hpp
@@ -7,141 +7,17 @@
 
 #include <metal/config.hpp>
 
+#include <metal/list/reverse.hpp>
+#include <metal/list/fold_left.hpp>
+
 namespace metal
 {
-    namespace detail
-    {
-        template<typename seq, typename state, typename lbd>
-        struct _fold_right;
-    }
-
     /// \ingroup list
     ///
     /// ### Description
     /// ...
     template<typename seq, typename state, typename lbd>
-    using fold_right = typename detail::_fold_right<seq, state, lbd>::type;
-}
-
-#include <metal/list/list.hpp>
-#include <metal/number/number.hpp>
-
-#include <metal/detail/fold_cons.hpp>
-
-namespace metal
-{
-    namespace detail
-    {
-        template<int_ n>
-        struct _cons_right_impl :
-            _cons_right_impl<(n >= 100) ? 100 : (n >= 10) ? 10 : (n >= 1)>
-        {};
-
-        template<>
-        struct _cons_right_impl<100>
-        {
-            template<
-                typename _,
-                typename _00, typename _01, typename _02, typename _03,
-                typename _04, typename _05, typename _06, typename _07,
-                typename _08, typename _09, typename _10, typename _11,
-                typename _12, typename _13, typename _14, typename _15,
-                typename _16, typename _17, typename _18, typename _19,
-                typename _20, typename _21, typename _22, typename _23,
-                typename _24, typename _25, typename _26, typename _27,
-                typename _28, typename _29, typename _30, typename _31,
-                typename _32, typename _33, typename _34, typename _35,
-                typename _36, typename _37, typename _38, typename _39,
-                typename _40, typename _41, typename _42, typename _43,
-                typename _44, typename _45, typename _46, typename _47,
-                typename _48, typename _49, typename _50, typename _51,
-                typename _52, typename _53, typename _54, typename _55,
-                typename _56, typename _57, typename _58, typename _59,
-                typename _60, typename _61, typename _62, typename _63,
-                typename _64, typename _65, typename _66, typename _67,
-                typename _68, typename _69, typename _70, typename _71,
-                typename _72, typename _73, typename _74, typename _75,
-                typename _76, typename _77, typename _78, typename _79,
-                typename _80, typename _81, typename _82, typename _83,
-                typename _84, typename _85, typename _86, typename _87,
-                typename _88, typename _89, typename _90, typename _91,
-                typename _92, typename _93, typename _94, typename _95,
-                typename _96, typename _97, typename _98, typename _99,
-                typename... tail
-            >
-            using type = typename _cons_right_impl<
-                sizeof...(tail)
-            >::template type<
-                list<
-                    _99, _98, _97, _96, _95, _94, _93, _92, _91, _90,
-                    _89, _88, _87, _86, _85, _84, _83, _82, _81, _80,
-                    _79, _78, _77, _76, _75, _74, _73, _72, _71, _70,
-                    _69, _68, _67, _66, _65, _64, _63, _62, _61, _60,
-                    _59, _58, _57, _56, _55, _54, _53, _52, _51, _50,
-                    _49, _48, _47, _46, _45, _44, _43, _42, _41, _40,
-                    _39, _38, _37, _36, _35, _34, _33, _32, _31, _30,
-                    _29, _28, _27, _26, _25, _24, _23, _22, _21, _20,
-                    _19, _18, _17, _16, _15, _14, _13, _12, _11, _10,
-                    _09, _08, _07, _06, _05, _04, _03, _02, _01, _00,
-                    _
-                >,
-                tail...
-            >;
-        };
-
-        template<>
-        struct _cons_right_impl<10>
-        {
-            template<
-                typename _,
-                typename _00, typename _01, typename _02, typename _03,
-                typename _04, typename _05, typename _06, typename _07,
-                typename _08, typename _09, typename... tail
-            >
-            using type = typename _cons_right_impl<
-                sizeof...(tail)
-            >::template type<
-                list<_09, _08, _07, _06, _05, _04, _03, _02, _01, _00, _>,
-                tail...
-            >;
-        };
-
-        template<>
-        struct _cons_right_impl<1>
-        {
-            template<typename _, typename head, typename... tail>
-            using type = typename _cons_right_impl<
-                sizeof...(tail)
-            >::template type<list<head, _>, tail...>;
-        };
-
-        template<>
-        struct _cons_right_impl<0>
-        {
-            template<typename _, typename...>
-            using type = _;
-        };
-
-        template<typename... vals>
-        struct _cons_right
-        {
-            using type = typename _cons_right_impl<
-                sizeof...(vals)
-            >::template type<list<>, vals...>;
-        };
-
-        template<typename... vals>
-        using cons_right = typename _cons_right<vals...>::type;
-
-        template<typename seq, typename state, typename lbd>
-        struct _fold_right
-        {};
-
-        template<typename... vals, typename state, typename lbd>
-        struct _fold_right<list<vals...>, state, lbd> :
-            _fold_cons<cons_right<vals...>, state, lbd>
-        {};
-    }
+    using fold_right = metal::fold_left<metal::reverse<seq>, state, lbd>;
 }
 
 #endif

From f0c1038d1db6962fbda44efd2e4a635e376e9e9e Mon Sep 17 00:00:00 2001
From: Bruno Dutra <brunocodutra@gmail.com>
Date: Tue, 6 Sep 2016 00:42:35 -0300
Subject: [PATCH 3/7] [doc] add a section dedicated to SFINAE-friendliness

---
 doc/Doxyfile.in               |  2 ++
 doc/manual.md                 | 31 ++++++++++++++++++++++++++++++-
 example/src/sfinae.cpp        | 25 +++++++++++++++++++++++++
 include/metal/value/value.hpp |  3 +--
 4 files changed, 58 insertions(+), 3 deletions(-)
 create mode 100644 example/src/sfinae.cpp

diff --git a/doc/Doxyfile.in b/doc/Doxyfile.in
index 3e6ada9e..cb90faf5 100644
--- a/doc/Doxyfile.in
+++ b/doc/Doxyfile.in
@@ -249,6 +249,8 @@ ALIASES +=pairs="\ref pair \"Pairs\""
 ALIASES +=map="\ref map"
 ALIASES +=maps="\ref map \"Maps\""
 
+ALIASES +=SFINAE="\ref SFINAE \"SFINAE\""
+
 ALIASES +=semantics="\par Semantics"
 
 ALIASES +=tip{1}="<div class=\"panel panel-info\"><div class="panel-heading"><span class=\"octicon octicon-light-bulb\"> Tip</span></div><div class="panel-body">\1</div></div>"
diff --git a/doc/manual.md b/doc/manual.md
index aa299898..cde8dac3 100644
--- a/doc/manual.md
+++ b/doc/manual.md
@@ -398,6 +398,33 @@ A [Map] is a [List] of [Pairs], whose first elements are all distinct, that is
 
 metal::map, metal::is_map, metal::keys, metal::values
 
+A Word on SFINAE-Friendliness {#SFINAE}
+================================================================================
+
+An [Expression] is said to be SFINAE-friendly when it is carefully designed so
+as never to prevent the [SFINAE] rule to be triggered. In general, such
+[Expressions] may only trigger template substitution errors at the point of
+instantiation of the *signature* of a type, which includes the instantiation of
+alias templates and default template arguments.
+
+SFINAE-friendly [Expressions] are exceedingly powerful, because they may be used
+to drive overload resolution, much like [`std::enable_if`][enable_if] does.
+For that reason all [Expressions] within `namespace metal` are guaranteed to be
+themselves SFINAE-friendly.
+
+\snippet sfinae.cpp SFINAE
+
+Conversely, an SFINAE-unfriendly [Expression] produces so called *hard errors*,
+which require the compilation to halt immediately. Examples of *hard errors*
+are failed `static_assert`'ions or template substitution errors at the point of
+instantiation of the nested members of a type.
+
+SFINAE-unfriendly [Expressions] are very inconvenient, because they force
+compilation to halt when they are not selected by overload resolution, thereby
+hindering the usage of the entire overloaded set. For that reason
+SFINAE-unfriendly [Expressions] should always be avoided.
+
+
 Metal in Action {#metal_in_action}
 ================================================================================
 
@@ -605,7 +632,7 @@ And ignores digit separators too.
 Church Booleans {#church_booleans}
 --------------------------------------------------------------------------------
 
-TODO
+[TODO]
 
 [Value]:            #value
 [Values]:           #value
@@ -646,7 +673,9 @@ TODO
 [constexpr]:        http://en.cppreference.com/w/cpp/language/constexpr
 [tuple]:            http://en.cppreference.com/w/cpp/utility/tuple
 [get]:              http://en.cppreference.com/w/cpp/utility/tuple/get
+[enable_if]:        http://en.cppreference.com/w/cpp/types/enable_if
 [literal]:          http://en.cppreference.com/w/cpp/language/user_literal
+[SFINAE]:           http://en.cppreference.com/w/cpp/language/sfinae
 
 [CMake]:            http://cmake.org/
 [Doxygen]:          http://doxygen.org/
diff --git a/example/src/sfinae.cpp b/example/src/sfinae.cpp
new file mode 100644
index 00000000..88a913cd
--- /dev/null
+++ b/example/src/sfinae.cpp
@@ -0,0 +1,25 @@
+// Copyright Bruno Dutra 2015-2016
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE.txt or copy at http://boost.org/LICENSE_1_0.txt
+
+#include <metal.hpp>
+
+#include <tuple>
+
+#include "example.hpp"
+
+/// [SFINAE]
+template<typename num>
+constexpr metal::if_<metal::is_number<num>, metal::int_> make() {
+    return num::value;
+} // instantiated for Numbers only
+
+template<typename seq>
+constexpr metal::apply<metal::lambda<std::tuple>, seq> make() {
+    return {};
+} // instantiated for Lists only
+
+static_assert(make<metal::number<42>>() == 42, "");
+static_assert(make<metal::list<int, char>>() == std::tuple<int, char>{}, "");
+/// [SFINAE]
+
diff --git a/include/metal/value/value.hpp b/include/metal/value/value.hpp
index b1298784..29a52d8d 100644
--- a/include/metal/value/value.hpp
+++ b/include/metal/value/value.hpp
@@ -24,8 +24,7 @@ namespace metal
     /// ### Description
     /// A tautological predicate that checks whether some type is a \value.
     ///
-    /// \tip{Use `metal::is_value` to trigger [SFINAE].}
-    /// [SFINAE]: http://en.cppreference.com/w/cpp/language/sfinae
+    /// \tip{Use `metal::is_value` to trigger \SFINAE.}
     ///
     /// ### Usage
     /// For any \value `val`

From d08bb4f93ebf24f53b8727271cad23ca05d53a95 Mon Sep 17 00:00:00 2001
From: Bruno Dutra <brunocodutra@gmail.com>
Date: Wed, 7 Sep 2016 12:32:12 -0300
Subject: [PATCH 4/7] [doc] fix minor issues

---
 doc/manual.md                 | 11 +++++------
 example/src/literal.cpp       |  2 +-
 include/metal/value/same.hpp  |  2 +-
 include/metal/value/value.hpp |  2 +-
 4 files changed, 8 insertions(+), 9 deletions(-)

diff --git a/doc/manual.md b/doc/manual.md
index cde8dac3..c86f10e9 100644
--- a/doc/manual.md
+++ b/doc/manual.md
@@ -486,8 +486,8 @@ At a first glance it might be tempting to try something like this
 \snippet literal.cpp naive_2
 }
 
-but do not forget why we're here to begin with, that is, recall we can't
-instantiate a template using a non-constexpr variable as argument!
+but let us not forget why we're here to begin with, that is, recall we can't
+instantiate a template using a non-`constexpr` variable as argument!
 
 At this point, a watchful reader might argue that in theory there is no real
 reason for this to be rejected, since the literal value must always be known at
@@ -535,8 +535,8 @@ individual digits according to the radix.
 To parse characters into their corresponding numerical value, we must first
 remove all digit separators.
 That can be easily accomplished using `metal::remove`, which takes a [List] `l`
-and a [Value] `v` and returns another [List] that contains every element from
-`l` and in the same order, except for those that are identical to `v`.
+and a [Value] `val` and returns another [List] that contains every element from
+`l` and in the same order, except for those that are identical to `val`.
 
 \snippet literal.cpp remove
 
@@ -550,8 +550,7 @@ another [List] containing the results of invoking `lbd` for each element in `l`.
 
 \snippet literal.cpp transform
 
-Notice how integral values of type `char` are translated into their actual
-numerical representation.
+Notice how characters are translated into their actual numerical representation.
 
 So there it is
 
diff --git a/example/src/literal.cpp b/example/src/literal.cpp
index 615dfc44..6c4f31f9 100644
--- a/example/src/literal.cpp
+++ b/example/src/literal.cpp
@@ -307,7 +307,6 @@ struct AugmentedTuple :
         return std::get<i>(*this);
     }
 };
-///[augmented_tuple]
 #else
 ///[augmented_tuple]
 template<typename... T>
@@ -322,6 +321,7 @@ struct AugmentedTuple :
         return std::get<i>(*this);
     }
 };
+///[augmented_tuple]
 #endif
 
 ///[teaser_1]
diff --git a/include/metal/value/same.hpp b/include/metal/value/same.hpp
index b9cd5620..1b8f7ff0 100644
--- a/include/metal/value/same.hpp
+++ b/include/metal/value/same.hpp
@@ -18,7 +18,7 @@ namespace metal
     /// \ingroup value
     ///
     /// ### Description
-    /// Checks whether \values are identical.
+    /// Checks whether all \values are identical.
     ///
     /// ### Usage
     /// For any \values `val_1, ..., val_n`
diff --git a/include/metal/value/value.hpp b/include/metal/value/value.hpp
index 29a52d8d..0bf3a827 100644
--- a/include/metal/value/value.hpp
+++ b/include/metal/value/value.hpp
@@ -57,7 +57,7 @@ namespace metal
     /// `::type`, unless `metal::value` is [empty](\ref nil), in which case it
     /// is undefined.
     ///
-    /// \tip{Use `metal::value` to prevent template pattern matching.}
+    /// \tip{Use `metal::value` to prevent undesired template pattern matching.}
     ///
     /// ### Usage
     /// For any \value `val`

From 0818f048375f13118484d7c6b31021ecde127f01 Mon Sep 17 00:00:00 2001
From: Bruno Dutra <brunocodutra@gmail.com>
Date: Wed, 7 Sep 2016 14:36:30 -0300
Subject: [PATCH 5/7] [doc] add google analytics tracking code

---
 doc/header.html | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/doc/header.html b/doc/header.html
index 1ca9259c..a769e241 100644
--- a/doc/header.html
+++ b/doc/header.html
@@ -32,6 +32,16 @@
     <script type="text/javascript" src="$relpath^bootstrap.min.js"></script>
     <script type="text/javascript" src="$relpath^metal.js"></script>
 
+    <script>
+      (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
+      (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
+      m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
+      })(window,document,'script','https://www.google-analytics.com/analytics.js','ga');
+
+      ga('create', 'UA-83817633-1', 'auto');
+      ga('send', 'pageview');
+    </script>
+
     <!-- HTML5 shim and Respond.js for IE8 support of HTML5 elements and media queries -->
     <!--[if lt IE 9]>
     <script src="https://oss.maxcdn.com/html5shiv/3.7.2/html5shiv.min.js"></script>

From 245a117e6eb5e4fb7974e0f35640e749517d1d71 Mon Sep 17 00:00:00 2001
From: Bruno Dutra <brunocodutra@gmail.com>
Date: Sun, 2 Oct 2016 19:28:15 +0200
Subject: [PATCH 6/7] [doc] fix compatibility issues with Doxygen 1.8.12

---
 doc/CMakeLists.txt |   5 +-
 doc/Doxyfile.in    | 233 ++++++++++++++++++++++++++++-----------------
 doc/css/metal.css  |  27 +-----
 doc/footer.html    |   2 +-
 doc/header.html    |   7 +-
 doc/js/metal.js    |  72 +++++++-------
 doc/layout.xml     |   2 +-
 7 files changed, 195 insertions(+), 153 deletions(-)

diff --git a/doc/CMakeLists.txt b/doc/CMakeLists.txt
index f2205f9f..e5d7cf4a 100644
--- a/doc/CMakeLists.txt
+++ b/doc/CMakeLists.txt
@@ -14,6 +14,7 @@ add_custom_target(doc
     COMMAND ${CMAKE_COMMAND} -E remove_directory "html"
     COMMAND ${DOXYGEN_EXECUTABLE} METAL_DOXYFILE
     COMMAND ${CMAKE_COMMAND} -E remove
-        "html/*.png" "html/dir_*.html" "html/namespacemetal.html"
-        "html/dynsections.js" "html/doxygen.css" "html/tabs.css"
+        "html/*.png" "html/dynsections.js" "html/doxygen.css" "html/tabs.css"
+        "html/dir_*.html" "html/namespacemetal.html"
+        "html/namespacemembers_type.html"
 )
diff --git a/doc/Doxyfile.in b/doc/Doxyfile.in
index cb90faf5..c920cd22 100644
--- a/doc/Doxyfile.in
+++ b/doc/Doxyfile.in
@@ -1,8 +1,4 @@
-# Copyright Bruno Dutra 2015-2016
-# Distributed under the Boost Software License, Version 1.0.
-# See accompanying file LICENSE.txt or copy at http://boost.org/LICENSE_1_0.txt
-
-# Doxyfile 1.8.9.1
+# Doxyfile 1.8.12
 
 # This file describes the settings to be used by the documentation system
 # doxygen (www.doxygen.org) for a project.
@@ -122,7 +118,17 @@ REPEAT_BRIEF           = YES
 # the entity):The $name class, The $name widget, The $name file, is, provides,
 # specifies, contains, represents, a, an and the.
 
-ABBREVIATE_BRIEF       =
+ABBREVIATE_BRIEF       = "The $name class" \
+                         "The $name widget" \
+                         "The $name file" \
+                         is \
+                         provides \
+                         specifies \
+                         contains \
+                         represents \
+                         a \
+                         an \
+                         the
 
 # If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
 # doxygen will generate a detailed section even if there is only a brief
@@ -232,30 +238,26 @@ TAB_SIZE               = 4
 # "Side Effects:". You can put \n's in the value part of an alias to insert
 # newlines.
 
-ALIASES += strike{1}="<div class=\"strike\">\1</div>"
-
-ALIASES +=value="\ref value"
-ALIASES +=values="\ref value \"Values\""
-ALIASES +=number="\ref number"
-ALIASES +=numbers="\ref number \"Numbers\""
-ALIASES +=expression="\ref expression"
-ALIASES +=expressions="\ref expression \"Expressions\""
-ALIASES +=lambda="\ref lambda"
-ALIASES +=lambdas="\ref lambda \"Lambdas\""
-ALIASES +=list="\ref list"
-ALIASES +=lists="\ref list \"Lists\""
-ALIASES +=pair="\ref pair"
-ALIASES +=pairs="\ref pair \"Pairs\""
-ALIASES +=map="\ref map"
-ALIASES +=maps="\ref map \"Maps\""
-
-ALIASES +=SFINAE="\ref SFINAE \"SFINAE\""
-
-ALIASES +=semantics="\par Semantics"
-
-ALIASES +=tip{1}="<div class=\"panel panel-info\"><div class="panel-heading"><span class=\"octicon octicon-light-bulb\"> Tip</span></div><div class="panel-body">\1</div></div>"
-ALIASES +=note{1}="<div class=\"panel panel-warning\"><div class="panel-heading"><span class=\"octicon octicon-info\"> Note</span></div><div class="panel-body">\1</div></div>"
-ALIASES +=warning{1}="<div class=\"panel panel-danger\"><div class="panel-heading"><span class=\"octicon octicon-stop\"> Warning</span></div><div class="panel-body">\1</div></div>"
+ALIASES                = "value=\ref value" \
+                         "values=\ref value \"Values\"" \
+                         "number=\ref number" \
+                         "numbers=\ref number \"Numbers\"" \
+                         "expression=\ref expression" \
+                         "expressions=\ref expression \"Expressions\"" \
+                         "lambda=\ref lambda" \
+                         "lambdas=\ref lambda \"Lambdas\"" \
+                         "list=\ref list" \
+                         "lists=\ref list \"Lists\"" \
+                         "pair=\ref pair" \
+                         "pairs=\ref pair \"Pairs\"" \
+                         "map=\ref map" \
+                         "maps=\ref map \"Maps\"" \
+                         "semantics=\par Semantics" \
+                         "SFINAE=\ref SFINAE \"SFINAE\"" \
+                         "tip{1}=<div class=\"panel panel-info\"><div class= panel-heading><span class=\"octicon octicon-light-bulb\"> Tip</span></div><div class= panel-body>\1</div></div>" \
+                         "note{1}=<div class=\"panel panel-warning\"><div class= panel-heading><span class=\"octicon octicon-info\"> Note</span></div><div class= panel-body>\1</div></div>" \
+                         "warning{1}=<div class=\"panel panel-danger\"><div class= panel-heading><span class=\"octicon octicon-stop\"> Warning</span></div><div class= panel-body>\1</div></div>" \
+                         "strike{1}=<div class=\"strike\">\1</div>"
 
 # This tag can be used to specify a number of word-keyword mappings (TCL only).
 # A mapping has the form "name=value". For example adding "class=itcl::class"
@@ -320,6 +322,15 @@ EXTENSION_MAPPING      =
 
 MARKDOWN_SUPPORT       = YES
 
+# When the TOC_INCLUDE_HEADINGS tag is set to a non-zero value, all headings up
+# to that level are automatically included in the table of contents, even if
+# they do not have an id attribute.
+# Note: This feature currently applies only to Markdown headings.
+# Minimum value: 0, maximum value: 99, default value: 0.
+# This tag requires that the tag MARKDOWN_SUPPORT is set to YES.
+
+TOC_INCLUDE_HEADINGS   = 0
+
 # When enabled doxygen tries to link words that correspond to documented
 # classes, or namespaces to their corresponding documentation. Such a link can
 # be prevented in individual cases by putting a % sign in front of the word or
@@ -336,7 +347,7 @@ AUTOLINK_SUPPORT       = YES
 # diagrams that involve STL classes more complete and accurate.
 # The default value is: NO.
 
-BUILTIN_STL_SUPPORT    = YES
+BUILTIN_STL_SUPPORT    = NO
 
 # If you use Microsoft's C++/CLI language, you should set this option to YES to
 # enable parsing support.
@@ -370,6 +381,13 @@ IDL_PROPERTY_SUPPORT   = YES
 
 DISTRIBUTE_GROUP_DOC   = YES
 
+# If one adds a struct or class to a group and this option is enabled, then also
+# any nested class or struct is added to the same group. By default this option
+# is disabled and one has to add nested compounds explicitly via \ingroup.
+# The default value is: NO.
+
+GROUP_NESTED_COMPOUNDS = NO
+
 # Set the SUBGROUPING tag to YES to allow class member groups of the same type
 # (for instance a group of public functions) to be put as a subgroup of that
 # type (e.g. under the Public Functions section). Set it to NO to prevent
@@ -377,7 +395,7 @@ DISTRIBUTE_GROUP_DOC   = YES
 # \nosubgrouping command.
 # The default value is: YES.
 
-SUBGROUPING            = NO
+SUBGROUPING            = YES
 
 # When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions
 # are shown inside the group in which they are included (e.g. using \ingroup)
@@ -388,7 +406,7 @@ SUBGROUPING            = NO
 # SEPARATE_MEMBER_PAGES.
 # The default value is: NO.
 
-INLINE_GROUPED_CLASSES = YES
+INLINE_GROUPED_CLASSES = NO
 
 # When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions
 # with only public data fields or simple typedef fields will be shown inline in
@@ -398,7 +416,7 @@ INLINE_GROUPED_CLASSES = YES
 # Man pages) or section (for LaTeX and RTF).
 # The default value is: NO.
 
-INLINE_SIMPLE_STRUCTS  = YES
+INLINE_SIMPLE_STRUCTS  = NO
 
 # When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or
 # enum is documented as struct, union, or enum with the name of the typedef. So
@@ -462,7 +480,7 @@ EXTRACT_STATIC         = NO
 # for Java sources.
 # The default value is: YES.
 
-EXTRACT_LOCAL_CLASSES  = NO
+EXTRACT_LOCAL_CLASSES  = YES
 
 # This flag is only useful for Objective-C code. If set to YES, local methods,
 # which are defined in the implementation section but not in the interface are
@@ -525,7 +543,7 @@ INTERNAL_DOCS          = NO
 # and Mac users are advised to set this option to NO.
 # The default value is: system dependent.
 
-CASE_SENSE_NAMES       = NO
+CASE_SENSE_NAMES       = YES
 
 # If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with
 # their full class and namespace scopes in the documentation. If set to YES, the
@@ -539,13 +557,13 @@ HIDE_SCOPE_NAMES       = NO
 # YES the compound reference will be hidden.
 # The default value is: NO.
 
-HIDE_COMPOUND_REFERENCE= YES
+HIDE_COMPOUND_REFERENCE= NO
 
 # If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of
 # the files that are included by a file in the documentation of that file.
 # The default value is: YES.
 
-SHOW_INCLUDE_FILES     = NO
+SHOW_INCLUDE_FILES     = YES
 
 # If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each
 # grouped member an include statement to the documentation, telling the reader
@@ -564,7 +582,7 @@ FORCE_LOCAL_INCLUDES   = NO
 # documentation for inline members.
 # The default value is: YES.
 
-INLINE_INFO            = NO
+INLINE_INFO            = YES
 
 # If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the
 # (detailed) documentation of file and class members alphabetically by member
@@ -579,7 +597,7 @@ SORT_MEMBER_DOCS       = YES
 # this will also influence the order of the classes in the class list.
 # The default value is: NO.
 
-SORT_BRIEF_DOCS        = YES
+SORT_BRIEF_DOCS        = NO
 
 # If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the
 # (brief and detailed) documentation of class members so that constructors and
@@ -591,14 +609,14 @@ SORT_BRIEF_DOCS        = YES
 # detailed member documentation.
 # The default value is: NO.
 
-SORT_MEMBERS_CTORS_1ST = YES
+SORT_MEMBERS_CTORS_1ST = NO
 
 # If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy
 # of group names into alphabetical order. If set to NO the group names will
 # appear in their defined order.
 # The default value is: NO.
 
-SORT_GROUP_NAMES       = YES
+SORT_GROUP_NAMES       = NO
 
 # If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by
 # fully-qualified names, including namespaces. If set to NO, the class list will
@@ -608,7 +626,7 @@ SORT_GROUP_NAMES       = YES
 # list.
 # The default value is: NO.
 
-SORT_BY_SCOPE_NAME     = YES
+SORT_BY_SCOPE_NAME     = NO
 
 # If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper
 # type resolution of all parameters of a function it will reject a match between
@@ -667,21 +685,21 @@ MAX_INITIALIZER_LINES  = 30
 # list will mention the files that were used to generate the documentation.
 # The default value is: YES.
 
-SHOW_USED_FILES        = NO
+SHOW_USED_FILES        = YES
 
 # Set the SHOW_FILES tag to NO to disable the generation of the Files page. This
 # will remove the Files entry from the Quick Index and from the Folder Tree View
 # (if specified).
 # The default value is: YES.
 
-SHOW_FILES             = NO
+SHOW_FILES             = YES
 
 # Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces
 # page. This will remove the Namespaces entry from the Quick Index and from the
 # Folder Tree View (if specified).
 # The default value is: YES.
 
-SHOW_NAMESPACES        = NO
+SHOW_NAMESPACES        = YES
 
 # The FILE_VERSION_FILTER tag can be used to specify a program or script that
 # doxygen should invoke to get the current version for each file (typically from
@@ -759,6 +777,12 @@ WARN_IF_DOC_ERROR      = YES
 
 WARN_NO_PARAMDOC       = NO
 
+# If the WARN_AS_ERROR tag is set to YES then doxygen will immediately stop when
+# a warning is encountered.
+# The default value is: NO.
+
+WARN_AS_ERROR          = NO
+
 # The WARN_FORMAT tag determines the format of the warning messages that doxygen
 # can produce. The string should contain the $file, $line, and $text tags, which
 # will be replaced by the file and line number from which the warning originated
@@ -782,12 +806,11 @@ WARN_LOGFILE           =
 # The INPUT tag is used to specify the files and/or directories that contain
 # documented source files. You may enter file names like myfile.cpp or
 # directories like /usr/src/myproject. Separate the files or directories with
-# spaces.
+# spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
 # Note: If this tag is empty the current directory is searched.
 
-INPUT                  =    @Metal_SOURCE_DIR@/doc/manual.md \
-                            @Metal_SOURCE_DIR@/include \
-
+INPUT                  = @Metal_SOURCE_DIR@/doc/manual.md \
+                         @Metal_SOURCE_DIR@/include
 
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
@@ -800,14 +823,20 @@ INPUT_ENCODING         = UTF-8
 
 # If the value of the INPUT tag contains directories, you can use the
 # FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and
-# *.h) to filter out the source-files in the directories. If left blank the
-# following patterns are tested:*.c, *.cc, *.cxx, *.cpp, *.c++, *.java, *.ii,
-# *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h, *.hh, *.hxx, *.hpp,
-# *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc, *.m, *.markdown,
-# *.md, *.mm, *.dox, *.py, *.f90, *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf,
-# *.qsf, *.as and *.js.
+# *.h) to filter out the source-files in the directories.
+#
+# Note that for custom extensions or not directly supported extensions you also
+# need to set EXTENSION_MAPPING for the extension otherwise the files are not
+# read by doxygen.
+#
+# If left blank the following patterns are tested:*.c, *.cc, *.cxx, *.cpp,
+# *.c++, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h,
+# *.hh, *.hxx, *.hpp, *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc,
+# *.m, *.markdown, *.md, *.mm, *.dox, *.py, *.pyw, *.f90, *.f95, *.f03, *.f08,
+# *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf and *.qsf.
 
-FILE_PATTERNS          = *.hpp *.md
+FILE_PATTERNS          = *.hpp \
+                         *.md
 
 # The RECURSIVE tag can be used to specify whether or not subdirectories should
 # be searched for input files as well.
@@ -891,6 +920,10 @@ IMAGE_PATH             =
 # Note that the filter must not add or remove lines; it is applied before the
 # code is scanned, but not when the output code is generated. If lines are added
 # or removed, the anchors will not be placed correctly.
+#
+# Note that for custom extensions or not directly supported extensions you also
+# need to set EXTENSION_MAPPING for the extension otherwise the files are not
+# properly processed by doxygen.
 
 INPUT_FILTER           =
 
@@ -900,6 +933,10 @@ INPUT_FILTER           =
 # (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how
 # filters are used. If the FILTER_PATTERNS tag is empty or if none of the
 # patterns match the file name, INPUT_FILTER is applied.
+#
+# Note that for custom extensions or not directly supported extensions you also
+# need to set EXTENSION_MAPPING for the extension otherwise the files are not
+# properly processed by doxygen.
 
 FILTER_PATTERNS        =
 
@@ -969,7 +1006,7 @@ REFERENCES_RELATION    = NO
 # link to the documentation.
 # The default value is: YES.
 
-REFERENCES_LINK_SOURCE = NO
+REFERENCES_LINK_SOURCE = YES
 
 # If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the
 # source code will show a tooltip with additional information such as prototype,
@@ -1027,7 +1064,7 @@ ALPHABETICAL_INDEX     = YES
 # Minimum value: 1, maximum value: 20, default value: 5.
 # This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
 
-COLS_IN_ALPHA_INDEX    = 1
+COLS_IN_ALPHA_INDEX    = 5
 
 # In case all classes in a project start with a common prefix, all classes will
 # be put under the same header in the alphabetical index. The IGNORE_PREFIX tag
@@ -1124,16 +1161,16 @@ HTML_EXTRA_STYLESHEET  =
 # files will be copied as-is; there are no commands or markers available.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
-HTML_EXTRA_FILES       =    @Metal_SOURCE_DIR@/doc/icons/octicons.eot \
-                            @Metal_SOURCE_DIR@/doc/icons/octicons.svg \
-                            @Metal_SOURCE_DIR@/doc/icons/octicons.ttf \
-                            @Metal_SOURCE_DIR@/doc/icons/octicons.woff \
-                            @Metal_SOURCE_DIR@/doc/css/bootstrap.min.css \
-                            @Metal_SOURCE_DIR@/doc/css/octicons.css \
-                            @Metal_SOURCE_DIR@/doc/css/metal.css \
-                            @Metal_SOURCE_DIR@/doc/js/bootstrap.min.js \
-                            @Metal_SOURCE_DIR@/doc/js/jquery.js \
-                            @Metal_SOURCE_DIR@/doc/js/metal.js \
+HTML_EXTRA_FILES       = @Metal_SOURCE_DIR@/doc/icons/octicons.eot \
+                         @Metal_SOURCE_DIR@/doc/icons/octicons.svg \
+                         @Metal_SOURCE_DIR@/doc/icons/octicons.ttf \
+                         @Metal_SOURCE_DIR@/doc/icons/octicons.woff \
+                         @Metal_SOURCE_DIR@/doc/css/bootstrap.min.css \
+                         @Metal_SOURCE_DIR@/doc/css/octicons.css \
+                         @Metal_SOURCE_DIR@/doc/css/metal.css \
+                         @Metal_SOURCE_DIR@/doc/js/bootstrap.min.js \
+                         @Metal_SOURCE_DIR@/doc/js/jquery.js \
+                         @Metal_SOURCE_DIR@/doc/js/metal.js
 
 # The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen
 # will adjust the colors in the style sheet and background images according to
@@ -1144,7 +1181,7 @@ HTML_EXTRA_FILES       =    @Metal_SOURCE_DIR@/doc/icons/octicons.eot \
 # Minimum value: 0, maximum value: 359, default value: 220.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
-HTML_COLORSTYLE_HUE    = 210
+HTML_COLORSTYLE_HUE    = 220
 
 # The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors
 # in the HTML output. For a value of 0 the output will use grayscales only. A
@@ -1152,7 +1189,7 @@ HTML_COLORSTYLE_HUE    = 210
 # Minimum value: 0, maximum value: 255, default value: 100.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
-HTML_COLORSTYLE_SAT    = 0
+HTML_COLORSTYLE_SAT    = 100
 
 # The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the
 # luminance component of the colors in the HTML output. Values below 100
@@ -1163,12 +1200,13 @@ HTML_COLORSTYLE_SAT    = 0
 # Minimum value: 40, maximum value: 240, default value: 80.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
-HTML_COLORSTYLE_GAMMA  = 101
+HTML_COLORSTYLE_GAMMA  = 80
 
 # If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
 # page will contain the date and time when the page was generated. Setting this
-# to NO can help when comparing the output of multiple runs.
-# The default value is: YES.
+# to YES can help to show when doxygen was last run and thus if the
+# documentation is up to date.
+# The default value is: NO.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
 HTML_TIMESTAMP         = NO
@@ -1192,7 +1230,7 @@ HTML_DYNAMIC_SECTIONS  = NO
 # Minimum value: 0, maximum value: 9999, default value: 100.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
-HTML_INDEX_NUM_ENTRIES = 0
+HTML_INDEX_NUM_ENTRIES = 100
 
 # If the GENERATE_DOCSET tag is set to YES, additional index files will be
 # generated that can be used as input for Apple's Xcode 3 integrated development
@@ -1391,7 +1429,7 @@ ECLIPSE_DOC_ID         = org.doxygen.Project
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
-DISABLE_INDEX          = NO
+DISABLE_INDEX          = YES
 
 # The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
 # structure should be generated to display hierarchical information. If the tag
@@ -1642,9 +1680,12 @@ COMPACT_LATEX          = NO
 PAPER_TYPE             = a4
 
 # The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names
-# that should be included in the LaTeX output. To get the times font for
-# instance you can specify
-# EXTRA_PACKAGES=times
+# that should be included in the LaTeX output. The package can be specified just
+# by its name or with the correct syntax as to be used with the LaTeX
+# \usepackage command. To get the times font for instance you can specify :
+# EXTRA_PACKAGES=times or EXTRA_PACKAGES={times}
+# To use the option intlimits with the amsmath package you can specify:
+# EXTRA_PACKAGES=[intlimits]{amsmath}
 # If left blank no extra packages will be included.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
@@ -1747,6 +1788,14 @@ LATEX_SOURCE_CODE      = NO
 
 LATEX_BIB_STYLE        = plain
 
+# If the LATEX_TIMESTAMP tag is set to YES then the footer of each generated
+# page will contain the date and time when the page was generated. Setting this
+# to NO can help when comparing the output of multiple runs.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_TIMESTAMP        = NO
+
 #---------------------------------------------------------------------------
 # Configuration options related to the RTF output
 #---------------------------------------------------------------------------
@@ -1993,7 +2042,7 @@ EXPAND_ONLY_PREDEF     = NO
 # The default value is: YES.
 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
 
-SEARCH_INCLUDES        = NO
+SEARCH_INCLUDES        = YES
 
 # The INCLUDE_PATH tag can be used to specify one or more directories that
 # contain include files that are not input files but should be processed by the
@@ -2124,7 +2173,7 @@ DIA_PATH               =
 # and usage relations if the target is undocumented or is not a class.
 # The default value is: YES.
 
-HIDE_UNDOC_RELATIONS   = NO
+HIDE_UNDOC_RELATIONS   = YES
 
 # If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
 # available from the path. This tool is part of Graphviz (see:
@@ -2175,7 +2224,7 @@ DOT_FONTPATH           =
 # The default value is: YES.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
-CLASS_GRAPH            = NO
+CLASS_GRAPH            = YES
 
 # If the COLLABORATION_GRAPH tag is set to YES then doxygen will generate a
 # graph for each documented class showing the direct and indirect implementation
@@ -2184,14 +2233,14 @@ CLASS_GRAPH            = NO
 # The default value is: YES.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
-COLLABORATION_GRAPH    = NO
+COLLABORATION_GRAPH    = YES
 
 # If the GROUP_GRAPHS tag is set to YES then doxygen will generate a graph for
 # groups, showing the direct groups dependencies.
 # The default value is: YES.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
-GROUP_GRAPHS           = NO
+GROUP_GRAPHS           = YES
 
 # If the UML_LOOK tag is set to YES, doxygen will generate inheritance and
 # collaboration diagrams in a style similar to the OMG's Unified Modeling
@@ -2245,7 +2294,8 @@ INCLUDED_BY_GRAPH      = YES
 #
 # Note that enabling this option will significantly increase the time of a run.
 # So in most cases it will be better to enable call graphs for selected
-# functions only using the \callgraph command.
+# functions only using the \callgraph command. Disabling a call graph can be
+# accomplished by means of the command \hidecallgraph.
 # The default value is: NO.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
@@ -2256,7 +2306,8 @@ CALL_GRAPH             = NO
 #
 # Note that enabling this option will significantly increase the time of a run.
 # So in most cases it will be better to enable caller graphs for selected
-# functions only using the \callergraph command.
+# functions only using the \callergraph command. Disabling a caller graph can be
+# accomplished by means of the command \hidecallergraph.
 # The default value is: NO.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
@@ -2267,7 +2318,7 @@ CALLER_GRAPH           = NO
 # The default value is: YES.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
-GRAPHICAL_HIERARCHY    = NO
+GRAPHICAL_HIERARCHY    = YES
 
 # If the DIRECTORY_GRAPH tag is set to YES then doxygen will show the
 # dependencies a directory has on other directories in a graphical way. The
@@ -2279,11 +2330,15 @@ GRAPHICAL_HIERARCHY    = NO
 DIRECTORY_GRAPH        = YES
 
 # The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
-# generated by dot.
+# generated by dot. For an explanation of the image formats see the section
+# output formats in the documentation of the dot tool (Graphviz (see:
+# http://www.graphviz.org/)).
 # Note: If you choose svg you need to set HTML_FILE_EXTENSION to xhtml in order
 # to make the SVG files visible in IE 9+ (other browsers do not have this
 # requirement).
-# Possible values are: png, jpg, gif and svg.
+# Possible values are: png, jpg, gif, svg, png:gd, png:gd:gd, png:cairo,
+# png:cairo:gd, png:cairo:cairo, png:cairo:gdiplus, png:gdiplus and
+# png:gdiplus:gdiplus.
 # The default value is: png.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
diff --git a/doc/css/metal.css b/doc/css/metal.css
index 1c34b405..709ee561 100644
--- a/doc/css/metal.css
+++ b/doc/css/metal.css
@@ -53,29 +53,6 @@ html, body {
     width: 102px;
 }
 
-.toolbar > * {
-    border-bottom: 1px solid #EEEEEE;
-}
-
-.nav-pills > li > a:hover,
-.nav-pills > li > a:focus,
-.nav-pills > li > a:active {
-    background-color: #F9F9F9;
-}
-
-.nav-pills > li.active > a,
-.nav-pills > li.active > a:hover,
-.nav-pills > li.active > a:focus,
-.nav-pills > li.active > a:active {
-    background-color: #464646;
-}
-
-.nav-pills > li > a {
-    color: #464646;
-    padding-left: 0px;
-    padding-right: 0px;
-}
-
 .toc {
     background-color: #F9F9F9;
     border: 1px solid #EEEEEE;
@@ -211,6 +188,10 @@ i.octicon {
     margin-right: 10px;
 }
 
+.caret {
+    margin-left: .5em;
+}
+
 .strike {
     text-decoration: line-through;
 }
diff --git a/doc/footer.html b/doc/footer.html
index 1c2776db..55a15f34 100644
--- a/doc/footer.html
+++ b/doc/footer.html
@@ -9,7 +9,7 @@
               <li><iframe class="github-btn" src="https://ghbtns.com/github-btn.html?user=brunocodutra&amp;repo=metal&amp;type=watch&amp;count=true" title="Star on GitHub"></iframe></li>
               <li><iframe class="github-btn" src="https://ghbtns.com/github-btn.html?user=brunocodutra&amp;repo=metal&amp;type=fork&amp;count=true" title="Fork on GitHub"></iframe></li>
             </ul>
-            &copy; Copyright 2015
+            &copy; Copyright 2015-$year
             <a href="https://github.com/brunocodutra">Bruno Dutra</a>,
             <span class="hidden-xs">Distributed under the</span>
             <a href="http://www.boost.org/LICENSE_1_0.txt">
diff --git a/doc/header.html b/doc/header.html
index a769e241..14264839 100644
--- a/doc/header.html
+++ b/doc/header.html
@@ -60,8 +60,11 @@
           </div>
           <ul class="nav navbar-nav navbar-left">
             <li id="sections" class="active dropdown">
-              <a class="active dropdown-toggle" data-toggle="dropdown" href="#"><span class="name"></span><span class="caret"></span></a>
+              <a class="active dropdown-toggle" data-toggle="dropdown" href="#"><span id="name"></span><span class="caret"></span></a>
               <ul id="menu" class="dropdown-menu">
+                <li><a href="index.html"><i class="octicon octicon-book"></i><span>Documentation</span></a></li>
+                <li><a href="modules.html"><i class="octicon octicon-code"></i><span>Reference</span></a></li>
+                <li><a href="namespacemembers.html"><i class="octicon octicon-list-unordered"></i><span>Alphabetical Index</span></a></li>
               </ul>
             </li>
           </ul>
@@ -85,4 +88,4 @@
       </nav>
       <div class="container">
         <div class="row">
-          <div class="toolbar">
+          <div>
diff --git a/doc/js/metal.js b/doc/js/metal.js
index e04a31b1..87e1d55d 100644
--- a/doc/js/metal.js
+++ b/doc/js/metal.js
@@ -5,38 +5,29 @@
 $(function(){
     var page = window.location.pathname.split("/").pop().split("#")[0];
 
-    $("li > a[href='index.html'] > span")
-        .before("<i class='octicon octicon-book'></i>");
-    $("li > a[href='modules.html'] > span")
-        .before("<i class='octicon octicon-code'></i>");
-    $("li > a[href='namespacemembers.html'] > span")
-        .before("<i class='octicon octicon-list-unordered'></i>");
-
-    $(".current").removeClass("current").addClass("active");
-
-    $("#navrow1 > ul > li").appendTo("#menu");
-
-    $("#sections").on("click", function(){
-        $("> .active > .name", this).text($("#menu > .active", this).text());
-    }).click();
+    if(/[^_]+__[^_.]+.html/.test(page))
+        section = "modules.html";
+    else
+        section = page;
+
+    $("#sections > #menu a[href='" + section +"']").each(function(){
+        $(this).parent().addClass("active");
+        $("#sections #name").html($(this).html());
+    });
 
     if(/namespacemembers(_type)?\.html$/.test(page)){
-        $("[id='navrow4']")
-            .removeAttr("id")
-            .addClass("hidden-xs")
-            .find("> ul")
-            .addClass("nav nav-pills nav-justified")
-            .find("> li")
-            .removeClass("active")
+        var $entries = $("h3").addClass("index-entry");
+
+        $entries
             .find("> a")
-            .click(function(){
+            .each(function(){
+                var entry = $(this).attr("id").replace(/index_(.+)/g, "$1");
                 $(this)
-                    .parent().addClass("active")
-                    .siblings().removeClass("active");
+                    .addClass("anchor")
+                    .attr("id", entry)
+                    .attr("href", "#" + entry);
             });
 
-        var $entries = $("h3").addClass("index-entry");
-
         $entries
             .find("+ ul")
             .addClass("list-inline")
@@ -52,8 +43,13 @@ $(function(){
         })
     }
 
-    $(".levels, .arrow, .heading, .memSeparator, \
-        [id^='navrow'], [id^='nav-path'], [class^='separator\\:']").remove();
+    $("a[href^='" + page + "#']").each(function(){
+        $(this).attr("href", $(this).attr("href").replace(/.*(#.+)/g, "$1"));
+    });
+
+    $(".levels, .arrow, .heading, .memtitle, .memSeparator, [class^='separator\\:']").remove();
+
+    $("a + .memitem").prev().addClass("anchor");
 
     $("div.header")
         .each(function(){
@@ -92,16 +88,22 @@ $(function(){
                 .append($(".memtemplate", this).append("<br>").contents())
                 .append($(".memname td", this).contents())
                 .prependTo(this)
+                .each(function(){
+                    if(/.*=[^=]*detail::[^=]*/.test($(this).text())){
+                        $(this).html(
+                            $(this).html().replace(
+                                /(.+=) typedef.+/,
+                                "$1 unspecified"
+                            )
+                        );
+                    }
+                })
                 .contents()
                 .each(function(){
                     if(this.nodeType == 3){
                         this.data = this.data
-                            .replace(
-                                /= typedef( typename)? (?!std::).+/g,
-                                "= unspecified"
-                            )
-                            .replace(/= typedef/g, "=")
-                            .replace(/detail::[_a-zA-Z_]+/g, "unspecified");
+                            .replace(/= typedef/, "=")
+                            .replace(/detail::[_a-zA-Z0-9_]+/, "unspecified");
                     }
                 });
 
@@ -167,7 +169,7 @@ $(function(){
         $(this).attr("href", "#" + $(this).attr("id"));
     });
 
-    $("a[href^='" + page + "#'], a[href^='#']").click(function(){
+    $("a[href^='#']").click(function(){
         var href = "#" + $.attr(this, "href").split("#").pop();
         if(href.length > 1){
             $("html, body").animate({
diff --git a/doc/layout.xml b/doc/layout.xml
index a8d7e5ff..0ab44390 100644
--- a/doc/layout.xml
+++ b/doc/layout.xml
@@ -9,7 +9,7 @@ See accompanying file LICENSE.txt or copy at http://boost.org/LICENSE_1_0.txt
     <tab type="mainpage" visible="yes" title="Documentation"/>
     <tab type="modules" visible="yes" title="Reference" intro=" "/>
     <tab type="namespacemembers"
-         visible="$ALPHABETICAL_INDEX"
+         visible="yes"
          title="Alphabetical Index"
          intro=" "
     />

From 9c8ad40fc23c24e05342b6a0c9210e0e0a76efc8 Mon Sep 17 00:00:00 2001
From: Bruno Dutra <brunocodutra@gmail.com>
Date: Sun, 2 Oct 2016 22:08:52 +0200
Subject: [PATCH 7/7] bump to 0.3.2

---
 include/metal/config/version.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/metal/config/version.hpp b/include/metal/config/version.hpp
index 90e13571..58726356 100644
--- a/include/metal/config/version.hpp
+++ b/include/metal/config/version.hpp
@@ -30,7 +30,7 @@
 ///
 /// ### See Also
 /// \see [Semantic Versioning](http://semver.org/)
-#define METAL_PATCH 1
+#define METAL_PATCH 2
 
 /// \ingroup config
 /// \hideinitializer