1/*!
2@file
3Defines `boost::hana::scan_left`.
4
5Copyright Louis Dionne 2013-2022
6Distributed under the Boost Software License, Version 1.0.
7(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
8 */
9
10#ifndef BOOST_HANA_SCAN_LEFT_HPP
11#define BOOST_HANA_SCAN_LEFT_HPP
12
13#include <boost/hana/fwd/scan_left.hpp>
14
15#include <boost/hana/at.hpp>
16#include <boost/hana/concept/sequence.hpp>
17#include <boost/hana/config.hpp>
18#include <boost/hana/core/dispatch.hpp>
19#include <boost/hana/core/make.hpp>
20#include <boost/hana/empty.hpp>
21#include <boost/hana/length.hpp>
22#include <boost/hana/prepend.hpp>
23
24#include <cstddef>
25#include <utility>
26
27
28namespace boost { namespace hana {
29 //! @cond
30 template <typename Xs, typename F>
31 constexpr auto scan_left_t::operator()(Xs&& xs, F const& f) const {
32 using S = typename hana::tag_of<Xs>::type;
33 using ScanLeft = BOOST_HANA_DISPATCH_IF(scan_left_impl<S>,
34 hana::Sequence<S>::value
35 );
36
37#ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS
38 static_assert(hana::Sequence<S>::value,
39 "hana::scan_left(xs, f) requires 'xs' to be a Sequence");
40#endif
41
42 return ScanLeft::apply(static_cast<Xs&&>(xs), f);
43 }
44
45 template <typename Xs, typename State, typename F>
46 constexpr auto scan_left_t::operator()(Xs&& xs, State&& state, F const& f) const {
47 using S = typename hana::tag_of<Xs>::type;
48 using ScanLeft = BOOST_HANA_DISPATCH_IF(scan_left_impl<S>,
49 hana::Sequence<S>::value
50 );
51
52#ifndef BOOST_HANA_CONFIG_DISABLE_CONCEPT_CHECKS
53 static_assert(hana::Sequence<S>::value,
54 "hana::scan_left(xs, state, f) requires 'xs' to be a Sequence");
55#endif
56
57 return ScanLeft::apply(static_cast<Xs&&>(xs),
58 static_cast<State&&>(state), f);
59 }
60 //! @endcond
61
62 template <typename S, bool condition>
63 struct scan_left_impl<S, when<condition>> : default_ {
64 // Without initial state
65 template <typename Xs, typename F, std::size_t n1, std::size_t n2, std::size_t ...ns>
66 static constexpr auto
67 apply1_impl(Xs&& xs, F const& f, std::index_sequence<n1, n2, ns...>) {
68 static_assert(n1 == 0, "logic error in Boost.Hana: file a bug report");
69
70 // Use scan_left with the first element as an initial state.
71 return scan_left_impl::apply_impl(
72 static_cast<Xs&&>(xs),
73 hana::at_c<0>(static_cast<Xs&&>(xs)),
74 f, std::index_sequence<n2, ns...>{}
75 );
76 }
77
78 template <typename Xs, typename F, std::size_t n>
79 static constexpr auto apply1_impl(Xs&& xs, F const&, std::index_sequence<n>) {
80 return hana::make<S>(hana::at_c<n>(static_cast<Xs&&>(xs)));
81 }
82
83 template <typename Xs, typename F>
84 static constexpr auto apply1_impl(Xs&&, F const&, std::index_sequence<>) {
85 return hana::empty<S>();
86 }
87
88 template <typename Xs, typename F>
89 static constexpr auto apply(Xs&& xs, F const& f) {
90 constexpr std::size_t Len = decltype(hana::length(xs))::value;
91 return scan_left_impl::apply1_impl(static_cast<Xs&&>(xs),
92 f, std::make_index_sequence<Len>{});
93 }
94
95
96 // With initial state
97 template <typename Xs, typename State, typename F,
98 std::size_t n1, std::size_t n2, std::size_t ...ns>
99 static constexpr auto
100 apply_impl(Xs&& xs, State&& state, F const& f,
101 std::index_sequence<n1, n2, ns...>)
102 {
103 auto rest = scan_left_impl::apply_impl(
104 static_cast<Xs&&>(xs),
105 f(state, hana::at_c<n1>(static_cast<Xs&&>(xs))),
106 f, std::index_sequence<n2, ns...>{});
107 return hana::prepend(std::move(rest), static_cast<State&&>(state));
108 }
109
110 template <typename Xs, typename State, typename F, std::size_t n>
111 static constexpr auto
112 apply_impl(Xs&& xs, State&& state, F const& f, std::index_sequence<n>) {
113 auto new_state = f(state, hana::at_c<n>(static_cast<Xs&&>(xs)));
114 return hana::make<S>(static_cast<State&&>(state), std::move(new_state));
115 }
116
117 template <typename Xs, typename State, typename F>
118 static constexpr auto
119 apply_impl(Xs&&, State&& state, F const&, std::index_sequence<>) {
120 return hana::make<S>(static_cast<State&&>(state));
121 }
122
123 template <typename Xs, typename State, typename F>
124 static constexpr auto apply(Xs&& xs, State&& state, F const& f) {
125 constexpr std::size_t Len = decltype(hana::length(xs))::value;
126 return scan_left_impl::apply_impl(static_cast<Xs&&>(xs),
127 static_cast<State&&>(state),
128 f, std::make_index_sequence<Len>{});
129 }
130 };
131}} // end namespace boost::hana
132
133#endif // !BOOST_HANA_SCAN_LEFT_HPP
134

source code of boost/libs/hana/include/boost/hana/scan_left.hpp