Minor cleanup of bindjam.h and mp.h.

* Fixed comments in bindjam.h
* Make mp.h properly include independent. And clang-reformat.

fixes #578

Author: paolopas

src/engine/bindjam.h

@@ -59,7 +59,7 @@ struct jam_binder : b2::bind::binder_<jam_binder>
 		::b2::bind::args_<A...> args);
 
 	/*
-	Bind the given method of a class. THe function can be any invocable whose
+	Bind the given method of a class. The function can be any invocable whose
 	interface will be reflected to Jam.
 	*/
 	template <class Function, class... A>
@@ -84,7 +84,7 @@ struct jam_binder : b2::bind::binder_<jam_binder>
 	void eval_data(const char * module_name, const char * data);
 
 	/*
-	Mark the module as loaded. Future attempts at loading, with `module.load`,
+	Mark the module as loaded. Future attempts at loading, with `modules.load`,
 	will fail (as noop).
 	*/
 	void set_loaded(const char * module_name);

src/engine/mp.h

@@ -1,96 +1,87 @@
-/*  Copyright 2019 Rene Rivera
+/*  Copyright 2019-2026 Rene Rivera
  *  Distributed under the Boost Software License, Version 1.0.
- *  (See accompanying file LICENSE.txt or https://www.bfgroup.xyz/b2/LICENSE.txt)
+ *  (See accompanying file LICENSE.txt or
+ * https://www.bfgroup.xyz/b2/LICENSE.txt)
  */
 
 #ifndef B2_MP_H
 #define B2_MP_H
 
-namespace b2
-{
-namespace mp
-{
+#include <cstddef>
+#include <type_traits>
+#include <utility>
+
+namespace b2 { namespace mp {
 
 // Simulate C++14 (make_)index_sequence..
 
 template <std::size_t... Ns>
 struct index_sequence
 {
-    using type = index_sequence;
+	using type = index_sequence;
 };
 
 template <typename A, typename B>
 struct merge_index_sequence;
 template <std::size_t... A, std::size_t... B>
-struct merge_index_sequence<
-    index_sequence<A...>, index_sequence<B...>>
-    : index_sequence<A..., (sizeof...(A) + B)...>
-{
-};
+struct merge_index_sequence<index_sequence<A...>, index_sequence<B...>>
+	: index_sequence<A..., (sizeof...(A) + B)...>
+{ };
 
 template <std::size_t N>
 struct make_index_sequence
-    : merge_index_sequence<
-          typename make_index_sequence<N / 2>::type,
-          typename make_index_sequence<N - (N / 2)>::type>
-{
-};
+	: merge_index_sequence<typename make_index_sequence<N / 2>::type,
+		  typename make_index_sequence<N - (N / 2)>::type>
+{ };
 template <>
 struct make_index_sequence<0> : index_sequence<>
-{
-};
+{ };
 template <>
 struct make_index_sequence<1> : index_sequence<0>
-{
-};
+{ };
 
 // Shallow, simulated, invoke..
 
 template <typename Return, typename Call, typename ArgsTuple, std::size_t... I>
-Return invoke(Call &&call, ArgsTuple &&args, index_sequence<I...>)
+Return invoke(Call && call, ArgsTuple && args, index_sequence<I...>)
 {
-    using std::get;
-    return call(get<I>(args)...);
+	using std::get;
+	return call(get<I>(args)...);
 }
 
 // Simulate C++ 20 remove_cvref..
 
 template <typename T>
 struct remove_cvref
 {
-    using type = typename std::remove_cv<
-        typename std::remove_reference<T>::type>::type;
+	using type =
+		typename std::remove_cv<typename std::remove_reference<T>::type>::type;
 };
 
 // Fusion style for_each..
 
 template <typename Call, typename... Args>
-void for_each_arg(Call &&call, Args &&... args)
+void for_each_arg(Call && call, Args &&... args)
 {
-    using x = int[];
-    (void)x{0, ((void)call(std::forward<Args>(args)), 0)...};
+	using x = int[];
+	(void)x { 0, ((void)call(std::forward<Args>(args)), 0)... };
 }
 
 template <typename Call, typename Tuple, std::size_t... I>
-void for_each(Tuple &&tuple, Call &&call, index_sequence<I...>)
+void for_each(Tuple && tuple, Call && call, index_sequence<I...>)
 {
-    using std::get;
-    for_each_arg(
-        std::forward<Call>(call),
-        get<I>(std::forward<Tuple>(tuple))...);
+	using std::get;
+	for_each_arg(std::forward<Call>(call), get<I>(std::forward<Tuple>(tuple))...);
 }
 
 template <typename Call, typename Tuple>
-void for_each(Tuple &&tuple, Call &&call)
+void for_each(Tuple && tuple, Call && call)
 {
-    using std::get;
-    for_each(
-        std::forward<Tuple>(tuple),
-        std::forward<Call>(call),
-        make_index_sequence<std::tuple_size<Tuple>::value>{});
+	using std::get;
+	for_each(std::forward<Tuple>(tuple), std::forward<Call>(call),
+		make_index_sequence<std::tuple_size<Tuple>::value> { });
 }
 
-} // namespace mp
-} // namespace b2
+}} // namespace b2::mp
 
 #endif