diff --git a/.travis.yml b/.travis.yml
index 4590a0fc..fe34f488 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -46,9 +46,20 @@ matrix:
                   - clang-format-5.0
                 sources:
                   - *srcs
-                  - sourceline: 'deb http://apt.llvm.org/trusty/ llvm-toolchain-trusty main'
+                  - sourceline: 'deb http://apt.llvm.org/trusty/ llvm-toolchain-trusty-5.0 main'
                     key_url: 'http://apt.llvm.org/llvm-snapshot.gpg.key'
 
+      - os: linux
+        dist: trusty
+        compiler: g++
+        env: CXXVER=4.7
+        addons:
+            apt:
+                packages:
+                  - *pkgs
+                  - g++-4.7
+                sources: *srcs
+
       - os: linux
         dist: trusty
         compiler: g++
@@ -229,7 +240,7 @@ matrix:
                   - libc++abi-dev
                 sources:
                   - *srcs
-                  - sourceline: 'deb http://apt.llvm.org/trusty/ llvm-toolchain-trusty main'
+                  - sourceline: 'deb http://apt.llvm.org/trusty/ llvm-toolchain-trusty-5.0 main'
                     key_url: 'http://apt.llvm.org/llvm-snapshot.gpg.key'
 
       - os: osx
@@ -352,3 +363,8 @@ script:
         (cd "${METAL_BUILD_PATH}" && ctest --output-on-failure -E ^test.format)
     fi
 
+notifications:
+  webhooks:
+    urls: https://webhooks.gitter.im/e/f0433b6f1de0942ea9a8
+    on_success: change
+    on_failure: always
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 237d9b1c..61a81ca6 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -40,7 +40,7 @@ message(STATUS "Configuring Metal ${METAL_VERSION}")
 add_header_library(Metal "${METAL_INCLUDE_DIR}/metal.hpp")
 set_target_properties(Metal PROPERTIES
     INTERFACE_LIB_VERSION ${METAL_VERSION}
-    INTERFACE_COMPILE_FEATURES cxx_std_14
+    INTERFACE_COMPILE_FEATURES cxx_std_11
 )
 
 deploy_header_library(Metal)
diff --git a/README.md b/README.md
index a331966a..473f13b9 100644
--- a/README.md
+++ b/README.md
@@ -1,15 +1,9 @@
-# Metal - Metaprogramming Algorithms
+# Metal [![version]][semver] [![travis.badge]][travis.metal] [![appveyor.badge]][appveyor.metal] [![gitter.badge]][gitter.metal] [![godbolt.badge]][godbolt.metal]
 
-[![version]][semver]
-[![travis.badge]][travis.metal]
-[![appveyor.badge]][appveyor.metal]
+Metal is a single header C++11 library designed to make you love template
+metaprogramming.
 
-Metal is a header-only C++14 library designed to make template metaprogramming
-intuitive.
-
-__[Try it online][godbolt.metal]__
-
-## Modern
+## Overview
 
 ```.cpp
 #include <metal.hpp>
@@ -77,21 +71,24 @@ static_assert(metal::same<sorted, metal::list<y, z, x>>::value, "");
 // that and much more!
 ```
 
-Check out [more examples][examples].
+## Quick Start
 
-## Blazing Fast
+1. Download [metal.hpp][releases]
+2. `# include </path/to/metal.hpp>`
+3. Love template metaprogramming
 
-Minutes-long compile times are a thing of the past!
+## Blazing Fast
 
 You don't have to just take my word for it, see for yourself at [metaben.ch].
 
 ## Portable
 
-Don't worry, all your favourite compilers are continuously tested at
+The following compilers are continuously tested at
 [Travis CI][travis.metal] and [Appveyor CI][appveyor.metal].
 
 | Compiler          | Version   | Operating System
 |-------------------|-----------|-----------------------
+| GCC               | 4.7       | Ubuntu 14.04 LTS
 | GCC               | 4.8       | Ubuntu 14.04 LTS
 | GCC               | 4.9       | Ubuntu 14.04 LTS
 | GCC               | 5         | Ubuntu 14.04 LTS
@@ -135,12 +132,19 @@ Metal is distributed under the
 [appveyor.metal]:   http://ci.appveyor.com/project/brunocodutra/metal
 [appveyor.badge]:   http://ci.appveyor.com/api/projects/status/85pk8n05n4r5x103/branch/master?svg=true
 
+[gitter.metal]:     http://gitter.im/brunocodutra/metal?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge
+[gitter.badge]:     http://badges.gitter.im/brunocodutra/metal.svg
+
+[godbolt.metal]:    http://godbolt.org/g/RFwvic
+[godbolt.badge]:    http://img.shields.io/badge/try%20it-on%20godbolt-222266.svg
+
 [boost.license]:    http://boost.org/LICENSE_1_0.txt
 
 [CMake]:            http://cmake.org/
 [Doxygen]:          http://doxygen.org/
 [metaben.ch]:       http://metaben.ch/
 
+[releases]:         http://github.com/brunocodutra/metal/releases
 [documentation]:    http://brunocodutra.github.io/metal
 [examples]:         http://brunocodutra.github.io/metal/#examples
 [SFINAE]:           http://brunocodutra.github.io/metal/#SFINAE
diff --git a/appveyor.yml b/appveyor.yml
index 5bf6f605..74d7957e 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -58,3 +58,9 @@ build_script:
     ) else (
         pushd "%METAL_BUILD_PATH%" && ctest -C "%CONFIGURATION%" --output-on-failure -E ^test.format & popd
     )
+
+notifications:
+  - provider: Webhook
+    url: https://webhooks.gitter.im/e/5daddf3d6cedeb27ba90
+    on_build_failure: true
+    on_build_status_changed: true
diff --git a/doc/manual.md b/doc/manual.md
index 050557bb..0b3e36f2 100644
--- a/doc/manual.md
+++ b/doc/manual.md
@@ -2,30 +2,24 @@
 
 \tableofcontents
 
-Metal is a header-only C++14 library designed to make template metaprogramming
-intuitive. It provides a powerful high-level abstraction for compile-time
-algorithms that mimic the Standard Algorithms Library, hence
-**Metal** - <b>Meta</b>programming <b>Al</b>gorithms.
+Metal is a single header C++11 library designed to make you love template
+metaprogramming.
 
 There is a myriad of C++ metaprogramming libraries out there so why Metal?
 
 * **Portable** - compatible with the
 [most popular compilers][Metal.portable].
 * **Blazing fast** - browse up to date benchmarks at [metaben.ch].
-* **Trivial Integration** - everything you need in a single self-contained 
+* **Trivial Integration** - everything you need in a single self-contained
 header file [`metal.hpp`][Metal.standalone].
 * **SFINAE-Friendly** - [control overload resolution](#SFINAE) and make the most
 out of function templates.
 
-In a Glimpse {#in_a_glimpse}
+Overview {#overview}
 ================================================================================
 
 \snippet tutorial.cpp tutorial
 
-**[Try it online][godbolt.metal]!**
-
-Be sure to also have a look at the [examples](#examples) below.
-
 Definitions {#definitions}
 ================================================================================
 
@@ -234,7 +228,7 @@ you might have come up with something like this
 \snippet literal.cpp naive_1
 }
 
-only to realize the hard way that this is simply not valid C++14.
+only to realize the hard way that this is simply not valid C++.
 
 > error: non-type template argument is not a constant expression
 
@@ -590,14 +584,12 @@ but also for numerical values
 Again, this only works as expected because of the strict SFINAE-friendliness
 guarantees provided by Metal.
 
-Getting Started {#getting_started}
+Quick Start {#quick_start}
 ================================================================================
 
-Metal is distributed as a drop-in standalone header file and integrating it in
-your project is as easy as it gets:
-
-1. Download the [latest release][Metal.releases]
+1. Download [metal.hpp][Metal.releases]
 2. `# include </path/to/metal.hpp>`
+3. Love template metaprogramming
 
 Migrating from Boost.MPL {#MPL}
 ================================================================================
@@ -731,15 +723,12 @@ the binary representation of numerical values is entirely irrelevant.
 [Map]:              #map
 [Maps]:             #map
 
-[C++14]:            http://en.wikipedia.org/wiki/C%2B%2B14
-[JavaScript]:       http://en.wikipedia.org/wiki/JavaScript
 [higher-order]:     http://en.wikipedia.org/wiki/Higher-order_function
 [first-class]:      http://en.wikipedia.org/wiki/First-class_citizen
 [fold]:             http://en.wikipedia.org/wiki/Fold_(higher-order_function)
 [church]:           http://en.wikipedia.org/wiki/Church_encoding#Church_Booleans
 [lambda notation]:  http://en.wikipedia.org/wiki/Lambda_calculus
 
-[algorithm]:        http://en.cppreference.com/w/cpp/algorithm
 [alias templates]:  http://en.cppreference.com/w/cpp/language/type_alias
 [constexpr]:        http://en.cppreference.com/w/cpp/language/constexpr
 [tuple]:            http://en.cppreference.com/w/cpp/utility/tuple
@@ -751,8 +740,6 @@ the binary representation of numerical values is entirely irrelevant.
 [SFINAE]:           http://en.cppreference.com/w/cpp/language/sfinae
 [RAII]:             http://en.cppreference.com/w/cpp/language/raii
 
-[godbolt.metal]:    https://godbolt.org/g/JN13FQ
-
 [travis.metal]:     http://travis-ci.org/brunocodutra/metal
 [appveyor.metal]:   http://ci.appveyor.com/project/brunocodutra/metal
 
diff --git a/example/CMakeLists.txt b/example/CMakeLists.txt
index 05b079db..f6f22c35 100644
--- a/example/CMakeLists.txt
+++ b/example/CMakeLists.txt
@@ -15,5 +15,13 @@ else()
 endif()
 
 test_units(example Metal "${CMAKE_CURRENT_SOURCE_DIR}/src/" EXCLUDE ${exclude})
+foreach(target example.literal example.sfinae)
+    if(TARGET ${target})
+        set_target_properties(${target} PROPERTIES
+            CXX_STANDARD 14
+            CXX_STANDARD_REQUIRED OFF
+        )
+    endif()
+endforeach()
 
 add_custom_target(examples DEPENDS example)
diff --git a/example/src/lambda.cpp b/example/src/lambda.cpp
index ca44c7ce..d99a4f25 100644
--- a/example/src/lambda.cpp
+++ b/example/src/lambda.cpp
@@ -14,7 +14,10 @@
 
 HIDE(
 /// [lbd1]
-using lbd = metal::lambda<std::add_pointer_t>;
+template<typename T>
+using expr = T*;
+
+using lbd = metal::lambda<expr>;
 /// [lbd1]
 
 IS_SAME(metal::is_lambda<lbd>, metal::true_);
@@ -22,8 +25,11 @@ IS_SAME(metal::is_lambda<lbd>, metal::true_);
 
 HIDE(
 /// [is_lambda]
+template<typename T>
+using expr = T*;
+
 IS_SAME(metal::is_lambda<void>, metal::false_);
-IS_SAME(metal::is_lambda<metal::lambda<std::add_pointer_t>>, metal::true_);
+IS_SAME(metal::is_lambda<metal::lambda<expr>>, metal::true_);
 IS_SAME(metal::is_lambda<metal::trait<std::is_pointer>>, metal::true_);
 IS_SAME(metal::is_lambda<metal::lazy<std::add_pointer>>, metal::true_);
 /// [is_lambda]
@@ -99,7 +105,7 @@ IS_SAME(metal::invoke<metal::arg<4>, bool, char, long, float>, float);
 
 HIDE(
 /// [invoke]
-using lbd = metal::lambda<std::common_type_t>;
+using lbd = metal::lazy<std::common_type>;
 
 IS_SAME(metal::invoke<lbd, bool, char, long, float>, float);
 /// [invoke]
@@ -107,7 +113,7 @@ IS_SAME(metal::invoke<lbd, bool, char, long, float>, float);
 
 HIDE(
 /// [apply]
-using lbd = metal::lambda<std::common_type_t>;
+using lbd = metal::lazy<std::common_type>;
 
 IS_SAME(metal::apply<lbd, metal::list<bool, char, long, float>>, float);
 /// [apply]
@@ -115,7 +121,7 @@ IS_SAME(metal::apply<lbd, metal::list<bool, char, long, float>>, float);
 
 HIDE(
 /// [partial]
-using promote = metal::partial<metal::lambda<std::common_type_t>, int>;
+using promote = metal::partial<metal::lazy<std::common_type>, int>;
 
 IS_SAME(metal::invoke<promote, char>, int);
 IS_SAME(metal::invoke<promote, short>, int);
@@ -126,7 +132,7 @@ IS_SAME(metal::invoke<promote, long>, long);
 HIDE(
 /// [bind]
 using promote = metal::bind<
-    metal::lambda<std::common_type_t>,
+    metal::lazy<std::common_type>,
     metal::always<int>,
     metal::_1 // equivalent to metal::arg<1>
 >;
@@ -136,7 +142,7 @@ IS_SAME(metal::invoke<promote, short>, int);
 IS_SAME(metal::invoke<promote, long>, long);
 
 using uac = metal::bind< // usual arithmetic conversion
-    metal::lambda<std::common_type_t>,
+    metal::lazy<std::common_type>,
     metal::bind<promote, metal::_1>,
     metal::bind<promote, metal::_2>
 >;
diff --git a/example/src/list.cpp b/example/src/list.cpp
index b4efcfb2..c80e5202 100644
--- a/example/src/list.cpp
+++ b/example/src/list.cpp
@@ -424,8 +424,8 @@ IS_SAME(
 
 HIDE(
 /// [repeat]
-IS_SAME(metal::repeat<char, metal::number<0>>, metal::list<>);
-IS_SAME(metal::repeat<char, metal::number<3>>, metal::list<char, char, char>);
+IS_SAME(metal::repeat<void, metal::number<0>>, metal::list<>);
+IS_SAME(metal::repeat<void, metal::number<3>>, metal::list<void, void, void>);
 /// [repeat]
 )
 
@@ -661,6 +661,7 @@ IS_SAME(
 /// [transpose]
 )
 
+#if !defined(METAL_WORKAROUND)
 HIDE(
 /// [accumulate]
 template<typename val, typename num>
@@ -685,3 +686,4 @@ IS_SAME(
 );
 /// [accumulate]
 )
+#endif
diff --git a/example/src/literal.cpp b/example/src/literal.cpp
index a11b0b1e..c35a7de4 100644
--- a/example/src/literal.cpp
+++ b/example/src/literal.cpp
@@ -54,31 +54,35 @@ IS_SAME(metal::remove<tokens, metal::number<'\''>>, metal::numbers<'3', '7', '1'
 #endif
 
 ///[parse_digit]
-template<typename c>
-using parse_digit = metal::if_<
-    metal::same<c, metal::number<'0'>>, metal::number<0>,
-    metal::same<c, metal::number<'1'>>, metal::number<1>,
-    metal::same<c, metal::number<'2'>>, metal::number<2>,
-    metal::same<c, metal::number<'3'>>, metal::number<3>,
-    metal::same<c, metal::number<'4'>>, metal::number<4>,
-    metal::same<c, metal::number<'5'>>, metal::number<5>,
-    metal::same<c, metal::number<'6'>>, metal::number<6>,
-    metal::same<c, metal::number<'7'>>, metal::number<7>,
-    metal::same<c, metal::number<'8'>>, metal::number<8>,
-    metal::same<c, metal::number<'9'>>, metal::number<9>,
-    metal::same<c, metal::number<'a'>>, metal::number<10>,
-    metal::same<c, metal::number<'b'>>, metal::number<11>,
-    metal::same<c, metal::number<'c'>>, metal::number<12>,
-    metal::same<c, metal::number<'d'>>, metal::number<13>,
-    metal::same<c, metal::number<'e'>>, metal::number<14>,
-    metal::same<c, metal::number<'f'>>, metal::number<15>,
-    metal::same<c, metal::number<'A'>>, metal::number<10>,
-    metal::same<c, metal::number<'B'>>, metal::number<11>,
-    metal::same<c, metal::number<'C'>>, metal::number<12>,
-    metal::same<c, metal::number<'D'>>, metal::number<13>,
-    metal::same<c, metal::number<'E'>>, metal::number<14>,
-    metal::same<c, metal::number<'F'>>, metal::number<15>
+template<typename token>
+using parse_digit = metal::at_key<
+    metal::map<
+        metal::pair<metal::number<'0'>, metal::number<0>>,
+        metal::pair<metal::number<'1'>, metal::number<1>>,
+        metal::pair<metal::number<'2'>, metal::number<2>>,
+        metal::pair<metal::number<'3'>, metal::number<3>>,
+        metal::pair<metal::number<'4'>, metal::number<4>>,
+        metal::pair<metal::number<'5'>, metal::number<5>>,
+        metal::pair<metal::number<'6'>, metal::number<6>>,
+        metal::pair<metal::number<'7'>, metal::number<7>>,
+        metal::pair<metal::number<'8'>, metal::number<8>>,
+        metal::pair<metal::number<'9'>, metal::number<9>>,
+        metal::pair<metal::number<'a'>, metal::number<10>>,
+        metal::pair<metal::number<'b'>, metal::number<11>>,
+        metal::pair<metal::number<'c'>, metal::number<12>>,
+        metal::pair<metal::number<'d'>, metal::number<13>>,
+        metal::pair<metal::number<'e'>, metal::number<14>>,
+        metal::pair<metal::number<'f'>, metal::number<15>>,
+        metal::pair<metal::number<'A'>, metal::number<10>>,
+        metal::pair<metal::number<'B'>, metal::number<11>>,
+        metal::pair<metal::number<'C'>, metal::number<12>>,
+        metal::pair<metal::number<'D'>, metal::number<13>>,
+        metal::pair<metal::number<'E'>, metal::number<14>>,
+        metal::pair<metal::number<'F'>, metal::number<15>>
+    >,
+    token
 >;
+
 ///[parse_digit]
 
 HIDE(
diff --git a/example/src/number.cpp b/example/src/number.cpp
index 688a21b4..a0d60eab 100644
--- a/example/src/number.cpp
+++ b/example/src/number.cpp
@@ -91,9 +91,9 @@ IS_SAME(
 
 HIDE(
 /// [if_]
-IS_SAME(metal::if_<metal::false_, int, metal::number<0>, int*, void>, void);
-IS_SAME(metal::if_<metal::false_,  int, metal::number<1>, int*, void>, int*);
-IS_SAME(metal::if_<metal::true_,  int, metal::number<1>, int*, void>, int);
+IS_SAME(metal::if_<metal::true_, int>, int);
+IS_SAME(metal::if_<metal::true_, int, void>, int);
+IS_SAME(metal::if_<metal::false_, int, void>, void);
 /// [if_]
 )
 
diff --git a/example/src/value.cpp b/example/src/value.cpp
index 15e6a9dd..b814364b 100644
--- a/example/src/value.cpp
+++ b/example/src/value.cpp
@@ -41,7 +41,7 @@ int not_a_val;
 HIDE(
 static constexpr
 /// [not_a_val2]
-decltype(auto) not_a_val = 3.14;
+auto not_a_val = 3.14;
 /// [not_a_val2]
 )
 
@@ -138,6 +138,7 @@ IS_SAME(metal::distinct<void, void*, void**, void***, void****>, metal::true_);
 /// [distinct]
 )
 
+#if !defined(METAL_WORKAROUND)
 HIDE(
 /// [fold_left]
 template<typename x, typename y>
@@ -165,3 +166,4 @@ IS_SAME(
 );
 /// [fold_right]
 )
+#endif
diff --git a/include/metal.hpp b/include/metal.hpp
index 68928d70..8d01131b 100644
--- a/include/metal.hpp
+++ b/include/metal.hpp
@@ -16,6 +16,6 @@
 /// \defgroup metal Metal
 
 /// \namespace metal
-/// \brief Metaprogramming algorithms.
+/// \brief Metal
 
 #endif
diff --git a/include/metal/config/version.hpp b/include/metal/config/version.hpp
index b3b1b8bb..04e5536c 100644
--- a/include/metal/config/version.hpp
+++ b/include/metal/config/version.hpp
@@ -12,7 +12,7 @@
 ///
 /// ### See Also
 /// \see [Semantic Versioning](http://semver.org/)
-#define METAL_MAJOR 0
+#define METAL_MAJOR 1
 
 /// \ingroup config
 ///
@@ -21,7 +21,7 @@
 ///
 /// ### See Also
 /// \see [Semantic Versioning](http://semver.org/)
-#define METAL_MINOR 7
+#define METAL_MINOR 0
 
 /// \ingroup config
 ///
diff --git a/include/metal/list/accumulate.hpp b/include/metal/list/accumulate.hpp
index a6c76549..082c48a0 100644
--- a/include/metal/list/accumulate.hpp
+++ b/include/metal/list/accumulate.hpp
@@ -6,6 +6,9 @@
 #define METAL_LIST_ACCUMULATE_HPP
 
 #include "../config.hpp"
+#include "../list/size.hpp"
+#include "../number/if.hpp"
+#include "../value/same.hpp"
 #include "../detail/sfinae.hpp"
 
 namespace metal {
@@ -46,18 +49,16 @@ namespace metal {
     /// ### See Also
     /// \see list, transform, fold_left
     template<typename lbd, typename state, typename... seqs>
-    using accumulate =
-        detail::call<detail::_accumulate<lbd>::template type, state, seqs...>;
+    using accumulate = detail::call<
+        if_<same<size<seqs>...>, detail::_accumulate<lbd>>::template type,
+        state, seqs...>;
 }
 
 #include "../lambda/lambda.hpp"
 #include "../list/at.hpp"
 #include "../list/indices.hpp"
 #include "../list/list.hpp"
-#include "../list/size.hpp"
-#include "../number/if.hpp"
 #include "../value/fold_left.hpp"
-#include "../value/same.hpp"
 
 namespace metal {
     /// \cond
@@ -95,10 +96,8 @@ namespace metal {
         template<template<typename...> class expr>
         struct _accumulate<lambda<expr>> {
             template<typename state, typename... seqs>
-            using type = forward<
-                if_<same<size<seqs>...>,
-                    _accumulate_impl<state, seqs...>>::template type,
-                expr>;
+            using type =
+                forward<_accumulate_impl<state, seqs...>::template type, expr>;
         };
     }
     /// \endcond
diff --git a/include/metal/list/find_if.hpp b/include/metal/list/find_if.hpp
index d03232d3..51ac3526 100644
--- a/include/metal/list/find_if.hpp
+++ b/include/metal/list/find_if.hpp
@@ -58,18 +58,9 @@ namespace metal {
 #include "../number/if.hpp"
 #include "../number/number.hpp"
 
-#include <initializer_list>
-
 namespace metal {
     /// \cond
     namespace detail {
-        template<typename seq>
-        struct _find_if {};
-
-        template<>
-        struct _find_if<list<>> : number<0> {};
-
-#if defined(METAL_WORKAROUND)
         template<typename seq, typename = indices<seq>>
         struct _find_index {};
 
@@ -78,25 +69,15 @@ namespace metal {
             using type = front<join<if_<number<vs>, list<is>, list<>>...>>;
         };
 
+        template<typename seq>
+        struct _find_if {};
+
+        template<>
+        struct _find_if<list<>> : number<0> {};
+
         template<int_... vs>
         struct _find_if<list<number<vs>...>>
             : _find_index<list<number<vs>..., true_>> {};
-#else
-        template<typename... _>
-        constexpr int_ find_index(_... vs) {
-            int_ ret = 0;
-            for(int_ x : std::initializer_list<int_>{vs...}) {
-                if(x)
-                    break;
-                else
-                    ++ret;
-            }
-            return ret;
-        }
-
-        template<int_... vs>
-        struct _find_if<list<number<vs>...>> : number<find_index(vs...)> {};
-#endif
     }
     /// \endcond
 }
diff --git a/include/metal/list/iota.hpp b/include/metal/list/iota.hpp
index 9af11b7a..f2e9269f 100644
--- a/include/metal/list/iota.hpp
+++ b/include/metal/list/iota.hpp
@@ -59,25 +59,12 @@ namespace metal {
 #include "../number/if.hpp"
 #include "../number/numbers.hpp"
 
-#if defined(__has_builtin)
-#if __has_builtin(__make_integer_seq)
-#define METAL_USE_BUILTIN_MAKE_INTEGER_SEQ
-#endif
-#endif
-
 namespace metal {
     /// \cond
     namespace detail {
         template<int_... ns>
         struct enumeration {};
 
-#if defined(METAL_USE_BUILTIN_MAKE_INTEGER_SEQ)
-        template<typename int_, int_... ns>
-        using enumerator = enumeration<ns...>;
-
-        template<int_ n>
-        using enumerate = __make_integer_seq<enumerator, int_, n>;
-#else
         template<typename ns>
         struct _even {};
 
@@ -110,7 +97,7 @@ namespace metal {
         struct _enumerate<0> {
             using type = enumeration<>;
         };
-#endif
+
         template<typename, int_ a, int_ b>
         struct _iota_impl {};
 
diff --git a/include/metal/list/transform.hpp b/include/metal/list/transform.hpp
index 2757f793..7968f3ad 100644
--- a/include/metal/list/transform.hpp
+++ b/include/metal/list/transform.hpp
@@ -6,6 +6,9 @@
 #define METAL_LIST_TRANSFORM_HPP
 
 #include "../config.hpp"
+#include "../list/size.hpp"
+#include "../number/if.hpp"
+#include "../value/same.hpp"
 #include "../detail/sfinae.hpp"
 
 namespace metal {
@@ -48,17 +51,15 @@ namespace metal {
     /// ### See Also
     /// \see list, accumulate
     template<typename lbd, typename... seqs>
-    using transform =
-        detail::call<detail::_transform<lbd>::template type, seqs...>;
+    using transform = detail::call<
+        if_<same<size<seqs>...>, detail::_transform<lbd>>::template type,
+        seqs...>;
 }
 
 #include "../lambda/lambda.hpp"
 #include "../list/at.hpp"
 #include "../list/indices.hpp"
 #include "../list/list.hpp"
-#include "../list/size.hpp"
-#include "../number/if.hpp"
-#include "../value/same.hpp"
 
 namespace metal {
     /// \cond
@@ -108,10 +109,7 @@ namespace metal {
         template<template<typename...> class expr>
         struct _transform<lambda<expr>> {
             template<typename... seqs>
-            using type = forward<
-                if_<same<size<seqs>...>,
-                    _transform_impl<seqs...>>::template type,
-                expr>;
+            using type = forward<_transform_impl<seqs...>::template type, expr>;
         };
     }
     /// \endcond
diff --git a/include/metal/number/add.hpp b/include/metal/number/add.hpp
index bac4f102..d280d739 100644
--- a/include/metal/number/add.hpp
+++ b/include/metal/number/add.hpp
@@ -6,13 +6,18 @@
 #define METAL_NUMBER_ADD_HPP
 
 #include "../config.hpp"
-#include "../detail/sfinae.hpp"
+#include "../lambda/lambda.hpp"
+#include "../number/number.hpp"
+#include "../value/fold_left.hpp"
 
 namespace metal {
     /// \cond
     namespace detail {
-        template<typename... nums>
+        template<typename x, typename y>
         struct _add;
+
+        template<typename x, typename y>
+        using add = typename _add<x, y>::type;
     }
     /// \endcond
 
@@ -40,46 +45,16 @@ namespace metal {
     /// ### See Also
     /// \see number, abs, inc, dec, neg, sub, mul, div, mod, pow
     template<typename... nums>
-    using add = detail::call<detail::_add<nums...>::template type>;
-}
-
-#include "../lambda/lambda.hpp"
-#include "../number/number.hpp"
-#include "../value/fold_left.hpp"
-
-#include <initializer_list>
+    using add = fold_left<lambda<detail::add>, nums..., number<0>>;
 
-namespace metal {
     /// \cond
     namespace detail {
-        template<typename... nums>
-        struct _add {};
-
-#if defined(METAL_WORKAROUND)
         template<typename x, typename y>
-        using add_impl = number<x::value + y::value>;
-
-        template<int_... ns>
-        struct _add<number<ns>...> {
-            template<typename... _>
-            using type = fold_left<lambda<add_impl>, number<ns>..., _...>;
-        };
-#else
-        template<typename... _>
-        constexpr int_ add_impl(int_ head, _... tail) {
-            return void(std::initializer_list<int_>{(head += tail)...}), head;
-        }
+        struct _add {};
 
-        template<int_... ns>
-        struct _add<number<ns>...> {
-            template<typename... _>
-            using type = number<add_impl((void(sizeof...(_)), ns)...)>;
-        };
-#endif
-        template<>
-        struct _add<> {
-            template<typename...>
-            using type = number<0>;
+        template<int_ x, int_ y>
+        struct _add<number<x>, number<y>> {
+            using type = number<x + y>;
         };
     }
     /// \endcond
diff --git a/include/metal/number/div.hpp b/include/metal/number/div.hpp
index f879abf1..c208bfe8 100644
--- a/include/metal/number/div.hpp
+++ b/include/metal/number/div.hpp
@@ -6,13 +6,18 @@
 #define METAL_NUMBER_DIV_HPP
 
 #include "../config.hpp"
-#include "../detail/sfinae.hpp"
+#include "../lambda/lambda.hpp"
+#include "../number/number.hpp"
+#include "../value/fold_left.hpp"
 
 namespace metal {
     /// \cond
     namespace detail {
-        template<typename... nums>
+        template<typename x, typename y>
         struct _div;
+
+        template<typename x, typename y>
+        using div = typename _div<x, y>::type;
     }
     /// \endcond
 
@@ -41,51 +46,20 @@ namespace metal {
     /// ### See Also
     /// \see number, abs, inc, dec, neg, add, sub, mul, mod, pow
     template<typename... nums>
-    using div = detail::call<detail::_div<nums...>::template type>;
-}
-
-#include "../lambda/lambda.hpp"
-#include "../number/number.hpp"
-#include "../value/fold_left.hpp"
-
-#include <initializer_list>
+    using div = fold_left<lambda<detail::div>, nums..., number<1>>;
 
-namespace metal {
     /// \cond
     namespace detail {
-        template<typename... nums>
-        struct _div {};
-
-#if defined(METAL_WORKAROUND)
         template<typename x, typename y>
-        struct _div_impl {};
-
-        template<int_ x, int_ y>
-        struct _div_impl<number<x>, number<y>> : number<x / y> {};
+        struct _div {};
 
         template<int_ x>
-        struct _div_impl<number<x>, number<0>> {};
+        struct _div<number<x>, number<0>> {};
 
-        template<typename x, typename y>
-        using div_impl = typename _div_impl<x, y>::type;
-
-        template<int_... ns>
-        struct _div<number<ns>...> {
-            template<typename... _>
-            using type = fold_left<lambda<div_impl>, number<ns>..., _...>;
-        };
-#else
-        template<typename... _>
-        constexpr int_ div_impl(int_ head, _... tail) {
-            return void(std::initializer_list<int_>{(head /= tail)...}), head;
-        }
-
-        template<int_... ns>
-        struct _div<number<ns>...> {
-            template<typename... _>
-            using type = number<div_impl((void(sizeof...(_)), ns)...)>;
+        template<int_ x, int_ y>
+        struct _div<number<x>, number<y>> {
+            using type = number<x / y>;
         };
-#endif
     }
     /// \endcond
 }
diff --git a/include/metal/number/if.hpp b/include/metal/number/if.hpp
index 1c2d3051..f2abeb6a 100644
--- a/include/metal/number/if.hpp
+++ b/include/metal/number/if.hpp
@@ -6,11 +6,12 @@
 #define METAL_NUMBER_IF_HPP
 
 #include "../config.hpp"
+#include "../detail/sfinae.hpp"
 
 namespace metal {
     /// \cond
     namespace detail {
-        template<typename...>
+        template<typename cond>
         struct _if_;
     }
     /// \endcond
@@ -18,37 +19,34 @@ namespace metal {
     /// \ingroup number
     ///
     /// ### Description
-    /// A multi-clause conditional expression.
+    /// A conditional expression.
     ///
     /// ### Usage
-    /// For any \numbers `num_0, ..., num_n-1` and \values `val_0, ..., val_n`
+    /// For any \number `num` and \values `x, y`
     /// \code
-    ///     using result = metal::if<
-    ///         num_0, val_0,
-    ///         ...,
-    ///         num_n-1, val_n-1,
-    ///         val_n
-    ///     >;
+    ///     using result = metal::if<num, x, y>;
     /// \endcode
     ///
     /// \returns: \value
     /// \semantics:
-    ///     If `num_i{} != false` and `num_j{} == false` for all `j < i`, then
+    ///     If `num{} != false`, then
     ///     \code
-    ///         using result = val_i;
+    ///         using result = x;
     ///     \endcode
-    ///     otherwise, if `num_i{} == false` for all `i` in `[0, n-1]`, then
+    ///     otherwise
     ///     \code
-    ///         using result = val_n;
+    ///         using result = y;
     ///     \endcode
     ///
+    /// \tip{If `num{} != false`, `y` may be omitted.}
+    ///
     /// ### Example
     /// \snippet number.cpp if_
     ///
     /// ### See Also
     /// \see number
-    template<typename cond, typename then_, typename... else_>
-    using if_ = typename detail::_if_<cond, then_, else_...>::type;
+    template<typename cond, typename... then>
+    using if_ = detail::call<detail::_if_<cond>::template type, then...>;
 }
 
 #include "../number/number.hpp"
@@ -56,20 +54,19 @@ namespace metal {
 namespace metal {
     /// \cond
     namespace detail {
-        template<typename...>
+        template<typename>
         struct _if_ {};
 
-        template<typename then_, typename... else_>
-        struct _if_<false_, then_, else_...> : _if_<else_...> {};
-
-        template<typename then_, typename else_>
-        struct _if_<false_, then_, else_> {
-            using type = else_;
+        template<int_ v>
+        struct _if_<number<v>> {
+            template<typename val, typename = void>
+            using type = val;
         };
 
-        template<int_ v, typename then_, typename... else_>
-        struct _if_<number<v>, then_, else_...> {
-            using type = then_;
+        template<>
+        struct _if_<false_> {
+            template<typename, typename val>
+            using type = val;
         };
     }
     /// \endcond
diff --git a/include/metal/number/max.hpp b/include/metal/number/max.hpp
index 58d05d1b..ebf7f64e 100644
--- a/include/metal/number/max.hpp
+++ b/include/metal/number/max.hpp
@@ -6,13 +6,17 @@
 #define METAL_NUMBER_MAX_HPP
 
 #include "../config.hpp"
-#include "../detail/sfinae.hpp"
+#include "../lambda/lambda.hpp"
+#include "../number/greater.hpp"
+#include "../number/if.hpp"
+#include "../number/number.hpp"
+#include "../value/fold_left.hpp"
 
 namespace metal {
     /// \cond
     namespace detail {
-        template<typename... nums>
-        struct _max;
+        template<typename x, typename y>
+        using max = if_<greater<x, y>, x, y>;
     }
     /// \endcond
 
@@ -41,47 +45,7 @@ namespace metal {
     /// ### See Also
     /// \see number, greater, less, min
     template<typename... nums>
-    using max = detail::call<detail::_max<nums...>::template type>;
-}
-
-#include "../lambda/lambda.hpp"
-#include "../number/greater.hpp"
-#include "../number/if.hpp"
-#include "../number/number.hpp"
-#include "../value/fold_left.hpp"
-
-#include <initializer_list>
-
-namespace metal {
-    /// \cond
-    namespace detail {
-        template<typename... nums>
-        struct _max {};
-
-#if defined(METAL_WORKAROUND)
-        template<typename x, typename y>
-        using max_impl = if_<greater<x, y>, x, y>;
-
-        template<int_... ns>
-        struct _max<number<ns>...> {
-            template<typename... _>
-            using type = fold_left<lambda<max_impl>, number<ns>..., _...>;
-        };
-#else
-        template<typename... _>
-        constexpr int_ max_impl(int_ head, _... tail) {
-            using expand = std::initializer_list<int_>;
-            return void(expand{(head = (tail > head) ? tail : head)...}), head;
-        }
-
-        template<int_... ns>
-        struct _max<number<ns>...> {
-            template<typename... _>
-            using type = number<max_impl((void(sizeof...(_)), ns)...)>;
-        };
-#endif
-    }
-    /// \endcond
+    using max = fold_left<lambda<detail::max>, if_<is_number<nums>, nums>...>;
 }
 
 #endif
diff --git a/include/metal/number/min.hpp b/include/metal/number/min.hpp
index fb890ade..678fe7a7 100644
--- a/include/metal/number/min.hpp
+++ b/include/metal/number/min.hpp
@@ -6,13 +6,17 @@
 #define METAL_NUMBER_MIN_HPP
 
 #include "../config.hpp"
-#include "../detail/sfinae.hpp"
+#include "../lambda/lambda.hpp"
+#include "../number/if.hpp"
+#include "../number/less.hpp"
+#include "../number/number.hpp"
+#include "../value/fold_left.hpp"
 
 namespace metal {
     /// \cond
     namespace detail {
-        template<typename... nums>
-        struct _min;
+        template<typename x, typename y>
+        using min = if_<less<x, y>, x, y>;
     }
     /// \endcond
 
@@ -41,47 +45,7 @@ namespace metal {
     /// ### See Also
     /// \see number, greater, less, max
     template<typename... nums>
-    using min = detail::call<detail::_min<nums...>::template type>;
-}
-
-#include "../lambda/lambda.hpp"
-#include "../number/if.hpp"
-#include "../number/less.hpp"
-#include "../number/number.hpp"
-#include "../value/fold_left.hpp"
-
-#include <initializer_list>
-
-namespace metal {
-    /// \cond
-    namespace detail {
-        template<typename... nums>
-        struct _min {};
-
-#if defined(METAL_WORKAROUND)
-        template<typename x, typename y>
-        using min_impl = if_<less<x, y>, x, y>;
-
-        template<int_... ns>
-        struct _min<number<ns>...> {
-            template<typename... _>
-            using type = fold_left<lambda<min_impl>, number<ns>..., _...>;
-        };
-#else
-        template<typename... _>
-        constexpr int_ min_impl(int_ head, _... tail) {
-            using expand = std::initializer_list<int_>;
-            return void(expand{(head = (tail < head) ? tail : head)...}), head;
-        }
-
-        template<int_... ns>
-        struct _min<number<ns>...> {
-            template<typename... _>
-            using type = number<min_impl((void(sizeof...(_)), ns)...)>;
-        };
-#endif
-    }
-    /// \endcond
+    using min = fold_left<lambda<detail::min>, if_<is_number<nums>, nums>...>;
 }
 
 #endif
diff --git a/include/metal/number/mod.hpp b/include/metal/number/mod.hpp
index 08bfdef8..409b2960 100644
--- a/include/metal/number/mod.hpp
+++ b/include/metal/number/mod.hpp
@@ -6,13 +6,19 @@
 #define METAL_NUMBER_MOD_HPP
 
 #include "../config.hpp"
-#include "../detail/sfinae.hpp"
+#include "../lambda/lambda.hpp"
+#include "../number/if.hpp"
+#include "../number/number.hpp"
+#include "../value/fold_left.hpp"
 
 namespace metal {
     /// \cond
     namespace detail {
-        template<typename... mod>
+        template<typename x, typename y>
         struct _mod;
+
+        template<typename x, typename y>
+        using mod = typename _mod<x, y>::type;
     }
     /// \endcond
 
@@ -41,51 +47,20 @@ namespace metal {
     /// ### See Also
     /// \see number, abs, inc, dec, neg, add, sub, mul, div, pow
     template<typename... nums>
-    using mod = detail::call<detail::_mod<nums...>::template type>;
-}
-
-#include "../lambda/lambda.hpp"
-#include "../number/number.hpp"
-#include "../value/fold_left.hpp"
-
-#include <initializer_list>
+    using mod = fold_left<lambda<detail::mod>, if_<is_number<nums>, nums>...>;
 
-namespace metal {
     /// \cond
     namespace detail {
-        template<typename... nums>
-        struct _mod {};
-
-#if defined(METAL_WORKAROUND)
         template<typename x, typename y>
-        struct _mod_impl {};
-
-        template<int_ x, int_ y>
-        struct _mod_impl<number<x>, number<y>> : number<x % y> {};
+        struct _mod {};
 
         template<int_ x>
-        struct _mod_impl<number<x>, number<0>> {};
+        struct _mod<number<x>, number<0>> {};
 
-        template<typename x, typename y>
-        using mod_impl = typename _mod_impl<x, y>::type;
-
-        template<int_... ns>
-        struct _mod<number<ns>...> {
-            template<typename... _>
-            using type = fold_left<lambda<mod_impl>, number<ns>..., _...>;
-        };
-#else
-        template<typename... _>
-        constexpr int_ mod_impl(int_ head, _... tail) {
-            return void(std::initializer_list<int_>{(head %= tail)...}), head;
-        }
-
-        template<int_... ns>
-        struct _mod<number<ns>...> {
-            template<typename... _>
-            using type = number<mod_impl((void(sizeof...(_)), ns)...)>;
+        template<int_ x, int_ y>
+        struct _mod<number<x>, number<y>> {
+            using type = number<x % y>;
         };
-#endif
     }
     /// \endcond
 }
diff --git a/include/metal/number/mul.hpp b/include/metal/number/mul.hpp
index 58918ddb..d264cc67 100644
--- a/include/metal/number/mul.hpp
+++ b/include/metal/number/mul.hpp
@@ -6,13 +6,18 @@
 #define METAL_NUMBER_MUL_HPP
 
 #include "../config.hpp"
-#include "../detail/sfinae.hpp"
+#include "../lambda/lambda.hpp"
+#include "../number/number.hpp"
+#include "../value/fold_left.hpp"
 
 namespace metal {
     /// \cond
     namespace detail {
-        template<typename... nums>
+        template<typename x, typename y>
         struct _mul;
+
+        template<typename x, typename y>
+        using mul = typename _mul<x, y>::type;
     }
     /// \endcond
 
@@ -40,46 +45,16 @@ namespace metal {
     /// ### See Also
     /// \see number, abs, inc, dec, neg, add, sub, div, mod, pow
     template<typename... nums>
-    using mul = detail::call<detail::_mul<nums...>::template type>;
-}
-
-#include "../lambda/lambda.hpp"
-#include "../number/number.hpp"
-#include "../value/fold_left.hpp"
-
-#include <initializer_list>
+    using mul = fold_left<lambda<detail::mul>, nums..., number<1>>;
 
-namespace metal {
     /// \cond
     namespace detail {
-        template<typename... nums>
-        struct _mul {};
-
-#if defined(METAL_WORKAROUND)
         template<typename x, typename y>
-        using mul_impl = number<x::value * y::value>;
-
-        template<int_... ns>
-        struct _mul<number<ns>...> {
-            template<typename... _>
-            using type = fold_left<lambda<mul_impl>, number<ns>..., _...>;
-        };
-#else
-        template<typename... _>
-        constexpr int_ mul_impl(int_ head, _... tail) {
-            return void(std::initializer_list<int_>{(head *= tail)...}), head;
-        }
+        struct _mul {};
 
-        template<int_... ns>
-        struct _mul<number<ns>...> {
-            template<typename... _>
-            using type = number<mul_impl((void(sizeof...(_)), ns)...)>;
-        };
-#endif
-        template<>
-        struct _mul<> {
-            template<typename...>
-            using type = number<1>;
+        template<int_ x, int_ y>
+        struct _mul<number<x>, number<y>> {
+            using type = number<x * y>;
         };
     }
     /// \endcond
diff --git a/include/metal/number/pow.hpp b/include/metal/number/pow.hpp
index e5c8e691..cd1bb6f8 100644
--- a/include/metal/number/pow.hpp
+++ b/include/metal/number/pow.hpp
@@ -6,13 +6,18 @@
 #define METAL_NUMBER_POW_HPP
 
 #include "../config.hpp"
-#include "../detail/sfinae.hpp"
+#include "../lambda/lambda.hpp"
+#include "../number/number.hpp"
+#include "../value/fold_left.hpp"
 
 namespace metal {
     /// \cond
     namespace detail {
-        template<typename... nums>
+        template<typename base, typename exp, typename ret = number<1>>
         struct _pow;
+
+        template<typename base, typename exp>
+        using pow = typename _pow<base, exp>::type;
     }
     /// \endcond
 
@@ -47,48 +52,29 @@ namespace metal {
     /// ### See Also
     /// \see number, abs, inc, dec, neg, add, sub, mul, div, mod
     template<typename... nums>
-    using pow = detail::call<detail::_pow<nums...>::template type>;
-}
-
-#include "../lambda/lambda.hpp"
-#include "../number/number.hpp"
-#include "../value/fold_left.hpp"
+    using pow = fold_left<lambda<detail::pow>, nums..., number<1>>;
 
-namespace metal {
     /// \cond
     namespace detail {
-        template<typename base, typename exp, typename ret = number<1>>
-        struct _pow_impl {};
+        template<typename base, typename exp, typename ret>
+        struct _pow {};
 
         template<int_ b, int_ e, int_ r>
-        struct _pow_impl<number<b>, number<e>, number<r>>
-            : _pow_impl<
-                  number<b * b>, number<e / 2>, number<(e % 2 ? b * r : r)>> {};
+        struct _pow<number<b>, number<e>, number<r>>
+            : _pow<number<b * b>, number<e / 2>, number<(e % 2 ? b * r : r)>> {
+        };
 
         template<int_ b, int_ r>
-        struct _pow_impl<number<b>, number<0>, number<r>> : number<1> {};
+        struct _pow<number<b>, number<0>, number<r>> : number<1> {};
 
         template<int_ b, int_ r>
-        struct _pow_impl<number<b>, number<1>, number<r>> : number<b * r> {};
+        struct _pow<number<b>, number<1>, number<r>> : number<b * r> {};
 
         template<int_ b, int_ r>
-        struct _pow_impl<number<b>, number<-1>, number<r>>
-            : number<1 / (b * r)> {};
+        struct _pow<number<b>, number<-1>, number<r>> : number<1 / (b * r)> {};
 
         template<int_ r>
-        struct _pow_impl<number<0>, number<-1>, number<r>> {};
-
-        template<typename x, typename y>
-        using pow_impl = typename _pow_impl<x, y>::type;
-
-        template<typename... nums>
-        struct _pow {};
-
-        template<int_... ns>
-        struct _pow<number<ns>...> {
-            template<typename... _>
-            using type = fold_left<lambda<pow_impl>, number<ns>..., _...>;
-        };
+        struct _pow<number<0>, number<-1>, number<r>> {};
     }
     /// \endcond
 }
diff --git a/include/metal/number/sub.hpp b/include/metal/number/sub.hpp
index ba126a3a..ce56b53c 100644
--- a/include/metal/number/sub.hpp
+++ b/include/metal/number/sub.hpp
@@ -6,13 +6,18 @@
 #define METAL_NUMBER_SUB_HPP
 
 #include "../config.hpp"
-#include "../detail/sfinae.hpp"
+#include "../lambda/lambda.hpp"
+#include "../number/number.hpp"
+#include "../value/fold_left.hpp"
 
 namespace metal {
     /// \cond
     namespace detail {
-        template<typename... nums>
+        template<typename x, typename y>
         struct _sub;
+
+        template<typename x, typename y>
+        using sub = typename _sub<x, y>::type;
     }
     /// \endcond
 
@@ -40,42 +45,17 @@ namespace metal {
     /// ### See Also
     /// \see number, abs, inc, dec, neg, add, mul, div, mod, pow
     template<typename... nums>
-    using sub = detail::call<detail::_sub<nums...>::template type>;
-}
+    using sub = fold_left<lambda<detail::sub>, nums..., number<0>>;
 
-#include "../lambda/lambda.hpp"
-#include "../number/number.hpp"
-#include "../value/fold_left.hpp"
-
-#include <initializer_list>
-
-namespace metal {
     /// \cond
     namespace detail {
-        template<typename... nums>
-        struct _sub {};
-
-#if defined(METAL_WORKAROUND)
         template<typename x, typename y>
-        using sub_impl = number<x::value - y::value>;
-
-        template<int_... ns>
-        struct _sub<number<ns>...> {
-            template<typename... _>
-            using type = fold_left<lambda<sub_impl>, number<ns>..., _...>;
-        };
-#else
-        template<typename... _>
-        constexpr int_ sub_impl(int_ head, _... tail) {
-            return void(std::initializer_list<int_>{(head -= tail)...}), head;
-        }
+        struct _sub {};
 
-        template<int_... ns>
-        struct _sub<number<ns>...> {
-            template<typename... _>
-            using type = number<sub_impl((void(sizeof...(_)), ns)...)>;
+        template<int_ x, int_ y>
+        struct _sub<number<x>, number<y>> {
+            using type = number<x - y>;
         };
-#endif
     }
     /// \endcond
 }
diff --git a/test/unit/src/metal/number/add.cpp b/test/unit/src/metal/number/add.cpp
index a6c154af..bf2f022d 100644
--- a/test/unit/src/metal/number/add.cpp
+++ b/test/unit/src/metal/number/add.cpp
@@ -7,48 +7,42 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    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) 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) 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) 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::is_invocable<metal::lambda<metal::add> COMMA(M) VALUES(M) COMMA(N) VALUES(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add> COMMA(M) VALUES(M) COMMA(N) NUMBERS(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add> COMMA(M) VALUES(M) COMMA(N) PAIRS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add> COMMA(M) VALUES(M) COMMA(N) LISTS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add> COMMA(M) VALUES(M) COMMA(N) MAPS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add> COMMA(M) VALUES(M) COMMA(N) LAMBDAS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add> COMMA(M) NUMBERS(M) COMMA(N) VALUES(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add> COMMA(M) NUMBERS(M) COMMA(N) NUMBERS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add> COMMA(M) NUMBERS(M) COMMA(N) PAIRS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add> COMMA(M) NUMBERS(M) COMMA(N) LISTS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add> COMMA(M) NUMBERS(M) COMMA(N) MAPS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add> COMMA(M) NUMBERS(M) COMMA(N) LAMBDAS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add> COMMA(M) PAIRS(M) COMMA(N) VALUES(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add> COMMA(M) PAIRS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add> COMMA(M) PAIRS(M) COMMA(N) PAIRS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add> COMMA(M) PAIRS(M) COMMA(N) LISTS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add> COMMA(M) PAIRS(M) COMMA(N) MAPS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add> COMMA(M) PAIRS(M) COMMA(N) LAMBDAS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add> COMMA(M) LISTS(M) COMMA(N) VALUES(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add> COMMA(M) LISTS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add> COMMA(M) LISTS(M) COMMA(N) PAIRS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add> COMMA(M) LISTS(M) COMMA(N) LISTS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add> COMMA(M) LISTS(M) COMMA(N) MAPS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add> COMMA(M) LISTS(M) COMMA(N) LAMBDAS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add> COMMA(M) MAPS(M) COMMA(N) VALUES(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add> COMMA(M) MAPS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add> COMMA(M) MAPS(M) COMMA(N) PAIRS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add> COMMA(M) MAPS(M) COMMA(N) LISTS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add> COMMA(M) MAPS(M) COMMA(N) MAPS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add> COMMA(M) MAPS(M) COMMA(N) LAMBDAS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add> COMMA(M) LAMBDAS(M) COMMA(N) VALUES(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add> COMMA(M) LAMBDAS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add> COMMA(M) LAMBDAS(M) COMMA(N) PAIRS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add> COMMA(M) LAMBDAS(M) COMMA(N) LISTS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add> COMMA(M) LAMBDAS(M) COMMA(N) MAPS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::add> COMMA(M) LAMBDAS(M) COMMA(N) LAMBDAS(N)>), (BOOL(!M && !N))); \
     CHECK((metal::add<NUMBERS(M) COMMA(AND(M, N)) NUMBERS(N)>), (NUMBER(M*(M - 1)/2 + N*(N - 1)/2))); \
 /**/
 
diff --git a/test/unit/src/metal/number/and.cpp b/test/unit/src/metal/number/and.cpp
index 014493cf..6d6475bb 100644
--- a/test/unit/src/metal/number/and.cpp
+++ b/test/unit/src/metal/number/and.cpp
@@ -7,48 +7,42 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    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) 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) 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) 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::is_invocable<metal::lambda<metal::and_> COMMA(M) VALUES(M) COMMA(N) VALUES(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_> COMMA(M) VALUES(M) COMMA(N) NUMBERS(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_> COMMA(M) VALUES(M) COMMA(N) PAIRS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_> COMMA(M) VALUES(M) COMMA(N) LISTS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_> COMMA(M) VALUES(M) COMMA(N) MAPS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_> COMMA(M) VALUES(M) COMMA(N) LAMBDAS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_> COMMA(M) NUMBERS(M) COMMA(N) VALUES(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_> COMMA(M) NUMBERS(M) COMMA(N) NUMBERS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_> COMMA(M) NUMBERS(M) COMMA(N) PAIRS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_> COMMA(M) NUMBERS(M) COMMA(N) LISTS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_> COMMA(M) NUMBERS(M) COMMA(N) MAPS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_> COMMA(M) NUMBERS(M) COMMA(N) LAMBDAS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_> COMMA(M) PAIRS(M) COMMA(N) VALUES(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_> COMMA(M) PAIRS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_> COMMA(M) PAIRS(M) COMMA(N) PAIRS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_> COMMA(M) PAIRS(M) COMMA(N) LISTS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_> COMMA(M) PAIRS(M) COMMA(N) MAPS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_> COMMA(M) PAIRS(M) COMMA(N) LAMBDAS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_> COMMA(M) LISTS(M) COMMA(N) VALUES(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_> COMMA(M) LISTS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_> COMMA(M) LISTS(M) COMMA(N) PAIRS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_> COMMA(M) LISTS(M) COMMA(N) LISTS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_> COMMA(M) LISTS(M) COMMA(N) MAPS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_> COMMA(M) LISTS(M) COMMA(N) LAMBDAS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_> COMMA(M) MAPS(M) COMMA(N) VALUES(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_> COMMA(M) MAPS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_> COMMA(M) MAPS(M) COMMA(N) PAIRS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_> COMMA(M) MAPS(M) COMMA(N) LISTS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_> COMMA(M) MAPS(M) COMMA(N) MAPS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_> COMMA(M) MAPS(M) COMMA(N) LAMBDAS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_> COMMA(M) LAMBDAS(M) COMMA(N) VALUES(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_> COMMA(M) LAMBDAS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_> COMMA(M) LAMBDAS(M) COMMA(N) PAIRS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_> COMMA(M) LAMBDAS(M) COMMA(N) LISTS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_> COMMA(M) LAMBDAS(M) COMMA(N) MAPS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::and_> COMMA(M) LAMBDAS(M) COMMA(N) LAMBDAS(N)>), (BOOL(!M && !N))); \
     CHECK((metal::and_<NUMBER(M) COMMA(N) NUMBERS(N)>), (BOOL(M && !N))); \
     CHECK((metal::and_<ENUM(N, NUMBER FIX(M))>), (BOOL(M || !N))); \
 /**/
diff --git a/test/unit/src/metal/number/div.cpp b/test/unit/src/metal/number/div.cpp
index 82477d0b..092e1f53 100644
--- a/test/unit/src/metal/number/div.cpp
+++ b/test/unit/src/metal/number/div.cpp
@@ -7,48 +7,42 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    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) 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) 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) 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::is_invocable<metal::lambda<metal::div> COMMA(M) VALUES(M) COMMA(N) VALUES(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div> COMMA(M) VALUES(M) COMMA(N) NUMBERS(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div> COMMA(M) VALUES(M) COMMA(N) PAIRS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div> COMMA(M) VALUES(M) COMMA(N) LISTS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div> COMMA(M) VALUES(M) COMMA(N) MAPS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div> COMMA(M) VALUES(M) COMMA(N) LAMBDAS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div> COMMA(M) NUMBERS(M) COMMA(N) VALUES(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div> COMMA(M) NUMBERS(M) COMMA(N) NUMBERS(N)>), (BOOL(!N || !M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div> COMMA(M) NUMBERS(M) COMMA(N) PAIRS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div> COMMA(M) NUMBERS(M) COMMA(N) LISTS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div> COMMA(M) NUMBERS(M) COMMA(N) MAPS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div> COMMA(M) NUMBERS(M) COMMA(N) LAMBDAS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div> COMMA(M) PAIRS(M) COMMA(N) VALUES(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div> COMMA(M) PAIRS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div> COMMA(M) PAIRS(M) COMMA(N) PAIRS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div> COMMA(M) PAIRS(M) COMMA(N) LISTS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div> COMMA(M) PAIRS(M) COMMA(N) MAPS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div> COMMA(M) PAIRS(M) COMMA(N) LAMBDAS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div> COMMA(M) LISTS(M) COMMA(N) VALUES(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div> COMMA(M) LISTS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div> COMMA(M) LISTS(M) COMMA(N) PAIRS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div> COMMA(M) LISTS(M) COMMA(N) LISTS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div> COMMA(M) LISTS(M) COMMA(N) MAPS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div> COMMA(M) LISTS(M) COMMA(N) LAMBDAS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div> COMMA(M) MAPS(M) COMMA(N) VALUES(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div> COMMA(M) MAPS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div> COMMA(M) MAPS(M) COMMA(N) PAIRS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div> COMMA(M) MAPS(M) COMMA(N) LISTS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div> COMMA(M) MAPS(M) COMMA(N) MAPS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div> COMMA(M) MAPS(M) COMMA(N) LAMBDAS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div> COMMA(M) LAMBDAS(M) COMMA(N) VALUES(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div> COMMA(M) LAMBDAS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div> COMMA(M) LAMBDAS(M) COMMA(N) PAIRS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div> COMMA(M) LAMBDAS(M) COMMA(N) LISTS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div> COMMA(M) LAMBDAS(M) COMMA(N) MAPS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::div> COMMA(M) LAMBDAS(M) COMMA(N) LAMBDAS(N)>), (BOOL(!M && !N))); \
     CHECK((metal::div<NUMBER(FACT(M)) COMMA(N) ENUM(N, NUMBER LIFT(INC))>), (NUMBER(FACT(M)/FACT(N)))); \
 /**/
 
diff --git a/test/unit/src/metal/number/if.cpp b/test/unit/src/metal/number/if.cpp
index 335df1ed..64cb3fae 100644
--- a/test/unit/src/metal/number/if.cpp
+++ b/test/unit/src/metal/number/if.cpp
@@ -13,12 +13,12 @@
     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_>, NUMBER(M) COMMA(N) VALUES(N)>), (BOOL((M && N == 1) || N == 2))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, NUMBER(M) COMMA(N) NUMBERS(N)>), (BOOL((M && N == 1) || N == 2))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, NUMBER(M) COMMA(N) PAIRS(N)>), (BOOL((M && N == 1) || N == 2))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, NUMBER(M) COMMA(N) LISTS(N)>), (BOOL((M && N == 1) || N == 2))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, NUMBER(M) COMMA(N) MAPS(N)>), (BOOL((M && N == 1) || N == 2))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::if_>, NUMBER(M) COMMA(N) LAMBDAS(N)>), (BOOL((M && N == 1) || 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)); \
@@ -49,7 +49,8 @@
     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))); \
+    CHECK((metal::if_<NUMBER(INC(M)), VALUE(N)>), (VALUE(N))); \
+    CHECK((metal::if_<NUMBER(M), VALUE(M), VALUE(N)>), (IF(M)(VALUE(M), VALUE(N)))); \
 /**/
 
 GEN(MATRIX)
diff --git a/test/unit/src/metal/number/max.cpp b/test/unit/src/metal/number/max.cpp
index 38f8ba0f..a920c26f 100644
--- a/test/unit/src/metal/number/max.cpp
+++ b/test/unit/src/metal/number/max.cpp
@@ -7,48 +7,42 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    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) 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) 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) 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::is_invocable<metal::lambda<metal::max> COMMA(M) VALUES(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max> COMMA(M) VALUES(M) COMMA(N) NUMBERS(N)>), (BOOL(!M && N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max> COMMA(M) VALUES(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max> COMMA(M) VALUES(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max> COMMA(M) VALUES(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max> COMMA(M) VALUES(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max> COMMA(M) NUMBERS(M) COMMA(N) VALUES(N)>), (BOOL(M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max> COMMA(M) NUMBERS(M) COMMA(N) NUMBERS(N)>), (BOOL(M || N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max> COMMA(M) NUMBERS(M) COMMA(N) PAIRS(N)>), (BOOL(M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max> COMMA(M) NUMBERS(M) COMMA(N) LISTS(N)>), (BOOL(M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max> COMMA(M) NUMBERS(M) COMMA(N) MAPS(N)>), (BOOL(M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max> COMMA(M) NUMBERS(M) COMMA(N) LAMBDAS(N)>), (BOOL(M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max> COMMA(M) PAIRS(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max> COMMA(M) PAIRS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M && N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max> COMMA(M) PAIRS(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max> COMMA(M) PAIRS(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max> COMMA(M) PAIRS(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max> COMMA(M) PAIRS(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max> COMMA(M) LISTS(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max> COMMA(M) LISTS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M && N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max> COMMA(M) LISTS(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max> COMMA(M) LISTS(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max> COMMA(M) LISTS(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max> COMMA(M) LISTS(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max> COMMA(M) MAPS(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max> COMMA(M) MAPS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M && N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max> COMMA(M) MAPS(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max> COMMA(M) MAPS(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max> COMMA(M) MAPS(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max> COMMA(M) MAPS(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max> COMMA(M) LAMBDAS(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max> COMMA(M) LAMBDAS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M && N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max> COMMA(M) LAMBDAS(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max> COMMA(M) LAMBDAS(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max> COMMA(M) LAMBDAS(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::max> COMMA(M) LAMBDAS(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
     CHECK((metal::max<NUMBER(M) COMMA(N) NUMBERS(N)>), (NUMBER((M >= N) ? M : N - 1))); \
 /**/
 
diff --git a/test/unit/src/metal/number/min.cpp b/test/unit/src/metal/number/min.cpp
index 4e34ef1b..f8c915de 100644
--- a/test/unit/src/metal/number/min.cpp
+++ b/test/unit/src/metal/number/min.cpp
@@ -7,48 +7,42 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    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) 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) 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) 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::is_invocable<metal::lambda<metal::min> COMMA(M) VALUES(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min> COMMA(M) VALUES(M) COMMA(N) NUMBERS(N)>), (BOOL(!M && N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min> COMMA(M) VALUES(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min> COMMA(M) VALUES(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min> COMMA(M) VALUES(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min> COMMA(M) VALUES(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min> COMMA(M) NUMBERS(M) COMMA(N) VALUES(N)>), (BOOL(M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min> COMMA(M) NUMBERS(M) COMMA(N) NUMBERS(N)>), (BOOL(M || N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min> COMMA(M) NUMBERS(M) COMMA(N) PAIRS(N)>), (BOOL(M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min> COMMA(M) NUMBERS(M) COMMA(N) LISTS(N)>), (BOOL(M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min> COMMA(M) NUMBERS(M) COMMA(N) MAPS(N)>), (BOOL(M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min> COMMA(M) NUMBERS(M) COMMA(N) LAMBDAS(N)>), (BOOL(M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min> COMMA(M) PAIRS(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min> COMMA(M) PAIRS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M && N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min> COMMA(M) PAIRS(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min> COMMA(M) PAIRS(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min> COMMA(M) PAIRS(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min> COMMA(M) PAIRS(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min> COMMA(M) LISTS(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min> COMMA(M) LISTS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M && N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min> COMMA(M) LISTS(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min> COMMA(M) LISTS(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min> COMMA(M) LISTS(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min> COMMA(M) LISTS(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min> COMMA(M) MAPS(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min> COMMA(M) MAPS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M && N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min> COMMA(M) MAPS(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min> COMMA(M) MAPS(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min> COMMA(M) MAPS(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min> COMMA(M) MAPS(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min> COMMA(M) LAMBDAS(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min> COMMA(M) LAMBDAS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M && N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min> COMMA(M) LAMBDAS(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min> COMMA(M) LAMBDAS(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min> COMMA(M) LAMBDAS(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::min> COMMA(M) LAMBDAS(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
     CHECK((metal::min<NUMBER(M) COMMA(N) NUMBERS(N)>), (NUMBER(IF(N)(0, M)))); \
 /**/
 
diff --git a/test/unit/src/metal/number/mod.cpp b/test/unit/src/metal/number/mod.cpp
index 1a4f728d..9b07ffbc 100644
--- a/test/unit/src/metal/number/mod.cpp
+++ b/test/unit/src/metal/number/mod.cpp
@@ -7,48 +7,42 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    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) 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) 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) 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::is_invocable<metal::lambda<metal::mod> COMMA(M) VALUES(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod> COMMA(M) VALUES(M) COMMA(N) NUMBERS(N)>), (BOOL(!M && N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod> COMMA(M) VALUES(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod> COMMA(M) VALUES(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod> COMMA(M) VALUES(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod> COMMA(M) VALUES(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod> COMMA(M) NUMBERS(M) COMMA(N) VALUES(N)>), (BOOL(M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod> COMMA(M) NUMBERS(M) COMMA(N) NUMBERS(N)>), (BOOL((M && !N) || (!M && N)))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod> COMMA(M) NUMBERS(M) COMMA(N) PAIRS(N)>), (BOOL(M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod> COMMA(M) NUMBERS(M) COMMA(N) LISTS(N)>), (BOOL(M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod> COMMA(M) NUMBERS(M) COMMA(N) MAPS(N)>), (BOOL(M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod> COMMA(M) NUMBERS(M) COMMA(N) LAMBDAS(N)>), (BOOL(M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod> COMMA(M) PAIRS(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod> COMMA(M) PAIRS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M && N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod> COMMA(M) PAIRS(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod> COMMA(M) PAIRS(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod> COMMA(M) PAIRS(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod> COMMA(M) PAIRS(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod> COMMA(M) LISTS(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod> COMMA(M) LISTS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M && N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod> COMMA(M) LISTS(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod> COMMA(M) LISTS(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod> COMMA(M) LISTS(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod> COMMA(M) LISTS(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod> COMMA(M) MAPS(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod> COMMA(M) MAPS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M && N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod> COMMA(M) MAPS(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod> COMMA(M) MAPS(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod> COMMA(M) MAPS(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod> COMMA(M) MAPS(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod> COMMA(M) LAMBDAS(M) COMMA(N) VALUES(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod> COMMA(M) LAMBDAS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M && N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod> COMMA(M) LAMBDAS(M) COMMA(N) PAIRS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod> COMMA(M) LAMBDAS(M) COMMA(N) LISTS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod> COMMA(M) LAMBDAS(M) COMMA(N) MAPS(N)>), (FALSE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mod> COMMA(M) LAMBDAS(M) COMMA(N) LAMBDAS(N)>), (FALSE)); \
     CHECK((metal::mod<NUMBER(M) COMMA(N) ENUM(N, NUMBER LIFT(INC))>), (NUMBER(IF(N)(0, M)))); \
 /**/
 
diff --git a/test/unit/src/metal/number/mul.cpp b/test/unit/src/metal/number/mul.cpp
index 2e5d3d5f..c27b76c4 100644
--- a/test/unit/src/metal/number/mul.cpp
+++ b/test/unit/src/metal/number/mul.cpp
@@ -7,48 +7,42 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    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) 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) 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) 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::is_invocable<metal::lambda<metal::mul> COMMA(M) VALUES(M) COMMA(N) VALUES(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul> COMMA(M) VALUES(M) COMMA(N) NUMBERS(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul> COMMA(M) VALUES(M) COMMA(N) PAIRS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul> COMMA(M) VALUES(M) COMMA(N) LISTS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul> COMMA(M) VALUES(M) COMMA(N) MAPS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul> COMMA(M) VALUES(M) COMMA(N) LAMBDAS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul> COMMA(M) NUMBERS(M) COMMA(N) VALUES(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul> COMMA(M) NUMBERS(M) COMMA(N) NUMBERS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul> COMMA(M) NUMBERS(M) COMMA(N) PAIRS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul> COMMA(M) NUMBERS(M) COMMA(N) LISTS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul> COMMA(M) NUMBERS(M) COMMA(N) MAPS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul> COMMA(M) NUMBERS(M) COMMA(N) LAMBDAS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul> COMMA(M) PAIRS(M) COMMA(N) VALUES(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul> COMMA(M) PAIRS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul> COMMA(M) PAIRS(M) COMMA(N) PAIRS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul> COMMA(M) PAIRS(M) COMMA(N) LISTS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul> COMMA(M) PAIRS(M) COMMA(N) MAPS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul> COMMA(M) PAIRS(M) COMMA(N) LAMBDAS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul> COMMA(M) LISTS(M) COMMA(N) VALUES(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul> COMMA(M) LISTS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul> COMMA(M) LISTS(M) COMMA(N) PAIRS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul> COMMA(M) LISTS(M) COMMA(N) LISTS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul> COMMA(M) LISTS(M) COMMA(N) MAPS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul> COMMA(M) LISTS(M) COMMA(N) LAMBDAS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul> COMMA(M) MAPS(M) COMMA(N) VALUES(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul> COMMA(M) MAPS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul> COMMA(M) MAPS(M) COMMA(N) PAIRS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul> COMMA(M) MAPS(M) COMMA(N) LISTS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul> COMMA(M) MAPS(M) COMMA(N) MAPS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul> COMMA(M) MAPS(M) COMMA(N) LAMBDAS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul> COMMA(M) LAMBDAS(M) COMMA(N) VALUES(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul> COMMA(M) LAMBDAS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul> COMMA(M) LAMBDAS(M) COMMA(N) PAIRS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul> COMMA(M) LAMBDAS(M) COMMA(N) LISTS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul> COMMA(M) LAMBDAS(M) COMMA(N) MAPS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::mul> COMMA(M) LAMBDAS(M) COMMA(N) LAMBDAS(N)>), (BOOL(!M && !N))); \
     CHECK((metal::mul<ENUM(M, NUMBER LIFT(INC)) COMMA(AND(M, N)) ENUM(N, NUMBER LIFT(INC))>), (NUMBER(FACT(M)*FACT(N)))); \
 /**/
 
diff --git a/test/unit/src/metal/number/or.cpp b/test/unit/src/metal/number/or.cpp
index c00ff805..72f9f3a5 100644
--- a/test/unit/src/metal/number/or.cpp
+++ b/test/unit/src/metal/number/or.cpp
@@ -7,48 +7,42 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    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) 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) 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) 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::is_invocable<metal::lambda<metal::or_> COMMA(M) VALUES(M) COMMA(N) VALUES(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_> COMMA(M) VALUES(M) COMMA(N) NUMBERS(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_> COMMA(M) VALUES(M) COMMA(N) PAIRS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_> COMMA(M) VALUES(M) COMMA(N) LISTS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_> COMMA(M) VALUES(M) COMMA(N) MAPS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_> COMMA(M) VALUES(M) COMMA(N) LAMBDAS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_> COMMA(M) NUMBERS(M) COMMA(N) VALUES(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_> COMMA(M) NUMBERS(M) COMMA(N) NUMBERS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_> COMMA(M) NUMBERS(M) COMMA(N) PAIRS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_> COMMA(M) NUMBERS(M) COMMA(N) LISTS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_> COMMA(M) NUMBERS(M) COMMA(N) MAPS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_> COMMA(M) NUMBERS(M) COMMA(N) LAMBDAS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_> COMMA(M) PAIRS(M) COMMA(N) VALUES(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_> COMMA(M) PAIRS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_> COMMA(M) PAIRS(M) COMMA(N) PAIRS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_> COMMA(M) PAIRS(M) COMMA(N) LISTS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_> COMMA(M) PAIRS(M) COMMA(N) MAPS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_> COMMA(M) PAIRS(M) COMMA(N) LAMBDAS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_> COMMA(M) LISTS(M) COMMA(N) VALUES(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_> COMMA(M) LISTS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_> COMMA(M) LISTS(M) COMMA(N) PAIRS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_> COMMA(M) LISTS(M) COMMA(N) LISTS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_> COMMA(M) LISTS(M) COMMA(N) MAPS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_> COMMA(M) LISTS(M) COMMA(N) LAMBDAS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_> COMMA(M) MAPS(M) COMMA(N) VALUES(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_> COMMA(M) MAPS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_> COMMA(M) MAPS(M) COMMA(N) PAIRS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_> COMMA(M) MAPS(M) COMMA(N) LISTS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_> COMMA(M) MAPS(M) COMMA(N) MAPS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_> COMMA(M) MAPS(M) COMMA(N) LAMBDAS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_> COMMA(M) LAMBDAS(M) COMMA(N) VALUES(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_> COMMA(M) LAMBDAS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_> COMMA(M) LAMBDAS(M) COMMA(N) PAIRS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_> COMMA(M) LAMBDAS(M) COMMA(N) LISTS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_> COMMA(M) LAMBDAS(M) COMMA(N) MAPS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::or_> COMMA(M) LAMBDAS(M) COMMA(N) LAMBDAS(N)>), (BOOL(!M && !N))); \
     CHECK((metal::or_<NUMBER(M) COMMA(N) NUMBERS(N)>), (BOOL(M || N > 1))); \
     CHECK((metal::or_<ENUM(N, NUMBER FIX(M))>), (BOOL(N && M))); \
 /**/
diff --git a/test/unit/src/metal/number/pow.cpp b/test/unit/src/metal/number/pow.cpp
index 23095528..e3f25727 100644
--- a/test/unit/src/metal/number/pow.cpp
+++ b/test/unit/src/metal/number/pow.cpp
@@ -7,48 +7,42 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    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) 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) 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) 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> COMMA(M) VALUES(M) COMMA(N) VALUES(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow> COMMA(M) VALUES(M) COMMA(N) NUMBERS(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow> COMMA(M) VALUES(M) COMMA(N) PAIRS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow> COMMA(M) VALUES(M) COMMA(N) LISTS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow> COMMA(M) VALUES(M) COMMA(N) MAPS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow> COMMA(M) VALUES(M) COMMA(N) LAMBDAS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow> COMMA(M) NUMBERS(M) COMMA(N) VALUES(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow> COMMA(M) NUMBERS(M) COMMA(N) NUMBERS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow> COMMA(M) NUMBERS(M) COMMA(N) PAIRS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow> COMMA(M) NUMBERS(M) COMMA(N) LISTS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow> COMMA(M) NUMBERS(M) COMMA(N) MAPS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow> COMMA(M) NUMBERS(M) COMMA(N) LAMBDAS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow> COMMA(M) PAIRS(M) COMMA(N) VALUES(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow> COMMA(M) PAIRS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow> COMMA(M) PAIRS(M) COMMA(N) PAIRS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow> COMMA(M) PAIRS(M) COMMA(N) LISTS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow> COMMA(M) PAIRS(M) COMMA(N) MAPS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow> COMMA(M) PAIRS(M) COMMA(N) LAMBDAS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow> COMMA(M) LISTS(M) COMMA(N) VALUES(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow> COMMA(M) LISTS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow> COMMA(M) LISTS(M) COMMA(N) PAIRS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow> COMMA(M) LISTS(M) COMMA(N) LISTS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow> COMMA(M) LISTS(M) COMMA(N) MAPS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow> COMMA(M) LISTS(M) COMMA(N) LAMBDAS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow> COMMA(M) MAPS(M) COMMA(N) VALUES(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow> COMMA(M) MAPS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow> COMMA(M) MAPS(M) COMMA(N) PAIRS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow> COMMA(M) MAPS(M) COMMA(N) LISTS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow> COMMA(M) MAPS(M) COMMA(N) MAPS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow> COMMA(M) MAPS(M) COMMA(N) LAMBDAS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow> COMMA(M) LAMBDAS(M) COMMA(N) VALUES(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow> COMMA(M) LAMBDAS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow> COMMA(M) LAMBDAS(M) COMMA(N) PAIRS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow> COMMA(M) LAMBDAS(M) COMMA(N) LISTS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow> COMMA(M) LAMBDAS(M) COMMA(N) MAPS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::pow> COMMA(M) LAMBDAS(M) COMMA(N) LAMBDAS(N)>), (BOOL(!M && !N))); \
     CHECK((metal::is_invocable<metal::lambda<metal::pow>, NUMBER(M), NUMBER(-N)>), (BOOL(M || !N))); \
     CHECK((metal::pow<NUMBER(M) COMMA(N) NUMBERS(N)>), (NUMBER(IF(N)(1, M)))); \
 /**/
diff --git a/test/unit/src/metal/number/sub.cpp b/test/unit/src/metal/number/sub.cpp
index 40ef993b..f56bcbc1 100644
--- a/test/unit/src/metal/number/sub.cpp
+++ b/test/unit/src/metal/number/sub.cpp
@@ -7,48 +7,42 @@
 #include "test.hpp"
 
 #define MATRIX(M, N) \
-    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) 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) 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) 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::is_invocable<metal::lambda<metal::sub> COMMA(M) VALUES(M) COMMA(N) VALUES(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub> COMMA(M) VALUES(M) COMMA(N) NUMBERS(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub> COMMA(M) VALUES(M) COMMA(N) PAIRS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub> COMMA(M) VALUES(M) COMMA(N) LISTS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub> COMMA(M) VALUES(M) COMMA(N) MAPS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub> COMMA(M) VALUES(M) COMMA(N) LAMBDAS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub> COMMA(M) NUMBERS(M) COMMA(N) VALUES(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub> COMMA(M) NUMBERS(M) COMMA(N) NUMBERS(N)>), (TRUE)); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub> COMMA(M) NUMBERS(M) COMMA(N) PAIRS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub> COMMA(M) NUMBERS(M) COMMA(N) LISTS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub> COMMA(M) NUMBERS(M) COMMA(N) MAPS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub> COMMA(M) NUMBERS(M) COMMA(N) LAMBDAS(N)>), (BOOL(!N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub> COMMA(M) PAIRS(M) COMMA(N) VALUES(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub> COMMA(M) PAIRS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub> COMMA(M) PAIRS(M) COMMA(N) PAIRS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub> COMMA(M) PAIRS(M) COMMA(N) LISTS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub> COMMA(M) PAIRS(M) COMMA(N) MAPS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub> COMMA(M) PAIRS(M) COMMA(N) LAMBDAS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub> COMMA(M) LISTS(M) COMMA(N) VALUES(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub> COMMA(M) LISTS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub> COMMA(M) LISTS(M) COMMA(N) PAIRS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub> COMMA(M) LISTS(M) COMMA(N) LISTS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub> COMMA(M) LISTS(M) COMMA(N) MAPS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub> COMMA(M) LISTS(M) COMMA(N) LAMBDAS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub> COMMA(M) MAPS(M) COMMA(N) VALUES(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub> COMMA(M) MAPS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub> COMMA(M) MAPS(M) COMMA(N) PAIRS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub> COMMA(M) MAPS(M) COMMA(N) LISTS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub> COMMA(M) MAPS(M) COMMA(N) MAPS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub> COMMA(M) MAPS(M) COMMA(N) LAMBDAS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub> COMMA(M) LAMBDAS(M) COMMA(N) VALUES(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub> COMMA(M) LAMBDAS(M) COMMA(N) NUMBERS(N)>), (BOOL(!M))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub> COMMA(M) LAMBDAS(M) COMMA(N) PAIRS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub> COMMA(M) LAMBDAS(M) COMMA(N) LISTS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub> COMMA(M) LAMBDAS(M) COMMA(N) MAPS(N)>), (BOOL(!M && !N))); \
+    CHECK((metal::is_invocable<metal::lambda<metal::sub> COMMA(M) LAMBDAS(M) COMMA(N) LAMBDAS(N)>), (BOOL(!M && !N))); \
     CHECK((metal::sub<NUMBER(M) COMMA(N) NUMBERS(N)>), (NUMBER(N*(1 - N)/2 + M))); \
 /**/