Can I compose functions using std::bind*?

Question

I'm playing with functional programming in C++20 and write something like that:

template <class OuterFn, class InnerFn, class... Args>
concept Composable =
    std::invocable<OuterFn, std::invoke_result_t<InnerFn, Args...>>;

template <class OuterFn, class InnerFn>
constexpr auto
compose(OuterFn&& outer, InnerFn&& inner)
{
    return [
        out = std::forward<OuterFn>(outer),
        in = std::forward<InnerFn>(inner)
    ]<class... Args>(Args && ... args)
        requires Composable<OuterFn, InnerFn, Args...>
    {
        using std::invoke, std::forward;
        return invoke(out, invoke(in, forward<Args>(args)...));
    };
}

template <class OuterFn, class InnerFn>
constexpr auto
operator*(OuterFn&& outer, InnerFn&& inner)
{
    using std::forward;
    return compose(forward<OuterFn>(outer), forward<InnerFn>(inner));
}

template <class... RestFn>
constexpr auto
compose(RestFn&&... rest)
{
    return (std::forward<RestFn>(rest) * ...);
}

This is work, but I want to refactor compose for two arguments by using std::bind* instead of lambda. So, I think that this:

using eq_t = std::equal_to<const std::string_view>;
constexpr auto eq_42 = std::bind_front(eq_t{}, "42");

is clearly than(especially if using function without overloaded operator for it):

constexpr auto eq_42 = [](const std::string_view sv){ return sv == "42"; };

Maybe You have an ideas how can I do this, or reasons why I can't do this?

The problem is how to retrieve arguments to inner function.

std::bind(outer, std::bind_front(inner)); I tried this for variadic template arguments(and million other variants) by analogy from std::bind(outer, std::bind(inner, _1)); for one argument, but it doesn't work.

P.S. Sorry for my english)

Why would you abandon lambda and choose std::bind, which is outdated and not recommended? — 康桓瑋
– 康桓瑋, Commented Nov 7, 2023 at 14:42
Where did you hear that std::bind is outdated? In my opinion, there are better(or simple, readable, laconic) ways for code composition than lambda. — hlebyshek
– hlebyshek, Commented Nov 7, 2023 at 15:09
std::bind is not "simple, readable, laconic" compared to a lambda — Caleth
– Caleth, Commented Nov 7, 2023 at 16:27
There are numerous recommendations to avoid std::bind(). For example, in this CppCon video, at 25:08 .. 33:05 (already from 2015) about <functional>, Stephan T. Lavavej (the implementor of Visual Studio's C++ Standard Library) wraps it up by saying, "Avoid using bind()!" And as I understand, std::bind() is essentially an obsolete construct that was invented only because there were no lambdas yet in the C++ language. — heap underrun
– heap underrun, Commented Nov 7, 2023 at 22:00

n. m. could be an AI · Accepted Answer · 2023-11-08 09:32:02Z

1

You need a couple of utility classes.

  #include <utility>
  #include <tuple>
  #include <functional>

  template <typename Func>
  struct wrap
  {
      wrap (Func func) : func{func} {}
      template <typename ... T>
      auto operator()(std::tuple<T...>&& args) {
          return std::apply(func, std::forward<std::tuple<T...>>(args));
      }
      Func func;
  };

  template <typename Func>
  struct unwrap
  {
      unwrap (Func func) : func{func} {}
      template <typename ... T>
      auto operator()(T&& ... args) {
          return func(std::tuple(std::forward<T>(args)...));
      }
      Func func;
  };

With this:

  template <typename Func1, typename Func2>
  auto compose (Func1 func1, Func2 func2)
  {
      using namespace std::placeholders;
      return unwrap(std::bind(func1, std::bind(wrap(func2), _1)));
  }

And a test:

  int foo(int a, int b) { return a+b; }
  int bar(int a) { return a*2; }

  int main()
  {
      std::cout << compose(bar, foo)(3,4);
  }

Conceptification and forwardification are left as an exercise for the reader.

But you should really forget about std::bind and use lambdas.

answered Nov 8, 2023 at 9:32

n. m. could be an AI

122k14 gold badges141 silver badges267 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

hlebyshek Over a year ago

Thanks for answer. Extra code in my situation will be superfluous. I will put up with using lambda)

Caleth · Accepted Answer · 2023-11-08 09:04:52Z

0

You can't replace your template compose with an implementation using std::bind, because you would need to supply a variable number of placeholders to the bind call. The best you can do is support a specific arity of arguments to the inner call, up to the (implementation-defined) limit of how many std::placeholders there are.

Nor can you use std::bind_front, because a function object in general isn't the value it returns when called.

So you have to have an intermediate function object, holding the inner and outer functions, and the simplest syntax for that is a lambda. If you really wanted to, you could wrap that in std::bind_front, but there's no point.

template <class OuterFn, class InnerFn>
constexpr auto
compose(OuterFn&& outer, InnerFn&& inner)
{
    using std::invoke, std::forward;
    struct composer {
        template <class Out, class In, class... Args>
        auto operator()(Out&& out, In&& in, Args&&.. args) {
            return invoke(out, invoke(in, forward<Args>(args)...));
        }
    };
    // Fairly gratuitous bind_front, composer could have done the capturing of outer and inner itself
    return std::bind_front(composer{}, forward(outer), forward(inner));
}

edited Nov 8, 2023 at 9:04

answered Nov 7, 2023 at 16:23

Caleth

66k2 gold badges53 silver badges101 bronze badges

2 Comments

hlebyshek Over a year ago

that's why I wrote std::bind*, meaning std::bind, std::bind_front, std::bind_back

Caleth Over a year ago

@hlebyshek the answer is still no, because you need to wait for the result of inner to have the argument to outer

Collectives™ on Stack Overflow

Can I compose functions using std::bind*?

2 Answers 2

1 Comment

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related