diff --git a/BUILD b/BUILD
index 7bf664db..ff3d8024 100644
--- a/BUILD
+++ b/BUILD
@@ -131,6 +131,7 @@ cc_library(
         ":jni_bind",
         ":mock_jni_env",
         ":mock_jvm",
+        "//bind_lang/metaprogramming:function_traits",
         "@googletest//:gtest_main",
     ],
 )
diff --git a/bind_lang/metaprogramming/all.h b/bind_lang/metaprogramming/all.h
index 503ff0d3..8921a461 100644
--- a/bind_lang/metaprogramming/all.h
+++ b/bind_lang/metaprogramming/all.h
@@ -19,7 +19,7 @@
 
 #include <type_traits>
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 template <typename Func>
 struct All {
@@ -34,6 +34,6 @@ using All_t = typename All<Func>::template type<Ts...>;
 template <typename Func, typename... Ts>
 static constexpr bool All_v = All_t<Func, Ts...>::value;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_ALL_H_
diff --git a/bind_lang/metaprogramming/all_test.cc b/bind_lang/metaprogramming/all_test.cc
index 17460bfe..f1c7e567 100644
--- a/bind_lang/metaprogramming/all_test.cc
+++ b/bind_lang/metaprogramming/all_test.cc
@@ -23,13 +23,13 @@
 #include "same.h"
 #include "unwrap.h"
 
-using ::jni::metaprogramming::All;
-using ::jni::metaprogramming::All_t;
-using ::jni::metaprogramming::All_v;
-using ::jni::metaprogramming::Invoke_t;
-using ::jni::metaprogramming::Same;
-using ::jni::metaprogramming::Unwrap;
-using ::jni::metaprogramming::Unwrap_t;
+using ::bind_lang::metaprogramming::All;
+using ::bind_lang::metaprogramming::All_t;
+using ::bind_lang::metaprogramming::All_v;
+using ::bind_lang::metaprogramming::Invoke_t;
+using ::bind_lang::metaprogramming::Same;
+using ::bind_lang::metaprogramming::Unwrap;
+using ::bind_lang::metaprogramming::Unwrap_t;
 
 namespace {
 
diff --git a/bind_lang/metaprogramming/all_unique.h b/bind_lang/metaprogramming/all_unique.h
index 923d291a..384c11c1 100644
--- a/bind_lang/metaprogramming/all_unique.h
+++ b/bind_lang/metaprogramming/all_unique.h
@@ -21,7 +21,7 @@
 
 #include "contains.h"
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 template <typename...>
 struct AllUnique {
@@ -47,6 +47,6 @@ constexpr bool AllUniqueValues(const T1&& t1, const Ts&&... ts) {
   return (!ContainsValue(t1, ts...)) && AllUniqueValues(ts...);
 }
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_ALL_UNIQUE_H_
diff --git a/bind_lang/metaprogramming/all_unique_test.cc b/bind_lang/metaprogramming/all_unique_test.cc
index c42080b7..b8fd450d 100644
--- a/bind_lang/metaprogramming/all_unique_test.cc
+++ b/bind_lang/metaprogramming/all_unique_test.cc
@@ -20,8 +20,8 @@
 
 namespace {
 
-using ::jni::metaprogramming::AllUnique_v;
-using ::jni::metaprogramming::AllUniqueValues;
+using ::bind_lang::metaprogramming::AllUnique_v;
+using ::bind_lang::metaprogramming::AllUniqueValues;
 
 static_assert(AllUnique_v<>);
 static_assert(AllUnique_v<void>);
diff --git a/bind_lang/metaprogramming/any.h b/bind_lang/metaprogramming/any.h
index 5fc9aee6..20bd5bf9 100644
--- a/bind_lang/metaprogramming/any.h
+++ b/bind_lang/metaprogramming/any.h
@@ -21,7 +21,7 @@
 
 #include "tuple_manipulation.h"
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 template <typename Func>
 struct Any {
@@ -42,6 +42,6 @@ using Any_Tup = TupleUnroller_t<Any<Func>, Ts>;
 template <typename Func, typename Ts>
 static constexpr bool Any_Tup_v = TupleUnroller_t<Any<Func>, Ts>::value;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_ANY_H_
diff --git a/bind_lang/metaprogramming/any_test.cc b/bind_lang/metaprogramming/any_test.cc
index c4befbcd..83e9f9db 100644
--- a/bind_lang/metaprogramming/any_test.cc
+++ b/bind_lang/metaprogramming/any_test.cc
@@ -21,11 +21,11 @@
 #include "invoke.h"
 #include "same.h"
 
-using ::jni::metaprogramming::Any;
-using ::jni::metaprogramming::Any_t;
-using ::jni::metaprogramming::Any_v;
-using ::jni::metaprogramming::Invoke_t;
-using ::jni::metaprogramming::Same;
+using ::bind_lang::metaprogramming::Any;
+using ::bind_lang::metaprogramming::Any_t;
+using ::bind_lang::metaprogramming::Any_v;
+using ::bind_lang::metaprogramming::Invoke_t;
+using ::bind_lang::metaprogramming::Same;
 
 namespace {
 
diff --git a/bind_lang/metaprogramming/apply.h b/bind_lang/metaprogramming/apply.h
index 597a2d7f..32f21bd9 100644
--- a/bind_lang/metaprogramming/apply.h
+++ b/bind_lang/metaprogramming/apply.h
@@ -19,7 +19,7 @@
 
 #include "tuple_manipulation.h"
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 // Forwards all arguments to a metafunction.  Note, Apply<Func> is itself a type
 // whose |type| (aka its metafunction's invocation).
@@ -37,6 +37,6 @@ using Apply_t = typename Apply<Function>::template type<Ts...>;
 template <template <typename...> class Function, typename TupleType>
 using ApplyTup_t = TupleUnroller_t<Apply<Function>, TupleType>;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_APPLY_H_
diff --git a/bind_lang/metaprogramming/apply_test.cc b/bind_lang/metaprogramming/apply_test.cc
index 618af261..11768c49 100644
--- a/bind_lang/metaprogramming/apply_test.cc
+++ b/bind_lang/metaprogramming/apply_test.cc
@@ -22,11 +22,11 @@
 #include "invoke.h"
 #include "same.h"
 
-using ::jni::metaprogramming::Apply;
-using ::jni::metaprogramming::Apply_t;
-using ::jni::metaprogramming::Invoke_t;
-using ::jni::metaprogramming::InvokePerTupArg_t;
-using ::jni::metaprogramming::Same;
+using ::bind_lang::metaprogramming::Apply;
+using ::bind_lang::metaprogramming::Apply_t;
+using ::bind_lang::metaprogramming::Invoke_t;
+using ::bind_lang::metaprogramming::InvokePerTupArg_t;
+using ::bind_lang::metaprogramming::Same;
 
 namespace {
 
diff --git a/bind_lang/metaprogramming/base.h b/bind_lang/metaprogramming/base.h
index af80e712..2ee15411 100644
--- a/bind_lang/metaprogramming/base.h
+++ b/bind_lang/metaprogramming/base.h
@@ -19,7 +19,7 @@
 
 #include <type_traits>
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 template <typename BaseToTest>
 struct Base {
@@ -30,6 +30,6 @@ struct Base {
 template <typename BaseToTest, typename TypeToTest>
 using Base_t = typename Base<BaseToTest>::template type<TypeToTest>;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_BASE_H_
diff --git a/bind_lang/metaprogramming/base_filter.h b/bind_lang/metaprogramming/base_filter.h
index 11c57b09..d51520de 100644
--- a/bind_lang/metaprogramming/base_filter.h
+++ b/bind_lang/metaprogramming/base_filter.h
@@ -22,7 +22,7 @@
 
 #include "concatenate.h"
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 // Returns all elements derived from DesiredBase.
 //
@@ -65,6 +65,6 @@ using BaseFilterWithDefault_t =
     DefaultIfEmpty_Tup<BaseFilter_t<DesiredBase, Ts...>,
                        std::tuple<DefaultValue>>;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_BASE_FILTER_H_
diff --git a/bind_lang/metaprogramming/base_filter_test.cc b/bind_lang/metaprogramming/base_filter_test.cc
index 83319fc0..d0c8ac41 100644
--- a/bind_lang/metaprogramming/base_filter_test.cc
+++ b/bind_lang/metaprogramming/base_filter_test.cc
@@ -19,7 +19,7 @@
 #include <tuple>
 #include <type_traits>
 
-using ::jni::metaprogramming::BaseFilter_t;
+using ::bind_lang::metaprogramming::BaseFilter_t;
 
 namespace {
 
diff --git a/bind_lang/metaprogramming/call.h b/bind_lang/metaprogramming/call.h
index 7b61ab34..b17cfaad 100644
--- a/bind_lang/metaprogramming/call.h
+++ b/bind_lang/metaprogramming/call.h
@@ -18,7 +18,7 @@
 
 #include <tuple>
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 // Call takes a tuple of arguments and returns a tuple of elements
 // dereferenced once (with no arguments). Eventually, this should have
@@ -39,6 +39,6 @@ struct Call {
 template <typename T>
 using Call_t = typename Call::type<T>;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_CALL_H_
diff --git a/bind_lang/metaprogramming/call_test.cc b/bind_lang/metaprogramming/call_test.cc
index 9b393c8e..37fc57b0 100644
--- a/bind_lang/metaprogramming/call_test.cc
+++ b/bind_lang/metaprogramming/call_test.cc
@@ -19,7 +19,7 @@
 #include <tuple>
 #include <type_traits>
 
-using ::jni::metaprogramming::Call_t;
+using ::bind_lang::metaprogramming::Call_t;
 
 namespace {
 
diff --git a/bind_lang/metaprogramming/cartesian_product.h b/bind_lang/metaprogramming/cartesian_product.h
index ab923d9e..33d76e2e 100644
--- a/bind_lang/metaprogramming/cartesian_product.h
+++ b/bind_lang/metaprogramming/cartesian_product.h
@@ -26,7 +26,7 @@
 #include "n_bit_sequence.h"
 #include "type_of_nth_element.h"
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 // Metafunction that takes a list of tuples, and creates a counter where each
 // value is the size of the corresponding tuple.  This can be used to create
@@ -100,6 +100,6 @@ struct CartesianProduct {
 template <typename... Tups>
 using CartesianProduct_t = typename CartesianProduct::template type<Tups...>;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_CARTESIAN_PRODUCT_H_
diff --git a/bind_lang/metaprogramming/cartesian_product_test.cc b/bind_lang/metaprogramming/cartesian_product_test.cc
index fd09319c..dd4a52c8 100644
--- a/bind_lang/metaprogramming/cartesian_product_test.cc
+++ b/bind_lang/metaprogramming/cartesian_product_test.cc
@@ -25,12 +25,12 @@
 
 namespace {
 
-using ::jni::metaprogramming::CartesianProduct;
-using ::jni::metaprogramming::CartesianProduct_t;
-using ::jni::metaprogramming::GenerateBitSequenceFromTupSets_t;
-using ::jni::metaprogramming::InvokeAsPack_t;
-using ::jni::metaprogramming::NBit;
-using ::jni::metaprogramming::NBitSequence;
+using ::bind_lang::metaprogramming::CartesianProduct;
+using ::bind_lang::metaprogramming::CartesianProduct_t;
+using ::bind_lang::metaprogramming::GenerateBitSequenceFromTupSets_t;
+using ::bind_lang::metaprogramming::InvokeAsPack_t;
+using ::bind_lang::metaprogramming::NBit;
+using ::bind_lang::metaprogramming::NBitSequence;
 
 template <typename... Ts>
 using Tup = std::tuple<Ts...>;
diff --git a/bind_lang/metaprogramming/chain.h b/bind_lang/metaprogramming/chain.h
index 288c0910..516141d1 100644
--- a/bind_lang/metaprogramming/chain.h
+++ b/bind_lang/metaprogramming/chain.h
@@ -19,7 +19,7 @@
 
 #include "invoke.h"
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 // Metafunction to invoke a metafunction and forward its output to another
 // metafunction (or sequence of metafunctions).  Note, unlike typical functional
@@ -42,6 +42,6 @@ struct Chain<FirstFunc, Funcs...> {
       Invoke_t<Chain<Funcs...>, Invoke_t<FirstFunc, ArgsForFirstFunc...>>;
 };
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_CHAIN_H_
diff --git a/bind_lang/metaprogramming/chain_test.cc b/bind_lang/metaprogramming/chain_test.cc
index 49af8bc5..5fdd2bd3 100644
--- a/bind_lang/metaprogramming/chain_test.cc
+++ b/bind_lang/metaprogramming/chain_test.cc
@@ -23,11 +23,11 @@
 #include "invoke.h"
 #include "same.h"
 
-using ::jni::metaprogramming::Chain;
-using ::jni::metaprogramming::Increment;
-using ::jni::metaprogramming::Increment_t;
-using ::jni::metaprogramming::Invoke_t;
-using ::jni::metaprogramming::Same;
+using ::bind_lang::metaprogramming::Chain;
+using ::bind_lang::metaprogramming::Increment;
+using ::bind_lang::metaprogramming::Increment_t;
+using ::bind_lang::metaprogramming::Invoke_t;
+using ::bind_lang::metaprogramming::Same;
 
 namespace {
 
diff --git a/bind_lang/metaprogramming/color.h b/bind_lang/metaprogramming/color.h
index a83289fb..8476dc28 100644
--- a/bind_lang/metaprogramming/color.h
+++ b/bind_lang/metaprogramming/color.h
@@ -20,7 +20,7 @@
 #include <string>
 #include <string_view>
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 struct Color {
   static constexpr std::string_view kNone{"\033[0m"};
@@ -71,6 +71,6 @@ inline std::string Colorize(std::string_view colour, std::string_view str,
                           std::string{Color::kNone};
 }
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_COLOR_H_
diff --git a/bind_lang/metaprogramming/color_test.cc b/bind_lang/metaprogramming/color_test.cc
index 9c9fedb9..2ed443db 100644
--- a/bind_lang/metaprogramming/color_test.cc
+++ b/bind_lang/metaprogramming/color_test.cc
@@ -21,8 +21,8 @@
 
 #include <gtest/gtest.h>
 
-using ::jni::metaprogramming::Color;
-using ::jni::metaprogramming::Colorize;
+using ::bind_lang::metaprogramming::Color;
+using ::bind_lang::metaprogramming::Colorize;
 
 namespace {
 
diff --git a/bind_lang/metaprogramming/combine.h b/bind_lang/metaprogramming/combine.h
index 8bd23f07..0debc762 100644
--- a/bind_lang/metaprogramming/combine.h
+++ b/bind_lang/metaprogramming/combine.h
@@ -19,7 +19,7 @@
 
 #include <tuple>
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 // Takes two tuples and collapses them into a single tuple.
 struct Combine {
@@ -41,6 +41,6 @@ struct Combine {
 template <typename Tup1, typename Tup2>
 using Combine_t = typename Combine::template type<Tup1, Tup2>;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_COMBINE_H_
diff --git a/bind_lang/metaprogramming/combine_test.cc b/bind_lang/metaprogramming/combine_test.cc
index 56838c31..a08f7705 100644
--- a/bind_lang/metaprogramming/combine_test.cc
+++ b/bind_lang/metaprogramming/combine_test.cc
@@ -19,7 +19,7 @@
 #include <tuple>
 #include <type_traits>
 
-using ::jni::metaprogramming::Combine_t;
+using ::bind_lang::metaprogramming::Combine_t;
 
 namespace {
 
diff --git a/bind_lang/metaprogramming/concatenate.h b/bind_lang/metaprogramming/concatenate.h
index 17f4e18a..dad64c9f 100644
--- a/bind_lang/metaprogramming/concatenate.h
+++ b/bind_lang/metaprogramming/concatenate.h
@@ -22,7 +22,7 @@
 #include "combine.h"
 #include "reduce.h"
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 // Metafunction to generate a concatenation of variadic args.
 struct Concatenate {
@@ -47,6 +47,6 @@ struct ConcatenateTup<std::tuple<T1s...>> {
 template <typename... Tups>
 using ConcatenateTup_t = Reduce_t<Combine, Tups...>;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_CONCATENATE_H_
diff --git a/bind_lang/metaprogramming/concatenate_test.cc b/bind_lang/metaprogramming/concatenate_test.cc
index eb1a5c52..edc5ffd9 100644
--- a/bind_lang/metaprogramming/concatenate_test.cc
+++ b/bind_lang/metaprogramming/concatenate_test.cc
@@ -19,8 +19,8 @@
 #include <tuple>
 #include <type_traits>
 
-using ::jni::metaprogramming::Concatenate_t;
-using ::jni::metaprogramming::ConcatenateTup_t;
+using ::bind_lang::metaprogramming::Concatenate_t;
+using ::bind_lang::metaprogramming::ConcatenateTup_t;
 
 namespace {
 
diff --git a/bind_lang/metaprogramming/conditional.h b/bind_lang/metaprogramming/conditional.h
index 6ea7dd9f..7813d6cd 100644
--- a/bind_lang/metaprogramming/conditional.h
+++ b/bind_lang/metaprogramming/conditional.h
@@ -20,7 +20,7 @@
 #include <tuple>
 #include <type_traits>
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 // For a given Func which takes values, returns std::tuple<Ts...> if
 // Func<Ts...>::value is true, otherwise returns std::tuple. Func must have a
@@ -38,6 +38,6 @@ struct Conditional {
 template <typename Func, typename... Ts>
 using Conditional_t = typename Conditional<Func>::template type<Ts...>;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_CONDITIONAL_H_
diff --git a/bind_lang/metaprogramming/conditional_test.cc b/bind_lang/metaprogramming/conditional_test.cc
index eeeff763..36132c4a 100644
--- a/bind_lang/metaprogramming/conditional_test.cc
+++ b/bind_lang/metaprogramming/conditional_test.cc
@@ -23,8 +23,8 @@
 
 namespace {
 
-using ::jni::metaprogramming::Conditional_t;
-using ::jni::metaprogramming::Same;
+using ::bind_lang::metaprogramming::Conditional_t;
+using ::bind_lang::metaprogramming::Same;
 
 struct A {};
 struct B {};
diff --git a/bind_lang/metaprogramming/contains.h b/bind_lang/metaprogramming/contains.h
index ac1703e3..72050f12 100644
--- a/bind_lang/metaprogramming/contains.h
+++ b/bind_lang/metaprogramming/contains.h
@@ -22,7 +22,7 @@
 #include "same.h"
 #include "tuple_manipulation.h"
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 template <typename SoughtType, typename... Ts>
 using Contains_t = Invoke_t<Any<Same<SoughtType>>, Ts...>;
@@ -42,6 +42,6 @@ constexpr bool ContainsValue(const SoughtType& sought_value, Ts&&... ts) {
   return ((sought_value == ts) || ...);
 }
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_CONTAINS_H_
diff --git a/bind_lang/metaprogramming/contains_base.h b/bind_lang/metaprogramming/contains_base.h
index 7b35d08f..b3b494ad 100644
--- a/bind_lang/metaprogramming/contains_base.h
+++ b/bind_lang/metaprogramming/contains_base.h
@@ -23,7 +23,7 @@
 #include "same.h"
 #include "tuple_manipulation.h"
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 template <typename SoughtType, typename... Ts>
 using ContainsBase_t = Invoke_t<Any<Base<SoughtType>>, Ts...>;
@@ -39,6 +39,6 @@ template <typename SoughtType, typename Tup>
 static constexpr bool TupContainsBase_v =
     TupContainsBase_t<SoughtType, Tup>::value;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_CONTAINS_BASE_H_
diff --git a/bind_lang/metaprogramming/contains_base_test.cc b/bind_lang/metaprogramming/contains_base_test.cc
index c3b8125e..edb9c992 100644
--- a/bind_lang/metaprogramming/contains_base_test.cc
+++ b/bind_lang/metaprogramming/contains_base_test.cc
@@ -20,8 +20,8 @@
 
 namespace {
 
-using ::jni::metaprogramming::Contains_v;
-using ::jni::metaprogramming::ContainsBase_v;
+using ::bind_lang::metaprogramming::Contains_v;
+using ::bind_lang::metaprogramming::ContainsBase_v;
 
 struct A {};
 struct B : A {};
diff --git a/bind_lang/metaprogramming/contains_test.cc b/bind_lang/metaprogramming/contains_test.cc
index 074b8180..be6d3739 100644
--- a/bind_lang/metaprogramming/contains_test.cc
+++ b/bind_lang/metaprogramming/contains_test.cc
@@ -20,9 +20,9 @@
 
 namespace {
 
-using ::jni::metaprogramming::Contains_v;
-using ::jni::metaprogramming::ContainsValue;
-using ::jni::metaprogramming::TupContains_v;
+using ::bind_lang::metaprogramming::Contains_v;
+using ::bind_lang::metaprogramming::ContainsValue;
+using ::bind_lang::metaprogramming::TupContains_v;
 
 struct A {};
 
diff --git a/bind_lang/metaprogramming/corpus.h b/bind_lang/metaprogramming/corpus.h
index 9d46b7a3..0358e129 100644
--- a/bind_lang/metaprogramming/corpus.h
+++ b/bind_lang/metaprogramming/corpus.h
@@ -23,7 +23,7 @@
 #include "corpus_tag.h"
 #include "detect.h"
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 // Provides the universe of keys, including user defined types if any.
 // Users define custom types by partially specialising UserDefined (see test).
@@ -47,6 +47,6 @@ struct Corpus {
 template <typename T, typename... Defaults>
 using Corpus_t = typename Corpus<Defaults...>::template type<T>;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_CORPUS_H_
diff --git a/bind_lang/metaprogramming/corpus_tag.h b/bind_lang/metaprogramming/corpus_tag.h
index b748b664..b6bf076d 100644
--- a/bind_lang/metaprogramming/corpus_tag.h
+++ b/bind_lang/metaprogramming/corpus_tag.h
@@ -17,12 +17,12 @@
 #ifndef JNI_BIND_BIND_LANG_METAPROGRAMMING_CORPUS_TAG_H_
 #define JNI_BIND_BIND_LANG_METAPROGRAMMING_CORPUS_TAG_H_
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 // Provide a partial specialization to this class to provide custom types.
 template <typename T>
 struct UserDefined;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_CORPUS_TAG_H_
diff --git a/bind_lang/metaprogramming/corpus_test.cc b/bind_lang/metaprogramming/corpus_test.cc
index 52c23c47..790b4a26 100644
--- a/bind_lang/metaprogramming/corpus_test.cc
+++ b/bind_lang/metaprogramming/corpus_test.cc
@@ -25,22 +25,23 @@ struct A {};
 struct B {};
 struct C {};
 
-// Note: This ordering is intentional (see `::jni::Corpus`).
-namespace jni::metaprogramming {
+// Note: This ordering is intentional (see
+// `::bind_lang::metaprogramming::Corpus`).
+namespace bind_lang::metaprogramming {
 
 template <>
 struct UserDefined<CorpusTag> {
   using type = std::tuple<A, B, C>;
 };
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #include "bind_lang/metaprogramming/corpus.h"
 #include "bind_lang/metaprogramming/detect.h"
 
-using ::jni::metaprogramming::Corpus_t;
-using ::jni::metaprogramming::Detect_t;
-using ::jni::metaprogramming::UserDefined;
+using ::bind_lang::metaprogramming::Corpus_t;
+using ::bind_lang::metaprogramming::Detect_t;
+using ::bind_lang::metaprogramming::UserDefined;
 
 namespace {
 
diff --git a/bind_lang/metaprogramming/deep_equal.h b/bind_lang/metaprogramming/deep_equal.h
index fbcd991e..be95c93f 100644
--- a/bind_lang/metaprogramming/deep_equal.h
+++ b/bind_lang/metaprogramming/deep_equal.h
@@ -22,7 +22,7 @@
 #include "bind_lang/metaprogramming/pack_discriminator.h"
 #include "bind_lang/metaprogramming/vals_equal.h"
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 template <typename T1>
 struct DeepEqual;
@@ -103,6 +103,6 @@ struct DeepEqual {
   static constexpr bool val = Val<T2>();
 };
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_DEEP_EQUAL_H_
diff --git a/bind_lang/metaprogramming/deep_equal_diminished.h b/bind_lang/metaprogramming/deep_equal_diminished.h
index 2283715c..b761e4ff 100644
--- a/bind_lang/metaprogramming/deep_equal_diminished.h
+++ b/bind_lang/metaprogramming/deep_equal_diminished.h
@@ -22,7 +22,7 @@
 #include "bind_lang/metaprogramming/pack_discriminator.h"
 #include "bind_lang/metaprogramming/vals_equal_diminished.h"
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 template <typename T1>
 struct DeepEqualDiminished;
@@ -106,6 +106,6 @@ struct DeepEqualDiminished {
   static constexpr bool val = Val<T2>();
 };
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_DEEP_EQUAL_DIMINISHED_H_
diff --git a/bind_lang/metaprogramming/deep_equal_diminished_test.cc b/bind_lang/metaprogramming/deep_equal_diminished_test.cc
index 49afb1ff..d8613bc5 100644
--- a/bind_lang/metaprogramming/deep_equal_diminished_test.cc
+++ b/bind_lang/metaprogramming/deep_equal_diminished_test.cc
@@ -25,7 +25,7 @@ namespace {
 // Unsupported assertions are intentionally left commented for comparison.
 ////////////////////////////////////////////////////////////////////////////////
 
-using ::jni::metaprogramming::DeepEqualDiminished_v;
+using ::bind_lang::metaprogramming::DeepEqualDiminished_v;
 
 struct A {
   constexpr explicit A(int i) : i_(i) {}
diff --git a/bind_lang/metaprogramming/deep_equal_test.cc b/bind_lang/metaprogramming/deep_equal_test.cc
index 68e5c164..e3fcc2e3 100644
--- a/bind_lang/metaprogramming/deep_equal_test.cc
+++ b/bind_lang/metaprogramming/deep_equal_test.cc
@@ -20,7 +20,7 @@
 
 namespace {
 
-using ::jni::metaprogramming::DeepEqual_v;
+using ::bind_lang::metaprogramming::DeepEqual_v;
 
 struct A {
   constexpr explicit A(int i) : i_(i) {}
diff --git a/bind_lang/metaprogramming/detect.h b/bind_lang/metaprogramming/detect.h
index bbccb364..e508854a 100644
--- a/bind_lang/metaprogramming/detect.h
+++ b/bind_lang/metaprogramming/detect.h
@@ -20,7 +20,7 @@
 #include <tuple>
 #include <type_traits>
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 // Metafunction that detects a partial specialisation for a Container.
 template <template <typename> class Container>
@@ -50,6 +50,6 @@ using Detect_t = typename Detect<Container>::template type<T>;
 template <template <typename> class Container, typename T>
 static constexpr bool Detect_v = Detect<Container>::template val<T>;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_DETECT_H_
diff --git a/bind_lang/metaprogramming/detect_test.cc b/bind_lang/metaprogramming/detect_test.cc
index 2a84a826..3f40fe98 100644
--- a/bind_lang/metaprogramming/detect_test.cc
+++ b/bind_lang/metaprogramming/detect_test.cc
@@ -19,8 +19,8 @@
 #include <tuple>
 #include <type_traits>
 
-using ::jni::metaprogramming::Detect_t;
-using ::jni::metaprogramming::Detect_v;
+using ::bind_lang::metaprogramming::Detect_t;
+using ::bind_lang::metaprogramming::Detect_v;
 
 namespace {
 
diff --git a/bind_lang/metaprogramming/double_locked_value.h b/bind_lang/metaprogramming/double_locked_value.h
index 39e9d571..de4d5a56 100644
--- a/bind_lang/metaprogramming/double_locked_value.h
+++ b/bind_lang/metaprogramming/double_locked_value.h
@@ -20,7 +20,7 @@
 #include <atomic>
 #include <mutex>
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 // This class is intended to mimic a function local static except that it
 // supports being reset. The object is constructed with a lambda and all
@@ -79,6 +79,6 @@ class DoubleLockedValue {
   std::mutex lock_;
 };
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_DOUBLE_LOCKED_VALUE_H_
diff --git a/bind_lang/metaprogramming/double_locked_value_test.cc b/bind_lang/metaprogramming/double_locked_value_test.cc
index 9efae9d5..6f70683d 100644
--- a/bind_lang/metaprogramming/double_locked_value_test.cc
+++ b/bind_lang/metaprogramming/double_locked_value_test.cc
@@ -20,7 +20,7 @@
 
 namespace {
 
-using ::jni::metaprogramming::DoubleLockedValue;
+using ::bind_lang::metaprogramming::DoubleLockedValue;
 
 TEST(DoubleLockedValue, ConstructsTrivialValue) {
   auto a = []() { return 1; };
diff --git a/bind_lang/metaprogramming/even_odd.h b/bind_lang/metaprogramming/even_odd.h
index 2b0410cf..bcc9b878 100644
--- a/bind_lang/metaprogramming/even_odd.h
+++ b/bind_lang/metaprogramming/even_odd.h
@@ -21,7 +21,7 @@
 
 #include "concatenate.h"
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 template <typename... Ts>
 struct EvenHelper {};
@@ -68,6 +68,6 @@ struct Odd {
 template <typename... Ts>
 using Odd_t = typename Odd::template type<Ts...>;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_EVEN_ODD_H_
diff --git a/bind_lang/metaprogramming/even_odd_test.cc b/bind_lang/metaprogramming/even_odd_test.cc
index 62199e1f..96c5b8f6 100644
--- a/bind_lang/metaprogramming/even_odd_test.cc
+++ b/bind_lang/metaprogramming/even_odd_test.cc
@@ -19,8 +19,8 @@
 #include <tuple>
 #include <type_traits>
 
-using ::jni::metaprogramming::Even_t;
-using ::jni::metaprogramming::Odd_t;
+using ::bind_lang::metaprogramming::Even_t;
+using ::bind_lang::metaprogramming::Odd_t;
 
 namespace {
 
diff --git a/bind_lang/metaprogramming/filter.h b/bind_lang/metaprogramming/filter.h
index e54dd084..ccb8d89e 100644
--- a/bind_lang/metaprogramming/filter.h
+++ b/bind_lang/metaprogramming/filter.h
@@ -22,7 +22,7 @@
 #include "concatenate.h"
 #include "conditional.h"
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 // Metafunction for filtering elements that do or don't satisfy a given
 // metafunction.  The metafunction must expose a static constepxr boolean
@@ -51,6 +51,6 @@ struct Filter {
 template <typename Func, typename... Ts>
 using Filter_t = typename Filter<Func>::template type<Ts...>;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_FILTER_H_
diff --git a/bind_lang/metaprogramming/filter_test.cc b/bind_lang/metaprogramming/filter_test.cc
index ee5d9b2e..58c21cb8 100644
--- a/bind_lang/metaprogramming/filter_test.cc
+++ b/bind_lang/metaprogramming/filter_test.cc
@@ -23,8 +23,8 @@
 
 namespace {
 
-using ::jni::metaprogramming::Filter_t;
-using ::jni::metaprogramming::Same;
+using ::bind_lang::metaprogramming::Filter_t;
+using ::bind_lang::metaprogramming::Same;
 
 struct A {};
 struct B {};
diff --git a/bind_lang/metaprogramming/find_idx_of_val.h b/bind_lang/metaprogramming/find_idx_of_val.h
index fc04b684..f16b17f8 100644
--- a/bind_lang/metaprogramming/find_idx_of_val.h
+++ b/bind_lang/metaprogramming/find_idx_of_val.h
@@ -23,7 +23,7 @@
 #include "same.h"
 #include "tuple_manipulation.h"
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 // Metafunction that binds a metafunction (e.g. Same), a query (e.g. "A"),  a
 // variadic pack as arguments, and returns the idx of the query.  All members
@@ -83,6 +83,6 @@ template <typename Query, typename TupType>
 static constexpr std::size_t FindIdxOfValInTup_idx =
     FindIdxOfValInTupWithComparator_idx<Same<Query>, TupType>;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_FIND_IDX_OF_VAL_H_
diff --git a/bind_lang/metaprogramming/find_idx_of_val_test.cc b/bind_lang/metaprogramming/find_idx_of_val_test.cc
index 955c1fb0..0a4e4e99 100644
--- a/bind_lang/metaprogramming/find_idx_of_val_test.cc
+++ b/bind_lang/metaprogramming/find_idx_of_val_test.cc
@@ -19,10 +19,10 @@
 #include <tuple>
 #include <type_traits>
 
-using ::jni::metaprogramming::FindIdxOfVal_idx;
-using ::jni::metaprogramming::FindIdxOfValInTup_idx;
-using ::jni::metaprogramming::FindIdxOfValInTupWithComparator_idx;
-using ::jni::metaprogramming::FindIdxOfValWithComparator_idx;
+using ::bind_lang::metaprogramming::FindIdxOfVal_idx;
+using ::bind_lang::metaprogramming::FindIdxOfValInTup_idx;
+using ::bind_lang::metaprogramming::FindIdxOfValInTupWithComparator_idx;
+using ::bind_lang::metaprogramming::FindIdxOfValWithComparator_idx;
 
 namespace {
 
diff --git a/bind_lang/metaprogramming/flatten.h b/bind_lang/metaprogramming/flatten.h
index f9a8656f..5489012e 100644
--- a/bind_lang/metaprogramming/flatten.h
+++ b/bind_lang/metaprogramming/flatten.h
@@ -21,7 +21,7 @@
 
 #include "concatenate.h"
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 // Metafunction that takes sets of tuples and reduces them to a single tuple.
 // No element in the result set will be a tuple, any and all nested tuples will
@@ -56,6 +56,6 @@ struct Flatten {
 template <typename... Ts>
 using Flatten_t = typename Flatten::template type<Ts...>;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_FLATTEN_H_
diff --git a/bind_lang/metaprogramming/flatten_test.cc b/bind_lang/metaprogramming/flatten_test.cc
index ad48b5d0..8ea6341a 100644
--- a/bind_lang/metaprogramming/flatten_test.cc
+++ b/bind_lang/metaprogramming/flatten_test.cc
@@ -19,7 +19,7 @@
 #include <tuple>
 #include <type_traits>
 
-using ::jni::metaprogramming::Flatten_t;
+using ::bind_lang::metaprogramming::Flatten_t;
 
 namespace {
 
diff --git a/bind_lang/metaprogramming/function_traits.h b/bind_lang/metaprogramming/function_traits.h
index 49e74765..8807a977 100644
--- a/bind_lang/metaprogramming/function_traits.h
+++ b/bind_lang/metaprogramming/function_traits.h
@@ -20,7 +20,7 @@
 #include <cstddef>
 #include <tuple>
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 // Metafunction for querying traits return and argument types of a function.
 template <typename>
@@ -66,6 +66,6 @@ template <typename T, std::size_t argument_idx>
 using FunctionTraitsArg_t =
     typename FunctionTraits<T>::template Argument<argument_idx>::type;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_FUNCTION_TRAITS_H_
diff --git a/bind_lang/metaprogramming/function_traits_test.cc b/bind_lang/metaprogramming/function_traits_test.cc
index fe940d3f..4d1e033a 100644
--- a/bind_lang/metaprogramming/function_traits_test.cc
+++ b/bind_lang/metaprogramming/function_traits_test.cc
@@ -24,8 +24,8 @@
 
 namespace {
 
-using ::jni::metaprogramming::FunctionTraitsArg_t;
-using ::jni::metaprogramming::FunctionTraitsReturn_t;
+using ::bind_lang::metaprogramming::FunctionTraitsArg_t;
+using ::bind_lang::metaprogramming::FunctionTraitsReturn_t;
 
 void VFoo() {}
 void VFoo_I(int) {}
diff --git a/bind_lang/metaprogramming/increment.h b/bind_lang/metaprogramming/increment.h
index 34de493e..6c2203e6 100644
--- a/bind_lang/metaprogramming/increment.h
+++ b/bind_lang/metaprogramming/increment.h
@@ -19,7 +19,7 @@
 
 #include <cstddef>
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 // Metafunction to increment types a certain number of times.
 // Types must export a type alias "Increment" which increments the type once.
@@ -42,6 +42,6 @@ struct Increment {
 template <typename T, std::size_t I = 1>
 using Increment_t = typename Increment<I>::template type<T>;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_INCREMENT_H_
diff --git a/bind_lang/metaprogramming/increment_test.cc b/bind_lang/metaprogramming/increment_test.cc
index 796a3833..3430f764 100644
--- a/bind_lang/metaprogramming/increment_test.cc
+++ b/bind_lang/metaprogramming/increment_test.cc
@@ -18,7 +18,7 @@
 
 #include <cstddef>
 
-using ::jni::metaprogramming::Increment_t;
+using ::bind_lang::metaprogramming::Increment_t;
 
 namespace {
 
diff --git a/bind_lang/metaprogramming/index.h b/bind_lang/metaprogramming/index.h
index 60ca649d..95c84936 100644
--- a/bind_lang/metaprogramming/index.h
+++ b/bind_lang/metaprogramming/index.h
@@ -22,7 +22,7 @@
 
 #include "tuple_manipulation.h"
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 template <std::size_t Idx, typename T>
 struct IndexEntry {
@@ -50,6 +50,6 @@ using Index_t = typename Index::template type<Ts...>;
 template <typename Tup>
 using Index_Tup = TupleUnroller_t<Index, Tup>;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_INDEX_H_
diff --git a/bind_lang/metaprogramming/index_test.cc b/bind_lang/metaprogramming/index_test.cc
index d8e115eb..1a0735b4 100644
--- a/bind_lang/metaprogramming/index_test.cc
+++ b/bind_lang/metaprogramming/index_test.cc
@@ -21,9 +21,9 @@
 
 namespace {
 
-using ::jni::metaprogramming::Index_t;
-using ::jni::metaprogramming::Index_Tup;
-using ::jni::metaprogramming::IndexEntry;
+using ::bind_lang::metaprogramming::Index_t;
+using ::bind_lang::metaprogramming::Index_Tup;
+using ::bind_lang::metaprogramming::IndexEntry;
 
 struct A {};
 struct B {};
diff --git a/bind_lang/metaprogramming/interleave.h b/bind_lang/metaprogramming/interleave.h
index 20b74429..93693d43 100644
--- a/bind_lang/metaprogramming/interleave.h
+++ b/bind_lang/metaprogramming/interleave.h
@@ -22,7 +22,7 @@
 #include <type_traits>
 #include <utility>
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 // Returns a null pointer of the type of the two input tuples interleaved.
 template <class Tuple1, class Tuple2, std::size_t... indices>
@@ -52,6 +52,6 @@ struct Interleaved<std::tuple<T0...>, std::tuple<T1...>> {
       decltype(Interleave<std::tuple<T0...>, std::tuple<T1...>>())>;
 };
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_INTERLEAVE_H_
diff --git a/bind_lang/metaprogramming/interleave_test.cc b/bind_lang/metaprogramming/interleave_test.cc
index 74f7c621..6db32f10 100644
--- a/bind_lang/metaprogramming/interleave_test.cc
+++ b/bind_lang/metaprogramming/interleave_test.cc
@@ -21,7 +21,7 @@
 
 #include <gtest/gtest.h>
 
-using ::jni::metaprogramming::Interleaved;
+using ::bind_lang::metaprogramming::Interleaved;
 
 namespace {
 
diff --git a/bind_lang/metaprogramming/invocable_map.h b/bind_lang/metaprogramming/invocable_map.h
index 688bf739..2fc1003e 100644
--- a/bind_lang/metaprogramming/invocable_map.h
+++ b/bind_lang/metaprogramming/invocable_map.h
@@ -23,7 +23,7 @@
 #include <type_traits>
 #include <utility>
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 // This is an interface that can be inherited from to expose an operator(...).
 // It provides compile time string index lookup with no macros although it is
@@ -119,6 +119,6 @@ class InvocableMap
           std::make_index_sequence<std::tuple_size_v<
               std::decay_t<decltype(tup_container_v.*nameable_member)>>>> {};
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_INVOCABLE_MAP_H_
diff --git a/bind_lang/metaprogramming/invocable_map_20.h b/bind_lang/metaprogramming/invocable_map_20.h
index 0d5cbff3..b037a0cb 100644
--- a/bind_lang/metaprogramming/invocable_map_20.h
+++ b/bind_lang/metaprogramming/invocable_map_20.h
@@ -26,7 +26,7 @@
 #include "modified_max.h"
 #include "string_literal.h"
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 // This class enables compile time lookup that perfectly forward arguments
 // to a method named `Call`.  This is a C++ 20 version of InvocableMap.
@@ -93,6 +93,6 @@ class InvocableMap20 {
 #endif  // __cplusplus >= 202002L
 };
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_INVOCABLE_MAP_20_H_
diff --git a/bind_lang/metaprogramming/invocable_map_20_test.cc b/bind_lang/metaprogramming/invocable_map_20_test.cc
index 7322e71c..e3d01311 100644
--- a/bind_lang/metaprogramming/invocable_map_20_test.cc
+++ b/bind_lang/metaprogramming/invocable_map_20_test.cc
@@ -24,8 +24,8 @@
 #include "string_literal.h"
 #include <gtest/gtest.h>
 
-using jni::metaprogramming::InvocableMap20;
-using jni::metaprogramming::StringLiteral;
+using bind_lang::metaprogramming::InvocableMap20;
+using bind_lang::metaprogramming::StringLiteral;
 
 struct Str {
   const char* name_;
diff --git a/bind_lang/metaprogramming/invocable_map_test.cc b/bind_lang/metaprogramming/invocable_map_test.cc
index d64db8a1..8f89f236 100644
--- a/bind_lang/metaprogramming/invocable_map_test.cc
+++ b/bind_lang/metaprogramming/invocable_map_test.cc
@@ -25,7 +25,7 @@
 
 namespace {
 
-using ::jni::metaprogramming::InvocableMap;
+using ::bind_lang::metaprogramming::InvocableMap;
 
 struct Str {
   const char* name_;
@@ -51,7 +51,7 @@ class SampleClassNowExposingCallOperator1
   template <typename CrtpBase, const auto& tup_container_v,
             typename TupContainerT, typename MemberT, MemberT nameable_member,
             size_t I>
-  friend class jni::metaprogramming::InvocableMapEntry;
+  friend class bind_lang::metaprogramming::InvocableMapEntry;
 
   template <size_t I, typename... Args>
   auto InvocableMapCall(const char* key, Args&&... ts) const {
@@ -96,7 +96,7 @@ class SampleClassNowExposingCallOperator2
   template <typename CrtpBase, const auto& tup_container_v,
             typename TupContainerT, typename MemberT, MemberT nameable_member,
             size_t I>
-  friend class jni::metaprogramming::InvocableMapEntry;
+  friend class bind_lang::metaprogramming::InvocableMapEntry;
 
   template <size_t I, typename... Args>
   auto InvocableMapCall(const char* key, Args&&... args) const {
diff --git a/bind_lang/metaprogramming/invoke.h b/bind_lang/metaprogramming/invoke.h
index 9405b5e0..b7c6dc9d 100644
--- a/bind_lang/metaprogramming/invoke.h
+++ b/bind_lang/metaprogramming/invoke.h
@@ -23,7 +23,7 @@
 #include "tuple_manipulation.h"
 #include "unwrap.h"
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 // "Invokes" a metafunction (i.e. a type alias for Func::type).
 // Handles both variadic or non-variadic args for a consistent syntax.
@@ -67,6 +67,6 @@ template <typename Func, typename TupleOfTupleOfArgs>
 using InvokePerTupArgAsPack_t =
     InvokePerTupArg_t<Unwrap<Func>, TupleOfTupleOfArgs>;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_INVOKE_H_
diff --git a/bind_lang/metaprogramming/invoke_test.cc b/bind_lang/metaprogramming/invoke_test.cc
index b41e2122..7d18b60e 100644
--- a/bind_lang/metaprogramming/invoke_test.cc
+++ b/bind_lang/metaprogramming/invoke_test.cc
@@ -24,13 +24,13 @@
 #include "per_element.h"
 #include "same.h"
 
-using ::jni::metaprogramming::Increment;
-using ::jni::metaprogramming::Invoke_t;
-using ::jni::metaprogramming::InvokeAsPack_t;
-using ::jni::metaprogramming::InvokePerTupArg_t;
-using ::jni::metaprogramming::InvokePerTupArgAsPack_t;
-using ::jni::metaprogramming::PerElement;
-using ::jni::metaprogramming::Same;
+using ::bind_lang::metaprogramming::Increment;
+using ::bind_lang::metaprogramming::Invoke_t;
+using ::bind_lang::metaprogramming::InvokeAsPack_t;
+using ::bind_lang::metaprogramming::InvokePerTupArg_t;
+using ::bind_lang::metaprogramming::InvokePerTupArgAsPack_t;
+using ::bind_lang::metaprogramming::PerElement;
+using ::bind_lang::metaprogramming::Same;
 
 namespace {
 
diff --git a/bind_lang/metaprogramming/lambda_string.h b/bind_lang/metaprogramming/lambda_string.h
index 7e0aadf6..edaec71c 100644
--- a/bind_lang/metaprogramming/lambda_string.h
+++ b/bind_lang/metaprogramming/lambda_string.h
@@ -24,7 +24,7 @@
 
 #define STR(x) []() { return x; }
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 template <typename Identifier>
 using identifier_type = decltype(std::declval<Identifier>()());
@@ -61,6 +61,6 @@ constexpr auto LambdaToStr(Identifier id) {
 template <typename NameLambda>
 using LambdaStringToType = decltype(LambdaToStr(std::declval<NameLambda>()));
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_LAMBDA_STRING_H_
diff --git a/bind_lang/metaprogramming/lambda_string_test.cc b/bind_lang/metaprogramming/lambda_string_test.cc
index 9579bc2b..4d20b9ad 100644
--- a/bind_lang/metaprogramming/lambda_string_test.cc
+++ b/bind_lang/metaprogramming/lambda_string_test.cc
@@ -20,9 +20,9 @@
 
 #include <gtest/gtest.h>
 
-using ::jni::metaprogramming::ConstexprStrlen;
-using ::jni::metaprogramming::LambdaStringToType;
-using ::jni::metaprogramming::StringAsType;
+using ::bind_lang::metaprogramming::ConstexprStrlen;
+using ::bind_lang::metaprogramming::LambdaStringToType;
+using ::bind_lang::metaprogramming::StringAsType;
 
 namespace {
 
diff --git a/bind_lang/metaprogramming/min_max.h b/bind_lang/metaprogramming/min_max.h
index 1921e48e..618df09b 100644
--- a/bind_lang/metaprogramming/min_max.h
+++ b/bind_lang/metaprogramming/min_max.h
@@ -20,7 +20,7 @@
 
 #include "vals.h"
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 struct Max {
   template <typename T1, typename T2>
@@ -60,6 +60,6 @@ using Min_t = typename Min::type<T1, T2>;
 template <typename T1, typename T2>
 static constexpr auto Min_v = Min_t<T1, T2>::val;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_MIN_MAX_H_
diff --git a/bind_lang/metaprogramming/min_max_test.cc b/bind_lang/metaprogramming/min_max_test.cc
index f9717bcc..1f4f59e1 100644
--- a/bind_lang/metaprogramming/min_max_test.cc
+++ b/bind_lang/metaprogramming/min_max_test.cc
@@ -23,15 +23,15 @@
 
 namespace {
 
-using ::jni::metaprogramming::Max;
-using ::jni::metaprogramming::Max_t;
-using ::jni::metaprogramming::Max_v;
-using ::jni::metaprogramming::Min;
-using ::jni::metaprogramming::Min_v;
-using ::jni::metaprogramming::Reduce_t;
-using ::jni::metaprogramming::ReduceAsPack_t;
-using ::jni::metaprogramming::ReduceAsPack_v;
-using ::jni::metaprogramming::Val_t;
+using ::bind_lang::metaprogramming::Max;
+using ::bind_lang::metaprogramming::Max_t;
+using ::bind_lang::metaprogramming::Max_v;
+using ::bind_lang::metaprogramming::Min;
+using ::bind_lang::metaprogramming::Min_v;
+using ::bind_lang::metaprogramming::Reduce_t;
+using ::bind_lang::metaprogramming::ReduceAsPack_t;
+using ::bind_lang::metaprogramming::ReduceAsPack_v;
+using ::bind_lang::metaprogramming::Val_t;
 
 static_assert(Max_v<Val_t<1>, Val_t<2>> == 2);
 static_assert(Max_v<Val_t<2>, Val_t<1>> == 2);
diff --git a/bind_lang/metaprogramming/modified_max.h b/bind_lang/metaprogramming/modified_max.h
index 6e2a5e1a..e72966ee 100644
--- a/bind_lang/metaprogramming/modified_max.h
+++ b/bind_lang/metaprogramming/modified_max.h
@@ -21,7 +21,7 @@
 #include <initializer_list>
 #include <limits>
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 constexpr std::size_t kNegativeOne = std::numeric_limits<std::size_t>::max();
 
@@ -56,6 +56,6 @@ constexpr std::size_t ModifiedMax(
   return max;
 }
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_MODIFIED_MAX_H_
diff --git a/bind_lang/metaprogramming/modified_max_test.cc b/bind_lang/metaprogramming/modified_max_test.cc
index 756358ad..b49887ff 100644
--- a/bind_lang/metaprogramming/modified_max_test.cc
+++ b/bind_lang/metaprogramming/modified_max_test.cc
@@ -20,8 +20,8 @@
 
 namespace {
 
-using ::jni::metaprogramming::kNegativeOne;
-using ::jni::metaprogramming::ModifiedMax;
+using ::bind_lang::metaprogramming::kNegativeOne;
+using ::bind_lang::metaprogramming::ModifiedMax;
 
 // Null sets work.
 static_assert(ModifiedMax({}) == kNegativeOne);
diff --git a/bind_lang/metaprogramming/n_bit.h b/bind_lang/metaprogramming/n_bit.h
index bafe806d..26c2077e 100644
--- a/bind_lang/metaprogramming/n_bit.h
+++ b/bind_lang/metaprogramming/n_bit.h
@@ -20,7 +20,7 @@
 #include <algorithm>
 #include <cstddef>
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 // Represents a value that can be [0, max], and an overflow bit.
 // When incremented, the type will rollover, and set its overflow bit.
@@ -37,6 +37,6 @@ struct NBit {
   using ResetOverflow = NBit<cur_value, max, false>;
 };
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_N_BIT_H_
diff --git a/bind_lang/metaprogramming/n_bit_sequence.h b/bind_lang/metaprogramming/n_bit_sequence.h
index 66856c55..e322356a 100644
--- a/bind_lang/metaprogramming/n_bit_sequence.h
+++ b/bind_lang/metaprogramming/n_bit_sequence.h
@@ -26,7 +26,7 @@
 #include "type_index_mask.h"
 #include "type_of_nth_element.h"
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 template <typename...>
 struct NBitSequence {};
@@ -98,6 +98,6 @@ struct NBitSequence<NBit<values, max_values, overflows>...> {
       Sequence, sequence_size_, std::make_index_sequence<sequence_size_>>::type;
 };
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_N_BIT_SEQUENCE_H_
diff --git a/bind_lang/metaprogramming/n_bit_sequence_test.cc b/bind_lang/metaprogramming/n_bit_sequence_test.cc
index 641394ee..3bc14ed3 100644
--- a/bind_lang/metaprogramming/n_bit_sequence_test.cc
+++ b/bind_lang/metaprogramming/n_bit_sequence_test.cc
@@ -23,9 +23,9 @@
 
 namespace {
 
-using ::jni::metaprogramming::Increment_t;
-using ::jni::metaprogramming::NBit;
-using ::jni::metaprogramming::NBitSequence;
+using ::bind_lang::metaprogramming::Increment_t;
+using ::bind_lang::metaprogramming::NBit;
+using ::bind_lang::metaprogramming::NBitSequence;
 
 // 1 binary value.
 using T1 = NBitSequence<NBit<0, 1>>;
diff --git a/bind_lang/metaprogramming/n_bit_test.cc b/bind_lang/metaprogramming/n_bit_test.cc
index 95f83d15..3158a464 100644
--- a/bind_lang/metaprogramming/n_bit_test.cc
+++ b/bind_lang/metaprogramming/n_bit_test.cc
@@ -20,8 +20,8 @@
 
 namespace {
 
-using ::jni::metaprogramming::Increment_t;
-using ::jni::metaprogramming::NBit;
+using ::bind_lang::metaprogramming::Increment_t;
+using ::bind_lang::metaprogramming::NBit;
 
 // Unary
 static_assert(NBit<0, 0>::value_ == 0);
diff --git a/bind_lang/metaprogramming/name_constants.h b/bind_lang/metaprogramming/name_constants.h
index a8eb9b22..143c186b 100644
--- a/bind_lang/metaprogramming/name_constants.h
+++ b/bind_lang/metaprogramming/name_constants.h
@@ -19,7 +19,7 @@
 
 #include <string_view>
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 struct Constants {
   static constexpr std::string_view new_line = "\n";
@@ -89,6 +89,6 @@ struct Constants {
   static constexpr std::string_view Z = "Z";
 };
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_NAME_CONSTANTS_H_
diff --git a/bind_lang/metaprogramming/next.h b/bind_lang/metaprogramming/next.h
index 0ecfdf9b..39449a96 100644
--- a/bind_lang/metaprogramming/next.h
+++ b/bind_lang/metaprogramming/next.h
@@ -19,7 +19,7 @@
 
 #include "pack_discriminator.h"
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 template <template <typename...> class Container>
 struct NextType;
@@ -46,6 +46,6 @@ using Next_t =
     typename PackDiscriminatedForward<NextType,
                                       NextConstRefVal>::template type<T>;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_NEXT_H_
diff --git a/bind_lang/metaprogramming/next_test.cc b/bind_lang/metaprogramming/next_test.cc
index 5048fc98..6794d2be 100644
--- a/bind_lang/metaprogramming/next_test.cc
+++ b/bind_lang/metaprogramming/next_test.cc
@@ -19,16 +19,16 @@
 #include <cstddef>
 #include <type_traits>
 
-using ::jni::metaprogramming::EndConstRefVal;
-using ::jni::metaprogramming::EndType;
-using ::jni::metaprogramming::EndVal;
+using ::bind_lang::metaprogramming::EndConstRefVal;
+using ::bind_lang::metaprogramming::EndType;
+using ::bind_lang::metaprogramming::EndVal;
 
-using ::jni::metaprogramming::Next_t;
-using ::jni::metaprogramming::NextConstRefVal;  // NOLINT
-using ::jni::metaprogramming::NextType;         // NOLINT
-using ::jni::metaprogramming::NextVal;          // NOLINT
+using ::bind_lang::metaprogramming::Next_t;
+using ::bind_lang::metaprogramming::NextConstRefVal;  // NOLINT
+using ::bind_lang::metaprogramming::NextType;         // NOLINT
+using ::bind_lang::metaprogramming::NextVal;          // NOLINT
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 ////////////////////////////////////////////////////////////////////////////////
 // Type tests.
@@ -144,4 +144,4 @@ static_assert(
         Next_t<Next_t<ConstRefCounter<kTheValue0, kMaxValSizeGlobal>>>>::val ==
     3);
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
diff --git a/bind_lang/metaprogramming/optional_wrap.h b/bind_lang/metaprogramming/optional_wrap.h
index 2a8552fe..e2d2e4dc 100644
--- a/bind_lang/metaprogramming/optional_wrap.h
+++ b/bind_lang/metaprogramming/optional_wrap.h
@@ -20,7 +20,7 @@
 #include <optional>
 #include <tuple>
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 template <typename>
 struct OptionalTup {};
@@ -35,6 +35,6 @@ struct OptionalTup<std::tuple<Ts...>> {
 template <typename... Ts>
 using OptionalTup_t = typename OptionalTup<Ts...>::type;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_OPTIONAL_WRAP_H_
diff --git a/bind_lang/metaprogramming/optional_wrap_test.cc b/bind_lang/metaprogramming/optional_wrap_test.cc
index f0ae0cf0..8732b08e 100644
--- a/bind_lang/metaprogramming/optional_wrap_test.cc
+++ b/bind_lang/metaprogramming/optional_wrap_test.cc
@@ -22,7 +22,7 @@
 
 #include <gtest/gtest.h>
 
-using ::jni::metaprogramming::OptionalTup_t;
+using ::bind_lang::metaprogramming::OptionalTup_t;
 
 namespace {
 
diff --git a/bind_lang/metaprogramming/pack_discriminator.h b/bind_lang/metaprogramming/pack_discriminator.h
index 98011cc1..c2d9d77c 100644
--- a/bind_lang/metaprogramming/pack_discriminator.h
+++ b/bind_lang/metaprogramming/pack_discriminator.h
@@ -17,7 +17,7 @@
 #ifndef JNI_BIND_BIND_LANG_METAPROGRAMMING_PACK_DISCRIMINATOR_H_
 #define JNI_BIND_BIND_LANG_METAPROGRAMMING_PACK_DISCRIMINATOR_H_
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 enum class PackType {
   NOT_CONTAINER,
@@ -76,6 +76,6 @@ struct PackDiscriminatedForward {
   using type = typename Helper<T>::type;
 };
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_PACK_DISCRIMINATOR_H_
diff --git a/bind_lang/metaprogramming/pack_discriminator_test.cc b/bind_lang/metaprogramming/pack_discriminator_test.cc
index c7264889..fb0a858f 100644
--- a/bind_lang/metaprogramming/pack_discriminator_test.cc
+++ b/bind_lang/metaprogramming/pack_discriminator_test.cc
@@ -18,8 +18,8 @@
 
 namespace {
 
-using ::jni::metaprogramming::PackDiscriminator_e;
-using ::jni::metaprogramming::PackType;
+using ::bind_lang::metaprogramming::PackDiscriminator_e;
+using ::bind_lang::metaprogramming::PackType;
 
 static constexpr bool kVal1 = false;
 static constexpr bool kVal2 = false;
diff --git a/bind_lang/metaprogramming/passthrough.h b/bind_lang/metaprogramming/passthrough.h
index 85f35c2c..a0ac3ba2 100644
--- a/bind_lang/metaprogramming/passthrough.h
+++ b/bind_lang/metaprogramming/passthrough.h
@@ -19,7 +19,7 @@
 
 #include <utility>
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 template <typename T>
 struct DefaultDeleter {
@@ -69,6 +69,6 @@ bool operator!=(const Passthrough<U, CustomDeleter>& lhs, const T& rhs) {
   return !(lhs == rhs);
 }
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_PASSTHROUGH_H_
diff --git a/bind_lang/metaprogramming/passthrough_test.cc b/bind_lang/metaprogramming/passthrough_test.cc
index c34c327e..320445b0 100644
--- a/bind_lang/metaprogramming/passthrough_test.cc
+++ b/bind_lang/metaprogramming/passthrough_test.cc
@@ -18,7 +18,7 @@
 
 #include <gtest/gtest.h>
 
-using ::jni::metaprogramming::Passthrough;
+using ::bind_lang::metaprogramming::Passthrough;
 
 template <typename T>
 struct ReleaseObjectRef {
diff --git a/bind_lang/metaprogramming/per_element.h b/bind_lang/metaprogramming/per_element.h
index f5c73122..5187818e 100644
--- a/bind_lang/metaprogramming/per_element.h
+++ b/bind_lang/metaprogramming/per_element.h
@@ -23,7 +23,7 @@
 
 #include "type_of_nth_element.h"
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 // Metafunction that takes variadic arguments and applies a bound metafunction
 // to each element.  Type exposed will always be a tuple.  This is intended for
@@ -48,6 +48,6 @@ struct PerElement {
 template <typename Func, typename... Ts>
 using PerElement_t = typename PerElement<Func>::template type<Ts...>;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_PER_ELEMENT_H_
diff --git a/bind_lang/metaprogramming/per_element_test.cc b/bind_lang/metaprogramming/per_element_test.cc
index 11665e33..bd4041c3 100644
--- a/bind_lang/metaprogramming/per_element_test.cc
+++ b/bind_lang/metaprogramming/per_element_test.cc
@@ -22,7 +22,7 @@
 
 namespace {
 
-using ::jni::metaprogramming::PerElement;
+using ::bind_lang::metaprogramming::PerElement;
 
 // Metafunction that binds an amount and increments incoming integral constants.
 template <size_t Amt>
diff --git a/bind_lang/metaprogramming/per_element_val.h b/bind_lang/metaprogramming/per_element_val.h
index 090852cd..4ba34d0b 100644
--- a/bind_lang/metaprogramming/per_element_val.h
+++ b/bind_lang/metaprogramming/per_element_val.h
@@ -19,7 +19,7 @@
 
 #include <array>
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 template <typename Lambda>
 struct PerElementVal {
@@ -36,6 +36,6 @@ template <typename Lambda, const auto... vs>
 static constexpr auto PerElementVal_v =
     PerElementVal<Lambda>::template val<vs...>;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_PER_ELEMENT_VAL_H_
diff --git a/bind_lang/metaprogramming/per_element_val_test.cc b/bind_lang/metaprogramming/per_element_val_test.cc
index 83ace846..9d67373d 100644
--- a/bind_lang/metaprogramming/per_element_val_test.cc
+++ b/bind_lang/metaprogramming/per_element_val_test.cc
@@ -20,7 +20,7 @@
 #include <cstddef>
 #include <utility>
 
-using ::jni::metaprogramming::PerElementVal_v;
+using ::bind_lang::metaprogramming::PerElementVal_v;
 
 namespace {
 
diff --git a/bind_lang/metaprogramming/queryable_map.h b/bind_lang/metaprogramming/queryable_map.h
index b6e30d7b..dc531c78 100644
--- a/bind_lang/metaprogramming/queryable_map.h
+++ b/bind_lang/metaprogramming/queryable_map.h
@@ -23,7 +23,7 @@
 #include <type_traits>
 #include <utility>
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 template <typename CrtpBase, const auto& tup_container_v,
           typename TupContainerT, typename MemberT, MemberT nameable_member,
@@ -126,6 +126,6 @@ class QueryableMapEntry {
 #endif  // __clang__
 };
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_QUERYABLE_MAP_H_
diff --git a/bind_lang/metaprogramming/queryable_map_20.h b/bind_lang/metaprogramming/queryable_map_20.h
index 725c3e1a..c5238387 100644
--- a/bind_lang/metaprogramming/queryable_map_20.h
+++ b/bind_lang/metaprogramming/queryable_map_20.h
@@ -26,7 +26,7 @@
 #include "modified_max.h"
 #include "string_literal.h"
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 // This is an interface that can be inherited from to expose an
 // operator.Access<"name">(). It provides compile time string index lookup with
@@ -85,6 +85,6 @@ class QueryableMap20 {
 #endif  // __cplusplus >= 202002L
 };
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_QUERYABLE_MAP_20_H_
diff --git a/bind_lang/metaprogramming/queryable_map_20_test.cc b/bind_lang/metaprogramming/queryable_map_20_test.cc
index 4b839a1c..cd34b166 100644
--- a/bind_lang/metaprogramming/queryable_map_20_test.cc
+++ b/bind_lang/metaprogramming/queryable_map_20_test.cc
@@ -25,8 +25,8 @@
 
 #if __cplusplus >= 202002L
 
-using jni::metaprogramming::QueryableMap20;
-using jni::metaprogramming::StringLiteral;
+using bind_lang::metaprogramming::QueryableMap20;
+using bind_lang::metaprogramming::StringLiteral;
 
 struct Str {
   const char* name_;
diff --git a/bind_lang/metaprogramming/queryable_map_test.cc b/bind_lang/metaprogramming/queryable_map_test.cc
index b8a0845c..bd151b54 100644
--- a/bind_lang/metaprogramming/queryable_map_test.cc
+++ b/bind_lang/metaprogramming/queryable_map_test.cc
@@ -25,7 +25,7 @@
 
 namespace {
 
-using ::jni::metaprogramming::QueryableMap_t;
+using ::bind_lang::metaprogramming::QueryableMap_t;
 
 struct Str {
   const char* name_;
@@ -56,7 +56,7 @@ class SampleClassNowExposingCallOperator1
   template <typename CrtpBase, const auto& tup_container_v,
             typename TupContainerT, typename MemberT, MemberT nameable_member,
             size_t I>
-  friend class jni::metaprogramming::QueryableMapEntry;
+  friend class bind_lang::metaprogramming::QueryableMapEntry;
 
   template <size_t I>
   auto QueryableMapCall(const char* key) {
@@ -122,7 +122,7 @@ class SampleClassNowExposingCallOperator2
   template <typename CrtpBase, const auto& tup_container_v,
             typename TupContainerT, typename MemberT, MemberT nameable_member,
             size_t I>
-  friend class jni::metaprogramming::QueryableMapEntry;
+  friend class bind_lang::metaprogramming::QueryableMapEntry;
 
   template <size_t I>
   auto QueryableMapCall(const char* key) {
diff --git a/bind_lang/metaprogramming/reduce.h b/bind_lang/metaprogramming/reduce.h
index 1a4e751c..e167a6b6 100644
--- a/bind_lang/metaprogramming/reduce.h
+++ b/bind_lang/metaprogramming/reduce.h
@@ -19,7 +19,7 @@
 
 #include "tuple_manipulation.h"
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 // Metafunction for a left fold reduction of a sequence of types with an
 // operation. Single element sequences return the input type with no use of
@@ -66,6 +66,6 @@ template <typename Operation, typename TupleOfTs>
 static constexpr auto ReduceAsPack_v =
     TupleUnroller_t<Reduce<Operation>, TupleOfTs>::val;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_REDUCE_H_
diff --git a/bind_lang/metaprogramming/reduce_test.cc b/bind_lang/metaprogramming/reduce_test.cc
index af9a8230..6fa3bd87 100644
--- a/bind_lang/metaprogramming/reduce_test.cc
+++ b/bind_lang/metaprogramming/reduce_test.cc
@@ -23,9 +23,9 @@
 
 namespace {
 
-using ::jni::metaprogramming::Combine;
-using ::jni::metaprogramming::Combine_t;
-using ::jni::metaprogramming::Reduce_t;
+using ::bind_lang::metaprogramming::Combine;
+using ::bind_lang::metaprogramming::Combine_t;
+using ::bind_lang::metaprogramming::Reduce_t;
 
 struct A {};
 struct B {};
diff --git a/bind_lang/metaprogramming/repeat_string.h b/bind_lang/metaprogramming/repeat_string.h
index ffbf78ca..7e8e9d1b 100644
--- a/bind_lang/metaprogramming/repeat_string.h
+++ b/bind_lang/metaprogramming/repeat_string.h
@@ -21,12 +21,12 @@
 
 #include "string_concatenate.h"
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 template <std::size_t repeat_cnt>
 struct RepeatString {
   template <const std::string_view& val_to_repeat>
-  static constexpr std::string_view val = metaprogramming::StringConcatenate_v<
+  static constexpr std::string_view val = StringConcatenate_v<
       val_to_repeat, RepeatString<repeat_cnt - 1>::template val<val_to_repeat>>;
 };
 
@@ -40,6 +40,6 @@ template <std::size_t repeat_cnt, const std::string_view& val_to_repeat>
 static constexpr auto RepeatString_v{
     RepeatString<repeat_cnt>::template val<val_to_repeat>};
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_REPEAT_STRING_H_
diff --git a/bind_lang/metaprogramming/repeat_string_test.cc b/bind_lang/metaprogramming/repeat_string_test.cc
index f48d112d..24a9bb6d 100644
--- a/bind_lang/metaprogramming/repeat_string_test.cc
+++ b/bind_lang/metaprogramming/repeat_string_test.cc
@@ -18,7 +18,7 @@
 
 #include <string_view>
 
-using ::jni::metaprogramming::RepeatString_v;
+using ::bind_lang::metaprogramming::RepeatString_v;
 
 namespace {
 
diff --git a/bind_lang/metaprogramming/replace_string.h b/bind_lang/metaprogramming/replace_string.h
index 15a22bc3..97b83096 100644
--- a/bind_lang/metaprogramming/replace_string.h
+++ b/bind_lang/metaprogramming/replace_string.h
@@ -23,7 +23,7 @@
 
 #include "lambda_string.h"
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 template <char sought_char, char new_char>
 struct Replace {
@@ -45,6 +45,6 @@ template <const std::string_view& str, char sought_char, char new_char>
 static constexpr auto Replace_v =
     Replace<sought_char, new_char>::template val<str>;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_REPLACE_STRING_H_
diff --git a/bind_lang/metaprogramming/replace_string_test.cc b/bind_lang/metaprogramming/replace_string_test.cc
index c27af4e2..7bf07879 100644
--- a/bind_lang/metaprogramming/replace_string_test.cc
+++ b/bind_lang/metaprogramming/replace_string_test.cc
@@ -18,7 +18,7 @@
 
 #include <string_view>
 
-using ::jni::metaprogramming::Replace_v;
+using ::bind_lang::metaprogramming::Replace_v;
 
 namespace {
 
diff --git a/bind_lang/metaprogramming/reverse.h b/bind_lang/metaprogramming/reverse.h
index 98a8e0db..f9a24470 100644
--- a/bind_lang/metaprogramming/reverse.h
+++ b/bind_lang/metaprogramming/reverse.h
@@ -22,7 +22,7 @@
 #include "concatenate.h"
 #include "tuple_manipulation.h"
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 struct Reverse {
   template <typename... Ts>
@@ -48,6 +48,6 @@ using Reverse_t = typename Reverse::template type<Ts...>;
 template <typename Tup>
 using Reverse_Tup = TupleUnroller_t<Reverse, Tup>;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_REVERSE_H_
diff --git a/bind_lang/metaprogramming/reverse_test.cc b/bind_lang/metaprogramming/reverse_test.cc
index 3f9e9482..721d5a50 100644
--- a/bind_lang/metaprogramming/reverse_test.cc
+++ b/bind_lang/metaprogramming/reverse_test.cc
@@ -26,8 +26,8 @@ struct B {};
 struct C {};
 struct D {};
 
-using ::jni::metaprogramming::Reverse_t;
-using ::jni::metaprogramming::Reverse_Tup;
+using ::bind_lang::metaprogramming::Reverse_t;
+using ::bind_lang::metaprogramming::Reverse_Tup;
 
 static_assert(std::is_same_v<Reverse_t<>, std::tuple<>>);
 static_assert(std::is_same_v<Reverse_t<A>, std::tuple<A>>);
diff --git a/bind_lang/metaprogramming/same.h b/bind_lang/metaprogramming/same.h
index 6b6cf07a..16d5126e 100644
--- a/bind_lang/metaprogramming/same.h
+++ b/bind_lang/metaprogramming/same.h
@@ -20,7 +20,7 @@
 #include <tuple>
 #include <type_traits>
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 // Metafunction to take a sequence of values and emit std::true or std::false
 // per element based on their type equality.
@@ -34,6 +34,6 @@ struct Same {
   constexpr static bool value = type<Us...>::value;
 };
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_SAME_H_
diff --git a/bind_lang/metaprogramming/same_test.cc b/bind_lang/metaprogramming/same_test.cc
index 99d22592..d62b572d 100644
--- a/bind_lang/metaprogramming/same_test.cc
+++ b/bind_lang/metaprogramming/same_test.cc
@@ -20,7 +20,7 @@
 
 namespace {
 
-using ::jni::metaprogramming::Same;
+using ::bind_lang::metaprogramming::Same;
 
 static_assert(std::is_same_v<Same<int>::type<int>, std::true_type>);
 static_assert(std::is_same_v<Same<float>::type<float>, std::true_type>);
diff --git a/bind_lang/metaprogramming/singleton.h b/bind_lang/metaprogramming/singleton.h
index 990cd68f..aec6d5bc 100644
--- a/bind_lang/metaprogramming/singleton.h
+++ b/bind_lang/metaprogramming/singleton.h
@@ -17,13 +17,13 @@
 #ifndef JNI_BIND_BIND_LANG_METAPROGRAMMING_SINGLETON_H_
 #define JNI_BIND_BIND_LANG_METAPROGRAMMING_SINGLETON_H_
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 template <typename T>
 struct Singleton {
   inline static T val = {};
 };
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_SINGLETON_H_
diff --git a/bind_lang/metaprogramming/singleton_test.cc b/bind_lang/metaprogramming/singleton_test.cc
index 51c1ddbf..b954582b 100644
--- a/bind_lang/metaprogramming/singleton_test.cc
+++ b/bind_lang/metaprogramming/singleton_test.cc
@@ -4,7 +4,7 @@
 
 #include <gtest/gtest.h>
 
-using ::jni::metaprogramming::Singleton;
+using ::bind_lang::metaprogramming::Singleton;
 
 namespace {
 
diff --git a/bind_lang/metaprogramming/string_concatenate.h b/bind_lang/metaprogramming/string_concatenate.h
index b1135910..67c2365e 100644
--- a/bind_lang/metaprogramming/string_concatenate.h
+++ b/bind_lang/metaprogramming/string_concatenate.h
@@ -21,7 +21,7 @@
 #include <cstddef>
 #include <string_view>
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 struct StringConcatenate {
   template <std::string_view const&... Vs>
@@ -53,6 +53,6 @@ struct StringConcatenate {
 template <std::string_view const&... Vs>
 static constexpr auto StringConcatenate_v = StringConcatenate::value<Vs...>;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_STRING_CONCATENATE_H_
diff --git a/bind_lang/metaprogramming/string_concatenate_test.cc b/bind_lang/metaprogramming/string_concatenate_test.cc
index 0a7064ab..b71007f3 100644
--- a/bind_lang/metaprogramming/string_concatenate_test.cc
+++ b/bind_lang/metaprogramming/string_concatenate_test.cc
@@ -4,7 +4,7 @@
 
 namespace {
 
-using ::jni::metaprogramming::StringConcatenate_v;
+using ::bind_lang::metaprogramming::StringConcatenate_v;
 
 // Empty list string concatenation.
 static constexpr auto kVoidSetResultsInVoid = StringConcatenate_v<>;
diff --git a/bind_lang/metaprogramming/string_contains.h b/bind_lang/metaprogramming/string_contains.h
index b11963c3..6ec8c573 100644
--- a/bind_lang/metaprogramming/string_contains.h
+++ b/bind_lang/metaprogramming/string_contains.h
@@ -21,7 +21,7 @@
 #include <string_view>
 #include <utility>
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 template <char sought>
 struct StringContains {
@@ -42,6 +42,6 @@ template <const std::string_view& str, char sought>
 static constexpr bool StringContains_v =
     StringContains<sought>::template val<str>;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_STRING_CONTAINS_H_
diff --git a/bind_lang/metaprogramming/string_contains_test.cc b/bind_lang/metaprogramming/string_contains_test.cc
index d0e9db6e..1e41e0df 100644
--- a/bind_lang/metaprogramming/string_contains_test.cc
+++ b/bind_lang/metaprogramming/string_contains_test.cc
@@ -18,7 +18,7 @@
 
 #include <string_view>
 
-using ::jni::metaprogramming::StringContains_v;
+using ::bind_lang::metaprogramming::StringContains_v;
 
 namespace {
 
diff --git a/bind_lang/metaprogramming/string_literal.h b/bind_lang/metaprogramming/string_literal.h
index bbdd3034..d88ab925 100644
--- a/bind_lang/metaprogramming/string_literal.h
+++ b/bind_lang/metaprogramming/string_literal.h
@@ -24,7 +24,7 @@
 #include <cstddef>
 #include <string_view>
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 // Inspired by Kevin Hartman's StringLiteral implementation.
 // https://ctrpeach.io/posts/cpp20-string-literal-template-parameters/
@@ -58,7 +58,7 @@ struct StringLiteral {
 template <size_t N>
 StringLiteral(const char (&str)[N]) -> StringLiteral<N>;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // __cplusplus >= 202002L
 #endif  // __cplusplus
diff --git a/bind_lang/metaprogramming/string_literal_test.cc b/bind_lang/metaprogramming/string_literal_test.cc
index 485bfc70..4c66b2ec 100644
--- a/bind_lang/metaprogramming/string_literal_test.cc
+++ b/bind_lang/metaprogramming/string_literal_test.cc
@@ -18,7 +18,7 @@
 
 #include <cstddef>
 
-using jni::metaprogramming::StringLiteral;
+using bind_lang::metaprogramming::StringLiteral;
 
 namespace {
 
diff --git a/bind_lang/metaprogramming/tuple_from_size.h b/bind_lang/metaprogramming/tuple_from_size.h
index f6a052e1..6002f528 100644
--- a/bind_lang/metaprogramming/tuple_from_size.h
+++ b/bind_lang/metaprogramming/tuple_from_size.h
@@ -21,7 +21,7 @@
 #include <tuple>
 #include <utility>
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 template <class T, std::size_t>
 using T_ = T;
@@ -40,6 +40,6 @@ auto TupleFromSize() {
 template <class DefaultType, std::size_t N>
 using TupleFromSize_t = decltype(TupleFromSize<DefaultType, N>());
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_TUPLE_FROM_SIZE_H_
diff --git a/bind_lang/metaprogramming/tuple_from_size_test.cc b/bind_lang/metaprogramming/tuple_from_size_test.cc
index b221880f..46466155 100644
--- a/bind_lang/metaprogramming/tuple_from_size_test.cc
+++ b/bind_lang/metaprogramming/tuple_from_size_test.cc
@@ -23,7 +23,7 @@
 
 namespace {
 
-using ::jni::metaprogramming::TupleFromSize_t;
+using ::bind_lang::metaprogramming::TupleFromSize_t;
 
 struct A {};
 
diff --git a/bind_lang/metaprogramming/tuple_manipulation.h b/bind_lang/metaprogramming/tuple_manipulation.h
index 13614861..10e07c39 100644
--- a/bind_lang/metaprogramming/tuple_manipulation.h
+++ b/bind_lang/metaprogramming/tuple_manipulation.h
@@ -20,7 +20,7 @@
 #include <tuple>
 #include <type_traits>
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 // Helper struct for figuring out the contents of a tuple.  Use Unwrap if you
 // plan to use this as a metafunction (this breaks the paradigm as type is not
@@ -91,6 +91,6 @@ template <typename ContainerType>
 using ExtractTupleFromType_t =
     typename ExtractTupleFromType<ContainerType>::type;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_TUPLE_MANIPULATION_H_
diff --git a/bind_lang/metaprogramming/tuple_manipulation_test.cc b/bind_lang/metaprogramming/tuple_manipulation_test.cc
index 09d01f49..a8399998 100644
--- a/bind_lang/metaprogramming/tuple_manipulation_test.cc
+++ b/bind_lang/metaprogramming/tuple_manipulation_test.cc
@@ -21,8 +21,8 @@
 #include <type_traits>
 #include <utility>
 
-using ::jni::metaprogramming::ExtractTupleFromType_t;
-using ::jni::metaprogramming::TupleToType_t;
+using ::bind_lang::metaprogramming::ExtractTupleFromType_t;
+using ::bind_lang::metaprogramming::TupleToType_t;
 
 namespace {
 
diff --git a/bind_lang/metaprogramming/type_index_mask.h b/bind_lang/metaprogramming/type_index_mask.h
index 5a72a4b6..c6237ee7 100644
--- a/bind_lang/metaprogramming/type_index_mask.h
+++ b/bind_lang/metaprogramming/type_index_mask.h
@@ -23,7 +23,7 @@
 
 #include "type_of_nth_element.h"
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 // Metafunction to take a sequence of indices, and produce the corresponding
 // elements in sequences of tuples.
@@ -56,6 +56,6 @@ template <typename TupOfTypes, std::size_t... sizes>
 using TypeTupFromIndexMask_t =
     typename TypeIndexMask<sizes...>::template type<TupOfTypes>;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_TYPE_INDEX_MASK_H_
diff --git a/bind_lang/metaprogramming/type_index_mask_test.cc b/bind_lang/metaprogramming/type_index_mask_test.cc
index aab5b606..80530c76 100644
--- a/bind_lang/metaprogramming/type_index_mask_test.cc
+++ b/bind_lang/metaprogramming/type_index_mask_test.cc
@@ -21,7 +21,7 @@
 
 namespace {
 
-using ::jni::metaprogramming::TypeTupFromIndexMask_t;
+using ::bind_lang::metaprogramming::TypeTupFromIndexMask_t;
 
 struct A {};
 struct B {};
diff --git a/bind_lang/metaprogramming/type_of_nth_element.h b/bind_lang/metaprogramming/type_of_nth_element.h
index 7ae33e37..e7e93e36 100644
--- a/bind_lang/metaprogramming/type_of_nth_element.h
+++ b/bind_lang/metaprogramming/type_of_nth_element.h
@@ -21,7 +21,7 @@
 
 #include "unwrap.h"
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 template <std::size_t N>
 struct TypeOfNthElement {
@@ -48,6 +48,6 @@ using TypeOfNthElement_t = typename TypeOfNthElement<N>::template type<Ts...>;
 template <std::size_t N, typename TupType>
 using TypeOfNthTupleElement_t = Unwrap_t<TypeOfNthElement<N>, TupType>;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_TYPE_OF_NTH_ELEMENT_H_
diff --git a/bind_lang/metaprogramming/type_of_nth_element_test.cc b/bind_lang/metaprogramming/type_of_nth_element_test.cc
index d4d1acfe..7d33f6ee 100644
--- a/bind_lang/metaprogramming/type_of_nth_element_test.cc
+++ b/bind_lang/metaprogramming/type_of_nth_element_test.cc
@@ -19,8 +19,8 @@
 #include <tuple>
 #include <type_traits>
 
-using ::jni::metaprogramming::TypeOfNthElement_t;
-using ::jni::metaprogramming::TypeOfNthTupleElement_t;
+using ::bind_lang::metaprogramming::TypeOfNthElement_t;
+using ::bind_lang::metaprogramming::TypeOfNthTupleElement_t;
 
 namespace {
 
diff --git a/bind_lang/metaprogramming/type_to_type_map.h b/bind_lang/metaprogramming/type_to_type_map.h
index 259e2be9..ced1d391 100644
--- a/bind_lang/metaprogramming/type_to_type_map.h
+++ b/bind_lang/metaprogramming/type_to_type_map.h
@@ -25,7 +25,7 @@
 #include "tuple_manipulation.h"
 #include "type_of_nth_element.h"
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 // Maps types to other types.
 // Keys do not need to be unique, although queries only return the first entry.
@@ -75,6 +75,6 @@ template <typename TupleOfKeyValuePairs>
 using TypeToTypeMapFromKeyValuesTup_t =
     TupleToType_t<TupleOfKeyValuePairs, TypeToTypeMapFromKeyValues_t>;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_TYPE_TO_TYPE_MAP_H_
diff --git a/bind_lang/metaprogramming/type_to_type_map_test.cc b/bind_lang/metaprogramming/type_to_type_map_test.cc
index 973bfb27..718bd10d 100644
--- a/bind_lang/metaprogramming/type_to_type_map_test.cc
+++ b/bind_lang/metaprogramming/type_to_type_map_test.cc
@@ -28,11 +28,11 @@ struct D {};
 struct E {};
 struct F {};
 
-using ::jni::metaprogramming::TypeToTypeMap;
-using ::jni::metaprogramming::TypeToTypeMap_Keys_t;
-using ::jni::metaprogramming::TypeToTypeMap_Values_t;
-using ::jni::metaprogramming::TypeToTypeMapFromKeyValues_t;
-using ::jni::metaprogramming::TypeToTypeMapQuery_t;
+using ::bind_lang::metaprogramming::TypeToTypeMap;
+using ::bind_lang::metaprogramming::TypeToTypeMap_Keys_t;
+using ::bind_lang::metaprogramming::TypeToTypeMap_Values_t;
+using ::bind_lang::metaprogramming::TypeToTypeMapFromKeyValues_t;
+using ::bind_lang::metaprogramming::TypeToTypeMapQuery_t;
 
 // Keys and values are expected.
 using MapUnderTest = TypeToTypeMapFromKeyValues_t<A, B, C, D, E, F>;
diff --git a/bind_lang/metaprogramming/unfurl.h b/bind_lang/metaprogramming/unfurl.h
index 92f35d70..669a8476 100644
--- a/bind_lang/metaprogramming/unfurl.h
+++ b/bind_lang/metaprogramming/unfurl.h
@@ -21,7 +21,7 @@
 #include <tuple>
 #include <utility>
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 // "Unfurls" an index sequence onto a container, and provides convenience
 // helpers
@@ -71,6 +71,6 @@ template <std::size_t Is, template <std::size_t, typename...> class Container,
 static constexpr bool UnfurlDisjunction_v =
     Unfurl<Container, Is, false>::template val<Ts...>;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_UNFURL_H_
diff --git a/bind_lang/metaprogramming/unfurl_test.cc b/bind_lang/metaprogramming/unfurl_test.cc
index c90b3e84..2494a160 100644
--- a/bind_lang/metaprogramming/unfurl_test.cc
+++ b/bind_lang/metaprogramming/unfurl_test.cc
@@ -24,10 +24,10 @@
 
 namespace {
 
-using ::jni::metaprogramming::Contains_v;
-using ::jni::metaprogramming::Unfurl_t;
-using ::jni::metaprogramming::UnfurlConjunction_v;
-using ::jni::metaprogramming::UnfurlDisjunction_v;
+using ::bind_lang::metaprogramming::Contains_v;
+using ::bind_lang::metaprogramming::Unfurl_t;
+using ::bind_lang::metaprogramming::UnfurlConjunction_v;
+using ::bind_lang::metaprogramming::UnfurlDisjunction_v;
 
 struct A {};
 struct B {};
diff --git a/bind_lang/metaprogramming/unique_set.h b/bind_lang/metaprogramming/unique_set.h
index ba89be2a..eb60e1d3 100644
--- a/bind_lang/metaprogramming/unique_set.h
+++ b/bind_lang/metaprogramming/unique_set.h
@@ -25,7 +25,7 @@
 #include "reverse.h"
 #include "tuple_manipulation.h"
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 // Builds a stable (i.e. first unique type is preserved) set of unique types
 // from a set.
@@ -64,6 +64,6 @@ using UniqueSet_t = typename UniqueSet::template type<Ts...>;
 template <typename Tup>
 using UniqueSet_Tup = TupleUnroller_t<UniqueSet, Tup>;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_UNIQUE_SET_H_
diff --git a/bind_lang/metaprogramming/unique_set_test.cc b/bind_lang/metaprogramming/unique_set_test.cc
index 06b0de39..84ab88f5 100644
--- a/bind_lang/metaprogramming/unique_set_test.cc
+++ b/bind_lang/metaprogramming/unique_set_test.cc
@@ -21,7 +21,7 @@
 
 namespace {
 
-using ::jni::metaprogramming::UniqueSet_t;
+using ::bind_lang::metaprogramming::UniqueSet_t;
 
 struct A {};
 struct B {};
diff --git a/bind_lang/metaprogramming/unwrap.h b/bind_lang/metaprogramming/unwrap.h
index 88bd8235..b191152c 100644
--- a/bind_lang/metaprogramming/unwrap.h
+++ b/bind_lang/metaprogramming/unwrap.h
@@ -19,7 +19,7 @@
 
 #include "tuple_manipulation.h"
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 // Metafunction to forward all args in a tuple on to a metafunction.
 // It's useful if you want to "derefence" arguments from another meta function.
@@ -35,6 +35,6 @@ using Unwrap_t = typename Unwrap<Func>::template type<Ts...>;
 template <typename Func, typename... Ts>
 static constexpr auto Unwrap_v = Unwrap_t<Func, Ts...>::value;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_UNWRAP_H_
diff --git a/bind_lang/metaprogramming/unwrap_test.cc b/bind_lang/metaprogramming/unwrap_test.cc
index f0315c04..b16e89be 100644
--- a/bind_lang/metaprogramming/unwrap_test.cc
+++ b/bind_lang/metaprogramming/unwrap_test.cc
@@ -21,8 +21,8 @@
 
 #include "same.h"
 
-using ::jni::metaprogramming::Same;
-using ::jni::metaprogramming::Unwrap_t;
+using ::bind_lang::metaprogramming::Same;
+using ::bind_lang::metaprogramming::Unwrap_t;
 
 namespace {
 
diff --git a/bind_lang/metaprogramming/vals.h b/bind_lang/metaprogramming/vals.h
index 3b90788f..516a27e5 100644
--- a/bind_lang/metaprogramming/vals.h
+++ b/bind_lang/metaprogramming/vals.h
@@ -19,7 +19,7 @@
 
 #include <array>
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 // Wrapper to convert a sequence of values into a type.
 template <const auto val_>
@@ -55,6 +55,6 @@ struct ValsConstRef {
   static constexpr std::array val{Vs...};
 };
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_VALS_H_
diff --git a/bind_lang/metaprogramming/vals_equal.h b/bind_lang/metaprogramming/vals_equal.h
index baf91516..662e069b 100644
--- a/bind_lang/metaprogramming/vals_equal.h
+++ b/bind_lang/metaprogramming/vals_equal.h
@@ -21,7 +21,7 @@
 
 #include "bind_lang/metaprogramming/vals.h"
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 // Performs a deep equality comparison of T, but is leniant about containers.
 // Returns true iff types are equal or both types are containers and their
@@ -84,6 +84,6 @@ template <const auto& V1, const auto& V2>
 static constexpr bool ValsEqual_cr_v =
     ValsEqual<ValsConstRef<V1>>::template val<ValsConstRef<V2>>;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_VALS_EQUAL_H_
diff --git a/bind_lang/metaprogramming/vals_equal_diminished.h b/bind_lang/metaprogramming/vals_equal_diminished.h
index be5d6096..736d7723 100644
--- a/bind_lang/metaprogramming/vals_equal_diminished.h
+++ b/bind_lang/metaprogramming/vals_equal_diminished.h
@@ -19,7 +19,7 @@
 
 #include "bind_lang/metaprogramming/vals.h"
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 // This class is a diminished form of `ValsEqual` that treats everything as an
 //  auto const&. Unfortunately, MSVC appears to have a bug that makes compiling
@@ -57,6 +57,6 @@ template <const auto& V1, const auto& V2>
 static constexpr bool ValsEqualDiminished_cr_v =
     ValsEqualDiminished<ValsConstRef<V1>>::template val<ValsConstRef<V2>>;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_VALS_EQUAL_DIMINISHED_H_
diff --git a/bind_lang/metaprogramming/vals_equal_diminished_test.cc b/bind_lang/metaprogramming/vals_equal_diminished_test.cc
index 81592d9a..c0e74cb8 100644
--- a/bind_lang/metaprogramming/vals_equal_diminished_test.cc
+++ b/bind_lang/metaprogramming/vals_equal_diminished_test.cc
@@ -25,11 +25,11 @@ namespace {
 // Unsupported assertions are intentionally left commented for comparison.
 ////////////////////////////////////////////////////////////////////////////////
 
-using ::jni::metaprogramming::Vals;
-using ::jni::metaprogramming::ValsConst;
-using ::jni::metaprogramming::ValsConstRef;
-using ::jni::metaprogramming::ValsEqualDiminished_v;
-using ::jni::metaprogramming::ValsRef;
+using ::bind_lang::metaprogramming::Vals;
+using ::bind_lang::metaprogramming::ValsConst;
+using ::bind_lang::metaprogramming::ValsConstRef;
+using ::bind_lang::metaprogramming::ValsEqualDiminished_v;
+using ::bind_lang::metaprogramming::ValsRef;
 
 template <const auto... Vs>
 struct A {};
diff --git a/bind_lang/metaprogramming/vals_equal_test.cc b/bind_lang/metaprogramming/vals_equal_test.cc
index 7cb65520..64a16620 100644
--- a/bind_lang/metaprogramming/vals_equal_test.cc
+++ b/bind_lang/metaprogramming/vals_equal_test.cc
@@ -20,11 +20,11 @@
 
 namespace {
 
-using ::jni::metaprogramming::Vals;
-using ::jni::metaprogramming::ValsConst;
-using ::jni::metaprogramming::ValsConstRef;
-using ::jni::metaprogramming::ValsEqual_v;
-using ::jni::metaprogramming::ValsRef;
+using ::bind_lang::metaprogramming::Vals;
+using ::bind_lang::metaprogramming::ValsConst;
+using ::bind_lang::metaprogramming::ValsConstRef;
+using ::bind_lang::metaprogramming::ValsEqual_v;
+using ::bind_lang::metaprogramming::ValsRef;
 
 template <const auto... Vs>
 struct A {};
diff --git a/bind_lang/metaprogramming/zip_invoke.h b/bind_lang/metaprogramming/zip_invoke.h
index 827c22cf..19f02304 100644
--- a/bind_lang/metaprogramming/zip_invoke.h
+++ b/bind_lang/metaprogramming/zip_invoke.h
@@ -23,7 +23,7 @@
 #include "apply.h"
 #include "invoke.h"
 
-namespace jni::metaprogramming {
+namespace bind_lang::metaprogramming {
 
 // Takes a set of 2 tuples, |Knobs| and |Args|.
 // This is frequently useful in a case where you might want to Apply across a
@@ -43,6 +43,6 @@ struct ZipInvoke<
 template <template <typename...> class Func, typename Knobs, typename Args>
 using ZipInvoke_t = typename ZipInvoke<Func, Knobs, Args>::type;
 
-}  // namespace jni::metaprogramming
+}  // namespace bind_lang::metaprogramming
 
 #endif  // JNI_BIND_BIND_LANG_METAPROGRAMMING_ZIP_INVOKE_H_
diff --git a/bind_lang/metaprogramming/zip_invoke_test.cc b/bind_lang/metaprogramming/zip_invoke_test.cc
index 071100ca..93ef4680 100644
--- a/bind_lang/metaprogramming/zip_invoke_test.cc
+++ b/bind_lang/metaprogramming/zip_invoke_test.cc
@@ -24,9 +24,9 @@
 
 namespace {
 
-using ::jni::metaprogramming::All_v;
-using ::jni::metaprogramming::Same;
-using ::jni::metaprogramming::ZipInvoke_t;
+using ::bind_lang::metaprogramming::All_v;
+using ::bind_lang::metaprogramming::Same;
+using ::bind_lang::metaprogramming::ZipInvoke_t;
 
 struct A {};
 struct B : A {};
diff --git a/implementation/array_type_conversion.h b/implementation/array_type_conversion.h
index be31977d..ff950aa6 100644
--- a/implementation/array_type_conversion.h
+++ b/implementation/array_type_conversion.h
@@ -51,7 +51,7 @@ using PrimitiveKeys =
 // Simple type for proxying types used in the API (e.g. jint) to their
 // corresponding array type (e.g. jintarray). Only use the former type when
 // using JNI Bind (e.g. LocalArray<jint>, not LocalArray<jintArray>).
-using RegularToArrayTypeMap = metaprogramming::TypeToTypeMap<
+using RegularToArrayTypeMap = bind_lang::metaprogramming::TypeToTypeMap<
     std::tuple<jbyte, jchar, jshort, jint, jlong, jfloat, jdouble, jboolean,
                jobject, jstring, jarray>,
     std::tuple<jbyteArray, jcharArray, jshortArray, jintArray, jlongArray,
@@ -61,12 +61,12 @@ using RegularToArrayTypeMap = metaprogramming::TypeToTypeMap<
 // Given a type, returns the corresponding array type (e.g. jint => jintArray).
 template <typename T>
 using RegularToArrayTypeMap_t =
-    metaprogramming::TypeToTypeMapQuery_t<RegularToArrayTypeMap, T>;
+    bind_lang::metaprogramming::TypeToTypeMapQuery_t<RegularToArrayTypeMap, T>;
 
 // Array to CDecl type used for invocation.
 // Defined separately since this map is not invertible (jobject, jstring =>
 // jobject).
-using ArrayToRegularTypeMap = metaprogramming::TypeToTypeMap<
+using ArrayToRegularTypeMap = bind_lang::metaprogramming::TypeToTypeMap<
     std::tuple<jbyteArray, jcharArray, jshortArray, jintArray, jlongArray,
                jfloatArray, jdoubleArray, jbooleanArray, jobjectArray, jarray>,
     std::tuple<jbyte, jchar, jshort, jint, jlong, jfloat, jdouble, jboolean,
@@ -74,7 +74,7 @@ using ArrayToRegularTypeMap = metaprogramming::TypeToTypeMap<
 
 template <typename T>
 using ArrayToRegularTypeMap_t =
-    metaprogramming::TypeToTypeMapQuery_t<ArrayToRegularTypeMap, T>;
+    bind_lang::metaprogramming::TypeToTypeMapQuery_t<ArrayToRegularTypeMap, T>;
 
 ////////////////////////////////////////////////////////////////////////////////
 // Storage Helper Metafunction.
diff --git a/implementation/class.h b/implementation/class.h
index 119e3158..27b5bd26 100644
--- a/implementation/class.h
+++ b/implementation/class.h
@@ -50,7 +50,8 @@ struct Class<Extends_, std::tuple<Constructors_...>,
              std::tuple<Methods_...>, std::tuple<Fields_...>> : public Object {
  public:
   // Filtering outputs a std::tuple<T>, the caller will use just T in ctor.
-  using ExtendsArgT = metaprogramming::TypeOfNthTupleElement_t<0, Extends_>;
+  using ExtendsArgT =
+      bind_lang::metaprogramming::TypeOfNthTupleElement_t<0, Extends_>;
 
   // The type of the parent class (default `RootObject`).
   const ExtendsStrip_t<Extends_> parent_;
@@ -208,14 +209,14 @@ constexpr bool operator!=(const Class<Ts...>& lhs, const NoClass&) {
 ////////////////////////////////////////////////////////////////////////////////
 template <typename... Params>
 Class(const char*, Params...)
-    -> Class<metaprogramming::BaseFilterWithDefault_t<
+    -> Class<bind_lang::metaprogramming::BaseFilterWithDefault_t<
                  ExtendsBase, Extends<RootObject>, Params...>,
-             metaprogramming::BaseFilterWithDefault_t<ConstructorBase,
-                                                      Constructor<>, Params...>,
-             metaprogramming::BaseFilterWithDefault_t<
+             bind_lang::metaprogramming::BaseFilterWithDefault_t<
+                 ConstructorBase, Constructor<>, Params...>,
+             bind_lang::metaprogramming::BaseFilterWithDefault_t<
                  StaticBase, Static<std::tuple<>, std::tuple<>>, Params...>,
-             metaprogramming::BaseFilter_t<MethodBase, Params...>,
-             metaprogramming::BaseFilter_t<FieldBase, Params...>>;
+             bind_lang::metaprogramming::BaseFilter_t<MethodBase, Params...>,
+             bind_lang::metaprogramming::BaseFilter_t<FieldBase, Params...>>;
 
 Class(const char*)
     -> Class<std::tuple<Extends<RootObject>>, std::tuple<Constructor<>>,
diff --git a/implementation/class_loader.h b/implementation/class_loader.h
index ae3f6c75..56e4dd3a 100644
--- a/implementation/class_loader.h
+++ b/implementation/class_loader.h
@@ -74,11 +74,11 @@ class ClassLoader : public Object {
       std::integer_sequence<std::size_t, Is...>) const {
     // std::max appears to be missing the initializer list overload in Bazel's
     // implementation of clang.  This should simply be std::max.
-    return metaprogramming::ModifiedMax(
+    return bind_lang::metaprogramming::ModifiedMax(
         {((std::get<Is>(supported_classes_) == class_v)
               ? std::size_t{Is}
-              : metaprogramming::kNegativeOne)...,
-         metaprogramming::kNegativeOne});
+              : bind_lang::metaprogramming::kNegativeOne)...,
+         bind_lang::metaprogramming::kNegativeOne});
   }
 
   // Returns the index for a given class within this set (any given class ref is
diff --git a/implementation/class_ref.h b/implementation/class_ref.h
index dfef8542..a11ca5c1 100644
--- a/implementation/class_ref.h
+++ b/implementation/class_ref.h
@@ -63,7 +63,7 @@ class ClassRef {
     // For the default classloader, storage in uniquely IDed struct static.
     if constexpr (JniT::GetClassLoader() == kDefaultClassLoader) {
       static auto get_lambda =
-          [](metaprogramming::DoubleLockedValue<jclass>* storage) {
+          [](bind_lang::metaprogramming::DoubleLockedValue<jclass>* storage) {
             if (kConfiguration.release_class_ids_on_teardown_) {
               DefaultRefs<jclass>().push_back(storage);
             }
@@ -120,7 +120,8 @@ class ClassRef {
   // A global reference to a jclass object that is returned from FindClass.
   // The variable has static storage because ClassIDs are static to the lifetime
   // of a JVM.  See GetAndMaybeLoadClassRef and MaybeReleaseClassRef.
-  static inline metaprogramming::DoubleLockedValue<jclass> class_ref_;
+  static inline bind_lang::metaprogramming::DoubleLockedValue<jclass>
+      class_ref_;
 };
 
 // When we get an object_ref_ as a return value from a Java method, it may be
diff --git a/implementation/default_class_loader.h b/implementation/default_class_loader.h
index 3c8eece2..116c0af6 100644
--- a/implementation/default_class_loader.h
+++ b/implementation/default_class_loader.h
@@ -29,7 +29,7 @@ namespace jni {
 
 static constexpr std::size_t kDefaultClassLoaderIdx = 0;
 static constexpr std::size_t kClassNotInLoaderSetIdx =
-    metaprogramming::kNegativeOne;
+    bind_lang::metaprogramming::kNegativeOne;
 
 // Class loader that can supply any class (to be used when none is specified).
 // Setting this as the root loader for user defined classes will disable checks
diff --git a/implementation/extends.h b/implementation/extends.h
index b03cb5c9..8f046dc1 100644
--- a/implementation/extends.h
+++ b/implementation/extends.h
@@ -30,13 +30,15 @@ struct ExtendsStrip {
   template <typename T>
   struct Helper {
     // Input is in a tuple of 1 element.
-    using StripOuterTuple = metaprogramming::TypeOfNthTupleElement_t<0, T>;
+    using StripOuterTuple =
+        bind_lang::metaprogramming::TypeOfNthTupleElement_t<0, T>;
     // Steal the outer Extends parameter pack into a tuple.
     // e.g. Extends<RootClass> => std::tuple<RootClass>.
     using ExtendsToTuple =
-        metaprogramming::ExtractTupleFromType_t<StripOuterTuple>;
+        bind_lang::metaprogramming::ExtractTupleFromType_t<StripOuterTuple>;
     // Extracts the single element.
-    using type = metaprogramming::TypeOfNthTupleElement_t<0, ExtendsToTuple>;
+    using type =
+        bind_lang::metaprogramming::TypeOfNthTupleElement_t<0, ExtendsToTuple>;
   };
 
   template <typename T>
diff --git a/implementation/field_ref.h b/implementation/field_ref.h
index c5a2f168..964d486c 100644
--- a/implementation/field_ref.h
+++ b/implementation/field_ref.h
@@ -44,8 +44,8 @@ namespace jni {
 
 // See JvmRef::~JvmRef.
 static inline auto& GetDefaultLoadedFieldList() {
-  static auto* ret_val =
-      new std::vector<metaprogramming::DoubleLockedValue<jfieldID>*>{};
+  static auto* ret_val = new std::vector<
+      bind_lang::metaprogramming::DoubleLockedValue<jfieldID>*>{};
   return *ret_val;
 }
 
@@ -70,7 +70,7 @@ class FieldRef {
 
   // This method is thread safe.
   static jfieldID GetFieldID(jclass clazz) {
-    static jni::metaprogramming::DoubleLockedValue<jfieldID> return_value;
+    static bind_lang::metaprogramming::DoubleLockedValue<jfieldID> return_value;
 
     return return_value.LoadAndMaybeInit([=]() {
       if constexpr (JniT::class_loader_v == kDefaultClassLoader) {
diff --git a/implementation/global_object.h b/implementation/global_object.h
index 01e37a4b..cad165c5 100644
--- a/implementation/global_object.h
+++ b/implementation/global_object.h
@@ -66,7 +66,7 @@ class GlobalObject
 
   template <const auto& class_v, const auto& class_loader_v, const auto& jvm_v>
   GlobalObject& operator=(LocalObject<class_v, class_loader_v, jvm_v>&& rhs) {
-    static_assert(::jni::metaprogramming::DeepEqualDiminished_v<
+    static_assert(::bind_lang::metaprogramming::DeepEqualDiminished_v<
                   LocalObject<class_v_, class_loader_v_, jvm_v_>,
                   LocalObject<class_v, class_loader_v, jvm_v>>);
     Base::MaybeReleaseUnderlyingObject();
diff --git a/implementation/id.h b/implementation/id.h
index 996b5ddc..dc03ef92 100644
--- a/implementation/id.h
+++ b/implementation/id.h
@@ -218,7 +218,7 @@ struct Id {
   }
   static constexpr std::string_view kName = Name();
   static constexpr std::string_view kNameUsingDots =
-      metaprogramming::Replace_v<kName, '/', '.'>;
+      bind_lang::metaprogramming::Replace_v<kName, '/', '.'>;
 
   static constexpr std::size_t NumParams() {
     if constexpr (kIdType == IdType::OVERLOAD ||
diff --git a/implementation/jni_helper/field_value.h b/implementation/jni_helper/field_value.h
index c6538bc2..22e17360 100644
--- a/implementation/jni_helper/field_value.h
+++ b/implementation/jni_helper/field_value.h
@@ -42,8 +42,8 @@ template <>
 struct FieldHelper<jboolean, 0, false, void> {
   static inline jboolean GetValue(const jobject object_ref,
                                   const jfieldID field_ref_) {
-    Trace(metaprogramming::LambdaToStr(STR("GetBooleanValue")), object_ref,
-          field_ref_);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("GetBooleanValue")),
+          object_ref, field_ref_);
 
 #ifdef DRY_RUN
     return Fake<jboolean>();
@@ -54,8 +54,8 @@ struct FieldHelper<jboolean, 0, false, void> {
 
   static inline void SetValue(const jobject object_ref,
                               const jfieldID field_ref_, jboolean&& value) {
-    Trace(metaprogramming::LambdaToStr(STR("GetBooleanValue")), object_ref,
-          field_ref_);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("GetBooleanValue")),
+          object_ref, field_ref_);
 
 #ifdef DRY_RUN
 #else
@@ -68,8 +68,8 @@ template <>
 struct FieldHelper<jbyte, 0, false, void> {
   static inline jbyte GetValue(const jobject object_ref,
                                const jfieldID field_ref_) {
-    Trace(metaprogramming::LambdaToStr(STR("GetByteValue")), object_ref,
-          field_ref_);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("GetByteValue")),
+          object_ref, field_ref_);
 
 #ifdef DRY_RUN
     return Fake<jbyte>();
@@ -80,8 +80,8 @@ struct FieldHelper<jbyte, 0, false, void> {
 
   static inline void SetValue(const jobject object_ref,
                               const jfieldID field_ref_, jbyte&& value) {
-    Trace(metaprogramming::LambdaToStr(STR("SetByteValue")), object_ref,
-          field_ref_);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("SetByteValue")),
+          object_ref, field_ref_);
 
 #ifdef DRY_RUN
 #else
@@ -94,8 +94,8 @@ template <>
 struct FieldHelper<jchar, 0, false, void> {
   static inline jchar GetValue(const jobject object_ref,
                                const jfieldID field_ref_) {
-    Trace(metaprogramming::LambdaToStr(STR("GetCharValue")), object_ref,
-          field_ref_);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("GetCharValue")),
+          object_ref, field_ref_);
 
 #ifdef DRY_RUN
     return Fake<jchar>();
@@ -106,8 +106,8 @@ struct FieldHelper<jchar, 0, false, void> {
 
   static inline void SetValue(const jobject object_ref,
                               const jfieldID field_ref_, jchar&& value) {
-    Trace(metaprogramming::LambdaToStr(STR("SetCharValue")), object_ref,
-          field_ref_);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("SetCharValue")),
+          object_ref, field_ref_);
 
 #ifdef DRY_RUN
 #else
@@ -120,8 +120,8 @@ template <>
 struct FieldHelper<jshort, 0, false, void> {
   static inline jshort GetValue(const jobject object_ref,
                                 const jfieldID field_ref_) {
-    Trace(metaprogramming::LambdaToStr(STR("GetShortValue")), object_ref,
-          field_ref_);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("GetShortValue")),
+          object_ref, field_ref_);
 
 #ifdef DRY_RUN
     return Fake<jshort>();
@@ -132,8 +132,8 @@ struct FieldHelper<jshort, 0, false, void> {
 
   static inline void SetValue(const jobject object_ref,
                               const jfieldID field_ref_, jshort&& value) {
-    Trace(metaprogramming::LambdaToStr(STR("SetShortValue")), object_ref,
-          field_ref_);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("SetShortValue")),
+          object_ref, field_ref_);
 
 #ifdef DRY_RUN
 #else
@@ -146,8 +146,8 @@ template <>
 struct FieldHelper<jint, 0, false, void> {
   static inline jint GetValue(const jobject object_ref,
                               const jfieldID field_ref_) {
-    Trace(metaprogramming::LambdaToStr(STR("GetIntValue")), object_ref,
-          field_ref_);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("GetIntValue")),
+          object_ref, field_ref_);
 
 #ifdef DRY_RUN
     return Fake<jint>();
@@ -158,8 +158,8 @@ struct FieldHelper<jint, 0, false, void> {
 
   static inline void SetValue(const jobject object_ref,
                               const jfieldID field_ref_, jint&& value) {
-    Trace(metaprogramming::LambdaToStr(STR("SetIntValue")), object_ref,
-          field_ref_);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("SetIntValue")),
+          object_ref, field_ref_);
 
 #ifdef DRY_RUN
 #else
@@ -172,8 +172,8 @@ template <>
 struct FieldHelper<jlong, 0, false, void> {
   static inline jlong GetValue(const jobject object_ref,
                                const jfieldID field_ref_) {
-    Trace(metaprogramming::LambdaToStr(STR("GetLongField")), object_ref,
-          field_ref_);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("GetLongField")),
+          object_ref, field_ref_);
 
 #ifdef DRY_RUN
     return Fake<jlong>();
@@ -184,8 +184,8 @@ struct FieldHelper<jlong, 0, false, void> {
 
   static inline void SetValue(const jobject object_ref,
                               const jfieldID field_ref_, jlong&& value) {
-    Trace(metaprogramming::LambdaToStr(STR("SetLongField")), object_ref,
-          field_ref_);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("SetLongField")),
+          object_ref, field_ref_);
 
 #ifdef DRY_RUN
 #else
@@ -198,8 +198,8 @@ template <>
 struct FieldHelper<jfloat, 0, false, void> {
   static inline jfloat GetValue(const jobject object_ref,
                                 const jfieldID field_ref_) {
-    Trace(metaprogramming::LambdaToStr(STR("GetFloatField")), object_ref,
-          field_ref_);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("GetFloatField")),
+          object_ref, field_ref_);
 
 #ifdef DRY_RUN
     return 123.f;
@@ -210,8 +210,8 @@ struct FieldHelper<jfloat, 0, false, void> {
 
   static inline void SetValue(const jobject object_ref,
                               const jfieldID field_ref_, jfloat&& value) {
-    Trace(metaprogramming::LambdaToStr(STR("SetFloatField")), object_ref,
-          field_ref_);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("SetFloatField")),
+          object_ref, field_ref_);
 
 #ifdef DRY_RUN
 #else
@@ -224,8 +224,8 @@ template <>
 struct FieldHelper<jdouble, 0, false, void> {
   static inline jdouble GetValue(const jobject object_ref,
                                  const jfieldID field_ref_) {
-    Trace(metaprogramming::LambdaToStr(STR("GetDoubleField")), object_ref,
-          field_ref_);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("GetDoubleField")),
+          object_ref, field_ref_);
 
 #ifdef DRY_RUN
     return 123.;
@@ -236,8 +236,8 @@ struct FieldHelper<jdouble, 0, false, void> {
 
   static inline void SetValue(const jobject object_ref,
                               const jfieldID field_ref_, jdouble&& value) {
-    Trace(metaprogramming::LambdaToStr(STR("SetDoubleField")), object_ref,
-          field_ref_);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("SetDoubleField")),
+          object_ref, field_ref_);
 
 #ifdef DRY_RUN
 #else
@@ -250,8 +250,8 @@ template <>
 struct FieldHelper<jobject, 0, false, void> {
   static inline jobject GetValue(const jobject object_ref,
                                  const jfieldID field_ref_) {
-    Trace(metaprogramming::LambdaToStr(STR("GetObjectField")), object_ref,
-          field_ref_);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("GetObjectField")),
+          object_ref, field_ref_);
 
 #ifdef DRY_RUN
     return Fake<jobject>();
@@ -262,8 +262,8 @@ struct FieldHelper<jobject, 0, false, void> {
 
   static inline void SetValue(const jobject object_ref,
                               const jfieldID field_ref_, jobject&& new_value) {
-    Trace(metaprogramming::LambdaToStr(STR("SetObjectField")), object_ref,
-          field_ref_);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("SetObjectField")),
+          object_ref, field_ref_);
 
 #ifdef DRY_RUN
 #else
@@ -276,8 +276,8 @@ template <>
 struct FieldHelper<jstring, 0, false, void> {
   static inline jstring GetValue(const jobject object_ref,
                                  const jfieldID field_ref_) {
-    Trace(metaprogramming::LambdaToStr(STR("GetObjectField")), object_ref,
-          field_ref_);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("GetObjectField")),
+          object_ref, field_ref_);
 
 #ifdef DRY_RUN
     return Fake<jstring>();
@@ -289,8 +289,8 @@ struct FieldHelper<jstring, 0, false, void> {
 
   static inline void SetValue(const jobject object_ref,
                               const jfieldID field_ref_, jstring&& new_value) {
-    Trace(metaprogramming::LambdaToStr(STR("SetObjectField")), object_ref,
-          field_ref_);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("SetObjectField")),
+          object_ref, field_ref_);
 
 #ifdef DRY_RUN
 #else
@@ -306,8 +306,9 @@ template <typename ArrayType>
 struct BaseFieldArrayHelper {
   static inline ArrayType GetValue(const jobject object_ref,
                                    const jfieldID field_ref_) {
-    Trace(metaprogramming::LambdaToStr(STR("GetObjectField, Rank 1")),
-          object_ref, field_ref_);
+    Trace(
+        bind_lang::metaprogramming::LambdaToStr(STR("GetObjectField, Rank 1")),
+        object_ref, field_ref_);
 
 #ifdef DRY_RUN
     return Fake<ArrayType>();
@@ -319,8 +320,8 @@ struct BaseFieldArrayHelper {
 
   static inline void SetValue(const jobject object_ref,
                               const jfieldID field_ref_, ArrayType&& value) {
-    Trace(metaprogramming::LambdaToStr(STR("SetObjectField")), object_ref,
-          field_ref_);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("SetObjectField")),
+          object_ref, field_ref_);
 
 #ifdef DRY_RUN
 #else
@@ -372,8 +373,9 @@ struct FieldHelper<
                       std::is_same_v<jstring, T> || (kRank > 1))> > {
   static inline jobjectArray GetValue(const jobject object_ref,
                                       const jfieldID field_ref_) {
-    Trace(metaprogramming::LambdaToStr(STR("GetObjectField, Rank >1")),
-          object_ref, field_ref_);
+    Trace(
+        bind_lang::metaprogramming::LambdaToStr(STR("GetObjectField, Rank >1")),
+        object_ref, field_ref_);
 
 #ifdef DRY_RUN
     return Fake<jobjectArray>();
@@ -385,8 +387,9 @@ struct FieldHelper<
 
   static inline void SetValue(const jobject object_ref,
                               const jfieldID field_ref_, jobjectArray&& value) {
-    Trace(metaprogramming::LambdaToStr(STR("SetObjectField, Rank >1")),
-          object_ref, field_ref_);
+    Trace(
+        bind_lang::metaprogramming::LambdaToStr(STR("SetObjectField, Rank >1")),
+        object_ref, field_ref_);
 
 #ifdef DRY_RUN
 #else
diff --git a/implementation/jni_helper/invoke.h b/implementation/jni_helper/invoke.h
index afcb2320..dbcc33a6 100644
--- a/implementation/jni_helper/invoke.h
+++ b/implementation/jni_helper/invoke.h
@@ -42,8 +42,8 @@ struct InvokeHelper<void, 0, false> {
                      Ts&&... ts) {
 #ifdef DRY_RUN
 #else
-    Trace(metaprogramming::LambdaToStr(STR("CallVoidMethod")), object, clazz,
-          method_id, ts...);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("CallVoidMethod")),
+          object, clazz, method_id, ts...);
 
     jni::JniEnv::GetEnv()->CallVoidMethod(object, method_id,
                                           std::forward<Ts>(ts)...);
@@ -62,8 +62,8 @@ struct InvokeHelper<jboolean, 0, false> {
 #ifdef DRY_RUN
     return Fake<jboolean>();
 #else
-    Trace(metaprogramming::LambdaToStr(STR("CallBooleanMethod")), object, clazz,
-          method_id, ts...);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("CallBooleanMethod")),
+          object, clazz, method_id, ts...);
 
     return jni::JniEnv::GetEnv()->CallBooleanMethod(object, method_id,
                                                     std::forward<Ts>(ts)...);
@@ -76,8 +76,8 @@ struct InvokeHelper<jint, 0, false> {
   template <typename... Ts>
   static jint Invoke(jobject object, jclass clazz, jmethodID method_id,
                      Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(STR("CallIntMethod")), object, clazz,
-          method_id, ts...);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("CallIntMethod")), object,
+          clazz, method_id, ts...);
 
 #ifdef DRY_RUN
     return Fake<jint>();
@@ -93,8 +93,8 @@ struct InvokeHelper<jlong, 0, false> {
   template <typename... Ts>
   static jlong Invoke(jobject object, jclass clazz, jmethodID method_id,
                       Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(STR("CallLongMethod")), object, clazz,
-          method_id, ts...);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("CallLongMethod")),
+          object, clazz, method_id, ts...);
 
 #ifdef DRY_RUN
     return Fake<jlong>();
@@ -110,8 +110,8 @@ struct InvokeHelper<jfloat, 0, false> {
   template <typename... Ts>
   static jfloat Invoke(jobject object, jclass clazz, jmethodID method_id,
                        Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(STR("CallFloatMethod")), object, clazz,
-          method_id, ts...);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("CallFloatMethod")),
+          object, clazz, method_id, ts...);
 
 #ifdef DRY_RUN
     //    return Fake<jfloat>();
@@ -128,8 +128,8 @@ struct InvokeHelper<jdouble, 0, false> {
   template <typename... Ts>
   static jdouble Invoke(jobject object, jclass clazz, jmethodID method_id,
                         Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(STR("CallDoubleMethod")), object, clazz,
-          method_id, ts...);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("CallDoubleMethod")),
+          object, clazz, method_id, ts...);
 
 #ifdef DRY_RUN
     // return Fake<jdouble>();
@@ -148,8 +148,8 @@ struct InvokeHelper<jobject, 0, false> {
   template <typename... Ts>
   static jobject Invoke(jobject object, jclass clazz, jmethodID method_id,
                         Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(STR("CallObjectMethod")), object, clazz,
-          method_id, ts...);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("CallObjectMethod")),
+          object, clazz, method_id, ts...);
 
 #ifdef DRY_RUN
     return Fake<jobject>();
@@ -165,8 +165,8 @@ struct InvokeHelper<jstring, 0, false> {
   template <typename... Ts>
   static jobject Invoke(jobject object, jclass clazz, jmethodID method_id,
                         Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(STR("CallObjectMethod")), object, clazz,
-          method_id, ts...);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("CallObjectMethod")),
+          object, clazz, method_id, ts...);
 
 #ifdef DRY_RUN
     return Fake<jstring>();
@@ -185,7 +185,7 @@ struct InvokeHelper<std::enable_if_t<(kRank == 1), jboolean>, kRank, false> {
   template <typename... Ts>
   static jbooleanArray Invoke(jobject object, jclass clazz, jmethodID method_id,
                               Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(
+    Trace(bind_lang::metaprogramming::LambdaToStr(
               STR("CallObjectMethod (jbooleanArray), Rank 1")),
           object, clazz, method_id, ts...);
 
@@ -203,7 +203,7 @@ struct InvokeHelper<std::enable_if_t<(kRank == 1), jbyte>, kRank, false> {
   template <typename... Ts>
   static jbyteArray Invoke(jobject object, jclass clazz, jmethodID method_id,
                            Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(
+    Trace(bind_lang::metaprogramming::LambdaToStr(
               STR("CallObjectMethod (jbyteArray), Rank 1")),
           object, clazz, method_id, ts...);
 
@@ -221,7 +221,7 @@ struct InvokeHelper<std::enable_if_t<(kRank == 1), jchar>, kRank, false> {
   template <typename... Ts>
   static jcharArray Invoke(jobject object, jclass clazz, jmethodID method_id,
                            Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(
+    Trace(bind_lang::metaprogramming::LambdaToStr(
               STR("CallObjectMethod (jcharArray), Rank 1")),
           object, clazz, method_id, ts...);
 
@@ -239,7 +239,7 @@ struct InvokeHelper<std::enable_if_t<(kRank == 1), jshort>, kRank, false> {
   template <typename... Ts>
   static jshortArray Invoke(jobject object, jclass clazz, jmethodID method_id,
                             Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(
+    Trace(bind_lang::metaprogramming::LambdaToStr(
               STR("CallObjectMethod (jshortArray), Rank 1")),
           object, clazz, method_id, ts...);
 
@@ -257,7 +257,7 @@ struct InvokeHelper<std::enable_if_t<(kRank == 1), jint>, kRank, false> {
   template <typename... Ts>
   static jintArray Invoke(jobject object, jclass clazz, jmethodID method_id,
                           Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(
+    Trace(bind_lang::metaprogramming::LambdaToStr(
               STR("CallObjectMethod (jintArray), Rank 1")),
           object, clazz, method_id, ts...);
 
@@ -275,7 +275,7 @@ struct InvokeHelper<std::enable_if_t<(kRank == 1), jlong>, kRank, false> {
   template <typename... Ts>
   static jlongArray Invoke(jobject object, jclass clazz, jmethodID method_id,
                            Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(
+    Trace(bind_lang::metaprogramming::LambdaToStr(
               STR("CallObjectMethod (jlongArray), Rank 1")),
           object, clazz, method_id, ts...);
 
@@ -293,7 +293,7 @@ struct InvokeHelper<std::enable_if_t<(kRank == 1), jfloat>, kRank, false> {
   template <typename... Ts>
   static jfloatArray Invoke(jobject object, jclass clazz, jmethodID method_id,
                             Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(
+    Trace(bind_lang::metaprogramming::LambdaToStr(
               STR("CallObjectMethod (jfloatArray), Rank 1")),
           object, clazz, method_id, ts...);
 
@@ -311,7 +311,7 @@ struct InvokeHelper<std::enable_if_t<(kRank == 1), jdouble>, kRank, false> {
   template <typename... Ts>
   static jdoubleArray Invoke(jobject object, jclass clazz, jmethodID method_id,
                              Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(
+    Trace(bind_lang::metaprogramming::LambdaToStr(
               STR("CallObjectMethod (jdoubleArray), Rank 1")),
           object, clazz, method_id, ts...);
 
@@ -331,7 +331,7 @@ struct InvokeHelper<std::enable_if_t<(kRank == 1), jarray>, kRank, false> {
   template <typename... Ts>
   static jobjectArray Invoke(jobject object, jclass clazz, jmethodID method_id,
                              Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(
+    Trace(bind_lang::metaprogramming::LambdaToStr(
               STR("CallObjectMethod (jobjectArray), Rank 1")),
           object, clazz, method_id, ts...);
 
@@ -349,7 +349,7 @@ struct InvokeHelper<std::enable_if_t<(kRank == 1), jobject>, kRank, false> {
   template <typename... Ts>
   static jobjectArray Invoke(jobject object, jclass clazz, jmethodID method_id,
                              Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(
+    Trace(bind_lang::metaprogramming::LambdaToStr(
               STR("CallObjectMethod (jobjectArray), Rank 1")),
           object, clazz, method_id, ts...);
 
@@ -370,7 +370,7 @@ struct InvokeHelper<std::enable_if_t<(kRank > 1), jboolean>, kRank, false> {
   template <typename... Ts>
   static jobjectArray Invoke(jobject object, jclass clazz, jmethodID method_id,
                              Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(
+    Trace(bind_lang::metaprogramming::LambdaToStr(
               STR("CallObjectMethod (jobjectArray), Rank >1")),
           object, clazz, method_id, ts...);
 
@@ -388,7 +388,7 @@ struct InvokeHelper<std::enable_if_t<(kRank > 1), jbyte>, kRank, false> {
   template <typename... Ts>
   static jobjectArray Invoke(jobject object, jclass clazz, jmethodID method_id,
                              Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(
+    Trace(bind_lang::metaprogramming::LambdaToStr(
               STR("CallObjectMethod (jobjectArray), Rank >1")),
           object, clazz, method_id, ts...);
 
@@ -406,7 +406,7 @@ struct InvokeHelper<std::enable_if_t<(kRank > 1), jchar>, kRank, false> {
   template <typename... Ts>
   static jobjectArray Invoke(jobject object, jclass clazz, jmethodID method_id,
                              Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(
+    Trace(bind_lang::metaprogramming::LambdaToStr(
               STR("CallObjectMethod (jobjectArray), Rank >1")),
           object, clazz, method_id, ts...);
 
@@ -424,7 +424,7 @@ struct InvokeHelper<std::enable_if_t<(kRank > 1), jshort>, kRank, false> {
   template <typename... Ts>
   static jobjectArray Invoke(jobject object, jclass clazz, jmethodID method_id,
                              Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(
+    Trace(bind_lang::metaprogramming::LambdaToStr(
               STR("CallObjectMethod (jobjectArray), Rank >1")),
           object, clazz, method_id, ts...);
 
@@ -442,7 +442,7 @@ struct InvokeHelper<std::enable_if_t<(kRank > 1), jint>, kRank, false> {
   template <typename... Ts>
   static jobjectArray Invoke(jobject object, jclass clazz, jmethodID method_id,
                              Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(
+    Trace(bind_lang::metaprogramming::LambdaToStr(
               STR("CallObjectMethod (jobjectArray), Rank >1")),
           object, clazz, method_id, ts...);
 
@@ -460,7 +460,7 @@ struct InvokeHelper<std::enable_if_t<(kRank > 1), jfloat>, kRank, false> {
   template <typename... Ts>
   static jobjectArray Invoke(jobject object, jclass clazz, jmethodID method_id,
                              Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(
+    Trace(bind_lang::metaprogramming::LambdaToStr(
               STR("CallObjectMethod (jobjectArray), Rank >1")),
           object, clazz, method_id, ts...);
 #ifdef DRY_RUN
@@ -477,7 +477,7 @@ struct InvokeHelper<std::enable_if_t<(kRank > 1), jdouble>, kRank, false> {
   template <typename... Ts>
   static jobjectArray Invoke(jobject object, jclass clazz, jmethodID method_id,
                              Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(
+    Trace(bind_lang::metaprogramming::LambdaToStr(
               STR("CallObjectMethod (jobjectArray), Rank >1")),
           object, clazz, method_id, ts...);
 
@@ -495,7 +495,7 @@ struct InvokeHelper<std::enable_if_t<(kRank > 1), jlong>, kRank, false> {
   template <typename... Ts>
   static jobjectArray Invoke(jobject object, jclass clazz, jmethodID method_id,
                              Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(
+    Trace(bind_lang::metaprogramming::LambdaToStr(
               STR("CallObjectMethod (jobjectArray), Rank >1")),
           object, clazz, method_id, ts...);
 
@@ -515,7 +515,7 @@ struct InvokeHelper<std::enable_if_t<(kRank > 1), jarray>, kRank, false> {
   template <typename... Ts>
   static jobjectArray Invoke(jobject object, jclass clazz, jmethodID method_id,
                              Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(
+    Trace(bind_lang::metaprogramming::LambdaToStr(
               STR("CallObjectMethod (jobjectArray), Rank >1")),
           object, clazz, method_id, ts...);
 
@@ -533,7 +533,7 @@ struct InvokeHelper<std::enable_if_t<(kRank > 1), jobject>, kRank, false> {
   template <typename... Ts>
   static jobjectArray Invoke(jobject object, jclass clazz, jmethodID method_id,
                              Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(
+    Trace(bind_lang::metaprogramming::LambdaToStr(
               STR("CallObjectMethod (jobjectArray), Rank >1")),
           object, clazz, method_id, ts...);
 
diff --git a/implementation/jni_helper/invoke_static.h b/implementation/jni_helper/invoke_static.h
index 9aaf7c1e..c3079f33 100644
--- a/implementation/jni_helper/invoke_static.h
+++ b/implementation/jni_helper/invoke_static.h
@@ -36,8 +36,8 @@ template <>
 struct InvokeHelper<void, 0, true> {
   template <typename... Ts>
   static void Invoke(jobject, jclass clazz, jmethodID method_id, Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(STR("CallStaticVoidMethod")), clazz,
-          method_id, ts...);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("CallStaticVoidMethod")),
+          clazz, method_id, ts...);
 
 #ifdef DRY_RUN
 #else
@@ -55,8 +55,9 @@ struct InvokeHelper<jboolean, 0, true> {
   template <typename... Ts>
   static jboolean Invoke(jobject, jclass clazz, jmethodID method_id,
                          Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(STR("CallStaticBooleanMethod")), clazz,
-          method_id, ts...);
+    Trace(
+        bind_lang::metaprogramming::LambdaToStr(STR("CallStaticBooleanMethod")),
+        clazz, method_id, ts...);
 
 #ifdef DRY_RUN
     return Fake<jboolean>();
@@ -72,8 +73,8 @@ struct InvokeHelper<jbyte, 0, true> {
   template <typename... Ts>
   static jboolean Invoke(jobject, jclass clazz, jmethodID method_id,
                          Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(STR("CallStaticByteMethod")), clazz,
-          method_id, ts...);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("CallStaticByteMethod")),
+          clazz, method_id, ts...);
 
 #ifdef DRY_RUN
     return Fake<jboolean>();
@@ -89,8 +90,8 @@ struct InvokeHelper<jchar, 0, true> {
   template <typename... Ts>
   static jboolean Invoke(jobject, jclass clazz, jmethodID method_id,
                          Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(STR("CallStaticCharMethod")), clazz,
-          method_id, ts...);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("CallStaticCharMethod")),
+          clazz, method_id, ts...);
 
 #ifdef DRY_RUN
     return Fake<jboolean>();
@@ -106,8 +107,8 @@ struct InvokeHelper<jshort, 0, true> {
   template <typename... Ts>
   static jboolean Invoke(jobject, jclass clazz, jmethodID method_id,
                          Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(STR("CallStaticShortMethod")), clazz,
-          method_id, ts...);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("CallStaticShortMethod")),
+          clazz, method_id, ts...);
 
 #ifdef DRY_RUN
     return Fake<jboolean>();
@@ -122,8 +123,8 @@ template <>
 struct InvokeHelper<jint, 0, true> {
   template <typename... Ts>
   static jint Invoke(jobject, jclass clazz, jmethodID method_id, Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(STR("CallStaticIntMethod")), clazz,
-          method_id, ts...);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("CallStaticIntMethod")),
+          clazz, method_id, ts...);
 
 #ifdef DRY_RUN
     return Fake<jint>();
@@ -138,8 +139,8 @@ template <>
 struct InvokeHelper<jlong, 0, true> {
   template <typename... Ts>
   static jlong Invoke(jobject, jclass clazz, jmethodID method_id, Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(STR("CallStaticLongMethod")), clazz,
-          method_id, ts...);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("CallStaticLongMethod")),
+          clazz, method_id, ts...);
 
 #ifdef DRY_RUN
     return Fake<jlong>();
@@ -154,8 +155,8 @@ template <>
 struct InvokeHelper<jfloat, 0, true> {
   template <typename... Ts>
   static jfloat Invoke(jobject, jclass clazz, jmethodID method_id, Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(STR("CallStaticFloatMethod")), clazz,
-          method_id, ts...);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("CallStaticFloatMethod")),
+          clazz, method_id, ts...);
 
 #ifdef DRY_RUN
     return 123.f;
@@ -171,8 +172,9 @@ struct InvokeHelper<jdouble, 0, true> {
   template <typename... Ts>
   static jdouble Invoke(jobject, jclass clazz, jmethodID method_id,
                         Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(STR("CallStaticDoubleMethod")), clazz,
-          method_id, ts...);
+    Trace(
+        bind_lang::metaprogramming::LambdaToStr(STR("CallStaticDoubleMethod")),
+        clazz, method_id, ts...);
 
 #ifdef DRY_RUN
     return 123.;
@@ -190,8 +192,9 @@ struct InvokeHelper<jobject, 0, true> {
   template <typename... Ts>
   static jobject Invoke(jobject, jclass clazz, jmethodID method_id,
                         Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(STR("CallStaticObjectMethod")), clazz,
-          method_id, ts...);
+    Trace(
+        bind_lang::metaprogramming::LambdaToStr(STR("CallStaticObjectMethod")),
+        clazz, method_id, ts...);
 
 #ifdef DRY_RUN
     return Fake<jobject>();
@@ -207,8 +210,9 @@ struct InvokeHelper<jstring, 0, true> {
   template <typename... Ts>
   static jobject Invoke(jobject, jclass clazz, jmethodID method_id,
                         Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(STR("CallStaticObjectMethod")), clazz,
-          method_id, ts...);
+    Trace(
+        bind_lang::metaprogramming::LambdaToStr(STR("CallStaticObjectMethod")),
+        clazz, method_id, ts...);
 
 #ifdef DRY_RUN
     return Fake<jobject>();
@@ -227,7 +231,8 @@ struct InvokeHelper<std::enable_if_t<(kRank == 1), jboolean>, kRank, true> {
   template <typename... Ts>
   static jbooleanArray Invoke(jobject, jclass clazz, jmethodID method_id,
                               Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(STR("CallStaticObjectMethod, Rank 1")),
+    Trace(bind_lang::metaprogramming::LambdaToStr(
+              STR("CallStaticObjectMethod, Rank 1")),
           clazz, method_id, ts...);
 
 #ifdef DRY_RUN
@@ -245,7 +250,8 @@ struct InvokeHelper<std::enable_if_t<(kRank == 1), jbyte>, kRank, true> {
   template <typename... Ts>
   static jbyteArray Invoke(jobject, jclass clazz, jmethodID method_id,
                            Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(STR("CallStaticObjectMethod, Rank 1")),
+    Trace(bind_lang::metaprogramming::LambdaToStr(
+              STR("CallStaticObjectMethod, Rank 1")),
           clazz, method_id, ts...);
 
 #ifdef DRY_RUN
@@ -263,7 +269,8 @@ struct InvokeHelper<std::enable_if_t<(kRank == 1), jchar>, kRank, true> {
   template <typename... Ts>
   static jcharArray Invoke(jobject, jclass clazz, jmethodID method_id,
                            Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(STR("CallStaticObjectMethod, Rank 1")),
+    Trace(bind_lang::metaprogramming::LambdaToStr(
+              STR("CallStaticObjectMethod, Rank 1")),
           clazz, method_id, ts...);
 
 #ifdef DRY_RUN
@@ -281,7 +288,8 @@ struct InvokeHelper<std::enable_if_t<(kRank == 1), jshort>, kRank, true> {
   template <typename... Ts>
   static jshortArray Invoke(jobject, jclass clazz, jmethodID method_id,
                             Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(STR("CallStaticObjectMethod, Rank 1")),
+    Trace(bind_lang::metaprogramming::LambdaToStr(
+              STR("CallStaticObjectMethod, Rank 1")),
           clazz, method_id, ts...);
 
 #ifdef DRY_RUN
@@ -299,7 +307,8 @@ struct InvokeHelper<std::enable_if_t<(kRank == 1), jint>, kRank, true> {
   template <typename... Ts>
   static jintArray Invoke(jobject, jclass clazz, jmethodID method_id,
                           Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(STR("CallStaticObjectMethod, Rank 1")),
+    Trace(bind_lang::metaprogramming::LambdaToStr(
+              STR("CallStaticObjectMethod, Rank 1")),
           clazz, method_id, ts...);
 
 #ifdef DRY_RUN
@@ -316,7 +325,8 @@ struct InvokeHelper<std::enable_if_t<(kRank == 1), jfloat>, kRank, true> {
   template <typename... Ts>
   static jfloatArray Invoke(jobject, jclass clazz, jmethodID method_id,
                             Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(STR("CallStaticObjectMethod, Rank 1")),
+    Trace(bind_lang::metaprogramming::LambdaToStr(
+              STR("CallStaticObjectMethod, Rank 1")),
           clazz, method_id, ts...);
 
 #ifdef DRY_RUN
@@ -334,7 +344,8 @@ struct InvokeHelper<std::enable_if_t<(kRank == 1), jdouble>, kRank, true> {
   template <typename... Ts>
   static jdoubleArray Invoke(jobject, jclass clazz, jmethodID method_id,
                              Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(STR("CallStaticObjectMethod, Rank 1")),
+    Trace(bind_lang::metaprogramming::LambdaToStr(
+              STR("CallStaticObjectMethod, Rank 1")),
           clazz, method_id, ts...);
 
 #ifdef DRY_RUN
@@ -352,7 +363,8 @@ struct InvokeHelper<std::enable_if_t<(kRank == 1), jlong>, kRank, true> {
   template <typename... Ts>
   static jlongArray Invoke(jobject, jclass clazz, jmethodID method_id,
                            Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(STR("CallStaticObjectMethod, Rank 1")),
+    Trace(bind_lang::metaprogramming::LambdaToStr(
+              STR("CallStaticObjectMethod, Rank 1")),
           clazz, method_id, ts...);
 
 #ifdef DRY_RUN
@@ -372,7 +384,8 @@ struct InvokeHelper<std::enable_if_t<(kRank == 1), jarray>, kRank, true> {
   template <typename... Ts>
   static jobjectArray Invoke(jobject, jclass clazz, jmethodID method_id,
                              Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(STR("CallStaticObjectMethod, Rank 1")),
+    Trace(bind_lang::metaprogramming::LambdaToStr(
+              STR("CallStaticObjectMethod, Rank 1")),
           clazz, method_id, ts...);
 
 #ifdef DRY_RUN
@@ -390,7 +403,8 @@ struct InvokeHelper<std::enable_if_t<(kRank == 1), jobject>, kRank, true> {
   template <typename... Ts>
   static jobjectArray Invoke(jobject, jclass clazz, jmethodID method_id,
                              Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(STR("CallStaticObjectMethod, Rank 1")),
+    Trace(bind_lang::metaprogramming::LambdaToStr(
+              STR("CallStaticObjectMethod, Rank 1")),
           clazz, method_id, ts...);
 
 #ifdef DRY_RUN
@@ -411,7 +425,7 @@ struct InvokeHelper<std::enable_if_t<(kRank > 1), jboolean>, kRank, true> {
   template <typename... Ts>
   static jobjectArray Invoke(jobject, jclass clazz, jmethodID method_id,
                              Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(
+    Trace(bind_lang::metaprogramming::LambdaToStr(
               STR("CallStaticObjectMethod (jboolean), Rank >1")),
           clazz, method_id, ts...);
 
@@ -430,7 +444,7 @@ struct InvokeHelper<std::enable_if_t<(kRank > 1), jbyte>, kRank, true> {
   template <typename... Ts>
   static jobjectArray Invoke(jobject, jclass clazz, jmethodID method_id,
                              Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(
+    Trace(bind_lang::metaprogramming::LambdaToStr(
               STR("CallStaticObjectMethod (jbyte), Rank >1")),
           clazz, method_id, ts...);
 
@@ -449,7 +463,7 @@ struct InvokeHelper<std::enable_if_t<(kRank > 1), jchar>, kRank, true> {
   template <typename... Ts>
   static jobjectArray Invoke(jobject, jclass clazz, jmethodID method_id,
                              Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(
+    Trace(bind_lang::metaprogramming::LambdaToStr(
               STR("CallStaticObjectMethod (jchar), Rank >1")),
           clazz, method_id, ts...);
 
@@ -468,7 +482,7 @@ struct InvokeHelper<std::enable_if_t<(kRank > 1), jshort>, kRank, true> {
   template <typename... Ts>
   static jobjectArray Invoke(jobject, jclass clazz, jmethodID method_id,
                              Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(
+    Trace(bind_lang::metaprogramming::LambdaToStr(
               STR("CallStaticObjectMethod (jshort), Rank >1")),
           clazz, method_id, ts...);
 
@@ -487,7 +501,7 @@ struct InvokeHelper<std::enable_if_t<(kRank > 1), jint>, kRank, true> {
   template <typename... Ts>
   static jobjectArray Invoke(jobject, jclass clazz, jmethodID method_id,
                              Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(
+    Trace(bind_lang::metaprogramming::LambdaToStr(
               STR("CallStaticObjectMethod (jint), Rank >1")),
           clazz, method_id, ts...);
 
@@ -506,7 +520,7 @@ struct InvokeHelper<std::enable_if_t<(kRank > 1), jfloat>, kRank, true> {
   template <typename... Ts>
   static jobjectArray Invoke(jobject, jclass clazz, jmethodID method_id,
                              Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(
+    Trace(bind_lang::metaprogramming::LambdaToStr(
               STR("CallStaticObjectMethod (jfloat), Rank >1")),
           clazz, method_id, ts...);
 
@@ -525,7 +539,7 @@ struct InvokeHelper<std::enable_if_t<(kRank > 1), jdouble>, kRank, true> {
   template <typename... Ts>
   static jobjectArray Invoke(jobject, jclass clazz, jmethodID method_id,
                              Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(
+    Trace(bind_lang::metaprogramming::LambdaToStr(
               STR("CallStaticObjectMethod (jdouble), Rank >1")),
           clazz, method_id, ts...);
 
@@ -544,7 +558,7 @@ struct InvokeHelper<std::enable_if_t<(kRank > 1), jlong>, kRank, true> {
   template <typename... Ts>
   static jobjectArray Invoke(jobject, jclass clazz, jmethodID method_id,
                              Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(
+    Trace(bind_lang::metaprogramming::LambdaToStr(
               STR("CallStaticObjectMethod (jlong), Rank >1")),
           clazz, method_id, ts...);
 
@@ -565,7 +579,7 @@ struct InvokeHelper<std::enable_if_t<(kRank > 1), jarray>, kRank, true> {
   template <typename... Ts>
   static jobjectArray Invoke(jobject, jclass clazz, jmethodID method_id,
                              Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(
+    Trace(bind_lang::metaprogramming::LambdaToStr(
               STR("CallStaticObjectMethod (jarray), Rank >1")),
           clazz, method_id, ts...);
 
@@ -584,7 +598,7 @@ struct InvokeHelper<std::enable_if_t<(kRank > 1), jobject>, kRank, true> {
   template <typename... Ts>
   static jobjectArray Invoke(jobject, jclass clazz, jmethodID method_id,
                              Ts&&... ts) {
-    Trace(metaprogramming::LambdaToStr(
+    Trace(bind_lang::metaprogramming::LambdaToStr(
               STR("CallStaticObjectMethod (jobject), Rank >1")),
           clazz, method_id, ts...);
 
diff --git a/implementation/jni_helper/jni_array_helper.h b/implementation/jni_helper/jni_array_helper.h
index b900b8d5..deddb8a5 100644
--- a/implementation/jni_helper/jni_array_helper.h
+++ b/implementation/jni_helper/jni_array_helper.h
@@ -29,7 +29,8 @@ namespace jni {
 
 struct JniArrayHelperBase {
   static inline std::size_t GetLength(jarray array) {
-    Trace(metaprogramming::LambdaToStr(STR("GetArrayLength")), array);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("GetArrayLength")),
+          array);
 
 #ifdef DRY_RUN
     return Fake<std::size_t>();
@@ -47,8 +48,8 @@ struct JniArrayHelper : public JniArrayHelperBase {
   static inline jobjectArray NewArray(std::size_t size,
                                       jclass class_id = nullptr,
                                       jobject initial_element = nullptr) {
-    Trace(metaprogramming::LambdaToStr(STR("NewObjectArray")), size, class_id,
-          initial_element);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("NewObjectArray")), size,
+          class_id, initial_element);
 
 #ifdef DRY_RUN
     return Fake<jobjectArray>();
@@ -60,8 +61,8 @@ struct JniArrayHelper : public JniArrayHelperBase {
 
   // The API of fetching objects only permits accessing one object at a time.
   static inline jobject GetArrayElement(jobjectArray array, std::size_t idx) {
-    Trace(metaprogramming::LambdaToStr(STR("GetObjectArrayElement")), array,
-          idx);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("GetObjectArrayElement")),
+          array, idx);
 
 #ifdef DRY_RUN
     return Fake<jobject>();
@@ -73,8 +74,8 @@ struct JniArrayHelper : public JniArrayHelperBase {
   // The API of fetching objects only permits accessing one object at a time.
   static inline void SetArrayElement(jobjectArray array, std::size_t idx,
                                      SpannedType obj) {
-    Trace(metaprogramming::LambdaToStr(STR("SetObjectArrayElement")), array,
-          idx, obj);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("SetObjectArrayElement")),
+          array, idx, obj);
 
 #ifdef DRY_RUN
 #else
@@ -88,7 +89,9 @@ struct JniArrayHelper<jboolean, 1> : public JniArrayHelperBase {
   using AsArrayType = jbooleanArray;
 
   static inline jbooleanArray NewArray(std::size_t size) {
-    Trace(metaprogramming::LambdaToStr(STR("NewBooleanArray, Rank 1")), size);
+    Trace(
+        bind_lang::metaprogramming::LambdaToStr(STR("NewBooleanArray, Rank 1")),
+        size);
 
 #ifdef DRY_RUN
     return Fake<jbooleanArray>();
@@ -99,9 +102,9 @@ struct JniArrayHelper<jboolean, 1> : public JniArrayHelperBase {
 
   static inline GetArrayElementsResult<jboolean> GetArrayElements(
       jarray array) {
-    Trace(
-        metaprogramming::LambdaToStr(STR("GetArrayElements, jboolean, Rank 1")),
-        array);
+    Trace(bind_lang::metaprogramming::LambdaToStr(
+              STR("GetArrayElements, jboolean, Rank 1")),
+          array);
 
 #ifdef DRY_RUN
     return GetArrayElementsResult<jboolean>{};
@@ -116,7 +119,7 @@ struct JniArrayHelper<jboolean, 1> : public JniArrayHelperBase {
 
   static inline void ReleaseArrayElements(jarray array, jboolean* native_ptr,
                                           bool copy_on_completion) {
-    Trace(metaprogramming::LambdaToStr(
+    Trace(bind_lang::metaprogramming::LambdaToStr(
               STR("ReleaseArrayElements, jboolean, Rank 1")),
           array, native_ptr, copy_on_completion);
 
@@ -134,7 +137,8 @@ struct JniArrayHelper<jbyte, 1> : public JniArrayHelperBase {
   using AsArrayType = jbyteArray;
 
   static inline jbyteArray NewArray(std::size_t size) {
-    Trace(metaprogramming::LambdaToStr(STR("NewByteArray, Rank 1")), size);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("NewByteArray, Rank 1")),
+          size);
 
 #ifdef DRY_RUN
     return Fake<jbyteArray>();
@@ -144,7 +148,8 @@ struct JniArrayHelper<jbyte, 1> : public JniArrayHelperBase {
   }
 
   static inline GetArrayElementsResult<jbyte> GetArrayElements(jarray array) {
-    Trace(metaprogramming::LambdaToStr(STR("GetArrayElements, jbyte, Rank 1")),
+    Trace(bind_lang::metaprogramming::LambdaToStr(
+              STR("GetArrayElements, jbyte, Rank 1")),
           array);
 
 #ifdef DRY_RUN
@@ -160,7 +165,7 @@ struct JniArrayHelper<jbyte, 1> : public JniArrayHelperBase {
 
   static inline void ReleaseArrayElements(jarray array, jbyte* native_ptr,
                                           bool copy_on_completion) {
-    Trace(metaprogramming::LambdaToStr(
+    Trace(bind_lang::metaprogramming::LambdaToStr(
               STR("ReleaseArrayElements, jbyte, Rank 1")),
           array, native_ptr, copy_on_completion);
 
@@ -178,7 +183,8 @@ struct JniArrayHelper<jchar, 1> : public JniArrayHelperBase {
   using AsArrayType = jcharArray;
 
   static inline jcharArray NewArray(std::size_t size) {
-    Trace(metaprogramming::LambdaToStr(STR("NewCharArray, Rank 1")), size);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("NewCharArray, Rank 1")),
+          size);
 
 #ifdef DRY_RUN
     return Fake<jcharArray>();
@@ -188,7 +194,8 @@ struct JniArrayHelper<jchar, 1> : public JniArrayHelperBase {
   }
 
   static inline GetArrayElementsResult<jchar> GetArrayElements(jarray array) {
-    Trace(metaprogramming::LambdaToStr(STR("GetArrayElements, jchar, Rank 1")),
+    Trace(bind_lang::metaprogramming::LambdaToStr(
+              STR("GetArrayElements, jchar, Rank 1")),
           array);
 
 #ifdef DRY_RUN
@@ -204,7 +211,7 @@ struct JniArrayHelper<jchar, 1> : public JniArrayHelperBase {
 
   static inline void ReleaseArrayElements(jarray array, jchar* native_ptr,
                                           bool copy_on_completion) {
-    Trace(metaprogramming::LambdaToStr(
+    Trace(bind_lang::metaprogramming::LambdaToStr(
               STR("ReleaseArrayElements, jchar, Rank 1")),
           array, native_ptr, copy_on_completion);
 
@@ -222,7 +229,8 @@ struct JniArrayHelper<jshort, 1> : public JniArrayHelperBase {
   using AsArrayType = jshortArray;
 
   static inline jshortArray NewArray(std::size_t size) {
-    Trace(metaprogramming::LambdaToStr(STR("NewShortArray, Rank 1")), size);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("NewShortArray, Rank 1")),
+          size);
 
 #ifdef DRY_RUN
     return Fake<jshortArray>();
@@ -232,7 +240,8 @@ struct JniArrayHelper<jshort, 1> : public JniArrayHelperBase {
   }
 
   static inline GetArrayElementsResult<jshort> GetArrayElements(jarray array) {
-    Trace(metaprogramming::LambdaToStr(STR("GetArrayElements, jshort, Rank 1")),
+    Trace(bind_lang::metaprogramming::LambdaToStr(
+              STR("GetArrayElements, jshort, Rank 1")),
           array);
 
 #ifdef DRY_RUN
@@ -248,7 +257,7 @@ struct JniArrayHelper<jshort, 1> : public JniArrayHelperBase {
 
   static inline void ReleaseArrayElements(jarray array, jshort* native_ptr,
                                           bool copy_on_completion) {
-    Trace(metaprogramming::LambdaToStr(
+    Trace(bind_lang::metaprogramming::LambdaToStr(
               STR("ReleaseArrayElements, jshort, Rank 1")),
           array, native_ptr, copy_on_completion);
 
@@ -266,7 +275,8 @@ struct JniArrayHelper<jint, 1> : public JniArrayHelperBase {
   using AsArrayType = jintArray;
 
   static inline jintArray NewArray(std::size_t size) {
-    Trace(metaprogramming::LambdaToStr(STR("NewIntArray, Rank 1")), size);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("NewIntArray, Rank 1")),
+          size);
 
 #ifdef DRY_RUN
     return Fake<jintArray>();
@@ -276,7 +286,8 @@ struct JniArrayHelper<jint, 1> : public JniArrayHelperBase {
   }
 
   static inline GetArrayElementsResult<jint> GetArrayElements(jarray array) {
-    Trace(metaprogramming::LambdaToStr(STR("GetArrayElements, jint, Rank 1")),
+    Trace(bind_lang::metaprogramming::LambdaToStr(
+              STR("GetArrayElements, jint, Rank 1")),
           array);
 
 #ifdef DRY_RUN
@@ -292,9 +303,9 @@ struct JniArrayHelper<jint, 1> : public JniArrayHelperBase {
 
   static inline void ReleaseArrayElements(jarray array, int* native_ptr,
                                           bool copy_on_completion) {
-    Trace(
-        metaprogramming::LambdaToStr(STR("ReleaseArrayElements, jint, Rank 1")),
-        array, native_ptr, copy_on_completion);
+    Trace(bind_lang::metaprogramming::LambdaToStr(
+              STR("ReleaseArrayElements, jint, Rank 1")),
+          array, native_ptr, copy_on_completion);
 
 #ifdef DRY_RUN
 #else
@@ -310,7 +321,8 @@ struct JniArrayHelper<jlong, 1> : public JniArrayHelperBase {
   using AsArrayType = jlongArray;
 
   static inline jlongArray NewArray(std::size_t size) {
-    Trace(metaprogramming::LambdaToStr(STR("NewLongArray, Rank 1")), size);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("NewLongArray, Rank 1")),
+          size);
 
 #ifdef DRY_RUN
     return Fake<jlongArray>();
@@ -320,7 +332,8 @@ struct JniArrayHelper<jlong, 1> : public JniArrayHelperBase {
   }
 
   static inline GetArrayElementsResult<jlong> GetArrayElements(jarray array) {
-    Trace(metaprogramming::LambdaToStr(STR("GetArrayElements, jlong, Rank 1")),
+    Trace(bind_lang::metaprogramming::LambdaToStr(
+              STR("GetArrayElements, jlong, Rank 1")),
           array);
 
 #ifdef DRY_RUN
@@ -335,7 +348,7 @@ struct JniArrayHelper<jlong, 1> : public JniArrayHelperBase {
 
   static inline void ReleaseArrayElements(jarray array, jlong* native_ptr,
                                           bool copy_on_completion) {
-    Trace(metaprogramming::LambdaToStr(
+    Trace(bind_lang::metaprogramming::LambdaToStr(
               STR("ReleaseArrayElements, jlong, Rank 1")),
           array, native_ptr, copy_on_completion);
 
@@ -353,7 +366,8 @@ struct JniArrayHelper<jfloat, 1> : public JniArrayHelperBase {
   using AsArrayType = jfloatArray;
 
   static inline jfloatArray NewArray(std::size_t size) {
-    Trace(metaprogramming::LambdaToStr(STR("NewFloatArray, Rank 1")), size);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("NewFloatArray, Rank 1")),
+          size);
 
 #ifdef DRY_RUN
     return Fake<jfloatArray>();
@@ -363,7 +377,8 @@ struct JniArrayHelper<jfloat, 1> : public JniArrayHelperBase {
   }
 
   static inline GetArrayElementsResult<jfloat> GetArrayElements(jarray array) {
-    Trace(metaprogramming::LambdaToStr(STR("GetArrayElements, jfloat, Rank 1")),
+    Trace(bind_lang::metaprogramming::LambdaToStr(
+              STR("GetArrayElements, jfloat, Rank 1")),
           array);
 
 #ifdef DRY_RUN
@@ -378,7 +393,7 @@ struct JniArrayHelper<jfloat, 1> : public JniArrayHelperBase {
 
   static inline void ReleaseArrayElements(jarray array, jfloat* native_ptr,
                                           bool copy_on_completion) {
-    Trace(metaprogramming::LambdaToStr(
+    Trace(bind_lang::metaprogramming::LambdaToStr(
               STR("ReleaseArrayElements, jfloat, Rank 1")),
           array, native_ptr, copy_on_completion);
 
@@ -393,7 +408,9 @@ struct JniArrayHelper<jdouble, 1> : public JniArrayHelperBase {
   using AsArrayType = jdoubleArray;
 
   static inline jdoubleArray NewArray(std::size_t size) {
-    Trace(metaprogramming::LambdaToStr(STR("NewDoubleArray, Rank 1")), size);
+    Trace(
+        bind_lang::metaprogramming::LambdaToStr(STR("NewDoubleArray, Rank 1")),
+        size);
 
 #ifdef DRY_RUN
     return Fake<jdoubleArray>();
@@ -403,9 +420,9 @@ struct JniArrayHelper<jdouble, 1> : public JniArrayHelperBase {
   }
 
   static inline GetArrayElementsResult<jdouble> GetArrayElements(jarray array) {
-    Trace(
-        metaprogramming::LambdaToStr(STR("GetArrayElements, jdouble, Rank 1")),
-        array);
+    Trace(bind_lang::metaprogramming::LambdaToStr(
+              STR("GetArrayElements, jdouble, Rank 1")),
+          array);
 
 #ifdef DRY_RUN
     return GetArrayElementsResult<jdouble>();
@@ -419,7 +436,7 @@ struct JniArrayHelper<jdouble, 1> : public JniArrayHelperBase {
 
   static inline void ReleaseArrayElements(jarray array, jdouble* native_ptr,
                                           bool copy_on_completion) {
-    Trace(metaprogramming::LambdaToStr(
+    Trace(bind_lang::metaprogramming::LambdaToStr(
               STR("ReleaseArrayElements, jdouble, Rank 1")),
           array, native_ptr, copy_on_completion);
 
@@ -440,7 +457,8 @@ struct JniArrayHelper<jobject, kRank> : public JniArrayHelperBase {
 
   static inline jobjectArray NewArray(std::size_t size, jclass class_id,
                                       jobject initial_element) {
-    Trace(metaprogramming::LambdaToStr(STR("NewArray, Rank >1")), kRank);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("NewArray, Rank >1")),
+          kRank);
 
 #ifdef DRY_RUN
     return Fake<jobjectArray>();
@@ -452,7 +470,9 @@ struct JniArrayHelper<jobject, kRank> : public JniArrayHelperBase {
 
   // The API of fetching objects only permits accessing one object at a time.
   static inline jobject GetArrayElement(jobjectArray array, std::size_t idx) {
-    Trace(metaprogramming::LambdaToStr(STR("GetArrayElement, Rank >1")), kRank);
+    Trace(bind_lang::metaprogramming::LambdaToStr(
+              STR("GetArrayElement, Rank >1")),
+          kRank);
 
 #ifdef DRY_RUN
     return Fake<jobject>();
@@ -464,7 +484,9 @@ struct JniArrayHelper<jobject, kRank> : public JniArrayHelperBase {
   // The API of fetching objects only permits accessing one object at a time.
   static inline void SetArrayElement(jobjectArray array, std::size_t idx,
                                      jobject obj) {
-    Trace(metaprogramming::LambdaToStr(STR("SetArrayElement, Rank >1")), kRank);
+    Trace(bind_lang::metaprogramming::LambdaToStr(
+              STR("SetArrayElement, Rank >1")),
+          kRank);
 
 #ifdef DRY_RUN
 #else
diff --git a/implementation/jni_helper/jni_helper.h b/implementation/jni_helper/jni_helper.h
index 0d8abe5a..9e82836b 100644
--- a/implementation/jni_helper/jni_helper.h
+++ b/implementation/jni_helper/jni_helper.h
@@ -73,7 +73,7 @@ inline jobject& FallbackLoader() {
 }
 
 inline jclass JniHelper::FindClass(const char* name) {
-  Trace(metaprogramming::LambdaToStr(STR("FindClass")), name);
+  Trace(bind_lang::metaprogramming::LambdaToStr(STR("FindClass")), name);
 
 #ifdef DRY_RUN
   return Fake<jclass>();
@@ -90,7 +90,7 @@ inline jclass JniHelper::FindClass(const char* name) {
 }
 
 inline jclass JniHelper::GetObjectClass(jobject object) {
-  Trace(metaprogramming::LambdaToStr(STR("GetObjectClass")), object);
+  Trace(bind_lang::metaprogramming::LambdaToStr(STR("GetObjectClass")), object);
 
 #ifdef DRY_RUN
   return Fake<jclass>();
@@ -101,8 +101,8 @@ inline jclass JniHelper::GetObjectClass(jobject object) {
 
 jmethodID JniHelper::GetMethodID(jclass clazz, const char* method_name,
                                  const char* method_signature) {
-  Trace(metaprogramming::LambdaToStr(STR("GetMethodID")), clazz, method_name,
-        method_signature);
+  Trace(bind_lang::metaprogramming::LambdaToStr(STR("GetMethodID")), clazz,
+        method_name, method_signature);
 
 #ifdef DRY_RUN
   return Fake<jmethodID>();
@@ -114,8 +114,8 @@ jmethodID JniHelper::GetMethodID(jclass clazz, const char* method_name,
 
 jmethodID JniHelper::GetStaticMethodID(jclass clazz, const char* method_name,
                                        const char* method_signature) {
-  Trace(metaprogramming::LambdaToStr(STR("GetStaticMethodID")), clazz,
-        method_name, method_signature);
+  Trace(bind_lang::metaprogramming::LambdaToStr(STR("GetStaticMethodID")),
+        clazz, method_name, method_signature);
 
 #ifdef DRY_RUN
   return Fake<jmethodID>();
@@ -127,7 +127,7 @@ jmethodID JniHelper::GetStaticMethodID(jclass clazz, const char* method_name,
 
 jfieldID JniHelper::GetFieldID(jclass clazz, const char* name,
                                const char* signature) {
-  Trace(metaprogramming::LambdaToStr(STR("GetFieldID")), clazz, name,
+  Trace(bind_lang::metaprogramming::LambdaToStr(STR("GetFieldID")), clazz, name,
         signature);
 
 #ifdef DRY_RUN
@@ -139,8 +139,8 @@ jfieldID JniHelper::GetFieldID(jclass clazz, const char* name,
 
 jfieldID JniHelper::GetStaticFieldID(jclass clazz, const char* name,
                                      const char* signature) {
-  Trace(metaprogramming::LambdaToStr(STR("GetStaticFieldID")), clazz, name,
-        signature);
+  Trace(bind_lang::metaprogramming::LambdaToStr(STR("GetStaticFieldID")), clazz,
+        name, signature);
 
 #ifdef DRY_RUN
   return Fake<jfieldID>();
@@ -150,7 +150,7 @@ jfieldID JniHelper::GetStaticFieldID(jclass clazz, const char* name,
 }
 
 inline const char* JniHelper::GetStringUTFChars(jstring str) {
-  Trace(metaprogramming::LambdaToStr(STR("GetStringUTFChars")), str);
+  Trace(bind_lang::metaprogramming::LambdaToStr(STR("GetStringUTFChars")), str);
 
 #ifdef DRY_RUN
   return "DEAD_BEEF";
@@ -165,7 +165,8 @@ inline const char* JniHelper::GetStringUTFChars(jstring str) {
 }
 
 inline void JniHelper::ReleaseStringUTFChars(jstring str, const char* chars) {
-  Trace(metaprogramming::LambdaToStr(STR("ReleaseStringUTFChars")), str, chars);
+  Trace(bind_lang::metaprogramming::LambdaToStr(STR("ReleaseStringUTFChars")),
+        str, chars);
 
 #ifdef DRY_RUN
 #else
diff --git a/implementation/jni_helper/lifecycle.h b/implementation/jni_helper/lifecycle.h
index 63f14b49..b71c2737 100644
--- a/implementation/jni_helper/lifecycle.h
+++ b/implementation/jni_helper/lifecycle.h
@@ -36,7 +36,8 @@ struct LifecycleHelper;
 template <typename Span>
 struct LifecycleLocalBase {
   static inline void Delete(Span object) {
-    Trace(metaprogramming::LambdaToStr(STR("DeleteLocalRef")), object);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("DeleteLocalRef")),
+          object);
 
 #ifdef DRY_RUN
 #else
@@ -45,7 +46,7 @@ struct LifecycleLocalBase {
   }
 
   static inline Span NewReference(Span object) {
-    Trace(metaprogramming::LambdaToStr(STR("NewLocalRef")), object);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("NewLocalRef")), object);
 
 #ifdef DRY_RUN
     return Fake<Span>();
@@ -66,7 +67,7 @@ struct LifecycleHelper<Span, LifecycleType::LOCAL>
 template <typename Span>
 struct LifecycleGlobalBase {
   static inline Span Promote(Span object) {
-    Trace(metaprogramming::LambdaToStr(STR("NewGlobalRef")), object);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("NewGlobalRef")), object);
 
 #ifdef DRY_RUN
     jobject ret = Fake<jobject>();
@@ -74,7 +75,8 @@ struct LifecycleGlobalBase {
     jobject ret = JniEnv::GetEnv()->NewGlobalRef(object);
 #endif  // DRY_RUN
 
-    Trace(metaprogramming::LambdaToStr(STR("DeleteLocalRef")), object);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("DeleteLocalRef")),
+          object);
 
 #ifdef DRY_RUN
 #else
@@ -85,7 +87,8 @@ struct LifecycleGlobalBase {
   }
 
   static inline void Delete(Span object) {
-    Trace(metaprogramming::LambdaToStr(STR("DeleteGlobalRef")), object);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("DeleteGlobalRef")),
+          object);
 
 #ifdef DRY_RUN
 #else
@@ -94,7 +97,7 @@ struct LifecycleGlobalBase {
   }
 
   static inline Span NewReference(Span object) {
-    Trace(metaprogramming::LambdaToStr(STR("NewGlobalRef")), object);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("NewGlobalRef")), object);
 
 #ifdef DRY_RUN
     return Fake<Span>();
diff --git a/implementation/jni_helper/lifecycle_object.h b/implementation/jni_helper/lifecycle_object.h
index 953de537..7ab220b1 100644
--- a/implementation/jni_helper/lifecycle_object.h
+++ b/implementation/jni_helper/lifecycle_object.h
@@ -32,8 +32,8 @@ struct LifecycleHelper<jobject, LifecycleType::LOCAL>
   template <typename... CtorArgs>
   static inline jobject Construct(jclass clazz, jmethodID ctor_method,
                                   CtorArgs&&... ctor_args) {
-    Trace(metaprogramming::LambdaToStr(STR("NewObject")), clazz, ctor_method,
-          ctor_args...);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("NewObject")), clazz,
+          ctor_method, ctor_args...);
 
 #ifdef DRY_RUN
     return Fake<jobject>();
diff --git a/implementation/jni_helper/lifecycle_string.h b/implementation/jni_helper/lifecycle_string.h
index 66c10621..7658fa6a 100644
--- a/implementation/jni_helper/lifecycle_string.h
+++ b/implementation/jni_helper/lifecycle_string.h
@@ -29,7 +29,7 @@ template <>
 struct LifecycleHelper<jstring, LifecycleType::LOCAL>
     : public LifecycleLocalBase<jstring> {
   static inline jstring Construct(const char* chars) {
-    Trace(metaprogramming::LambdaToStr(STR("NewStringUTF")), chars);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("NewStringUTF")), chars);
 
 #ifdef DRY_RUN
     return Fake<jstring>();
diff --git a/implementation/jni_helper/static_field_value.h b/implementation/jni_helper/static_field_value.h
index ba7bd565..a521782a 100644
--- a/implementation/jni_helper/static_field_value.h
+++ b/implementation/jni_helper/static_field_value.h
@@ -35,8 +35,8 @@ template <>
 struct FieldHelper<jboolean, 0, true, void> {
   static inline jboolean GetValue(const jclass clazz,
                                   const jfieldID field_ref_) {
-    Trace(metaprogramming::LambdaToStr(STR("GetStaticBooleanField")), clazz,
-          field_ref_);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("GetStaticBooleanField")),
+          clazz, field_ref_);
 
 #ifdef DRY_RUN
     return Fake<jboolean>();
@@ -47,8 +47,8 @@ struct FieldHelper<jboolean, 0, true, void> {
 
   static inline void SetValue(const jclass clazz, const jfieldID field_ref_,
                               jboolean&& value) {
-    Trace(metaprogramming::LambdaToStr(STR("SetStaticBooleanField")), clazz,
-          field_ref_, value);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("SetStaticBooleanField")),
+          clazz, field_ref_, value);
 
 #ifdef DRY_RUN
 #else
@@ -60,8 +60,8 @@ struct FieldHelper<jboolean, 0, true, void> {
 template <>
 struct FieldHelper<jbyte, 0, true, void> {
   static inline jbyte GetValue(const jclass clazz, const jfieldID field_ref_) {
-    Trace(metaprogramming::LambdaToStr(STR("GetStaticByteField")), clazz,
-          field_ref_);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("GetStaticByteField")),
+          clazz, field_ref_);
 
 #ifdef DRY_RUN
     return Fake<jbyte>();
@@ -72,8 +72,8 @@ struct FieldHelper<jbyte, 0, true, void> {
 
   static inline void SetValue(const jclass clazz, const jfieldID field_ref_,
                               jbyte&& value) {
-    Trace(metaprogramming::LambdaToStr(STR("SetStaticByteField")), clazz,
-          field_ref_, value);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("SetStaticByteField")),
+          clazz, field_ref_, value);
 
 #ifdef DRY_RUN
 #else
@@ -85,8 +85,8 @@ struct FieldHelper<jbyte, 0, true, void> {
 template <>
 struct FieldHelper<jchar, 0, true, void> {
   static inline jchar GetValue(const jclass clazz, const jfieldID field_ref_) {
-    Trace(metaprogramming::LambdaToStr(STR("GetStaticCharField")), clazz,
-          field_ref_);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("GetStaticCharField")),
+          clazz, field_ref_);
 
 #ifdef DRY_RUN
     return Fake<jchar>();
@@ -97,8 +97,8 @@ struct FieldHelper<jchar, 0, true, void> {
 
   static inline void SetValue(const jclass clazz, const jfieldID field_ref_,
                               jchar&& value) {
-    Trace(metaprogramming::LambdaToStr(STR("SetStaticCharField")), clazz,
-          field_ref_, value);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("SetStaticCharField")),
+          clazz, field_ref_, value);
 
 #ifdef DRY_RUN
 #else
@@ -110,8 +110,8 @@ struct FieldHelper<jchar, 0, true, void> {
 template <>
 struct FieldHelper<jshort, 0, true, void> {
   static inline jshort GetValue(const jclass clazz, const jfieldID field_ref_) {
-    Trace(metaprogramming::LambdaToStr(STR("GetStaticShortField")), clazz,
-          field_ref_);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("GetStaticShortField")),
+          clazz, field_ref_);
 
 #ifdef DRY_RUN
     return Fake<jshort>();
@@ -122,8 +122,8 @@ struct FieldHelper<jshort, 0, true, void> {
 
   static inline void SetValue(const jclass clazz, const jfieldID field_ref_,
                               jshort&& value) {
-    Trace(metaprogramming::LambdaToStr(STR("SetStaticShortField")), clazz,
-          field_ref_, value);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("SetStaticShortField")),
+          clazz, field_ref_, value);
 
 #ifdef DRY_RUN
 #else
@@ -135,8 +135,8 @@ struct FieldHelper<jshort, 0, true, void> {
 template <>
 struct FieldHelper<jint, 0, true, void> {
   static inline jint GetValue(const jclass clazz, const jfieldID field_ref_) {
-    Trace(metaprogramming::LambdaToStr(STR("GetStaticIntField")), clazz,
-          field_ref_);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("GetStaticIntField")),
+          clazz, field_ref_);
 
 #ifdef DRY_RUN
     return Fake<jint>();
@@ -147,8 +147,8 @@ struct FieldHelper<jint, 0, true, void> {
 
   static inline void SetValue(const jclass clazz, const jfieldID field_ref_,
                               jint&& value) {
-    Trace(metaprogramming::LambdaToStr(STR("SetStaticIntField")), clazz,
-          field_ref_, value);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("SetStaticIntField")),
+          clazz, field_ref_, value);
 
 #ifdef DRY_RUN
 #else
@@ -160,8 +160,8 @@ struct FieldHelper<jint, 0, true, void> {
 template <>
 struct FieldHelper<jlong, 0, true, void> {
   static inline jlong GetValue(const jclass clazz, const jfieldID field_ref_) {
-    Trace(metaprogramming::LambdaToStr(STR("GetStaticLongField")), clazz,
-          field_ref_);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("GetStaticLongField")),
+          clazz, field_ref_);
 
 #ifdef DRY_RUN
     return Fake<jlong>();
@@ -172,8 +172,8 @@ struct FieldHelper<jlong, 0, true, void> {
 
   static inline void SetValue(const jclass clazz, const jfieldID field_ref_,
                               jlong&& value) {
-    Trace(metaprogramming::LambdaToStr(STR("SetStaticLongField")), clazz,
-          field_ref_, value);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("SetStaticLongField")),
+          clazz, field_ref_, value);
 
 #ifdef DRY_RUN
 #else
@@ -185,8 +185,8 @@ struct FieldHelper<jlong, 0, true, void> {
 template <>
 struct FieldHelper<jfloat, 0, true, void> {
   static inline jfloat GetValue(const jclass clazz, const jfieldID field_ref_) {
-    Trace(metaprogramming::LambdaToStr(STR("GetStaticFloatField")), clazz,
-          field_ref_);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("GetStaticFloatField")),
+          clazz, field_ref_);
 
 #ifdef DRY_RUN
     return 123.f;
@@ -197,8 +197,8 @@ struct FieldHelper<jfloat, 0, true, void> {
 
   static inline void SetValue(const jclass clazz, const jfieldID field_ref_,
                               jfloat&& value) {
-    Trace(metaprogramming::LambdaToStr(STR("SetStaticFloatField")), clazz,
-          field_ref_, value);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("SetStaticFloatField")),
+          clazz, field_ref_, value);
 
 #ifdef DRY_RUN
 #else
@@ -211,8 +211,8 @@ template <>
 struct FieldHelper<jdouble, 0, true, void> {
   static inline jdouble GetValue(const jclass clazz,
                                  const jfieldID field_ref_) {
-    Trace(metaprogramming::LambdaToStr(STR("GetStaticDoubleField")), clazz,
-          field_ref_);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("GetStaticDoubleField")),
+          clazz, field_ref_);
 
 #ifdef DRY_RUN
     return 123.;
@@ -223,8 +223,8 @@ struct FieldHelper<jdouble, 0, true, void> {
 
   static inline void SetValue(const jclass clazz, const jfieldID field_ref_,
                               jdouble&& value) {
-    Trace(metaprogramming::LambdaToStr(STR("SetStaticDoubleField")), clazz,
-          field_ref_, value);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("SetStaticDoubleField")),
+          clazz, field_ref_, value);
 
 #ifdef DRY_RUN
 #else
@@ -237,8 +237,8 @@ template <>
 struct FieldHelper<jobject, 0, true, void> {
   static inline jobject GetValue(const jclass clazz,
                                  const jfieldID field_ref_) {
-    Trace(metaprogramming::LambdaToStr(STR("GetStaticObjectField")), clazz,
-          field_ref_);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("GetStaticObjectField")),
+          clazz, field_ref_);
 
 #ifdef DRY_RUN
     return Fake<jobject>();
@@ -249,8 +249,8 @@ struct FieldHelper<jobject, 0, true, void> {
 
   static inline void SetValue(const jclass clazz, const jfieldID field_ref_,
                               jobject&& new_value) {
-    Trace(metaprogramming::LambdaToStr(STR("SetStaticObjectField")), clazz,
-          field_ref_, new_value);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("SetStaticObjectField")),
+          clazz, field_ref_, new_value);
 
 #ifdef DRY_RUN
 #else
@@ -263,8 +263,8 @@ template <>
 struct FieldHelper<jstring, 0, true, void> {
   static inline jstring GetValue(const jclass clazz,
                                  const jfieldID field_ref_) {
-    Trace(metaprogramming::LambdaToStr(STR("GetStaticObjectField")), clazz,
-          field_ref_);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("GetStaticObjectField")),
+          clazz, field_ref_);
 
 #ifdef DRY_RUN
     return Fake<jstring>();
@@ -276,8 +276,8 @@ struct FieldHelper<jstring, 0, true, void> {
 
   static inline void SetValue(const jclass clazz, const jfieldID field_ref_,
                               jstring&& new_value) {
-    Trace(metaprogramming::LambdaToStr(STR("SetStaticObjectField")), clazz,
-          field_ref_, new_value);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("SetStaticObjectField")),
+          clazz, field_ref_, new_value);
 
 #ifdef DRY_RUN
 #else
@@ -293,8 +293,8 @@ template <typename ArrayType>
 struct StaticBaseFieldArrayHelper {
   static inline ArrayType GetValue(const jobject object_ref,
                                    const jfieldID field_ref_) {
-    Trace(metaprogramming::LambdaToStr(STR("GetObjectField")), object_ref,
-          field_ref_);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("GetObjectField")),
+          object_ref, field_ref_);
 
 #ifdef DRY_RUN
     return Fake<ArrayType>();
@@ -306,8 +306,8 @@ struct StaticBaseFieldArrayHelper {
 
   static inline void SetValue(const jobject object_ref,
                               const jfieldID field_ref_, ArrayType&& value) {
-    Trace(metaprogramming::LambdaToStr(STR("SetObjectField")), object_ref,
-          field_ref_, value);
+    Trace(bind_lang::metaprogramming::LambdaToStr(STR("SetObjectField")),
+          object_ref, field_ref_, value);
 
 #ifdef DRY_RUN
 #else
@@ -358,7 +358,8 @@ struct FieldHelper<
     std::enable_if_t<(std::is_same_v<jobject, T> || (kRank > 1))> > {
   static inline jobjectArray GetValue(const jclass clazz,
                                       const jfieldID field_ref_) {
-    Trace(metaprogramming::LambdaToStr(STR("GetStaticObjectField, Rank 1+")),
+    Trace(bind_lang::metaprogramming::LambdaToStr(
+              STR("GetStaticObjectField, Rank 1+")),
           clazz, field_ref_);
 
 #ifdef DRY_RUN
@@ -371,7 +372,8 @@ struct FieldHelper<
 
   static inline void SetValue(const jclass clazz, const jfieldID field_ref_,
                               jobjectArray&& value) {
-    Trace(metaprogramming::LambdaToStr(STR("SetStaticObjectField, Rank 1+")),
+    Trace(bind_lang::metaprogramming::LambdaToStr(
+              STR("SetStaticObjectField, Rank 1+")),
           clazz, field_ref_, value);
 
 #ifdef DRY_RUN
diff --git a/implementation/jni_helper/trace.h b/implementation/jni_helper/trace.h
index a56776ba..41fe333a 100644
--- a/implementation/jni_helper/trace.h
+++ b/implementation/jni_helper/trace.h
@@ -30,13 +30,14 @@ namespace jni {
 
 // Called once, before any arguments are printed.
 template <char... chars>
-inline void PreTrace(metaprogramming::StringAsType<chars...> tag) {
-  printf(
-      "%s%s",
-      metaprogramming::Colorize(metaprogramming::Color::kBlueBold,
-                                tag.static_chars)
-          .data(),
-      metaprogramming::Colorize(metaprogramming::Color::kPurple, "(").data());
+inline void PreTrace(bind_lang::metaprogramming::StringAsType<chars...> tag) {
+  printf("%s%s",
+         bind_lang::metaprogramming::Colorize(
+             bind_lang::metaprogramming::Color::kBlueBold, tag.static_chars)
+             .data(),
+         bind_lang::metaprogramming::Colorize(
+             bind_lang::metaprogramming::Color::kPurple, "(")
+             .data());
 }
 
 template <typename T1, typename T2>
@@ -45,20 +46,20 @@ struct ArgTrace {};
 // Called per argument.
 template <std::size_t... Is, char... chars>
 struct ArgTrace<std::index_sequence<Is...>,
-                metaprogramming::StringAsType<chars...> > {
+                bind_lang::metaprogramming::StringAsType<chars...> > {
   template <std::size_t I>
   struct Helper {
     static constexpr bool IsLastArgument() { return I == sizeof...(Is) - 1; }
 
     template <typename Arg>
     static void Do(const Arg& arg) {
-      printf("%s", metaprogramming::Colorize(metaprogramming::Color::kCyan,
-                                             ArgString(arg))
+      printf("%s", bind_lang::metaprogramming::Colorize(
+                       bind_lang::metaprogramming::Color::kCyan, ArgString(arg))
                        .c_str());
       if constexpr (!IsLastArgument()) {
-        printf("%s",
-               metaprogramming::Colorize(metaprogramming::Color::kYellow, ",")
-                   .data());
+        printf("%s", bind_lang::metaprogramming::Colorize(
+                         bind_lang::metaprogramming::Color::kYellow, ",")
+                         .data());
       }
     }
   };
@@ -71,14 +72,14 @@ struct ArgTrace<std::index_sequence<Is...>,
 
 // Called once, after all arguments.
 template <char... chars>
-inline void PostTrace(metaprogramming::StringAsType<chars...> tag) {
-  printf(
-      "%s\n",
-      metaprogramming::Colorize(metaprogramming::Color::kPurple, ");").data());
+inline void PostTrace(bind_lang::metaprogramming::StringAsType<chars...> tag) {
+  printf("%s\n", bind_lang::metaprogramming::Colorize(
+                     bind_lang::metaprogramming::Color::kPurple, ");")
+                     .data());
 }
 
 template <char... chars, typename... Args>
-inline void Trace(metaprogramming::StringAsType<chars...> tag,
+inline void Trace(bind_lang::metaprogramming::StringAsType<chars...> tag,
                   const Args&... args) {
 // WARNING: This define is temporary and will be replaced. This unblocks
 // 1.0 release but will eventually be configurable at compile time.
diff --git a/implementation/jni_helper/trace_test.cc b/implementation/jni_helper/trace_test.cc
index adc69416..2e3aa75d 100644
--- a/implementation/jni_helper/trace_test.cc
+++ b/implementation/jni_helper/trace_test.cc
@@ -21,8 +21,8 @@
 #include <gtest/gtest.h>
 #include "bind_lang/metaprogramming/lambda_string.h"
 
+using ::bind_lang::metaprogramming::LambdaToStr;
 using ::jni::Trace;
-using ::jni::metaprogramming::LambdaToStr;
 
 using ::testing::internal::CaptureStdout;
 using ::testing::internal::GetCapturedStdout;
diff --git a/implementation/jni_type.h b/implementation/jni_type.h
index fda2f623..6465b7c0 100644
--- a/implementation/jni_type.h
+++ b/implementation/jni_type.h
@@ -102,7 +102,7 @@ struct JniT<SpanType_, class_v_, class_loader_v_, jvm_v_, kRank_, class_idx_,
 
   static constexpr std::string_view kName{GetClass().name_};
   static constexpr std::string_view kNameWithDots{
-      metaprogramming::Replace_v<kName, '/', '.'>};
+      bind_lang::metaprogramming::Replace_v<kName, '/', '.'>};
 
   static constexpr const auto& GetJvm() { return jvm_v_; }
 
@@ -217,10 +217,11 @@ struct JniTEqual<JniT<SpanType1, class_v_1, class_loader_v_1, jvm_v_1, kRank_1,
                       class_idx_2, class_loader_idx_2>> {
   static constexpr bool val =
       std::is_same_v<SpanType1, SpanType2> &&
-      metaprogramming::ValsEqualDiminished_cr_v<class_v_1, class_v_2> &&
-      metaprogramming::ValsEqualDiminished_cr_v<class_loader_v_1,
-                                                class_loader_v_2> &&
-      metaprogramming::ValsEqualDiminished_cr_v<jvm_v_1, jvm_v_2> &&
+      bind_lang::metaprogramming::ValsEqualDiminished_cr_v<class_v_1,
+                                                           class_v_2> &&
+      bind_lang::metaprogramming::ValsEqualDiminished_cr_v<class_loader_v_1,
+                                                           class_loader_v_2> &&
+      bind_lang::metaprogramming::ValsEqualDiminished_cr_v<jvm_v_1, jvm_v_2> &&
       kRank_1 == kRank_2 && class_idx_1 == class_idx_2 &&
       class_loader_idx_1 == class_loader_idx_2;
 };
diff --git a/implementation/jvm.h b/implementation/jvm.h
index 00f4c391..1704b9bd 100644
--- a/implementation/jvm.h
+++ b/implementation/jvm.h
@@ -39,7 +39,7 @@ class Jvm {
   template <const auto& class_loader_v, std::size_t... Is>
   constexpr size_t IdxOfClassLoaderHelper(
       std::integer_sequence<std::size_t, Is...>) const {
-    return metaprogramming::ModifiedMax(
+    return bind_lang::metaprogramming::ModifiedMax(
         {((std::get<Is>(class_loaders_) == class_loader_v) ? Is : -1)...});
   }
 
diff --git a/implementation/jvm_ref.h b/implementation/jvm_ref.h
index 84ac4574..413695d1 100644
--- a/implementation/jvm_ref.h
+++ b/implementation/jvm_ref.h
@@ -118,8 +118,8 @@ class JvmRef : public JvmRefBase {
               std::tuple_size_v<decltype(jvm_v_.class_loaders_)>>());
 
       auto& default_loaded_class_list = DefaultRefs<jclass>();
-      for (metaprogramming::DoubleLockedValue<jclass>* maybe_loaded_class_id :
-           default_loaded_class_list) {
+      for (bind_lang::metaprogramming::DoubleLockedValue<jclass>*
+               maybe_loaded_class_id : default_loaded_class_list) {
         maybe_loaded_class_id->Reset([](jclass clazz) {
           LifecycleHelper<jobject, LifecycleType::GLOBAL>::Delete(clazz);
         });
@@ -130,8 +130,8 @@ class JvmRef : public JvmRefBase {
     if (kConfiguration.release_method_ids_on_teardown_) {
       // Methods do not need to be released, just forgotten.
       auto& default_loaded_method_ref_list = DefaultRefs<jmethodID>();
-      for (metaprogramming::DoubleLockedValue<jmethodID>* cached_method_id :
-           default_loaded_method_ref_list) {
+      for (bind_lang::metaprogramming::DoubleLockedValue<jmethodID>*
+               cached_method_id : default_loaded_method_ref_list) {
         cached_method_id->Reset();
       }
       default_loaded_method_ref_list.clear();
@@ -140,8 +140,8 @@ class JvmRef : public JvmRefBase {
     if (kConfiguration.release_field_ids_on_teardown_) {
       // Fields do not need to be released, just forgotten.
       auto& default_loaded_field_ref_list = GetDefaultLoadedFieldList();
-      for (metaprogramming::DoubleLockedValue<jfieldID>* cached_field_id :
-           default_loaded_field_ref_list) {
+      for (bind_lang::metaprogramming::DoubleLockedValue<jfieldID>*
+               cached_field_id : default_loaded_field_ref_list) {
         cached_field_id->Reset();
       }
       default_loaded_field_ref_list.clear();
diff --git a/implementation/method_selection.h b/implementation/method_selection.h
index 49827410..92dad159 100644
--- a/implementation/method_selection.h
+++ b/implementation/method_selection.h
@@ -46,8 +46,8 @@ struct Viable {
 
   static constexpr bool val =
       Proxy_t<typename IdTParamType::UnstrippedRawVal>::template kViable<
-          IdTParamType,
-          metaprogramming::TypeOfNthElement_t<I, std::decay_t<Ts>...>>;
+          IdTParamType, bind_lang::metaprogramming::TypeOfNthElement_t<
+                            I, std::decay_t<Ts>...>>;
 };
 
 template <typename OverloadId, IdType kReturnIDType>
@@ -56,9 +56,9 @@ struct ArgumentValidate {
   template <typename... Ts>
   static constexpr bool ViableHelper() {
     if constexpr (sizeof...(Ts) == OverloadId::kNumParams) {
-      return metaprogramming::UnfurlConjunction_v<
+      return bind_lang::metaprogramming::UnfurlConjunction_v<
           OverloadId::kNumParams, Viable, OverloadId,
-          metaprogramming::Val_t<kReturnIDType>, Ts...>;
+          bind_lang::metaprogramming::Val_t<kReturnIDType>, Ts...>;
     } else {
       return false;
     }
@@ -91,15 +91,18 @@ struct MethodSelection {
 
   template <std::size_t I, typename... Ts>
   struct Helper {
-    using type = metaprogramming::Val_t<OverloadSelection<
+    using type = bind_lang::metaprogramming::Val_t<OverloadSelection<
         Id<_JniT, kIDType, IdT::kIdx, I, kNoIdx, 0>,
         kReturnIDType>::template OverloadIdxIfViable<Ts...>()>;
   };
 
   template <typename... Ts>
-  static constexpr std::size_t kIdxForTs = metaprogramming::ReduceAsPack_t<
-      metaprogramming::Min, metaprogramming::Call_t<metaprogramming::Unfurl_t<
-                                IdT::NumParams(), Helper, Ts...>>>::val;
+  static constexpr std::size_t kIdxForTs =
+      bind_lang::metaprogramming::ReduceAsPack_t<
+          bind_lang::metaprogramming::Min,
+          bind_lang::metaprogramming::Call_t<
+              bind_lang::metaprogramming::Unfurl_t<IdT::NumParams(), Helper,
+                                                   Ts...>>>::val;
 
   template <typename... Ts>
   using FindOverloadSelection = OverloadSelection<
diff --git a/implementation/object_ref.h b/implementation/object_ref.h
index e452696b..422bbdbb 100644
--- a/implementation/object_ref.h
+++ b/implementation/object_ref.h
@@ -51,17 +51,17 @@ namespace jni {
 template <typename JniT>
 class ObjectRef
     // C++17 augmentations.
-    : public metaprogramming::InvocableMap<
+    : public bind_lang::metaprogramming::InvocableMap<
           ObjectRef<JniT>, JniT::stripped_class_v, typename JniT::ClassT,
           decltype(&JniT::ClassT::methods_), &JniT::ClassT::methods_>,
-      public metaprogramming::QueryableMap_t<
+      public bind_lang::metaprogramming::QueryableMap_t<
           ObjectRef<JniT>, JniT::stripped_class_v,
           decltype(&JniT::ClassT::fields_), &JniT::ClassT::fields_>,
       // C++ 20 augmentations.
-      public metaprogramming::InvocableMap20<
+      public bind_lang::metaprogramming::InvocableMap20<
           ObjectRef<JniT>, JniT::stripped_class_v, ObjectRef<JniT>,
           decltype(&JniT::ClassT::methods_), &JniT::ClassT::methods_>,
-      public metaprogramming::QueryableMap20<
+      public bind_lang::metaprogramming::QueryableMap20<
           ObjectRef<JniT>, JniT::stripped_class_v, ObjectRef<JniT>,
           decltype(&JniT::ClassT::fields_), &JniT::ClassT::fields_>,
       public RefBase<typename JniT::StorageType> {
@@ -70,7 +70,7 @@ class ObjectRef
       JniT::class_loader_v
           .template SupportedDirectlyOrIndirectly<JniT::class_v>(),
       "This class is not directly or indirectly supported by this loader.");
-  static_assert(!metaprogramming::StringContains_v<JniT::kName, '.'>,
+  static_assert(!bind_lang::metaprogramming::StringContains_v<JniT::kName, '.'>,
                 "Use '/', not '.' in class names (for maximum) portability.");
 
   using RefBaseT = RefBase<typename JniT::StorageType>;
@@ -131,7 +131,7 @@ class ObjectRef
 ////////////////////////////////////////////////////////////////////////////////
 #if __cplusplus >= 202002L
   // Invoked through CRTP from InvocableMap, C++20 only.
-  template <size_t I, metaprogramming::StringLiteral key_literal,
+  template <size_t I, bind_lang::metaprogramming::StringLiteral key_literal,
             typename... Args>
   auto InvocableMap20Call(Args&&... args) const {
     using IdT = Id<JniT, IdType::OVERLOAD_SET, I, kNoIdx, kNoIdx, 0>;
@@ -147,7 +147,7 @@ class ObjectRef
   }
 
   // Invoked through CRTP from QueryableMap20, C++20 only.
-  template <size_t I, metaprogramming::StringLiteral key_literal>
+  template <size_t I, bind_lang::metaprogramming::StringLiteral key_literal>
   auto QueryableMap20Call() const {
     return FieldRef<JniT, IdType::FIELD, I>{GetJClass(), RefBaseT::object_ref_};
   }
diff --git a/implementation/overload_ref.h b/implementation/overload_ref.h
index 4d8c4f41..7371b2ed 100644
--- a/implementation/overload_ref.h
+++ b/implementation/overload_ref.h
@@ -55,7 +55,7 @@ struct OverloadRefUniqueId {
   // IdT::Name will be the overload name (e.g. "Foo").
   // Dashes are solely for readability in debugging.
   static constexpr std::string_view TypeName() {
-    return metaprogramming::StringConcatenate_v<
+    return bind_lang::metaprogramming::StringConcatenate_v<
         kClassQualifier, kDash, kOverloadName, kDash, Signature_v<IdT>>;
   }
 };
@@ -74,7 +74,8 @@ struct OverloadRef {
 
   static jmethodID GetMethodID(jclass clazz) {
     static auto get_lambda =
-        [clazz](metaprogramming::DoubleLockedValue<jmethodID>* storage) {
+        [clazz](
+            bind_lang::metaprogramming::DoubleLockedValue<jmethodID>* storage) {
           if (kConfiguration.release_method_ids_on_teardown_) {
             DefaultRefs<jmethodID>().push_back(storage);
           }
diff --git a/implementation/promotion_mechanics.h b/implementation/promotion_mechanics.h
index 26142b03..fe2902c6 100644
--- a/implementation/promotion_mechanics.h
+++ b/implementation/promotion_mechanics.h
@@ -41,10 +41,11 @@ struct EntryBase : public Base {
   using Span = typename JniT::SpanType;
 
   // `RefBase` move constructor for object of same span type.
-  template <typename T,
-            typename = std::enable_if_t<
-                (::jni::metaprogramming::DeepEqualDiminished_v<EntryBase, T> ||
-                 std::is_base_of_v<RefBase<Span>, T>)>>
+  template <
+      typename T,
+      typename = std::enable_if_t<
+          (::bind_lang::metaprogramming::DeepEqualDiminished_v<EntryBase, T> ||
+           std::is_base_of_v<RefBase<Span>, T>)>>
   EntryBase(T&& rhs) : Base(rhs.Release()) {}
   EntryBase(AdoptLocal, ViableSpan object) : Base(object) {}
 
@@ -131,10 +132,11 @@ struct EntryBase<Base, LifecycleType::GLOBAL, JniT, ViableSpan> : public Base {
   using Span = typename JniT::SpanType;
 
   // `RefBase` move constructor for object of same span type.
-  template <typename T,
-            typename = std::enable_if_t<
-                (::jni::metaprogramming::DeepEqualDiminished_v<EntryBase, T> ||
-                 std::is_base_of_v<RefBase<Span>, T>)>>
+  template <
+      typename T,
+      typename = std::enable_if_t<
+          (::bind_lang::metaprogramming::DeepEqualDiminished_v<EntryBase, T> ||
+           std::is_base_of_v<RefBase<Span>, T>)>>
   EntryBase(T&& rhs)
       : Base(LifecycleHelper<typename JniT::StorageType,
                              LifecycleType::GLOBAL>::Promote(rhs.Release())) {}
diff --git a/implementation/proxy.h b/implementation/proxy.h
index ca8e5f67..3719d1d1 100644
--- a/implementation/proxy.h
+++ b/implementation/proxy.h
@@ -43,7 +43,7 @@ template <typename t1, typename t2 = void>
 struct Proxy;
 
 // CDecls for all declarable types (these index into proxy definitions).
-using AllKeys = metaprogramming::Corpus_t<
+using AllKeys = bind_lang::metaprogramming::Corpus_t<
     JniUserDefinedCorpusTag, void, jboolean, jbyte, jshort, jint, jfloat, jlong,
     jchar, jdouble, jstring, jobject, Self, jarray, jobjectArray, jintArray,
     jbooleanArray, jbyteArray, jcharArray, jshortArray, jdoubleArray,
@@ -59,31 +59,33 @@ struct ProxyHelper {
   struct IndexToKey {
     // Proxies can be indexed by their |AsArg|s or their |AsDecl|.
     template <typename CDecl>
-    using type = metaprogramming::CartesianProduct_t<
+    using type = bind_lang::metaprogramming::CartesianProduct_t<
         std::tuple<CDecl>,
-        metaprogramming::UniqueSet_Tup<metaprogramming::ConcatenateTup_t<
-            typename Proxy<CDecl>::AsArg, typename Proxy<CDecl>::AsDecl>>>;
+        bind_lang::metaprogramming::UniqueSet_Tup<
+            bind_lang::metaprogramming::ConcatenateTup_t<
+                typename Proxy<CDecl>::AsArg, typename Proxy<CDecl>::AsDecl>>>;
   };
 
   // Build a list of two element tuples (in preparation to build a map).  e.g.
   // { {jint, int}, {jstring, const char*}, {jstring, std::string}, etc. }.
   // Note that types may map to 1 or more types, such as jstring above.
-  using IndexToKeyAsTuples = metaprogramming::Reduce_t<
-      metaprogramming::Combine,
-      metaprogramming::InvokePerTupArg_t<IndexToKey, AllKeys>>;
+  using IndexToKeyAsTuples = bind_lang::metaprogramming::Reduce_t<
+      bind_lang::metaprogramming::Combine,
+      bind_lang::metaprogramming::InvokePerTupArg_t<IndexToKey, AllKeys>>;
 
   // Collapse this list into a set of keys and values consumable by
   // TypeToTypeMap.
-  using IndexToKeyMap = metaprogramming::TypeToTypeMapFromKeyValuesTup_t<
-      metaprogramming::Flatten_t<IndexToKeyAsTuples>>;
+  using IndexToKeyMap =
+      bind_lang::metaprogramming::TypeToTypeMapFromKeyValuesTup_t<
+          bind_lang::metaprogramming::Flatten_t<IndexToKeyAsTuples>>;
 
   // When flipped, a type passed can be reverse indexed to select the same
   // Proxy partial specialisation.
-  using KeyToIndex = metaprogramming::TypeToTypeMap_Invert<IndexToKeyMap>;
+  using KeyToIndex =
+      bind_lang::metaprogramming::TypeToTypeMap_Invert<IndexToKeyMap>;
 
-  using Index =
-      metaprogramming::TypeToTypeMapQueryWithComparator_t<KeyToIndex,
-                                                          IsConvertibleKey<T>>;
+  using Index = bind_lang::metaprogramming::TypeToTypeMapQueryWithComparator_t<
+      KeyToIndex, IsConvertibleKey<T>>;
 
   using Proxy_t = Proxy<Index>;
 
diff --git a/implementation/proxy_test.cc b/implementation/proxy_test.cc
index f4235c74..1ed93328 100644
--- a/implementation/proxy_test.cc
+++ b/implementation/proxy_test.cc
@@ -25,6 +25,7 @@
 #include "jni_bind.h"
 #include "jni_test.h"
 
+using ::bind_lang::metaprogramming::TypeToTypeMapQuery_t;
 using ::jni::AsDecl_t;
 using ::jni::Class;
 using ::jni::ClassLoader;
@@ -32,7 +33,6 @@ using ::jni::GlobalObject;
 using ::jni::LocalObject;
 using ::jni::Proxy_t;
 using ::jni::Return_t;
-using ::jni::metaprogramming::TypeToTypeMapQuery_t;
 using ::jni::test::JniTest;
 
 namespace jni {
diff --git a/implementation/ref_storage.h b/implementation/ref_storage.h
index 62cde92c..42314c4f 100644
--- a/implementation/ref_storage.h
+++ b/implementation/ref_storage.h
@@ -31,16 +31,17 @@ namespace jni {
 // Only applicable for Jvms not fully specified (i.e. default classloader).
 // See JvmRef::~JvmRef.
 template <typename T>
-static std::vector<metaprogramming::DoubleLockedValue<T>*>& DefaultRefs() {
+static std::vector<bind_lang::metaprogramming::DoubleLockedValue<T>*>&
+DefaultRefs() {
   static auto* ret_val =
-      new std::vector<metaprogramming::DoubleLockedValue<T>*>{};
+      new std::vector<bind_lang::metaprogramming::DoubleLockedValue<T>*>{};
   return *ret_val;
 }
 
 // Provides a static inline `DoubleLockedValue<T>` val against a `UniqueID`.
 template <typename UniqueID, typename T>
 struct StaticDoubleLock {
-  static inline metaprogramming::DoubleLockedValue<T> val;
+  static inline bind_lang::metaprogramming::DoubleLockedValue<T> val;
 };
 
 // Takes a GetLambda and only invokes it for the first time on equal values of
@@ -54,7 +55,8 @@ struct RefStorage {
   static constexpr auto kSignature = []() {
     return SignatureLambda::TypeName().data();
   };
-  using Signature = metaprogramming::LambdaStringToType<decltype(kSignature)>;
+  using Signature =
+      bind_lang::metaprogramming::LambdaStringToType<decltype(kSignature)>;
 
   // Common ID-wide double locked value.
   using Storage = StaticDoubleLock<Signature, ReturnT>;
diff --git a/implementation/selector_static_info.h b/implementation/selector_static_info.h
index 6262a668..cbf57727 100644
--- a/implementation/selector_static_info.h
+++ b/implementation/selector_static_info.h
@@ -119,19 +119,22 @@ struct SelectorStaticInfo {
 
   static constexpr std::string_view kEmptyStr = "";
   static constexpr std::string_view kModifierStr =
-      (kRank == 0) ? ""
-                   : metaprogramming::RepeatString_v<
-                         kRank, metaprogramming::Constants::left_bracket>;
+      (kRank == 0)
+          ? ""
+          : bind_lang::metaprogramming::RepeatString_v<
+                kRank, bind_lang::metaprogramming::Constants::left_bracket>;
 
   static constexpr std::string_view UndecoratedTypeName() {
     if constexpr (kIsObject) {
-      return metaprogramming::StringConcatenate_v<
-          metaprogramming::Constants::L, kTypeNameOrNothingIfNotAnObject,
-          metaprogramming::Constants::semi_colon>;
+      return bind_lang::metaprogramming::StringConcatenate_v<
+          bind_lang::metaprogramming::Constants::L,
+          kTypeNameOrNothingIfNotAnObject,
+          bind_lang::metaprogramming::Constants::semi_colon>;
     } else if constexpr (kIsSelf) {
-      return metaprogramming::StringConcatenate_v<
-          metaprogramming::Constants::L, kTypeNameOrNothingIfNotAnObject,
-          metaprogramming::Constants::semi_colon>;
+      return bind_lang::metaprogramming::StringConcatenate_v<
+          bind_lang::metaprogramming::Constants::L,
+          kTypeNameOrNothingIfNotAnObject,
+          bind_lang::metaprogramming::Constants::semi_colon>;
     } else if constexpr (kIsVoid) {
       return JavaTypeToString<void>();
     } else {
@@ -143,8 +146,8 @@ struct SelectorStaticInfo {
       UndecoratedTypeName();
 
   static constexpr std::string_view TypeName() {
-    return metaprogramming::StringConcatenate_v<kModifierStr,
-                                                kUndecoratedTypeName>;
+    return bind_lang::metaprogramming::StringConcatenate_v<
+        kModifierStr, kUndecoratedTypeName>;
   }
 
   static constexpr std::string_view kTypeName = TypeName();
diff --git a/implementation/signature.h b/implementation/signature.h
index 9ac63648..ac96491a 100644
--- a/implementation/signature.h
+++ b/implementation/signature.h
@@ -59,7 +59,7 @@ struct Signature<
     };
 
     static constexpr std::string_view val =
-        metaprogramming::StringConcatenate_v<Val<Is>::val...>;
+        bind_lang::metaprogramming::StringConcatenate_v<Val<Is>::val...>;
   };
 
   struct ReturnHelper {
@@ -81,14 +81,17 @@ struct Signature<
                          kIdType_ == IdType::STATIC_OVERLOAD) {
       using Idxs = std::make_index_sequence<IdT::NumParams()>;
       if constexpr (IdT::kIsConstructor) {
-        return metaprogramming::StringConcatenate_v<
-            metaprogramming::Constants::left_parenthesis, Helper<Idxs>::val,
-            metaprogramming::Constants::right_parenthesis,
-            metaprogramming::Constants::V>;
+        return bind_lang::metaprogramming::StringConcatenate_v<
+            bind_lang::metaprogramming::Constants::left_parenthesis,
+            Helper<Idxs>::val,
+            bind_lang::metaprogramming::Constants::right_parenthesis,
+            bind_lang::metaprogramming::Constants::V>;
       } else {
-        return metaprogramming::StringConcatenate_v<
-            metaprogramming::Constants::left_parenthesis, Helper<Idxs>::val,
-            metaprogramming::Constants::right_parenthesis, ReturnHelper::val>;
+        return bind_lang::metaprogramming::StringConcatenate_v<
+            bind_lang::metaprogramming::Constants::left_parenthesis,
+            Helper<Idxs>::val,
+            bind_lang::metaprogramming::Constants::right_parenthesis,
+            ReturnHelper::val>;
       }
     } else if constexpr (kIdType_ == IdType::OVERLOAD_PARAM ||
                          kIdType_ == IdType::STATIC_OVERLOAD_PARAM) {
diff --git a/implementation/static.h b/implementation/static.h
index c2b87fb9..9f56fde0 100644
--- a/implementation/static.h
+++ b/implementation/static.h
@@ -47,8 +47,8 @@ Static() -> Static<std::tuple<>, std::tuple<>>;
 
 template <typename... Params>
 Static(Params...)
-    -> Static<metaprogramming::BaseFilter_t<MethodBase, Params...>,
-              metaprogramming::BaseFilter_t<FieldBase, Params...>>;
+    -> Static<bind_lang::metaprogramming::BaseFilter_t<MethodBase, Params...>,
+              bind_lang::metaprogramming::BaseFilter_t<FieldBase, Params...>>;
 
 }  // namespace jni
 
diff --git a/implementation/static_ref.h b/implementation/static_ref.h
index c610654c..6f1a6bd7 100644
--- a/implementation/static_ref.h
+++ b/implementation/static_ref.h
@@ -45,22 +45,21 @@ struct StaticRefHelper {
   using _JniT = JniT<jobject, class_v_, class_loader_v_, jvm_v_>;
 
   // C++17 augmentations.
-  using MethodMapT = metaprogramming::InvocableMap<
+  using MethodMapT = bind_lang::metaprogramming::InvocableMap<
       CrtpBase_, _JniT::static_v, typename _JniT::StaticT,
       decltype(&_JniT::StaticT::methods_), &_JniT::StaticT::methods_>;
-  using FieldMapT =
-      metaprogramming::QueryableMap_t<CrtpBase_, _JniT::static_v,
+  using FieldMapT = bind_lang::metaprogramming::QueryableMap_t<
+      CrtpBase_, _JniT::static_v,
 
-                                      decltype(&_JniT::StaticT::fields_),
-                                      &_JniT::StaticT::fields_>;
+      decltype(&_JniT::StaticT::fields_), &_JniT::StaticT::fields_>;
 
   // C++ 20 augmentations.
-  using MethodMap20T = metaprogramming::InvocableMap20<
+  using MethodMap20T = bind_lang::metaprogramming::InvocableMap20<
       CrtpBase_, _JniT::static_v,
       StaticRefHelper<CrtpBase_, class_v_, class_loader_v_, jvm_v_>,
       decltype(&_JniT::StaticT::methods_), &_JniT::StaticT::methods_>;
 
-  using FieldMap20T = metaprogramming::QueryableMap20<
+  using FieldMap20T = bind_lang::metaprogramming::QueryableMap20<
       CrtpBase_, _JniT::static_v,
       StaticRefHelper<CrtpBase_, class_v_, class_loader_v_, jvm_v_>,
       decltype(&_JniT::StaticT::fields_), &_JniT::StaticT::fields_>;
@@ -140,7 +139,7 @@ struct StaticRef
 
 #if __cplusplus >= 202002L
   // Invoked through CRTP from InvocableMap, C++20 only.
-  template <size_t I, metaprogramming::StringLiteral key_literal,
+  template <size_t I, bind_lang::metaprogramming::StringLiteral key_literal,
             typename... Args>
   auto InvocableMap20Call(Args&&... args) const {
     using IdT = Id<_JniT, IdType::STATIC_OVERLOAD_SET, I, kNoIdx, kNoIdx, 0>;
@@ -156,7 +155,7 @@ struct StaticRef
   }
 
   // Invoked through CRTP from QueryableMap20, C++20 only.
-  template <size_t I, metaprogramming::StringLiteral key_literal>
+  template <size_t I, bind_lang::metaprogramming::StringLiteral key_literal>
   auto QueryableMap20Call() const {
     return FieldRef<_JniT, IdType::STATIC_FIELD, I>{GetJClass(), nullptr};
   }
diff --git a/implementation/supported_class_set.h b/implementation/supported_class_set.h
index 12667399..b92babb1 100644
--- a/implementation/supported_class_set.h
+++ b/implementation/supported_class_set.h
@@ -32,7 +32,7 @@ class SupportedClassSet {
   constexpr SupportedClassSet(Classes_... supported_classes)
       : supported_classes_(supported_classes...) {
     // TODO(b/143908983): Classloaders should enforce unique classes.
-    // static_assert(metaprogramming::AllUniqueValues(supported_classes...),
+    // static_assert(bind_lang::metaprogramming::AllUniqueValues(supported_classes...),
     //"All classes supported by the class loader must be unique.");
   }
 };
diff --git a/implementation/thread_guard.h b/implementation/thread_guard.h
index 6a8626c0..3f1fb41f 100644
--- a/implementation/thread_guard.h
+++ b/implementation/thread_guard.h
@@ -79,13 +79,13 @@ class ThreadGuard {
     JavaVM* const vm = JvmRefBase::GetJavaVm();
     JNIEnv* jni_env = 0;
 
-    using TypeForGetEnv =
-        metaprogramming::FunctionTraitsArg_t<decltype(&JavaVM::GetEnv), 1>;
+    using TypeForGetEnv = bind_lang::metaprogramming::FunctionTraitsArg_t<
+        decltype(&JavaVM::GetEnv), 1>;
     const int code =
         vm->GetEnv(reinterpret_cast<TypeForGetEnv>(&jni_env), JNI_VERSION_1_6);
 
     if (code != JNI_OK) {
-      using TypeForAttachment = metaprogramming::FunctionTraitsArg_t<
+      using TypeForAttachment = bind_lang::metaprogramming::FunctionTraitsArg_t<
           decltype(&JavaVM::AttachCurrentThread), 1>;
       vm->AttachCurrentThread(reinterpret_cast<TypeForAttachment>(&jni_env),
                               nullptr);
diff --git a/javatests/com/jnibind/test/array_test_field_rank_1_jni.cc b/javatests/com/jnibind/test/array_test_field_rank_1_jni.cc
index ccaf4a57..a849d702 100644
--- a/javatests/com/jnibind/test/array_test_field_rank_1_jni.cc
+++ b/javatests/com/jnibind/test/array_test_field_rank_1_jni.cc
@@ -25,6 +25,7 @@
 #include "javatests/com/jnibind/test/object_test_helper_jni.h"
 #include "jni_bind.h"
 
+using ::bind_lang::metaprogramming::StringLiteral;
 using ::jni::Array;
 using ::jni::ArrayView;
 using ::jni::Class;
@@ -33,7 +34,6 @@ using ::jni::LocalArray;
 using ::jni::LocalObject;
 using ::jni::LocalString;
 using ::jni::StaticRef;
-using ::jni::metaprogramming::StringLiteral;
 
 static std::unique_ptr<jni::JvmRef<jni::kDefaultJvm>> jvm;
 
diff --git a/javatests/com/jnibind/test/array_test_field_rank_2_jni.cc b/javatests/com/jnibind/test/array_test_field_rank_2_jni.cc
index 714ec89d..3f5ebc15 100644
--- a/javatests/com/jnibind/test/array_test_field_rank_2_jni.cc
+++ b/javatests/com/jnibind/test/array_test_field_rank_2_jni.cc
@@ -24,6 +24,7 @@
 #include "javatests/com/jnibind/test/object_test_helper_jni.h"
 #include "jni_bind.h"
 
+using ::bind_lang::metaprogramming::StringLiteral;
 using ::jni::Array;
 using ::jni::ArrayView;
 using ::jni::Class;
@@ -33,7 +34,6 @@ using ::jni::LocalObject;
 using ::jni::Modulo;
 using ::jni::Rank;
 using ::jni::StaticRef;
-using ::jni::metaprogramming::StringLiteral;
 
 static std::unique_ptr<jni::JvmRef<jni::kDefaultJvm>> jvm;
 
diff --git a/javatests/com/jnibind/test/array_test_method_rank_1_jni.cc b/javatests/com/jnibind/test/array_test_method_rank_1_jni.cc
index c9aa2d8a..db42fef1 100644
--- a/javatests/com/jnibind/test/array_test_method_rank_1_jni.cc
+++ b/javatests/com/jnibind/test/array_test_method_rank_1_jni.cc
@@ -22,13 +22,13 @@
 #include "javatests/com/jnibind/test/object_test_helper_jni.h"
 #include "jni_bind.h"
 
+using ::bind_lang::metaprogramming::StringLiteral;
 using ::jni::ArrayView;
 using ::jni::LocalArray;
 using ::jni::LocalObject;
 using ::jni::LocalString;
 using ::jni::RegularToArrayTypeMap_t;
 using ::jni::StaticRef;
-using ::jni::metaprogramming::StringLiteral;
 
 static std::unique_ptr<jni::JvmRef<jni::kDefaultJvm>> jvm;
 
diff --git a/javatests/com/jnibind/test/array_test_method_rank_2_jni.cc b/javatests/com/jnibind/test/array_test_method_rank_2_jni.cc
index e8b098ee..488c9133 100644
--- a/javatests/com/jnibind/test/array_test_method_rank_2_jni.cc
+++ b/javatests/com/jnibind/test/array_test_method_rank_2_jni.cc
@@ -23,12 +23,12 @@
 #include "javatests/com/jnibind/test/object_test_helper_jni.h"
 #include "jni_bind.h"
 
+using ::bind_lang::metaprogramming::StringLiteral;
 using ::jni::LocalArray;
 using ::jni::LocalObject;
 using ::jni::Modulo;
 using ::jni::RegularToArrayTypeMap_t;
 using ::jni::StaticRef;
-using ::jni::metaprogramming::StringLiteral;
 
 static std::unique_ptr<jni::JvmRef<jni::kDefaultJvm>> jvm;
 
diff --git a/jni_bind.h b/jni_bind.h
index e5abe00e..d3ef8a5b 100644
--- a/jni_bind.h
+++ b/jni_bind.h
@@ -53,6 +53,10 @@ static constexpr Configuration kConfig{
 #include "implementation/jni_helper/lifecycle.h"
 #include "implementation/jni_helper/static_field_value.h"
 
+namespace jni {
+namespace metaprogramming = ::bind_lang::metaprogramming;
+}  // namespace jni
+
 // Headers for static definitions.
 #include "implementation/array.h"
 #include "implementation/array_type_conversion.h"
diff --git a/jni_test.h b/jni_test.h
index 237aa4c3..1feb576a 100644
--- a/jni_test.h
+++ b/jni_test.h
@@ -17,8 +17,10 @@
 #ifndef JNI_BIND_JNI_TEST_H_
 #define JNI_BIND_JNI_TEST_H_
 
+#include <cstddef>
 #include <cstring>
 #include <memory>
+#include <type_traits>
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
@@ -28,6 +30,7 @@
 #ifdef JNI_BIND_USE_FOR_TESTING_RELEASE_HEADER
 #include "jni_bind_release_for_testing.h"
 #else
+#include "bind_lang/metaprogramming/function_traits.h"
 #include "jni_bind.h"
 #endif
 
@@ -80,9 +83,10 @@ class JniTestWithNoDefaultJvmRef : public ::testing::Test {
     // Different jni.h implementations define AttachCurrentThread with different
     // args.  If a different jni.h is used for testing, this would likely need
     // to be updated.
-    static_assert(std::is_same_v<metaprogramming::FunctionTraitsArg_t<
-                                     decltype(&JavaVM::AttachCurrentThread), 1>,
-                                 void**>);
+    static_assert(
+        std::is_same_v<bind_lang::metaprogramming::FunctionTraitsArg_t<
+                           decltype(&JavaVM::AttachCurrentThread), 1>,
+                       void**>);
 
     ON_CALL(*jvm_, GetEnv).WillByDefault([&](void** out_env, int vs_code) {
       *reinterpret_cast<JNIEnv**>(out_env) = env_.get();