std::integer_sequence< T, v > Struct Template Reference

Description

template<typename T, T ... v>
struct std::integer_sequence< T, v >

Adaptation of std::integer_sequence for Hana.

Modeled concepts

1. Comparable
   Two std::integer_sequences are equal if and only if they have the same number of elements, and if corresponding elements compare equal. The types of the elements held in both integer_sequences may be different, as long as they can be compared.

   // Copyright Louis Dionne 2013-2017
   // Distributed under the Boost Software License, Version 1.0.
   // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
    
   #include <boost/hana/assert.hpp>
   #include <boost/hana/equal.hpp>
   #include <boost/hana/ext/std/integer_sequence.hpp>
   #include <boost/hana/not_equal.hpp>
    
   #include <utility>
   namespace hana = boost::hana;
    
    
   constexpr std::integer_sequence<int, 1, 2, 3, 4> xs{};
   constexpr std::integer_sequence<long, 1, 2, 3, 4> ys{};
   constexpr std::integer_sequence<long, 1, 2, 3, 4, 5> zs{};
    
   BOOST_HANA_CONSTANT_CHECK(hana::equal(xs, ys));
   BOOST_HANA_CONSTANT_CHECK(hana::not_equal(xs, zs));
   BOOST_HANA_CONSTANT_CHECK(hana::not_equal(ys, zs));
    
   int main() { }

2. Foldable
   Folding an integer_sequence is equivalent to folding a sequence of std::integral_constants with the corresponding types.

   // Copyright Louis Dionne 2013-2017
   // Distributed under the Boost Software License, Version 1.0.
   // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
    
   #include <boost/hana/assert.hpp>
   #include <boost/hana/ext/std/integer_sequence.hpp>
   #include <boost/hana/unpack.hpp>
    
   #include <tuple>
   #include <utility>
   namespace hana = boost::hana;
    
    
   auto add = [](auto a, auto b, auto c) { return a + b + c; };
    
   int main() {
       std::tuple<int, long, double> tuple{1, 2l, 3.3};
    
       auto sum = hana::unpack(std::integer_sequence<int, 0, 1, 2>{}, [&](auto ...i) {
           // the `i`s are `std::integral_constant<int, ...>`s
           return add(std::get<decltype(i)::value>(tuple)...);
       });
    
       BOOST_HANA_RUNTIME_CHECK(sum == 6.3);
   }

3. Iterable
   Iterating over an integer_sequence is equivalent to iterating over a sequence of the corresponding std::integral_constants.

   // Copyright Louis Dionne 2013-2017
   // Distributed under the Boost Software License, Version 1.0.
   // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
    
   #include <boost/hana/assert.hpp>
   #include <boost/hana/at.hpp>
   #include <boost/hana/equal.hpp>
   #include <boost/hana/ext/std/integer_sequence.hpp>
   #include <boost/hana/ext/std/integral_constant.hpp>
    
   #include <type_traits>
   #include <utility>
   namespace hana = boost::hana;
    
    
   constexpr std::integer_sequence<int, 0, 1, 2, 3, 4> indices{};
    
   BOOST_HANA_CONSTANT_CHECK(hana::equal(
       hana::at_c<2>(indices),
       std::integral_constant<int, 2>{}
   ));
    
   int main() { }

4. Searchable
   Searching through an integer_sequence is equivalent to searching through the corresponding sequence of std::integral_constants.

   // Copyright Louis Dionne 2013-2017
   // Distributed under the Boost Software License, Version 1.0.
   // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
    
   #include <boost/hana/assert.hpp>
   #include <boost/hana/equal.hpp>
   #include <boost/hana/ext/std/integer_sequence.hpp>
   #include <boost/hana/ext/std/integral_constant.hpp>
   #include <boost/hana/find.hpp>
   #include <boost/hana/integral_constant.hpp>
   #include <boost/hana/optional.hpp>
    
   #include <type_traits>
   #include <utility>
   namespace hana = boost::hana;
    
    
   constexpr std::integer_sequence<int, 1, 2, 3, 4> xs{};
    
   BOOST_HANA_CONSTANT_CHECK(hana::equal(
       hana::find(xs, hana::int_c<3>),
       hana::just(std::integral_constant<int, 3>{})
   ));
    
   int main() { }