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/eval_if.hpp (6453B)

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

@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_EVAL_IF_HPP
#define BOOST_HANA_FWD_EVAL_IF_HPP

#include <boost/hana/config.hpp>
#include <boost/hana/core/when.hpp>

BOOST_HANA_NAMESPACE_BEGIN
    //! Conditionally execute one of two branches based on a condition.
    //! @ingroup group-Logical
    //!
    //! Given a condition and two branches in the form of lambdas or
    //! `hana::lazy`s, `eval_if` will evaluate the branch selected by the
    //! condition with `eval` and return the result. The exact requirements
    //! for what the branches may be are the same requirements as those for
    //! the `eval` function.
    //!
    //!
    //! Deferring compile-time evaluation inside `eval_if`
    //! --------------------------------------------------
    //! By passing a unary callable to `eval_if`, it is possible to defer
    //! the compile-time evaluation of selected expressions inside the
    //! lambda. This is useful when instantiating a branch would trigger
    //! a compile-time error; we only want the branch to be instantiated
    //! when that branch is selected. Here's how it can be achieved.
    //!
    //! For simplicity, we'll use a unary lambda as our unary callable.
    //! Our lambda must accept a parameter (usually called `_`), which
    //! can be used to defer the compile-time evaluation of expressions
    //! as required. For example,
    //! @code
    //!     template <typename N>
    //!     auto fact(N n) {
    //!         return hana::eval_if(n == hana::int_c<0>,
    //!             [] { return hana::int_c<1>; },
    //!             [=](auto _) { return n * fact(_(n) - hana::int_c<1>); }
    //!         );
    //!     }
    //! @endcode
    //!
    //! What happens here is that `eval_if` will call `eval` on the selected
    //! branch. In turn, `eval` will call the selected branch either with
    //! nothing -- for the _then_ branch -- or with `hana::id` -- for the
    //! _else_ branch. Hence, `_(x)` is always the same as `x`, but the
    //! compiler can't tell until the lambda has been called! Hence, the
    //! compiler has to wait before it instantiates the body of the lambda
    //! and no infinite recursion happens. However, this trick to delay the
    //! instantiation of the lambda's body can only be used when the condition
    //! is known at compile-time, because otherwise both branches have to be
    //! instantiated inside the `eval_if` anyway.
    //!
    //! There are several caveats to note with this approach to lazy branching.
    //! First, because we're using lambdas, it means that the function's
    //! result can't be used in a constant expression. This is a limitation
    //! of the current language.
    //!
    //! The second caveat is that compilers currently have several bugs
    //! regarding deeply nested lambdas with captures. So you always risk
    //! crashing the compiler, but this is a question of time before it is
    //! not a problem anymore.
    //!
    //! Finally, it means that conditionals can't be written directly inside
    //! unevaluated contexts. The reason is that a lambda can't appear in an
    //! unevaluated context, for example in `decltype`. One way to workaround
    //! this is to completely lift your type computations into variable
    //! templates instead. For example, instead of writing
    //! @code
    //!     template <typename T>
    //!     struct pointerize : decltype(
    //!         hana::eval_if(hana::traits::is_pointer(hana::type_c<T>),
    //!             [] { return hana::type_c<T>; },
    //!             [](auto _) { return _(hana::traits::add_pointer)(hana::type_c<T>); }
    //!         ))
    //!     { };
    //! @endcode
    //!
    //! you could instead write
    //!
    //! @code
    //!     template <typename T>
    //!     auto pointerize_impl(T t) {
    //!         return hana::eval_if(hana::traits::is_pointer(t),
    //!             [] { return hana::type_c<T>; },
    //!             [](auto _) { return _(hana::traits::add_pointer)(hana::type_c<T>); }
    //!         );
    //!     }
    //!
    //!     template <typename T>
    //!     using pointerize = decltype(pointerize_impl(hana::type_c<T>));
    //! @endcode
    //!
    //! > __Note__: This example would actually be implemented more easily
    //! > with partial specializations, but my bag of good examples is empty
    //! > at the time of writing this.
    //!
    //! Now, this hoop-jumping only has to be done in one place, because
    //! you should use normal function notation everywhere else in your
    //! metaprogram to perform type computations. So the syntactic
    //! cost is amortized over the whole program.
    //!
    //! Another way to work around this limitation of the language would be
    //! to use `hana::lazy` for the branches. However, this is only suitable
    //! when the branches are not too complicated. With `hana::lazy`, you
    //! could write the previous example as
    //! @code
    //!     template <typename T>
    //!     struct pointerize : decltype(
    //!         hana::eval_if(hana::traits::is_pointer(hana::type_c<T>),
    //!             hana::make_lazy(hana::type_c<T>),
    //!             hana::make_lazy(hana::traits::add_pointer)(hana::type_c<T>)
    //!         ))
    //!     { };
    //! @endcode
    //!
    //!
    //! @param cond
    //! The condition determining which of the two branches is selected.
    //!
    //! @param then
    //! An expression called as `eval(then)` if `cond` is true-valued.
    //!
    //! @param else_
    //! A function called as `eval(else_)` if `cond` is false-valued.
    //!
    //!
    //! Example
    //! -------
    //! @include example/eval_if.cpp
#ifdef BOOST_HANA_DOXYGEN_INVOKED
    constexpr auto eval_if = [](auto&& cond, auto&& then, auto&& else_) -> decltype(auto) {
        return tag-dispatched;
    };
#else
    template <typename L, typename = void>
    struct eval_if_impl : eval_if_impl<L, when<true>> { };

struct eval_if_t {
        template <typename Cond, typename Then, typename Else>
        constexpr decltype(auto) operator()(Cond&& cond, Then&& then, Else&& else_) const;
    };

constexpr eval_if_t eval_if{};
#endif
BOOST_HANA_NAMESPACE_END

#endif // !BOOST_HANA_FWD_EVAL_IF_HPP

cmd: