Classes
class	eagine::optional_reference_wrapper< T >
	Optional reference to an instance of type `T`. More...

struct	eagine::always_valid_policy
	Policy for always valid values. More...

class	eagine::basic_valid_if_value< T >
	Base class for basic_valid_if, storing the conditionally valid value. More...

class	eagine::basic_valid_if< T, Policy, DoLog, P >
	Basic template for conditionally-valid values. More...

struct	eagine::valid_if_btwn_policy< T, C, Min, Max >
	Policy for values valid if between Min and Max. More...

struct	eagine::valid_flag_policy
	Policy for optionally valid values, indicated by a boolean flag. More...

class	eagine::valid_if< T, Policy, DoLog >
	Primary template for conditionally valid values. More...

struct	eagine::valid_if_ge0_le1_policy< T >
	Policy for values valid if between zero and one. More...

struct	eagine::valid_if_ge0_lt1_policy< T >
	Policy for values valid if greate or equal to zero, less than one. More...

struct	eagine::valid_if_in_list_policy< T, Range >
	Policy for values valid if contained in object of Range type. More...

struct	eagine::valid_if_indicated_policy< Indicator, Comparable, Value >
	Policy for values valid when non-boolean Indicator has Value. More...

struct	eagine::valid_if_le_size_ge0_policy< T, C >
	Policy for values valid if >= 0 and <= container.size(). More...

struct	eagine::valid_if_lt_policy< T, Cmp >
	Policy class for values valid if less than Cmp. More...

struct	eagine::valid_if_lt_size_policy< T, C >
	Policy class for values valid if less than container.size(). More...

struct	eagine::valid_if_lt_size_ge0_policy< T, C >
	Policy for values valid if >= 0 and < container.size(). More...

struct	eagine::never_valid_policy
	Policy for never-valid values. More...

struct	eagine::valid_if_nonneg_policy< T >
	Policy class for values valid when they are non-negative. More...

struct	eagine::valid_if_not_empty_policy< T >
	Policy class for containers valid if their empty() member function return false. More...

struct	eagine::valid_if_ne_policy< T, Cmp >
	Policy class for values valid if not equal to Cmp. More...

struct	eagine::valid_if_nz_policy< T >
	Policy class for values valid if not equal to zero. More...

struct	eagine::valid_if_positive_policy< T >
	Policy class for values valid when they are positive. More...

struct	eagine::valid_if_size_gt_policy< C, T >
	Policy class for containers valid if their size is larger than specified number. More...

struct	eagine::valid_if_within_limits_policy< Dst, Src >
	Policy class for values valid if they are withing limits of other type. More...

Typedefs
template<typename T >
using	eagine::always_valid = valid_if< T, always_valid_policy >
	Specialization of valid_if, for always valid values. More...

template<typename T , typename C , C Min, C Max>
using	eagine::valid_if_between_c = valid_if< T, valid_if_btwn_policy< T, C, Min, Max > >
	Specialization of valid_if, for values valid if between Min and Max.

template<typename T , T Min, T Max>
using	eagine::valid_if_between = valid_if_between_c< T, T, Min, Max >
	Specialization of valid_if, for values valid if between Min and Max. More...

template<typename T >
using	eagine::optionally_valid = valid_if< T, valid_flag_policy >
	Specialization of valid_if with flag indicating validity. More...

template<typename T >
using	eagine::valid_if_between_0_1 = valid_if< T, valid_if_ge0_le1_policy< T > >
	Specialization of valid_if, for values valid if 0 <= value <= 1. More...

template<typename T >
using	eagine::valid_if_ge0_lt1 = valid_if< T, valid_if_ge0_lt1_policy< T > >
	Specialization of valid_if, for values valid if 0 <= value < 1. More...

template<typename T , typename Range >
using	eagine::valid_if_in_list = valid_if< T, valid_if_in_list_policy< T, Range > >
	Specialization of valid_if, for values valid in Range.

template<typename T , typename Indicator , typename Comparable = bool, Comparable Value = true>
using	eagine::valid_if_indicated = valid_if< T, valid_if_indicated_policy< Indicator, Comparable, Value > >
	Specialization of valid_if, for values with non-boolean indicator. More...

template<typename C , typename T >
using	eagine::valid_if_le_size_ge0 = in_class_valid_if< T, C, valid_if_le_size_ge0_policy< T, C > >
	Specialization of valid_if, for values valid if >= 0 and <= container.size(). More...

template<typename T , T Cmp>
using	eagine::valid_if_less_than = valid_if< T, valid_if_lt_policy< T, Cmp > >
	Specialization of valid_if, for values valid if less than Cmp. More...

template<typename C , typename T >
using	eagine::valid_if_lt_size = in_class_valid_if< T, C, valid_if_lt_size_policy< T, C > >
	Policy class for values valid if less than container size. More...

template<typename C , typename T >
using	eagine::valid_if_lt_size_ge0 = in_class_valid_if< T, C, valid_if_lt_size_ge0_policy< T, C > >
	Specialization of valid_if, for values valid if >= 0 and < container.size(). More...

template<typename T >
using	eagine::never_valid = valid_if< T, never_valid_policy >
	Specialization of valid_if, for never-valid values. More...

template<typename T >
using	eagine::valid_if_nonnegative = valid_if< T, valid_if_nonneg_policy< T > >
	Specialization of valid_if, for values valid if non-negative. More...

template<typename T >
using	eagine::valid_if_not_empty = valid_if< T, valid_if_not_empty_policy< T > >
	Specialization of valid_if, for values valid if not empty. More...

template<typename T , T Cmp>
using	eagine::valid_if_not = valid_if< T, valid_if_ne_policy< T, Cmp > >
	Specialization of valid_if, for values valid if not equal to Cmp. More...

template<typename T >
using	eagine::valid_if_not_zero = valid_if< T, valid_if_nz_policy< T > >
	Specialization of valid_if, for values valid if not equal to zero. More...

template<typename T >
using	eagine::nonzero_t = valid_if_not_zero< T >
	Alias for valid_if_not_zero.

template<typename T >
using	eagine::valid_if_positive = valid_if< T, valid_if_positive_policy< T > >
	Specialization of valid_if, for values valid if positive. More...

template<typename C , typename T >
using	eagine::valid_if_size_gt = in_class_valid_if< C, T, valid_if_size_gt_policy< C, T > >
	Specialization of valid_if, for values valid if they contain more than n items. More...

template<typename Dst , typename Src >
using	eagine::valid_if_within_limits = valid_if< Src, valid_if_within_limits_policy< Dst, Src > >
	Specialization of valid_if, for values valid if within limits of Dst type. More...

Functions
template<typename T >
static auto	eagine::extract (optional_reference_wrapper< T > ref) noexcept -> T &
	Overload of extract for optional_reference_wrapper.

template<typename T >
static auto	eagine::extract_or (optional_reference_wrapper< T > ref, T &fallback) noexcept -> T &
	Overload of extract_or for optional_reference_wrapper.

template<typename T , typename F >
static auto	eagine::extract_or (optional_reference_wrapper< T > ref, F &&fallback) -> std::enable_if_t< std::is_convertible_v< F, T >, T >
	Overload of extract_or for optional_reference_wrapper.

template<typename T , typename P1 , typename P2 >
static constexpr auto	eagine::operator== (const valid_if< T, P1 > &v1, const valid_if< T, P2 > &v2) noexcept -> tribool
	Equality comparison of two conditionally valid values.

template<typename T , typename P1 , typename P2 >
static constexpr auto	eagine::operator!= (const valid_if< T, P1 > &v1, const valid_if< T, P2 > &v2) noexcept -> tribool
	Non-equality comparison of two conditionally valid values.

template<typename T , typename P1 , typename P2 >
static constexpr auto	eagine::operator< (const valid_if< T, P1 > &v1, const valid_if< T, P2 > &v2) noexcept -> tribool
	Less-than comparison of two conditionally valid values.

template<typename T , typename P1 , typename P2 >
static constexpr auto	eagine::operator> (const valid_if< T, P1 > &v1, const valid_if< T, P2 > &v2) noexcept -> tribool
	Greater-than comparison of two conditionally valid values.

template<typename T , typename P1 , typename P2 >
static constexpr auto	eagine::operator<= (const valid_if< T, P1 > &v1, const valid_if< T, P2 > &v2) noexcept -> tribool
	Less-equal comparison of two conditionally valid values.

template<typename T , typename P1 , typename P2 >
static constexpr auto	eagine::operator>= (const valid_if< T, P1 > &v1, const valid_if< T, P2 > &v2) noexcept -> tribool
	Greater-equal comparison of two conditionally valid values.

template<typename T , typename P , typename F >
static auto	eagine::either_or (valid_if< T, P > vi, F f) noexcept(noexcept(valid_if< T, P >(std::declval< valid_if< T, P > && >())) &&noexcept(F(std::declval< F && >()))) -> valid_if_or_fallback< T, P, F >
	Constructor function for valid_if_or_fallback.

template<typename T , typename P , typename L >
auto	eagine::operator<< (std::ostream &out, const basic_valid_if< T, P, L > &v) -> auto &
	Operator for writing values of basic_valid_if to output streams.