Compose callable object

Question

I need a template function:

template <typename ...Signatures, typename ...Functions>
auto make_callable_object (Functions&& ...functions);

that will return a callable object. When that callable object is called with any of the signature from Signatures, the correspondent functions from Functions should be called.

E.g.:

auto co = create_callable_object<void (int), void (std::string), void (std::exception)> (
             [] (int i) { std::cout << "int"; },
             [] (std::string) { std::cout << "string"; }
             [] (std::exception) { std::cout << "exception"; }
          );

should return an object that is equivalent to

struct { 
  void operator() (int) const { std::cout << "int"; }
  void operator() (std::string) const { std::cout << "string"; }
  void operator() (std::exception) const { std::cout << "exception"; }
};

I created some implementation, but it does not compile with clang c++11.

I'm not sure if there is compiler bug or bug in my code. I'm looking for workarounds or may be a better solution, that would compile with both gcc and clang in c++11 mode.

Coliru link

#include <iostream>
#include <tuple>
#include <type_traits>
#include <functional>

#define noexcept
#define constexpr
#define constexpr14

struct callable_impl_base {
  // will trigger if called with bad signature
  template <typename ...Ts>
  void operator() (Ts...) const { throw std::bad_function_call {}; }
};

template <typename Func, typename Base, typename Sig>
struct callable_impl;

template <typename Func, typename Base, typename R, typename ...Args>
struct callable_impl<Func, Base, R (Args...)>: public Base
{
  template <typename FF>
  constexpr callable_impl (FF&& f, Base&& b)
    : Base (std::forward<Base> (b))
    , func (std::forward<FF> (f))
  {
  }

  // unhiding method from the base classes.
  using Base::operator();

  constexpr R operator() (Args&& ...args) const
  {
    return func (std::forward<Args> (args)...);
  }

  constexpr14 R operator() (Args&& ...args)
  {
    return func (std::forward<Args> (args)...);
  }

  Func func;
};

template <typename Sig, typename Func, typename Base>
constexpr
callable_impl<
    typename std::decay<Func>::type
  , typename std::decay<Base>::type
  , Sig
>
make_callable_impl (Func&& func, Base&& base)
{
  return { std::forward<Func> (func), std::forward<Base> (base) };
}

// Recursion stopper.
template <typename ...>
constexpr callable_impl_base 
make_callable () { return {}; }

// Strip first Sig and first Func one by one.
template <typename Sig, typename ...Sigs, typename F, typename ...Fs>
constexpr14 auto
make_callable (F&& f, Fs&& ...fs)
   -> decltype (make_callable_impl<Sig> (
        std::forward<F> (f),
        make_callable<Sigs...> (std::forward<Fs> (fs)...)))
{
  static_assert (sizeof... (Sigs) == sizeof... (Fs), "bad number of args");

  return make_callable_impl<Sig> (
      std::forward<F> (f),
      make_callable<Sigs...> (std::forward<Fs> (fs)...));
}

using namespace std;

struct A {};
struct B {};

int main ()
{
  auto x = make_callable<void (const A&), void(B const&), void(int,int,int)> (
                [] (A const&) {cout << "A\n";},
                [] (B const&) {cout << "B\n";},
                [] (int,int,int) { cout << "int,int,int\n"; }
  );

  x (B{});
  x (A{});
  x (1,2,4);

  // this must throw because of incompatible signature.
  try {
    x (1,2);
  }
  catch (std::bad_function_call)
  {
      std::cout << "x (1,2) -> got exception (ok)\n";
  }
}

UPDATE:

I tried another solution and get rid of explicit signatures in make_callable template parameters. So, the compose function now is called in such easy way:

int main ()
{
  using namespace std;

  auto co = make_callable (
       [] (int) { cout << "int\n"; },
       [] (string) { cout << "string\n"; },
       [] (int,int) { cout << "int,int\n"; }
  );

  cout << "co(\"str\") -> "; co ("fff");
  cout << "co(55) -> "; co (55);
  cout << "co(55, 44) -> "; co (55, 44);

  // This must throw exception.
  try { co ('c', 4, 4); }
  catch (bad_function_call) { cout << "co('c',4,4) -> exception (ok)\n"; }

}

And here is Coliru Demo. But I still not sure if it is quite effective or some much better solution is possible.

Answer 1

The following approach is shorter (and IMHO easier to grok):

You did the grunt work for detecting if a callable is a match:

struct can_call_test
{
  template<typename F, typename... A>
  static decltype(std::declval<F>()(std::declval<A>()...), std::true_type())
  f(int);

  template<typename F, typename... A>
  static std::false_type
  f(...);
};

} // namespace detail

template<typename F, typename... A>
struct is_callable : decltype(detail::can_call_test::f<F, A...>(0)) { };

template<typename F, typename... A>
struct is_callable <F(A...)> : is_callable <F, A...> { };

Lets define fallback callables so that we can treat the not found case identical to all others:

template <bool Strict>
struct Fallback
{
  template<typename... Args, typename T = int>
  void operator()(Args&&...) const
  {
    static_assert (sizeof(T) == 0,
      "Bad function call: incompatible signature, see next error message");
  }
};

template <>
struct Fallback<false>
{
  template<typename... Args>
  void operator()(Args&&...) const
  {
    throw std::bad_function_call {};
  }
};

Now, given a tuple of callables, lets figure out the index of the first matching callable:

template <size_t Idx, typename Tuple, typename... Args>
struct FirstCallable;

template <size_t Idx, typename C, typename... Rest, typename... Args>
struct FirstCallable<Idx, std::tuple<C, Rest...>, Args...>
{
  static constexpr size_t index =
      is_callable<C, Args...>::value
          ? Idx
          : FirstCallable<Idx + 1, std::tuple<Rest...>, Args...>::index;
};

template <size_t Idx, typename C, typename... Args>
struct FirstCallable<Idx, std::tuple<C>, Args...>
{
  static constexpr size_t index = Idx;
};

The callable template can be completely fallback-agnostic which might be quite handy, actually, if one fine day you want to have different behavior (e.g. a different exception). It just needs to call the first matching tuple element:

template <class... Functions>
struct callable
{
  using FTuple = std::tuple<Functions...>;

  FTuple functions;

  template <typename Tuple>
  callable(Tuple&& f)
      : functions(std::forward<Tuple>(f))
  {
  }

  template <class... Args>
  auto operator()(Args&&... args) const
      -> decltype(std::get<FirstCallable<0, FTuple, Args...>::index>(functions)(
          std::forward<Args>(args)...))
  {
    return std::get<FirstCallable<0, FTuple, Args...>::index>(functions)(
        std::forward<Args>(args)...);
  }
};

The factory functions finally add the fallback.

template <class... Functions>
callable<typename std::decay<Functions>::type..., Fallback<true>>
make_strict_callable(Functions&&... functions)
{
  return {std::forward_as_tuple(std::forward<Functions>(functions)...,
                                Fallback<true>{})};
}

template <class... Functions>
callable<typename std::decay<Functions>::type..., Fallback<false>>
make_callable(Functions&&... functions)
{
  return {std::forward_as_tuple(std::forward<Functions>(functions)...,
                                Fallback<false>{})};
}

Code also posted here: http://coliru.stacked-crooked.com/a/3942dfd3de7c1ef8