Why is operator() of function views non-const?

[melg8]

Problem

I want to create callable object with const cv qualifier and call it with some value.

Code example

using namespace caf;

using inc_actor_t = typed_actor<replies_to<int>::with<int>>;

void b_impl(event_based_actor* self, const inc_actor_t &a) {
  const auto increment = make_function_view(a);
  increment(1);
}

Expected behavior

Successful compilation.

Current behavior

Compilation error:

`error: no matching function for call to object of type 'const caf::function_view<caf::typed_actor<caf::result<int> (int)> >' 

Possible solutions

1. In my opinion best solution, but maybe implicitly changing current code

Add to current call operator overload

  template <class... Ts>
  auto operator()(Ts&&... xs) {

const qualifier

  template <class... Ts>
  auto operator()(Ts&&... xs) const {

And fix compilation errors by addition of const or static to functions flatten:

  template <class T>
  static T&& flatten(T& x) {
    return std::move(x);
  }

  template <class T>
  static T&& flatten(std::tuple<T>& x) {
    return std::move(get<0>(x));
  }

2. At least, not affecting curent code

Add to class

template <class Actor>
class function_view;

operator() overload with const and separate implementation.

Why it matters

1. Now I see no reason, why that callable couldn't be const, or at least couldn't support const overload.
2. As advised in cppcoreguidelines: Con:2 "By default, make member functions const"
3. And this would open up the possibility of complying to cppcoreguidelines: Con:4 "Use const to define objects with values that do not change after construction." Which would be great to users of the library.

[Neverlord]

The function view isn't const, because:

Use const to define objects with values that do not change after construction

Now, technically the function view could get away with const since it wraps an actor handle. Semantically, the "function" changes its state whenever you call it. We decided to not make the function call operator const to make it clear that there are state changes whenever you call it. It's still message passing underneath.

[melg8]

I see... So it would be like - calling the same const object twice with the same values, but getting different results, yea that would be confusing.