filter(P f) {\n return {std::move(f)};\n }\n\n /**\n * Returns maybe itself if maybe has value and the predicate returns true,\n * otherwise returns nullopt or nullptr (according to the type of maybe).\n *\n * @param maybe Maybe\n * @param predicate (&T) -> bool\n * @return Maybe\n */\n template\n Maybe filter(Maybe maybe, P predicate) requires requires {\n { predicate(*maybe) } -> std::same_as; } {\n if (maybe && predicate(*maybe)) { return maybe; }\n else { return detail::make_none();}\n }\n\n template\n auto operator|(Maybe maybe, detail::FilterPartial

&&partial) requires requires {\n { partial.predicate(*maybe) } -> std::same_as; } {\n if (maybe && partial.predicate(*maybe)) { return maybe; }\n else { return detail::make_none(); }\n }\n}\n\n// endregion\n\n// region deref.hpp\n\n\n\nnamespace maybe_ext::detail {\n struct DerefPartial {};\n}\n\nnamespace maybe_ext {\n inline detail::DerefPartial deref() {\n return {};\n }\n\n template\n decltype(auto) deref(Maybe &&maybe) {\n return *std::forward(maybe);\n }\n\n template\n decltype(auto) operator|(Maybe &&maybe, detail::DerefPartial &&) {\n return *std::forward(maybe);\n }\n}\n\n// endregion\n\n// region contains.hpp\n\n\n\nnamespace maybe_ext::detail {\n template\n struct ContainsPartial {\n const U &value;\n };\n}\n\nnamespace maybe_ext {\n template\n detail::ContainsPartial contains(const U &value) {\n return {value};\n }\n\n /** Returns true if maybe is not empty and contains the given value. */\n template\n bool contains(const Maybe &maybe, const U &value) requires requires {\n { *maybe == value } -> std::same_as; } {\n return maybe && (*maybe == value);\n }\n\n template\n bool operator|(const Maybe &maybe, detail::ContainsPartial &&partial) requires requires {\n { *maybe == partial.value } -> std::same_as; } {\n return maybe && (*maybe == partial.value);\n }\n}\n\n// endregion\n\n// region cloned.hpp\n\n\n#include \n\nnamespace maybe_ext::detail {\n struct ClonedPartial {};\n}\n\nnamespace maybe_ext {\n inline detail::ClonedPartial cloned() {\n return {};\n }\n\n template>>\n requires std::copy_constructible\n std::optional cloned(const Maybe &maybe) {\n return maybe ? std::optional(*maybe) : std::nullopt;\n }\n\n template>>\n requires std::copy_constructible\n std::optional operator|(const Maybe &maybe, detail::ClonedPartial &&) {\n return maybe ? std::optional(*maybe) : std::nullopt;\n }\n}\n\n// endregion\n\n// region as_unowned.hpp\n\n\n\nnamespace maybe_ext {\n template>\n T *as_unowned(Maybe &maybe) {\n return maybe ? std::addressof(*maybe) : nullptr;\n }\n}\n\n// endregion\n\n// region member_ptr_adaptor.hpp\n\n\n#include \n\nnamespace maybe_ext::detail {\n template\n auto method_ptr_adaptor(Method method) {\n return [method](T &&obj) -> decltype(auto) {\n return (std::forward(obj).*method)();\n };\n }\n\n template\n auto field_ptr_map_adaptor(Field field) {\n return [field](auto &&obj) -> auto & {\n return obj.*field;\n };\n }\n\n template\n auto field_ptr_and_then_adaptor(Field field) {\n return [field](auto &&obj) {\n static_assert(Nullable,\n \"This field is not a nullable type.\");\n return as_unowned(obj.*field);\n };\n }\n}\n\n// endregion\n\n// region map_or_else.hpp\n\n\n\nnamespace maybe_ext::detail {\n template\n struct MapOrElsePartial {\n D default_provider;\n F f;\n };\n\n template\n MapOrElsePartial(D, F) -> MapOrElsePartial;\n}\n\nnamespace maybe_ext {\n template\n detail::MapOrElsePartial map_or_else(D default_provider, F f) {\n return {std::move(default_provider), std::move(f)};\n }\n\n// template\n// auto map_or_else(D default_provider, MethodPtr method) {\n// return detail::MapOrElsePartial{\n// std::move(default_provider),\n// detail::method_ptr_adaptor(method)\n// };\n// }\n\n template\n auto map_or_else(D default_provider, FieldPtr field) {\n return detail::MapOrElsePartial{\n std::move(default_provider),\n detail::field_ptr_map_adaptor(field)\n };\n }\n\n template>>\n U map_or_else(Maybe &&maybe, D default_provider, F f)requires requires {\n { default_provider() } -> std::same_as;\n { f(*std::forward(maybe)) } -> std::convertible_to; } {\n return maybe ? static_cast(f(*std::forward(maybe)))\n : default_provider();\n }\n\n template>>\n U operator|(Maybe &&maybe, detail::MapOrElsePartial &&partial) requires requires {\n { partial.default_provider() } -> std::same_as;\n { partial.f(*std::forward(maybe)) } -> std::convertible_to; } {\n return maybe ? static_cast(partial.f(*std::forward(maybe)))\n : partial.default_provider();\n }\n}\n\nnamespace maybe_ext {\n template\n auto map_or_else(U default_provider, Ret (Class::*method)()) {\n return detail::MapOrElsePartial{\n std::move(default_provider),\n detail::method_ptr_adaptor(method)\n };\n }\n template\n auto map_or_else(U default_provider, Ret (Class::*method)() noexcept) {\n return detail::MapOrElsePartial{\n std::move(default_provider),\n detail::method_ptr_adaptor(method)\n };\n }\n template\n auto map_or_else(U default_provider, Ret (Class::*method)() &) {\n return detail::MapOrElsePartial{\n std::move(default_provider),\n detail::method_ptr_adaptor(method)\n };\n }\n template\n auto map_or_else(U default_provider, Ret (Class::*method)() & noexcept) {\n return detail::MapOrElsePartial{\n std::move(default_provider),\n detail::method_ptr_adaptor(method)\n };\n }\n\n template\n auto map_or_else(U default_provider, Ret (Class::*method)() const) {\n return detail::MapOrElsePartial{\n std::move(default_provider),\n detail::method_ptr_adaptor(method)\n };\n }\n template\n auto map_or_else(U default_provider, Ret (Class::*method)() const &) {\n return detail::MapOrElsePartial{\n std::move(default_provider),\n detail::method_ptr_adaptor(method)\n };\n }\n template\n auto map_or_else(U default_provider, Ret (Class::*method)() const noexcept) {\n return detail::MapOrElsePartial{\n std::move(default_provider),\n detail::method_ptr_adaptor(method)\n };\n }\n template\n auto map_or_else(U default_provider, Ret (Class::*method)() const & noexcept) {\n return detail::MapOrElsePartial{\n std::move(default_provider),\n detail::method_ptr_adaptor(method)\n };\n }\n\n template\n auto map_or_else(U default_provider, Ret (Class::*method)() &&) {\n return detail::MapOrElsePartial{\n std::move(default_provider),\n detail::method_ptr_adaptor(method)\n };\n }\n template\n auto map_or_else(U default_provider, Ret (Class::*method)() && noexcept) {\n return detail::MapOrElsePartial{\n std::move(default_provider),\n detail::method_ptr_adaptor(method)\n };\n }\n\n template\n auto map_or_else(U default_provider, Ret (Class::*method)() const &&) {\n return detail::MapOrElsePartial{\n std::move(default_provider),\n detail::method_ptr_adaptor(method)\n };\n }\n template\n auto map_or_else(U default_provider, Ret (Class::*method)() const && noexcept) {\n return detail::MapOrElsePartial{\n std::move(default_provider),\n detail::method_ptr_adaptor(method)\n };\n }\n}\n\n// endregion\n\n// region map_or.hpp\n\n\n\nnamespace maybe_ext::detail {\n template\n struct MapOrPartial {\n U default_value;\n F f;\n };\n\n template\n MapOrPartial(U, F) -> MapOrPartial;\n}\n\nnamespace maybe_ext {\n template\n detail::MapOrPartial map_or(U default_value, F f) {\n return {std::move(default_value), std::move(f)};\n }\n\n// template\n// auto map_or(U default_value, MethodPtr method) {\n// return detail::MapOrPartial{\n// std::move(default_value),\n// detail::method_ptr_adaptor(method)\n// };\n// }\n\n template\n auto map_or(U default_value, FieldPtr field) {\n return detail::MapOrPartial{\n std::move(default_value),\n detail::field_ptr_map_adaptor(field)\n };\n }\n\n /**\n * Returns the provided default value if maybe is empty,\n * else applies function f to the contained value.\n *\n * @param maybe Nullable\n * @param f (T) -> U or (&T) -> U\n * @return U\n */\n template\n U map(Maybe &&maybe, U default_value, F f) requires requires {\n { f(*std::forward(maybe)) } -> std::convertible_to; } {\n return maybe ? static_cast(f(*std::forward(maybe)))\n : std::move(default_value);\n }\n\n template\n U operator|(Maybe &&maybe, detail::MapOrPartial &&partial) requires requires {\n { partial.f(*std::forward(maybe)) } -> std::convertible_to; } {\n return maybe ? static_cast(partial.f(*std::forward(maybe)))\n : std::move(partial.default_value);\n }\n}\n\nnamespace maybe_ext {\n template\n auto map_or(U default_value, Ret (Class::*method)()) {\n return detail::MapOrPartial{\n std::move(default_value),\n detail::method_ptr_adaptor(method)\n };\n }\n template\n auto map_or(U default_value, Ret (Class::*method)() noexcept) {\n return detail::MapOrPartial{\n std::move(default_value),\n detail::method_ptr_adaptor(method)\n };\n }\n template\n auto map_or(U default_value, Ret (Class::*method)() &) {\n return detail::MapOrPartial{\n std::move(default_value),\n detail::method_ptr_adaptor(method)\n };\n }\n template\n auto map_or(U default_value, Ret (Class::*method)() & noexcept) {\n return detail::MapOrPartial{\n std::move(default_value),\n detail::method_ptr_adaptor(method)\n };\n }\n\n template\n auto map_or(U default_value, Ret (Class::*method)() const) {\n return detail::MapOrPartial{\n std::move(default_value),\n detail::method_ptr_adaptor(method)\n };\n }\n template\n auto map_or(U default_value, Ret (Class::*method)() const &) {\n return detail::MapOrPartial{\n std::move(default_value),\n detail::method_ptr_adaptor(method)\n };\n }\n template\n auto map_or(U default_value, Ret (Class::*method)() const noexcept) {\n return detail::MapOrPartial{\n std::move(default_value),\n detail::method_ptr_adaptor(method)\n };\n }\n template\n auto map_or(U default_value, Ret (Class::*method)() const & noexcept) {\n return detail::MapOrPartial{\n std::move(default_value),\n detail::method_ptr_adaptor(method)\n };\n }\n\n template\n auto map_or(U default_value, Ret (Class::*method)() &&) {\n return detail::MapOrPartial{\n std::move(default_value),\n detail::method_ptr_adaptor(method)\n };\n }\n template\n auto map_or(U default_value, Ret (Class::*method)() && noexcept) {\n return detail::MapOrPartial{\n std::move(default_value),\n detail::method_ptr_adaptor(method)\n };\n }\n\n template\n auto map_or(U default_value, Ret (Class::*method)() const &&) {\n return detail::MapOrPartial{\n std::move(default_value),\n detail::method_ptr_adaptor(method)\n };\n }\n template\n auto map_or(U default_value, Ret (Class::*method)() const && noexcept) {\n return detail::MapOrPartial{\n std::move(default_value),\n detail::method_ptr_adaptor(method)\n };\n }\n}\n\n// endregion\n\n// region map.hpp\n\n\n\nnamespace maybe_ext::detail {\n template\n struct MapPartial {\n F f;\n };\n\n template\n MapPartial(F) -> MapPartial;\n}\n\nnamespace maybe_ext {\n template\n detail::MapPartial map(F f) {\n return {std::move(f)};\n }\n\n// template\n// auto map(MethodPtr method) {\n// return detail::MapPartial{detail::method_ptr_adaptor(method)};\n// }\n\n template\n auto map(FieldPtr field) {\n return detail::MapPartial{detail::field_ptr_map_adaptor(field)};\n }\n\n /**\n * @param maybe Maybe\n * @param f (T) -> U or (&T) -> U, where U is not a lvalue reference.\n * That means the result of f is value semantic. We use std::optional to represent nullable values.\n * @return std::optional\n */\n template\n auto map(Maybe &&maybe, F f) requires requires {\n { f(*std::forward(maybe)) } -> detail::NotLValueRef; } {\n return maybe ? std::optional(f(*std::forward(maybe)))\n : std::nullopt;\n }\n\n template\n auto operator|(Maybe &&maybe, detail::MapPartial &&partial) requires requires {\n { partial.f(*std::forward(maybe)) } -> detail::NotLValueRef; } {\n return maybe ? std::optional(partial.f(*std::forward(maybe)))\n : std::nullopt;\n }\n\n /**\n * @param maybe Maybe\n * @param f (T) -> U& or (&T) -> U&, where U& is a lvalue reference.\n * That means the result of f is reference semantic. We use pointers to represent nullable references.\n * @return U*\n */\n template\n auto map(Maybe &&maybe, F f) requires requires {\n { f(*std::forward(maybe)) } -> detail::LValueRef; } {\n return maybe ? std::addressof(f(*std::forward(maybe)))\n : nullptr;\n }\n\n template\n auto operator|(Maybe &&maybe, detail::MapPartial &&partial) requires requires {\n { partial.f(*std::forward(maybe)) } -> detail::LValueRef; } {\n return maybe ? std::addressof(partial.f(*std::forward(maybe)))\n : nullptr;\n }\n}\n\nnamespace maybe_ext {\n template\n auto map(Ret (Class::*method)()) {\n return detail::MapPartial{\n detail::method_ptr_adaptor(method)\n };\n }\n template\n auto map(Ret (Class::*method)() noexcept) {\n return detail::MapPartial{\n detail::method_ptr_adaptor(method)\n };\n }\n template\n auto map(Ret (Class::*method)() &) {\n return detail::MapPartial{\n detail::method_ptr_adaptor(method)\n };\n }\n template\n auto map(Ret (Class::*method)() & noexcept) {\n return detail::MapPartial{\n detail::method_ptr_adaptor(method)\n };\n }\n\n template\n auto map(Ret (Class::*method)() const) {\n return detail::MapPartial{\n detail::method_ptr_adaptor(method)\n };\n }\n template\n auto map(Ret (Class::*method)() const &) {\n return detail::MapPartial{\n detail::method_ptr_adaptor(method)\n };\n }\n template\n auto map(Ret (Class::*method)() const noexcept) {\n return detail::MapPartial{\n detail::method_ptr_adaptor(method)\n };\n }\n template\n auto map(Ret (Class::*method)() const & noexcept) {\n return detail::MapPartial{\n detail::method_ptr_adaptor(method)\n };\n }\n\n template\n auto map(Ret (Class::*method)() &&) {\n return detail::MapPartial{\n detail::method_ptr_adaptor(method)\n };\n }\n template\n auto map(Ret (Class::*method)() && noexcept) {\n return detail::MapPartial{\n detail::method_ptr_adaptor(method)\n };\n }\n\n template\n auto map(Ret (Class::*method)() const &&) {\n return detail::MapPartial{\n detail::method_ptr_adaptor(method)\n };\n }\n template\n auto map(Ret (Class::*method)() const && noexcept) {\n return detail::MapPartial{\n detail::method_ptr_adaptor(method)\n };\n }\n}\n\n// endregion\n\n// region operator_bind.hpp\n\n\n\nnamespace maybe_ext::utils {\n template\n auto operator>>(Maybe &&maybe, F f) requires requires {\n { f(*std::forward(maybe)) } -> detail::Nullable;\n { f(*std::forward(maybe)) } -> detail::NotLValueRef; } {\n using Ret = decltype(f(*std::forward(maybe)));\n return maybe ? f(*std::forward(maybe))\n : detail::make_none();\n }\n\n template\n auto operator>>(Maybe &&maybe, F f) requires requires {\n { f(*std::forward(maybe)) } -> detail::Nullable;\n { f(*std::forward(maybe)) } -> detail::LValueRef; } {\n return maybe ? as_unowned(f(*std::forward(maybe)))\n : nullptr;\n }\n\n template\n auto operator>>(Maybe &&maybe, FieldPtr field) {\n return std::forward(maybe)\n >> detail::field_ptr_and_then_adaptor(field);\n }\n}\n\nnamespace maybe_ext::utils {\n template\n auto operator>>(Maybe &&maybe, Ret (Class::*method)()) {\n return std::forward(maybe)\n >> detail::method_ptr_adaptor(method);\n }\n template\n auto operator>>(Maybe &&maybe, Ret (Class::*method)() noexcept) {\n return std::forward(maybe)\n >> detail::method_ptr_adaptor(method);\n }\n template\n auto operator>>(Maybe &&maybe, Ret (Class::*method)() &) {\n return std::forward(maybe)\n >> detail::method_ptr_adaptor(method);\n }\n template\n auto operator>>(Maybe &&maybe, Ret (Class::*method)() & noexcept) {\n return std::forward(maybe)\n >> detail::method_ptr_adaptor(method);\n }\n\n template\n auto operator>>(Maybe &&maybe, Ret (Class::*method)() const) {\n return std::forward(maybe)\n >> detail::method_ptr_adaptor(method);\n }\n template\n auto operator>>(Maybe &&maybe, Ret (Class::*method)() const noexcept) {\n return std::forward(maybe)\n >> detail::method_ptr_adaptor(method);\n }\n template\n auto operator>>(Maybe &&maybe, Ret (Class::*method)() const &) {\n return std::forward(maybe)\n >> detail::method_ptr_adaptor(method);\n }\n template\n auto operator>>(Maybe &&maybe, Ret (Class::*method)() const & noexcept) {\n return std::forward(maybe)\n >> detail::method_ptr_adaptor(method);\n }\n\n template\n auto operator>>(Maybe &&maybe, Ret (Class::*method)() &&) {\n return std::forward(maybe)\n >> detail::method_ptr_adaptor(method);\n }\n template\n auto operator>>(Maybe &&maybe, Ret (Class::*method)() && noexcept) {\n return std::forward(maybe)\n >> detail::method_ptr_adaptor(method);\n }\n template\n auto operator>>(Maybe &&maybe, Ret (Class::*method)() const &&) {\n return std::forward(maybe)\n >> detail::method_ptr_adaptor(method);\n }\n template\n auto operator>>(Maybe &&maybe, Ret (Class::*method)() const && noexcept) {\n return std::forward(maybe)\n >> detail::method_ptr_adaptor(method);\n }\n}\n\n// endregion\n\n// region and_then.hpp\n\n\n\nnamespace maybe_ext::detail {\n template\n struct AndThenPartial {\n F f;\n };\n\n template\n AndThenPartial(F) -> AndThenPartial;\n}\n\nnamespace maybe_ext {\n template\n detail::AndThenPartial and_then(F f) {\n return {std::move(f)};\n }\n\n// template\n// auto and_then(MethodPtr method) {\n// return detail::AndThenPartial{\n// detail::method_ptr_adaptor(method)\n// };\n// }\n\n template\n auto and_then(FieldPtr field) {\n return detail::AndThenPartial{\n detail::field_ptr_and_then_adaptor(field)\n };\n }\n\n /**\n * Returns nullopt or nullptr (according to the type of maybe) if maybe is empty,\n * otherwise calls f with the wrapped default_value and returns the result.\n *

\n * This operation is also known as flatmap in other languages.\n *\n * @param maybe Maybe\n * @param f (T) -> Maybe or (T&) -> Maybe\n * @return Maybe\n */\n template\n auto and_then(Maybe &&maybe, F f) requires requires {\n { f(*std::forward(maybe)) } -> detail::Nullable;\n { f(*std::forward(maybe)) } -> detail::NotLValueRef; } {\n using Ret = decltype(f(*std::forward(maybe)));\n return maybe ? f(*std::forward(maybe))\n : detail::make_none();\n }\n\n template\n auto operator|(Maybe &&maybe, detail::AndThenPartial &&partial) requires requires {\n { partial.f(*std::forward(maybe)) } -> detail::Nullable;\n { partial.f(*std::forward(maybe)) } -> detail::NotLValueRef; } {\n using Ret = decltype(partial.f(*std::forward(maybe)));\n return maybe ? partial.f(*std::forward(maybe))\n : detail::make_none();\n }\n\n template\n auto and_then(Maybe &&maybe, F f) requires requires {\n { f(*std::forward(maybe)) } -> detail::Nullable;\n { f(*std::forward(maybe)) } -> detail::LValueRef; } {\n return maybe ? as_unowned(f(*std::forward(maybe)))\n : nullptr;\n }\n\n template\n auto operator|(Maybe &&maybe, detail::AndThenPartial &&partial) requires requires {\n { partial.f(*std::forward(maybe)) } -> detail::Nullable;\n { partial.f(*std::forward(maybe)) } -> detail::LValueRef; } {\n return maybe ? as_unowned(partial.f(*std::forward(maybe)))\n : nullptr;\n }\n}\n\nnamespace maybe_ext {\n template\n auto and_then(Ret (Class::*method)()) {\n return detail::AndThenPartial{\n detail::method_ptr_adaptor(method)\n };\n }\n template\n auto and_then(Ret (Class::*method)() noexcept) {\n return detail::AndThenPartial{\n detail::method_ptr_adaptor(method)\n };\n }\n template\n auto and_then(Ret (Class::*method)() &) {\n return detail::AndThenPartial{\n detail::method_ptr_adaptor(method)\n };\n }\n template\n auto and_then(Ret (Class::*method)() & noexcept) {\n return detail::AndThenPartial{\n detail::method_ptr_adaptor(method)\n };\n }\n\n template\n auto and_then(Ret (Class::*method)() const) {\n return detail::AndThenPartial{\n detail::method_ptr_adaptor(method)\n };\n }\n template\n auto and_then(Ret (Class::*method)() const &) {\n return detail::AndThenPartial{\n detail::method_ptr_adaptor(method)\n };\n }\n template\n auto and_then(Ret (Class::*method)() const noexcept) {\n return detail::AndThenPartial{\n detail::method_ptr_adaptor(method)\n };\n }\n template\n auto and_then(Ret (Class::*method)() const & noexcept) {\n return detail::AndThenPartial{\n detail::method_ptr_adaptor(method)\n };\n }\n\n template\n auto and_then(Ret (Class::*method)() &&) {\n return detail::AndThenPartial{\n detail::method_ptr_adaptor(method)\n };\n }\n template\n auto and_then(Ret (Class::*method)() && noexcept) {\n return detail::AndThenPartial{\n detail::method_ptr_adaptor(method)\n };\n }\n\n template\n auto and_then(Ret (Class::*method)() const &&) {\n return detail::AndThenPartial{\n detail::method_ptr_adaptor(method)\n };\n }\n template\n auto and_then(Ret (Class::*method)() const && noexcept) {\n return detail::AndThenPartial{\n detail::method_ptr_adaptor(method)\n };\n }\n}\n\n// endregion\n\n// region and.hpp\n\n\n\nnamespace maybe_ext::detail {\n template\n struct AndPartial {\n Maybe b;\n };\n}\n\nnamespace maybe_ext {\n template\n detail::AndPartial and_(Maybe b) {\n return {std::move(b)};\n }\n\n /** Returns nullopt or nullptr (according to the type of b) if a is empty, otherwise returns b. */\n template\n MaybeB and_(const MaybeA &a, MaybeB b) {\n if (!a) { return detail::make_none(); }\n else { return b; }\n }\n\n template\n MaybeB operator|(const MaybeA &a, detail::AndPartial &&partial) {\n if (!a) { return detail::make_none(); }\n else { return std::move(partial.b); }\n }\n}\n\n// endregion\n\n#endif\n","stdin","compiler","warning,optimize,boost-nothing-clang-head,c++2b,cpp-pedantic","createdAt",1640902137,"title","description","isPrivate","compilerInfo",{"_11":888,"_13":3402,"_15":333,"_17":737,"_19":3403,"_22":23,"_24":25,"_26":890,"_28":3404},"13.0.0 (https://github.com/llvm/llvm-project.git c4ed142e695f14ba5675ec6d12226ee706329a0f)",[767],[3405,3407,3409,3411,3475,3480,3485,3501],{"_31":32,"_33":3406},{"_11":35,"_36":23,"_37":38,"_17":39},{"_31":32,"_33":3408},{"_11":42,"_36":25,"_37":43,"_17":44},{"_31":32,"_33":3410},{"_11":47,"_36":25,"_37":48,"_17":49},{"_31":51,"_33":3412},{"_11":900,"_36":3413,"_55":3414},"boost-1.73.0-clang-head",[3415,3416,3420,3424,3428,3432,3436,3440,3444,3448,3452,3456,3460,3464,3468,3472],{"_11":901,"_37":59,"_17":330},{"_11":3417,"_37":3418,"_17":3419},"boost-1.60.0-clang-head","-I/opt/wandbox/boost-1.60.0/clang-head/include","Boost 1.60.0",{"_11":3421,"_37":3422,"_17":3423},"boost-1.61.0-clang-head","-I/opt/wandbox/boost-1.61.0/clang-head/include","Boost 1.61.0",{"_11":3425,"_37":3426,"_17":3427},"boost-1.62.0-clang-head","-I/opt/wandbox/boost-1.62.0/clang-head/include","Boost 1.62.0",{"_11":3429,"_37":3430,"_17":3431},"boost-1.63.0-clang-head","-I/opt/wandbox/boost-1.63.0/clang-head/include","Boost 1.63.0",{"_11":3433,"_37":3434,"_17":3435},"boost-1.64.0-clang-head","-I/opt/wandbox/boost-1.64.0/clang-head/include","Boost 1.64.0",{"_11":3437,"_37":3438,"_17":3439},"boost-1.65.0-clang-head","-I/opt/wandbox/boost-1.65.0/clang-head/include","Boost 1.65.0",{"_11":3441,"_37":3442,"_17":3443},"boost-1.65.1-clang-head","-I/opt/wandbox/boost-1.65.1/clang-head/include","Boost 1.65.1",{"_11":3445,"_37":3446,"_17":3447},"boost-1.66.0-clang-head","-I/opt/wandbox/boost-1.66.0/clang-head/include","Boost 1.66.0",{"_11":3449,"_37":3450,"_17":3451},"boost-1.67.0-clang-head","-I/opt/wandbox/boost-1.67.0/clang-head/include","Boost 1.67.0",{"_11":3453,"_37":3454,"_17":3455},"boost-1.68.0-clang-head","-I/opt/wandbox/boost-1.68.0/clang-head/include","Boost 1.68.0",{"_11":3457,"_37":3458,"_17":3459},"boost-1.69.0-clang-head","-I/opt/wandbox/boost-1.69.0/clang-head/include","Boost 1.69.0",{"_11":3461,"_37":3462,"_17":3463},"boost-1.70.0-clang-head","-I/opt/wandbox/boost-1.70.0/clang-head/include","Boost 1.70.0",{"_11":3465,"_37":3466,"_17":3467},"boost-1.71.0-clang-head","-I/opt/wandbox/boost-1.71.0/clang-head/include","Boost 1.71.0",{"_11":3469,"_37":3470,"_17":3471},"boost-1.72.0-clang-head","-I/opt/wandbox/boost-1.72.0/clang-head/include","Boost 1.72.0",{"_11":3413,"_37":3473,"_17":3474},"-I/opt/wandbox/boost-1.73.0/clang-head/include","Boost 1.73.0",{"_31":32,"_33":3476},{"_11":3477,"_36":25,"_37":3478,"_17":3479},"sprout","-I/opt/wandbox/sprout","Sprout",{"_31":32,"_33":3481},{"_11":3482,"_36":25,"_37":3483,"_17":3484},"msgpack","-I/opt/wandbox/msgpack/include","MessagePack",{"_31":51,"_33":3486},{"_11":351,"_36":352,"_55":3487},[3488,3489,3490,3491,3492,3493,3494,3495,3496,3497,3498,3499,3500],{"_11":355,"_37":59,"_17":60},{"_11":357,"_37":358,"_17":359},{"_11":361,"_37":362,"_17":363},{"_11":365,"_37":366,"_17":367},{"_11":369,"_37":370,"_17":371},{"_11":373,"_37":374,"_17":375},{"_11":377,"_37":378,"_17":379},{"_11":381,"_37":382,"_17":383},{"_11":385,"_37":386,"_17":387},{"_11":389,"_37":390,"_17":391},{"_11":393,"_37":394,"_17":395},{"_11":397,"_37":398,"_17":399},{"_11":352,"_37":401,"_17":402},{"_31":51,"_33":3502},{"_11":86,"_36":87,"_55":3503},[3504,3505,3506],{"_11":87,"_37":59,"_17":90},{"_11":86,"_37":92,"_17":92},{"_11":94,"_37":95,"_17":95},"results",[3509,3513,3516,3519],{"_31":3510,"_3511":3512},"Control","data","Start",{"_31":3514,"_3511":3515},"StdOut","optional(3)\nnullopt\nnullopt\nnullopt\n",{"_31":3517,"_3511":3518},"ExitCode","0",{"_31":3510,"_3511":3520},"Finish","hpplib",[3523,3538,3549,3558,3567,3576,3585,3594,3604,3613,3624,3635,3646,3657,3666,3677],{"_11":3524,"_3525":3526,"_3398":3527,"_3528":3529,"_3530":3531,"_3536":3537},"CLI11","repository","CLIUtils/CLI11","CLI11 is a command line parser for C++11 and beyond that provides a rich feature set with a simple and intuitive interface.","headerDescription","","wandbox",{"_3532":3533,"_3534":3535},"tagName","v2.5.0","publishedAt","2025-02-27T12:29:12Z","clangd",{"_3532":3533,"_3534":3535},{"_11":3539,"_3525":3540,"_3398":3541,"_3528":3542,"_3530":3543,"_3536":3546},"cxxopts","jarro2783/cxxopts","Lightweight C++ command line option parser","",{"_3532":3544,"_3534":3545},"v3.3.1","2025-05-26T08:12:04Z",{"_3532":3547,"_3534":3548},"v3.2.0","2024-02-15T05:32:43Z",{"_11":3550,"_3525":3551,"_3398":3552,"_3528":3553,"_3530":3554,"_3536":3557},"nanobench","martinus/nanobench","Simple, fast, accurate single-header microbenchmarking functionality for C++11/14/17/20","",{"_3532":3555,"_3534":3556},"v4.3.11","2023-02-16T19:06:26Z",{"_3532":3555,"_3534":3556},{"_11":3559,"_3525":3560,"_3398":3561,"_3528":3562,"_3530":3563,"_3536":3566},"toml11","ToruNiina/toml11","TOML for Modern C++","",{"_3532":3564,"_3534":3565},"v4.4.0","2025-02-15T16:20:52Z",{"_3532":3564,"_3534":3565},{"_11":3568,"_3525":3569,"_3398":3570,"_3528":3571,"_3530":3572,"_3536":3575},"toml++","marzer/tomlplusplus","Header-only TOML config file parser and serializer for C++17.","",{"_3532":3573,"_3534":3574},"v3.4.0","2023-10-13T13:45:17Z",{"_3532":3573,"_3534":3574},{"_11":3577,"_3525":3578,"_3398":3579,"_3528":3580,"_3530":3581,"_3536":3584},"rapidjson","Tencent/rapidjson","A fast JSON parser/generator for C++ with both SAX/DOM style API","",{"_3532":3582,"_3534":3583},"v1.1.0","2016-08-25T08:01:22Z",{"_3532":3582,"_3534":3583},{"_11":3586,"_3525":3587,"_3398":3588,"_3528":3589,"_3530":3590,"_3536":3593},"picojson","kazuho/picojson","a header-file-only, JSON parser serializer in C++","",{"_3532":3591,"_3534":3592},"v1.3.0","2015-02-25T04:12:53Z",{"_3532":3591,"_3534":3592},{"_11":3595,"_3525":3595,"_3398":3596,"_3528":3597,"_3530":3598,"_3536":3601},"nlohmann/json","JSON for Modern C++","",{"_3532":3599,"_3534":3600},"v3.12.0","2025-04-11T08:43:39Z",{"_3532":3602,"_3534":3603},"v3.11.3","2023-11-28T21:38:09Z",{"_11":3605,"_3525":3606,"_3398":3607,"_3528":3608,"_3530":3609,"_3536":3612},"csv-parser","vincentlaucsb/csv-parser","A high-performance, fully-featured CSV parser and serializer for modern C++.","",{"_3532":3610,"_3534":3611},"2.3.0","2024-06-15T20:23:18Z",{"_3532":3610,"_3534":3611},{"_11":3614,"_3525":3615,"_3398":3616,"_3528":3617,"_3530":3618,"_3536":3621},"rapidcsv","d99kris/rapidcsv","C++ CSV parser library","",{"_3532":3619,"_3534":3620},"v8.87","2025-05-17T05:37:53Z",{"_3532":3622,"_3534":3623},"v8.84","2024-09-28T05:31:16Z",{"_11":3625,"_3525":3626,"_3398":3627,"_3528":3628,"_3530":3629,"_3536":3632},"fmt","fmtlib/fmt","A modern formatting library","",{"_3532":3630,"_3534":3631},"11.2.0","2025-05-03T16:40:00Z",{"_3532":3633,"_3534":3634},"11.1.4","2025-02-26T18:33:33Z",{"_11":3636,"_3525":3637,"_3398":3638,"_3528":3639,"_3530":3640,"_3536":3643},"NumCpp","dpilger26/NumCpp","C++ implementation of the Python Numpy library","",{"_3532":3641,"_3534":3642},"Version_2.14.1","2025-05-05T03:42:56Z",{"_3532":3644,"_3534":3645},"Version_2.14.0","2025-02-09T04:16:30Z",{"_11":3647,"_3525":3648,"_3398":3649,"_3528":3650,"_3530":3651,"_3536":3654},"spdlog","gabime/spdlog","Fast C++ logging library.","",{"_3532":3652,"_3534":3653},"v1.15.3","2025-05-09T08:59:29Z",{"_3532":3655,"_3534":3656},"v1.15.1","2025-02-01T12:08:58Z",{"_11":3658,"_3525":3659,"_3398":3660,"_3528":3661,"_3530":3662,"_3536":3665},"expected-lite","martinmoene/expected-lite","expected lite - Expected objects in C++11 and later in a single-file header-only library","",{"_3532":3663,"_3534":3664},"v0.8.0","2024-06-05T21:24:45Z",{"_3532":3663,"_3534":3664},{"_11":3667,"_3525":3668,"_3398":3669,"_3528":3670,"_3530":3671,"_3536":3674},"gsl-lite","gsl-lite/gsl-lite","ISO C++ Core Guidelines Library implementation for C++98, C++11 up","",{"_3532":3672,"_3534":3673},"v1.0.1","2025-05-19T21:18:08Z",{"_3532":3675,"_3534":3676},"v0.42.0","2024-11-01T20:24:11Z",{"_11":3678,"_3525":3679,"_3398":3680,"_3528":3681,"_3530":3682,"_3536":3685},"ut","boost-ext/ut","C++20 μ(micro)/Unit Testing framework","",{"_3532":3683,"_3534":3684},"v2.3.1","2025-04-02T13:02:52Z",{"_3532":3686,"_3534":3687},"v2.3.0","2025-02-04T11:58:39Z","env",{"_3690":3691,"_3692":3693,"_3694":3695,"_3696":3697,"_3698":3699,"_3700":3701,"_3702":3703,"_3704":3705,"_3706":3707},"KV_CACHE",{},"KV_SESSION",{},"R2_BUCKET",{},"WANDBOX_GITHUB_CLIENT_ID","f9d429d939d997e6b08e","WANDBOX_GITHUB_CLIENT_SECRET","d99b3d12225671cde514d9e2b3d5cc8356f4ed5f","WANDBOX_KV_COOKIE_SECRET","FaCnykHoYzqiXReGkgvmcYGvQdQ4yZUE","WANDBOX_R2_PREFIX","master/","WANDBOX_URL_PREFIX","https://api.wandbox.org","ASSETS",{},"root","actionData","errors"]