Boost.Hana: boost::hana::optional< T > Struct Template Reference . Boost , ,

Boost.Hana 1.0.1

Your standard library for metaprogramming

Факультативное значение, факультативность которого известна во время компиляции.

(0) либо содержит значение (представлено как<just(x)>), либо является пустым (представлено как<nothing>). По сути,<hana::optional>в значительной степени похож на<boost::optional>или предстоящий<std::optional>, за исключением того факта, что<hana::optional>пуст или не известен во время компиляции. Это может быть особенно полезно для возвращения из функции, которая может выйти из строя, но причина отказа не важна. Конечно, о том, что функция выйдет из строя, нужно знать во время компиляции.

В отличие от<std::optional<T>{}>и<std::optional<T>{x}>, которые разделяют один и тот же тип<std::optional<T>>,<hana::just(x)>и<hana::nothing>не разделяют один и тот же тип, поскольку состояние факультативного должно быть известно во время компиляции. Следовательно, будет ли<hana::just>или<hana::nothing>возвращено из функции, должно быть известно во время компиляции, чтобы тип возврата этой функции был вычислим компилятором. Это делает<hana::optional>хорошо подходящим для статических задач метапрограммирования, но очень плохим для чего-либо динамического.

Interoperation with `type`s

Когда<just>содержит объект типа<T>, который является<type>, он имеет вложенный<::type>псевдоним, эквивалентный<T::type>.<nothing>, однако никогда не имеет вложенного<::type>псевдонима. Если<t>является<type>, это позволяет рассматривать<decltype(just(t))>как нулевую метафункцию, эквивалентную<decltype(t)>. Наряду с функцией<sfinae>это позволяет<hana::optional>легко взаимодействовать с метафункциями, удобными для SFINAE. Пример:

// 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/not.hpp>
#include <boost/hana/optional.hpp>
#include <boost/hana/traits.hpp>
#include <boost/hana/type.hpp>
#include <type_traits>
#include <utility>
namespace hana = boost::hana;
template <typename ...>
using void_t = void;
template <typename T, typename = void>
struct has_type : std::false_type { };
template <typename T>
struct has_type<T, void_t<typename T::type>>
    : std::true_type
{ };
auto common_type_impl = hana::sfinae([](auto t, auto u) -> decltype(hana::type_c<
    decltype(true ? hana::traits::declval(t) : hana::traits::declval(u))
>) { return {}; });
template <typename T, typename U>
using common_type2 = decltype(common_type_impl(hana::type_c<T>, hana::type_c<U>));
static_assert(!has_type<common_type2<int, int*>>{}, "");
static_assert(std::is_same<common_type2<int, float>::type, float>{}, "");
int main() { }

Modeled concepts

Comparable
Дваoptionalравны, если и только если они оба пусты или оба содержат значение и эти значения равны.
// Авторское право 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/optional.hpp>
пространство именхана =повышение::хана;
Boost_HANA_CONSTANT_CHECK(хана::ничего == хана::ничего);
static_assert (hana::just& #39;x') == hana::just& #39;x'),"";
static_assert (hana::just& #39;x') != hana::just& #39;y'),"");
Boost_HANA_CONSTANT_CHECK(hana::just& #39;x')!= hana::nothing);
intmain()
[ORIG_END] -->
Orderable
Опциональные значения могут быть упорядочены с учетом значения, которое они имеют, если таковое имеется. Для решения вопроса о пустом необязательном значении мы произвольно устанавливаемnothingкак меньшее, чем любое другоеjust. Следовательно,
просто(x)<просто(y) если и только если x< y
ничего<просто(что угодно)
Пример:
// Авторское право Louis Dionne 2013-2016
// Распространяется по лицензии Boost Software, версия 1.0.
// (См. сопровождающий файл LICENSE.md или копию по адресу http://boost.org/LICENSE_1_0.txt)
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/greater.hpp>
#include <boost/hana/less.hpp>
#include <boost/hana/optional.hpp>
namespace hana = boost::hana;
BOOST_HANA_CONSTANT_CHECK(hana::nothing < hana::just(3));
BOOST_HANA_CONSTANT_CHECK(hana::just(0) > hana::nothing);
static_assert(hana::just(1) < hana::just(3), "");
static_assert(hana::just(3) > hana::just(2), "");
int main() { }
[ORIG_END] -->
Functor
Необязательное значение можно рассматривать как список, содержащий либо один элементjust(x), либо вообще никаких элементовnothing. Таким образом, отображение функции над необязательным значением эквивалентно применению его к его значению, если оно есть, и кnothingв противном случае:
трансформировать просто(x), f) ==просто(f(x))
трансформировать[ничего, f] == ничего
Пример:
// Авторское право Louis Dionne 2013-2016
// Распространяется по лицензии Boost Software License, версия 1.0.
// [См. сопроводительный файл LICENSE.md или копию по адресу http://boost.org/LICENSE_1_0.txt]
boost/hana/assert.hppboost/hana/equal.hpp
[186 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/functional/placeholder.hpp>
#include <boost/hana/optional.hpp>
#include <boost/hana/transform.hpp>
namespace hana = boost::hana;
BOOST_HANA_CONSTANT_CHECK(hana::transform(hana::nothing, hana::_ + 1) == hana::nothing);
static_assert(hana::transform(hana::just(1), hana::_ + 1) == hana::just(2), "");
int main() { }
[ORIG_END] -->
Applicative
Во-первых, значение может быть сделано необязательным сlift<optional_tag>, что эквивалентноjust. Во-вторых, можно подавать факультативное значение факультативной функции сap, которое будет возвращатьjust(f(x)), если есть и функцияизначение, иnothingв противном случае:
ap(просто(f),просто(x)) ==просто(f(x))
ap
ap
Простой пример:
// Авторское право Louis Dionne 2013-2016
// Распространяется по лицензии Boost Software License, Version 1.0.
// (См. сопроводительный файл LICENSE.md или копию по адресу http://boost.org/LICENSE_1_0.txt)
boost/hana/ap.hpp>boost/hana/assert.hpp>
boost/hana/optional.hpp
constexproptional]
[статический_assert]
[хана:
[хана][хана:& #39;x' [3 BOOST_HANA_CONSTANT_CHECKhana::ap(hana::nothing, hana::just& #39;x') == hana::nothing;
BOOST_HANA_CONSTANT_CHECK(hana::ap(hana::just(next), hana::nothing) == hana::nothing);
BOOST_HANA_CONSTANT_CHECK(hana::ap(hana:::nothing:::nothing) == hana:
intmain()
Более сложный пример:
// Авторское право Louis Dionne 2013-2016
// Распространяется по лицензии Boost Software License, Version 1.0.
// [См. сопроводительный файл LICENSE.md или копию по адресу http://boost.org/LICENSE_1_0.txt]
шаблоншаблон
авто
[(оценить<'1', '+', '2'>== hana::just(1+2));
Boost_HANA_CONSTANT_CHECK(оценить<'?','+','2'>== hana::nothing);
BOOST_HANA_CONSTANT_CHECK(оценить<'1',',''>== hana::nothing);
BOOST_HANA_CONSTANT_CHECK(оценить<'1', '+', ';'>== hana::nothing);
static_assert(hana::lift(123) == hana::just(123),""]
] A simple 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/assert.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/optional.hpp>
namespace hana = boost::hana;
constexpr char next(char c) { return c + 1; }
static_assert(hana::ap(hana::just(next), hana::just('x')) == hana::just('y'), "");
BOOST_HANA_CONSTANT_CHECK(hana::ap(hana::nothing, hana::just('x')) == hana::nothing);
BOOST_HANA_CONSTANT_CHECK(hana::ap(hana::just(next), hana::nothing) == hana::nothing);
BOOST_HANA_CONSTANT_CHECK(hana::ap(hana::nothing, hana::nothing) == hana::nothing);
int main() { }
A more complex 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/assert.hpp>
#include <boost/hana/bool.hpp>
#include <boost/hana/config.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/if.hpp>
#include <boost/hana/lift.hpp>
#include <boost/hana/optional.hpp>
namespace hana = boost::hana;
template <char op>
constexpr auto function = hana::nothing;
template <>
BOOST_HANA_CONSTEXPR_LAMBDA auto function<'+'> = hana::just([](auto x, auto y) {
return x + y;
});
template <>
BOOST_HANA_CONSTEXPR_LAMBDA auto function<'-'> = hana::just([](auto x, auto y) {
return x - y;
});
// and so on...
template <char n>
constexpr auto digit = hana::if_(hana::bool_c<(n >= '0' && n <= '9')>,
hana::just(static_cast<int>(n - 48)),
hana::nothing
);
template <char x, char op, char y>
BOOST_HANA_CONSTEXPR_LAMBDA auto evaluate = hana::ap(function<op>, digit<x>, digit<y>);
int main() {
BOOST_HANA_CONSTEXPR_CHECK(evaluate<'1', '+', '2'> == hana::just(1 + 2));
BOOST_HANA_CONSTANT_CHECK(evaluate<'?', '+', '2'> == hana::nothing);
BOOST_HANA_CONSTANT_CHECK(evaluate<'1', '?', '2'> == hana::nothing);
BOOST_HANA_CONSTANT_CHECK(evaluate<'1', '+', '?'> == hana::nothing);
BOOST_HANA_CONSTANT_CHECK(evaluate<'?', '?', '?'> == hana::nothing);
static_assert(hana::lift<hana::optional_tag>(123) == hana::just(123), "");
}
[ORIG_END] -->
Monad
МодельMonadпозволяет легко составлять действия, которые могут потерпеть неудачу. Можно подавать дополнительное значение, если оно есть, в функцию сchain, которая возвращаетnothing, если нет значения. Наконец, факультативные значения могут иметь избыточный уровень факультативности, удаленный сflatten. Также обратите внимание, что оператор|может использоваться вместо функцииchain. Пример:
// Авторское право Louis Dionne 2013-2016
// Распространяется по лицензии Boost Software License, Version 1.0.
// [См. сопроводительный файл LICENSE.md или копию по адресу http://boost.org/LICENSE_1_0.txt]
[hana::chain(hana::just(1), inc) == hana::just(2));
BOOST_HANA_CONSTANT_CHECK hana::chain(hana::nothing, inc) == hana::nothing;
Boost_HANA_CONSTEXPR_CHECK hana::flatten(hana::just(hana::just(2))) == hana::just(2));
}
[ORIG_END] -->
MonadPlus
МодельMonadPlusпозволяет выбрать первое действительное значение из двух дополнительных значений сconcat. Если оба необязательных значения равныnothingс,concatвернетсяnothing. Пример:
// Авторское право Louis Dionne 2013-2016
// Распространяется по лицензии Boost Software License, Version 1.0.
// (См. сопроводительный файл LICENSE.md или копию по адресу http://boost.org/LICENSE_1_0.txt)
nothing
MonadPlus
MonadPlus
MonadPlus
MonadPlusMonadPlus
MonadPlusMonadPlusMonadPlusMonadPlusMonadPlusMonadPlusMonadPlusMonadPlusMonadPlusMonadPlusMonadPlus
] " BOOST_HANA_CONSTANT_CHECK
[ХАНА_CONSTANT_CHECK[ORIG_END] -->

Foldable
Складка необязательного значения эквивалентна складыванию списка, содержащего либо отсутствие элементов (дляnothing), либоx(дляjust(x). Пример:
// Авторское право Louis Dionne 2013-2016
// Распространяется по лицензии Boost Software License, Version 1.0.
// (См. сопроводительный файл LICENSE.md или копию по адресу http://boost.org/LICENSE_1_0.txt)
>
[ORIG_END] -->

Searchable
Поиск необязательного значения эквивалентен поиску списка, содержащегоxдляjust(x)и пустого списка дляnothing. Пример:
// Авторское право Louis Dionne 2013-2016
// Распространяется по лицензии Boost Software License, Version 1.0.
// [См. сопроводительный файл LICENSE.md или копию по адресу http://boost.org/LICENSE_1_0.txt]
[ hana::int_c<0>;
};
Boost_HANA_CONSTANT_CHECK hana::find_if(hana::just(hana::int_c<3>), odd) == hana::just::hana::int_c<3>);
BOOST_HANA_CONSTANT_CHECK hana::find_if(hana::just (hana::int_c<2>), odd) == hana::nothing;
BOOST_HANA_CONSTANT_CHECK hana::find_if(hana::nothing, odd) == hana::nothing;
BOOST_HANA_CONSTANT_CHECK hana::all_of(hana::just (hana::int_c<3>), odd));
BOOST_HANA_CONSTANT_CHECK hana::all_of(hana:: nothing, odd));
intmain()
[ORIG_END] -->

Synopsis of associated functions
template<>
constexpr auto	make< optional_tag >
	Create an optional value. More...

constexpr auto	make_optional = make<optional_tag>
	Alias to `make<optional_tag>`; provided for convenience. More...

constexpr auto	just
	Create an optional value containing `x`. More...

constexpr optional	nothing {}
	An empty optional value. More...

constexpr auto	maybe
	Apply a function to the contents of an optional, with a fallback result. More...

auto	sfinae
	Calls a function if the call expression is well-formed. More...

constexpr auto	is_just
	Return whether an `optional` contains a value. More...

constexpr auto	is_nothing
	Return whether an `optional` is empty. More...

Friends
template<typename... T, typename F >
constexpr auto	operator\| (optional< T... >, F)
	Equivalent to `hana::chain`.

template<typename X , typename Y >
constexpr auto	operator== (X &&x, Y &&y)
	Equivalent to `hana::equal`

template<typename X , typename Y >
constexpr auto	operator!= (X &&x, Y &&y)
	Equivalent to `hana::not_equal`

template<typename X , typename Y >
constexpr auto	operator< (X &&x, Y &&y)
	Equivalent to `hana::less`

template<typename X , typename Y >
constexpr auto	operator> (X &&x, Y &&y)
	Equivalent to `hana::greater`

template<typename X , typename Y >
constexpr auto	operator<= (X &&x, Y &&y)
	Equivalent to `hana::less_equal`

template<typename X , typename Y >
constexpr auto	operator>= (X &&x, Y &&y)
	Equivalent to `hana::greater_equal`

Public Member Functions
constexpr	optional ()=default
	Default-construct an `optional`. Only exists if the optional contains a value, and if that value is DefaultConstructible.

	optional (optional const &)=default
	Copy-construct an `optional`. An empty optional may only be copy-constructed from another empty `optional`, and an `optional` with a value may only be copy-constructed from another `optional` with a value. Furthermore, this constructor only exists if the value held in the `optional` is CopyConstructible.

	optional (optional &&)=default
	Move-construct an `optional`. An empty optional may only be move-constructed from another empty `optional`, and an `optional` with a value may only be move-constructed from another `optional` with a value. Furthermore, this constructor only exists if the value held in the `optional` is MoveConstructible.

constexpr	optional (T const &t)
	Construct an `optional` holding a value of type `T` from another object of type `T`. The value is copy-constructed.

constexpr	optional (T &&t)
	Construct an `optional` holding a value of type `T` from another object of type `T`. The value is move-constructed.

constexpr optional &	operator= (optional const &)=default
	Copy-assign an `optional`. An empty optional may only be copy-assigned from another empty `optional`, and an `optional` with a value may only be copy-assigned from another `optional` with a value. Furthermore, this assignment operator only exists if the value held in the `optional` is CopyAssignable.

constexpr optional &	operator= (optional &&)=default
	Move-assign an `optional`. An empty optional may only be move-assigned from another empty `optional`, and an `optional` with a value may only be move-assigned from another `optional` with a value. Furthermore, this assignment operator only exists if the value held in the `optional` is MoveAssignable.

constexpr T *	operator-> ()
	Returns a pointer to the contained value, or a `nullptr` if the `optional` is empty. More...

constexpr T &	value ()
	Extract the content of an `optional`, or fail at compile-time. More...

constexpr T &	operator* ()
	Equivalent to `value()`, provided for convenience. More...

template<typename U >
decltype(auto) constexpr	value_or (U &&default_)
	Return the contents of an `optional`, with a fallback result. More...

Associated functions

template<typename... T>

template<>

constexpr auto make< optional_tag >

Initial value:

= []([auto&& x]) {
        return optional<std::decay<decltype(x)>::type>{forwarded(x)};
    }

Создайте дополнительную ценность.

В частности,<make<optional_tag>()>эквивалентно<nothing>, а<make<optional_tag>(x)>эквивалентно<just(x)>. Это обеспечивает согласованность с другими<make<...>>функциями.

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/make.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/optional.hpp>
namespace hana = boost::hana;
int main() {
    constexpr auto x = hana::make<hana::optional_tag>();
    BOOST_HANA_CONSTANT_CHECK(x == hana::make_optional());
    BOOST_HANA_CONSTANT_CHECK(hana::is_nothing(x));
    constexpr auto just_x = hana::make<hana::optional_tag>('x');
    static_assert(just_x == hana::make_optional('x'), "");
    BOOST_HANA_CONSTANT_CHECK(hana::is_just(just_x));
}

template<typename... T>

constexpr auto make_optional = make<optional_tag>

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

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/make.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/optional.hpp>
namespace hana = boost::hana;
int main() {
    constexpr auto x = hana::make<hana::optional_tag>();
    BOOST_HANA_CONSTANT_CHECK(x == hana::make_optional());
    BOOST_HANA_CONSTANT_CHECK(hana::is_nothing(x));
    constexpr auto just_x = hana::make<hana::optional_tag>('x');
    static_assert(just_x == hana::make_optional('x'), "");
    BOOST_HANA_CONSTANT_CHECK(hana::is_just(just_x));
}

template<typename... T>

constexpr auto just

Initial value:

= [](auto&& x) {
        return optional<std::decay<decltype(x)>::type>{forwarded(x)};
    }

Создать необязательное значение, содержащее<x>.

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/optional.hpp>
namespace hana = boost::hana;
constexpr auto just_x = hana::just('x');
BOOST_HANA_CONSTANT_CHECK(hana::is_just(just_x));
int main() { }

template<typename... T>

constexpr optional 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/optional.hpp>
namespace hana = boost::hana;
constexpr auto x = hana::nothing;
BOOST_HANA_CONSTANT_CHECK(hana::is_nothing(x));
int main() { }

template<typename... T>

constexpr auto maybe

Initial value:

= [](auto&& default_, auto&& f, auto&& m) -> decltype(auto) {
        if (m is a just(x)) {
            return forwarded(f)(forwarded(x));
        else
            return forwarded(default_);
        }
    }

Применить функцию к содержимому опционального, с обратным результатом.

В частности,<maybe>принимает значение по умолчанию, функцию и необязательное значение. Если необязательное значение<nothing>, то значение по умолчанию возвращается. В противном случае функция применяется к содержанию<just>.

Parameters

default_	Возвращается значение по умолчанию, если<`m`><`nothing`>.
f	Функция, называемая<`f(x)`>тогда и только тогда, когда<`m`>является необязательным значением формы<`just(x)`>. В этом случае результат возврата<`maybe`>является результатом<`f`>.
m	Факультативная стоимость.

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/functional/placeholder.hpp>
#include <boost/hana/optional.hpp>
namespace hana = boost::hana;
static_assert(hana::maybe('x', hana::_ + 1, hana::just(1)) == 2, "");
static_assert(hana::maybe('x', hana::_ + 1, hana::nothing) == 'x', "");
int main() { }

template<typename... T>

auto sfinae

Initial value:

= [](auto&& f) {
        return [perfect-capture](auto&& ...x) {
            if (decltype(forwarded(f)(forwarded(x)...)) is well-formed)
                return just(forwarded(f)(forwarded(x)...));
            else
                return nothing;
        };
    }

Вызывает функцию, если выражение вызова хорошо сформировано.

При наличии функции<f><sfinae>возвращает новую функцию, применяющую<f>к ее аргументам, и возвращает<just>результат, если вызов хорошо сформирован, и<nothing>в противном случае. Иными словами,<sfinae(f)(x...)>является<just(f(x...))>, если это выражение хорошо сформировано, и<nothing>в противном случае. Обратите внимание, однако, что выражение<f(x...)>может быть хорошо сформировано в отношении SFINAE, но попытка фактически составить<f(x...)>по-прежнему терпит неудачу. В этом случае<sfinae>не сможет обнаружить его, и, вероятно, произойдет тяжелый сбой.

Note: The function given to sfinae must not return void, since just(void) does not make sense. A compilation error is triggered if the function returns void.

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/equal.hpp>
#include <boost/hana/optional.hpp>
namespace hana = boost::hana;
int main() {
    BOOST_HANA_CONSTEXPR_LAMBDA auto incr = [](auto x) -> decltype(x + 1) {
        return x + 1;
    };
    BOOST_HANA_CONSTEXPR_CHECK(hana::sfinae(incr)(1) == hana::just(2));
    struct invalid { };
    BOOST_HANA_CONSTANT_CHECK(hana::sfinae(incr)(invalid{}) == hana::nothing);
}

template<typename... T>

constexpr auto is_just

Initial value:

= [](auto const& m) {
        return m is a just(x);
    }

Возврат, если<optional>содержит значение.

В частности, возвращает время компиляции истинно оцененным<Logical>, если<m>имеет форму<just(x)>для некоторых<x>, и ложно оцененным иначе.

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/not.hpp>
#include <boost/hana/optional.hpp>
namespace hana = boost::hana;
BOOST_HANA_CONSTANT_CHECK( hana::is_just(hana::just('x')));
BOOST_HANA_CONSTANT_CHECK( hana::is_just(hana::just(hana::nothing)));
BOOST_HANA_CONSTANT_CHECK(!hana::is_just(hana::nothing));
int main() { }

template<typename... T>

constexpr auto is_nothing

Initial value:

= [](auto const& m) {
        return m is a nothing;
    }

Возвращайся, если<optional>пуст.

В частности, возвращает время компиляции истинно оцененным<Logical>, если<m>является<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/not.hpp>
#include <boost/hana/optional.hpp>
namespace hana = boost::hana;
BOOST_HANA_CONSTANT_CHECK( hana::is_nothing(hana::nothing));
BOOST_HANA_CONSTANT_CHECK(!hana::is_nothing(hana::just('x')));
BOOST_HANA_CONSTANT_CHECK(!hana::is_nothing(hana::just(hana::nothing)));
int main() { }

Member Function Documentation

template<typename... T>

constexpr T* boost::hana::optional< T >::operator-> ( )

Возвращает указатель к содержащемуся значению или<nullptr>, если<optional>пуст.

Note: Overloads of this method are provided for both the const and the non-const cases.

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/optional.hpp>
#include <boost/hana/type.hpp>
#include <string>
namespace hana = boost::hana;
int main() {
    static_assert(hana::just('x').value() == 'x', "");
    BOOST_HANA_CONSTANT_CHECK(*hana::just(hana::type_c<int>) == hana::type_c<int>);
    BOOST_HANA_RUNTIME_CHECK(hana::just(std::string{"abcd"})->size() == 4);
    // hana::nothing.value(); // compile-time error
}

template<typename... T>

constexpr T& boost::hana::optional< T >::value ( )

Извлеките содержимое<optional>или провалитесь во время компиляции.

Если<*this>содержит значение, то это значение возвращается. В противном случае возникает статическое утверждение.

Note: Overloads of this method are provided for the cases where *this is a reference, a rvalue-reference and their const counterparts.

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/optional.hpp>
#include <boost/hana/type.hpp>
#include <string>
namespace hana = boost::hana;
int main() {
    static_assert(hana::just('x').value() == 'x', "");
    BOOST_HANA_CONSTANT_CHECK(*hana::just(hana::type_c<int>) == hana::type_c<int>);
    BOOST_HANA_RUNTIME_CHECK(hana::just(std::string{"abcd"})->size() == 4);
    // hana::nothing.value(); // compile-time error
}

template<typename... T>

constexpr T& boost::hana::optional< T >::operator* ( )

<value()>Для удобства.

Note: Overloads of this method are provided for the cases where *this is a reference, a rvalue-reference and their const counterparts.

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/optional.hpp>
#include <boost/hana/type.hpp>
#include <string>
namespace hana = boost::hana;
int main() {
    static_assert(hana::just('x').value() == 'x', "");
    BOOST_HANA_CONSTANT_CHECK(*hana::just(hana::type_c<int>) == hana::type_c<int>);
    BOOST_HANA_RUNTIME_CHECK(hana::just(std::string{"abcd"})->size() == 4);
    // hana::nothing.value(); // compile-time error
}

template<typename... T>

template<typename U >

decltype(auto) constexpr boost::hana::optional< T >::value_or ( U && default_ )

Возвратить содержимое<optional>с обратным результатом.

Если<*this>содержит значение, то это значение возвращается. В противном случае предоставленное значение по умолчанию возвращается.

Note: Overloads of this method are provided for the cases where *this is a reference, a rvalue-reference and their const counterparts.

Parameters

default_ По умолчанию значение возвращается, если<*this>не содержит значения.

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/optional.hpp>
namespace hana = boost::hana;
static_assert(hana::just(1).value_or('x') == 1, "");
static_assert(hana::nothing.value_or('x') == 'x', "");
int main() { }

Статья Boost.Hana: boost::hana::optional< T > Struct Template Reference раздела может быть полезна для разработчиков на c++ и boost.

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

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

Время компиляции файла: 2024-08-30 11:47:00
2025-05-20 13:34:14/0.031240940093994/1

Boost.Hana: boost::hana::optional< T > Struct Template Reference

Boost , ,

Interoperation with types

Modeled concepts

Synopsis of associated functions

Friends

Public Member Functions

Associated functions

Example

Example

Example

Example

Example

Example

Example

Example

Member Function Documentation

Example

Example

Example

Example

Interoperation with `type`s