Boost.Hana: Comparable . Boost , ,

Boost.Hana 1.0.1

Your standard library for metaprogramming

Понятие<Comparable>определяет равенство и неравенство.

Интуитивно<Comparable>объекты должны определять двоичный предикат, названный<equal>, который возвращает, представляют ли оба объекта одно и то же абстрактное значение. Иными словами,<equal>должно проверять на глубокое равенство. Поскольку «представление одной и той же абстрактной ценности» трудно выразить формально, точный смысл равенства частично оставлен для интерпретации программистом со следующими указаниями:

Равенство должно быть совместимо с конструированием копий; копирование, конструирующее значение, дает значениеequal.
Равенство должно быть независимым от представления; объект, представляющий дробь как4/8, должен бытьequalк объекту, представляющему дробь как2/4, поскольку они оба представляют математический объект1/2.

Более того,<equal>должно проявлять свойства, которые делают интуитивно понятным использование для определения эквивалентности объектов, что формализуется законами для<Comparable>.

Minimal complete definition

equal
Когдаequalопределено,not_equalреализуется по умолчанию в качестве его дополнения. Для всех объектовx,yметкиComparable,
не равны(x, y) ==не_равны(x, y))
[ORIG_END] -->

Laws

<equal>должно определятьотношение эквивалентности, и<not_equal>должно быть его дополнением. Другими словами, для всех объектов<a>,<b>,<c>метки<Comparable>верно следующее (где<x == y>и<x != y>обозначают<equal(x, y)>и<not_equal(x, y)>соответственно):

a == a                          // Reflexivity
if a == b then b == a           // Symmetry
if a == b && b == c then a == c // Transitivity
a != b is equivalent to !(a == b)

Concrete models

<hana::integral_constant>,<hana::map>,<hana::optional>,<hana::pair>,<hana::range>,<hana::set>,<hana::string>,<hana::tuple>,<hana::type>

Free model for `EqualityComparable` data types

Два типа данных<T>и<U>, которые моделируют концепцию EqualityComparable перекрестного типа, представленную вN3351, автоматически моделируют концепцию<Comparable>, устанавливая

equal(x, y) = (x == y)

Обратите внимание, что это также делает одинаковыми типы равенства вобычном смыслемодели<Comparable>.

Equality-preserving functions

Пусть<A>и<B>будут двумя<Comparable>бирками. Функция \(f: A \to B\) называется равносохраняющей, если она сохраняет структуру<Comparable>понятия, которое можно строго изложить следующим образом. Для всех объектов<x>,<y>метки<A>,

if equal(x, y) then equal(f(x), f(y))

Мы просто требуем, чтобы<f>была функция в обычном математическом смысле. Другим свойством являетсяинъекционность, которую можно рассматривать как отображение без потерь. Это свойство можно определить как

if equal(f(x), f(y)) then equal(x, y)

Это эквивалентно утверждению, что<f>отображает отдельные элементы в отдельные элементы, отсюда и аналогия «без потерь». Другими словами,<f>не будет сжимать отдельные элементы из своего домена в один элемент в своем изображении, тем самым теряя информацию.

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

Cross-type version of the methods

Методы<equal>и<not_equal>«перегружены» для обработки отдельных тегов с определенными свойствами. В частности, они определены дляразличныхтегов<A>и<B>, так что

AиBимеют общую меткуC, определяемую метафункциейcommon.
A,BиC- всеComparable, если принимать индивидуально
\(\mathtt{to} : A \to C \) и \(\mathtt{to} : B \to C\) являются как сохраняющими равенство, так и инъекционными (т.е. они являются встраиванием), как определено метафункциейis_embedding.

Определения метода для тегов, удовлетворяющих вышеуказанным свойствам, являются

equal(x, y) = equal(to<C>(x), to<C>(y))

not_equal(x, y) = not_equal(to<C>(x), to<C>(y))

Important note: special behavior of `equal`

В контексте программирования с разнородными значениями полезно сравнивать несвязанные объекты<false>вместо того, чтобы вызывать ошибку. По этой причине<equal>принимает специальное поведение для несвязанных объектов меток<T>и<U>, не удовлетворяющих вышеуказанным требованиям к перегрузкам поперечного типа. В частности, когда<T>и<U>не связаны (т.е.<T>не могут быть преобразованы в<U>и наоборот), сравнение объектов с этими тегами дает ложное значение времени компиляции. Это приводит к тому, что несвязанные объекты, такие как<float>и<std::string>, будут сравнивать ложные, в то время как сравнение связанных объектов, которые не могут быть безопасно встроены в одну и ту же сверхструктуру (например,<long long>и<float>из-за потери точности), вызовет утверждение времени компиляции. Также обратите внимание, что для любого тега<T>, для которого не предусмотрено минимальное полное определение<Comparable>, также будет запущено утверждение времени компиляции, потому что<T>и<T>тривиально разделяют общий тег<T>, который является ожидаемым поведением. Этот выбор дизайна направлен на обеспечение большей гибкости для сравнения объектов, в то же время отвергая шаблоны использования, которые, скорее всего, являются ошибками программирования.

Variables
constexpr auto	boost::hana::comparing
	Returns a function performing `equal` after applying a transformation to both arguments.`comparing` creates an equivalence relation based on the result of applying a function to some objects, which is especially useful in conjunction with algorithms that accept a custom predicate that must represent an equivalence relation. More...

constexpr auto	boost::hana::equal
	Returns a `Logical` representing whether `x` is equal to `y`.The `equal` function can be called in two different ways. First, it can be called like a normal function: More...

constexpr auto	boost::hana::not_equal
	Returns a `Logical` representing whether `x` is not equal to `y`.The `not_equal` function can be called in two different ways. First, it can be called like a normal function: More...

Variable Documentation

constexpr auto boost::hana::comparing

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

Initial value:

= [](auto&& f) {
        return [perfect-capture](auto&& x, auto&& y) {
            return equal(f(forwarded(x)), f(forwarded(y)));
        };
    }

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

В частности,<comparing>является

comparing(f) == equal ^on^ f

или, эквивалентно,

comparing(f)(x, y) == equal(f(x), f(y))

Note: This is not a tag-dispatched method (hence it can't be customized), but just a convenience function provided with the Comparable concept.

Signature

При наличии логических<Bool>и сопоставимых<B>подпись \(\mathtt{comparing} : (A \to B) \to (A \times A \to 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/comparing.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/group.hpp>
#include <boost/hana/length.hpp>
#include <boost/hana/range.hpp>
#include <boost/hana/tuple.hpp>
namespace hana = boost::hana;
int main() {
    constexpr auto sequences = hana::make_tuple(
        hana::make_tuple(1, 2, 3),
        hana::make_tuple('x', 'y', 'z'),
        hana::range_c<long, 0, 1>,
        hana::tuple_t<char, int>,
        hana::range_c<int, 0, 2>,
        hana::make_tuple(123.4, nullptr)
    );
    constexpr auto grouped = hana::group.by(hana::comparing(hana::length), sequences);
    static_assert(grouped == hana::make_tuple(
        hana::make_tuple(
            hana::make_tuple(1, 2, 3),
            hana::make_tuple('x', 'y', 'z')
        ),
        hana::make_tuple(
            hana::range_c<long, 0, 1>
        ),
        hana::make_tuple(
            hana::tuple_t<char, int>,
            hana::range_c<int, 0, 2>,
            hana::make_tuple(123.4, nullptr)
        )
    ), "");
}

constexpr auto boost::hana::equal

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

Initial value:

= [](auto&& x, auto&& y) {
        return tag-dispatched;
    }

Возвращает<Logical>, представляя, равна ли<x><y>. Функция<equal>может быть названа двумя различными способами. Во-первых, его можно назвать нормальной функцией:

equal(x, y)

Однако он также может быть частично применен к аргументу, используя<equal.to>:

equal.to(x)(y) == equal(x, y)

Иными словами,<equal.to(x)>является функциональным объектом, эквивалентным<partial(equal, x)>. Это обеспечивается для повышения читаемости некоторых конструкций, особенно при использовании алгоритмов более высокого порядка.

Signature

При наличии Логического<Bool>и двух Сравнительных<A>и<B>, которые разделяют общее встраивание, подпись \(\mathtt{equal} : A \times B \to Bool \

Parameters

x,y	Два объекта для сравнения равенства.

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

Rationale for the arity of equal

Вопрос в том, следует ли<equal>принять более 2 аргументов и иметь семантику, соответствующую семантике Python<==>. В настоящее время это не поддерживается по следующим причинам:

Он был реализован в MPL11, но пока не показал себя полезным.

Дляnot_equalне имеет смысла иметь аритмию более 2, толькоequalможет иметь ту семантику, которая нарушала бы симметрию.

constexpr auto boost::hana::not_equal

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

Initial value:

= [](auto&& x, auto&& y) {
        return tag-dispatched;
    }

<Logical>, что означает, что<x>не равен<y>.<not_equal>функция может быть названа двумя различными способами. Во-первых, его можно назвать нормальной функцией:

not_equal(x, y)

Однако это также может быть частично применено к аргументу, используя<not_equal.to>:

not_equal.to(x)(y) == not_equal(x, y)

Иными словами,<not_equal.to(x)>является функциональным объектом, эквивалентным<partial(not_equal, x)>. Это обеспечивается для повышения читаемости некоторых конструкций, особенно при использовании алгоритмов более высокого порядка.

Signature

При наличии Логического<Bool>и двух Сравнительных<A>и<B>, которые имеют общее вложение, подпись \(\mathtt{not\_equal} : A \times B \to Bool \

Parameters

x,y	Два объекта для сравнения неравенства.

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/not_equal.hpp>
#include <boost/hana/tuple.hpp>
namespace hana = boost::hana;
int main() {
    static_assert(hana::not_equal(hana::make_tuple(1, 2), hana::make_tuple(3)), "");
    static_assert(hana::not_equal('x', 'y'), "");
    BOOST_HANA_CONSTANT_CHECK(hana::not_equal(hana::make_tuple(1, 2), 'y'));
    static_assert(hana::all_of(hana::make_tuple(1, 2, 3), hana::not_equal.to(5)), "");
}

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

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

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

Время компиляции файла: 2024-08-30 11:47:00
2025-05-20 01:46:48/0.0059108734130859/0

Boost.Hana: Comparable

Boost , ,

Minimal complete definition

Laws

Concrete models

Free model for EqualityComparable data types

Equality-preserving functions

Cross-type version of the methods

Important note: special behavior of equal

Variables

Variable Documentation

Signature

Example

Signature

Example

Rationale for the arity of equal

Signature

Example

Free model for `EqualityComparable` data types

Important note: special behavior of `equal`

Rationale for the arity of `equal`