FM / fwd

/usr/include/boost/hana/fwd

Name	Size	Mode	Actions
concept/	-	0755	rm
core/	-	0755	rm
accessors.hpp	1519	0644	edit dl rm
adapt_adt.hpp	1596	0644	edit dl rm
adapt_struct.hpp	1586	0644	edit dl rm
adjust.hpp	1787	0644	edit dl rm
adjust_if.hpp	2275	0644	edit dl rm
all.hpp	1185	0644	edit dl rm
all_of.hpp	1476	0644	edit dl rm
and.hpp	1441	0644	edit dl rm
any.hpp	1178	0644	edit dl rm
any_of.hpp	1445	0644	edit dl rm
ap.hpp	2649	0644	edit dl rm
append.hpp	2044	0644	edit dl rm
at.hpp	2824	0644	edit dl rm
at_key.hpp	2334	0644	edit dl rm
back.hpp	1355	0644	edit dl rm
basic_tuple.hpp	2292	0644	edit dl rm
bool.hpp	384	0644	edit dl rm
cartesian_product.hpp	1837	0644	edit dl rm
chain.hpp	1964	0644	edit dl rm
comparing.hpp	1924	0644	edit dl rm
concat.hpp	1838	0644	edit dl rm
contains.hpp	2378	0644	edit dl rm
core.hpp	619	0644	edit dl rm
count.hpp	1683	0644	edit dl rm
count_if.hpp	1634	0644	edit dl rm
cycle.hpp	2460	0644	edit dl rm
define_struct.hpp	1582	0644	edit dl rm
difference.hpp	854	0644	edit dl rm
div.hpp	1772	0644	edit dl rm
drop_back.hpp	2016	0644	edit dl rm
drop_front.hpp	2268	0644	edit dl rm
drop_front_exactly.hpp	2409	0644	edit dl rm
drop_while.hpp	2047	0644	edit dl rm
duplicate.hpp	1574	0644	edit dl rm
empty.hpp	1306	0644	edit dl rm
equal.hpp	2584	0644	edit dl rm
erase_key.hpp	876	0644	edit dl rm
eval.hpp	2012	0644	edit dl rm
eval_if.hpp	6453	0644	edit dl rm
extend.hpp	1733	0644	edit dl rm
extract.hpp	1547	0644	edit dl rm
fill.hpp	1412	0644	edit dl rm
filter.hpp	2600	0644	edit dl rm
find.hpp	1778	0644	edit dl rm
find_if.hpp	1734	0644	edit dl rm
first.hpp	1470	0644	edit dl rm
flatten.hpp	1727	0644	edit dl rm
fold.hpp	1066	0644	edit dl rm
fold_left.hpp	3004	0644	edit dl rm
fold_right.hpp	3193	0644	edit dl rm
for_each.hpp	1513	0644	edit dl rm
front.hpp	1401	0644	edit dl rm
fuse.hpp	1580	0644	edit dl rm
greater.hpp	1464	0644	edit dl rm
greater_equal.hpp	1563	0644	edit dl rm
group.hpp	3872	0644	edit dl rm
hash.hpp	2158	0644	edit dl rm
if.hpp	1651	0644	edit dl rm
index_if.hpp	1846	0644	edit dl rm
insert.hpp	1695	0644	edit dl rm
insert_range.hpp	1778	0644	edit dl rm
integral_constant.hpp	4791	0644	edit dl rm
intersection.hpp	872	0644	edit dl rm
intersperse.hpp	1780	0644	edit dl rm
is_disjoint.hpp	1445	0644	edit dl rm
is_empty.hpp	1453	0644	edit dl rm
is_subset.hpp	2800	0644	edit dl rm
keys.hpp	1338	0644	edit dl rm
lazy.hpp	4593	0644	edit dl rm
length.hpp	1415	0644	edit dl rm
less.hpp	1394	0644	edit dl rm
less_equal.hpp	1493	0644	edit dl rm
lexicographical_compare.hpp	3819	0644	edit dl rm
lift.hpp	1686	0644	edit dl rm
map.hpp	13142	0644	edit dl rm
max.hpp	1150	0644	edit dl rm
maximum.hpp	4344	0644	edit dl rm
members.hpp	1256	0644	edit dl rm
min.hpp	1525	0644	edit dl rm
minimum.hpp	4334	0644	edit dl rm
minus.hpp	2101	0644	edit dl rm
mod.hpp	1970	0644	edit dl rm
monadic_compose.hpp	2296	0644	edit dl rm
monadic_fold_left.hpp	4016	0644	edit dl rm
monadic_fold_right.hpp	4174	0644	edit dl rm
mult.hpp	1933	0644	edit dl rm
negate.hpp	1022	0644	edit dl rm
none.hpp	1217	0644	edit dl rm
none_of.hpp	1498	0644	edit dl rm
not.hpp	1220	0644	edit dl rm
not_equal.hpp	2115	0644	edit dl rm
one.hpp	1116	0644	edit dl rm
optional.hpp	18788	0644	edit dl rm
or.hpp	1426	0644	edit dl rm
ordering.hpp	1902	0644	edit dl rm
pair.hpp	5768	0644	edit dl rm
partition.hpp	2731	0644	edit dl rm
permutations.hpp	1563	0644	edit dl rm
plus.hpp	1944	0644	edit dl rm
power.hpp	1560	0644	edit dl rm
prefix.hpp	2097	0644	edit dl rm
prepend.hpp	2415	0644	edit dl rm
product.hpp	2636	0644	edit dl rm
range.hpp	5480	0644	edit dl rm
remove.hpp	2177	0644	edit dl rm
remove_at.hpp	2371	0644	edit dl rm
remove_if.hpp	2155	0644	edit dl rm
remove_range.hpp	2745	0644	edit dl rm
repeat.hpp	1624	0644	edit dl rm
replace.hpp	1842	0644	edit dl rm
replace_if.hpp	1853	0644	edit dl rm
replicate.hpp	2511	0644	edit dl rm
reverse.hpp	1187	0644	edit dl rm
reverse_fold.hpp	2886	0644	edit dl rm
scan_left.hpp	3712	0644	edit dl rm
scan_right.hpp	3811	0644	edit dl rm
second.hpp	1477	0644	edit dl rm
set.hpp	9981	0644	edit dl rm
size.hpp	929	0644	edit dl rm
slice.hpp	3524	0644	edit dl rm
sort.hpp	3770	0644	edit dl rm
span.hpp	2858	0644	edit dl rm
string.hpp	10794	0644	edit dl rm
suffix.hpp	2081	0644	edit dl rm
sum.hpp	3253	0644	edit dl rm
symmetric_difference.hpp	944	0644	edit dl rm
take_back.hpp	2178	0644	edit dl rm
take_front.hpp	2231	0644	edit dl rm
take_while.hpp	1692	0644	edit dl rm
tap.hpp	2183	0644	edit dl rm
then.hpp	1420	0644	edit dl rm
transform.hpp	1467	0644	edit dl rm
tuple.hpp	8554	0644	edit dl rm
type.hpp	19848	0644	edit dl rm
unfold_left.hpp	2546	0644	edit dl rm
unfold_right.hpp	2569	0644	edit dl rm
union.hpp	811	0644	edit dl rm
unique.hpp	3337	0644	edit dl rm
unpack.hpp	3560	0644	edit dl rm
value.hpp	3159	0644	edit dl rm
while.hpp	2432	0644	edit dl rm
zero.hpp	1095	0644	edit dl rm
zip.hpp	1918	0644	edit dl rm
zip_shortest.hpp	2039	0644	edit dl rm
zip_shortest_with.hpp	2163	0644	edit dl rm
zip_with.hpp	2042	0644	edit dl rm

Edit: /usr/include/boost/hana/fwd/optional.hpp (18788B)

/*!
@file
Forward declares `boost::hana::optional`.

@copyright Louis Dionne 2013-2017
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
 */

#ifndef BOOST_HANA_FWD_OPTIONAL_HPP
#define BOOST_HANA_FWD_OPTIONAL_HPP

#include <boost/hana/config.hpp>
#include <boost/hana/detail/operators/adl.hpp>
#include <boost/hana/fwd/core/make.hpp>

BOOST_HANA_NAMESPACE_BEGIN
    //! @ingroup group-datatypes
    //! Optional value whose optional-ness is known at compile-time.
    //!
    //! An `optional` either contains a value (represented as `just(x)`), or
    //! it is empty (represented as `nothing`). In essence, `hana::optional`
    //! is pretty much like a `boost::optional` or the upcoming `std::optional`,
    //! except for the fact that whether a `hana::optional` is empty or not is
    //! known at compile-time. This can be particularly useful for returning
    //! from a function that might fail, but whose reason for failing is not
    //! important. Of course, whether the function will fail has to be known
    //! at compile-time.
    //!
    //! This is really an important difference between `hana::optional` and
    //! `std::optional`. Unlike `std::optional<T>{}` and `std::optional<T>{x}`
    //! who share the same type (`std::optional<T>`), `hana::just(x)` and
    //! `hana::nothing` do not share the same type, since the state of the
    //! optional has to be known at compile-time. Hence, whether a `hana::just`
    //! or a `hana::nothing` will be returned from a function has to be known
    //! at compile-time for the return type of that function to be computable
    //! by the compiler. This makes `hana::optional` well suited for static
    //! metaprogramming tasks, but very poor for anything dynamic.
    //!
    //! @note
    //! When you use a container, remember not to make assumptions about its
    //! representation, unless the documentation gives you those guarantees.
    //! More details [in the tutorial](@ref tutorial-containers-types).
    //!
    //!
    //! Interoperation with `type`s
    //! ---------------------------
    //! When a `just` contains an object of type `T` which is a `type`,
    //! it has a nested `::%type` alias equivalent to `T::%type`. `nothing`,
    //! however, never has a nested `::%type` alias. If `t` is a `type`,
    //! this allows `decltype(just(t))` to be seen as a nullary metafunction
    //! equivalent to `decltype(t)`. Along with the `sfinae` function,
    //! this allows `hana::optional` to interact seamlessly with
    //! SFINAE-friendly metafunctions.
    //! Example:
    //! @include example/optional/sfinae_friendly_metafunctions.cpp
    //!
    //!
    //! Modeled concepts
    //! ----------------
    //! 1. `Comparable`\n
    //! Two `optional`s are equal if and only if they are both empty or they
    //! both contain a value and those values are equal.
    //! @include example/optional/comparable.cpp
    //!
    //! 2. `Orderable`\n
    //! Optional values can be ordered by considering the value they are
    //! holding, if any. To handle the case of an empty optional value, we
    //! arbitrarily set `nothing` as being less than any other `just`. Hence,
    //! @code
    //!     just(x) < just(y) if and only if x < y
    //!     nothing < just(anything)
    //! @endcode
    //! Example:
    //! @include example/optional/orderable.cpp
    //!
    //! 3. `Functor`\n
    //! An optional value can be seen as a list containing either one element
    //! (`just(x)`) or no elements at all (`nothing`). As such, mapping
    //! a function over an optional value is equivalent to applying it to
    //! its value if there is one, and to `nothing` otherwise:
    //! @code
    //!     transform(just(x), f) == just(f(x))
    //!     transform(nothing, f) == nothing
    //! @endcode
    //! Example:
    //! @include example/optional/functor.cpp
    //!
    //! 4. `Applicative`\n
    //! First, a value can be made optional with `lift<optional_tag>`, which
    //! is equivalent to `just`. Second, one can feed an optional value to an
    //! optional function with `ap`, which will return `just(f(x))` if there
    //! is both a function _and_ a value, and `nothing` otherwise:
    //! @code
    //!     ap(just(f), just(x)) == just(f(x))
    //!     ap(nothing, just(x)) == nothing
    //!     ap(just(f), nothing) == nothing
    //!     ap(nothing, nothing) == nothing
    //! @endcode
    //! A simple example:
    //! @include example/optional/applicative.cpp
    //! A more complex example:
    //! @include example/optional/applicative.complex.cpp
    //!
    //! 5. `Monad`\n
    //! The `Monad` model makes it easy to compose actions that might fail.
    //! One can feed an optional value if there is one into a function with
    //! `chain`, which will return `nothing` if there is no value. Finally,
    //! optional-optional values can have their redundant level of optionality
    //! removed with `flatten`. Also note that the `|` operator can be used in
    //! place of the `chain` function.
    //! Example:
    //! @include example/optional/monad.cpp
    //!
    //! 6. `MonadPlus`\n
    //! The `MonadPlus` model allows choosing the first valid value out of
    //! two optional values with `concat`. If both optional values are
    //! `nothing`s, `concat` will return `nothing`.
    //! Example:
    //! @include example/optional/monad_plus.cpp
    //!
    //! 7. `Foldable`\n
    //! Folding an optional value is equivalent to folding a list containing
    //! either no elements (for `nothing`) or `x` (for `just(x)`).
    //! Example:
    //! @include example/optional/foldable.cpp
    //!
    //! 8. `Searchable`\n
    //! Searching an optional value is equivalent to searching a list
    //! containing `x` for `just(x)` and an empty list for `nothing`.
    //! Example:
    //! @include example/optional/searchable.cpp
#ifdef BOOST_HANA_DOXYGEN_INVOKED
    template <typename ...T>
    struct optional {
        // 5.3.1, Constructors

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

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

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

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

//! Construct an `optional` holding a value of type `T` from another
        //! object of type `T`. The value is move-constructed.
        constexpr optional(T&& t)
            : value_(static_cast<T&&>(t))
        { }

// 5.3.3, Assignment

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

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

// 5.3.5, Observers

//! Returns a pointer to the contained value, or a `nullptr` if the
        //! `optional` is empty.
        //!
        //!
        //! @note Overloads of this method are provided for both the `const`
        //! and the non-`const` cases.
        //!
        //!
        //! Example
        //! -------
        //! @include example/optional/value.cpp
        constexpr T* operator->();

//! Extract the content of an `optional`, or fail at compile-time.
        //!
        //! If `*this` contains a value, that value is returned. Otherwise,
        //! a static assertion is triggered.
        //!
        //! @note
        //! Overloads of this method are provided for the cases where `*this`
        //! is a reference, a rvalue-reference and their `const` counterparts.
        //!
        //!
        //! Example
        //! -------
        //! @include example/optional/value.cpp
        constexpr T& value();

//! Equivalent to `value()`, provided for convenience.
        //!
        //! @note
        //! Overloads of this method are provided for the cases where `*this`
        //! is a reference, a rvalue-reference and their `const` counterparts.
        //!
        //!
        //! Example
        //! -------
        //! @include example/optional/value.cpp
        constexpr T& operator*();

//! Return the contents of an `optional`, with a fallback result.
        //!
        //! If `*this` contains a value, that value is returned. Otherwise,
        //! the default value provided is returned.
        //!
        //! @note
        //! Overloads of this method are provided for the cases where `*this`
        //! is a reference, a rvalue-reference and their `const` counterparts.
        //!
        //!
        //! @param default_
        //! The default value to return if `*this` does not contain a value.
        //!
        //!
        //! Example
        //! -------
        //! @include example/optional/value_or.cpp
        template <typename U>
        constexpr decltype(auto) value_or(U&& default_);

//! Equivalent to `hana::chain`.
        template <typename ...T, typename F>
        friend constexpr auto operator|(optional<T...>, F);

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

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

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

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

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

//! Equivalent to `hana::greater_equal`
        template <typename X, typename Y>
        friend constexpr auto operator>=(X&& x, Y&& y);
    };
#else
    template <typename ...T>
    struct optional;
#endif

//! Tag representing a `hana::optional`.
    //! @relates hana::optional
    struct optional_tag { };

//! Create an optional value.
    //! @relates hana::optional
    //!
    //! Specifically, `make<optional_tag>()` is equivalent to `nothing`, and
    //! `make<optional_tag>(x)` is equivalent to `just(x)`. This is provided
    //! for consistency with the other `make<...>` functions.
    //!
    //!
    //! Example
    //! -------
    //! @include example/optional/make.cpp
#ifdef BOOST_HANA_DOXYGEN_INVOKED
    template <>
    constexpr auto make<optional_tag> = []([auto&& x]) {
        return optional<std::decay<decltype(x)>::type>{forwarded(x)};
    };
#endif

//! Alias to `make<optional_tag>`; provided for convenience.
    //! @relates hana::optional
    //!
    //!
    //! Example
    //! -------
    //! @include example/optional/make.cpp
    constexpr auto make_optional = make<optional_tag>;

//! Create an optional value containing `x`.
    //! @relates hana::optional
    //!
    //!
    //! Example
    //! -------
    //! @include example/optional/just.cpp
#ifdef BOOST_HANA_DOXYGEN_INVOKED
    constexpr auto just = [](auto&& x) {
        return optional<std::decay<decltype(x)>::type>{forwarded(x)};
    };
#else
    struct make_just_t {
        template <typename T>
        constexpr auto operator()(T&&) const;
    };

constexpr make_just_t just{};
#endif

//! An empty optional value.
    //! @relates hana::optional
    //!
    //!
    //! Example
    //! -------
    //! @include example/optional/nothing.cpp
#ifdef BOOST_HANA_DOXYGEN_INVOKED
    constexpr optional<> nothing{};
#else
    template <>
    struct optional<> : detail::operators::adl<optional<>> {
        // 5.3.1, Constructors
        constexpr optional() = default;
        constexpr optional(optional const&) = default;
        constexpr optional(optional&&) = default;

// 5.3.3, Assignment
        constexpr optional& operator=(optional const&) = default;
        constexpr optional& operator=(optional&&) = default;

// 5.3.5, Observers
        constexpr decltype(nullptr) operator->() const { return nullptr; }

template <typename ...dummy>
        constexpr auto value() const;

template <typename ...dummy>
        constexpr auto operator*() const;

template <typename U>
        constexpr U&& value_or(U&& u) const;
    };

constexpr optional<> nothing{};
#endif

//! Apply a function to the contents of an optional, with a fallback
    //! result.
    //! @relates hana::optional
    //!
    //! Specifically, `maybe` takes a default value, a function and an
    //! optional value. If the optional value is `nothing`, the default
    //! value is returned. Otherwise, the function is applied to the
    //! content of the `just`.
    //!
    //!
    //! @param default_
    //! A default value returned if `m` is `nothing`.
    //!
    //! @param f
    //! A function called as `f(x)` if and only if `m` is an optional value
    //! of the form `just(x)`. In that case, the result returend by `maybe`
    //! is the result of `f`.
    //!
    //! @param m
    //! An optional value.
    //!
    //!
    //! Example
    //! -------
    //! @include example/optional/maybe.cpp
#ifdef BOOST_HANA_DOXYGEN_INVOKED
    constexpr auto maybe = [](auto&& default_, auto&& f, auto&& m) -> decltype(auto) {
        if (m is a just(x)) {
            return forwarded(f)(forwarded(x));
        else
            return forwarded(default_);
        }
    };
#else
    struct maybe_t {
        template <typename Def, typename F, typename T>
        constexpr decltype(auto) operator()(Def&&, F&& f, optional<T> const& m) const
        { return static_cast<F&&>(f)(m.value_); }

template <typename Def, typename F, typename T>
        constexpr decltype(auto) operator()(Def&&, F&& f, optional<T>& m) const
        { return static_cast<F&&>(f)(m.value_); }

template <typename Def, typename F, typename T>
        constexpr decltype(auto) operator()(Def&&, F&& f, optional<T>&& m) const
        { return static_cast<F&&>(f)(static_cast<optional<T>&&>(m).value_); }

template <typename Def, typename F>
        constexpr Def operator()(Def&& def, F&&, optional<> const&) const
        { return static_cast<Def&&>(def); }
    };

constexpr maybe_t maybe{};
#endif

//! Calls a function if the call expression is well-formed.
    //! @relates hana::optional
    //!
    //! Given a function `f`, `sfinae` returns a new function applying `f`
    //! to its arguments and returning `just` the result if the call is
    //! well-formed, and `nothing` otherwise. In other words, `sfinae(f)(x...)`
    //! is `just(f(x...))` if that expression is well-formed, and `nothing`
    //! otherwise. Note, however, that it is possible for an expression
    //! `f(x...)` to be well-formed as far as SFINAE is concerned, but
    //! trying to actually compile `f(x...)` still fails. In this case,
    //! `sfinae` won't be able to detect it and a hard failure is likely
    //! to happen.
    //!
    //!
    //! @note
    //! The function given to `sfinae` must not return `void`, since
    //! `just(void)` does not make sense. A compilation error is
    //! triggered if the function returns void.
    //!
    //!
    //! Example
    //! -------
    //! @include example/optional/sfinae.cpp
#ifdef BOOST_HANA_DOXYGEN_INVOKED
    auto sfinae = [](auto&& f) {
        return [perfect-capture](auto&& ...x) {
            if (decltype(forwarded(f)(forwarded(x)...)) is well-formed)
                return just(forwarded(f)(forwarded(x)...));
            else
                return nothing;
        };
    };
#else
    struct sfinae_t {
        template <typename F>
        constexpr decltype(auto) operator()(F&& f) const;
    };

constexpr sfinae_t sfinae{};
#endif

//! Return whether an `optional` contains a value.
    //! @relates hana::optional
    //!
    //! Specifically, returns a compile-time true-valued `Logical` if `m` is
    //! of the form `just(x)` for some `x`, and a false-valued one otherwise.
    //!
    //!
    //! Example
    //! -------
    //! @include example/optional/is_just.cpp
#ifdef BOOST_HANA_DOXYGEN_INVOKED
    constexpr auto is_just = [](auto const& m) {
        return m is a just(x);
    };
#else
    struct is_just_t {
        template <typename ...T>
        constexpr auto operator()(optional<T...> const&) const;
    };

constexpr is_just_t is_just{};
#endif

//! Return whether an `optional` is empty.
    //! @relates hana::optional
    //!
    //! Specifically, returns a compile-time true-valued `Logical` if `m` is
    //! a `nothing`, and a false-valued one otherwise.
    //!
    //!
    //! Example
    //! -------
    //! @include example/optional/is_nothing.cpp
#ifdef BOOST_HANA_DOXYGEN_INVOKED
    constexpr auto is_nothing = [](auto const& m) {
        return m is a nothing;
    };
#else
    struct is_nothing_t {
        template <typename ...T>
        constexpr auto operator()(optional<T...> const&) const;
    };

constexpr is_nothing_t is_nothing{};
#endif
BOOST_HANA_NAMESPACE_END

#endif // !BOOST_HANA_FWD_OPTIONAL_HPP

cmd: