use optional return types for fallible methods

[redraincatching]

closes #119 by implementing p3981, using beman.optional as specified in the issue.

[github-actions]

Remaining comments which cannot be posted as a review comment to avoid GitHub Rate Limit

pre-commit

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Line 76 in 3108e69

return Pointer(std::forward<T>(value));

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 79 to 81 in 3108e69

	template <typename Pointer, typename IteratorConcept>
	struct pointer {
	using type = Pointer;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 83 to 85 in 3108e69

	template <typename Pointer>
	struct pointer<Pointer, std::output_iterator_tag> {
	using type = void;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Line 92 in 3108e69

std::integral_constant<bool, (std::is_convertible<T, U>::value || std::is_convertible<U, T>::value)>;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Line 98 in 3108e69

using use_base = decltype(access::base(std::declval<T&>()));

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 100 to 101 in 3108e69

	template <typename... T>
	using void_t = void;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Line 103 in 3108e69

template <typename AlwaysVoid, template <class...> class Template, typename... Args>

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Line 107 in 3108e69

struct detector<void_t<Template<Args...>>, Template, Args...> : std::true_type {};

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Line 109 in 3108e69

template <typename T, typename U, bool UseBase = detector<void, use_base, T>::value>

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 111 to 113 in 3108e69

	static constexpr auto call(T lhs, U rhs) {
	return static_cast<common_t<T, U>>(lhs).derived() == static_cast<common_t<T, U>>(rhs).derived();
	}

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 115 to 117 in 3108e69

	template <typename T, typename U>
	struct common_eq<T, U, true> {
	static constexpr auto call(T lhs, U rhs) { return access::base(lhs) == access::base(rhs); }

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 122 to 124 in 3108e69

	common_diff(T lhs, U rhs) noexcept(noexcept(static_cast<common_t<T, U>>(lhs) - static_cast<common_t<T, U>>(rhs)))
	-> decltype(static_cast<common_t<T, U>>(lhs) - static_cast<common_t<T, U>>(rhs)) {
	return static_cast<common_t<T, U>>(lhs) - static_cast<common_t<T, U>>(rhs);

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 135 to 148 in 3108e69

	/** A CRTP template that one may derive from to make defining iterators
	easier.
	The template parameter `D` for `iterator_interface` may be an
	incomplete type. Before any member of the resulting specialization of
	`iterator_interface` other than special member functions is
	referenced, `D` shall be complete, and model
	`std::derived_from<iterator_interface<D>>`. */
	template <typename Derived,
	typename IteratorConcept,
	typename ValueType,
	typename Reference = ValueType&,
	typename Pointer = ValueType*,
	typename DifferenceType = std::ptrdiff_t

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 150 to 152 in 3108e69

	,
	typename E = std::enable_if_t<std::is_class<Derived>::value &&
	std::is_same<Derived, std::remove_cv_t<Derived>>::value>

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 154 to 188 in 3108e69

	>
	struct iterator_interface;
	namespace v1_dtl {
	template <typename Iterator, typename = void>
	struct ra_iter : std::false_type {};
	template <typename Iterator>
	struct ra_iter<Iterator, void_t<typename Iterator::iterator_concept>>
	: std::integral_constant<
	bool,
	std::is_base_of<std::random_access_iterator_tag, typename Iterator::iterator_concept>::value> {};
	template <typename Iterator, typename DifferenceType, typename = void>
	struct plus_eq : std::false_type {};
	template <typename Iterator, typename DifferenceType>
	struct plus_eq<Iterator,
	DifferenceType,
	void_t<decltype(std::declval<Iterator&>() += std::declval<DifferenceType>())>> : std::true_type {};
	template <typename D,
	typename IteratorConcept,
	typename ValueType,
	typename Reference,
	typename Pointer,
	typename DifferenceType>
	void
	derived_iterator(const iterator_interface<D, IteratorConcept, ValueType, Reference, Pointer, DifferenceType>&);
	} // namespace v1_dtl
	template <typename Derived,
	typename IteratorConcept,
	typename ValueType,
	typename Reference,
	typename Pointer,
	typename DifferenceType

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 190 to 191 in 3108e69

	,
	typename E

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 193 to 194 in 3108e69

	>
	struct iterator_interface {

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 196 to 198 in 3108e69

	private:
	constexpr Derived& derived() noexcept { return static_cast<Derived&>(*this); }
	constexpr const Derived& derived() const noexcept { return static_cast<const Derived&>(*this); }

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 200 to 201 in 3108e69

	template <typename T, typename U, bool UseBase>
	friend struct detail::common_eq;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 204 to 307 in 3108e69

	public:
	using iterator_concept = IteratorConcept;
	using iterator_category = iterator_concept;
	using value_type = std::remove_const_t<ValueType>;
	using reference = Reference;
	using pointer = detail::pointer_t<Pointer, iterator_concept>;
	using difference_type = DifferenceType;
	template <typename D = Derived>
	constexpr auto operator*() noexcept(noexcept(*access::base(std::declval<D&>())))
	-> decltype(*access::base(std::declval<D&>())) {
	return *access::base(derived());
	}
	template <typename D = Derived>
	constexpr auto operator*() const noexcept(noexcept(*access::base(std::declval<const D&>())))
	-> decltype(*access::base(std::declval<const D&>())) {
	return *access::base(derived());
	}
	template <typename D = Derived>
	constexpr auto operator->() noexcept(noexcept(detail::make_pointer<pointer, reference>(*std::declval<D&>())))
	-> decltype(detail::make_pointer<pointer, reference>(*std::declval<D&>())) {
	return detail::make_pointer<pointer, reference>(*derived());
	}
	template <typename D = Derived>
	constexpr auto operator->() const
	noexcept(noexcept(detail::make_pointer<pointer, reference>(*std::declval<const D&>())))
	-> decltype(detail::make_pointer<pointer, reference>(*std::declval<const D&>())) {
	return detail::make_pointer<pointer, reference>(*derived());
	}
	template <typename D = Derived>
	constexpr auto operator[](difference_type i) const
	noexcept(noexcept(D(std::declval<const D&>()), std::declval<D&>() += i, *std::declval<D&>()))
	-> decltype(std::declval<D&>() += i, *std::declval<D&>()) {
	D retval = derived();
	retval += i;
	return *retval;
	}
	template <typename D = Derived,
	typename Enable = std::enable_if_t<!v1_dtl::plus_eq<D, difference_type>::value>>
	constexpr auto operator++() noexcept(noexcept(++access::base(std::declval<D&>())))
	-> decltype(++access::base(std::declval<D&>()), std::declval<D&>()) {
	++access::base(derived());
	return derived();
	}
	template <typename D = Derived>
	constexpr auto operator++() noexcept(noexcept(std::declval<D&>() += difference_type(1)))
	-> decltype(std::declval<D&>() += difference_type(1), std::declval<D&>()) {
	derived() += difference_type(1);
	return derived();
	}
	template <typename D = Derived>
	constexpr auto operator++(int) noexcept(noexcept(D(std::declval<D&>()), ++std::declval<D&>()))
	-> std::remove_reference_t<decltype(D(std::declval<D&>()), ++std::declval<D&>(), std::declval<D&>())> {
	D retval = derived();
	++derived();
	return retval;
	}
	template <typename D = Derived>
	constexpr auto operator+=(difference_type n) noexcept(noexcept(access::base(std::declval<D&>()) += n))
	-> decltype(access::base(std::declval<D&>()) += n, std::declval<D&>()) {
	access::base(derived()) += n;
	return derived();
	}
	template <typename D = Derived>
	constexpr auto operator+(difference_type i) const noexcept(noexcept(D(std::declval<D&>()),
	std::declval<D&>() += i))
	-> std::remove_reference_t<decltype(D(std::declval<D&>()), std::declval<D&>() += i, std::declval<D&>())> {
	D retval = derived();
	retval += i;
	return retval;
	}
	friend BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_HIDDEN_FRIEND_CONSTEXPR Derived operator+(difference_type i,
	Derived it) noexcept {
	return it + i;
	}
	template <typename D = Derived,
	typename Enable = std::enable_if_t<!v1_dtl::plus_eq<D, difference_type>::value>>
	constexpr auto operator--() noexcept(noexcept(--access::base(std::declval<D&>())))
	-> decltype(--access::base(std::declval<D&>()), std::declval<D&>()) {
	--access::base(derived());
	return derived();
	}
	template <typename D = Derived>
	constexpr auto operator--() noexcept(noexcept(D(std::declval<D&>()),
	std::declval<D&>() += -difference_type(1)))
	-> decltype(std::declval<D&>() += -difference_type(1), std::declval<D&>()) {
	derived() += -difference_type(1);
	return derived();
	}
	template <typename D = Derived>
	constexpr auto operator--(int) noexcept(noexcept(D(std::declval<D&>()), --std::declval<D&>()))
	-> std::remove_reference_t<decltype(D(std::declval<D&>()), --std::declval<D&>(), std::declval<D&>())> {
	D retval = derived();
	--derived();
	return retval;
	}

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 309 to 313 in 3108e69

	template <typename D = Derived>
	constexpr D& operator-=(difference_type i) noexcept {
	derived() += -i;
	return derived();
	}

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 315 to 320 in 3108e69

	template <typename D = Derived>
	constexpr auto operator-(D other) const
	noexcept(noexcept(access::base(std::declval<const D&>()) - access::base(other)))
	-> decltype(access::base(std::declval<const D&>()) - access::base(other)) {
	return access::base(derived()) - access::base(other);
	}

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 322 to 328 in 3108e69

	friend BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_HIDDEN_FRIEND_CONSTEXPR Derived
	operator-(Derived it, difference_type i) noexcept {
	Derived retval = it;
	retval += -i;
	return retval;
	}
	};

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 330 to 340 in 3108e69

	/** Implementation of `operator==()`, implemented in terms of the iterator
	underlying IteratorInterface, for all iterators derived from
	`iterator_interface`, except those with an iterator category derived
	from `std::random_access_iterator_tag`. */
	template <typename IteratorInterface1,
	typename IteratorInterface2,
	typename Enable = std::enable_if_t<!v1_dtl::ra_iter<IteratorInterface1>::value>>
	constexpr auto operator==(IteratorInterface1 lhs, IteratorInterface2 rhs) noexcept
	-> decltype(access::base(std::declval<IteratorInterface1&>()) ==
	access::base(std::declval<IteratorInterface2&>())) {
	return access::base(lhs) == access::base(rhs);

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 343 to 352 in 3108e69

	/** Implementation of `operator==()` for all iterators derived from
	`iterator_interface` that have an iterator category derived from
	`std::random_access_iterator_tag`. */
	template <typename IteratorInterface1,
	typename IteratorInterface2,
	typename Enable = std::enable_if_t<v1_dtl::ra_iter<IteratorInterface1>::value>>
	constexpr auto operator==(IteratorInterface1 lhs,
	IteratorInterface2 rhs) noexcept(noexcept(detail::common_diff(lhs, rhs)))
	->decltype(v1_dtl::derived_iterator(lhs), detail::common_diff(lhs, rhs) == 0) {
	return detail::common_diff(lhs, rhs) == 0;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 355 to 360 in 3108e69

	/** Implementation of `operator!=()` for all iterators derived from
	`iterator_interface`. */
	template <typename IteratorInterface1, typename IteratorInterface2>
	constexpr auto operator!=(IteratorInterface1 lhs, IteratorInterface2 rhs) noexcept(noexcept(!(lhs == rhs)))
	->decltype(v1_dtl::derived_iterator(lhs), !(lhs == rhs)) {
	return !(lhs == rhs);

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 363 to 370 in 3108e69

	/** Implementation of `operator<()` for all iterators derived from
	`iterator_interface` that have an iterator category derived from
	`std::random_access_iterator_tag`. */
	template <typename IteratorInterface1, typename IteratorInterface2>
	constexpr auto operator<(IteratorInterface1 lhs,
	IteratorInterface2 rhs) noexcept(noexcept(detail::common_diff(lhs, rhs)))
	->decltype(v1_dtl::derived_iterator(lhs), detail::common_diff(lhs, rhs) < 0) {
	return detail::common_diff(lhs, rhs) < 0;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 373 to 380 in 3108e69

	/** Implementation of `operator<=()` for all iterators derived from
	`iterator_interface` that have an iterator category derived from
	`std::random_access_iterator_tag`. */
	template <typename IteratorInterface1, typename IteratorInterface2>
	constexpr auto operator<=(IteratorInterface1 lhs,
	IteratorInterface2 rhs) noexcept(noexcept(detail::common_diff(lhs, rhs)))
	->decltype(v1_dtl::derived_iterator(lhs), detail::common_diff(lhs, rhs) <= 0) {
	return detail::common_diff(lhs, rhs) <= 0;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 383 to 390 in 3108e69

	/** Implementation of `operator>()` for all iterators derived from
	`iterator_interface` that have an iterator category derived from
	`std::random_access_iterator_tag`. */
	template <typename IteratorInterface1, typename IteratorInterface2>
	constexpr auto operator>(IteratorInterface1 lhs,
	IteratorInterface2 rhs) noexcept(noexcept(detail::common_diff(lhs, rhs)))
	->decltype(v1_dtl::derived_iterator(lhs), detail::common_diff(lhs, rhs) > 0) {
	return detail::common_diff(lhs, rhs) > 0;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 393 to 400 in 3108e69

	/** Implementation of `operator>=()` for all iterators derived from
	`iterator_interface` that have an iterator category derived from
	`std::random_access_iterator_tag`. */
	template <typename IteratorInterface1, typename IteratorInterface2>
	constexpr auto operator>=(IteratorInterface1 lhs,
	IteratorInterface2 rhs) noexcept(noexcept(detail::common_diff(lhs, rhs)))
	->decltype(v1_dtl::derived_iterator(lhs), detail::common_diff(lhs, rhs) >= 0) {
	return detail::common_diff(lhs, rhs) >= 0;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 403 to 415 in 3108e69

	/** A template alias useful for defining proxy iterators. \see
	`iterator_interface`. */
	template <typename Derived,
	typename IteratorConcept,
	typename ValueType,
	typename Reference = ValueType,
	typename DifferenceType = std::ptrdiff_t>
	using proxy_iterator_interface = iterator_interface<Derived,
	IteratorConcept,
	ValueType,
	Reference,
	proxy_arrow_result<Reference>,
	DifferenceType>;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Line 420 in 3108e69

#if defined(BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_DOXYGEN) || BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_USE_CONCEPTS

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 426 to 456 in 3108e69

	namespace v2_dtl {
	template <typename Iterator>
	struct iter_concept;
	template <typename Iterator>
	requires requires { typename std::iterator_traits<Iterator>::iterator_concept; }
	struct iter_concept<Iterator> {
	using type = typename std::iterator_traits<Iterator>::iterator_concept;
	};
	template <typename Iterator>
	requires (
	!requires { typename std::iterator_traits<Iterator>::iterator_concept; } &&
	requires { typename std::iterator_traits<Iterator>::iterator_category; })
	struct iter_concept<Iterator> {
	using type = typename std::iterator_traits<Iterator>::iterator_category;
	};
	template <typename Iterator>
	requires (
	!requires { typename std::iterator_traits<Iterator>::iterator_concept; } &&
	!requires { typename std::iterator_traits<Iterator>::iterator_category; })
	struct iter_concept<Iterator> {
	using type = std::random_access_iterator_tag;
	};
	template <typename Iterator>
	struct iter_concept {};
	template <typename Iterator>
	using iter_concept_t = typename iter_concept<Iterator>::type;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 458 to 459 in 3108e69

	template <typename D, typename DifferenceType>
	// clang-format off

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Line 461 in 3108e69

// clang-format on

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 463 to 464 in 3108e69

	template <typename D, typename D2 = D>
	// clang-format off

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Line 471 in 3108e69

// clang-format on

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 473 to 474 in 3108e69

	template <typename D1, typename D2 = D1>
	// clang-format off

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Line 477 in 3108e69

// clang-format on

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 479 to 480 in 3108e69

	template <typename D, typename D2 = D>
	// clang-format off

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 485 to 522 in 3108e69

	// clang-format on
	// This iterator concept -> category mapping scheme follows the one
	// from zip_transform_view; see
	// https://eel.is/c++draft/range.zip.transform.iterator#1.
	template <typename IteratorConcept, typename ReferenceType>
	constexpr auto category_tag() {
	if constexpr (std::is_base_of_v<std::forward_iterator_tag, IteratorConcept>) {
	if constexpr (!std::is_reference_v<ReferenceType>) {
	return std::input_iterator_tag{};
	} else if constexpr (std::is_base_of_v<std::random_access_iterator_tag, IteratorConcept>) {
	return std::random_access_iterator_tag{};
	} else if constexpr (std::is_base_of_v<std::bidirectional_iterator_tag, IteratorConcept>) {
	return std::bidirectional_iterator_tag{};
	} else {
	return std::forward_iterator_tag{};
	}
	} else {
	return 0; // int means "no tag"
	}
	}
	template <typename IteratorConcept,
	typename ReferenceType,
	typename IteratorCategory = decltype(v2_dtl::category_tag<IteratorConcept, ReferenceType>())>
	struct iterator_category_base {
	using iterator_category = IteratorCategory;
	};
	template <typename IteratorConcept, typename ReferenceType>
	struct iterator_category_base<IteratorConcept, ReferenceType, int> {};
	template <typename IteratorConcept, typename ReferenceType>
	constexpr bool non_input_tag() {
	if (std::same_as<IteratorConcept, std::input_iterator_tag>)
	return false;
	using tag_t = decltype(v2_dtl::category_tag<IteratorConcept, ReferenceType>());
	return !std::same_as<tag_t, std::input_iterator_tag>;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 524 to 526 in 3108e69

	} // namespace v2_dtl
	// clang-format off

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 724 to 738 in 3108e69

	// clang-format on
	/** A template alias useful for defining proxy iterators. \see
	`iterator_interface`. */
	template <typename Derived,
	typename IteratorConcept,
	typename ValueType,
	typename Reference = ValueType,
	typename DifferenceType = std::ptrdiff_t>
	using proxy_iterator_interface = iterator_interface<Derived,
	IteratorConcept,
	ValueType,
	Reference,
	proxy_arrow_result<Reference>,
	DifferenceType>;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Line 745 in 3108e69

#if defined(BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_DOXYGEN) || BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_USE_DEDUCED_THIS

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Line 751 in 3108e69

// clang-format off

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Line 918 in 3108e69

// clang-format on

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 920 to 927 in 3108e69

	/** A template alias useful for defining proxy iterators. \see
	`iterator_interface`. */
	template <typename IteratorConcept,
	typename ValueType,
	typename Reference = ValueType,
	typename DifferenceType = std::ptrdiff_t>
	using proxy_iterator_interface =
	iterator_interface<IteratorConcept, ValueType, Reference, proxy_arrow_result<Reference>, DifferenceType>;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Line 940 in 3108e69

For example: `BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_STATIC_ASSERT_CONCEPT(my_iter,

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Line 945 in 3108e69

#define BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_STATIC_ASSERT_CONCEPT(type, concept_name)

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 952 to 953 in 3108e69

	For example: `BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_STATIC_ASSERT_ITERATOR_TRAITS(my_iter,
	std::input_iterator_tag, std::input_iterator, int, int &, int *, std::ptrdiff_t)`.

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Line 957 in 3108e69

#define BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_STATIC_ASSERT_ITERATOR_TRAITS( \

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 962 to 963 in 3108e69

	#define BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_STATIC_ASSERT_ITERATOR_CONCEPT_IMPL(type, concept_name) \
	static_assert(concept_name<type>, "");

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 966 to 967 in 3108e69

	#define BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_STATIC_ASSERT_CONCEPT(iter, concept_name) \
	BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_STATIC_ASSERT_ITERATOR_CONCEPT_IMPL(iter, concept_name)

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Line 969 in 3108e69

#define BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_STATIC_ASSERT_CONCEPT(iter, concept_name)

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/detail/stl_interfaces/iterator_interface.hpp

Lines 972 to 982 in 3108e69

	#define BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_STATIC_ASSERT_ITERATOR_TRAITS_IMPL( \
	iter, category, value_t, ref, ptr, diff_t) \
	static_assert(std::is_same<typename std::iterator_traits<iter>::value_type, value_t>::value, ""); \
	static_assert(std::is_same<typename std::iterator_traits<iter>::reference, ref>::value, ""); \
	static_assert(std::is_same<typename std::iterator_traits<iter>::pointer, ptr>::value, ""); \
	static_assert(std::is_same<typename std::iterator_traits<iter>::difference_type, diff_t>::value, "");
	#define BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_STATIC_ASSERT_ITERATOR_TRAITS( \
	iter, category, concept, value_type, reference, pointer, difference_type) \
	BEMAN_OPTIONAL_DETAIL_STL_INTERFACES_STATIC_ASSERT_ITERATOR_TRAITS_IMPL( \
	iter, category, value_type, reference, pointer, difference_type)

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 7 in 3108e69

#include <version>

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 10 in 3108e69

#if defined(__cpp_lib_format_ranges)

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 24 to 25 in 3108e69

	concept optional_eq_rel = requires(const T& t, const U& u) {
	{ t == u } -> std::convertible_to<bool>;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 29 to 30 in 3108e69

	concept optional_ne_rel = requires(const T& t, const U& u) {
	{ t != u } -> std::convertible_to<bool>;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 34 to 35 in 3108e69

	concept optional_lt_rel = requires(const T& t, const U& u) {
	{ t < u } -> std::convertible_to<bool>;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 39 to 40 in 3108e69

	concept optional_gt_rel = requires(const T& t, const U& u) {
	{ t > u } -> std::convertible_to<bool>;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 44 to 45 in 3108e69

	concept optional_le_rel = requires(const T& t, const U& u) {
	{ t <= u } -> std::convertible_to<bool>;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 49 to 50 in 3108e69

	concept optional_ge_rel = requires(const T& t, const U& u) {
	{ t >= u } -> std::convertible_to<bool>;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 54 in 3108e69

explicit from_function_t() = default;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 65 in 3108e69

explicit in_place_t() = default;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 76 to 77 in 3108e69

	template <class T>
	class optional; // partially freestanding

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 82 in 3108e69

inline constexpr bool std::ranges::enable_view<beman::optional::optional<T>> = true;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 86 in 3108e69

inline constexpr bool std::ranges::enable_borrowed_range<beman::optional::optional<T&>> = true;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 91 in 3108e69

inline constexpr auto std::format_kind<beman::optional::optional<T>> = range_format::disabled;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 96 to 99 in 3108e69

	template <typename T>
	inline constexpr bool is_optional = false;
	template <typename T>
	inline constexpr bool is_optional<optional<T>> = true;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 105 to 106 in 3108e69

	concept is_derived_from_optional = requires(const T& t) { // exposition only
	[]<class U>(const optional<U>&) {}(t);

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 114 to 131 in 3108e69

	/** @enum Tag
	* @brief Tag enum for nullopt_t construction
	*/
	enum class Tag { tag /**< the tag value for nullopt_t::Tag */ };
	/**
	* @brief Construct a new nullopt_t object
	* @arg Tag
	* @details constexpr for nullopt_t to be literal.
	*/
	explicit constexpr nullopt_t(Tag) noexcept {}
	private:
	friend constexpr bool operator==(nullopt_t, nullopt_t) noexcept { return true; }
	friend constexpr std::strong_ordering operator<=>(nullopt_t, nullopt_t) noexcept {
	return std::strong_ordering::equivalent;
	}

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 142 to 143 in 3108e69

	constexpr bool operator==(const optional<T>& lhs, const optional<U>& rhs)
	requires detail::optional_eq_rel<T, U>;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 145 to 146 in 3108e69

	constexpr bool operator!=(const optional<T>& lhs, const optional<U>& rhs)
	requires detail::optional_ne_rel<T, U>;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 148 to 149 in 3108e69

	constexpr bool operator<(const optional<T>& lhs, const optional<U>& rhs)
	requires detail::optional_lt_rel<T, U>;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 151 to 152 in 3108e69

	constexpr bool operator>(const optional<T>& lhs, const optional<U>& rhs)
	requires detail::optional_gt_rel<T, U>;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 154 to 155 in 3108e69

	constexpr bool operator<=(const optional<T>& lhs, const optional<U>& rhs)
	requires detail::optional_le_rel<T, U>;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 157 to 158 in 3108e69

	constexpr bool operator>=(const optional<T>& lhs, const optional<U>& rhs)
	requires detail::optional_ge_rel<T, U>;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 160 in 3108e69

constexpr std::compare_three_way_result_t<T, U> operator<=>(const optional<T>&, const optional<U>&);

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 164 in 3108e69

constexpr bool operator==(const optional<T>&, nullopt_t) noexcept;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 166 in 3108e69

constexpr std::strong_ordering operator<=>(const optional<T>&, nullopt_t) noexcept;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 170 to 171 in 3108e69

	constexpr bool operator==(const optional<T>& lhs, const U& rhs)
	requires (!detail::is_optional<U>) && detail::optional_eq_rel<T, U>;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 174 to 175 in 3108e69

	constexpr bool operator==(const T& lhs, const optional<U>& rhs)
	requires (!detail::is_optional<T>) && detail::optional_eq_rel<T, U>;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 178 to 179 in 3108e69

	constexpr bool operator!=(const optional<T>& lhs, const U& rhs)
	requires (!detail::is_optional<U>) && detail::optional_ne_rel<T, U>;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 182 to 183 in 3108e69

	constexpr bool operator!=(const T& lhs, const optional<U>& rhs)
	requires (!detail::is_optional<T>) && detail::optional_ne_rel<T, U>;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 186 to 187 in 3108e69

	constexpr bool operator<(const optional<T>& lhs, const U& rhs)
	requires (!detail::is_optional<U>) && detail::optional_lt_rel<T, U>;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 190 to 191 in 3108e69

	constexpr bool operator<(const T& lhs, const optional<U>& rhs)
	requires (!detail::is_optional<T>) && detail::optional_lt_rel<T, U>;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 194 to 195 in 3108e69

	constexpr bool operator>(const optional<T>& lhs, const U& rhs)
	requires (!detail::is_optional<U>) && detail::optional_gt_rel<T, U>;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 198 to 199 in 3108e69

	constexpr bool operator>(const T& lhs, const optional<U>& rhs)
	requires (!detail::is_optional<T>) && detail::optional_gt_rel<T, U>;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 202 to 203 in 3108e69

	constexpr bool operator<=(const optional<T>& lhs, const U& rhs)
	requires (!detail::is_optional<U>) && detail::optional_le_rel<T, U>;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 206 to 207 in 3108e69

	constexpr bool operator<=(const T& lhs, const optional<U>& rhs)
	requires (!detail::is_optional<T>) && detail::optional_le_rel<T, U>;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 210 to 211 in 3108e69

	constexpr bool operator>=(const optional<T>& lhs, const U& rhs)
	requires (!detail::is_optional<U>) && detail::optional_ge_rel<T, U>;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 214 to 215 in 3108e69

	constexpr bool operator>=(const T& lhs, const optional<U>& rhs)
	requires (!detail::is_optional<T>) && detail::optional_ge_rel<T, U>;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 218 to 219 in 3108e69

	requires (!is_derived_from_optional<U>) && std::three_way_comparable_with<T, U>
	constexpr std::compare_three_way_result_t<T, U> operator<=>(const optional<T>& x, const U& v);

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 226 to 227 in 3108e69

	constexpr void swap(optional<T>& x, optional<T>& y) noexcept(noexcept(x.swap(y)))
	requires std::is_move_constructible_v<T> && std::is_swappable_v<T>;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 233 to 235 in 3108e69

	constexpr optional<std::decay_t<T>>
	make_optional(T&&) noexcept(std::is_nothrow_constructible_v<optional<std::decay_t<T>>, T>)
	requires std::is_constructible_v<std::decay_t<T>, T>;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 238 to 239 in 3108e69

	constexpr optional<T> make_optional(Args&&... args) noexcept(std::is_nothrow_constructible_v<T, Args...>)
	requires std::is_constructible_v<T, Args...>;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 243 to 245 in 3108e69

	make_optional(std::initializer_list<U> il,
	Args&&... args) noexcept(std::is_nothrow_constructible_v<T, std::initializer_list<U>&, Args...>)
	requires std::is_constructible_v<T, std::initializer_list<U>&, Args...>;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 259 in 3108e69

!std::is_same_v<std::decay_t<U>, in_place_t> && std::is_constructible_v<T, U&&>;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 262 to 271 in 3108e69

	concept enable_from_other = !std::is_same_v<T, U> && //
	std::is_constructible_v<T, Other> && //
	!std::is_constructible_v<T, optional<U>&> && //
	!std::is_constructible_v<T, optional<U>&&> && //
	!std::is_constructible_v<T, const optional<U>&> && //
	!std::is_constructible_v<T, const optional<U>&&> && //
	!std::is_convertible_v<optional<U>&, T> && //
	!std::is_convertible_v<optional<U>&&, T> && //
	!std::is_convertible_v<const optional<U>&, T> && //
	!std::is_convertible_v<const optional<U>&&, T>;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 274 to 276 in 3108e69

	concept enable_assign_forward = !std::is_same_v<optional<T>, std::decay_t<U>> &&
	!std::conjunction_v<std::is_scalar<T>, std::is_same<T, std::decay_t<U>>> &&
	std::is_constructible_v<T, U> && std::is_assignable_v<T&, U>;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 280 to 286 in 3108e69

	std::is_constructible_v<T, Other> && std::is_assignable_v<T&, Other> &&
	!std::is_constructible_v<T, optional<U>&> && !std::is_constructible_v<T, optional<U>&&> &&
	!std::is_constructible_v<T, const optional<U>&> && !std::is_constructible_v<T, const optional<U>&&> &&
	!std::is_convertible_v<optional<U>&, T> && !std::is_convertible_v<optional<U>&&, T> &&
	!std::is_convertible_v<const optional<U>&, T> && !std::is_convertible_v<const optional<U>&&, T> &&
	!std::is_assignable_v<T&, optional<U>&> && !std::is_assignable_v<T&, optional<U>&&> &&
	!std::is_assignable_v<T&, const optional<U>&> && !std::is_assignable_v<T&, const optional<U>&&>;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 295 to 750 in 3108e69

	template <class T>
	class optional {
	static_assert((!std::is_same_v<T, std::remove_cv_t<in_place_t>>) &&
	(!std::is_same_v<std::remove_cv_t<T>, nullopt_t>));
	static_assert(std::is_object_v<T> && !std::is_array_v<T>);
	public:
	/**
	* @brief Type alias for the value type contained in the optional.
	*
	*/
	using value_type = T;
	/**
	* @brief Type alias for the iterator type of the optional.
	*
	* @details Since P3168R2: Give std::optional Range Support.
	*/
	using iterator = detail::contiguous_iterator<T,
	optional>; // see~\ref{optional.iterators}
	/**
	* @brief Type alias for the const iterator type of the optional.
	*
	* @details Since P3168R2: Give std::optional Range Support.
	*/
	using const_iterator = detail::contiguous_iterator<const T,
	optional>; // see~\ref{optional.iterators}
	// \ref{optional.ctor}, constructors
	/**
	* @brief Default constructs an empty optional.
	*
	*/
	constexpr optional() noexcept;
	/**
	* @brief Constructs an empty optional.
	*
	*/
	constexpr optional(nullopt_t) noexcept;
	/**
	* @brief Copy constructs the value from \p rhs if it has one.
	*
	*/
	constexpr optional(const optional& rhs)
	requires std::is_copy_constructible_v<T> && (!std::is_trivially_copy_constructible_v<T>);
	/**
	* @brief Copy constructs the value from \p rhs if it has one.
	* @details Defaulted if T is trivially copy constructible.
	*/
	constexpr optional(const optional&)
	requires std::is_copy_constructible_v<T> && std::is_trivially_copy_constructible_v<T>
	= default;
	/**
	* @brief Move constructs the value from \p rhs if it has one.
	*/
	constexpr optional(optional&& rhs) noexcept(std::is_nothrow_move_constructible_v<T>)
	requires std::is_move_constructible_v<T> && (!std::is_trivially_move_constructible_v<T>);
	/**
	* @brief Move constructs the value from \p rhs if it has one.
	* @details Defaulted if T is trivially move constructible.
	*/
	constexpr optional(optional&&)
	requires std::is_move_constructible_v<T> && std::is_trivially_move_constructible_v<T>
	= default;
	/**
	* @brief Constructs the value in-place using the given arguments.
	*
	* @param args The arguments to use for in-place construction.
	*/
	template <class... Args>
	constexpr explicit optional(in_place_t, Args&&... args)
	requires std::is_constructible_v<T, Args...>;
	/**
	* @brief Constructs the value in-place using the given arguments.
	*
	* @param il The initializer list to use for in-place construction.
	* @param args The arguments to use for in-place construction.
	*/
	template <class U, class... Args>
	constexpr explicit optional(in_place_t, std::initializer_list<U> il, Args&&... args)
	requires std::is_constructible_v<T, std::initializer_list<U>&, Args&&...>;
	/**
	* @brief Constructs the value from \p u, forwarding it if necessary.
	*
	* If \p u is convertible to \p T, this is an explicit constructor.
	*/
	template <class U = T>
	constexpr explicit(!std::is_convertible_v<U, T>) optional(U&& u)
	requires detail::enable_forward_value<T, U>;
	/**
	* @brief Constructs the value from \p rhs if it has one.
	*
	* @tparam U
	*/
	template <class U>
	constexpr explicit(!std::is_convertible_v<U, T>) optional(const optional<U>& rhs)
	requires (detail::enable_from_other<T, U, const U&>);
	/**
	* @brief Constructs the value from \p rhs if it has one.
	*/
	template <class U>
	constexpr explicit(!std::is_convertible_v<U, T>) optional(optional<U>&& rhs)
	requires (detail::enable_from_other<T, U, U &&>);
	// \ref{optional.dtor}, destructor
	/**
	* @brief Destructs the optional.
	*
	*/
	constexpr ~optional()
	requires std::is_trivially_destructible_v<T>
	= default;
	/**
	* @brief Destroys the optional and its value if it has one.
	*/
	constexpr ~optional()
	requires (!std::is_trivially_destructible_v<T>);
	// \ref{optional.assign}, assignment
	/**
	* @brief Resets the optional to an empty state.
	*/
	constexpr optional& operator=(nullopt_t) noexcept;
	/**
	* @brief Copy assigns the value from \p rhs if it has one.
	*/
	constexpr optional& operator=(const optional& rhs)
	requires std::is_copy_constructible_v<T> && std::is_copy_assignable_v<T> &&
	(!std::is_trivially_copy_assignable_v<T>);
	/**
	* @brief Copy assigns the value from \p rhs if it has one.
	*
	* @return optional&
	*/
	constexpr optional& operator=(const optional&)
	requires std::is_copy_constructible_v<T> && std::is_copy_assignable_v<T> &&
	std::is_trivially_copy_constructible_v<T> && std::is_trivially_copy_assignable_v<T>
	= default;
	/**
	* @brief Move assigns the value from \p rhs if it has one.
	*/
	constexpr optional& operator=(optional&& rhs) noexcept(std::is_nothrow_move_constructible_v<T>)
	requires std::is_move_constructible_v<T> && std::is_move_assignable_v<T> &&
	(!std::is_trivially_move_assignable_v<T>);
	/**
	* @brief Move assigns the value from \p rhs if it has one.
	*/
	constexpr optional& operator=(optional&&)
	requires std::is_move_constructible_v<T> && std::is_move_assignable_v<T> &&
	std::is_trivially_move_constructible_v<T> && std::is_trivially_move_assignable_v<T>
	= default;
	/**
	* @brief Assigns the contained value from \p u, destroying the old value if there
	*
	* @tparam U The type of the value to assign.
	* @param u The value to assign.
	* @return optional&
	*/
	template <class U = T>
	constexpr optional& operator=(U&& u)
	requires detail::enable_assign_forward<T, U>;
	/**
	* @brief Assigns the contained value from \p rhs if it has one, destroying the old value if there
	*
	*/
	template <class U>
	constexpr optional& operator=(const optional<U>& rhs)
	requires (detail::enable_assign_from_other<T, U, const U&>);
	/**
	* @brief Assigns the contained value from \p rhs if it has one, destroying the old value if there
	*/
	template <class U>
	constexpr optional& operator=(optional<U>&& rhs)
	requires (detail::enable_assign_from_other<T, U, U>);
	/**
	* @brief Constructs the value in-place, destroying the current one if there
	*
	* @tparam Args
	* @param args The argument list to use in emplacement construction.
	* @return T&
	*/
	template <class... Args>
	constexpr T& emplace(Args&&... args);
	/**
	* @brief Constructs the value in-place using the given arguments, destroying the current one if there
	*
	* @tparam U
	* @tparam Args
	* @param il The initializer list to use in emplacement construction.
	* @param args The argument list to use in emplacement construction.
	* @return T&
	*/
	template <class U, class... Args>
	constexpr T& emplace(std::initializer_list<U> il, Args&&... args);
	// \ref{optional.swap}, swap
	/**
	* @brief Swaps this optional with the other.
	*
	* @param rhs The optional to swap with.
	*/
	constexpr void swap(optional& rhs) noexcept(std::is_nothrow_move_constructible<T>::value &&
	std::is_nothrow_swappable<T>::value);
	// \ref{optional.iterators}, iterator support
	/**
	* @brief Returns an iterator to the beginning of the optional.
	* @return iterator
	*/
	constexpr iterator begin() noexcept;
	/**
	* @brief Returns a const iterator to the beginning of the optional.
	* @return const_iterator
	*/
	constexpr const_iterator begin() const noexcept;
	/**
	* @brief Returns an iterator to the end of the optional.
	* @return iterator
	*/
	constexpr iterator end() noexcept;
	/**
	* @brief Returns a const iterator to the end of the optional.
	* @return const_iterator
	*/
	constexpr const_iterator end() const noexcept;
	// \ref{optional.observe}, observers
	/**
	* @brief Returns a pointer to the contained value.
	*/
	constexpr const T* operator->() const;
	/**
	* @brief Returns a pointer to the contained value.
	*
	* @return T*
	*/
	constexpr T* operator->();
	/**
	* @brief Returns a reference to the contained value.
	*
	* @return T&
	*/
	constexpr T& operator*() &;
	/**
	* @brief Returns a reference to the contained value.
	*
	* @return const T&
	*/
	constexpr const T& operator*() const&;
	/**
	* @brief Returns a reference to the contained value.
	*
	* @return T&&
	*/
	constexpr T&& operator*() &&;
	/**
	* @brief Converts the optional to a boolean indicating whether it has a value.
	*
	* @return bool
	*/
	constexpr explicit operator bool() const noexcept;
	/**
	* @brief Returns whether or not the optional has a value.
	*
	* @return bool
	*/
	constexpr bool has_value() const noexcept;
	/**
	* @brief Returns a reference to the contained value.
	*
	* @return T&
	*/
	constexpr T& value() &;
	/**
	* @brief Returns a reference to the contained value.
	*
	* @return const T&
	*/
	constexpr const T& value() const&;
	/**
	* @brief Returns a reference to the contained value.
	*
	* @return T&&
	*/
	constexpr T&& value() &&;
	/**
	* @brief Returns the contained value if there is one, otherwise returns `u`.
	*
	* @tparam U The type of the alternate value
	* @param u The value to return in the empty case
	* @return T
	*/
	template <class U = std::remove_cv_t<T>>
	constexpr std::remove_cv_t<T> value_or(U&& u) const&;
	/**
	* @brief Returns the contained value if there is one, otherwise returns `u`.
	*
	* @tparam U The type of the alternate value
	* @param u The value to return in the empty case
	* @return T
	*/
	template <class U = std::remove_cv_t<T>>
	constexpr std::remove_cv_t<T> value_or(U&& u) &&;
	// \ref{optional.monadic}, monadic operations
	/**
	* @brief Applies a function to the contained value if there is one.
	*
	* @tparam F The type of the invocable
	* @param f The invocable to apply to the contained value
	* @return auto
	*
	* @details
	* The return type is the same as `std::invoke_result_t<F, T&>`,
	* but wrapped in an optional. The function \p f must return an optional type.
	*/
	template <class F>
	constexpr auto and_then(F&& f) &;
	/**
	* @brief Applies a function to the contained value if there is one.
	*
	* @tparam F The type of the invocable
	* @param f The invocable to apply to the contained value
	* @return auto
	*
	* @details
	* The return type is the same as `std::invoke_result_t<F, T&>`,
	* but wrapped in an optional. The function \p f must return an optional type.
	*/
	template <class F>
	constexpr auto and_then(F&& f) &&;
	/**
	* @brief Applies a function to the contained value if there is one.
	*
	* @tparam F The type of the invocable
	* @param f The invocable to apply to the contained value
	* @return auto
	*
	* @details
	* The return type is the same as `std::invoke_result_t<F, T&>`,
	* but wrapped in an optional. The function \p f must return an optional type.
	*/
	template <class F>
	constexpr auto and_then(F&& f) const&;
	/**
	* @brief Applies a function to the contained value if there is one.
	*
	* @tparam F The type of the invocable
	* @param f The invocable to apply to the contained value
	* @return auto
	*
	* @details
	* The return type is the same as `std::invoke_result_t<F, T&>`,
	* but wrapped in an optional. The function \p f must return an optional type.
	*/
	template <class F>
	constexpr auto and_then(F&& f) const&&;
	/**
	* @brief Returns an optional containing the result of applying \p f to the
	* contained value, or an empty optional if there is no contained value.
	*
	* @tparam F
	* @param f An invocable to apply to the contained value.
	* @return optional
	*/
	template <class F>
	constexpr auto transform(F&& f) &;
	/**
	* @brief Returns an optional containing the result of applying \p f to the
	* contained value, or an empty optional if there is no contained value.
	*
	* @tparam F
	* @param f An invocable to apply to the contained value.
	* @return auto
	*/
	template <class F>
	constexpr auto transform(F&& f) &&;
	/**
	* @brief Returns an optional containing the result of applying \p f to the
	* contained value, or an empty optional if there is no contained value.
	*
	* @tparam F
	* @param f An invocable to apply to the contained value.
	* @return auto
	*/
	template <class F>
	constexpr auto transform(F&& f) const&;
	/**
	* @brief Returns an optional containing the result of applying \p f to the
	* contained value, or an empty optional if there is no contained value.
	*
	* @tparam F
	* @param f An invocable to apply to the contained value.
	* @return auto
	*/
	template <class F>
	constexpr auto transform(F&& f) const&&;
	/**
	* @brief Returns an optional containing the contained value if it has one, or the result of applying \p f to the
	* optional if it does not.
	*
	* @tparam F An invocable type returning an optional.
	* @param f The invocable to call if the optional is disengaged.
	* @return optional
	*/
	template <class F>
	constexpr optional or_else(F&& f) const&
	requires (std::invocable<F> && std::copy_constructible<T>);
	/**
	* @brief Returns an optional containing the contained value if it has one, or
	* the result of calling \p f if it does not.
	*
	* @tparam F An invocable type returning an optional.
	* @param f The invocable to call if the optional is disengaged.
	* @return auto
	*/
	template <class F>
	constexpr optional or_else(F&& f) &&
	requires (std::invocable<F> && std::move_constructible<T>);

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 752 to 780 in 3108e69

	// \ref{optional.mod}, modifiers
	/**
	* @brief Resets the optional to an empty state, destroying the contained value if there is one.
	*
	*/
	constexpr void reset() noexcept;
	private:
	struct empty {};
	union {
	/**
	* @brief The empty state of the optional.
	*
	*/
	empty _{};
	/**
	* @brief The contained value of the optional.
	*
	*/
	T value_;
	};
	bool engaged_ = false;
	template <class... Args>
	constexpr void construct(Args&&... args) {
	std::construct_at(std::addressof(value_), std::forward<Args>(args)...);
	engaged_ = true;
	}

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 782 to 785 in 3108e69

	constexpr void hard_reset() noexcept {
	std::destroy_at(std::addressof(value_));
	engaged_ = false;
	}

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 787 to 788 in 3108e69

	template <class U>
	friend class optional;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 790 to 792 in 3108e69

	template <class F, class Arg>
	constexpr optional(detail::from_function_t, F&& f, Arg&& arg)
	: value_(std::invoke(std::forward<F>(f), std::forward<Arg>(arg))), engaged_(true) {}

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 799 to 811 in 3108e69

	public:
	/**
	* @brief Construct a new bad optional access object
	*
	*/
	bad_optional_access() = default;
	/**
	* @brief Get the error message for bad optional access
	*
	* @return const char*
	*/
	const char* what() const noexcept { return "Optional has no value"; }

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 818 to 819 in 3108e69

	template <class T>
	inline constexpr optional<T>::optional(nullopt_t) noexcept {}

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 822 to 823 in 3108e69

	inline constexpr optional<T>::optional(const optional& rhs)
	requires std::is_copy_constructible_v<T> && (!std::is_trivially_copy_constructible_v<T>)

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 825 to 827 in 3108e69

	if (rhs.has_value()) {
	construct(rhs.value_);
	}

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 831 to 832 in 3108e69

	inline constexpr optional<T>::optional(optional&& rhs) noexcept(std::is_nothrow_move_constructible_v<T>)
	requires std::is_move_constructible_v<T> && (!std::is_trivially_move_constructible_v<T>)

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 834 to 836 in 3108e69

	if (rhs.has_value()) {
	construct(std::move(rhs.value_));
	}

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 842 to 843 in 3108e69

	inline constexpr optional<T>::optional(in_place_t, Args&&... args)
	requires std::is_constructible_v<T, Args...>

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 848 to 849 in 3108e69

	inline constexpr optional<T>::optional(in_place_t, std::initializer_list<U> il, Args&&... args)
	requires std::is_constructible_v<T, std::initializer_list<U>&, Args&&...>

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 855 to 856 in 3108e69

	inline constexpr optional<T>::optional(U&& u)
	requires detail::enable_forward_value<T, U>

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 862 to 863 in 3108e69

	inline constexpr optional<T>::optional(const optional<U>& rhs)
	requires (detail::enable_from_other<T, U, const U&>)

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 865 to 867 in 3108e69

	if (rhs.has_value()) {
	construct(*rhs);
	}

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 873 to 874 in 3108e69

	inline constexpr optional<T>::optional(optional<U>&& rhs)
	requires (detail::enable_from_other<T, U, U &&>)

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 876 to 878 in 3108e69

	if (rhs.has_value()) {
	construct(*std::move(rhs));
	}

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 885 in 3108e69

requires (!std::is_trivially_destructible_v<T>)

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 887 to 888 in 3108e69

	if (has_value())
	std::destroy_at(std::addressof(value_));

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 894 to 896 in 3108e69

	inline constexpr optional<T>& optional<T>::operator=(nullopt_t) noexcept {
	reset();
	return *this;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 900 to 902 in 3108e69

	inline constexpr optional<T>& optional<T>::operator=(const optional<T>& rhs)
	requires std::is_copy_constructible_v<T> && std::is_copy_assignable_v<T> &&
	(!std::is_trivially_copy_assignable_v<T>)

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 904 to 910 in 3108e69

	if (!rhs.has_value())
	reset();
	else if (has_value())
	value_ = rhs.value_;
	else
	construct(rhs.value_);
	return *this;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 914 to 917 in 3108e69

	inline constexpr optional<T>&
	optional<T>::operator=(optional<T>&& rhs) noexcept(std::is_nothrow_move_constructible_v<T>)
	requires std::is_move_constructible_v<T> && std::is_move_assignable_v<T> &&
	(!std::is_trivially_move_assignable_v<T>)

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 919 to 925 in 3108e69

	if (!rhs.has_value())
	reset();
	else if (has_value())
	value_ = std::move(rhs.value_);
	else
	construct(std::move(rhs.value_));
	return *this;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 932 to 933 in 3108e69

	inline constexpr optional<T>& optional<T>::operator=(U&& u)
	requires detail::enable_assign_forward<T, U>

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 935 to 939 in 3108e69

	if (has_value()) {
	value_ = std::forward<U>(u);
	} else {
	construct(std::forward<U>(u));
	}

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 941 in 3108e69

return *this;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 950 to 951 in 3108e69

	inline constexpr optional<T>& optional<T>::operator=(const optional<U>& rhs)
	requires (detail::enable_assign_from_other<T, U, const U&>)

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 953 to 958 in 3108e69

	if (has_value()) {
	if (rhs.has_value()) {
	value_ = *rhs;
	} else {
	hard_reset();
	}

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 960 in 3108e69

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 961 to 963 in 3108e69

	else if (rhs.has_value()) {
	construct(*rhs);
	}

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 965 in 3108e69

return *this;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 974 to 975 in 3108e69

	inline constexpr optional<T>& optional<T>::operator=(optional<U>&& rhs)
	requires (detail::enable_assign_from_other<T, U, U>)

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 977 to 982 in 3108e69

	if (has_value()) {
	if (rhs.has_value()) {
	value_ = *std::move(rhs);
	} else {
	hard_reset();
	}

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 984 in 3108e69

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 985 to 987 in 3108e69

	else if (rhs.has_value()) {
	construct(*std::move(rhs));
	}

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 989 in 3108e69

return *this;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 996 to 1000 in 3108e69

	constexpr T& optional<T>::emplace(Args&&... args) {
	static_assert(std::is_constructible_v<T, Args&&...>);
	*this = nullopt;
	construct(std::forward<Args>(args)...);
	return value();

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1005 to 1009 in 3108e69

	constexpr T& optional<T>::emplace(std::initializer_list<U> il, Args&&... args) {
	static_assert(std::is_constructible_v<T, std::initializer_list<U>&, Args&&...>);
	*this = nullopt;
	construct(il, std::forward<Args>(args)...);
	return value();

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1020 to 1033 in 3108e69

	inline constexpr void optional<T>::swap(optional<T>& rhs) noexcept(std::is_nothrow_move_constructible<T>::value &&
	std::is_nothrow_swappable<T>::value) {
	static_assert(std::is_move_constructible_v<T>);
	using std::swap;
	if (has_value()) {
	if (rhs.has_value()) {
	swap(value(), *rhs);
	} else {
	std::construct_at(std::addressof(rhs.value_), std::move(value_));
	value_.T::~T();
	}
	} else if (rhs.has_value()) {
	std::construct_at(std::addressof(value_), std::move(rhs.value_));
	rhs.value_.T::~T();

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 1035 in 3108e69

swap(engaged_, rhs.engaged_);

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 1042 in 3108e69

return iterator(has_value() ? std::addressof(value_) : nullptr);

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1046 to 1047 in 3108e69

	inline constexpr optional<T>::const_iterator optional<T>::begin() const noexcept {
	return const_iterator(has_value() ? std::addressof(value_) : nullptr);

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 1051 in 3108e69

return begin() + has_value();

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 1056 in 3108e69

return begin() + has_value();

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1062 to 1064 in 3108e69

	template <class T>
	inline constexpr const T* optional<T>::operator->() const {
	return std::addressof(value_);

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1067 to 1069 in 3108e69

	template <class T>
	inline constexpr T* optional<T>::operator->() {
	return std::addressof(value_);

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1073 to 1075 in 3108e69

	template <class T>
	inline constexpr T& optional<T>::operator*() & {
	return value_;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1078 to 1080 in 3108e69

	template <class T>
	inline constexpr const T& optional<T>::operator*() const& {
	return value_;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1083 to 1085 in 3108e69

	template <class T>
	inline constexpr T&& optional<T>::operator*() && {
	return std::move(value_);

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 1090 in 3108e69

return engaged_;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 1096 in 3108e69

return engaged_;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1101 to 1103 in 3108e69

	template <class T>
	inline constexpr T& optional<T>::value() & {
	return has_value() ? value_ : throw bad_optional_access();

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1105 to 1107 in 3108e69

	template <class T>
	inline constexpr const T& optional<T>::value() const& {
	return has_value() ? value_ : throw bad_optional_access();

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1109 to 1110 in 3108e69

	template <class T>
	inline constexpr T&& optional<T>::value() && {

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1112 to 1115 in 3108e69

	if (has_value()) {
	return std::move(value_);
	}
	throw bad_optional_access();

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 1117 in 3108e69

return has_value() ? std::move(value_) : throw bad_optional_access();

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1124 to 1130 in 3108e69

	inline constexpr std::remove_cv_t<T> optional<T>::value_or(U&& u) const& {
	using X = std::remove_cv_t<T>;
	static_assert(std::is_convertible_v<const T&, X>, "Must be able to convert const T& to remove_cv_t<T>");
	static_assert(std::is_convertible_v<U, X>, "Must be able to convert u to remove_cv_t<T>");
	if (has_value())
	return value_;
	return std::forward<U>(u);

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1135 to 1142 in 3108e69

	inline constexpr std::remove_cv_t<T> optional<T>::value_or(U&& u) && {
	using X = std::remove_cv_t<T>;
	static_assert(std::is_convertible_v<T, X>, "Must be able to convert T to remove_cv_t<T>");
	static_assert(std::is_convertible_v<U, X>, "Must be able to convert u to remove_cv_t<T>");
	if (has_value()) {
	return std::move(value_);
	}
	return std::forward<U>(u);

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1148 to 1155 in 3108e69

	constexpr auto optional<T>::and_then(F&& f) & {
	using U = std::invoke_result_t<F, T&>;
	static_assert(detail::is_optional<std::remove_cvref_t<U>>);
	if (has_value()) {
	return std::invoke(std::forward<F>(f), value_);
	} else {
	return std::remove_cvref_t<U>();
	}

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1160 to 1167 in 3108e69

	constexpr auto optional<T>::and_then(F&& f) && {
	using U = std::invoke_result_t<F, T&&>;
	static_assert(detail::is_optional<std::remove_cvref_t<U>>);
	if (has_value()) {
	return std::invoke(std::forward<F>(f), std::move(value_));
	} else {
	return std::remove_cvref_t<U>();
	}

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1172 to 1179 in 3108e69

	constexpr auto optional<T>::and_then(F&& f) const& {
	using U = std::invoke_result_t<F, const T&>;
	static_assert(detail::is_optional<std::remove_cvref_t<U>>);
	if (has_value()) {
	return std::invoke(std::forward<F>(f), value_);
	} else {
	return std::remove_cvref_t<U>();
	}

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1184 to 1191 in 3108e69

	constexpr auto optional<T>::and_then(F&& f) const&& {
	using U = std::invoke_result_t<F, const T&&>;
	static_assert(detail::is_optional<std::remove_cvref_t<U>>);
	if (has_value()) {
	return std::invoke(std::forward<F>(f), std::move(value_));
	} else {
	return std::remove_cvref_t<U>();
	}

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1197 to 1203 in 3108e69

	constexpr auto optional<T>::transform(F&& f) & {
	using U = std::invoke_result_t<F, T&>;
	static_assert(!std::is_array_v<U>);
	static_assert(!std::is_same_v<U, in_place_t>);
	static_assert(!std::is_same_v<U, nullopt_t>);
	static_assert(std::is_object_v<U> || std::is_reference_v<U>); /// References now allowed
	return (has_value()) ? optional<U>{detail::from_function, std::forward<F>(f), value_} : optional<U>{};

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1208 to 1214 in 3108e69

	constexpr auto optional<T>::transform(F&& f) && {
	using U = std::invoke_result_t<F, T&&>;
	static_assert(!std::is_array_v<U>);
	static_assert(!std::is_same_v<U, in_place_t>);
	static_assert(!std::is_same_v<U, nullopt_t>);
	static_assert(std::is_object_v<U> || std::is_reference_v<U>); /// References now allowed
	return (has_value()) ? optional<U>{detail::from_function, std::forward<F>(f), std::move(value_)} : optional<U>{};

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1219 to 1225 in 3108e69

	constexpr auto optional<T>::transform(F&& f) const& {
	using U = std::invoke_result_t<F, const T&>;
	static_assert(!std::is_array_v<U>);
	static_assert(!std::is_same_v<U, in_place_t>);
	static_assert(!std::is_same_v<U, nullopt_t>);
	static_assert(std::is_object_v<U> || std::is_reference_v<U>); /// References now allowed
	return (has_value()) ? optional<U>{detail::from_function, std::forward<F>(f), value_} : optional<U>{};

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1230 to 1236 in 3108e69

	constexpr auto optional<T>::transform(F&& f) const&& {
	using U = std::invoke_result_t<F, const T&>;
	static_assert(!std::is_array_v<U>);
	static_assert(!std::is_same_v<U, in_place_t>);
	static_assert(!std::is_same_v<U, nullopt_t>);
	static_assert(std::is_object_v<U> || std::is_reference_v<U>); /// References now allowed
	return (has_value()) ? optional<U>{detail::from_function, std::forward<F>(f), std::move(value_)} : optional<U>{};

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 1240 in 3108e69

* @brief Returns an optional containing the contained value if it has one, or the result of calling

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1250 to 1251 in 3108e69

	constexpr optional<T> optional<T>::or_else(F&& f) const&
	requires (std::invocable<F> && std::copy_constructible<T>)

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1253 to 1255 in 3108e69

	static_assert(std::is_same_v<std::remove_cvref_t<std::invoke_result_t<F>>, optional>);
	if (has_value())
	return value_;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 1257 in 3108e69

return std::forward<F>(f)();

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 1261 in 3108e69

* @brief Returns an optional containing the contained value if it has one, or the result of calling

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1271 to 1272 in 3108e69

	constexpr optional<T> optional<T>::or_else(F&& f) &&
	requires (std::invocable<F> && std::move_constructible<T>)

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1274 to 1276 in 3108e69

	static_assert(std::is_same_v<std::remove_cvref_t<std::invoke_result_t<F>>, optional>);
	if (has_value())
	return std::move(value_);

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 1278 in 3108e69

return std::forward<F>(f)();

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1282 to 1288 in 3108e69

	template <class T>
	constexpr void optional<T>::reset() noexcept {
	if constexpr (!std::is_trivially_destructible_v<T>) {
	if (has_value())
	value_.~T();
	}
	engaged_ = false;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1297 to 1298 in 3108e69

	constexpr bool operator==(const optional<T>& lhs, const optional<U>& rhs)
	requires detail::optional_eq_rel<T, U>

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 1300 in 3108e69

return static_cast<bool>(lhs) == static_cast<bool>(rhs) && (!lhs || *lhs == *rhs);

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1304 to 1305 in 3108e69

	constexpr bool operator!=(const optional<T>& lhs, const optional<U>& rhs)
	requires detail::optional_ne_rel<T, U>

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 1307 in 3108e69

return static_cast<bool>(lhs) != static_cast<bool>(rhs) || (static_cast<bool>(lhs) && *lhs != *rhs);

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1311 to 1312 in 3108e69

	constexpr bool operator<(const optional<T>& lhs, const optional<U>& rhs)
	requires detail::optional_lt_rel<T, U>

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 1314 in 3108e69

return static_cast<bool>(rhs) && (!lhs || *lhs < *rhs);

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1318 to 1319 in 3108e69

	constexpr bool operator>(const optional<T>& lhs, const optional<U>& rhs)
	requires detail::optional_gt_rel<T, U>

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 1321 in 3108e69

return static_cast<bool>(lhs) && (!rhs || *lhs > *rhs);

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1325 to 1326 in 3108e69

	constexpr bool operator<=(const optional<T>& lhs, const optional<U>& rhs)
	requires detail::optional_le_rel<T, U>

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 1328 in 3108e69

return !lhs || (static_cast<bool>(rhs) && *lhs <= *rhs);

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1332 to 1333 in 3108e69

	constexpr bool operator>=(const optional<T>& lhs, const optional<U>& rhs)
	requires detail::optional_ge_rel<T, U>

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 1335 in 3108e69

return !rhs || (static_cast<bool>(lhs) && *lhs >= *rhs);

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1339 to 1340 in 3108e69

	constexpr std::compare_three_way_result_t<T, U> operator<=>(const optional<T>& x, const optional<U>& y) {
	return x && y ? *x <=> *y : bool(x) <=> bool(y);

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1345 to 1346 in 3108e69

	constexpr bool operator==(const optional<T>& lhs, nullopt_t) noexcept {
	return !lhs;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1350 to 1351 in 3108e69

	constexpr std::strong_ordering operator<=>(const optional<T>& x, nullopt_t) noexcept {
	return bool(x) <=> false;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1356 to 1357 in 3108e69

	constexpr bool operator==(const optional<T>& lhs, const U& rhs)
	requires (!detail::is_optional<U>) && detail::optional_eq_rel<T, U>

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 1359 in 3108e69

return lhs && *lhs == rhs;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1363 to 1364 in 3108e69

	constexpr bool operator==(const T& lhs, const optional<U>& rhs)
	requires (!detail::is_optional<T>) && detail::optional_eq_rel<T, U>

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 1366 in 3108e69

return rhs && lhs == *rhs;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1370 to 1371 in 3108e69

	constexpr bool operator!=(const optional<T>& lhs, const U& rhs)
	requires (!detail::is_optional<U>) && detail::optional_ne_rel<T, U>

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 1373 in 3108e69

return !lhs || *lhs != rhs;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1377 to 1378 in 3108e69

	constexpr bool operator!=(const T& lhs, const optional<U>& rhs)
	requires (!detail::is_optional<T>) && detail::optional_ne_rel<T, U>

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 1380 in 3108e69

return !rhs || lhs != *rhs;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1384 to 1385 in 3108e69

	constexpr bool operator<(const optional<T>& lhs, const U& rhs)
	requires (!detail::is_optional<U>) && detail::optional_lt_rel<T, U>

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 1387 in 3108e69

return !lhs || *lhs < rhs;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1391 to 1392 in 3108e69

	constexpr bool operator<(const T& lhs, const optional<U>& rhs)
	requires (!detail::is_optional<T>) && detail::optional_lt_rel<T, U>

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 1394 in 3108e69

return rhs && lhs < *rhs;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1398 to 1399 in 3108e69

	constexpr bool operator>(const optional<T>& lhs, const U& rhs)
	requires (!detail::is_optional<U>) && detail::optional_gt_rel<T, U>

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 1401 in 3108e69

return lhs && *lhs > rhs;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1405 to 1406 in 3108e69

	constexpr bool operator>(const T& lhs, const optional<U>& rhs)
	requires (!detail::is_optional<T>) && detail::optional_gt_rel<T, U>

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 1408 in 3108e69

return !rhs || lhs > *rhs;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1412 to 1413 in 3108e69

	constexpr bool operator<=(const optional<T>& lhs, const U& rhs)
	requires (!detail::is_optional<U>) && detail::optional_le_rel<T, U>

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 1415 in 3108e69

return !lhs || *lhs <= rhs;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1419 to 1420 in 3108e69

	constexpr bool operator<=(const T& lhs, const optional<U>& rhs)
	requires (!detail::is_optional<T>) && detail::optional_le_rel<T, U>

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 1422 in 3108e69

return rhs && lhs <= *rhs;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1426 to 1427 in 3108e69

	constexpr bool operator>=(const optional<T>& lhs, const U& rhs)
	requires (!detail::is_optional<U>) && detail::optional_ge_rel<T, U>

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 1429 in 3108e69

return lhs && *lhs >= rhs;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1433 to 1434 in 3108e69

	constexpr bool operator>=(const T& lhs, const optional<U>& rhs)
	requires (!detail::is_optional<T>) && detail::optional_ge_rel<T, U>

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 1436 in 3108e69

return !rhs || lhs >= *rhs;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1440 to 1442 in 3108e69

	requires (!is_derived_from_optional<U>) && std::three_way_comparable_with<T, U>
	constexpr std::compare_three_way_result_t<T, U> operator<=>(const optional<T>& x, const U& v) {
	return bool(x) ? *x <=> v : std::strong_ordering::less;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1448 to 1449 in 3108e69

	constexpr void swap(optional<T>& x, optional<T>& y) noexcept(noexcept(x.swap(y)))
	requires std::is_move_constructible_v<T> && std::is_swappable_v<T>

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 1451 in 3108e69

return x.swap(y);

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1455 to 1457 in 3108e69

	constexpr optional<std::decay_t<T>>
	make_optional(T&& t) noexcept(std::is_nothrow_constructible_v<optional<std::decay_t<T>>, T>)
	requires std::is_constructible_v<std::decay_t<T>, T>

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 1459 in 3108e69

return optional<std::decay_t<T>>{std::forward<T>(t)};

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1463 to 1464 in 3108e69

	constexpr optional<T> make_optional(Args&&... args) noexcept(std::is_nothrow_constructible_v<T, Args...>)
	requires std::is_constructible_v<T, Args...>

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1466 to 1467 in 3108e69

	static_assert(!std::is_reference_v<T>, "May not make an optional containing a reference");
	return optional<T>{in_place, std::forward<Args>(args)...};

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1472 to 1474 in 3108e69

	make_optional(std::initializer_list<U> init_list,
	Args&&... args) noexcept(std::is_nothrow_constructible_v<T, std::initializer_list<U>&, Args...>)
	requires std::is_constructible_v<T, std::initializer_list<U>&, Args...>

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1476 to 1477 in 3108e69

	static_assert(!std::is_reference_v<U>, "Can not make optional from initializer_list of references.");
	return optional<T>{in_place, init_list, std::forward<Args>(args)...};

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 1496 in 3108e69

(!std::is_reference_v<From> && std::is_convertible_v<std::remove_cvref_t<From>*, std::remove_cvref_t<To>*>) ||

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1502 to 1504 in 3108e69

	(std::is_lvalue_reference_v<To> && std::is_const_v<std::remove_reference_t<To>> &&
	std::is_convertible_v<From, const std::remove_cvref_t<To>&&> &&
	!std::is_convertible_v<From, std::remove_cvref_t<To>&>));

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1518 to 1922 in 3108e69

	template <class T>
	class optional<T&> {
	public:
	/**
	* @brief The type of the value contained in the optional.
	*
	*/
	using value_type = T;
	/**
	* @brief The type of the iterator for the optional.
	*
	*/
	using iterator = detail::contiguous_iterator<T,
	optional>; // see [optionalref.iterators]
	public:
	// \ref{optionalref.ctor}, constructors
	/**
	* @brief Default constructor.
	*/
	constexpr optional() noexcept = default;
	/**
	* @brief Constructs an empty optional.
	*/
	constexpr optional(nullopt_t) noexcept : optional() {}
	/**
	* @brief Copy constructor.
	*
	* Constructs an empty optional if the rhs is empty, otherwise constructs
	* the contained value from the rhs.
	*/
	constexpr optional(const optional& rhs) noexcept = default;
	/**
	* @brief In-place constructor.
	*
	* @tparam Arg
	* @param arg The value to construct in-place from.
	*/
	template <class Arg>
	requires (std::is_constructible_v<T&, Arg> && !detail::reference_constructs_from_temporary_v<T&, Arg>)
	constexpr explicit optional(in_place_t, Arg&& arg);
	/**
	* @brief Construct from a U
	* @tparam U
	* @param u The value to construct from.
	* @details
	* Constructs the contained value from `u` if it is convertible to `T&`.
	* If `T&` can be constructed from a temporary, this constructor is
	* deleted to prevent binding a temporary to a reference.
	*/
	template <class U>
	requires (std::is_constructible_v<T&, U> && !(std::is_same_v<std::remove_cvref_t<U>, in_place_t>) &&
	!(std::is_same_v<std::remove_cvref_t<U>, optional>) &&
	!detail::reference_constructs_from_temporary_v<T&, U>)
	constexpr explicit(!std::is_convertible_v<U, T&>)
	optional(U&& u) noexcept(std::is_nothrow_constructible_v<T&, U>) {
	convert_ref_init_val(u);
	}
	/**
	* @brief Constructs an optional from a U, but deletes the constructor if
	*
	* @tparam U
	*/
	template <class U>
	requires (std::is_constructible_v<T&, U> && !(std::is_same_v<std::remove_cvref_t<U>, in_place_t>) &&
	!(std::is_same_v<std::remove_cvref_t<U>, optional>) &&
	detail::reference_constructs_from_temporary_v<T&, U>)
	constexpr optional(U&& u) = delete;
	// The full set of 4 overloads on optional<U> by value category, doubled to
	// 8 by deleting if reference_constructs_from_temporary_v is true. This
	// allows correct constraints by propagating the value category from the
	// optional to the value within the rhs.
	/**
	* @brief Constructs an optional from another optional of type U.
	*
	* @tparam U
	* @param rhs The optional to construct from.
	* @details
	* Constructs the contained value from the rhs if it has a value, otherwise
	* constructs an empty optional.
	* If `T&` can be constructed from a temporary, this constructor is
	* deleted to prevent binding a temporary to a reference.
	*/
	template <class U>
	requires (std::is_constructible_v<T&, U&> && !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
	!std::is_same_v<T&, U> && !detail::reference_constructs_from_temporary_v<T&, U&>)
	constexpr explicit(!std::is_convertible_v<U&, T&>)
	optional(optional<U>& rhs) noexcept(std::is_nothrow_constructible_v<T&, U&>);
	/**
	* @brief Constructs an optional from another optional of type U.
	* @param rhs The optional to construct from.
	* @tparam U
	* @details
	* Constructs the contained value from the rhs if it has a value, otherwise
	* constructs an empty optional.
	* If `T&` can be constructed from a temporary, this constructor is
	* deleted to prevent binding a temporary to a reference.
	*/
	template <class U>
	requires (std::is_constructible_v<T&, const U&> && !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
	!std::is_same_v<T&, U> && !detail::reference_constructs_from_temporary_v<T&, const U&>)
	constexpr explicit(!std::is_convertible_v<const U&, T&>)
	optional(const optional<U>& rhs) noexcept(std::is_nothrow_constructible_v<T&, const U&>);
	/**
	* @brief Constructs an optional from another optional of type U.
	* @param rhs The optional to construct from.
	* @tparam U
	* @details
	* Constructs the contained value from the rhs if it has a value, otherwise
	* constructs an empty optional.
	* If `T&` can be constructed from a temporary, this constructor is
	* deleted to prevent binding a temporary to a reference.
	*/
	template <class U>
	requires (std::is_constructible_v<T&, U> && !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
	!std::is_same_v<T&, U> && !detail::reference_constructs_from_temporary_v<T&, U>)
	constexpr explicit(!std::is_convertible_v<U, T&>)
	optional(optional<U>&& rhs) noexcept(noexcept(std::is_nothrow_constructible_v<T&, U>));
	/**
	* @brief Constructs an optional from another optional of type U.
	*
	* @tparam U The type contained the right hand side optional.
	* @param rhs The optional to construct from.
	* @details
	* Constructs the contained value from the rhs if it has a value, otherwise
	* constructs an empty optional.
	* If `T&` can be constructed from a temporary, this constructor is
	* deleted to prevent binding a temporary to a reference.
	*/
	template <class U>
	requires (std::is_constructible_v<T&, const U> && !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
	!std::is_same_v<T&, U> && !detail::reference_constructs_from_temporary_v<T&, const U>)
	constexpr explicit(!std::is_convertible_v<const U, T&>)
	optional(const optional<U>&& rhs) noexcept(noexcept(std::is_nothrow_constructible_v<T&, const U>));
	/**
	* @brief Constructs an optional from another optional of type U
	*
	* @tparam U
	* @param rhs
	* @details
	* Constructs the contained value from the rhs if it has a value, otherwise
	* constructs an empty optional.
	* If `T&` can be constructed from a temporary, this constructor is
	* deleted to prevent binding a temporary to a reference.
	*/
	template <class U>
	requires (std::is_constructible_v<T&, U&> && !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
	!std::is_same_v<T&, U> && detail::reference_constructs_from_temporary_v<T&, U&>)
	constexpr optional(optional<U>& rhs) = delete;
	/**
	* @brief Constructs an optional from another optional of type U
	*
	* @tparam U
	* @param rhs
	* @details
	* Constructs the contained value from the rhs if it has a value, otherwise
	* constructs an empty optional.
	* If `T&` can be constructed from a temporary, this constructor is
	* deleted to prevent binding a temporary to a reference.
	*/
	template <class U>
	requires (std::is_constructible_v<T&, const U&> && !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
	!std::is_same_v<T&, U> && detail::reference_constructs_from_temporary_v<T&, const U&>)
	constexpr optional(const optional<U>& rhs) = delete;
	/**
	* @brief Constructs an optional from another optional of type U
	*
	* @tparam U
	* @param rhs
	* @details
	* Constructs the contained value from the rhs if it has a value, otherwise
	* constructs an empty optional.
	* If `T&` can be constructed from a temporary, this constructor is
	* deleted to prevent binding a temporary to a reference.
	*/
	template <class U>
	requires (std::is_constructible_v<T&, U> && !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
	!std::is_same_v<T&, U> && detail::reference_constructs_from_temporary_v<T&, U>)
	constexpr optional(optional<U>&& rhs) = delete;
	/**
	* @brief Constructs an optional from another optional of type U
	*
	* @tparam U
	* @param rhs
	* @details
	* Constructs the contained value from the rhs if it has a value, otherwise
	* constructs an empty optional.
	* If `T&` can be constructed from a temporary, this constructor is
	* deleted to prevent binding a temporary to a reference.
	*/
	template <class U>
	requires (std::is_constructible_v<T&, const U> && !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
	!std::is_same_v<T&, U> && detail::reference_constructs_from_temporary_v<T&, const U>)
	constexpr optional(const optional<U>&& rhs) = delete;
	// \ref{optionalref.dtor}, destructor
	/**
	* @brief Destructor.
	*
	* @details
	* Does not destroy the contained value, as it is a reference.
	*/
	constexpr ~optional() = default;
	// \ref{optionalref.assign}, assignment
	/**
	* @brief Nullopt assignment operator.
	*
	* @return optional&
	*
	* @details
	* Destroys the current value if there is one, and leaves the optional
	* in an empty state.
	*/
	constexpr optional& operator=(nullopt_t) noexcept;
	/**
	* @brief Assignment operator.
	*
	* @param rhs The value to assign.
	* @return optional&
	* @details
	* If `rhs` has a value, assigns it to the contained value. Otherwise resets
	* the contained value in `*this`.
	*/
	constexpr optional& operator=(const optional& rhs) noexcept = default;
	/**
	* @brief Emplaces a new value in the optional, destroying the current one
	* if the optional is engaged.
	*
	* @tparam U The type of the value to emplace.
	* @param u The value to emplace.
	* @return T&
	* @details
	* Constructs the contained value from `u` if it is convertible to `T&`.
	*/
	template <class U>
	requires (std::is_constructible_v<T&, U> && !detail::reference_constructs_from_temporary_v<T&, U>)
	constexpr T& emplace(U&& u) noexcept(std::is_nothrow_constructible_v<T&, U>);
	// \ref{optionalref.swap}, swap
	/**
	* @brief Swaps the contents of this optional with another.
	*
	* @param rhs The value to swap with.
	*/
	constexpr void swap(optional& rhs) noexcept;
	// \ref{optional.iterators}, iterator support
	/**
	* @brief Returns an iterator to the beginning of the optional.
	*
	* @return iterator
	*/
	constexpr iterator begin() const noexcept;
	/**
	* @brief Returns an iterator to the end of the optional.
	*
	* @return iterator
	*/
	constexpr iterator end() const noexcept;
	// \ref{optionalref.observe}, observers
	/**
	* @brief Returns a pointer to the contained value.
	*
	* @return T*
	*/
	constexpr T* operator->() const noexcept;
	/**
	* @brief Returns a reference to the contained value.
	*
	* @return T&
	*/
	constexpr T& operator*() const noexcept;
	/**
	* @brief Converts the optional to a boolean value.
	*
	* @return bool
	*/
	constexpr explicit operator bool() const noexcept;
	/**
	* @brief Checks if the optional has a value.
	*
	* @return bool
	*/
	constexpr bool has_value() const noexcept;
	/**
	* @brief Returns the contained value if there is one, otherwise throws
	*
	* @return T&
	*/
	constexpr T& value() const;
	// LWG4304. std::optional<NonReturnable&> is ill-formed due to value_o
	// Resolution:
	// -?- Constraints: T is a non-array object type.
	// -?- Remarks: The return type is unspecified if T is an array type or a
	// non-object type. [Note ?: This is to avoid the declaration being
	// ill-formed. — end note]
	//
	// Implementer Note: Using decay_t as a detail as it is remove_cv_t for
	// non-array objects, and produces a valid type for arrays and functions,
	// which are otherwise `required` out.
	/**
	* @brief Returns the contained value if there is one, otherwise returns `u`.
	*
	* @tparam U The type of the alternate value
	* @param u The value to return in the empty case
	* @return std::remove_cv_t<T>
	*/
	template <class U = std::remove_cv_t<T>>
	requires (std::is_object_v<T> && !std::is_array_v<T>)
	constexpr std::decay_t<T> value_or(U&& u) const;
	// \ref{optionalref.monadic}, monadic operations
	/**
	* @brief Applies a function to the contained value if there is one.
	*
	* @tparam F The type of the invocable
	* @param f The invocable to apply to the contained value
	* @return auto
	*
	* @details
	* The return type is the same as `std::invoke_result_t<F, T&>`,
	* but wrapped in an optional. The function \p f must return an optional type.
	*/
	template <class F>
	constexpr auto and_then(F&& f) const;
	/**
	* @brief Applies a function to the contained value if there is one.
	*
	* @tparam F The type of the invocable
	* @param f The invocable to apply to the contained value
	* @return optional<std::invoke_result_t<F, T&>>
	*
	* @details
	* The return type is the same as `std::invoke_result_t<F, T&>`,
	* but wrapped in an optional.
	*/
	template <class F>
	constexpr optional<std::invoke_result_t<F, T&>> transform(F&& f) const;
	/**
	* @brief Calls a function if the optional is empty.
	*
	* @tparam F The type of the invocable
	* @param f The invocable to apply to the contained value
	* @return optional
	* @details
	* The return type is the same as the return type of \p f, which must
	* return an optional type.
	*/
	template <class F>
	constexpr optional or_else(F&& f) const
	requires (std::invocable<F>);
	// \ref{optional.mod}, modifiers
	/**
	* @brief Resets the optional to an empty state.
	*
	*/
	constexpr void reset() noexcept;
	private:
	T* value_ = nullptr; // exposition only
	// \ref{optionalref.expos}, exposition only helper functions
	template <class U>
	constexpr void convert_ref_init_val(U&& u) {
	// Creates a variable, \tcode{r},
	// as if by \tcode{T\& r(std::forward<U>(u));}
	// and then initializes \exposid{val} with \tcode{addressof(r)}
	T& r(std::forward<U>(u));
	value_ = std::addressof(r);
	}
	template <class U>
	friend class optional;
	template <class F, class Arg>
	constexpr optional(detail::from_function_t, F&& f, Arg&& arg) {
	convert_ref_init_val(std::invoke(std::forward<F>(f), std::forward<Arg>(arg)));
	}

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1928 to 1930 in 3108e69

	requires (std::is_constructible_v<T&, Arg> && !detail::reference_constructs_from_temporary_v<T&, Arg>)
	constexpr optional<T&>::optional(in_place_t, Arg&& arg) {
	convert_ref_init_val(std::forward<Arg>(arg));

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1937 to 1939 in 3108e69

	// requires(std::is_constructible_v<T&, U> && !(is_same_v<remove_cvref_t<U>, in_place_t>) &&
	// !(is_same_v<remove_cvref_t<U>, optional<T&>>) && !detail::reference_constructs_from_temporary_v<T&, U>)
	// constexpr optional<T&>::optional(U&& u) noexcept(is_nothrow_constructible_v<T&, U>)

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1944 to 1949 in 3108e69

	requires (std::is_constructible_v<T&, U&> && !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
	!std::is_same_v<T&, U> && !detail::reference_constructs_from_temporary_v<T&, U&>)
	constexpr optional<T&>::optional(optional<U>& rhs) noexcept(std::is_nothrow_constructible_v<T&, U&>) {
	if (rhs.has_value()) {
	convert_ref_init_val(*rhs);
	}

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1954 to 1959 in 3108e69

	requires (std::is_constructible_v<T&, const U&> && !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
	!std::is_same_v<T&, U> && !detail::reference_constructs_from_temporary_v<T&, const U&>)
	constexpr optional<T&>::optional(const optional<U>& rhs) noexcept(std::is_nothrow_constructible_v<T&, const U&>) {
	if (rhs.has_value()) {
	convert_ref_init_val(*rhs);
	}

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1964 to 1969 in 3108e69

	requires (std::is_constructible_v<T&, U> && !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
	!std::is_same_v<T&, U> && !detail::reference_constructs_from_temporary_v<T&, U>)
	constexpr optional<T&>::optional(optional<U>&& rhs) noexcept(noexcept(std::is_nothrow_constructible_v<T&, U>)) {
	if (rhs.has_value()) {
	convert_ref_init_val(*std::move(rhs));
	}

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1974 to 1980 in 3108e69

	requires (std::is_constructible_v<T&, const U> && !std::is_same_v<std::remove_cv_t<T>, optional<U>> &&
	!std::is_same_v<T&, U> && !detail::reference_constructs_from_temporary_v<T&, const U>)
	constexpr optional<T&>::optional(const optional<U>&& rhs) noexcept(
	noexcept(std::is_nothrow_constructible_v<T&, const U>)) {
	if (rhs.has_value()) {
	convert_ref_init_val(*std::move(rhs));
	}

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1985 to 1987 in 3108e69

	constexpr optional<T&>& optional<T&>::operator=(nullopt_t) noexcept {
	value_ = nullptr;
	return *this;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 1992 to 1995 in 3108e69

	requires (std::is_constructible_v<T&, U> && !detail::reference_constructs_from_temporary_v<T&, U>)
	constexpr T& optional<T&>::emplace(U&& u) noexcept(std::is_nothrow_constructible_v<T&, U>) {
	convert_ref_init_val(std::forward<U>(u));
	return *value_;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 2001 to 2002 in 3108e69

	constexpr void optional<T&>::swap(optional<T&>& rhs) noexcept {
	std::swap(value_, rhs.value_);

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 2008 to 2009 in 3108e69

	constexpr optional<T&>::iterator optional<T&>::begin() const noexcept {
	return iterator(has_value() ? value_ : nullptr);

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 2013 to 2014 in 3108e69

	constexpr optional<T&>::iterator optional<T&>::end() const noexcept {
	return begin() + has_value();

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 2018 to 2020 in 3108e69

	template <class T>
	constexpr T* optional<T&>::operator->() const noexcept {
	return value_;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 2023 to 2025 in 3108e69

	template <class T>
	constexpr T& optional<T&>::operator*() const noexcept {
	return *value_;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 2028 to 2030 in 3108e69

	template <class T>
	constexpr optional<T&>::operator bool() const noexcept {
	return value_ != nullptr;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 2032 to 2034 in 3108e69

	template <class T>
	constexpr bool optional<T&>::has_value() const noexcept {
	return value_ != nullptr;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 2037 to 2042 in 3108e69

	template <class T>
	constexpr T& optional<T&>::value() const {
	if (has_value()) {
	return *value_;
	}
	throw bad_optional_access();

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 2047 to 2055 in 3108e69

	requires (std::is_object_v<T> && !std::is_array_v<T>)
	constexpr std::decay_t<T> optional<T&>::value_or(U&& u) const {
	using X = std::remove_cv_t<T>;
	static_assert(std::is_convertible_v<T&, X>, "remove_cv_t<T> must be constructible from a T&");
	static_assert(std::is_convertible_v<U, X>, "Must be able to convert u to remove_cv_t<T>");
	if (has_value()) {
	return *value_;
	}
	return std::forward<U>(u);

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 2061 to 2068 in 3108e69

	constexpr auto optional<T&>::and_then(F&& f) const {
	using U = std::invoke_result_t<F, T&>;
	static_assert(detail::is_optional<U>, "F must return an optional");
	if (has_value()) {
	return std::invoke(std::forward<F>(f), *value_);
	} else {
	return std::remove_cvref_t<U>();
	}

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 2078 to 2088 in 3108e69

	constexpr optional<std::invoke_result_t<F, T&>> optional<T&>::transform(F&& f) const {
	using U = std::invoke_result_t<F, T&>;
	static_assert(!std::is_same_v<std::remove_cvref_t<U>, in_place_t>, "Result must not be in_place_t");
	static_assert(!std::is_same_v<std::remove_cvref_t<U>, nullopt_t>, "Result must not be nullopt_t");
	static_assert((std::is_object_v<U> && !std::is_array_v<U>) || std::is_lvalue_reference_v<U>,
	"Result must be an non-array object or an lvalue reference");
	if (has_value()) {
	return optional<U>{detail::from_function, std::forward<F>(f), *value_};
	} else {
	return optional<U>{};
	}

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 2092 in 3108e69

* @brief Returns an optional containing the contained value if it has one, or the result of calling

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 2102 in 3108e69

constexpr optional<T&> optional<T&>::or_else(F&& f) const

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 2104 in 3108e69

requires (std::invocable<F>)

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 2106 to 2112 in 3108e69

	using U = std::invoke_result_t<F>;
	static_assert(std::is_same_v<std::remove_cvref_t<U>, optional>, "Result must be an optional");
	if (has_value()) {
	return *this;
	} else {
	return std::forward<F>(f)();
	}

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 2116 to 2118 in 3108e69

	template <class T>
	constexpr void optional<T&>::reset() noexcept {
	value_ = nullptr;

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 2124 to 2126 in 3108e69

	requires requires(T a) {
	{ std::hash<remove_const_t<T>>{}(a) } -> std::convertible_to<std::size_t>;
	}

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Lines 2128 to 2140 in 3108e69

	static_assert(!is_reference_v<T>, "hash is not enabled for reference types");
	/**
	* @brief Hashes the optional value.
	*
	* @param o
	* @return size_t
	*/
	size_t operator()(const beman::optional::optional<T>& o) const noexcept(noexcept(hash<remove_const_t<T>>{}(*o))) {
	if (o) {
	return std::hash<std::remove_const_t<T>>{}(*o);
	} else {
	return 0;
	}

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/include/beman/optional/optional.hpp

Line 2142 in 3108e69

};

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/tests/beman/inplace_vector/ref_impl.test.cpp

Line 781 in 3108e69

CHECK((uintptr_t)c.begin() == (uintptr_t)std::addressof(*c.try_emplace_back(2, 3.5)));

---

[pre-commit] _{reported by reviewdog 🐶}

inplace_vector/tests/beman/inplace_vector/ref_impl.test.cpp

Line 785 in 3108e69

CHECK((uintptr_t)(c.begin() + 1) == (uintptr_t)std::addressof(*c.try_emplace_back(3, 4.5)));

[JeffGarland]

it's weird that there's a detail include from optional here....

[JeffGarland]

so I think the issue here is we're introducing a dependence on beman optional -- is that right?

[redraincatching]

yes, the original issue suggested using beman optional so i decided to go along with that
there's every chance i've mishandled bringing int the dependency

[JeffGarland]

copy pasta?

[wusatosi]

Thank you for your contribution, please allow some time to review.

[coveralls]

coverage: 98.726% (+0.08%) from 98.649% — redraincatching:return-types into bemanproject:main