|
|
|
Boost.Hana: FoldableBoost , ,
Variable Documentation
< return tag-dispatched; } constexpr auto value Return the compile-time value associated to a constant.This function returns the value associated to ... Definition: value.hpp:54 Возвращает количество элементов в структуре, которые сравниваются с заданным значением. При наличии складной структуры<
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/count.hpp> #include <boost/hana/equal.hpp> #include <boost/hana/integral_constant.hpp> #include <boost/hana/tuple.hpp> #include <boost/hana/type.hpp> namespace hana = boost::hana; int main() { constexpr auto ints = hana::tuple_c<int, 1, 2, 3, 2, 2, 4, 2>; BOOST_HANA_CONSTANT_CHECK(hana::count(ints, hana::int_c<2>) == hana::size_c<4>); static_assert(hana::count(ints, 2) == 4, ""); constexpr auto types = hana::tuple_t<int, char, long, short, char, double>; BOOST_HANA_CONSTANT_CHECK(hana::count(types, hana::type_c<char>) == hana::size_c<2>); }
< = [](auto&& xs, auto&& predicate) { return tag-dispatched; } Возвращает количество элементов в структуре, для которых удовлетворяется<
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/count_if.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/tuple.hpp> #include <boost/hana/type.hpp> #include <type_traits> namespace hana = boost::hana; using namespace hana::literals; auto is_odd = [](auto x) { return x % 2_c != 0_c; }; int main() { constexpr auto ints = hana::tuple_c<int, 1, 2, 3>; BOOST_HANA_CONSTANT_CHECK(hana::count_if(ints, is_odd) == hana::size_c<2>); constexpr auto types = hana::tuple_t<int, char, long, short, char, double>; BOOST_HANA_CONSTANT_CHECK(hana::count_if(types, hana::trait<std::is_floating_point>) == hana::size_c<1>); BOOST_HANA_CONSTANT_CHECK(hana::count_if(types, hana::equal.to(hana::type_c<char>)) == hana::size_c<2>); BOOST_HANA_CONSTANT_CHECK(hana::count_if(types, hana::equal.to(hana::type_c<void>)) == hana::size_c<0>); }
< < 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/fold.hpp> #include <boost/hana/tuple.hpp> #include <sstream> #include <string> namespace hana = boost::hana; auto to_string = [](auto x) { std::ostringstream ss; ss << x; return ss.str(); }; int main() { auto f = [=](std::string s, auto element) { return "f(" + s + ", " + to_string(element) + ")"; }; // with an initial state == "f(f(f(f(1, 2), 3), 4), 5)" ); // without initial state == "f(f(f(f(1, 2), 3), 4), 5)" ); }
< = [](auto&& xs[, auto&& state], auto&& f) -> decltype(auto) { return tag-dispatched; } Левая часть структуры с использованием двоичной операции и факультативного начального состояния восстановления.< f(... f(f(f(x1, x2), x3), x4) ..., xn) // without state f(... f(f(f(f(state, x1), x2), x3), x4) ..., xn) // with state Когда структура пуста, могут возникнуть две вещи. Если первоначальное состояние было обеспечено, оно возвращается как есть. В противном случае, если используется версия функции без состояния, срабатывает ошибка. Когда конструкция содержит один элемент и используется версия функции без состояния, этот единственный элемент возвращается как есть. SignatureПри наличии< \[ \mathtt{fold\_left} : F(T) \times S \times (S \times T \to S) \to S \] для варианта с начальным состоянием, и \[ \mathtt{fold\_left} : F(T) \times (T \times T \to T) \to T \] вариант без начального состояния.
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/fold_left.hpp> #include <boost/hana/tuple.hpp> #include <sstream> #include <string> namespace hana = boost::hana; auto to_string = [](auto x) { std::ostringstream ss; ss << x; return ss.str(); }; int main() { auto f = [=](std::string s, auto element) { return "f(" + s + ", " + to_string(element) + ")"; }; // with an initial state == "f(f(f(f(1, 2), 3), 4), 5)" ); // without initial state == "f(f(f(f(1, 2), 3), 4), 5)" ); }
< = [](auto&& xs[, auto&& state], auto&& f) -> decltype(auto) { return tag-dispatched; } Правое сложение структуры с использованием двоичной операции и факультативного начального состояния восстановления.< f(x1, f(x2, f(x3, f(x4, ... f(xn-1, xn) ... )))) // without state f(x1, f(x2, f(x3, f(x4, ... f(xn, state) ... )))) // with state
Когда структура пуста, могут возникнуть две вещи. Если первоначальное состояние было обеспечено, оно возвращается как есть. В противном случае, если используется версия функции без состояния, срабатывает ошибка. Когда конструкция содержит один элемент и используется версия функции без состояния, этот единственный элемент возвращается как есть. Signature< \[ \mathtt{fold\_right} : F(T) \times S \times (T \times S \to S) \to S \] для варианта с начальным состоянием, и \[ \mathtt{fold\_right} : F(T) \times (T \times T \to T) \to T \] вариант без начального состояния.
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/fold_right.hpp> #include <boost/hana/tuple.hpp> #include <sstream> #include <string> namespace hana = boost::hana; auto to_string = [](auto x) { std::ostringstream ss; ss << x; return ss.str(); }; int main() { auto f = [=](auto element, std::string s) { return "f(" + to_string(element) + ", " + s + ")"; }; // with an initial state == "f(1, f(2, f(3, f(4, 5))))" ); // without initial state == "f(1, f(2, f(3, f(4, 5))))" ); }
< = [](auto&& xs, auto&& f) -> void { tag-dispatched; } Выполняйте действие на каждый элемент складного, каждый раз отбрасывая результат. Итерация выполняется слева направо, то есть в том же порядке, что и при использовании<
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/for_each.hpp> #include <boost/hana/tuple.hpp> #include <sstream> namespace hana = boost::hana; int main() { std::stringstream ss; ss << x << ' '; }); BOOST_HANA_RUNTIME_CHECK(ss.str() == "0 1 234 5.5 "); }
< = [](auto&& f) { return unpack(forwarded(xs), forwarded(f)); }; } constexpr auto unpack Invoke a function with the elements of a Foldable as arguments.Given a function and a foldable struct... Definition: unpack.hpp:79 constexpr auto capture Create a function capturing the given variables. Definition: capture.hpp:45 Преобразовать функцию, принимающую множество аргументов, в функцию, которая может быть вызвана временем компиляции< Эта функция предусмотрена для удобства как другой способ вызова< где<
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/fuse.hpp> #include <boost/hana/tuple.hpp> namespace hana = boost::hana; auto tie = [](auto& ...vars) { return hana::fuse([&vars...](auto ...values) { // Using an initializer list to sequence the assignments. int dummy[] = {0, ((void)(vars = values), 0)...}; (void)dummy; }); }; int main() { int a = 0; char b = '\0'; double c = 0; tie(a, b, c)(hana::make_tuple(1, '2', 3.3)); BOOST_HANA_RUNTIME_CHECK(a == 1 && b == '2' && c == 3.3); }
< = [](auto const& xs) { return tag-dispatched; } Верните количество элементов в складную структуру. Учитывая<
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/length.hpp> #include <boost/hana/optional.hpp> #include <boost/hana/tuple.hpp> namespace hana = boost::hana; int main() { BOOST_HANA_CONSTANT_CHECK(hana::length(hana::make_tuple()) == hana::size_c<0>); BOOST_HANA_CONSTANT_CHECK(hana::length(hana::nothing) == hana::size_c<0>); }
< = [](auto&& xs[, auto&& predicate]) -> decltype(auto) { return tag-dispatched; } Возвращает наибольший элемент непустой структуры по отношению к< Если структура содержит разнородные объекты, то предикат должен возвращать время компиляции< SignatureДано Складное< \[ \mathtt{maximum} : F(T) \times (T \times T \to Bool) \to T \] Для варианта без пользовательского предиката требуется< \[ \mathtt{maximum} : F(T) \to T \]
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/greater.hpp> #include <boost/hana/integral_constant.hpp> #include <boost/hana/maximum.hpp> #include <boost/hana/tuple.hpp> namespace hana = boost::hana; int main() { // without a predicate hana::maximum(hana::tuple_c<int, -1, 0, 2, -4, 6, 9>) == hana::int_c<9> ); // with a predicate return x > y; // order is reversed! }); BOOST_HANA_CONSTANT_CHECK(smallest == hana::int_c<-4>); } Syntactic sugar (
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
| constexpr auto boost::hana::minimum |
<#include <boost/hana/fwd/minimum.hpp>>
Возвращает наименьший элемент непустой структуры по отношению к<predicate>, по умолчанию<less>.Учитывая непустую структуру и необязательный бинарный предикат<less>по умолчанию,<minimum>возвращает наименьший элемент структуры, т.е. элемент, который меньше или равен любому другому элементу в структуре, согласно предикату.
Если структура содержит разнородные объекты, то предикат должен возвращать время компиляции<Logical>. Если предикат не предусмотрен, элементы в структуре должны быть упорядоченными, или упорядоченными во времени компиляции, если структура неоднородна.
<Foldable><F>, логический<Bool>и предикат \(\mathtt{pred} : T \times T \to Bool \),<minimum>имеет следующие подписи. Для варианта с заданным предикатом,
\[ \mathtt{minimum} : F(T) \times (T \times T \to Bool) \to T \]
Для варианта без пользовательского предиката требуется<T>быть упорядоченным. Подпись тогда
\[ \mathtt{minimum} : F(T) \to T \]
| xs | Структура для поиска наименьшего элемента. |
| predicate | Функция называется<predicate(x, y)>, где<x>и<y>являются элементами структуры.<predicate>должно быть строгое слабое упорядочивание на элементах структуры и его возвращаемое значение должно быть логическим, или компиляционно-временным логическим, если структура неоднородна. |
minimum.by) <minimum>можно назвать третьим способом, который обеспечивает хороший синтаксис, особенно при работе с комбинатором<ordering>:
где<minimum(-, predicate)>обозначает частичное применение<minimum>к<predicate>.
Как непредикативная версия, так и предикативная версия<minimum>являются методами, распределенными по тегам, и, следовательно, они могут быть настроены независимо. Одна из причин этого заключается в том, что некоторые структуры способны обеспечить гораздо более эффективную реализацию<minimum>при использовании предиката<less>. Вот как отправляются различные версии<minimum>:
Также обратите внимание, что<minimum.by>не маркируется отдельно, поскольку это просто синтаксический сахар для вызова соответствующего<minimum>.
| constexpr auto boost::hana::monadic_fold_left |
<#include <boost/hana/fwd/monadic_fold_left.hpp>>
Монадическое левое сложение структуры с бинарной операцией и факультативным начальным состоянием редукции.
hana::fold_left, and to have read the primer on monadic folds.<monadic_fold_left<M>>является левоассоциативной монадической складкой. При наличии<Foldable>с линеаризацией<[x1, ..., xn]>, функции<f>и факультативного начального состояния<monadic_fold_left<M>>применяется<f>следующим образом:
где<f(-, xk)>обозначает частичное применение<f>к<xk>, а<|>является просто операторской версией монадического<chain>.
Когда структура пуста, может произойти одна из двух вещей. Если первоначальное состояние было обеспечено, оно поднимается к данной Монаде и возвращается как есть. В противном случае, если используется версия функции без состояния, срабатывает ошибка. Когда конструкция содержит один элемент и используется негосударственная версия функции, этот единственный элемент поднимается в данную Монаду и возвращается как есть.
Учитывая<Monad><M>,<Foldable><F>, начальное состояние тега<S>и функцию \(f : S \times T \to M(S)\), подписи<monadic_fold_left<M>>являются
\[ \mathtt{monadic\_fold\_left}_M : F(T) \times S \times (S \times T \to M(S)) \to M(S) \]
для версии с начальным состоянием и
\[ \mathtt{monadic\_fold\_left}_M : F(T) \times (T \times T \to M(T)) \to M(T) \]
Для версии без начального состояния.
| M | Монада представляет собой монадический контекст, в котором происходит складка. Тип возврата<f>должен быть в этой Монаде. |
| xs | Структура складывается. |
| state | Начальное значение, используемое для складывания. Если структура пуста, это значение поднимается до<M>Монады, а затем возвращается как есть. |
| f | Бинарная функция называется<f(state, x)>, где<state>является результатом, накопленным до сих пор, и<x>является элементом в структуре. Функция должна возвращать свой результат внутри<M>Монады. |
| constexpr auto boost::hana::monadic_fold_right |
<#include <boost/hana/fwd/monadic_fold_right.hpp>>
Монадическая правая часть структуры с бинарной операцией и факультативным начальным состоянием восстановления.
hana::fold_right, and to have read the primer on monadic folds.<monadic_fold_right<M>>является правоассоциативной монадической складкой. Учитывая структуру, содержащую<x1, ..., xn>, функцию<f>и факультативное начальное состояние,<monadic_fold_right<M>>применяется<f>следующим образом:
где<f(xk, -)>означает частичное применение<f>к<xk>, и<|>является только операторской версией монадического<chain>. Стоит отметить, что порядок, в котором двоичная функция должна ожидать своих аргументов, обратный<monadic_fold_left<M>>.
Когда структура пуста, может произойти одна из двух вещей. Если первоначальное состояние было обеспечено, оно поднимается к данной Монаде и возвращается как есть. В противном случае, если используется версия функции без состояния, срабатывает ошибка. Когда конструкция содержит один элемент и используется негосударственная версия функции, этот единственный элемент поднимается в данную Монаду и возвращается как есть.
Учитывая<Monad><M>,<Foldable><F>, начальное состояние тега<S>и функцию \(f : T \times S \to M(S)\), подписи<monadic_fold_right<M>>являются
\[ \mathtt{monadic\_fold\_right}_M : F(T) \times S \times (T \times S \to M(S)) \to M(S) \]
для версии с начальным состоянием и
\[ \mathtt{monadic\_fold\_right}_M : F(T) \times (T \times T \to M(T)) \to M(T) \]
Для версии без начального состояния.
| M | Монада представляет собой монадический контекст, в котором происходит складка. Тип возврата<f>должен быть в этой Монаде. |
| xs | Структура складывается. |
| state | Начальное значение, используемое для складывания. Если структура пуста, это значение поднимается до<M>Монады, а затем возвращается как есть. |
| f | Бинарная функция называется<f(x, state)>, где<state>является результатом, накопленным до сих пор, и<x>является элементом в структуре. Функция должна возвращать свой результат внутри Монады<M>. |
| constexpr auto boost::hana::product = see documentation |
<#include <boost/hana/fwd/product.hpp>>
Вычислить произведение чисел структуры. В более общем плане<product>будет принимать любую складную структуру, содержащую объекты, образующие кольцо, и уменьшать их с помощью двоичной операции кольца. Начальное состояние складывания — это тождество операции Кольца. Иногда необходимо указать Кольцо для использования; это возможно с помощью<product<R>>. Если Кольцо не указано, в структуре будет использоваться Кольцо, образованное элементами, которые оно содержит (если оно знает это), или<integral_constant_tag<int>>. Следовательно.
Для чисел это будет просто вычислять произведение чисел в структуре<xs>.
mult on any two adjacent elements of the structure, which requires each pair of adjacent element to at least have a common Ring embedding. The meaning of "adjacent" as used here is that two elements of the structure x and y are adjacent if and only if they are adjacent in the linearization of that structure, as documented by the Iterable concept.sum to understand why the Ring must sometimes be specified explicitly.| constexpr auto boost::hana::reverse_fold |
<#include <boost/hana/fwd/reverse_fold.hpp>>
<reverse_fold>в Boost.Fusion и Boost. MPL. Этот метод имеет ту же семантику, что и<reverse_fold>. Фьюжн и буст. MPL, с расширением, что начальное состояние не требуется. Этот метод эквивалентен<fold_right>, за исключением того, что функция накопления должна принимать свои аргументы в обратном порядке, чтобы соответствовать порядку, используемому в Fusion. Другими словами,
fold_right. As an alias, reverse_fold is not tag-dispatched on its own and fold_right should be customized instead.<Foldable><F>и факультативное начальное состояние метки<S>, подписи для<reverse_fold>являются
\[ \mathtt{reverse\_fold} : F(T) \times S \times (S \times T \to S) \to S \]
для варианта с начальным состоянием, и
\[ \mathtt{reverse\_fold} : F(T) \times (T \times T \to T) \to T \]
вариант без начального состояния.
| xs | Структура складывается. |
| state | Начальное значение, используемое для складывания. |
| f | Бинарная функция называется<f(state, x)>, где<state>является результатом, накопленным до сих пор, и<x>является элементом в структуре. Для обратных складок без начального состояния функция называется<f(x1, x2)>, где<x1>и<x2>являются элементами структуры. |
| constexpr auto boost::hana::size = hana::length |
<#include <boost/hana/fwd/size.hpp>>
Эквивалент<length>; предусмотрен для согласования со стандартной библиотекой. Этот метод является псевдонимом<length>, предназначенным для удобства и согласованности со стандартной библиотекой. В качестве псевдонима<size>не отправляется тег сам по себе и<length>должен быть настроен вместо этого.
| constexpr auto boost::hana::sum = see documentation |
<#include <boost/hana/fwd/sum.hpp>>
Вычислите сумму чисел структуры. В более общем плане<sum>берет любую складную структуру, содержащую объекты, образующие Моноид, и уменьшает их с помощью двоичной операции Моноида. Начальным состоянием для складывания является идентичность Моноида. Иногда необходимо указать Моноид для использования; это возможно с помощью<sum<M>>. Если Моноид не указан, в структуре будет использоваться Моноид, образованный элементами, которые он содержит (если он знает это), или<integral_constant_tag<int>>иначе. Следовательно.
Для чисел это будет просто вычислять сумму чисел в структуре<xs>.
plus on any two adjacent elements of the structure, which requires each pair of adjacent element to at least have a common Monoid embedding. The meaning of "adjacent" as used here is that two elements of the structure x and y are adjacent if and only if they are adjacent in the linearization of that structure, as documented by the Iterable concept.Monoid by using sum<M>? Это связано с тем, что метки последовательности, такие как<tuple_tag>, не параметризированы (по дизайну). Следовательно, мы не знаем, какие объекты находятся в последовательности, поэтому мы не можем знать значение<0>, какой тип должен быть возвращен, когда последовательность пуста. Поэтому тип<0>для возврата в пустом случае должен быть указан явно. Другие складные структуры, такие как<hana::range>s, будут игнорировать предложенный Моноид, потому что они знают метки объектов, которые они содержат. Это непоследовательное поведение является ограничением существующего дизайна с непараметризированными тегами, но пока у нас нет хорошего решения.
| constexpr auto boost::hana::unpack |
<#include <boost/hana/fwd/unpack.hpp>>
Вызовите функцию с элементами Foldable в качестве аргументов. Учитывая функцию и складную структуру, длина которой может быть известна во время компиляции,<unpack>вызывает функцию с содержанием этой структуры. Другими словами,<unpack(xs, f)>эквивалентно<f(x...)>, где<x...>являются элементами структуры. Длина структуры должна быть известна во время компиляции, потому что версия<f>'s<operator()>, которая будет компилироваться, зависит от количества аргументов, с которыми она называется, которые должны быть известны во время компиляции.
Чтобы создать функцию, которая принимает складные, а не вариадные аргументы, см.<fuse>.
| xs | Структура расширяется до функции. |
| f | Функция, которая вызывается как<f(x...)>, где<x...>являются элементами структуры, если они были линеаризованы с<to<tuple_tag>>. |
unpack's name and parameter order Было предложено несколько раз, чтобы<unpack>было названо<apply>вместо этого, и чтобы порядок параметров был отменен, чтобы соответствовать тому изпредложенного std::apply функции. Однако название<apply>уже используется для обозначения нормального функционального приложения, использование которого согласуется с библиотекой Boost MPL и с остальным миром, особенно с сообществом функционального программирования. Кроме того, автор этой библиотеки считает, что предложенное<std::apply>имеет как неудачное имя, так и неудачный порядок параметров. Действительно, принятие функции в качестве первого аргумента означает, что использование<std::apply>с функцией лямбды выглядит так:
Это, несомненно, уродливо из-за отставания<, tuple)>на последней линии. С другой стороны, принятие функции в качестве второго аргумента позволяет писать.
который выглядит намного приятнее. Из-за этих наблюдений автор этой библиотеки считает оправданным использовать<unpack>вместо<apply>и использовать порядок нормальных параметров.
Статья Boost.Hana: Foldable раздела может быть полезна для разработчиков на c++ и boost.
:: Главная :: ::
реклама |