BlackMATov/kari.hpp
1
0
Fork 0
mirror of https://github.com/BlackMATov/kari.hpp.git synced 2025-12-15 13:29:49 +07:00
Code Issues Packages Projects Releases Wiki Activity

temporary remove variadic curring

Browse Source
This commit is contained in:
BlackMATov
2020-12-10 20:47:02 +07:00
parent 5a169d9efe
commit d8a4722c62
3 changed files with 15 additions and 192 deletions
Download Patch File Download Diff File Expand all files Collapse all files

74
headers/kari.hpp/kari.hpp
View File

@@ -12,7 +12,7 @@
namespace kari_hpp
{
template < std::size_t N, typename F, typename... Args >
template < typename F, typename... Args >
struct curry_t;
namespace impl
@@ -21,8 +21,8 @@ namespace kari_hpp
struct is_curried_impl
: std::false_type {};
template < std::size_t N, typename F, typename... Args >
struct is_curried_impl<curry_t<N, F, Args...>>
template < typename F, typename... Args >
struct is_curried_impl<curry_t<F, Args...>>
: std::true_type {};
}
@@ -36,48 +36,40 @@ namespace kari_hpp
namespace kari_hpp::detail
{
template < std::size_t N, typename F, typename... Args >
template < typename F, typename... Args >
constexpr auto curry_or_apply(F&& f, std::tuple<Args...>&& args) {
if constexpr ( !N && std::is_invocable_v<std::decay_t<F>, Args...> ) {
if constexpr ( std::is_invocable_v<std::decay_t<F>, Args...> ) {
return std::apply(std::forward<F>(f), std::move(args));
} else {
return curry_t<N, std::decay_t<F>, Args...>(std::forward<F>(f), std::move(args));
return curry_t<std::decay_t<F>, Args...>(std::forward<F>(f), std::move(args));
}
}
template < std::size_t N, typename F >
template < typename F >
constexpr auto curry_or_apply(F&& f) {
return curry_or_apply<N>(std::forward<F>(f), std::make_tuple());
return curry_or_apply(std::forward<F>(f), std::make_tuple());
}
}
namespace kari_hpp
{
template < std::size_t N, typename F, typename... Args >
template < typename F, typename... Args >
struct curry_t final {
template < typename U >
constexpr curry_t(U&& u, std::tuple<Args...>&& args)
: f_(std::forward<U>(u))
, args_(std::move(args)) {}
// min_arity
constexpr std::size_t min_arity() const noexcept {
return N;
}
// recurry
template < std::size_t M >
constexpr auto recurry() && {
return detail::curry_or_apply<M>(
return detail::curry_or_apply(
std::move(f_),
std::move(args_));
}
template < std::size_t M >
constexpr auto recurry() const & {
return std::move(curry_t(*this)).template recurry<M>();
return std::move(curry_t(*this)).recurry();
}
// operator(As&&...)
@@ -88,7 +80,7 @@ namespace kari_hpp
template < typename A >
constexpr auto operator()(A&& a) && {
return detail::curry_or_apply<(N > 0 ? N - 1 : 0)>(
return detail::curry_or_apply(
std::move(f_),
std::tuple_cat(
std::move(args_),
@@ -121,7 +113,7 @@ namespace kari_hpp
if constexpr ( is_curried_v<std::decay_t<F>> ) {
return std::forward<F>(f);
} else {
return detail::curry_or_apply<0>(std::forward<F>(f));
return detail::curry_or_apply(std::forward<F>(f));
}
}
@@ -129,44 +121,4 @@ namespace kari_hpp
constexpr auto curry(F&& f, A&& a, As&&... as) {
return curry(std::forward<F>(f))(std::forward<A>(a), std::forward<As>(as)...);
}
//
// curryV
//
template < typename F >
constexpr auto curryV(F&& f) {
constexpr std::size_t max_n = std::size_t(-1);
if constexpr ( is_curried_v<std::decay_t<F>> ) {
return std::forward<F>(f).template recurry<max_n>();
} else {
return detail::curry_or_apply<max_n>(std::forward<F>(f));
}
}
template < typename F, typename A, typename... As >
constexpr auto curryV(F&& f, A&& a, As&&... as) {
return curryV(std::forward<F>(f))(std::forward<A>(a), std::forward<As>(as)...);
}
//
// curryN
//
template < std::size_t N, typename F >
constexpr auto curryN(F&& f) {
if constexpr ( is_curried_v<std::decay_t<F>> ) {
return std::forward<F>(f).template recurry<N>();
} else {
return detail::curry_or_apply<N>(std::forward<F>(f));
}
}
template < std::size_t N, typename F, typename A, typename... As >
constexpr auto curryN(F&& f, A&& a, As&&... as) {
constexpr std::size_t max_n = std::size_t(-1);
constexpr std::size_t arg_n = sizeof...(As) + 1;
static_assert(max_n - arg_n >= N, "invalid N argument");
return curryN<N + arg_n>(std::forward<F>(f))(std::forward<A>(a), std::forward<As>(as)...);
}
}