Boost.Hana: Searchable . Boost , ,

Boost.Hana 1.0.1

Your standard library for metaprogramming

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

Интуитивно<Searchable>— это любая структура, конечная или бесконечная, содержащая элементы, которые можно искать с помощью предиката. Иногда<Searchable>s связывает ключи с значениями; можно искать ключ с предикатом, и значение, связанное с ним, возвращается. Это приводит к появлению картоподобных структур данных. В других случаях элементы структуры, которые ищутся (т.е. те, к которым применяется предикат), являются теми же, которые возвращаются, что приводит к появлению набороподобных структур данных. В общем, мы будем относиться кключамструктуры<Searchable>как к тем элементам, которые используются для поиска, и кзначениям<Searchable>как к тем элементам, которые возвращаются при успешном поиске. Как было объяснено, нет требования, чтобы оба понятия различались, и часто полезно, чтобы ключи и значения совпадали (подумайте о<std::set>).

Некоторые методы, такие как<any_of>,<all_of>и<none_of>, позволяют выполнять простые запросы на клавишах структуры, в то время как другие методы, такие как<find>и<find_if>, позволяют находить значение, связанное с ключом. Наиболее специфический метод всегда должен использоваться, если вы заботитесь о производительности, потому что обычно тяжелые оптимизации могут быть выполнены более конкретными методами. Например, ассоциативная структура данных, реализованная в виде хеш-таблицы, будет гораздо быстрее для доступа с использованием<find>, чем<find_if>, поскольку во втором случае ей придется выполнять линейный поиск по всем записям. В этом случае<contains>будет намного быстрее, чем<any_of>.

Проницательность
В ленивом контексте оценки любой<Foldable>может также стать моделью<Searchable>, потому что мы можем лениво искать через структуру с<fold_right>. Однако в контексте C++ некоторые<Searchable>s нельзя сложить; подумайте, например, о бесконечном множестве.

Minimal complete definition

<find_if>и<any_of>

При предоставлении<find_if>и<any_of>другие функции выполняются в соответствии с законами, изложенными ниже.

Note: We could implement any_of(xs, pred) by checking whether find_if(xs, pred) is an empty optional or not, and then reduce the minimal complete definition to find_if. However, this is not done because that implementation requires the predicate of any_of to return a compile-time Logical, which is more restrictive than what we have right now.

Laws

Для того чтобы семантика методов была последовательной, некоторые свойства должны удовлетворяться любой моделью концепции<Searchable>. Для любого<Searchable>s<xs>и<ys>и любого предиката<p>должны быть выполнены следующие законы:

any_of(xs, p) <=> !all_of(xs, negated p)
              <=> !none_of(xs, p)
contains(xs, x) <=> any_of(xs, equal.to(x))
find(xs, x) == find_if(xs, equal.to(x))
find_if(xs, always(false_)) == nothing
is_subset(xs, ys) <=> all_of(xs, [](auto x) { return contains(ys, x); })
is_disjoint(xs, ys) <=> none_of(xs, [](auto x) { return contains(ys, x); })

Кроме того, если все ключи<Searchable>равны<Logical>с, то должны соблюдаться следующие законы:

any(xs)  <=> any_of(xs, id)
all(xs)  <=> all_of(xs, id)
none(xs) <=> none_of(xs, id)

Concrete models

<hana::map>,<hana::optional>,<hana::range>,<hana::set>,<hana::string>,<hana::tuple>

Free model for builtin arrays

Встроенные массивы, размер которых известен, можно искать, если они были однородными кортежами. Однако, поскольку массивы могут удерживать только объекты одного типа и предикат к<find_if>должен возвращать время компиляции<Logical>, метод<find_if>довольно бесполезен. По аналогичным причинам метод<find>также довольно бесполезен. Эта модель предоставляется в основном из-за метода<any_of>; друзья, которые полезны и эффективны для компиляции.

Structure preserving functions

Учитывая два<Searchables><S1>и<S2>, функция \(f : S_1(X) \to S_2(X) \) считается сохраняющей структуру<Searchable>, если для всех<xs>типа данных<S1(X)>и предикатов \(\mathtt{pred} : X \to Bool \) (для<Logical><Bool>),

any_of(xs, pred) if and only if any_of(f(xs), pred)

find_if(xs, pred) == find_if(f(xs), pred)

Это просто обобщение следующих, более интуитивных требований. Для всех<xs>типов данных<S1(X)>и<x>типов данных<X>,

x ^in^ xs if and only if x ^in^ f(xs)

find(xs, x) == find(f(xs), x)

Эти требования можно понимать как указание на то, что<f>не изменяет содержание<xs>, хотя может изменять порядок элементов. Как обычно, такое структурно-сохраняющее преобразование называется встраиванием, если оно также является инъекционным, то есть если это преобразование без потерь.

Variables
constexpr auto	boost::hana::all
	Returns whether all the keys of the structure are true-valued.The keys of the structure must be `Logical`s. If the structure is not finite, a false-valued key must appear at a finite "index" in order for this method to finish. More...

constexpr auto	boost::hana::all_of
	Returns whether all the keys of the structure satisfy the `predicate`.If the structure is not finite, `predicate` has to return a false- valued `Logical` after looking at a finite number of keys for this method to finish. More...

constexpr auto	boost::hana::any
	Returns whether any key of the structure is true-valued.The keys of the structure must be `Logical`s. If the structure is not finite, a true-valued key must appear at a finite "index" in order for this method to finish. More...

constexpr auto	boost::hana::any_of
	Returns whether any key of the structure satisfies the `predicate`.If the structure is not finite, `predicate` has to be satisfied after looking at a finite number of keys for this method to finish. More...

constexpr auto	boost::hana::at_key
	Returns the value associated to the given key in a structure, or fail.Given a `key` and a `Searchable` structure, `at_key` returns the first value whose key is equal to the given `key`, and fails at compile-time if no such key exists. This requires the `key` to be compile-time `Comparable`, exactly like for `find`. `at_key` satisfies the following: More...

constexpr auto	boost::hana::contains
	Returns whether the key occurs in the structure.Given a `Searchable` structure `xs` and a `key`, `contains` returns whether any of the keys of the structure is equal to the given `key`. If the structure is not finite, an equal key has to appear at a finite position in the structure for this method to finish. For convenience, `contains` can also be applied in infix notation. More...

constexpr auto	boost::hana::in = hana::infix(hana::flip(hana::contains))
	Return whether the key occurs in the structure.Specifically, this is equivalent to `contains`, except `in` takes its arguments in reverse order. Like `contains`, `in` can also be applied in infix notation for increased expressiveness. This function is not a method that can be overriden; it is just a convenience function provided with the concept. More...

constexpr auto	boost::hana::find
	Finds the value associated to the given key in a structure.Given a `key` and a `Searchable` structure, `find` returns the `just` the first value whose key is equal to the given `key`, or `nothing` if there is no such key. Comparison is done with `equal`. `find` satisfies the following: More...

constexpr auto	boost::hana::find_if
	Finds the value associated to the first key satisfying a predicate.Given a `Searchable` structure `xs` and a predicate `pred`, `find_if(xs, pred)` returns `just` the first element whose key satisfies the predicate, or `nothing` if there is no such element. More...

constexpr auto	boost::hana::is_disjoint
	Returns whether two `Searchable`s are disjoint.Given two `Searchable`s `xs` and `ys`, `is_disjoint` returns a `Logical` representing whether the keys in `xs` are disjoint from the keys in `ys`, i.e. whether both structures have no keys in common. More...

constexpr auto	boost::hana::is_subset
	Returns whether a structure contains a subset of the keys of another structure.Given two `Searchable`s `xs` and `ys`, `is_subset` returns a `Logical` representing whether `xs` is a subset of `ys`. In other words, it returns whether all the keys of `xs` are also present in `ys`. This method does not return whether `xs` is a strict subset of `ys`; if `xs` and `ys` are equal, all the keys of `xs` are also present in `ys`, and `is_subset` returns true. More...

constexpr auto	boost::hana::none
	Returns whether all of the keys of the structure are false-valued.The keys of the structure must be `Logical`s. If the structure is not finite, a true-valued key must appear at a finite "index" in order for this method to finish. More...

constexpr auto	boost::hana::none_of
	Returns whether none of the keys of the structure satisfy the `predicate`.If the structure is not finite, `predicate` has to return a true- valued `Logical` after looking at a finite number of keys for this method to finish. More...

Variable Documentation

constexpr auto boost::hana::all

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

Initial value:

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

Возвращает, являются ли все ключи структуры истинными. Ключи от конструкции должны быть<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/all.hpp>
#include <boost/hana/assert.hpp>
#include <boost/hana/bool.hpp>
#include <boost/hana/not.hpp>
#include <boost/hana/tuple.hpp>
namespace hana = boost::hana;
static_assert(hana::all(hana::make_tuple(hana::true_c, true, hana::true_c)), "");
BOOST_HANA_CONSTANT_CHECK(!hana::all(hana::make_tuple(true, hana::false_c, hana::true_c)));
int main() { }

constexpr auto boost::hana::all_of

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

Initial value:

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

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

Parameters

xs	Структура для поиска.
predicate	Функция называется<`predicate(k)`>, где<`k`>является ключом структуры, и возвращает<`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/all_of.hpp>
#include <boost/hana/assert.hpp>
#include <boost/hana/config.hpp>
#include <boost/hana/ext/std/integral_constant.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/mod.hpp>
#include <boost/hana/not.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;
BOOST_HANA_CONSTEXPR_LAMBDA auto is_odd = [](auto x) {
    return x % 2_c != 0_c;
};
int main() {
    BOOST_HANA_CONSTEXPR_CHECK(hana::all_of(hana::make_tuple(1, 3), is_odd));
    BOOST_HANA_CONSTANT_CHECK(!hana::all_of(hana::make_tuple(3_c, 4_c), is_odd));
    BOOST_HANA_CONSTANT_CHECK(!hana::all_of(
        hana::make_tuple(hana::type_c<void>, hana::type_c<char&>), hana::trait<std::is_void>
    ));
    BOOST_HANA_CONSTANT_CHECK(hana::all_of(
        hana::make_tuple(hana::type_c<int>, hana::type_c<char>), hana::trait<std::is_integral>
    ));
}

constexpr auto boost::hana::any

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

Initial value:

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

Возвращает, является ли любой ключ структуры истинным. Ключи от конструкции должны быть<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/any.hpp>
#include <boost/hana/assert.hpp>
#include <boost/hana/bool.hpp>
#include <boost/hana/tuple.hpp>
namespace hana = boost::hana;
BOOST_HANA_CONSTANT_CHECK(hana::any(hana::make_tuple(false, hana::false_c, hana::true_c)));
static_assert(hana::any(hana::make_tuple(false, hana::false_c, true)), "");
static_assert(!hana::any(hana::make_tuple(false, hana::false_c, hana::false_c)), "");
int main() { }

constexpr auto boost::hana::any_of

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

Initial value:

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

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

Parameters

xs	Структура для поиска.
predicate	Функция называется<`predicate(k)`>, где<`k`>является ключом структуры, и возвращает<`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/any_of.hpp>
#include <boost/hana/assert.hpp>
#include <boost/hana/config.hpp>
#include <boost/hana/ext/std/integral_constant.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/mod.hpp>
#include <boost/hana/not.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;
BOOST_HANA_CONSTEXPR_LAMBDA auto is_odd = [](auto x) {
    return x % 2_c != 0_c;
};
int main() {
    BOOST_HANA_CONSTEXPR_CHECK(hana::any_of(hana::make_tuple(1, 2), is_odd));
    BOOST_HANA_CONSTANT_CHECK(!hana::any_of(hana::make_tuple(2_c, 4_c), is_odd));
    BOOST_HANA_CONSTANT_CHECK(hana::any_of(
        hana::make_tuple(hana::type_c<void>, hana::type_c<char&>), hana::trait<std::is_void>
    ));
    BOOST_HANA_CONSTANT_CHECK(!hana::any_of(
        hana::make_tuple(hana::type_c<void>, hana::type_c<char&>), hana::trait<std::is_integral>
    ));
}

constexpr auto boost::hana::at_key

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

Initial value:

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

Возвращает значение, связанное с заданным ключом в структуре, или выходит из строя. При наличии структуры<key>и<Searchable>,<at_key>возвращает первое значение, ключ которого равен данному<key>, и выходит из строя во время компиляции, если такой ключ не существует. Для этого требуется<key>время компиляции<Comparable>, как и для<find>.<at_key>удовлетворяет следующим требованиям:

at_key(xs, key) == find(xs, key).value()

Если<Searchable>действительно хранит элементы, которые он содержит,<at_key>требуется вернуть ссылку на lvalue, ссылку на lvalue на const или ссылку на rvalue на найденное значение, где тип ссылки должен соответствовать типу ссылки, переданной структуре<at_key>. Если<Searchable>не хранит элементы, которые он содержит (т.е. генерирует их по требованию), это требование отпадает.

Parameters

xs	Структура, которую нужно искать.
key	Ключ, который нужно искать в структуре. Ключ должен быть<`Comparable`>с другими ключами структуры. В текущей версии библиотеки сравнение<`key`>с любым другим ключом структуры должно возвращать время компиляции<`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/at_key.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/map.hpp>
#include <boost/hana/pair.hpp>
#include <boost/hana/type.hpp>
#include <string>
namespace hana = boost::hana;
int main() {
    auto m = hana::make_map(
        hana::make_pair(hana::type_c<int>, std::string{"int"}),
        hana::make_pair(hana::int_c<3>, std::string{"3"})
    );
    BOOST_HANA_RUNTIME_CHECK(hana::at_key(m, hana::type_c<int>) == "int");
    // usage as operator[]
    BOOST_HANA_RUNTIME_CHECK(m[hana::type_c<int>] == "int");
    BOOST_HANA_RUNTIME_CHECK(m[hana::int_c<3>] == "3");
}

constexpr auto boost::hana::contains

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

Initial value:

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

Возвращается ли ключ в структуре. При наличии<Searchable>структуры<xs>и<key>,<contains>возвращается, является ли любой из ключей структуры равным данному<key>. Если структура не конечна, равный ключ должен появиться в конечном положении в структуре для завершения этого метода. Для удобства<contains>можно также применять в инфиксной записи.

Parameters

xs	Структура для поиска.
key	Ключ, который нужно искать в структуре. Ключ должен быть<`Comparable`>с другими ключами структуры.

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/contains.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/set.hpp>
#include <boost/hana/tuple.hpp>
#include <boost/hana/type.hpp>
namespace hana = boost::hana;
BOOST_HANA_CONSTANT_CHECK(hana::contains(hana::make_tuple(2, hana::int_c<2>, hana::int_c<3>, 'x'), hana::int_c<3>));
BOOST_HANA_CONSTANT_CHECK(hana::contains(hana::make_set(hana::int_c<3>, hana::type_c<void>), hana::type_c<void>));
// contains can be applied in infix notation
BOOST_HANA_CONSTANT_CHECK(
    hana::make_tuple(2, hana::int_c<2>, hana::int_c<3>, 'x') ^hana::contains^ hana::int_c<2>
);
int main() { }

constexpr auto boost::hana::in = hana::infix(hana::flip(hana::contains))

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

Вернитесь, если ключ находится в структуре. В частности, это эквивалентно<contains>, за исключением<in>принимает свои аргументы в обратном порядке. Как и<contains>,<in>также может быть применен в фиксации для повышения выразительности. Эта функция не является методом, который может быть перегружен; это просто функция удобства, обеспеченная концепцией.

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/contains.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/tuple.hpp>
namespace hana = boost::hana;
BOOST_HANA_CONSTANT_CHECK(hana::int_c<2> ^hana::in^ hana::make_tuple(2, hana::int_c<2>, hana::int_c<3>, 'x'));
int main() { }

constexpr auto boost::hana::find

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

Initial value:

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

Находит значение, связанное с данным ключом в структуре. При наличии<key>и<Searchable>структуры<find>возвращает<just>первое значение, ключ которого равен данному<key>, или<nothing>, если такого ключа нет. Сравнение проводится с<equal>.<find>удовлетворяет следующим требованиям:

find(xs, key) == find_if(xs, equal.to(key))

Parameters

xs	Структура, которую нужно искать.
key	Ключ, который нужно искать в структуре. Ключ должен быть<`Comparable`>с другими ключами структуры. В текущей версии библиотеки сравнение<`key`>с любым другим ключом структуры должно возвращать время компиляции<`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/find.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/map.hpp>
#include <boost/hana/optional.hpp>
#include <boost/hana/pair.hpp>
#include <boost/hana/tuple.hpp>
#include <boost/hana/type.hpp>
namespace hana = boost::hana;
BOOST_HANA_CONSTANT_CHECK(
    hana::find(hana::make_tuple(hana::int_c<1>, hana::type_c<int>, '3'), hana::type_c<int>) == hana::just(hana::type_c<int>)
);
BOOST_HANA_CONSTANT_CHECK(
    hana::find(hana::make_tuple(hana::int_c<1>, hana::type_c<int>, '3'), hana::type_c<void>) == hana::nothing
);
constexpr auto m = hana::make_map(
    hana::make_pair(hana::int_c<2>, 2),
    hana::make_pair(hana::type_c<float>, 3.3),
    hana::make_pair(hana::type_c<char>, hana::type_c<int>)
);
static_assert(hana::find(m, hana::type_c<float>) == hana::just(3.3), "");
int main() { }

Ссылка наboost::hana::literals::operator""_s().

constexpr auto boost::hana::find_if

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

Initial value:

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

Находит значение, связанное с первым ключом, удовлетворяющим предикату. При наличии<Searchable>структуры<xs>и предиката<pred><find_if(xs, pred)>возвращает<just>первый элемент, ключ которого удовлетворяет предикату, или<nothing>, если такого элемента нет.

Parameters

xs Структура, которую нужно искать.

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

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/equal.hpp>
#include <boost/hana/ext/std/integral_constant.hpp>
#include <boost/hana/find_if.hpp>
#include <boost/hana/functional/compose.hpp>
#include <boost/hana/optional.hpp>
#include <boost/hana/tuple.hpp>
#include <boost/hana/type.hpp>
#include <type_traits>
namespace hana = boost::hana;
// First get the type of the object, and then call the trait on it.
constexpr auto is_integral = hana::compose(hana::trait<std::is_integral>, hana::typeid_);
constexpr auto is_class = hana::compose(hana::trait<std::is_class>, hana::typeid_);
static_assert(
    hana::find_if(hana::make_tuple(1.0, 2, '3'), is_integral) == hana::just(2)
, "");
BOOST_HANA_CONSTANT_CHECK(
    hana::find_if(hana::make_tuple(1.0, 2, '3'), is_class) == hana::nothing
);
constexpr auto types = hana::tuple_t<char, int, unsigned, long, unsigned long>;
BOOST_HANA_CONSTANT_CHECK(
    hana::find_if(types, hana::equal.to(hana::type_c<unsigned>)) == hana::just(hana::type_c<unsigned>)
);
BOOST_HANA_CONSTANT_CHECK(
    hana::find_if(types, hana::equal.to(hana::type_c<void>)) == hana::nothing
);
int main() { }

constexpr auto boost::hana::is_disjoint

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

Initial value:

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

Возвращает ли два<Searchable>несвязанных. Учитывая два<Searchable>с<xs>и<ys>,<is_disjoint>возвращает a<Logical>, представляющее, являются ли ключи в<xs>несвязанными с ключами в<ys>, то есть не имеют ли обе структуры общих ключей.

Parameters

xs,ys Два<Searchable>для проверки на несоответствие.

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/is_disjoint.hpp>
#include <boost/hana/map.hpp>
#include <boost/hana/not.hpp>
#include <boost/hana/set.hpp>
#include <boost/hana/tuple.hpp>
#include <boost/hana/type.hpp>
#include <string>
namespace hana = boost::hana;
using namespace std::literals;
int main() {
    // Tuples
    auto xs = hana::make_tuple(hana::int_c<1>, "alfa"s, hana::type_c<int>);
    auto ys = hana::make_tuple(hana::type_c<void>, hana::int_c<3>, "bravo"s);
    BOOST_HANA_RUNTIME_CHECK(hana::is_disjoint(xs, ys));
    // Sets
    auto s1 = hana::make_set(hana::int_c<1>, hana::type_c<void>, hana::int_c<2>);
    auto s2 = hana::make_set(hana::type_c<char>, hana::type_c<int>, hana::int_c<1>);
    BOOST_HANA_CONSTANT_CHECK(!hana::is_disjoint(s1, s2));
    // Maps
    auto vowels = hana::make_map(
        hana::make_pair(hana::char_c<'a'>, "alfa"s),
        hana::make_pair(hana::char_c<'e'>, "echo"s),
        hana::make_pair(hana::char_c<'i'>, "india"s)
        // ...
    );
    auto consonants = hana::make_map(
        hana::make_pair(hana::char_c<'b'>, "bravo"s),
        hana::make_pair(hana::char_c<'c'>, "charlie"s),
        hana::make_pair(hana::char_c<'f'>, "foxtrot"s)
        // ...
    );
    BOOST_HANA_CONSTANT_CHECK(hana::is_disjoint(vowels, consonants));
}

constexpr auto boost::hana::is_subset

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

Initial value:

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

Возвращает, содержит ли структура подмножество ключей другой структуры. При наличии двух<Searchable>s<xs>и<ys>,<is_subset>возвращает<Logical>, представляющее, является ли<xs>подмножеством<ys>. Другими словами, он возвращает, все ли ключи<xs>также присутствуют в<ys>. Этот метод не возвращает, является ли<xs>строгимподмножеством<ys>; если<xs>и<ys>равны, все ключи<xs>также присутствуют в<ys>, и<is_subset>возвращает истинно.

Note: For convenience, is_subset can also be applied in infix notation.

Cross-type version of the method

Этот метод отправляется с использованием тегов обоих аргументов. Он может быть назван с любыми двумя<Searchable>s общим<Searchable>встраиванием, как определено в основной документации концепции<Searchable>. Когда<Searchable>s с двумя различными тегами, но совместное использование общего встраивания отправляется в<is_subset>, они сначала преобразуются в этот общий<Searchable>, а затем используется<is_subset>метод общего встраивания. Конечно, метод может быть перегружен для пользовательских<Searchable>для эффективности.

Note: While cross-type dispatching for is_subset is supported, it is not currently used by the library because there are no models of Searchable with a common embedding.

Parameters

xs	Структура для проверки, является ли она подмножеством<`ys`>.
ys	Строение для проверки, является ли оно супермножеством<`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/is_subset.hpp>
#include <boost/hana/tuple.hpp>
namespace hana = boost::hana;
static_assert(
    hana::is_subset(hana::make_tuple(1, '2', 3.3), hana::make_tuple(3.3, 1, '2', nullptr))
, "");
// is_subset can be applied in infix notation
static_assert(
    hana::make_tuple(1, '2', 3.3) ^hana::is_subset^ hana::make_tuple(3.3, 1, '2', nullptr)
, "");
int main() { }

constexpr auto boost::hana::none

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

Initial value:

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

Возвращает, являются ли все ключи структуры ложными. Ключи от конструкции должны быть<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/bool.hpp>
#include <boost/hana/none.hpp>
#include <boost/hana/not.hpp>
#include <boost/hana/tuple.hpp>
namespace hana = boost::hana;
static_assert(hana::none(hana::make_tuple(false, hana::false_c, hana::false_c)), "");
static_assert(!hana::none(hana::make_tuple(false, hana::false_c, true)), "");
BOOST_HANA_CONSTANT_CHECK(!hana::none(hana::make_tuple(false, hana::false_c, hana::true_c)));
int main() { }

constexpr auto boost::hana::none_of

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

Initial value:

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

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

Parameters

xs	Структура для поиска.
predicate	Функция называется<`predicate(k)`>, где<`k`>является ключом структуры, и возвращает<`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/config.hpp>
#include <boost/hana/ext/std/integral_constant.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/mod.hpp>
#include <boost/hana/none_of.hpp>
#include <boost/hana/not.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;
BOOST_HANA_CONSTEXPR_LAMBDA auto is_odd = [](auto x) {
    return x % 2_c != 0_c;
};
int main() {
    BOOST_HANA_CONSTANT_CHECK(hana::none_of(hana::make_tuple(2_c, 4_c), is_odd));
    BOOST_HANA_CONSTEXPR_CHECK(!hana::none_of(hana::make_tuple(1, 2), is_odd));
    BOOST_HANA_CONSTANT_CHECK(
        !hana::none_of(hana::make_tuple(hana::type_c<void>, hana::type_c<char&>), hana::trait<std::is_void>)
    );
    BOOST_HANA_CONSTANT_CHECK(
        hana::none_of(hana::make_tuple(hana::type_c<void>, hana::type_c<char&>), hana::trait<std::is_integral>)
    );
}

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

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

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

Время компиляции файла: 2024-08-30 11:47:00
2025-05-19 19:54:34/0.033952951431274/1

Boost.Hana: Searchable

Boost , ,

Minimal complete definition

Laws

Concrete models

Free model for builtin arrays

Structure preserving functions

Variables

Variable Documentation

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Cross-type version of the method

Example

Example

Example