From f5396e9386d0ce7704fb6b34fdf43867a6f67ada Mon Sep 17 00:00:00 2001
From: badair <badair@harding.edu>
Date: Wed, 23 Mar 2016 20:57:25 -0500
Subject: [PATCH] fully-fledged std::bind expression parser

---
 include/callable_traits/any_arg.hpp           |  37 ++++
 include/callable_traits/arity.hpp             |  21 +-
 include/callable_traits/bind_args_t.hpp       | 108 ----------
 include/callable_traits/bind_expression.hpp   | 193 ++++++++++++++++++
 .../bind_expression_parser.hpp                | 165 +++++++++++++++
 include/callable_traits/callable_traits.hpp   |  21 +-
 .../callable_traits/categorize_bind_arg.hpp   |  27 +++
 ...args_t_fwd.hpp => bind_expression_fwd.hpp} |   8 +-
 .../callable_traits/is_bind_expression.hpp    |  31 +++
 .../callable_traits/placeholder_routes.hpp    |  38 ++--
 include/callable_traits/prepend.hpp           |  35 ++++
 .../remove_duplicate_placeholders.hpp         |   4 +-
 include/callable_traits/sort_tuple.hpp        |  29 ++-
 include/callable_traits/traits.hpp            |   1 +
 include/callable_traits/tuple_group_by.hpp    | 122 +++++++++++
 test/{bind_args.cpp => bind_expression.cpp}   |  46 ++---
 test/bind_expression_parser.cpp               | 165 +++++++++++++++
 17 files changed, 844 insertions(+), 207 deletions(-)
 create mode 100644 include/callable_traits/any_arg.hpp
 delete mode 100644 include/callable_traits/bind_args_t.hpp
 create mode 100644 include/callable_traits/bind_expression.hpp
 create mode 100644 include/callable_traits/bind_expression_parser.hpp
 rename include/callable_traits/fwd/{bind_args_t_fwd.hpp => bind_expression_fwd.hpp} (67%)
 create mode 100644 include/callable_traits/is_bind_expression.hpp
 create mode 100644 include/callable_traits/prepend.hpp
 create mode 100644 include/callable_traits/tuple_group_by.hpp
 rename test/{bind_args.cpp => bind_expression.cpp} (73%)
 create mode 100644 test/bind_expression_parser.cpp

diff --git a/include/callable_traits/any_arg.hpp b/include/callable_traits/any_arg.hpp
new file mode 100644
index 0000000..123e56b
--- /dev/null
+++ b/include/callable_traits/any_arg.hpp
@@ -0,0 +1,37 @@
+ /*!
+@file
+
+@copyright Barrett Adair 2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+
+*/
+
+#ifndef CALLABLE_TRAITS_ANY_ARG_HPP
+#define CALLABLE_TRAITS_ANY_ARG_HPP
+
+namespace callable_traits {
+
+    namespace ctdetail {
+
+        //any_arg is only used in unevaluated contexts
+        template<std::size_t I = 0>
+        struct any_arg {
+
+            template<typename T>
+            operator T& () const;
+
+            template<typename T>
+            operator T&& () const;
+
+            any_arg() = default;
+
+#if !defined(_MSC_VER)
+            template<typename... T>
+            any_arg(T&&...);
+#endif //!defined(_MSC_VER)
+        };
+    }
+}
+
+#endif //CALLABLE_TRAITS_ANY_ARG_HPP
\ No newline at end of file
diff --git a/include/callable_traits/arity.hpp b/include/callable_traits/arity.hpp
index 41f0975..0a3a650 100644
--- a/include/callable_traits/arity.hpp
+++ b/include/callable_traits/arity.hpp
@@ -12,32 +12,13 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <callable_traits/disjunction.hpp>
 #include <callable_traits/can_invoke_t.hpp>
+#include <callable_traits/any_arg.hpp>
 #include <cstdint>
 
 namespace callable_traits {
 
     namespace ctdetail {
 
-        //any_arg is only used in unevaluated contexts
-        template<std::size_t I>
-        struct any_arg {
-
-            template<typename T>
-            operator T& () const;
-
-            template<typename T>
-            operator T&& () const;
-
-            any_arg() = default;
-
-#if !defined(_MSC_VER)
-            template<typename... T>
-            any_arg(T&&...);
-#endif
-        };
-
-
-
         template<typename, typename>
         struct max_args {
             static constexpr bool value = true;
diff --git a/include/callable_traits/bind_args_t.hpp b/include/callable_traits/bind_args_t.hpp
deleted file mode 100644
index 7651a86..0000000
--- a/include/callable_traits/bind_args_t.hpp
+++ /dev/null
@@ -1,108 +0,0 @@
-/*!
-Copyright (c) 2001-2004 Peter Dimov and Multi Media Ltd.
-Copyright (c) 2001 David Abrahams
-Copyright (c) 2005 Peter Dimov
-Copyright (c) 2016 Barrett Adair
-
-Distributed under the Boost Software License, Version 1.0.
-(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
-*/
-
-#ifndef CALLABLE_TRAITS_BIND_WRAPPER_HPP
-#define CALLABLE_TRAITS_BIND_WRAPPER_HPP
-
-#include <callable_traits/traits.hpp>
-#include <callable_traits/categorize_bind_arg.hpp>
-#include <callable_traits/tags.hpp>
-#include <callable_traits/ph.hpp>
-#include <callable_traits/sort_tuple.hpp>
-#include <callable_traits/placeholder_routes.hpp>
-#include <callable_traits/remove_duplicate_placeholders.hpp>
-#include <callable_traits/fwd/bind_args_t_fwd.hpp>
-
-#include <tuple>
-#include <functional>
-
-namespace callable_traits {
-    
-    namespace ctdetail {
-
-        template<typename PhRouteLeft, typename PhRouteRight>
-        struct compare_input_index {
-            static constexpr bool value = 
-                PhRouteLeft::input_index < PhRouteRight::input_index;
-        };
-
-        template<typename PhRouteLeft, typename PhRouteRight>
-        struct compare_output_index {
-            static constexpr bool value = 
-                PhRouteLeft::output_index < PhRouteRight::output_index;
-        };
-
-        template <typename PhRoutesTuple, typename OriginalArgsTuple, typename Seq>
-        struct placeholders_mapped_to_original_signature;
-
-        template <typename PhRoutesTuple, typename OriginalArgsTuple,  std::size_t... I>
-        struct placeholders_mapped_to_original_signature<
-            PhRoutesTuple, OriginalArgsTuple, std::index_sequence<I...>> {
-
-            //this is where the magic happens
-            using type = std::tuple<
-                typename std::tuple_element<
-                    std::tuple_element<I, PhRoutesTuple>::type::output_index,
-                    OriginalArgsTuple
-                >::type...
-            >;
-        };
-
-        template <typename PhRoutesTuple, std::size_t... I>
-        struct placeholders_mapped_to_original_signature<
-            PhRoutesTuple, std::tuple<>, std::index_sequence<I...>> {
-            using type = std::tuple<>;
-        };
-
-        template <typename T, std::size_t... I>
-        struct placeholders_mapped_to_original_signature<
-            T, std::tuple<ambiguous_type>, std::index_sequence<I...>> {
-            using type = std::tuple<ambiguous_type>;
-        };
-
-        template<typename Callable, typename... Args>
-        struct bind_args_t {
-
-        private:
-
-            using bind_args_tuple = std::tuple<
-                typename categorize_bind_arg<Args>::type...
-            >;
-
-            using placeholder_route_map = typename placeholder_routes<
-                bind_args_tuple
-            >::type;
-
-            using sorted_placeholder_routes =
-                typename remove_duplicate_placeholders<
-                    sort_tuple<
-                        placeholder_route_map,
-                        compare_input_index
-                    >
-                >::type;
-
-            using placeholder_count = std::tuple_size<
-                sorted_placeholder_routes
-            >;
-
-            using original_args = typename traits<Callable>::arg_types;
-
-        public:
-
-            using type = typename placeholders_mapped_to_original_signature<
-                sorted_placeholder_routes,
-                original_args,
-                std::make_index_sequence<placeholder_count::value>
-            >::type;
-        };
-    }
-}
-
-#endif
\ No newline at end of file
diff --git a/include/callable_traits/bind_expression.hpp b/include/callable_traits/bind_expression.hpp
new file mode 100644
index 0000000..3e4c95a
--- /dev/null
+++ b/include/callable_traits/bind_expression.hpp
@@ -0,0 +1,193 @@
+/*!
+Copyright (c) 2001-2004 Peter Dimov and Multi Media Ltd.
+Copyright (c) 2001 David Abrahams
+Copyright (c) 2005 Peter Dimov
+Copyright (c) 2016 Barrett Adair
+
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef CALLABLE_TRAITS_BIND_EXPRESSION_HPP
+#define CALLABLE_TRAITS_BIND_EXPRESSION_HPP
+
+#include <callable_traits/traits.hpp>
+#include <callable_traits/categorize_bind_arg.hpp>
+#include <callable_traits/tags.hpp>
+#include <callable_traits/ph.hpp>
+#include <callable_traits/sort_tuple.hpp>
+#include <callable_traits/placeholder_routes.hpp>
+#include <callable_traits/remove_duplicate_placeholders.hpp>
+#include <callable_traits/fwd/bind_expression_fwd.hpp>
+#include <callable_traits/prepend.hpp>
+#include <callable_traits/private_tuple.hpp>
+
+#include <tuple>
+#include <functional>
+
+namespace callable_traits {
+    
+    namespace ctdetail {
+
+        template<typename PhRouteLeft, typename PhRouteRight>
+        struct compare_ph_value {
+            static constexpr bool value = 
+                PhRouteLeft::ph_value < PhRouteRight::ph_value;
+        };
+
+        template <typename PhRoutesTuple, typename OriginalArgsTuple, typename Seq>
+        struct placeholders_mapped_to_original_signature;
+
+        template <typename PhRoutesTuple, typename OriginalArgsTuple,  std::size_t... I>
+        struct placeholders_mapped_to_original_signature<
+            PhRoutesTuple, OriginalArgsTuple, std::index_sequence<I...>> {
+
+            //this is where the magic happens
+            using type = std::tuple<
+                typename std::tuple_element<
+                    std::tuple_element<I, PhRoutesTuple>::type::original_arg_index,
+                    OriginalArgsTuple
+                >::type...
+            >;
+        };
+
+        template <typename PhRoutesTuple, std::size_t... I>
+        struct placeholders_mapped_to_original_signature<
+            PhRoutesTuple, std::tuple<>, std::index_sequence<I...>> {
+            using type = std::tuple<>;
+        };
+
+        template <typename T, std::size_t... I>
+        struct placeholders_mapped_to_original_signature<
+            T, std::tuple<ambiguous_type>, std::index_sequence<I...>> {
+            using type = std::tuple<ambiguous_type>;
+        };
+
+        template <typename...> struct bind_expressions_filter;
+
+        template <> struct bind_expressions_filter<> { using type = std::tuple<>; };
+
+        template <typename Head, typename... Tail>
+        struct bind_expressions_filter<Head, Tail...> {
+            using type = typename bind_expressions_filter<Tail...>::type;
+        };
+
+        template<typename Callable, typename... BindExprArgs, typename ...Tail>
+        struct bind_expressions_filter<
+            bind_expression<Callable, BindExprArgs...>, Tail...
+        > {
+            using type = typename prepend<
+                bind_expression<Callable, BindExprArgs...>,
+                typename bind_expressions_filter<Tail...>::type
+            >::type;
+        };
+
+        template <typename... Ts>
+        struct remove_non_bind_expressions {
+            using type = typename bind_expressions_filter<Ts...>::type;
+        };
+
+        template<typename T>
+        struct is_empty_tuple {
+            using value_type = std::false_type;
+        };
+
+        template<>
+        struct is_empty_tuple<std::tuple<>> {
+            using value_type = std::true_type;
+        };
+
+        template<typename T>
+        struct is_not_empty_tuple {
+            using value_type = std::true_type;
+        };
+
+        template<>
+        struct is_not_empty_tuple<std::tuple<>> {
+            using value_type = std::false_type;
+        };
+
+        template <typename BindExpr, typename = std::true_type>
+        struct flatten_bind_expressions;
+
+        template <typename... BindExprs>
+        struct flatten_bind_expressions<
+            std::tuple<BindExprs...>,
+            std::true_type
+        > {
+            using type = decltype(std::tuple_cat(
+                std::declval<typename flatten_bind_expressions<BindExprs>::type>()...
+            ));
+        };
+
+        template <typename BindExpr>
+        struct flatten_bind_expressions<
+            BindExpr,
+            typename is_not_empty_tuple<typename BindExpr::inner_bind_expressions>::value_type
+        > {
+            using type = typename prepend<
+                BindExpr,
+                typename flatten_bind_expressions<
+                    typename BindExpr::inner_bind_expressions
+                >::type
+            >::type;
+        };
+
+        //base case - bind expression has no inner bind expressions
+        template <typename BindExpr>
+        struct flatten_bind_expressions<
+            BindExpr,
+            typename is_empty_tuple<typename BindExpr::inner_bind_expressions>::value_type
+        > {
+            using type = std::tuple<BindExpr>;
+        };
+
+        template<typename Callable, typename... Args>
+        struct bind_expression {
+
+            using bind_args_tuple = std::tuple<
+                typename categorize_bind_arg<Args>::type...
+            >;
+
+            using inner_bind_expressions =
+                typename remove_non_bind_expressions<Args...>::type;
+
+            using has_inner_bind_expressions = std::is_same<
+                inner_bind_expressions, std::tuple<>
+            >;
+
+            using flattened_bind_expressions =
+                typename flatten_bind_expressions<bind_expression>::type;
+
+            using placeholder_route_map = typename placeholder_routes<
+                bind_expression,
+                bind_args_tuple
+            >::type;
+
+            using sorted_placeholder_routes =
+                typename remove_duplicate_placeholders<
+                    sort_tuple<
+                        placeholder_route_map,
+                        compare_ph_value
+                    >
+                >::type;
+
+            using placeholder_count = std::tuple_size<
+                sorted_placeholder_routes
+            >;
+
+            using original_args = typename traits<Callable>::arg_types;
+
+            /*using arg_types = typename placeholders_mapped_to_original_signature<
+                sorted_placeholder_routes,
+                original_args,
+                std::make_index_sequence<placeholder_count::value>
+            >::type;*/
+
+            using return_type = typename traits<Callable>::return_type;
+        };
+
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/include/callable_traits/bind_expression_parser.hpp b/include/callable_traits/bind_expression_parser.hpp
new file mode 100644
index 0000000..2fefb30
--- /dev/null
+++ b/include/callable_traits/bind_expression_parser.hpp
@@ -0,0 +1,165 @@
+/*!
+Copyright (c) 2001-2004 Peter Dimov and Multi Media Ltd.
+Copyright (c) 2001 David Abrahams
+Copyright (c) 2005 Peter Dimov
+Copyright (c) 2016 Barrett Adair
+
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef CALLABLE_TRAITS_BIND_EXPRESSION_PARSER_HPP
+#define CALLABLE_TRAITS_BIND_EXPRESSION_PARSER_HPP
+
+#include <callable_traits/traits.hpp>
+#include <callable_traits/tuple_group_by.hpp>
+#include <callable_traits/sort_tuple.hpp>
+#include <callable_traits/bind_expression.hpp>
+#include <tuple>
+#include <functional>
+
+namespace callable_traits {
+    
+    namespace ctdetail {
+
+        template<typename BindExpressionTuple>
+        struct combined_placeholder_routes;
+
+        template<typename... BindExprs>
+        struct combined_placeholder_routes<std::tuple<BindExprs...>> {
+
+            using placeholder_route_map = decltype(std::tuple_cat(std::declval<
+                typename placeholder_routes<
+                    BindExprs,
+                    typename BindExprs::bind_args_tuple
+            >::type>()...));
+
+            using type = sort_tuple<
+                placeholder_route_map,
+                compare_ph_value
+            >;
+        };
+
+        template<typename T>
+        struct ph_value_wrapper {
+            static constexpr const auto value = T::ph_value;
+        };
+
+        template <typename...> struct filter_invalid_args;
+
+        template <> struct filter_invalid_args<> {
+            using type = std::tuple<>;
+        };
+
+        template <typename Head, typename ...Tail>
+        struct filter_invalid_args<Head, Tail...> {
+
+            static constexpr const auto is_legal_arg =
+                !std::is_same<Head, any_arg<>>{}
+                && !std::is_same<Head, ambiguous_type>{}
+                && !std::is_same<Head, invalid_type>{};
+
+            using type = typename std::conditional<
+                is_legal_arg,
+                typename prepend<Head, typename filter_invalid_args<Tail...>::type>::type,
+                typename filter_invalid_args<Tail...>::type
+            >::type;
+        };
+
+        template<typename Tup>
+        struct valid_args;
+
+        template<typename... Ts>
+        struct valid_args<std::tuple<Ts...>> {
+            using filtered_args = typename filter_invalid_args<Ts...>::type;
+            using type = typename std::conditional<
+                std::is_same<filtered_args, std::tuple<>>::value,
+                std::tuple<ambiguous_type>,
+                filtered_args
+            >::type;
+        };
+
+        template <class ...T> struct common_type;
+ 
+        template <class T>
+        struct common_type<T> {
+            using type = T;
+        };
+         
+        template <class T, class U>
+        struct common_type<T, U> {
+
+            using type = typename std::conditional<
+                std::is_convertible<T, U>::value,
+                U,
+                typename std::conditional<
+                    std::is_convertible<U, T>::value,
+                    T,
+                    decltype(true ? std::declval<T>() : std::declval<U>())
+                >::type
+            >::type;
+        };
+         
+        template <class T, class U, class... V>
+        struct common_type<T, U, V...> {
+            using type = typename common_type<typename common_type<T, U>::type, V...>::type;
+        };
+
+        template<typename Tup>
+        struct custom_common_type;
+
+        template<typename... Ts>
+        struct custom_common_type<std::tuple<Ts...>> {
+            using type = typename common_type<Ts...>::type;
+        };
+
+        template<typename Tup>
+        struct common_expected_arg_types;
+
+        template<typename... PhRoutes, typename... OtherGroupTuples>
+        struct common_expected_arg_types<std::tuple<std::tuple<PhRoutes...>, OtherGroupTuples...>> {
+
+            using expected_types = std::tuple<
+                typename std::tuple_element<
+                    PhRoutes::original_arg_index,
+                    typename PhRoutes::expression::original_args
+                >::type...
+            >;
+
+            using type = typename prepend<
+                typename custom_common_type<typename valid_args<expected_types>::type>::type,
+                typename common_expected_arg_types<std::tuple<OtherGroupTuples...>>::type
+            >::type;
+        };
+
+        template<>
+        struct common_expected_arg_types<std::tuple<>> {
+            using type = std::tuple<>;
+        };
+
+        template<typename BindExpr>
+        struct bind_expression_parser;
+
+        template<typename Callable, typename... Args>
+        struct bind_expression_parser<bind_expression<Callable, Args...>> {
+
+            using root_expression = bind_expression<Callable, Args...>;
+
+            using flattened_bind_expressions =
+                typename root_expression::flattened_bind_expressions;
+
+            using placeholder_routes = typename combined_placeholder_routes<
+                flattened_bind_expressions
+            >::type;
+
+            using grouped_placeholders = tuple_group_by<
+                placeholder_routes,
+                ph_value_wrapper
+            >;
+
+            using arg_types = typename common_expected_arg_types<grouped_placeholders>::type;
+        };
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/include/callable_traits/callable_traits.hpp b/include/callable_traits/callable_traits.hpp
index 5622e5c..186c4a4 100644
--- a/include/callable_traits/callable_traits.hpp
+++ b/include/callable_traits/callable_traits.hpp
@@ -23,7 +23,9 @@ Distributed under the Boost Software License, Version 1.0.
 #include <callable_traits/can_invoke_t.hpp>
 #include <callable_traits/substitution.hpp>
 #include <callable_traits/arity.hpp>
-#include <callable_traits/bind_args_t.hpp>
+#include <callable_traits/bind_expression.hpp>
+#include <callable_traits/bind_expression_parser.hpp>
+#include <callable_traits/is_bind_expression.hpp>
 
 //todo remove?
 #include <callable_traits/can_invoke_t.hpp>
@@ -39,8 +41,15 @@ namespace callable_traits {
         return{};
     }
 
-    template<typename T>
-    using args = typename ctdetail::traits<T>::arg_types;
+    template<
+        typename T,
+        typename U = typename std::remove_cv<typename std::remove_reference<T>::type>::type
+    >
+    using args = typename std::conditional<
+        ctdetail::is_bind_expression<U>::value,
+        ctdetail::bind_expression_parser<U>,
+        ctdetail::traits<T>
+    >::type::arg_types;
 
     template<size_t Index, typename T>
     using arg_at = typename std::tuple_element<Index, args<T>>::type;
@@ -116,8 +125,10 @@ namespace callable_traits {
     }
 
     template<typename Callable, typename... Args>
-    auto bind_args(Callable, Args...) ->
-        typename ctdetail::bind_args_t<Callable, Args...>::type;
+    auto bind_expr(Callable, Args...) ->
+        ctdetail::bind_expression<Callable, Args...> {
+        return{};
+    }
 }
 
 #endif
\ No newline at end of file
diff --git a/include/callable_traits/categorize_bind_arg.hpp b/include/callable_traits/categorize_bind_arg.hpp
index 02aa459..d01d1f9 100644
--- a/include/callable_traits/categorize_bind_arg.hpp
+++ b/include/callable_traits/categorize_bind_arg.hpp
@@ -9,6 +9,9 @@ Distributed under the Boost Software License, Version 1.0.
 */
 
 #include <callable_traits/ph.hpp>
+#include <callable_traits/fwd/bind_expression_fwd.hpp>
+#include <callable_traits/any_arg.hpp>
+#include <callable_traits/tags.hpp>
 #include <functional>
 
 namespace callable_traits {
@@ -25,21 +28,45 @@ namespace callable_traits {
                 bind_value<T>,
                 ph<std::is_placeholder< T >::value>
             >::type;
+
+            using bind_expression = invalid_type;
+            using is_bind_expression = std::false_type;
         };
 
         template<typename T>
         struct categorize_bind_arg< bind_value<T> > {
             using type = ctdetail::bind_value<T>;
+            using bind_expression = invalid_type;
+            using is_bind_expression = std::false_type;
         };
 
         template<typename T>
         struct categorize_bind_arg< std::reference_wrapper<T> > {
             using type = std::reference_wrapper<T>;
+            using bind_expression = invalid_type;
+            using is_bind_expression = std::false_type;
         };
 
         template<int I>
         struct categorize_bind_arg< ph<I> > {
             using type = ph<I>;
+            using bind_expression = invalid_type;
+            using is_bind_expression = std::false_type;
+        };
+
+        template<typename Callable, typename... Args>
+        struct categorize_bind_arg<bind_expression<Callable, Args...>> {
+
+            using return_type =  typename bind_expression<Callable, Args...>::return_type;
+
+            using type = typename std::conditional<
+                std::is_same<return_type, ambiguous_type>::value,
+                any_arg<>,
+                return_type
+            >::type;
+
+            using bind_expression = bind_expression<Callable, Args...>;
+            using is_bind_expression = std::true_type;
         };
     }
 }
\ No newline at end of file
diff --git a/include/callable_traits/fwd/bind_args_t_fwd.hpp b/include/callable_traits/fwd/bind_expression_fwd.hpp
similarity index 67%
rename from include/callable_traits/fwd/bind_args_t_fwd.hpp
rename to include/callable_traits/fwd/bind_expression_fwd.hpp
index 8ffbd8f..bcdf661 100644
--- a/include/callable_traits/fwd/bind_args_t_fwd.hpp
+++ b/include/callable_traits/fwd/bind_expression_fwd.hpp
@@ -5,15 +5,15 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
 */
 
-#ifndef CALLABLE_TRAITS_FWD_BIND_ARGS_T_FWD_HPP
-#define CALLABLE_TRAITS_FWD_BIND_ARGS_T_FWD_HPP
+#ifndef CALLABLE_TRAITS_FWD_BIND_EXPRESSION_FWD_HPP
+#define CALLABLE_TRAITS_FWD_BIND_EXPRESSION_FWD_HPP
 
 namespace callable_traits {
 
     namespace ctdetail {
-
+        
         template<typename Callable, typename... Args>
-        struct bind_args_t;
+        struct bind_expression;
 
     }
 }
diff --git a/include/callable_traits/is_bind_expression.hpp b/include/callable_traits/is_bind_expression.hpp
new file mode 100644
index 0000000..43c431e
--- /dev/null
+++ b/include/callable_traits/is_bind_expression.hpp
@@ -0,0 +1,31 @@
+ /*!
+@file
+
+@copyright Barrett Adair 2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+
+*/
+
+#ifndef CALLABLE_TRAITS_IS_BIND_EXPRESSION_HPP
+#define CALLABLE_TRAITS_IS_BIND_EXPRESSION_HPP
+
+#include <callable_traits/bind_expression.hpp>
+
+namespace callable_traits {
+
+    namespace ctdetail {
+
+        template<typename T>
+        struct is_bind_expression {
+            static constexpr const bool value = false;
+        };
+
+        template<typename Callable, typename... Args>
+        struct is_bind_expression<bind_expression<Callable, Args...>> {
+            static constexpr const bool value = true;
+        };
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/include/callable_traits/placeholder_routes.hpp b/include/callable_traits/placeholder_routes.hpp
index b4988a5..102d411 100644
--- a/include/callable_traits/placeholder_routes.hpp
+++ b/include/callable_traits/placeholder_routes.hpp
@@ -8,23 +8,27 @@ Distributed under the Boost Software License, Version 1.0.
 #ifndef CALLABLE_TRAITS_BIND_PLACEHOLDER_ROUTES_HPP
 #define CALLABLE_TRAITS_BIND_PLACEHOLDER_ROUTES_HPP
 
+#include <callable_traits/prepend.hpp>
+
 namespace callable_traits { 
 
     namespace ctdetail { 
 
-        template<std::size_t OutputIndex, std::size_t InputIndex>
+        template<typename Expression, std::size_t OriginalArgIndex, std::size_t PhValue>
         struct ph_route {
-            static constexpr const auto output_index = OutputIndex;
-            static constexpr const auto input_index = InputIndex;
+            using expression = Expression;
+            static constexpr const auto original_arg_index = OriginalArgIndex;
+            static constexpr const auto ph_value = PhValue;
         };
 
-        template<typename, typename> struct argument_routing {};
+        template<typename Expression, typename, typename> struct argument_routing {};
 
-        template<std::size_t... I, typename Tuple>
-        struct argument_routing<std::index_sequence<I...>, Tuple> {
+        template<typename Expression, std::size_t... I, typename Tuple>
+        struct argument_routing<Expression, std::index_sequence<I...>, Tuple> {
             using type =
                 std::tuple<
                     ph_route<
+                        Expression,
                         I,
                         std::is_placeholder<
                             typename std::tuple_element<I, Tuple>::type
@@ -33,17 +37,6 @@ namespace callable_traits {
                 >;
         };
 
-        template <typename...> struct prepend;
-
-        template <> struct prepend<> {
-            using type = std::tuple<>;
-        };
-
-        template <typename T, typename... Args>
-        struct prepend<T, std::tuple<Args...> > {
-            using type = std::tuple<T, Args...>;
-        };
-
         //base case
         template <typename...> struct placeholder_routes_detail;
         template <> struct placeholder_routes_detail<> {
@@ -54,7 +47,7 @@ namespace callable_traits {
         struct placeholder_routes_detail<Head, Tail...> {
             //TODO - is there a faster way to do this?
             using type = typename std::conditional<
-                Head::input_index == 0,
+                Head::ph_value == 0,
                 typename placeholder_routes_detail<Tail...>::type,
                 typename prepend<
                     Head,
@@ -74,14 +67,15 @@ namespace callable_traits {
                 std::is_placeholder<PhLeft>::value < std::is_placeholder<PhRight>::value;
         };
 
-        template <typename...> struct placeholder_routes;
-        template <> struct placeholder_routes<> { using type = std::tuple<>; };
+        template <typename Expression, typename...> struct placeholder_routes;
+        template <typename Expression> struct placeholder_routes<Expression> { using type = std::tuple<>; };
 
-        template <typename... Args>
-        struct placeholder_routes<std::tuple<Args...> >
+        template <typename Expression, typename... Args>
+        struct placeholder_routes<Expression, std::tuple<Args...> >
         {
             using routed_placeholders = typename placeholder_routes_detail<
                 typename argument_routing<
+                    Expression,
                     std::make_index_sequence<sizeof...(Args)>,
                     std::tuple<Args...>
                 >::type
diff --git a/include/callable_traits/prepend.hpp b/include/callable_traits/prepend.hpp
new file mode 100644
index 0000000..b5fbc36
--- /dev/null
+++ b/include/callable_traits/prepend.hpp
@@ -0,0 +1,35 @@
+/*!
+@copyright Barrett Adair 2016
+
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef CALLABLE_TRAITS_PREPEND_HPP
+#define CALLABLE_TRAITS_PREPEND_HPP
+
+#include <callable_traits/private_tuple.hpp>
+
+namespace callable_traits { 
+
+    namespace ctdetail { 
+
+        template <typename...> struct prepend;
+
+        template <> struct prepend<> {
+            using type = std::tuple<>;
+        };
+
+        template <typename T, typename... Args>
+        struct prepend<T, std::tuple<Args...> > {
+            using type = std::tuple<T, Args...>;
+        };
+
+        template <typename T, typename... Args>
+        struct prepend<T, private_tuple<Args...> > {
+            using type = private_tuple<T, Args...>;
+        };
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/include/callable_traits/remove_duplicate_placeholders.hpp b/include/callable_traits/remove_duplicate_placeholders.hpp
index e628c1c..b19b7ee 100644
--- a/include/callable_traits/remove_duplicate_placeholders.hpp
+++ b/include/callable_traits/remove_duplicate_placeholders.hpp
@@ -26,7 +26,7 @@ namespace callable_traits {
         template<typename PhRoute1, typename PhRoute2, typename... Tail>
         struct remove_duplicate_placeholders<PhRoute1, PhRoute2, Tail...> {
             using type = typename std::conditional<
-                PhRoute1::input_index == PhRoute2::input_index,
+                PhRoute1::ph_value == PhRoute2::ph_value,
                 typename remove_duplicate_placeholders<PhRoute1, Tail...>::type,
                 typename prepend<PhRoute1, typename remove_duplicate_placeholders<PhRoute2, Tail...>::type>::type
             >::type;
@@ -36,7 +36,7 @@ namespace callable_traits {
         template<typename PhRoute1, typename PhRoute2>
         struct remove_duplicate_placeholders<PhRoute1, PhRoute2> {
             using type = typename std::conditional<
-                PhRoute1::input_index == PhRoute2::input_index,
+                PhRoute1::ph_value == PhRoute2::ph_value,
                 std::tuple<PhRoute1>,
                 std::tuple<PhRoute1, PhRoute2>
             >::type;
diff --git a/include/callable_traits/sort_tuple.hpp b/include/callable_traits/sort_tuple.hpp
index 99957c4..5474166 100644
--- a/include/callable_traits/sort_tuple.hpp
+++ b/include/callable_traits/sort_tuple.hpp
@@ -18,17 +18,16 @@ namespace callable_traits {
 
     namespace ctdetail {
 
-        using index = std::size_t;
         using empty_seq = std::index_sequence<>;
 
-        template <typename Pred, index Insert, bool IsInsertionPoint,
-            typename Left, index ...Right>
+        template <typename Pred, std::size_t Insert, bool IsInsertionPoint,
+            typename Left, std::size_t ...Right>
         struct insert;
 
         // We did not find the insertion point; continue processing elements
         // recursively.
-        template <typename Pred, index Insert, index ...Left,
-            index Right1, index Right2, index ...Right>
+        template <typename Pred, std::size_t Insert, std::size_t ...Left,
+            std::size_t Right1, std::size_t Right2, std::size_t ...Right>
         struct insert<Pred, Insert, false, std::index_sequence<Left...>,
             Right1, Right2, Right...> {
             using type = typename insert<
@@ -40,22 +39,22 @@ namespace callable_traits {
 
         // We did not find the insertion point, but there is only one element
         // left. We insert at the end of the list, and we're done.
-        template <typename Pred, index Insert, index ...Left, index Last>
+        template <typename Pred, std::size_t Insert, std::size_t ...Left, std::size_t Last>
         struct insert<Pred, Insert, false, std::index_sequence<Left...>, Last> {
             using type = std::index_sequence<Left..., Last, Insert>;
         };
 
         // We found the insertion point, we're done.
-        template <typename Pred, index Insert, index ...Left, index ...Right>
+        template <typename Pred, std::size_t Insert, std::size_t ...Left, std::size_t ...Right>
         struct insert<Pred, Insert, true, std::index_sequence<Left...>, Right...> {
             using type = std::index_sequence<Left..., Insert, Right...>;
         };
 
-        template <typename Pred, typename Result, index ...T>
+        template <typename Pred, typename Result, std::size_t ...T>
         struct insertion_sort;
 
-        template <typename Pred, index Result1, index ...Results,
-            index T, index ...Ts>
+        template <typename Pred, std::size_t Result1, std::size_t ...Results,
+            std::size_t T, std::size_t ...Ts>
         struct insertion_sort<Pred, std::index_sequence<Result1, Results...>, T, Ts...> {
             static constexpr bool pred_result = Pred::template apply<T, Result1>::value;
             using insert_result = typename insert<
@@ -64,7 +63,7 @@ namespace callable_traits {
             using type = typename insertion_sort<Pred, insert_result, Ts...>::type;
         };
 
-        template <typename Pred, index T, index ...Ts>
+        template <typename Pred, std::size_t T, std::size_t ...Ts>
         struct insertion_sort<Pred, empty_seq, T, Ts...> {
             using type = typename insertion_sort<
                 Pred, std::index_sequence<T>, Ts...
@@ -79,26 +78,26 @@ namespace callable_traits {
         template <typename Pred, typename Indices>
         struct sort_indices;
 
-        template <typename Pred, index ...i>
+        template <typename Pred, std::size_t ...i>
         struct sort_indices<Pred, std::index_sequence<i...>> {
             using type = typename insertion_sort<Pred, empty_seq, i...>::type;
         };
 
         template<typename Tup, typename Pred>
         struct sort_impl {
-            static constexpr index len = std::tuple_size<Tup>::value;
+            static constexpr std::size_t len = std::tuple_size<Tup>::value;
             using indices = typename sort_indices<Pred, std::make_index_sequence<len>>::type;
             using type = typename sort_impl<Tup, indices>::type;
         };
 
-        template <typename Tup, index ...i>
+        template <typename Tup, std::size_t ...i>
         struct sort_impl<Tup, std::index_sequence<i...>> {
             using type = std::tuple<typename std::tuple_element<i, Tup>::type...>;
         };
 
         template <typename Tup, template<class, class> class Pred>
         struct predicate {
-            template <index I, index J>
+            template <std::size_t I, std::size_t J>
             using apply = Pred<
                 typename std::tuple_element<I, Tup>::type,
                 typename std::tuple_element<J, Tup>::type
diff --git a/include/callable_traits/traits.hpp b/include/callable_traits/traits.hpp
index 9b73fee..ae558cb 100644
--- a/include/callable_traits/traits.hpp
+++ b/include/callable_traits/traits.hpp
@@ -19,6 +19,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <callable_traits/fwd/pmf_fwd.hpp>
 #include <callable_traits/fwd/function_fwd.hpp>
 #include <callable_traits/fwd/function_object_fwd.hpp>
+#include <callable_traits/fwd/bind_expression_fwd.hpp>
 
 #include <type_traits>
 
diff --git a/include/callable_traits/tuple_group_by.hpp b/include/callable_traits/tuple_group_by.hpp
new file mode 100644
index 0000000..74c2b07
--- /dev/null
+++ b/include/callable_traits/tuple_group_by.hpp
@@ -0,0 +1,122 @@
+/*!
+@file
+
+@coyright Modified Work Barrett Adair 2016
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef CALLABLE_TRAITS_TUPLE_GROUP_BY_HPP
+#define CALLABLE_TRAITS_TUPLE_GROUP_BY_HPP
+
+#include <callable_traits/sort_tuple.hpp>
+#include <callable_traits/prepend.hpp>
+#include <tuple>
+#include <type_traits>
+
+namespace callable_traits { 
+
+    namespace ctdetail {
+
+        template<typename T, template<class> class Pred>
+        struct group_by_value {
+            static constexpr auto value = Pred<T>::value;
+        };
+
+        template<typename Tup, template<class> class Pred>
+        struct distinct_group_by_values;
+
+        template<typename Last, template<class> class Pred>
+        struct distinct_group_by_values<std::tuple<Last>, Pred> {
+            using type = std::tuple<group_by_value<Last, Pred>>;
+        };
+
+        template<typename Head, typename Next, typename... Tail, template<class> class Pred>
+        struct distinct_group_by_values<std::tuple<Head, Next, Tail...>, Pred> {
+
+            static constexpr const auto is_in_same_group =
+                Pred<Head>::value == Pred<Next>::value;
+
+            using next = typename distinct_group_by_values<std::tuple<Next, Tail...>, Pred>::type;
+
+            using type = typename std::conditional<
+                is_in_same_group,
+                next,
+                typename prepend<group_by_value<Head, Pred>, next>::type
+            >::type;
+        };
+
+        template <typename Pred, typename...> struct group_by_filter_impl;
+
+        template <typename Pred> struct group_by_filter_impl<Pred> {
+            using type = std::tuple<>;
+        };
+
+        template <typename Pred, typename Head, typename ...Tail>
+        struct group_by_filter_impl<Pred, Head, Tail...> {
+            using type = typename std::conditional<
+                decltype(std::declval<Pred>()(std::declval<Head>()))::value,
+                typename prepend<Head, typename group_by_filter_impl<Pred, Tail...>::type>::type,
+                typename group_by_filter_impl<Pred, Tail...>::type
+            >::type;
+        };
+
+        template <typename Pred, typename Tup>
+        struct group_by_filter;
+
+        template <typename Pred, typename... Ts>
+        struct group_by_filter<Pred, std::tuple<Ts...>> {
+            using type = typename group_by_filter_impl<Pred, Ts...>::type;
+        };
+
+        template<typename DistinctGroupByValues, template<class> class Pred, std::size_t I>
+        struct filter_predicate {
+
+            using compare_against =
+                typename std::tuple_element<I, DistinctGroupByValues>::type;
+
+            template<typename T>
+            auto operator()(T) ->
+                std::integral_constant<bool, Pred<T>::value == compare_against::value>;
+        };
+
+        template<typename Tup, typename DistinctGroupByValues, template<class> class Pred, typename ValuesSeq>
+        struct group_by_impl;
+
+        template<typename Tup, typename DistinctGroupByValues, template<class> class Pred, std::size_t... I>
+        struct group_by_impl<Tup, DistinctGroupByValues, Pred, std::index_sequence<I...>> {
+
+            using type = std::tuple<
+                typename group_by_filter<
+                    filter_predicate<DistinctGroupByValues, Pred, I>,
+                    Tup
+                >::type...
+            >;
+        };
+
+        template<typename Tup, template<class> class Pred>
+        struct group_by_t {
+
+            template<typename T, typename U>
+            struct sort_predicate {
+                static constexpr const auto left = Pred<T>::value;
+                static constexpr const auto right = Pred<U>::value;
+                static constexpr const bool value = left < right;
+            };
+
+            using group_by_values = typename distinct_group_by_values<Tup, Pred>::type;
+
+            using type = typename group_by_impl<
+                sort_tuple<Tup, sort_predicate>,
+                group_by_values,
+                Pred,
+                std::make_index_sequence<std::tuple_size<group_by_values>::value>
+            >::type;
+        };
+
+        template<typename Tup, template<class> class Pred>
+        using tuple_group_by = typename group_by_t<Tup, Pred>::type;
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/test/bind_args.cpp b/test/bind_expression.cpp
similarity index 73%
rename from test/bind_args.cpp
rename to test/bind_expression.cpp
index ca1d703..4eed23d 100644
--- a/test/bind_args.cpp
+++ b/test/bind_expression.cpp
@@ -71,7 +71,7 @@ apply(F&& f, Tuple&& t) {
         std::forward<F>(f),
         std::forward<Tuple>(t),
         std::make_index_sequence<
-            std::tuple_size<std::remove_reference_t<Tuple>>::value
+        std::tuple_size<std::remove_reference_t<Tuple>>::value
         >{}
     );
 }
@@ -89,61 +89,45 @@ int main() {
     assert(letters(a, b, c, d, e, f, g) == "ABCDEFG");
     assert(ordered_letters(a, b, c, d, e, f, g) == "ABCDEFG");
 
+
     {
-        using args = decltype(ct::bind_args(
-            &ordered_letters, _1, _2, _3, _4, _5, _6, _7));
+        auto expr = ct::bind_expr(&ordered_letters, _1, _2, _3, _4, _5, _6, _7);
+        using args = ct::args<decltype(expr)>;
         using expected_args = std::tuple<A, B, C, D, E, F, G>;
         CT_ASSERT(std::is_same<args, expected_args>{});
-
         auto test = std::bind(&ordered_letters, _1, _2, _3, _4, _5, _6, _7);
         assert(apply(test, expected_args{}) == "ABCDEFG");
-    } {   
-        using args = decltype(ct::bind_args(
-            &ordered_letters, a, b, c, _1, _2, _3, _4));
+    } {
+        auto expr = ct::bind_expr(&ordered_letters, a, b, c, _1, _2, _3, _4);
+        using args = ct::args<decltype(expr)>;
         using expected_args = std::tuple<D, E, F, G>;
         CT_ASSERT(std::is_same<args, expected_args>{});
-
         auto test = std::bind(&ordered_letters, a, b, c, _1, _2, _3, _4);
         assert(apply(test, expected_args{}) == "ABCDEFG");
     } {
-        using args = decltype(ct::bind_args(
-            &ordered_letters, _7, _6, _5, _4, _3, _2, _1));
+        auto expr = ct::bind_expr(&ordered_letters, _7, _6, _5, _4, _3, _2, _1);
+        using args = ct::args<decltype(expr)>;
         using expected_args = std::tuple<G, F, E, D, C, B, A>;
         CT_ASSERT(std::is_same<args, expected_args>{});
-
         auto test = std::bind(&ordered_letters, _7, _6, _5, _4, _3, _2, _1);
         assert(apply(test, expected_args{}) == "ABCDEFG");
     } {
-        using args = decltype(ct::bind_args(
-            &ordered_letters, a, b, c, _4, _3, _2, _1));
+        auto expr = ct::bind_expr(&ordered_letters, a, b, c, _4, _3, _2, _1);
+        using args = ct::args<decltype(expr)>;
         using expected_args = std::tuple<G, F, E, D>;
         CT_ASSERT(std::is_same<args, expected_args>{});
-
         auto test = std::bind(&ordered_letters, a, b, c, _4, _3, _2, _1);
         assert(apply(test, expected_args{}) == "ABCDEFG");
     } {
-        using args = decltype(ct::bind_args(
-            &ordered_letters, _4, _3, _2, _1, e, f, g));
+        auto expr = ct::bind_expr(&ordered_letters, _4, _3, _2, _1, e, f, g);
+        using args = ct::args<decltype(expr)>;
         using expected_args = std::tuple<D, C, B, A>;
         CT_ASSERT(std::is_same<args, expected_args>{});
-
         auto test = std::bind(&ordered_letters, _4, _3, _2, _1, e, f, g);
         assert(apply(test, expected_args{}) == "ABCDEFG");
     } {
-        //These aren't valid binds. Here we are testing the
-        //correctness of the arg_types alias in binding_wrapper.
-        using args = decltype(ct::bind_args(
-            &ordered_letters, _1, _1, _3, _3, _2, _1, _2));
-        using expected_args = std::tuple<A, E, C>;
-        CT_ASSERT(std::is_same<args, expected_args>{});
-    } {
-        using args = decltype(ct::bind_args(
-            &ordered_letters, _4, _1, _2, _3, _1, _2, _4));
-        using expected_args = std::tuple<B, C, D, A>;
-        CT_ASSERT(std::is_same<args, expected_args>{});
-    } {
-        using args = decltype(ct::bind_args(
-            &letters, _1, _1, _3, _3, _2, a, b));
+        auto expr = ct::bind_expr(&letters, _1, _1, _3, _3, _2, a, b);
+        using args = ct::args<decltype(expr)>;
         using expected_args = std::tuple<const Letter&, const Letter&, const Letter&>;
         CT_ASSERT(std::is_same<args, expected_args>{});
     }
diff --git a/test/bind_expression_parser.cpp b/test/bind_expression_parser.cpp
new file mode 100644
index 0000000..7768d45
--- /dev/null
+++ b/test/bind_expression_parser.cpp
@@ -0,0 +1,165 @@
+/*
+
+Copyright Barrett Adair 2016
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+
+*/
+
+#include <cassert>
+#include <type_traits>
+#include <functional>
+#include <iostream>
+#include <sstream>
+#include <memory>
+#include <iostream>
+#include <cstdint>
+#include <callable_traits/callable_traits.hpp>
+
+#ifndef CT_ASSERT
+#define CT_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+#endif //CT_ASSERT
+
+using namespace std::placeholders;
+namespace ct = callable_traits;
+
+struct Letter {
+    virtual operator const char*() const volatile = 0;
+};
+
+#define DEFINE_TEST_LETTER(L) \
+struct L : Letter { operator const char*() const volatile override { return #L; } }
+
+DEFINE_TEST_LETTER(A);
+DEFINE_TEST_LETTER(B);
+DEFINE_TEST_LETTER(C);
+DEFINE_TEST_LETTER(D);
+DEFINE_TEST_LETTER(E);
+DEFINE_TEST_LETTER(F);
+DEFINE_TEST_LETTER(G);
+
+// functions `ordered_letters`, `BEEF_returns_D`, `BEEF_returns_G`,
+// and `BEEF_returns_B` are used to set up a complex bind expression
+// with ct::bind_expr
+
+auto ordered_letters(A a, B b, C c, D d, E e, F f, G g) {
+    auto ss = std::stringstream{};
+    ss << a << b << c << d << e << f << g;
+    return ss.str();
+}
+
+auto BEEF_returns_D(B, E, E, F) {
+    return D{};
+}
+
+auto BEEF_returns_G(B, E, E, F) {
+    return G{};
+}
+
+auto BEEF_returns_B(B, E, E, F) {
+    return B{};
+}
+
+template <typename F, typename Tuple, std::size_t... I>
+constexpr decltype(auto)
+apply_helper(F&& f, Tuple&& t, std::index_sequence<I...>) {
+    return std::forward<F>(f)(std::get<I>(std::forward<Tuple>(t))...);
+}
+
+//used to apply the expected_args tuple to std::bind
+template <typename F, typename Tuple>
+constexpr decltype(auto)
+apply(F&& f, Tuple&& t) {
+    return apply_helper(
+        std::forward<F>(f),
+        std::forward<Tuple>(t),
+        std::make_index_sequence<
+        std::tuple_size<std::remove_reference_t<Tuple>>::value
+        >{}
+    );
+}
+
+const auto a = A{};
+const auto b = B{};
+const auto c = C{};
+const auto d = D{};
+const auto e = E{};
+const auto f = F{};
+const auto g = G{};
+
+// lets us create a complex bind expression with both
+// `std::bind` and `ct::bind_expr`
+#define BIND_WITH(bind_name)                     \
+        bind_name(&ordered_letters,              \
+            _1,                                  \
+            _2,                                  \
+            _3,                                  \
+                bind_name(&BEEF_returns_D,       \
+                _2,                              \
+                e,                               \
+                _4,                              \
+                _7                               \
+            ),                                   \
+            _5,                                  \
+            _6,                                  \
+                bind_name(&BEEF_returns_G,       \
+                    bind_name(&BEEF_returns_B,   \
+                    b,                           \
+                    _10,                         \
+                    e,                           \
+                    f                            \
+                ),                               \
+                _9,                              \
+                e,                               \
+                _8                               \
+            )                                    \
+        )                                        \
+/**/
+
+template<typename BindExpr>
+void check_expression_flattening();
+
+int main() {
+
+    assert(ordered_letters(a, b, c, d, e, f, g) == "ABCDEFG");
+
+    using bind_expr = decltype(BIND_WITH(ct::bind_expr));
+
+    check_expression_flattening<bind_expr>();
+
+    using args = ct::args<bind_expr>;
+
+    // these are the argument types as dictated by 
+    // the bind expression's placeholders
+    using expected_args = std::tuple<A, B, C, E, E, F, F, F, E, E>;
+
+    CT_ASSERT(std::is_same<args, expected_args>{});
+
+    auto runtime_test = BIND_WITH(std::bind);
+    assert(apply(runtime_test, expected_args{}) == "ABCDEFG");
+
+    return 0;
+}
+
+template<typename BindExpr>
+void check_expression_flattening() {
+    using inner3 = decltype(ct::bind_expr(&BEEF_returns_B, b, _10, e, f));
+    using inner2 = decltype(ct::bind_expr(&BEEF_returns_G, inner3{}, _9, e, _8));
+    using inner1 = decltype(ct::bind_expr(&BEEF_returns_D, _2, e, _4, _7));
+
+    using bind_expr_check = decltype(ct::bind_expr(
+        &ordered_letters, _1, _2, _3,
+        inner1{},
+        _5, _6,
+        inner2{}
+    ));
+
+    // this assert makes sure the BIND_WITH macro (defined above)
+    // hasn't been modified out of sync with this function definition
+    CT_ASSERT(std::is_same<BindExpr, bind_expr_check>{});
+
+    using flattened_exprs = typename BindExpr::flattened_bind_expressions;
+    using expected_exprs = std::tuple<BindExpr, inner1, inner2, inner3>;
+
+    CT_ASSERT(std::is_same<flattened_exprs, expected_exprs>{});
+}
\ No newline at end of file