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/range.hpp (5480B)

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

@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_RANGE_HPP
#define BOOST_HANA_FWD_RANGE_HPP

#include <boost/hana/config.hpp>
#include <boost/hana/fwd/core/make.hpp>
#include <boost/hana/fwd/integral_constant.hpp>

BOOST_HANA_NAMESPACE_BEGIN
#ifdef BOOST_HANA_DOXYGEN_INVOKED
    //! @ingroup group-datatypes
    //! Compile-time half-open interval of `hana::integral_constant`s.
    //!
    //! A `range` represents a half-open interval of the form `[from, to)`
    //! containing `hana::integral_constant`s of a given type. The `[from, to)`
    //! notation represents the values starting at `from` (inclusively) up
    //! to but excluding `from`. In other words, it is a bit like the list
    //! `from, from+1, ..., to-1`.
    //!
    //! In particular, note that the bounds of the range can be any
    //! `hana::integral_constant`s (negative numbers are allowed) and the
    //! range does not have to start at zero. The only requirement is that
    //! `from <= to`.
    //!
    //! @note
    //! The representation of `hana::range` is implementation defined. In
    //! particular, one should not take for granted the number and types
    //! of template parameters. The proper way to create a `hana::range`
    //! is to use `hana::range_c` or `hana::make_range`. More details
    //! [in the tutorial](@ref tutorial-containers-types).
    //!
    //!
    //! Modeled concepts
    //! ----------------
    //! 1. `Comparable`\n
    //! Two ranges are equal if and only if they are both empty or they both
    //! span the same interval.
    //! @include example/range/comparable.cpp
    //!
    //! 2. `Foldable`\n
    //! Folding a `range` is equivalent to folding a list of the
    //! `integral_constant`s in the interval it spans.
    //! @include example/range/foldable.cpp
    //!
    //! 3. `Iterable`\n
    //! Iterating over a `range` is equivalent to iterating over a list of
    //! the values it spans. In other words, iterating over the range
    //! `[from, to)` is equivalent to iterating over a list containing
    //! `from, from+1, from+2, ..., to-1`. Also note that `operator[]` can
    //! be used in place of the `at` function.
    //! @include example/range/iterable.cpp
    //!
    //! 4. `Searchable`\n
    //! Searching a `range` is equivalent to searching a list of the values
    //! in the range `[from, to)`, but it is much more compile-time efficient.
    //! @include example/range/searchable.cpp
    template <typename T, T from, T to>
    struct range {
        //! 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::at`
        template <typename N>
        constexpr decltype(auto) operator[](N&& n);
    };
#else
    template <typename T, T from, T to>
    struct range;
#endif

//! Tag representing a `hana::range`.
    //! @relates hana::range
    struct range_tag { };

#ifdef BOOST_HANA_DOXYGEN_INVOKED
    //! Create a `hana::range` representing a half-open interval of
    //! `integral_constant`s.
    //! @relates hana::range
    //!
    //! Given two `IntegralConstant`s `from` and `to`, `make<range_tag>`
    //! returns a `hana::range` representing the half-open interval of
    //! `integral_constant`s `[from, to)`. `from` and `to` must form a
    //! valid interval, which means that `from <= to` must be true. Otherwise,
    //! a compilation error is triggered. Also note that if `from` and `to`
    //! are `IntegralConstant`s with different underlying integral types,
    //! the created range contains `integral_constant`s whose underlying
    //! type is their common type.
    //!
    //!
    //! Example
    //! -------
    //! @include example/range/make.cpp
    template <>
    constexpr auto make<range_tag> = [](auto const& from, auto const& to) {
        return range<implementation_defined>{implementation_defined};
    };
#endif

//! Alias to `make<range_tag>`; provided for convenience.
    //! @relates hana::range
    constexpr auto make_range = make<range_tag>;

//! Shorthand to create a `hana::range` with the given bounds.
    //! @relates hana::range
    //!
    //! This shorthand is provided for convenience only and it is equivalent
    //! to `make_range`. Specifically, `range_c<T, from, to>` is such that
    //! @code
    //!     range_c<T, from, to> == make_range(integral_c<T, from>, integral_c<T, to>)
    //! @endcode
    //!
    //!
    //! @tparam T
    //! The underlying integral type of the `integral_constant`s in the
    //! created range.
    //!
    //! @tparam from
    //! The inclusive lower bound of the created range.
    //!
    //! @tparam to
    //! The exclusive upper bound of the created range.
    //!
    //!
    //! Example
    //! -------
    //! @include example/range/range_c.cpp
#ifdef BOOST_HANA_DOXYGEN_INVOKED
    template <typename T, T from, T to>
    constexpr auto range_c = make_range(integral_c<T, from>, integral_c<T, to>);
#else
    template <typename T, T from, T to>
    constexpr range<T, from, to> range_c{};
#endif
BOOST_HANA_NAMESPACE_END

#endif // !BOOST_HANA_FWD_RANGE_HPP

cmd: