1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
/*!
@file
Defines `boost::hana::monadic_fold_left`.
@copyright Louis Dionne 2013-2016
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_HANA_MONADIC_FOLD_LEFT_HPP
#define BOOST_HANA_MONADIC_FOLD_LEFT_HPP
#include <boost/hana/fwd/monadic_fold_left.hpp>
#include <boost/hana/chain.hpp>
#include <boost/hana/concept/foldable.hpp>
#include <boost/hana/concept/monad.hpp>
#include <boost/hana/config.hpp>
#include <boost/hana/core/dispatch.hpp>
#include <boost/hana/detail/decay.hpp>
#include <boost/hana/fold_right.hpp>
#include <boost/hana/functional/curry.hpp>
#include <boost/hana/functional/partial.hpp>
#include <boost/hana/lift.hpp>
#include <type_traits>
BOOST_HANA_NAMESPACE_BEGIN
template <typename M>
struct monadic_fold_left_t {
#ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS
static_assert(hana::Monad<M>::value,
"hana::monadic_fold_left<M> requires 'M' to be a Monad");
#endif
template <typename Xs, typename State, typename F>
constexpr decltype(auto) operator()(Xs&& xs, State&& state, F&& f) const {
using S = typename hana::tag_of<Xs>::type;
using MonadicFoldLeft = BOOST_HANA_DISPATCH_IF(monadic_fold_left_impl<S>,
hana::Foldable<S>::value
);
#ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS
static_assert(hana::Foldable<S>::value,
"hana::monadic_fold_left<M>(xs, state, f) requires 'xs' to be Foldable");
#endif
return MonadicFoldLeft::template apply<M>(static_cast<Xs&&>(xs),
static_cast<State&&>(state),
static_cast<F&&>(f));
}
template <typename Xs, typename F>
constexpr decltype(auto) operator()(Xs&& xs, F&& f) const {
using S = typename hana::tag_of<Xs>::type;
using MonadicFoldLeft = BOOST_HANA_DISPATCH_IF(monadic_fold_left_impl<S>,
hana::Foldable<S>::value
);
#ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS
static_assert(hana::Foldable<S>::value,
"hana::monadic_fold_left<M>(xs, f) requires 'xs' to be Foldable");
#endif
return MonadicFoldLeft::template apply<M>(static_cast<Xs&&>(xs),
static_cast<F&&>(f));
}
};
namespace detail {
struct foldlM_helper {
template <typename F, typename X, typename K, typename Z>
constexpr decltype(auto) operator()(F&& f, X&& x, K&& k, Z&& z) const {
return hana::chain(
static_cast<F&&>(f)(
static_cast<Z&&>(z),
static_cast<X&&>(x)
),
static_cast<K&&>(k)
);
}
};
template <typename End, typename M, typename F>
struct monadic_foldl1_helper {
F f;
template <typename X, typename Y>
constexpr decltype(auto) operator()(X&& x, Y&& y) const
{ return f(static_cast<X&&>(x), static_cast<Y&&>(y)); }
template <typename Y>
constexpr decltype(auto) operator()(End, Y&& y) const
{ return hana::lift<M>(static_cast<Y&&>(y)); }
};
}
template <typename T, bool condition>
struct monadic_fold_left_impl<T, when<condition>> : default_ {
// with state
template <typename M, typename Xs, typename S, typename F>
static constexpr decltype(auto) apply(Xs&& xs, S&& s, F&& f) {
return hana::fold_right(
static_cast<Xs&&>(xs),
hana::lift<M>,
hana::curry<3>(hana::partial(
detail::foldlM_helper{}, static_cast<F&&>(f)
))
)(static_cast<S&&>(s));
}
// without state
template <typename M, typename Xs, typename F>
static constexpr decltype(auto) apply(Xs&& xs, F&& f) {
struct end { };
using G = detail::monadic_foldl1_helper<end, M, typename detail::decay<F>::type>;
decltype(auto) result = hana::monadic_fold_left<M>(
static_cast<Xs&&>(xs),
end{},
G{static_cast<F&&>(f)}
);
static_assert(!std::is_same<
std::remove_reference_t<decltype(result)>,
decltype(hana::lift<M>(end{}))
>{},
"hana::monadic_fold_left<M>(xs, f) requires 'xs' to be non-empty");
return result;
}
};
BOOST_HANA_NAMESPACE_END
#endif // !BOOST_HANA_MONADIC_FOLD_LEFT_HPP
|
