Boost.Hana: Sequence . Boost , ,

Boost.Hana 1.0.1

Your standard library for metaprogramming

Концепция<Sequence>представляет собой общие индексные последовательности.

По сравнению с другими абстрактными понятиями концепция последовательности очень специфична. Он представляет собой общие индексные последовательности. Причина, по которой предлагается такая конкретная концепция, заключается в том, что существует множество моделей, которые ведут себя точно так же, но реализуются совершенно по-разному. Для целей общего программирования полезно перегруппировать все эти типы данных под одним зонтиком.

На самом деле модели этого понятия не толькопохожи. Они на самом делеизоморфны, в том смысле, который мы определяем ниже, что является причудливым способом строго сказать, что они ведут себя точно так же с внешним наблюдателем.

Minimal complete definition

<Iterable>,<Foldable>и<make>

Концепция<Sequence>не предоставляет базовых методов, которые можно было бы использовать в качестве минимального полного определения; вместо этого она заимствует методы из других концепций и добавляет к ним законы. По этой причине необходимо специализировать метафункцию<Sequence>в пространстве имён Ханы, чтобы сказать Хане, что тип действительно является<Sequence>. Явно специализируясь на<Sequence>метафункции, можно увидеть печать, говорящую, что этот тип данных удовлетворяет дополнительным законам «Последовательности», поскольку они не могут быть проверены Ханой автоматически.

Laws

Законы бытия<Sequence>просты, и их цель — ограничить семантику, которая может быть связана с функциями, предоставляемыми другими понятиями. Во-первых,<Sequence>должно быть конечным<Iterable>(таким образом<Foldable>тоже). Во-вторых, для<Sequence>метки<S><make<S>(x1, ..., xn)>должен быть объект метки<S>и линеаризация которого<[x1, ..., xn]>. Это в основном гарантирует, что объекты тега<S>эквивалентны их линеаризации, и что они могут быть созданы из такой линеаризации (с<make>).

Хотя теоретически возможно обрабатывать бесконечные последовательности, это усложняет реализацию многих алгоритмов. Для простоты текущая версия библиотеки обрабатывает только конечные последовательности. Однако обратите внимание, что это никоим образом не влияет на возможность иметь бесконечные<Searchable>с и<Iterable>с.

Refined concepts

Comparable(определение предоставляется автоматически)
ДваSequenceравны тогда и только тогда, когда они содержат одинаковое число элементов и их элементы при любом данном индексе равны.
// Авторское право Louis Dionne 2013-2016
// Распространяется под лицензией Boost Software License, версия 1.0.
// (См. сопроводительный файл LICENSE.md или копию на http://boost.org/LICENSE_1_0.txt)
#include<boost/hana/assert.hpp>
#include<boost/hana/equal.hpp>
#include<boost/hana/not_equal.hpp>
#include<boost/hana/tuple.hpp>
пространство именhana =boost::hana;
static_assert(hana::make_tuple(1, 2, 3) == hana::make_tuple(1, 2, 3),"");
Boost_HANA_CONSTANT_CHECK(hana::make_tuple(1, 2, 3)! hana::make_tuple(1, 2, 3, 4));
intmain()
[ORIG_END] -->
Orderable(определение предоставляется автоматически)
Sequences заказываются с использованием традиционного лексикографического упорядочения.
// Авторское право Louis Dionne 2013-2016
// Распространяется по лицензии Boost Software, версия 1.0.
// (См. сопроводительный файл LICENSE.md или копию по адресу http://boost.org/LICENSE_1_0.txt)
#include<
namespacehana =
static_assert(hana::make_tuple(1, 2, 3)<]""]
static_assert(1, 3, 4]]
static_assert(1, 2, 3)<
]
static_assert(1, 2, 3)<]&make_tuple(1, 2, 3)<[ORIG_END] -->

Functor(определение предоставляется автоматически)
Sequences реализуютtransformкак отображение функции над каждым элементом последовательности. Это несколько эквивалентно тому, чтоstd::transformделает с диапазонами итераторов. Также обратите внимание, что отображение функции по пустой последовательности возвращает пустую последовательность и никогда не применяет функцию, как ожидалось.

// Авторское право Louis Dionne 2013-2016
// Распространяется по лицензии Boost Software License, Version 1.0.
// [См. сопроводительный файл LICENSE.md или копия по http://boost.org/LICENSE_130]

"345""[ORIG_END] -->

Applicative(определение предоставляется автоматически)
Во-первых,liftвключение значения вSequenceравносильно созданию однотонной последовательности, содержащей это значение. Во-вторых, применение последовательности функций к последовательности значений будет применять каждую функцию ко всем значениям в последовательности, а затем возвращать список всех результатов. Другими словами,
ap[[f1, ..., fN], [x1, ..., xM]] ==
f1(x1), ..., f1(xM),
fN(x1), ..., fN(xM)
Пример:
// Авторское право Louis Dionne 2013-2016
// Распространяется по лицензии Boost Software License, Version 1.0.
// [См. сопровождающий файл LICENSE.md или копию по http://boost.org/LICENSE_1_0.txt]
[2 Example:
// 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)
#include <boost/hana/ap.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/ext/std/tuple.hpp>
#include <boost/hana/functional/flip.hpp>
#include <boost/hana/lift.hpp>
#include <boost/hana/pair.hpp>
#include <boost/hana/tuple.hpp>
#include <tuple>
namespace hana = boost::hana;
static_assert(hana::lift<hana::tuple_tag>('x') == hana::make_tuple('x'), "");
static_assert(hana::equal(hana::lift<hana::ext::std::tuple_tag>('x'), std::make_tuple('x')), "");
constexpr auto f = hana::make_pair;
constexpr auto g = hana::flip(hana::make_pair);
static_assert(
hana::ap(hana::make_tuple(f, g), hana::make_tuple(1, 2, 3), hana::make_tuple('a', 'b'))
==
hana::make_tuple(
f(1, 'a'), f(1, 'b'), f(2, 'a'), f(2, 'b'), f(3, 'a'), f(3, 'b'),
g(1, 'a'), g(1, 'b'), g(2, 'a'), g(2, 'b'), g(3, 'a'), g(3, 'b')
)
, "");
int main() { }
[ORIG_END] -->
Monad(определение предоставляется автоматически)
Во-первых,flatenнаSequenceберет последовательность последовательностей и конкатенирует их, чтобы получить большую последовательность. Другими словами,
сплющивается[[a1, ..., aN], ..., [z1, ..., zM]] ==
a1, ..., aN, ..., z1, ..., zM
]
Это действует как функцияstd::tuple_cat, за исключением того, что она получает последовательность последовательностей вместо вариадной пачки последовательностей для сплющивания.
Пример:
// Авторское право Louis Dionne 2013-2016
// Распространяется по лицензии Boost Software License, Version 1.0.
// (См. сопроводительный файл LICENSE.md или копию по адресу http://boost.org/LICENSE_1_0.txt)
>
Также обратите внимание, что модельMonadдляSequenceможет рассматриваться как модель недетерминизма. Недетерминированные вычисления могут быть смоделированы как функция, которая возвращает последовательность возможных результатов. В этой мыслиchainвключение последовательности значений в такую функцию возвращает последовательность всех возможных выходных значений, то есть последовательность всех значений, применяемых ко всем функциям в последовательностях.
Пример:
// Авторское право Louis Dionne 2013-2016
// Распространяется по лицензии Boost Software License, Version 1.0.
// [См. сопроводительный файл LICENSE.md или копию по адресу http://boost.org/LICENSE_1_0.txt]
>
boost/hana/assert.hpp>
boost/hana/chain.hpp>boost/hana/chain.hpp>boost/hana/chain.hpp
Используя «тройную» Монаду, мы генерируем все возможные комбинации
// cv-квалификаторы и эталонные квалификаторы. Затем мы используем «факультативно»
// Монада, чтобы убедиться, что наша родовая функция может быть вызвана
[ This acts like a std::tuple_cat function, except it receives a sequence of sequences instead of a variadic pack of sequences to flatten.
Example:
// 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)
#include <boost/hana/equal.hpp>
#include <boost/hana/flatten.hpp>
#include <boost/hana/tuple.hpp>
namespace hana = boost::hana;
static_assert(
hana::flatten(hana::make_tuple(
hana::make_tuple(1, 2),
hana::make_tuple(3, 4),
hana::make_tuple(hana::make_tuple(5, 6))
))
== hana::make_tuple(1, 2, 3, 4, hana::make_tuple(5, 6))
, "");
int main() { }
Also note that the model of Monad for Sequences can be seen as modeling nondeterminism. A nondeterministic computation can be modeled as a function which returns a sequence of possible results. In this line of thought, chaining a sequence of values into such a function will return a sequence of all the possible output values, i.e. a sequence of all the values applied to all the functions in the sequences.
Example:
// 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)
#include <boost/hana/assert.hpp>
#include <boost/hana/chain.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/for_each.hpp>
#include <boost/hana/traits.hpp>
#include <boost/hana/tuple.hpp>
#include <boost/hana/type.hpp>
#include <type_traits>
#include <utility>
namespace hana = boost::hana;
// Using the `tuple` Monad, we generate all the possible combinations of
// cv-qualifiers and reference qualifiers. Then, we use the `optional`
// Monad to make sure that our generic function can be called with
// arguments of any of those types.
// cv_qualifiers : type -> tuple(type)
auto cv_qualifiers = [](auto t) {
return hana::make_tuple(
t,
hana::traits::add_const(t),
hana::traits::add_volatile(t),
hana::traits::add_volatile(hana::traits::add_const(t))
);
};
// ref_qualifiers : type -> tuple(type)
auto ref_qualifiers = [](auto t) {
return hana::make_tuple(
hana::traits::add_lvalue_reference(t),
hana::traits::add_rvalue_reference(t)
);
};
auto possible_args = cv_qualifiers(hana::type_c<int>) | ref_qualifiers;
BOOST_HANA_CONSTANT_CHECK(
possible_args == hana::make_tuple(
hana::type_c<int&>,
hana::type_c<int&&>,
hana::type_c<int const&>,
hana::type_c<int const&&>,
hana::type_c<int volatile&>,
hana::type_c<int volatile&&>,
hana::type_c<int const volatile&>,
hana::type_c<int const volatile&&>
)
);
struct some_function {
template <typename T>
void operator()(T&&) const { }
};
int main() {
hana::for_each(possible_args, [](auto t) {
using T = typename decltype(t)::type;
static_assert(decltype(hana::is_valid(some_function{})(std::declval<T>())){},
"some_function should be callable with any type of argument");
});
}
[ORIG_END] -->
MonadPlus(определение предоставляется автоматически)
Sequences являются моделями концепцииMonadPlus, рассматривая пустую последовательность как единицуconcat, а конкатенацию последовательности какconcat.
// Авторское право Louis Dionne 2013-2016
// Распространяется по лицензии Boost Software License, Version 1.0.
// [См. сопроводительный файл LICENSE.md или копию по http://boost.org/LICENSE_1_0.xt]
[75[ORIG_END] -->

Foldable
МодельFoldableдляSequenceс однозначно определяется модельюIterable.

// Авторское право Louis Dionne 2013-2016
// Распространяется по лицензии Boost Software License, Version 1.0.
// [См. сопроводительный файл LICENSE.md или копию по http://boost.org/LICENSE_1_0.txt]

[[ORIG_END] -->

Iterable
МодельIterableдляSequences соответствует итерации по каждому элементу последовательности по порядку. Эта модель не предоставляется автоматически и фактически является частью минимального полного определения для концепцииSequence.
// Авторское право Louis Dionne 2013-2016
// Распространяется по лицензии Boost Software, версия 1.0.
// (См. сопроводительный файл LICENSE.md или копия по http://boost.org/LICENSE_1000_0.xt)
[ORIG_END] -->
Searchable(определение предоставляется автоматически)
Поиск поSequenceэквивалентен простому поиску по списку значений, которые он содержит. Ключи и значения, на которых выполняется поиск, являются элементами последовательности.
// Авторское право Louis Dionne 2013-2016
// Распространяется по лицензии Boost Software, версия 1.0.
// [См. сопроводительный файл LICENSE.md или копия по http://boost.org/LICENSE_101.txt]
Sequenceбустер/хана/ассерт.hppSequenceбустер/хана/ассерт.hpp
]
[11[ORIG_END] -->

Concrete models

<hana::tuple>

Variables
constexpr auto	boost::hana::cartesian_product
	Computes the cartesian product of a sequence of sequences.Given a sequence of sequences, `cartesian_product` returns a new sequence of sequences containing the cartesian product of the original sequences. For this method to finish, a finite number of finite sequences must be provided. More...

constexpr auto	boost::hana::drop_back
	Drop the last `n` elements of a finite sequence, and return the rest.Given a finite `Sequence` `xs` with a linearization of `[x1, ..., xm]` and a non-negative `IntegralConstant` `n`, `drop_back(xs, n)` is a sequence with the same tag as `xs` whose linearization is `[x1, ..., xm-n]`. If `n` is not given, it defaults to an `IntegralConstant` with a value equal to `1`. More...

constexpr auto	boost::hana::group
	Group adjacent elements of a sequence that all respect a binary predicate, by default equality.Given a finite Sequence and an optional predicate (by default `equal`), `group` returns a sequence of subsequences representing groups of adjacent elements that are "equal" with respect to the predicate. In other words, the groups are such that the predicate is satisfied when it is applied to any two adjacent elements in that group. The sequence returned by `group` is such that the concatenation of its elements is equal to the original sequence, which is equivalent to saying that the order of the elements is not changed. More...

constexpr insert_t	boost::hana::insert {}
	Insert a value at a given index in a sequence.Given a sequence, an index and an element to insert, `insert` inserts the element at the given index. More...

constexpr auto	boost::hana::insert_range
	Insert several values at a given index in a sequence.Given a sequence, an index and any `Foldable` containing elements to insert, `insert_range` inserts the elements in the `Foldable` at the given index of the sequence. More...

constexpr auto	boost::hana::intersperse
	Insert a value between each pair of elements in a finite sequence.Given a finite `Sequence` `xs` with a linearization of `[x1, x2, ..., xn]`, `intersperse(xs, z)` is a new sequence with a linearization of `[x1, z, x2, z, x3, ..., xn-1, z, xn]`. In other words, it inserts the `z` element between every pair of elements of the original sequence. If the sequence is empty or has a single element, `intersperse` returns the sequence as-is. In all cases, the sequence must be finite. More...

constexpr auto	boost::hana::partition
	Partition a sequence based on a `predicate`.Specifically, returns an unspecified `Product` whose first element is a sequence of the elements satisfying the predicate, and whose second element is a sequence of the elements that do not satisfy the predicate. More...

constexpr auto	boost::hana::permutations
	Return a sequence of all the permutations of the given sequence.Specifically, `permutations(xs)` is a sequence whose elements are permutations of the original sequence `xs`. The permutations are not guaranteed to be in any specific order. Also note that the number of permutations grows very rapidly as the length of the original sequence increases. The growth rate is `O(length(xs)!)`; with a sequence `xs` of length only 8, `permutations(xs)` contains over 40 000 elements! More...

constexpr auto	boost::hana::remove_at
	Remove the element at a given index from a sequence.`remove_at` returns a new sequence identical to the original, except that the element at the given index is removed. Specifically, `remove_at([x0, ..., xn-1, xn, xn+1, ..., xm], n)` is a new sequence equivalent to `[x0, ..., xn-1, xn+1, ..., xm]`. More...

template<std::size_t n>
constexpr auto	boost::hana::remove_at_c
	Equivalent to `remove_at`; provided for convenience. More...

constexpr auto	boost::hana::remove_range
	Remove the elements inside a given range of indices from a sequence.`remove_range` returns a new sequence identical to the original, except that elements at indices in the provided range are removed. Specifically, `remove_range([x0, ..., xn], from, to)` is a new sequence equivalent to `[x0, ..., x_from-1, x_to, ..., xn]`. More...

template<std::size_t from, std::size_t to>
constexpr auto	boost::hana::remove_range_c
	Equivalent to `remove_range`; provided for convenience. More...

constexpr auto	boost::hana::reverse
	Reverse a sequence.Specifically, `reverse(xs)` is a new sequence containing the same elements as `xs`, except in reverse order. More...

constexpr auto	boost::hana::scan_left
	Fold a Sequence to the left and return a list containing the successive reduction states.Like `fold_left`, `scan_left` reduces a sequence to a single value using a binary operation. However, unlike `fold_left`, it builds up a sequence of the intermediary results computed along the way and returns that instead of only the final reduction state. Like `fold_left`, `scan_left` can be used with or without an initial reduction state. More...

constexpr auto	boost::hana::scan_right
	Fold a Sequence to the right and return a list containing the successive reduction states.Like `fold_right`, `scan_right` reduces a sequence to a single value using a binary operation. However, unlike `fold_right`, it builds up a sequence of the intermediary results computed along the way and returns that instead of only the final reduction state. Like `fold_right`, `scan_right` can be used with or without an initial reduction state. More...

constexpr auto	boost::hana::slice
	Extract the elements of a `Sequence` at the given indices.Given an arbitrary sequence of `indices`, `slice` returns a new sequence of the elements of the original sequence that appear at those indices. In other words,. More...

template<std::size_t from, std::size_t to>
constexpr auto	boost::hana::slice_c
	Shorthand to `slice` a contiguous range of elements.`slice_c` is simply a shorthand to slice a contiguous range of elements. In particular, `slice_c<from, to>(xs)` is equivalent to `slice(xs, range_c<std::size_t, from, to>)`, which simply slices all the elements of `xs` contained in the half-open interval delimited by `[from, to)`. Like for `slice`, the indices used with `slice_c` are 0-based and they must be in the bounds of the sequence being sliced. More...

constexpr auto	boost::hana::sort
	Sort a sequence, optionally based on a custom `predicate`.Given a Sequence and an optional predicate (by default `less`), `sort` returns a new sequence containing the same elements as the original, except they are ordered in such a way that if `x` comes before `y` in the sequence, then either `predicate(x, y)` is true, or both `predicate(x, y)` and `predicate(y, x)` are false. More...

constexpr auto	boost::hana::span
	Returns a `Product` containing the longest prefix of a sequence satisfying a predicate, and the rest of the sequence.The first component of the returned `Product` is a sequence for which all elements satisfy the given predicate. The second component of the returned `Product` is a sequence containing the remainder of the argument. Both or either sequences may be empty, depending on the input argument. More specifically,. More...

constexpr auto	boost::hana::take_back
	Returns the last `n` elements of a sequence, or the whole sequence if the sequence has less than `n` elements.Given a `Sequence` `xs` and an `IntegralConstant` `n`, `take_back(xs, n)` is a new sequence containing the last `n` elements of `xs`, in the same order. If `length(xs) <= n`, the whole sequence is returned and no error is triggered. More...

constexpr auto	boost::hana::take_front
	Returns the first `n` elements of a sequence, or the whole sequence if the sequence has less than `n` elements.Given a `Sequence` `xs` and an `IntegralConstant` `n`, `take_front(xs, n)` is a new sequence containing the first `n` elements of `xs`, in the same order. If `length(xs) <= n`, the whole sequence is returned and no error is triggered. More...

template<std::size_t n>
constexpr auto	boost::hana::take_front_c
	Equivalent to `take_front`; provided for convenience. More...

constexpr auto	boost::hana::take_while
	Take elements from a sequence while the `predicate` is satisfied.Specifically, `take_while` returns a new sequence containing the longest prefix of `xs` in which all the elements satisfy the given predicate. More...

template<typename S >
constexpr auto	boost::hana::unfold_left
	Dual operation to `fold_left` for sequences.While `fold_left` reduces a structure to a summary value from the left, `unfold_left` builds a sequence from a seed value and a function, starting from the left. More...

template<typename S >
constexpr auto	boost::hana::unfold_right
	Dual operation to `fold_right` for sequences.While `fold_right` reduces a structure to a summary value from the right, `unfold_right` builds a sequence from a seed value and a function, starting from the right. More...

constexpr auto	boost::hana::unique
	Removes all consecutive duplicate elements from a Sequence.Given a `Sequence` and an optional binary predicate, `unique` returns a new sequence containing only the first element of every subrange of the original sequence whose elements are all equal. In other words, it turns a sequence of the form `[a, a, b, c, c, c, d, d, d, a]` into a sequence `[a, b, c, d, a]`. The equality of two elements is determined by the provided `predicate`, or by `equal` if no `predicate` is provided. More...

constexpr auto	boost::hana::zip
	Zip one sequence or more.Given `n` sequences `s1, ..., sn`, `zip` produces a sequence whose `i`-th element is a tuple of `(s1[i], ..., sn[i])`, where `sk[i]` denotes the `i`-th element of the `k`-th sequence. In other words, `zip` produces a sequence of the form. More...

constexpr auto	boost::hana::zip_shortest
	Zip one sequence or more.Given `n` sequences `s1, ..., sn`, `zip_shortest` produces a sequence whose `i`-th element is a tuple of `(s1[i], ..., sn[i])`, where `sk[i]` denotes the `i`-th element of the `k`-th sequence. In other words, `zip_shortest` produces a sequence of the form. More...

constexpr auto	boost::hana::zip_shortest_with
	Zip one sequence or more with a given function.Given a `n`-ary function `f` and `n` sequences `s1, ..., sn`, `zip_shortest_with` produces a sequence whose `i`-th element is `f(s1[i], ..., sn[i])`, where `sk[i]` denotes the `i`-th element of the `k`-th sequence. In other words, `zip_shortest_with` produces a sequence of the form. More...

constexpr auto	boost::hana::zip_with
	Zip one sequence or more with a given function.Given a `n`-ary function `f` and `n` sequences `s1, ..., sn`, `zip_with` produces a sequence whose `i`-th element is `f(s1[i], ..., sn[i])`, where `sk[i]` denotes the `i`-th element of the `k`-th sequence. In other words, `zip_with` produces a sequence of the form. More...

Variable Documentation

constexpr auto boost::hana::cartesian_product

<#include <boost/hana/fwd/cartesian_product.hpp>>

Initial value:

= [](auto&& xs) {
        return tag-dispatched;
    }

Вычисляет картезианский продукт последовательности последовательностей. Учитывая последовательность последовательностей,<cartesian_product>возвращает новую последовательность последовательностей, содержащих картезианский продукт исходных последовательностей. Для завершения этого метода необходимо предоставить конечное число конечных последовательностей.

Note: All the sequences must have the same tag, and that tag must also match that of the top-level sequence.

Signature

При этом<Sequence><S(T)>подпись

\[ \mathtt{cartesian\_product} : S(S(T)) \to S(S(T)) \]

Parameters

xs	Последовательность последовательностей, из которых вычисляется картезианский продукт.

Example

// 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)
#include <boost/hana/cartesian_product.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/tuple.hpp>
#include <boost/hana/type.hpp>
namespace hana = boost::hana;
constexpr auto tuples = hana::make_tuple(
    hana::make_tuple(1, 2, 3),
    hana::make_tuple('a', 'b'),
    hana::make_tuple(hana::type_c<int>, hana::type_c<char>)
);
constexpr auto prod = hana::make_tuple(
    hana::make_tuple(1, 'a', hana::type_c<int>),
    hana::make_tuple(1, 'a', hana::type_c<char>),
    hana::make_tuple(1, 'b', hana::type_c<int>),
    hana::make_tuple(1, 'b', hana::type_c<char>),
    hana::make_tuple(2, 'a', hana::type_c<int>),
    hana::make_tuple(2, 'a', hana::type_c<char>),
    hana::make_tuple(2, 'b', hana::type_c<int>),
    hana::make_tuple(2, 'b', hana::type_c<char>),
    hana::make_tuple(3, 'a', hana::type_c<int>),
    hana::make_tuple(3, 'a', hana::type_c<char>),
    hana::make_tuple(3, 'b', hana::type_c<int>),
    hana::make_tuple(3, 'b', hana::type_c<char>)
);
static_assert(hana::cartesian_product(tuples) == prod, "");
int main() { }

constexpr auto boost::hana::drop_back

<#include <boost/hana/fwd/drop_back.hpp>>

Initial value:

= [](auto&& xs[, auto const& n]) {
        return tag-dispatched;
    }

Опустить последние<n>элементы конечной последовательности и вернуть остальные. Признавая конечную<Sequence><xs>с линеаризацией<[x1, ..., xm]>и неотрицательную<IntegralConstant><n>,<drop_back(xs, n)>представляет собой последовательность с той же меткой, что и<xs>, линеаризация которой является<[x1, ..., xm-n]>. Если<n>не дано, он по умолчанию<IntegralConstant>со значением, равным<1>.

В случае<length(xs) <= n>,<drop_back>просто отбросит всю последовательность без сбоев, таким образом возвращая пустую последовательность.

Parameters

xs	Последовательность, из которой выпадают элементы.
n	Неотрицательный<`IntegralConstant`>, представляющий число элементов, подлежащих выпадению из конца последовательности. Если<`n`>не дано, он по умолчанию<`IntegralConstant`>со значением, равным<`1`>.

Example

// 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)
#include <boost/hana/assert.hpp>
#include <boost/hana/drop_back.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/tuple.hpp>
namespace hana = boost::hana;
constexpr auto xs = hana::make_tuple(0, '1', 2.0);
static_assert(hana::drop_back(xs, hana::size_c<0>) == xs, "");
static_assert(hana::drop_back(xs, hana::size_c<1>) == hana::make_tuple(0, '1'), "");
static_assert(hana::drop_back(xs, hana::size_c<2>) == hana::make_tuple(0), "");
BOOST_HANA_CONSTANT_CHECK(hana::drop_back(xs, hana::size_c<3>) == hana::make_tuple());
BOOST_HANA_CONSTANT_CHECK(hana::drop_back(xs, hana::size_c<4>) == hana::make_tuple());
static_assert(hana::drop_back(xs) == hana::make_tuple(0, '1'), "");
int main() { }

constexpr auto boost::hana::group

<#include <boost/hana/fwd/group.hpp>>

Initial value:

= [](auto&& xs[, auto&& predicate]) {
        return tag-dispatched;
    }

Групповые смежные элементы последовательности, которые все уважают бинарный предикат, по умолчанию равенство.Признается, чтоПоследовательность и необязательный предикат (по умолчанию<equal>),<group>возвращает последовательность подпоследовательности, представляющую группы соседних элементов, которые «равны» по отношению к предикату. Другими словами, группы таковы, что предикат удовлетворяется, когда он применяется к любым двум соседним элементам в этой группе. Последовательность, возвращаемая<group>, такова, что сцепление ее элементов равно исходной последовательности, что эквивалентно утверждению, что порядок элементов не изменяется.

Если предикат не предусмотрен, все смежные элементы в последовательности должны быть компиляционными<Comparable>.

Signature

При наличии последовательности<s>с меткой<S(T)>,<IntegralConstant><Bool>, имеющей значение типа<bool>, и предиката \(предварительно: T \times T \to Bool \),<group>имеет следующие подписи. Для варианта с заданным предикатом,

\[ \mathtt{group} : S(T) \times (T \times T \to Bool) \to S(S(T)) \]

Для варианта без пользовательского предиката<T>требуется сопоставимость. Подпись тогда

\[ \mathtt{group} : S(T) \to S(S(T)) \]

Parameters

xs Последовательность для разделения на группы.

predicate Бинарная функция, называемая<predicate(x, y)>, где<x>и<y>являютсясмежнымиэлементами в последовательности, должны ли оба элемента находиться в одной группе (последовательности) результата. В текущей версии библиотеки результат, возвращенный<predicate>, должен быть<IntegralConstant>с значением типа, конвертируемого в<bool>. Кроме того,<predicate>должно определить отношение эквивалентности, как определено понятием<Comparable>. Когда этот предикат не предусмотрен, он по умолчанию соответствует<equal>, что требует сравнения любых двух соседних элементов в последовательности для возврата булевого<IntegralConstant>.

Syntactic sugar (`group.by`)

<group>можно назвать третьим способом, который обеспечивает хороший синтаксис, особенно при работе с комбинатором<comparing>:

group.by(predicate, xs) == group(xs, predicate)

group.by(predicate) == group(-, predicate)

где<group(-, predicate)>обозначает частичное применение<group>к<predicate>.

Example

// 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)
#include <boost/hana/assert.hpp>
#include <boost/hana/comparing.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/group.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/length.hpp>
#include <boost/hana/range.hpp>
#include <boost/hana/tuple.hpp>
#include <boost/hana/type.hpp>
namespace hana = boost::hana;
// group without a predicate
BOOST_HANA_CONSTANT_CHECK(
    hana::group(hana::make_tuple(hana::int_c<1>, hana::long_c<1>, hana::type_c<int>, hana::char_c<'x'>, hana::char_c<'x'>))
        == hana::make_tuple(
            hana::make_tuple(hana::int_c<1>, hana::long_c<1>),
            hana::make_tuple(hana::type_c<int>),
            hana::make_tuple(hana::char_c<'x'>, hana::char_c<'x'>)
        )
);
// group with a predicate
constexpr auto tuples = hana::make_tuple(
    hana::range_c<int, 0, 1>,
    hana::range_c<int, 0, 2>,
    hana::range_c<int, 1, 3>,
    hana::range_c<int, 2, 6>
);
BOOST_HANA_CONSTANT_CHECK(
    hana::group(tuples, hana::comparing(hana::length))
        == hana::make_tuple(
            hana::make_tuple(
                hana::range_c<int, 0, 1>
            ),
            hana::make_tuple(
                hana::range_c<int, 0, 2>,
                hana::range_c<int, 1, 3>
            ),
            hana::make_tuple(
                hana::range_c<int, 2, 6>
            )
        )
);
// group.by is syntactic sugar
static_assert(
    hana::group.by(hana::comparing(hana::typeid_),
                   hana::make_tuple(1, 2, 3, 'x', 'y', 4.4, 5.5))
        == hana::make_tuple(
            hana::make_tuple(1, 2, 3),
            hana::make_tuple('x', 'y'),
            hana::make_tuple(4.4, 5.5)
        )
, "");
int main() { }

constexpr auto boost::hana::insert {}

<#include <boost/hana/fwd/insert.hpp>>

Вставить значение в заданный индекс в последовательности. При наличии последовательности, индекса и элемента для вставки<insert>вставляет элемент в данный индекс.

Parameters

xs	Последовательность, в которую следует вставить значение.
n	Индекс, по которому должен быть вставлен элемент. Это должно быть неотрицательно<`Constant`>интегрального типа, и также должно быть верно, что<`n < length(xs)`>, если<`xs`>является конечной последовательностью.
element	Элемент для вставки в последовательность.

Example

// 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)
#include <boost/hana/assert.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/insert.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/tuple.hpp>
#include <string>
namespace hana = boost::hana;
using namespace hana::literals;
using namespace std::literals;
int main() {
    auto xs = hana::make_tuple("Hello"s, "world!"s);
    BOOST_HANA_RUNTIME_CHECK(
        hana::insert(xs, 1_c, " "s) == hana::make_tuple("Hello"s, " "s, "world!"s)
    );
}

constexpr auto boost::hana::insert_range

<#include <boost/hana/fwd/insert_range.hpp>>

Initial value:

= [](auto&& xs, auto&& n, auto&& elements) {
        return tag-dispatched;
    }

Вставьте несколько значений в заданный индекс в последовательности. При наличии последовательности, индекса и любого<Foldable>, содержащего элементы для вставки,<insert_range>вставляет элементы в<Foldable>при заданном индексе последовательности.

Parameters

xs	Последовательность, в которую следует вставлять значения.
n	Индекс, по которому должны быть вставлены элементы. Это должно быть неотрицательно<`Constant`>интегрального типа, и также должно быть верно, что<`n < length(xs)`>, если<`xs`>является конечной последовательностью.
elements	А<`Foldable`>содержит элементы для вставки в последовательность.

Example

// 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)
#include <boost/hana/assert.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/insert_range.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/tuple.hpp>
#include <string>
namespace hana = boost::hana;
using namespace hana::literals;
using namespace std::literals;
int main() {
    auto xs = hana::make_tuple("Hello"s, "world!"s);
    BOOST_HANA_RUNTIME_CHECK(
        hana::insert_range(xs, 1_c, hana::make_tuple(1, 2, 3)) == hana::make_tuple("Hello"s, 1, 2, 3, "world!"s)
    );
}

constexpr auto boost::hana::intersperse

<#include <boost/hana/fwd/intersperse.hpp>>

Initial value:

= [](auto&& xs, auto&& z) {
        return tag-dispatched;
    }

Вставьте значение между каждой парой элементов в конечную последовательность. При наличии конечного<Sequence><xs>с линеаризацией<[x1, x2, ..., xn]>,<intersperse(xs, z)>представляет собой новую последовательность с линеаризацией<[x1, z, x2, z, x3, ..., xn-1, z, xn]>. Другими словами, он вставляет элемент<z>между каждой парой элементов исходной последовательности. Если последовательность пуста или имеет один элемент,<intersperse>возвращает последовательность как есть. Во всех случаях последовательность должна быть конечной.

Parameters

xs	Последовательность, в которой значение перемежается.
z	Значение, которое необходимо вставить между каждой парой элементов последовательности.

Example

// 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)
#include <boost/hana/assert.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/intersperse.hpp>
#include <boost/hana/tuple.hpp>
namespace hana = boost::hana;
static_assert(hana::intersperse(hana::make_tuple(1, '2', 3.3), 'x') == hana::make_tuple(1, 'x', '2', 'x', 3.3), "");
BOOST_HANA_CONSTANT_CHECK(hana::intersperse(hana::make_tuple(), 'x') == hana::make_tuple());
int main() { }

constexpr auto boost::hana::partition

<#include <boost/hana/fwd/partition.hpp>>

Initial value:

= [](auto&& xs, auto&& predicate) {
        return tag-dispatched;
    }

Разделение последовательности на основе<predicate>.В частности, возвращает неопределенный<Product>, первый элемент которого представляет собой последовательность элементов, удовлетворяющих предикату, и второй элемент которого представляет собой последовательность элементов, не удовлетворяющих предикату.

Signature

При наличии последовательности<S(T)>,<IntegralConstant><Bool>, имеющей значение типа<bool>, и предиката \( T \to Bool \),<partition>имеет следующую подпись:

\[ \mathtt{partition} : S(T) \times (T \to Bool) \to S(T) \times S(T) \]

Parameters

xs Последовательность должна быть разделена.

predicate Функция, называемая<predicate(x)>для каждого элемента<x>в последовательности и возвращающая, следует ли<x>добавлять к последовательности в первом компоненте или во втором компоненте получающейся пары. В текущей версии библиотеки<predicate>должен вернуть<IntegralConstant>, держащее значение, конвертируемое в<bool>.

Syntactic sugar (`partition.by`)

<partition>можно назвать попеременно, что обеспечивает хороший синтаксис в некоторых случаях, когда предикат короткий:

partition.by(predicate, xs) == partition(xs, predicate)

partition.by(predicate) == partition(-, predicate)

где<partition(-, predicate)>обозначает частичное применение<partition>к<predicate>.

Example

// 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)
#include <boost/hana/assert.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/ext/std/integral_constant.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/mod.hpp>
#include <boost/hana/not_equal.hpp>
#include <boost/hana/pair.hpp>
#include <boost/hana/partition.hpp>
#include <boost/hana/tuple.hpp>
#include <boost/hana/type.hpp>
#include <type_traits>
namespace hana = boost::hana;
BOOST_HANA_CONSTANT_CHECK(
    hana::partition(hana::tuple_c<int, 1, 2, 3, 4, 5, 6, 7>, [](auto x) {
        return x % hana::int_c<2> != hana::int_c<0>;
    })
    ==
    hana::make_pair(
        hana::tuple_c<int, 1, 3, 5, 7>,
        hana::tuple_c<int, 2, 4, 6>
    )
);
BOOST_HANA_CONSTANT_CHECK(
    hana::partition(hana::tuple_t<void, int, float, char, double>, hana::trait<std::is_floating_point>)
    ==
    hana::make_pair(
        hana::tuple_t<float, double>,
        hana::tuple_t<void, int, char>
    )
);
// partition.by is syntactic sugar
BOOST_HANA_CONSTANT_CHECK(
    hana::partition.by(hana::trait<std::is_floating_point>,
                       hana::tuple_t<void, int, float, char, double>)
    ==
    hana::make_pair(
        hana::tuple_t<float, double>,
        hana::tuple_t<void, int, char>
    )
);
int main() { }

constexpr auto boost::hana::permutations

<#include <boost/hana/fwd/permutations.hpp>>

Initial value:

= [](auto&& xs) {
        return tag-dispatched;
    }

Верните последовательность всех перестановок данной последовательности. В частности,<permutations(xs)>представляет собой последовательность, элементы которой являются перестановками исходной последовательности<xs>. Преобразования не гарантируются в каком-либо определенном порядке. Также обратите внимание, что количество перестановок растет очень быстро по мере увеличения длины исходной последовательности. Темп роста<O(length(xs)!)>; с последовательностью<xs>длины всего 8,<permutations(xs)>содержит более 40 000 элементов!

Example

// 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)
#include <boost/hana/all_of.hpp>
#include <boost/hana/assert.hpp>
#include <boost/hana/config.hpp>
#include <boost/hana/contains.hpp>
#include <boost/hana/functional/curry.hpp>
#include <boost/hana/permutations.hpp>
#include <boost/hana/tuple.hpp>
namespace hana = boost::hana;
BOOST_HANA_CONSTEXPR_LAMBDA auto is_permutation_of = hana::curry<2>([](auto xs, auto perm) {
    return hana::contains(hana::permutations(xs), perm);
});
int main() {
    BOOST_HANA_CONSTEXPR_CHECK(
        hana::all_of(
            hana::make_tuple(
                hana::make_tuple('1', 2, 3.0),
                hana::make_tuple('1', 3.0, 2),
                hana::make_tuple(2, '1', 3.0),
                hana::make_tuple(2, 3.0, '1'),
                hana::make_tuple(3.0, '1', 2),
                hana::make_tuple(3.0, 2, '1')
            ),
            is_permutation_of(hana::make_tuple('1', 2, 3.0))
        )
    );
}

constexpr auto boost::hana::remove_at

<#include <boost/hana/fwd/remove_at.hpp>>

Initial value:

= [](auto&& xs, auto const& n) {
        return tag-dispatched;
    }

Удалите элемент в заданном индексе из последовательности.<remove_at>возвращает новую последовательность, идентичную исходной, за исключением того, что элемент в данном индексе удаляется. В частности,<remove_at([x0, ..., xn-1, xn, xn+1, ..., xm], n)>представляет собой новую последовательность, эквивалентную<[x0, ..., xn-1, xn+1, ..., xm]>.

Note: The behavior is undefined if the index is out of the bounds of the sequence.

Parameters

xs	Последовательность, из которой должен быть удален элемент.
n	Неотрицательный<`IntegralConstant`>, представляющий индекс элемента, который должен быть удален из последовательности. Поведение не определено, если этот индекс не находится в границах последовательности.

Example

// 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)
#include <boost/hana/equal.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/remove_at.hpp>
#include <boost/hana/tuple.hpp>
namespace hana = boost::hana;
constexpr auto xs = hana::make_tuple(0, '1', 2.2, 3u);
static_assert(hana::remove_at(xs, hana::size_c<2>) == hana::make_tuple(0, '1', 3u), "");
int main() { }

template<std::size_t n>

constexpr auto boost::hana::remove_at_c

<#include <boost/hana/fwd/remove_at.hpp>>

Initial value:

= [](auto&& xs) {
        return hana::remove_at(forwarded(xs), hana::size_c<n>);
    }

<remove_at>Для удобства.

Example

// 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)
#include <boost/hana/equal.hpp>
#include <boost/hana/remove_at.hpp>
#include <boost/hana/tuple.hpp>
namespace hana = boost::hana;
constexpr auto xs = hana::make_tuple(0, '1', 2.2, 3u);
static_assert(hana::remove_at_c<2>(xs) == hana::make_tuple(0, '1', 3u), "");
int main() { }

constexpr auto boost::hana::remove_range

<#include <boost/hana/fwd/remove_range.hpp>>

Initial value:

= [](auto&& xs, auto const& from, auto const& to) {
        return tag-dispatched;
    }

Удалите элементы внутри заданного диапазона индексов из последовательности.<remove_range>возвращает новую последовательность, идентичную исходной, за исключением того, что элементы в индексах в предоставленном диапазоне удаляются. В частности,<remove_range([x0, ..., xn], from, to)>представляет собой новую последовательность, эквивалентную<[x0, ..., x_from-1, x_to, ..., xn]>.

Note: The behavior is undefined if the range contains any index out of the bounds of the sequence.

Parameters

xs Последовательность, из которой удаляются элементы.

[from,to) Полуоткрытый интервал<IntegralConstant>s, представляющий индексы элементов, подлежащих удалению из последовательности.<IntegralConstant>с в полуоткрытом интервале должны быть неотрицательными и в границах последовательности. Полуоткрытый интервал также должен быть действительным, то есть<from <= to>.

Example

// 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)
#include <boost/hana/equal.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/remove_range.hpp>
#include <boost/hana/tuple.hpp>
namespace hana = boost::hana;
constexpr auto xs = hana::make_tuple(0, '1', 2.2, 3u, 4, 5.5);
static_assert(hana::remove_range(xs, hana::size_c<2>, hana::size_c<4>) == hana::make_tuple(0, '1', 4, 5.5), "");
int main() { }

template<std::size_t from, std::size_t to>

constexpr auto boost::hana::remove_range_c

<#include <boost/hana/fwd/remove_range.hpp>>

Initial value:

= [](auto&& xs) {
        return hana::remove_range(forwarded(xs), hana::size_c<from>, hana::size_c<to>);
    }

<remove_range>, для удобства.

Example

// 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)
#include <boost/hana/equal.hpp>
#include <boost/hana/remove_range.hpp>
#include <boost/hana/tuple.hpp>
namespace hana = boost::hana;
constexpr auto xs = hana::make_tuple(0, '1', 2.2, 3u, 4, 5.5);
static_assert(hana::remove_range_c<2, 4>(xs) == hana::make_tuple(0, '1', 4, 5.5), "");
int main() { }

constexpr auto boost::hana::reverse

<#include <boost/hana/fwd/reverse.hpp>>

Initial value:

= [](auto&& xs) {
        return tag-dispatched;
    }

Переверните последовательность. В частности,<reverse(xs)>представляет собой новую последовательность, содержащую те же элементы, что и<xs>, за исключением обратного порядка.

Parameters

xs	Последовательность, чтобы изменить.

Example

// 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)
#include <boost/hana/equal.hpp>
#include <boost/hana/reverse.hpp>
#include <boost/hana/tuple.hpp>
namespace hana = boost::hana;
static_assert(hana::reverse(hana::make_tuple(1, '2', 3.3)) == hana::make_tuple(3.3, '2', 1), "");
int main() { }

constexpr auto boost::hana::scan_left

<#include <boost/hana/fwd/scan_left.hpp>>

Initial value:

= [](auto&& xs[, auto&& state], auto const& f) {
        return tag-dispatched;
    }

Сложите последовательность слева и верните список, содержащий последовательные состояния сокращения. Подобно<fold_left>,<scan_left>уменьшает последовательность до одного значения с помощью двоичной операции. Однако, в отличие от<fold_left>, он создает последовательность промежуточных результатов, вычисленных по пути, и возвращает, что вместо окончательного состояния восстановления. Как и<fold_left>,<scan_left>можно использовать с начальным состоянием восстановления или без него.

Когда последовательность пуста, могут возникнуть две вещи. Если первоначальное состояние было предоставлено, возвращается список синглтона, содержащий это состояние. В противном случае, если начальное состояние не было предоставлено, возвращается пустой список. В частности, в отличие от<fold_left>, использование<scan_left>на пустой последовательности без начального состояния не является ошибкой.

Более конкретно,<scan_left([x1, ..., xn], state, f)>является последовательностью, чей<i>элемент эквивалентен<fold_left([x1, ..., xi], state, f)>. Вариант без государства обрабатывается аналогичным образом. Для иллюстрации рассмотрим эту левую складку на короткой последовательности:

fold_left([x1, x2, x3], state, f) == f(f(f(state, x1), x2), x3)

Аналогичная последовательность, сгенерированная с<scan_left>, будет

scan_left([x1, x2, x3], state, f) == [
    state,
    f(state, x1),
    f(f(state, x1), x2),
    f(f(f(state, x1), x2), x3)
]

Аналогично, рассмотрим эту левую складку (без начального состояния) на короткой последовательности:

fold_left([x1, x2, x3, x4], f) == f(f(f(x1, x2), x3), x4)

Аналогичная последовательность, сгенерированная с<scan_left>, будет

scan_left([x1, x2, x3, x4], f) == [
    x1,
    f(x1, x2),
    f(f(x1, x2), x3),
    f(f(f(x1, x2), x3), x4)
]

Parameters

xs	Последовательность для сканирования слева.
state	Состояние (факультативно) первоначального сокращения.
f	Бинарная функция называется<`f(state, x)`>, где<`state`>является результатом, накопленным до сих пор, и<`x`>является элементом в последовательности. Если начальное состояние не предусмотрено,<`f`>называется<`f(x1, x2)`>, где<`x1`>и<`x2`>являются элементами последовательности.

Example

// 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)
#include <boost/hana/assert.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/scan_left.hpp>
#include <boost/hana/tuple.hpp>
#include <sstream>
namespace hana = boost::hana;
auto to_string = [](auto x) {
    std::ostringstream ss;
    ss << x;
    return ss.str();
};
auto f = [](auto state, auto element) {
    return "f(" + to_string(state) + ", " + to_string(element) + ")";
};
int main() {
    // with initial state
    BOOST_HANA_RUNTIME_CHECK(hana::scan_left(hana::make_tuple(2, "3", '4'), 1, f) == hana::make_tuple(
        1,
        "f(1, 2)",
        "f(f(1, 2), 3)",
        "f(f(f(1, 2), 3), 4)"
    ));
    // without initial state
    BOOST_HANA_RUNTIME_CHECK(hana::scan_left(hana::make_tuple(1, "2", '3'), f) == hana::make_tuple(
        1,
        "f(1, 2)",
        "f(f(1, 2), 3)"
    ));
}

constexpr auto boost::hana::scan_right

<#include <boost/hana/fwd/scan_right.hpp>>

Initial value:

= [](auto&& xs[, auto&& state], auto const& f) {
        return tag-dispatched;
    }

Сложите последовательность вправо и верните список, содержащий последовательные состояния сокращения. Подобно<fold_right>,<scan_right>уменьшает последовательность до одного значения с помощью двоичной операции. Однако, в отличие от<fold_right>, он создает последовательность промежуточных результатов, вычисленных по пути, и возвращает, что вместо окончательного состояния восстановления. Как и<fold_right>,<scan_right>может использоваться с начальным состоянием восстановления или без него.

Когда последовательность пуста, могут возникнуть две вещи. Если первоначальное состояние было предоставлено, возвращается список синглтона, содержащий это состояние. В противном случае, если начальное состояние не было предоставлено, возвращается пустой список. В частности, в отличие от<fold_right>, использование<scan_right>на пустой последовательности без начального состояния не является ошибкой.

Более конкретно,<scan_right([x1, ..., xn], state, f)>является последовательностью, чей<i>элемент эквивалентен<fold_right([x1, ..., xi], state, f)>. Вариант без государства обрабатывается аналогичным образом. Для иллюстрации рассмотрим эту правую складку на короткой последовательности:

fold_right([x1, x2, x3], state, f) == f(x1, f(x2, f(x3, state)))

Аналогичная последовательность, сгенерированная с<scan_right>, будет

scan_right([x1, x2, x3], state, f) == [
    f(x1, f(x2, f(x3, state))),
          f(x2, f(x3, state)),
                f(x3, state),
                      state
]

Аналогично, рассмотрим эту правую складку (без начального состояния) на короткой последовательности:

fold_right([x1, x2, x3, x4], f) == f(x1, f(x2, f(x3, x4)))

Аналогичная последовательность, сгенерированная с<scan_right>, будет

scan_right([x1, x2, x3, x4], f) == [
    f(x1, f(x2, f(x3, x4))),
          f(x2, f(x3, x4)),
                f(x3, x4),
                      x4
]

Parameters

xs	Последовательность для сканирования справа.
state	Состояние (факультативно) первоначального сокращения.
f	Бинарная функция называется<`f(x, state)`>, где<`state`>является результатом, накопленным до сих пор, и<`x`>является элементом в последовательности. При отсутствии начального состояния<`f`>называется<`f(x1, x2)`>, где<`x1`>и<`x2`>являются элементами последовательности.

Example

// 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)
#include <boost/hana/assert.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/scan_right.hpp>
#include <boost/hana/tuple.hpp>
#include <sstream>
namespace hana = boost::hana;
auto to_string = [](auto x) {
    std::ostringstream ss;
    ss << x;
    return ss.str();
};
auto f = [](auto element, auto state) {
    return "f(" + to_string(element) + ", " + to_string(state) + ")";
};
int main() {
    // with initial state
    BOOST_HANA_RUNTIME_CHECK(hana::scan_right(hana::make_tuple(1, "2", '3'), 4, f) == hana::make_tuple(
        "f(1, f(2, f(3, 4)))",
        "f(2, f(3, 4))",
        "f(3, 4)",
        4
    ));
    // without initial state
    BOOST_HANA_RUNTIME_CHECK(hana::scan_right(hana::make_tuple(1, "2", '3'), f) == hana::make_tuple(
        "f(1, f(2, 3))",
        "f(2, 3)",
        '3'
    ));
}

constexpr auto boost::hana::slice

<#include <boost/hana/fwd/slice.hpp>>

Initial value:

= [](auto&& xs, auto&& indices) {
        return tag-dispatched;
    }

Извлеките элементы a<Sequence>по заданным показателям. Учитывая произвольную последовательность<indices>,<slice>возвращает новую последовательность элементов исходной последовательности, которые появляются в этих индексах. Другими словами,

slice([x1, ..., xn], [i1, ..., ik]) == [x_i1, ..., x_ik]

Индексы не должны быть упорядочены или смежными каким-либо определенным образом, но они не должны выходить за пределы последовательности. Также можно несколько раз указать один и тот же индекс, и в этом случае элемент этого индекса будет неоднократно включен в полученную последовательность.

Parameters

xs Последовательность, из которой извлекается последовательность.

indices Время компиляции<Foldable>, содержащее неотрицательные<IntegralConstant>с, представляющие индексы. Индексы основаны на 0, и все они должны быть в пределах последовательности<xs>. Обратите внимание, что любое<Foldable>действительно будет делать (например, нет необходимости в<Iterable>); для определения порядка элементов, включенных в срез, используется линеаризация<indices>.

Example

// 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)
#include <boost/hana/assert.hpp>
#include <boost/hana/core/to.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/filter.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/length.hpp>
#include <boost/hana/mod.hpp>
#include <boost/hana/range.hpp>
#include <boost/hana/slice.hpp>
#include <boost/hana/tuple.hpp>
#include <boost/hana/type.hpp>
namespace hana = boost::hana;
using namespace hana::literals;
// Slice a contiguous range
constexpr auto xs = hana::make_tuple(0, '1', 2.2, 3_c, hana::type_c<float>);
static_assert(
    hana::slice(xs, hana::tuple_c<std::size_t, 1, 2, 3>) ==
    hana::make_tuple('1', 2.2, 3_c)
, "");
// A more complex example with a non-contiguous range
constexpr auto letters = hana::to_tuple(hana::range_c<char, 'a', 'z'>);
constexpr auto indices = hana::to_tuple(hana::make_range(hana::size_c<0>, hana::length(letters)));
auto even_indices = hana::filter(indices, [](auto n) {
    return n % hana::size_c<2> == hana::size_c<0>;
});
BOOST_HANA_CONSTANT_CHECK(
    hana::slice(letters, even_indices) == hana::tuple_c<char,
        'a', 'c', 'e', 'g', 'i', 'k', 'm', 'o', 'q', 's', 'u', 'w', 'y'
    >
);
int main() { }

template<std::size_t from, std::size_t to>

constexpr auto boost::hana::slice_c

<#include <boost/hana/fwd/slice.hpp>>

Initial value:

= [](auto&& xs) {
        return hana::slice(forwarded(xs), hana::range_c<std::size_t, from, to>);
    }

Сокращение до<slice>непрерывного ряда элементов.<slice_c>— это просто сокращение, чтобы разрезать смежный диапазон элементов. В частности,<slice_c<from, to>(xs)>эквивалентно<slice(xs, range_c<std::size_t, from, to>)>, которое просто разрезает все элементы<xs>, содержащиеся в полуоткрытом интервале, ограниченном<[from, to)>. Как и для<slice>, индексы, используемые с<slice_c>, основаны на 0, и они должны быть в пределах нарезанной последовательности.

Template Parameters

from	Индекс первого элемента в срезе.
to	Однократный индекс последнего элемента в срезе. Это должно быть сделано<`from <= to`>.

Example

// 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)
#include <boost/hana/equal.hpp>
#include <boost/hana/slice.hpp>
#include <boost/hana/tuple.hpp>
#include <boost/hana/type.hpp>
namespace hana = boost::hana;
static_assert(
    hana::slice_c<1, 3>(hana::make_tuple(1, '2', 3.3, hana::type_c<float>))
            ==
    hana::make_tuple('2', 3.3)
, "");
int main() { }

constexpr auto boost::hana::sort

<#include <boost/hana/fwd/sort.hpp>>

Initial value:

= [](auto&& xs[, auto&& predicate]) {
        return tag-dispatched;
    }

Сортировать последовательность, необязательно основанную на заказе<predicate>.Учитывая последовательность и необязательный предикат (по умолчанию<less>),<sort>возвращает новую последовательность, содержащую те же элементы, что и оригинал, за исключением того, что они упорядочены таким образом, что если<x>предшествует<y>в последовательности, то либо<predicate(x, y)>является истинным, либо оба<predicate(x, y)>и<predicate(y, x)>являются ложными.

Также обратите внимание, что сорт гарантированно будет стабильным. Следовательно, если<x>предшествует<y>в исходной последовательности и оба<predicate(x, y)>и<predicate(y, x)>являются ложными, то<x>будет предшествовать<y>в полученной последовательности.

Если предикат не предусмотрен, все элементы в последовательности должны быть компиляционными<Orderable>.

Signature

Учитывая<Sequence><S(T)>, булев<IntegralConstant><Bool>и двоичный предикат \( T \times T \to Bool \),<sort>имеет следующие подписи. Для варианта с заданным предикатом,

\[ \mathtt{sort} : S(T) \times (T \times T \to Bool) \to S(T) \]

Для варианта без пользовательского предиката<T>требуется<Orderable>. Подпись тогда

\[ \mathtt{sort} : S(T) \to S(T) \]

Parameters

xs Последовательность для сортировки.

predicate Функция, называемая<predicate(x, y)>для двух элементов<x>и<y>последовательности, и возвращающая булевой<IntegralConstant>, представляющий, следует ли<x>считатьменее, чем<y>, т.е. должно ли<x>появлятьсядо<y>в полученной последовательности. Более конкретно,<predicate>должен определятьстрогий слабый порядокна элементах последовательности. Когда предикат не указан, это по умолчанию<less>. В текущей версии библиотеки предикат должен вернуть<IntegralConstant>, держащее значение, конвертируемое в<bool>.

Syntactic sugar (`sort.by`)

<sort>можно назвать третьим способом, который обеспечивает хороший синтаксис, особенно при работе с комбинатором<ordering>:

sort.by(predicate, xs) == sort(xs, predicate)

sort.by(predicate) == sort(-, predicate)

где<sort(-, predicate)>означает частичное применение<sort>к<predicate>.

Example

// 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)
#include <boost/hana/assert.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/front.hpp>
#include <boost/hana/greater.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/negate.hpp>
#include <boost/hana/ordering.hpp>
#include <boost/hana/sort.hpp>
#include <boost/hana/tuple.hpp>
#include <string>
namespace hana = boost::hana;
using namespace hana::literals;
using namespace std::literals;
// sort without a predicate
BOOST_HANA_CONSTANT_CHECK(
    hana::sort(hana::make_tuple(1_c, -2_c, 3_c, 0_c)) ==
               hana::make_tuple(-2_c, 0_c, 1_c, 3_c)
);
// sort with a predicate
BOOST_HANA_CONSTANT_CHECK(
    hana::sort(hana::make_tuple(1_c, -2_c, 3_c, 0_c), hana::greater) ==
               hana::make_tuple(3_c, 1_c, 0_c, -2_c)
);
int main() {
    // sort.by is syntactic sugar
    auto tuples = hana::make_tuple(
        hana::make_tuple(2_c, 'x', nullptr),
        hana::make_tuple(1_c, "foobar"s, hana::int_c<4>)
    );
    BOOST_HANA_RUNTIME_CHECK(
        hana::sort.by(hana::ordering(hana::front), tuples)
            == hana::make_tuple(
                hana::make_tuple(1_c, "foobar"s, hana::int_c<4>),
                hana::make_tuple(2_c, 'x', nullptr)
            )
    );
}

constexpr auto boost::hana::span

<#include <boost/hana/fwd/span.hpp>>

Initial value:

= [](auto&& xs, auto&& predicate) {
        return tag-dispatched;
    }

Возвращает<Product>, содержащий самый длинный префикс последовательности, удовлетворяющей предикату, и остальную последовательность. Первый компонент возвращаемого<Product>представляет собой последовательность, для которой все элементы удовлетворяют данному предикату. Второй компонент возвращаемого<Product>представляет собой последовательность, содержащую остаток аргумента. Обе или обе последовательности могут быть пустыми, в зависимости от входного аргумента. Более конкретно.

span(xs, predicate) == make_pair(take_while(xs, predicate),

drop_while(xs, predicate))

(254) может быть только произвольным (255).

Signature

Если дано<Sequence><S(T)>,<Logical><Bool>и предикат \( T \to Bool \),<span>имеет следующую подпись:

\[ \mathtt{span} : S(T) \times (T \to Bool) \to S(T) \times S(T) \]

Parameters

xs	Последовательность разбивается на две части.
predicate	Функция называется<`predicate(x)`>, где<`x`>является элементом последовательности, и возвращает<`Logical. In the current implementation of the library,`>предикат<`has to return a compile-time`>Логика.

Syntactic sugar (`span.by`)

<span>можно назвать попеременно, что обеспечивает хороший синтаксис в некоторых случаях, когда предикат короткий:

span.by(predicate, xs) == span(xs, predicate)

span.by(predicate) == span(-, predicate)

где<span(-, predicate)>означает частичное применение<span>к<predicate>.

Example

// 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)
#include <boost/hana/assert.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/less.hpp>
#include <boost/hana/pair.hpp>
#include <boost/hana/span.hpp>
#include <boost/hana/tuple.hpp>
namespace hana = boost::hana;
constexpr auto xs = hana::make_tuple(hana::int_c<1>, hana::int_c<2>, hana::int_c<3>, hana::int_c<4>);
BOOST_HANA_CONSTANT_CHECK(
    hana::span(xs, hana::less.than(hana::int_c<3>))
    ==
    hana::make_pair(hana::make_tuple(hana::int_c<1>, hana::int_c<2>),
                    hana::make_tuple(hana::int_c<3>, hana::int_c<4>))
);
BOOST_HANA_CONSTANT_CHECK(
    hana::span(xs, hana::less.than(hana::int_c<0>))
    ==
    hana::make_pair(hana::make_tuple(), xs)
);
BOOST_HANA_CONSTANT_CHECK(
    hana::span(xs, hana::less.than(hana::int_c<5>))
    ==
    hana::make_pair(xs, hana::make_tuple())
);
// span.by is syntactic sugar
BOOST_HANA_CONSTANT_CHECK(
    hana::span.by(hana::less.than(hana::int_c<3>), xs)
    ==
    hana::make_pair(hana::make_tuple(hana::int_c<1>, hana::int_c<2>),
                    hana::make_tuple(hana::int_c<3>, hana::int_c<4>))
);
int main() { }

constexpr auto boost::hana::take_back

<#include <boost/hana/fwd/take_back.hpp>>

Initial value:

= [](auto&& xs, auto const& n) {
        return tag-dispatched;
    }

Возвращает последние<n>элементы последовательности или всю последовательность, если последовательность имеет меньше<n>элементов.<Sequence><xs>и<IntegralConstant><n>,<take_back(xs, n)>представляет собой новую последовательность, содержащую последние<n>элементы<xs>, в том же порядке. Если<length(xs) <= n>, вся последовательность возвращается, и ошибка не запускается.

Parameters

xs	Последовательность для взятия элементов из.
n	Неотрицательный<`IntegralConstant`>, представляющий количество элементов, которые должны находиться в результирующей последовательности.

Example

// 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)
#include <boost/hana/assert.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/take_back.hpp>
#include <boost/hana/tuple.hpp>
namespace hana = boost::hana;
BOOST_HANA_CONSTANT_CHECK(hana::take_back(hana::make_tuple(1, '2', 3.3), hana::size_c<0>) == hana::make_tuple());
static_assert(hana::take_back(hana::make_tuple(1, '2', 3.3), hana::size_c<1>) == hana::make_tuple(3.3), "");
static_assert(hana::take_back(hana::make_tuple(1, '2', 3.3), hana::size_c<2>) == hana::make_tuple('2', 3.3), "");
static_assert(hana::take_back(hana::make_tuple(1, '2', 3.3), hana::size_c<3>) == hana::make_tuple(1, '2', 3.3), "");
static_assert(hana::take_back(hana::make_tuple(1, '2', 3.3), hana::size_c<4>) == hana::make_tuple(1, '2', 3.3), "");
int main() { }

constexpr auto boost::hana::take_front

<#include <boost/hana/fwd/take_front.hpp>>

Initial value:

= [](auto&& xs, auto const& n) {
        return tag-dispatched;
    }

Возвращает первые<n>элементы последовательности или всю последовательность, если последовательность имеет меньше<n>элементов. Учитывая<Sequence><xs>и<IntegralConstant><n>,<take_front(xs, n)>представляет собой новую последовательность, содержащую первые<n>элементы<xs>, в том же порядке. Если<length(xs) <= n>, вся последовательность возвращается, и ошибка не запускается.

Parameters

xs	Последовательность для взятия элементов из.
n	Неотрицательный<`IntegralConstant`>, представляющий количество элементов, которые должны находиться в результирующей последовательности.

Example

// 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)
#include <boost/hana/assert.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/take_front.hpp>
#include <boost/hana/tuple.hpp>
namespace hana = boost::hana;
BOOST_HANA_CONSTANT_CHECK(hana::take_front(hana::make_tuple(1, '2', 3.3), hana::size_c<0>) == hana::make_tuple());
static_assert(hana::take_front(hana::make_tuple(1, '2', 3.3), hana::size_c<1>) == hana::make_tuple(1), "");
static_assert(hana::take_front(hana::make_tuple(1, '2', 3.3), hana::size_c<2>) == hana::make_tuple(1, '2'), "");
static_assert(hana::take_front(hana::make_tuple(1, '2', 3.3), hana::size_c<3>) == hana::make_tuple(1, '2', 3.3), "");
static_assert(hana::take_front(hana::make_tuple(1, '2', 3.3), hana::size_c<4>) == hana::make_tuple(1, '2', 3.3), "");
int main() { }

template<std::size_t n>

constexpr auto boost::hana::take_front_c

<#include <boost/hana/fwd/take_front.hpp>>

Initial value:

= [](auto&& xs) {
        return hana::take_front(forwarded(xs), hana::size_c<n>);
    }

<take_front>Для удобства.

Example

// 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)
#include <boost/hana/equal.hpp>
#include <boost/hana/take_front.hpp>
#include <boost/hana/tuple.hpp>
namespace hana = boost::hana;
static_assert(hana::take_front_c<2>(hana::make_tuple(1, '2', 3.3)) == hana::make_tuple(1, '2'), "");
int main() { }

constexpr auto boost::hana::take_while

<#include <boost/hana/fwd/take_while.hpp>>

Initial value:

= [](auto&& xs, auto&& predicate) {
        return tag-dispatched;
    }

Взять элементы из последовательности, пока удовлетворяется<predicate>. В частности,<take_while>возвращает новую последовательность, содержащую самый длинный префикс<xs>, в котором все элементы удовлетворяют данному предикату.

Parameters

xs Последовательность для взятия элементов из.

predicate Функция, называемая<predicate(x)>, где<x>является элементом последовательности, и возвращающая<Logical>, представляющая, следует ли<x>включать в полученную последовательность. В текущей версии библиотеки<predicate>должно быть возвращено<Constant Logical>.

Example

// 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)
#include <boost/hana/assert.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/less.hpp>
#include <boost/hana/take_while.hpp>
#include <boost/hana/tuple.hpp>
namespace hana = boost::hana;
using namespace hana::literals;
BOOST_HANA_CONSTANT_CHECK(
    hana::take_while(hana::tuple_c<int, 0, 1, 2, 3>, hana::less.than(2_c))
    ==
    hana::tuple_c<int, 0, 1>
);
int main() { }

template<typename S >

constexpr auto boost::hana::unfold_left

<#include <boost/hana/fwd/unfold_left.hpp>>

Initial value:

= [](auto&& state, auto&& f) {
        return tag-dispatched;
    }

Двойная операция<fold_left>для последовательностей. В то время как<fold_left>сводит структуру к суммарному значению слева,<unfold_left>строит последовательность из начального значения и функции, начиная с левого.

Signature

Учитывая<Sequence><S>, начальное значение<state>метки<I>, произвольный Продукт<P>и функцию \(f : I \to P(I, T)\),<unfold_left<S>>имеет следующую подпись:

\[ \mathtt{unfold\_left}_S : I \times (I \to P(I, T)) \to S(T) \]

Template Parameters

S	Тег последовательности для создания.

Parameters

state Начальное значение для построения последовательности из.

Функция называется<f(state)>, где<state>является начальным значением, и возвращает

< [1222] >, , , ,< [1222] >,
,
.
< [1224] >,< [1225] >,< [1226] >,< [1227] >,< [1228] >,< [1229] >,,,,,.

nothing, если это сделано для получения последовательности.

В противном случаеjust(make<P>(state, x)), гдеstateявляется новым начальным значением, используемым в следующем вызове кf,xявляется элементом, который должен быть добавлен к полученной последовательности, иPявляется произвольнымProduct.

[ORIG_END] -->

Fun fact

В некоторых случаях<unfold_left>может отменить операцию<fold_left>:

unfold_left<S>(fold_left(xs, state, f), g) == xs

Если следующее имеет

g(f(x, y)) == just(make_pair(x, y))

g(state) == nothing

Example

// 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)
#include <boost/hana/assert.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/if.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/minus.hpp>
#include <boost/hana/optional.hpp>
#include <boost/hana/pair.hpp>
#include <boost/hana/tuple.hpp>
#include <boost/hana/unfold_left.hpp>
namespace hana = boost::hana;
BOOST_HANA_CONSTANT_CHECK(
    hana::unfold_left<hana::tuple_tag>(hana::int_c<10>, [](auto x) {
        return hana::if_(x == hana::int_c<0>,
            hana::nothing,
            hana::just(hana::make_pair(x - hana::int_c<1>, x))
        );
    })
    ==
    hana::tuple_c<int, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10>
);
int main() { }

template<typename S >

constexpr auto boost::hana::unfold_right

<#include <boost/hana/fwd/unfold_right.hpp>>

Initial value:

= [](auto&& state, auto&& f) {
        return tag-dispatched;
    }

Двойная операция<fold_right>для последовательностей. Хотя<fold_right>сводит структуру к суммарному значению справа,<unfold_right>строит последовательность из начального значения и функции, начиная с правого.

Signature

Учитывая<Sequence><S>, начальное значение<state>метки<I>, произвольный Продукт<P>и функцию \(f : I \to P(T, I)\),<unfold_right<S>>имеет следующую подпись:

\[ \mathtt{unfold\_right}_S : I \times (I \to P(T, I)) \to S(T) \]

Template Parameters

S	Тег последовательности для создания.

Parameters

state Начальное значение для построения последовательности из.

Функция называется<f(state)>, где<state>является начальным значением, и возвращает

< [1222] >, , , ,< [1222] >,
,
.
< [1245] >,< [1246] >< [1246] >< [1246] >< [1247] >< [1248] >< [1246] >]< [1249] >< [1250] >< [1249] >< [1249] >< [1250] >SequenceSequenceSequence]SequenceSequenceSequenceSequence.

nothing, если это сделано для получения последовательности.

В противном случаеjust(make<P>(x, state)), гдеstateявляется новым начальным значением, используемым в следующем вызове кf,xявляется элементом, подлежащим предварительной подготовке к полученной последовательности, иPявляется произвольнымProduct.

[ORIG_END] -->

Fun fact

В некоторых случаях<unfold_right>может отменить операцию<fold_right>:

unfold_right<S>(fold_right(xs, state, f), g) == xs

Если следующее имеет

g(f(x, y)) == just(make_pair(x, y))

g(state) == nothing

Example

// 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)
#include <boost/hana/assert.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/if.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/minus.hpp>
#include <boost/hana/optional.hpp>
#include <boost/hana/pair.hpp>
#include <boost/hana/tuple.hpp>
#include <boost/hana/unfold_right.hpp>
namespace hana = boost::hana;
BOOST_HANA_CONSTANT_CHECK(
    hana::unfold_right<hana::tuple_tag>(hana::int_c<10>, [](auto x) {
        return hana::if_(x == hana::int_c<0>,
            hana::nothing,
            hana::just(hana::make_pair(x, x - hana::int_c<1>))
        );
    })
    ==
    hana::tuple_c<int, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1>
);
int main() { }

constexpr auto boost::hana::unique

<#include <boost/hana/fwd/unique.hpp>>

Initial value:

= [](auto&& xs[, auto&& predicate]) {
        return tag-dispatched;
    }

Удаляет все последовательные дублирующие элементы из последовательности. Учитывая<Sequence>и необязательный двоичный предикат,<unique>возвращает новую последовательность, содержащую только первый элемент каждого поддиапазона исходной последовательности, все элементы которой равны. Другими словами, он превращает последовательность формы<[a, a, b, c, c, c, d, d, d, a]>в последовательность<[a, b, c, d, a]>. Равенство двух элементов определяется предоставленным<predicate>или<equal>, если не предусмотрено<predicate>.

Signature

Учитывая<Sequence><S(T)>,<Logical><Bool>и двоичный предикат \(T \times T \to Bool \),<unique>имеет следующую подпись:

\[ \mathtt{unique} : S(T) \times (T \times T \to Bool) \to S(T) \]

Parameters

xs Последовательность, из которой удаляются последовательные дубликаты.

predicate Функция, называемая<predicate(x, y)>, где<x>и<y>являются смежными элементами последовательности, и возвращающая<Logical>, представляющая, следует ли считать<x>и<y>равными.<predicate>должно определятьотношение эквивалентностинад элементами последовательности. В текущей реализации библиотеки<predicate>приходится возвращать время компиляции<Logical>. Этот параметр необязателен; он по умолчанию<equal>, если он не предусмотрен, что затем требует, чтобы элементы последовательности составляли время компиляции<Comparable>.

Syntactic sugar (`unique.by`)

<unique>можно назвать альтернативным способом, который обеспечивает хороший синтаксис, особенно в сочетании с комбинатором<comparing>:

unique.by(predicate, xs) == unique(xs, predicate)

unique.by(predicate) == unique(-, predicate)

где<unique(-, predicate)>означает частичное применение<unique>к<predicate>.

Example

// 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)
#include <boost/hana/assert.hpp>
#include <boost/hana/comparing.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/tuple.hpp>
#include <boost/hana/type.hpp>
#include <boost/hana/unique.hpp>
#include <string>
namespace hana = boost::hana;
using namespace std::literals;
// unique without a predicate
constexpr auto types = hana::tuple_t<int, float, float, char, int, int, int, double>;
BOOST_HANA_CONSTANT_CHECK(
    hana::unique(types) == hana::tuple_t<int, float, char, int, double>
);
int main() {
    // unique with a predicate
    auto objects = hana::make_tuple(1, 2, "abc"s, 'd', "efg"s, "hij"s, 3.4f);
    BOOST_HANA_RUNTIME_CHECK(
        hana::unique(objects, [](auto const& t, auto const& u) {
            return hana::typeid_(t) == hana::typeid_(u);
        })
        == hana::make_tuple(1, "abc"s, 'd', "efg"s, 3.4f)
    );
    // unique.by is syntactic sugar
    BOOST_HANA_RUNTIME_CHECK(
        hana::unique.by(hana::comparing(hana::typeid_), objects) ==
            hana::make_tuple(1, "abc"s, 'd', "efg"s, 3.4f)
    );
}

constexpr auto boost::hana::zip

<#include <boost/hana/fwd/zip.hpp>>

Initial value:

= [](auto&& x1, ..., auto&& xn) {
        return tag-dispatched;
    }

Зажмите одну последовательность или более. Учитывая<n>последовательности<s1, ..., sn>,<zip>производит последовательность, чей<i>-й элемент является кортежем<(s1[i], ..., sn[i])>, где<sk[i]>обозначает<i>-й элемент<k>-й последовательности. Иными словами,<zip>образует последовательность формы.

[
    make_tuple(s1[0], ..., sn[0]),
    make_tuple(s1[1], ..., sn[1]),
    ...
    make_tuple(s1[M], ..., sn[M])
]

где<M>— длина последовательностей, которые, как предполагается, имеют одинаковую длину. Предполагая, что все последовательности имеют одинаковый размер, библиотека может выполнять некоторые оптимизации. Для зип-последовательности, которые могут иметь разную длину, следует использовать<zip_shortest>. Также обратите внимание, что ошибка заключается в отсутствии последовательности, т.е.<zip>ожидает по меньшей мере одну последовательность.

Example

// 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)
#include <boost/hana/equal.hpp>
#include <boost/hana/tuple.hpp>
#include <boost/hana/zip.hpp>
namespace hana = boost::hana;
static_assert(
    hana::zip(hana::make_tuple(1, 'a'), hana::make_tuple(2, 3.3))
    ==
    hana::make_tuple(hana::make_tuple(1, 2), hana::make_tuple('a', 3.3))
, "");
int main() { }

constexpr auto boost::hana::zip_shortest

<#include <boost/hana/fwd/zip_shortest.hpp>>

Initial value:

= [](auto&& x1, ..., auto&& xn) {
        return tag-dispatched;
    }

Зажмите одну последовательность или более. Учитывая<n>последовательности<s1, ..., sn>,<zip_shortest>производит последовательность, чей<i>-й элемент является кортежем<(s1[i], ..., sn[i])>, где<sk[i]>обозначает<i>-й элемент<k>-й последовательности. Другими словами,<zip_shortest>производит последовательность формы.

[
    make_tuple(s1[0], ..., sn[0]),
    make_tuple(s1[1], ..., sn[1]),
    ...
    make_tuple(s1[M], ..., sn[M])
]

где<M>— длина самой короткой последовательности. Следовательно, возвращенная последовательность прекращается, когда исчерпана самая короткая входная последовательность. Если вы знаете, что все последовательности, которые вы собираетесь zip, имеют одинаковую длину, вы должны использовать<zip>вместо этого. Также обратите внимание, что ошибка заключается в отсутствии последовательности, т.е.<zip_shortest>ожидает по меньшей мере одну последовательность.

Example

// 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)
#include <boost/hana/equal.hpp>
#include <boost/hana/tuple.hpp>
#include <boost/hana/zip_shortest.hpp>
namespace hana = boost::hana;
static_assert(
    hana::zip_shortest(hana::make_tuple(1, 'a'), hana::make_tuple(2, 3.3), hana::make_tuple(3, 'c', "ignored"))
    ==
    hana::make_tuple(hana::make_tuple(1, 2, 3), hana::make_tuple('a', 3.3, 'c'))
, "");
int main() { }

constexpr auto boost::hana::zip_shortest_with

<#include <boost/hana/fwd/zip_shortest_with.hpp>>

Initial value:

= [](auto&& f, auto&& x1, ..., auto&& xn) {
        return tag-dispatched;
    }

Захват одной последовательности или более с заданной функцией. Учитывая<n>-ary функцию<f>и<n>последовательности<s1, ..., sn>,<zip_shortest_with>производит последовательность, чей<i>-й элемент является<f(s1[i], ..., sn[i])>, где<sk[i]>обозначает<i>-й элемент<k>-й последовательности. Другими словами,<zip_shortest_with>производит последовательность формы.

[
    f(s1[0], ..., sn[0]),
    f(s1[1], ..., sn[1]),
    ...
    f(s1[M], ..., sn[M])
]

где<M>— длина самой короткой последовательности. Следовательно, возвращенная последовательность прекращается, когда исчерпана самая короткая входная последовательность. Если вы знаете, что все последовательности, которые вы собираетесь zip, имеют одинаковую длину, вы должны использовать<zip_with>вместо этого. Также обратите внимание, что ошибка заключается в отсутствии последовательности, т.е.<zip_shortest_with>ожидает по меньшей мере одну последовательность.

Example

// 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)
#include <boost/hana/equal.hpp>
#include <boost/hana/mult.hpp>
#include <boost/hana/tuple.hpp>
#include <boost/hana/zip_shortest_with.hpp>
namespace hana = boost::hana;
static_assert(
    hana::zip_shortest_with(hana::mult, hana::make_tuple(1, 2, 3, 4), hana::make_tuple(5, 6, 7, 8, "ignored"))
    ==
    hana::make_tuple(5, 12, 21, 32)
, "");
int main() { }

constexpr auto boost::hana::zip_with

<#include <boost/hana/fwd/zip_with.hpp>>

Initial value:

= [](auto&& f, auto&& x1, ..., auto&& xn) {
        return tag-dispatched;
    }

Захват одной последовательности или более с заданной функцией. Учитывая<n>-арную функцию<f>и<n>последовательности<s1, ..., sn>,<zip_with>производит последовательность, чей<i>-й элемент является<f(s1[i], ..., sn[i])>, где<sk[i]>обозначает<i>-й элемент<k>-й последовательности. Другими словами,<zip_with>производит последовательность формы.

[
    f(s1[0], ..., sn[0]),
    f(s1[1], ..., sn[1]),
    ...
    f(s1[M], ..., sn[M])
]

где<M>— длина последовательностей, которые, как предполагается, имеют одинаковую длину. Предполагая, что все последовательности имеют одинаковый размер, библиотека может выполнять некоторые оптимизации. Для зип-последовательностей, которые могут иметь разную длину, следует использовать<zip_shortest_with>. Также обратите внимание, что ошибка заключается в отсутствии последовательности, т.е.<zip_with>ожидает по меньшей мере одну последовательность.

Example

// 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)
#include <boost/hana/equal.hpp>
#include <boost/hana/mult.hpp>
#include <boost/hana/tuple.hpp>
#include <boost/hana/zip_with.hpp>
namespace hana = boost::hana;
static_assert(
    hana::zip_with(hana::mult, hana::make_tuple(1, 2, 3, 4), hana::make_tuple(5, 6, 7, 8))
    ==
    hana::make_tuple(5, 12, 21, 32)
, "");
int main() { }

Статья Boost.Hana: Sequence раздела может быть полезна для разработчиков на c++ и boost.

Материалы статей собраны из открытых источников, владелец сайта не претендует на авторство. Там где авторство установить не удалось, материал подаётся без имени автора. В случае если Вы считаете, что Ваши права нарушены, пожалуйста, свяжитесь с владельцем сайта.

:: Главная :: ::

Время компиляции файла: 2024-08-30 11:47:00
2025-05-20 00:49:59/0.043275833129883/1

Boost.Hana: Sequence

Boost , ,

Minimal complete definition

Laws

Refined concepts

Concrete models

Variables

Variable Documentation

Signature

Example

Example

Signature

Syntactic sugar (group.by)

Example

Example

Example

Example

Signature

Syntactic sugar (partition.by)

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Signature

Syntactic sugar (sort.by)

Example

Signature

Syntactic sugar (span.by)

Example

Example

Example

Example

Example

Signature

Fun fact

Example

Signature

Fun fact

Example

Signature

Syntactic sugar (unique.by)

Example

Example

Example

Example

Example

Syntactic sugar (`group.by`)

Syntactic sugar (`partition.by`)

Syntactic sugar (`sort.by`)

Syntactic sugar (`span.by`)

Syntactic sugar (`unique.by`)