[taepper]

Rationale for this change

This is the last change for #50250. The remaining FnOnce does not have corresponding utilities in the C++20 standard library according to my knowledge.

What changes are included in this PR?

This removes the custom meta-programming facility call_traits::argument_type. We instead use the provided type_traits header which allows us to check invocability (and thus indirectly the argument type) with e.g. std::is_invocable.

It needs to be mentioned that none of std::is_invocable_v, std::invoke_result_t, .. is a drop-in replacement for the removed argument_type. I instead migrated all users of the old facility to the standard constructs. Some call-sites needed changing by supplying template parameters explicitly, but in my opinion all changes are defendable or even improvements.

Are these changes tested?

Yes, this refactoring commit still passes all test cases

Are there any user-facing changes?

No

• GitHub Issue: [C++] Simplify or remove arrow/util/functional.h #50250

[pitrou]

Wrapping the result in a std::function adds a layer of indirection when calling operator() that might be expensive. Can we avoid this?

[taepper]

Maybe I am understanding the code wrong, but I thought the change is equivalent.

The previous version had the function declaration:
static std::function<RetType(const Key&)> Memoize(...)

whereas now we have
static auto Memoize(...)

so all I did in the return statement was changing the implicit conversion to a std::function to an explicit one

[HuaHuaY]

I previously copied and modified this file in iceberg-cpp repo. The file in iceberg-cpp might be as pitrou described. Maybe we can open a new PR to refactor the code. https://github.com/apache/iceberg-cpp/pull/891/changes#diff-6e67f7ceb80cef4c07b66e68bc6907d481231abde46ce1168ed492eadbceb6f1

template <template <typename...> class MemoizerType, typename Func>
auto Memoize(Func&& func, int32_t cache_capacity) {
  using Function = decltype(std::function{std::forward<Func>(func)});
  using Key = std::decay_t<typename unary_traits<Function>::arg>;
  using Value = std::decay_t<std::invoke_result_t<Func, const Key&>>;
  using Memoizer = MemoizerType<Key, Value, LruCache<Key, Value>, Func>;
  return Memoizer(std::forward<Func>(func), cache_capacity);
}

// Apply a LRU memoization cache to a callable.
template <typename Func>
auto MemoizeLru(Func&& func, int32_t cache_capacity) {
  return Memoize<ThreadSafeMemoizer>(std::forward<Func>(func), cache_capacity);
}

However, I discovered that no code within Arrow currently uses this arrow::internal::LruCache; perhaps we can simply delete the file.

[pitrou]

The previous version had the function declaration:
static std::function<RetType(const Key&)> Memoize(...)

Oh, you're right, I misread. Sorry for the noise!

[pitrou]

However, I discovered that no code within Arrow currently uses this arrow::internal::LruCache; perhaps we can simply delete the file.

Let's open a separate issue for that?

[pitrou]

Unfortunately we'll have to wait for #51326 before we can ensure that this doesn't break on some C++ compilers on our CI platforms.

[pitrou]

I've rebased and hopefully we can get mostly green CI.