2 * Copyright 2016 Facebook, Inc.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
19 #include <folly/ApplyTuple.h>
23 template <typename F, typename Tuple>
30 template <typename Callable, typename... Args>
31 Partial(Callable&& callable, Args&&... args)
32 : f_(std::forward<Callable>(callable)),
33 stored_args_(std::forward<Args>(args)...) {}
35 template <typename... CArgs>
36 auto operator()(CArgs&&... cargs) & {
39 static_cast<Tuple&>(stored_args_),
40 std::forward_as_tuple(std::forward<CArgs>(cargs)...));
43 template <typename... CArgs>
44 auto operator()(CArgs&&... cargs) const& {
46 static_cast<F const&>(f_),
47 static_cast<Tuple const&>(stored_args_),
48 std::forward_as_tuple(std::forward<CArgs>(cargs)...));
51 template <typename... CArgs>
52 auto operator()(CArgs&&... cargs) && {
55 static_cast<Tuple&&>(stored_args_),
56 std::forward_as_tuple(std::forward<CArgs>(cargs)...));
61 * Partially applies arguments to a callable
63 * `partial` takes a callable and zero or more additional arguments and returns
64 * a callable object, which when called with zero or more arguments, will invoke
65 * the original callable with the additional arguments passed to `partial`,
66 * followed by those passed to the call.
68 * E.g. `partial(Foo, 1, 2)(3)` is equivalent to `Foo(1, 2, 3)`.
70 * `partial` can be used to bind a class method to an instance:
71 * `partial(&Foo::method, foo_pointer)` returns a callable object that can be
72 * invoked in the same way as `foo_pointer->method`. In case the first
73 * argument in a call to `partial` is a member pointer, the second argument
74 * can be a reference, pointer or any object that can be dereferenced to
75 * an object of type Foo (like `std::shared_ptr` or `std::unique_ptr`).
77 * `partial` is similar to `std::bind`, but you don't have to use placeholders
78 * to have arguments passed on. Any number of arguments passed to the object
79 * returned by `partial` when called will be added to those passed to `partial`
80 * and passed to the original callable.
82 template <typename F, typename... Args>
83 auto partial(F&& f, Args&&... args) -> Partial<
84 typename std::decay<F>::type,
85 std::tuple<typename std::decay<Args>::type...>> {
86 return {std::forward<F>(f), std::forward<Args>(args)...};