?????????? ????????? - ??????????????? - /home/agenciai/public_html/cd38d8/fwd.zip
???????
PK �|!\#tX X repeat.hppnu �[��� /*! @file Forward declares `boost::hana::repeat`. @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_REPEAT_HPP #define BOOST_HANA_FWD_REPEAT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Invokes a nullary function `n` times. //! @ingroup group-IntegralConstant //! //! Given an `IntegralConstant` `n` and a nullary function `f`, //! `repeat(n, f)` will call `f` `n` times. In particular, any //! decent compiler should expand `repeat(n, f)` to //! @code //! f(); f(); ... f(); // n times total //! @endcode //! //! //! @param n //! An `IntegralConstant` holding a non-negative value representing //! the number of times `f` should be repeatedly invoked. //! //! @param f //! A function to repeatedly invoke `n` times. `f` is allowed to have //! side effects. //! //! //! Example //! ------- //! @include example/repeat.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto repeat = [](auto const& n, auto&& f) -> void { f(); f(); ... f(); // n times total }; #else template <typename N, typename = void> struct repeat_impl : repeat_impl<N, when<true>> { }; struct repeat_t { template <typename N, typename F> constexpr void operator()(N const& n, F&& f) const; }; constexpr repeat_t repeat{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_REPEAT_HPP PK �|!\VTn�b b count_if.hppnu �[��� /*! @file Forward declares `boost::hana::count_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_COUNT_IF_HPP #define BOOST_HANA_FWD_COUNT_IF_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Return the number of elements in the structure for which the //! `predicate` is satisfied. //! @ingroup group-Foldable //! //! Specifically, returns an object of an unsigned integral type, or //! a `Constant` holding such an object, which represents the number //! of elements in the structure satisfying the given `predicate`. //! //! //! @param xs //! The structure whose elements are counted. //! //! @param predicate //! A function called as `predicate(x)`, where `x` is an element of the //! structure, and returning a `Logical` representing whether `x` should //! be counted. //! //! //! Example //! ------- //! @include example/count_if.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto count_if = [](auto&& xs, auto&& predicate) { return tag-dispatched; }; #else template <typename T, typename = void> struct count_if_impl : count_if_impl<T, when<true>> { }; struct count_if_t { template <typename Xs, typename Pred> constexpr auto operator()(Xs&& xs, Pred&& pred) const; }; constexpr count_if_t count_if{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_COUNT_IF_HPP PK �|!\+� group.hppnu �[��� /*! @file Forward declares `boost::hana::group`. @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_GROUP_HPP #define BOOST_HANA_FWD_GROUP_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/detail/nested_by_fwd.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Group adjacent elements of a sequence that all respect a binary //! predicate, by default equality. //! @ingroup group-Sequence //! //! Given a _finite_ Sequence and an optional predicate (by default //! `equal`), `group` returns a sequence of subsequences representing //! groups of adjacent elements that are "equal" with respect to the //! predicate. In other words, the groups are such that the predicate is //! satisfied when it is applied to any two adjacent elements in that //! group. The sequence returned by `group` is such that the concatenation //! of its elements is equal to the original sequence, which is equivalent //! to saying that the order of the elements is not changed. //! //! If no predicate is provided, adjacent elements in the sequence must //! all be compile-time `Comparable`. //! //! //! Signature //! --------- //! Given a Sequence `s` with tag `S(T)`, an `IntegralConstant` `Bool` //! holding a value of type `bool`, and a predicate //! \f$ pred : T \times T \to Bool \f$, `group` has the following //! signatures. For the variant with a provided predicate, //! \f[ //! \mathtt{group} : S(T) \times (T \times T \to Bool) \to S(S(T)) //! \f] //! //! for the variant without a custom predicate, `T` is required to be //! Comparable. The signature is then //! \f[ //! \mathtt{group} : S(T) \to S(S(T)) //! \f] //! //! @param xs //! The sequence to split into groups. //! //! @param predicate //! A binary function called as `predicate(x, y)`, where `x` and `y` are //! _adjacent_ elements in the sequence, whether both elements should be //! in the same group (subsequence) of the result. In the current version //! of the library, the result returned by `predicate` must be an //! `IntegralConstant` holding a value of a type convertible to `bool`. //! Also, `predicate` has to define an equivalence relation as defined by //! the `Comparable` concept. When this predicate is not provided, it //! defaults to `equal`, which requires the comparison of any two adjacent //! elements in the sequence to return a boolean `IntegralConstant`. //! //! //! Syntactic sugar (`group.by`) //! ---------------------------- //! `group` can be called in a third way, which provides a nice syntax //! especially when working with the `comparing` combinator: //! @code //! group.by(predicate, xs) == group(xs, predicate) //! group.by(predicate) == group(-, predicate) //! @endcode //! //! where `group(-, predicate)` denotes the partial application of //! `group` to `predicate`. //! //! //! Example //! ------- //! @include example/group.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto group = [](auto&& xs[, auto&& predicate]) { return tag-dispatched; }; #else template <typename S, typename = void> struct group_impl : group_impl<S, when<true>> { }; struct group_t : detail::nested_by<group_t> { template <typename Xs> constexpr auto operator()(Xs&& xs) const; template <typename Xs, typename Predicate> constexpr auto operator()(Xs&& xs, Predicate&& pred) const; }; constexpr group_t group{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_GROUP_HPP PK �|!\��cy y front.hppnu �[��� /*! @file Forward declares `boost::hana::front`. @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_FRONT_HPP #define BOOST_HANA_FWD_FRONT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns the first element of a non-empty iterable. //! @ingroup group-Iterable //! //! Given a non-empty Iterable `xs` with a linearization of `[x1, ..., xN]`, //! `front(xs)` is equal to `x1`. If `xs` is empty, it is an error to //! use this function. Equivalently, `front(xs)` must be equivalent to //! `at_c<0>(xs)`, and that regardless of the value category of `xs` //! (`front` must respect the reference semantics of `at`). //! //! //! Example //! ------- //! @include example/front.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto front = [](auto&& xs) -> decltype(auto) { return tag-dispatched; }; #else template <typename It, typename = void> struct front_impl : front_impl<It, when<true>> { }; struct front_t { template <typename Xs> constexpr decltype(auto) operator()(Xs&& xs) const; }; constexpr front_t front{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_FRONT_HPP PK �|!\�'BF� � scan_right.hppnu �[��� /*! @file Forward declares `boost::hana::scan_right`. @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_SCAN_RIGHT_HPP #define BOOST_HANA_FWD_SCAN_RIGHT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Fold a Sequence to the right and return a list containing the //! successive reduction states. //! @ingroup group-Sequence //! //! Like `fold_right`, `scan_right` reduces a sequence to a single value //! using a binary operation. However, unlike `fold_right`, it builds up //! a sequence of the intermediary results computed along the way and //! returns that instead of only the final reduction state. Like //! `fold_right`, `scan_right` can be used with or without an initial //! reduction state. //! //! When the sequence is empty, two things may arise. If an initial state //! was provided, a singleton list containing that state is returned. //! Otherwise, if no initial state was provided, an empty list is //! returned. In particular, unlike for `fold_right`, using `scan_right` //! on an empty sequence without an initial state is not an error. //! //! More specifically, `scan_right([x1, ..., xn], state, f)` is a sequence //! whose `i`th element is equivalent to `fold_right([x1, ..., xi], state, f)`. //! The no-state variant is handled in an analogous way. For illustration, //! consider this right fold on a short sequence: //! @code //! fold_right([x1, x2, x3], state, f) == f(x1, f(x2, f(x3, state))) //! @endcode //! //! The analogous sequence generated with `scan_right` will be //! @code //! scan_right([x1, x2, x3], state, f) == [ //! f(x1, f(x2, f(x3, state))), //! f(x2, f(x3, state)), //! f(x3, state), //! state //! ] //! @endcode //! //! Similarly, consider this right fold (without an initial state) on //! a short sequence: //! @code //! fold_right([x1, x2, x3, x4], f) == f(x1, f(x2, f(x3, x4))) //! @endcode //! //! The analogous sequence generated with `scan_right` will be //! @code //! scan_right([x1, x2, x3, x4], f) == [ //! f(x1, f(x2, f(x3, x4))), //! f(x2, f(x3, x4)), //! f(x3, x4), //! x4 //! ] //! @endcode //! //! @param xs //! The sequence to scan from the right. //! //! @param state //! The (optional) initial reduction state. //! //! @param f //! A binary function called as `f(x, state)`, where `state` is the //! result accumulated so far and `x` is an element in the sequence. //! When no initial state is provided, `f` is called as `f(x1, x2)`, //! where `x1` and `x2` are elements of the sequence. //! //! //! Example //! ------- //! @include example/scan_right.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto scan_right = [](auto&& xs[, auto&& state], auto const& f) { return tag-dispatched; }; #else template <typename S, typename = void> struct scan_right_impl : scan_right_impl<S, when<true>> { }; struct scan_right_t { template <typename Xs, typename State, typename F> constexpr auto operator()(Xs&& xs, State&& state, F const& f) const; template <typename Xs, typename F> constexpr auto operator()(Xs&& xs, F const& f) const; }; constexpr scan_right_t scan_right{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_SCAN_RIGHT_HPP PK �|!\C�#?2 2 adapt_struct.hppnu �[��� /*! @file Documents the `BOOST_HANA_ADAPT_STRUCT` macro. @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_ADAPT_STRUCT_HPP #define BOOST_HANA_FWD_ADAPT_STRUCT_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN // Note: // The weird definition as a variable seems to exploit a glitch in Doxygen // which makes the macro appear in the related objects of Struct (as we // want it to). //! Defines a model of `Struct` with the given members. //! @ingroup group-Struct //! //! Using this macro at _global scope_ will define a model of the `Struct` //! concept for the given type. This can be used to easily adapt existing //! user-defined types in a ad-hoc manner. Unlike the //! `BOOST_HANA_DEFINE_STRUCT` macro, this macro does not //! require the types of the members to be specified. //! //! @note //! This macro only works if the tag of the user-defined type `T` is `T` //! itself. This is the case unless you specifically asked for something //! different; see `tag_of`'s documentation. //! //! //! Example //! ------- //! @include example/adapt_struct.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED auto BOOST_HANA_ADAPT_STRUCT(...) = ; #define BOOST_HANA_ADAPT_STRUCT(Name, ...) see documentation #else // defined in <boost/hana/adapt_struct.hpp> #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_ADAPT_STRUCT_HPP PK �|!\�:, , fuse.hppnu �[��� /*! @file Forward declares `boost::hana::fuse`. @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_FUSE_HPP #define BOOST_HANA_FWD_FUSE_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Transform a function taking multiple arguments into a function that //! can be called with a compile-time `Foldable`. //! @ingroup group-Foldable //! //! //! This function is provided for convenience as a different way of //! calling `unpack`. Specifically, `fuse(f)` is a function such that //! @code //! fuse(f)(foldable) == unpack(foldable, f) //! == f(x...) //! @endcode //! where `x...` are the elements in the foldable. This function is //! useful when one wants to create a function that accepts a foldable //! which is not known yet. //! //! @note //! This function is not tag-dispatched; customize `unpack` instead. //! //! //! Example //! ------- //! @include example/fuse.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto fuse = [](auto&& f) { return [perfect-capture](auto&& xs) -> decltype(auto) { return unpack(forwarded(xs), forwarded(f)); }; }; #else struct fuse_t { template <typename F> constexpr auto operator()(F&& f) const; }; constexpr fuse_t fuse{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_FUSE_HPP PK �|!\,f5ۥ � any_of.hppnu �[��� /*! @file Forward declares `boost::hana::any_of`. @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_ANY_OF_HPP #define BOOST_HANA_FWD_ANY_OF_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns whether any key of the structure satisfies the `predicate`. //! @ingroup group-Searchable //! //! If the structure is not finite, `predicate` has to be satisfied //! after looking at a finite number of keys for this method to finish. //! //! //! @param xs //! The structure to search. //! //! @param predicate //! A function called as `predicate(k)`, where `k` is a key of the //! structure, and returning a `Logical`. //! //! //! Example //! ------- //! @include example/any_of.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto any_of = [](auto&& xs, auto&& predicate) { return tag-dispatched; }; #else template <typename S, typename = void> struct any_of_impl : any_of_impl<S, when<true>> { }; struct any_of_t { template <typename Xs, typename Pred> constexpr auto operator()(Xs&& xs, Pred&& pred) const; }; constexpr any_of_t any_of{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_ANY_OF_HPP PK �|!\"��2� � lazy.hppnu �[��� /*! @file Forward declares `boost::hana::lazy`. @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_LAZY_HPP #define BOOST_HANA_FWD_LAZY_HPP #include <boost/hana/config.hpp> #include <boost/hana/fwd/core/make.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-datatypes //! `hana::lazy` implements superficial laziness via a monadic interface. //! //! It is important to understand that the laziness implemented by `lazy` //! is only superficial; only function applications made inside the `lazy` //! monad can be made lazy, not all their subexpressions. //! //! //! @note //! The actual representation of `hana::lazy` is completely //! implementation-defined. Lazy values may only be created through //! `hana::make_lazy`, and they can be stored in variables using //! `auto`, but any other assumption about the representation of //! `hana::lazy<...>` should be avoided. In particular, one should //! not rely on the fact that `hana::lazy<...>` can be pattern-matched //! on, because it may be a dependent type. //! //! //! Modeled concepts //! ---------------- //! 1. `Functor`\n //! Applying a function over a lazy value with `transform` returns the //! result of applying the function, as a lazy value. //! @include example/lazy/functor.cpp //! //! 2. `Applicative`\n //! A normal value can be lifted into a lazy value by using `lift<lazy_tag>`. //! A lazy function can be lazily applied to a lazy value by using `ap`. //! //! 3. `Monad`\n //! The `lazy` monad allows combining lazy computations into larger //! lazy computations. Note that the `|` operator can be used in place //! of the `chain` function. //! @include example/lazy/monad.cpp //! //! 4. `Comonad`\n //! The `lazy` comonad allows evaluating a lazy computation to get its //! result and lazily applying functions taking lazy inputs to lazy //! values. This [blog post][1] goes into more details about lazy //! evaluation and comonads. //! @include example/lazy/comonad.cpp //! //! //! @note //! `hana::lazy` only models a few concepts because providing more //! functionality would require evaluating the lazy values in most cases. //! Since this raises some issues such as side effects and memoization, //! the interface is kept minimal. //! //! //! [1]: http://ldionne.com/2015/03/16/laziness-as-a-comonad #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename implementation_defined> struct lazy { //! Equivalent to `hana::chain`. template <typename ...T, typename F> friend constexpr auto operator|(lazy<T...>, F); }; #else // We do not _actually_ define the lazy<...> type. Per the documentation, // users can't rely on it being anything, and so they should never use // it explicitly. The implementation in <boost/hana/lazy.hpp> is much // simpler if we use different types for lazy calls and lazy values. #endif //! Tag representing `hana::lazy`. //! @relates hana::lazy struct lazy_tag { }; //! Lifts a normal value to a lazy one. //! @relates hana::lazy //! //! `make<lazy_tag>` can be used to lift a normal value or a function call //! into a lazy expression. Precisely, `make<lazy_tag>(x)` is a lazy value //! equal to `x`, and `make<lazy_tag>(f)(x1, ..., xN)` is a lazy function //! call that is equal to `f(x1, ..., xN)` when it is `eval`uated. //! //! @note //! It is interesting to note that `make<lazy_tag>(f)(x1, ..., xN)` is //! equivalent to //! @code //! ap(make<lazy_tag>(f), lift<lazy_tag>(x1), ..., lift<lazy_tag>(xN)) //! @endcode //! which in turn is equivalent to `make<lazy_tag>(f(x1, ..., xN))`, except //! for the fact that the inner call to `f` is evaluated lazily. //! //! //! Example //! ------- //! @include example/lazy/make.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <> constexpr auto make<lazy_tag> = [](auto&& x) { return lazy<implementation_defined>{forwarded(x)}; }; #endif //! Alias to `make<lazy_tag>`; provided for convenience. //! @relates hana::lazy //! //! Example //! ------- //! @include example/lazy/make.cpp constexpr auto make_lazy = make<lazy_tag>; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_LAZY_HPP PK �|!\Ud;k k core.hppnu �[��� /*! @file Forward declares the @ref group-core module. @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_CORE_HPP #define BOOST_HANA_FWD_CORE_HPP #include <boost/hana/fwd/core/common.hpp> #include <boost/hana/fwd/core/to.hpp> #include <boost/hana/fwd/core/default.hpp> #include <boost/hana/fwd/core/is_a.hpp> #include <boost/hana/fwd/core/make.hpp> #include <boost/hana/fwd/core/tag_of.hpp> #include <boost/hana/fwd/core/when.hpp> #endif // !BOOST_HANA_FWD_CORE_HPP PK �|!\;���� � unfold_left.hppnu �[��� /*! @file Forward declares `boost::hana::unfold_left`. @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_UNFOLD_LEFT_HPP #define BOOST_HANA_FWD_UNFOLD_LEFT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Dual operation to `fold_left` for sequences. //! @ingroup group-Sequence //! //! While `fold_left` reduces a structure to a summary value from the left, //! `unfold_left` builds a sequence from a seed value and a function, //! starting from the left. //! //! //! Signature //! --------- //! Given a `Sequence` `S`, an initial value `state` of tag `I`, an //! arbitrary Product `P` and a function \f$ f : I \to P(I, T) \f$, //! `unfold_left<S>` has the following signature: //! \f[ //! \mathtt{unfold\_left}_S : I \times (I \to P(I, T)) \to S(T) //! \f] //! //! @tparam S //! The tag of the sequence to build up. //! //! @param state //! An initial value to build the sequence from. //! //! @param f //! A function called as `f(state)`, where `state` is an initial value, //! and returning //! 1. `nothing` if it is done producing the sequence. //! 2. otherwise, `just(make<P>(state, x))`, where `state` is the new //! initial value used in the next call to `f`, `x` is an element to //! be appended to the resulting sequence, and `P` is an arbitrary //! `Product`. //! //! //! Fun fact //! --------- //! In some cases, `unfold_left` can undo a `fold_left` operation: //! @code //! unfold_left<S>(fold_left(xs, state, f), g) == xs //! @endcode //! //! if the following holds //! @code //! g(f(x, y)) == just(make_pair(x, y)) //! g(state) == nothing //! @endcode //! //! //! Example //! ------- //! @include example/unfold_left.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename S> constexpr auto unfold_left = [](auto&& state, auto&& f) { return tag-dispatched; }; #else template <typename S, typename = void> struct unfold_left_impl : unfold_left_impl<S, when<true>> { }; template <typename S> struct unfold_left_t; template <typename S> constexpr unfold_left_t<S> unfold_left{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_UNFOLD_LEFT_HPP PK �|!\�pd\ \ one.hppnu �[��� /*! @file Forward declares `boost::hana::one`. @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_ONE_HPP #define BOOST_HANA_FWD_ONE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Identity of the `Ring` multiplication. //! @ingroup group-Ring //! //! @tparam R //! The tag (must be a model of `Ring`) of the returned identity. //! //! //! Example //! ------- //! @include example/one.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename R> constexpr auto one = []() -> decltype(auto) { return tag-dispatched; }; #else template <typename R, typename = void> struct one_impl : one_impl<R, when<true>> { }; template <typename R> struct one_t { constexpr decltype(auto) operator()() const; }; template <typename R> constexpr one_t<R> one{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_ONE_HPP PK �|!\3ooϰ � monadic_fold_left.hppnu �[��� /*! @file Forward declares `boost::hana::monadic_fold_left`. @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_MONADIC_FOLD_LEFT_HPP #define BOOST_HANA_FWD_MONADIC_FOLD_LEFT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Monadic left-fold of a structure with a binary operation and an //! optional initial reduction state. //! @ingroup group-Foldable //! //! @note //! This assumes the reader to be accustomed to non-monadic left-folds as //! explained by `hana::fold_left`, and to have read the [primer] //! (@ref monadic-folds) on monadic folds. //! //! `monadic_fold_left<M>` is a left-associative monadic fold. Given a //! `Foldable` with linearization `[x1, ..., xn]`, a function `f` and an //! optional initial state, `monadic_fold_left<M>` applies `f` as follows: //! @code //! // with state //! ((((f(state, x1) | f(-, x2)) | f(-, x3)) | ...) | f(-, xn)) //! //! // without state //! ((((f(x1, x2) | f(-, x3)) | f(-, x4)) | ...) | f(-, xn)) //! @endcode //! //! where `f(-, xk)` denotes the partial application of `f` to `xk`, and //! `|` is just the operator version of the monadic `chain`. //! //! When the structure is empty, one of two things may happen. If an //! initial state was provided, it is lifted to the given Monad and //! returned as-is. Otherwise, if the no-state version of the function //! was used, an error is triggered. When the stucture contains a single //! element and the no-state version of the function was used, that //! single element is lifted into the given Monad and returned as is. //! //! //! Signature //! --------- //! Given a `Monad` `M`, a `Foldable` `F`, an initial state of tag `S`, //! and a function @f$ f : S \times T \to M(S) @f$, the signatures of //! `monadic_fold_left<M>` are //! \f[ //! \mathtt{monadic\_fold\_left}_M : //! F(T) \times S \times (S \times T \to M(S)) \to M(S) //! \f] //! //! for the version with an initial state, and //! \f[ //! \mathtt{monadic\_fold\_left}_M : //! F(T) \times (T \times T \to M(T)) \to M(T) //! \f] //! //! for the version without an initial state. //! //! @tparam M //! The Monad representing the monadic context in which the fold happens. //! The return type of `f` must be in that Monad. //! //! @param xs //! The structure to fold. //! //! @param state //! The initial value used for folding. If the structure is empty, this //! value is lifted in to the `M` Monad and then returned as-is. //! //! @param f //! A binary function called as `f(state, x)`, where `state` is the result //! accumulated so far and `x` is an element in the structure. The //! function must return its result inside the `M` Monad. //! //! //! Example //! ------- //! @include example/monadic_fold_left.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename M> constexpr auto monadic_fold_left = [](auto&& xs[, auto&& state], auto&& f) -> decltype(auto) { return tag-dispatched; }; #else template <typename T, typename = void> struct monadic_fold_left_impl : monadic_fold_left_impl<T, when<true>> { }; template <typename M> struct monadic_fold_left_t { template <typename Xs, typename State, typename F> constexpr decltype(auto) operator()(Xs&& xs, State&& state, F&& f) const; template <typename Xs, typename F> constexpr decltype(auto) operator()(Xs&& xs, F&& f) const; }; template <typename M> constexpr monadic_fold_left_t<M> monadic_fold_left{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_MONADIC_FOLD_LEFT_HPP PK �|!\?��� � zip_with.hppnu �[��� /*! @file Forward declares `boost::hana::zip_with`. @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_ZIP_WITH_HPP #define BOOST_HANA_FWD_ZIP_WITH_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Zip one sequence or more with a given function. //! @ingroup group-Sequence //! //! Given a `n`-ary function `f` and `n` sequences `s1, ..., sn`, //! `zip_with` produces a sequence whose `i`-th element is //! `f(s1[i], ..., sn[i])`, where `sk[i]` denotes the `i`-th element of //! the `k`-th sequence. In other words, `zip_with` produces a sequence //! of the form //! @code //! [ //! f(s1[0], ..., sn[0]), //! f(s1[1], ..., sn[1]), //! ... //! f(s1[M], ..., sn[M]) //! ] //! @endcode //! where `M` is the length of the sequences, which are all assumed to //! have the same length. Assuming the sequences to all have the same size //! allows the library to perform some optimizations. To zip sequences //! that may have different lengths, `zip_shortest_with` should be used //! instead. Also note that it is an error to provide no sequence at all, //! i.e. `zip_with` expects at least one sequence. //! //! //! Example //! ------- //! @include example/zip_with.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto zip_with = [](auto&& f, auto&& x1, ..., auto&& xn) { return tag-dispatched; }; #else template <typename S, typename = void> struct zip_with_impl : zip_with_impl<S, when<true>> { }; struct zip_with_t { template <typename F, typename Xs, typename ...Ys> constexpr auto operator()(F&& f, Xs&& xs, Ys&& ...ys) const; }; constexpr zip_with_t zip_with{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_ZIP_WITH_HPP PK �|!\?�h� � append.hppnu �[��� /*! @file Forward declares `boost::hana::append`. @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_APPEND_HPP #define BOOST_HANA_FWD_APPEND_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Append an element to a monadic structure. //! @ingroup group-MonadPlus //! //! Given an element `x` and a monadic structure `xs`, `append` returns a //! new monadic structure which is the result of lifting `x` into the //! monadic structure and then combining that (to the right) with `xs`. //! In other words, //! @code //! append(xs, x) == concat(xs, lift<Xs>(x)) //! @endcode //! where `Xs` is the tag of `xs`. For sequences, this has the intuitive //! behavior of simply appending an element to the end of the sequence, //! hence the name. //! //! > #### Rationale for not calling this `push_back` //! > See the rationale for using `prepend` instead of `push_front`. //! //! //! Signature //! --------- //! Given a MonadPlus `M`, the signature is //! @f$ \mathtt{append} : M(T) \times T \to M(T) @f$. //! //! @param xs //! A monadic structure that will be combined to the left of the element. //! //! @param x //! An element to combine to the right of the monadic structure. //! //! //! Example //! ------- //! @include example/append.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto append = [](auto&& xs, auto&& x) { return tag-dispatched; }; #else template <typename M, typename = void> struct append_impl : append_impl<M, when<true>> { }; struct append_t { template <typename Xs, typename X> constexpr auto operator()(Xs&& xs, X&& x) const; }; constexpr append_t append{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_APPEND_HPP PK �|!\!^m�� � flatten.hppnu �[��� /*! @file Forward declares `boost::hana::flatten`. @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_FLATTEN_HPP #define BOOST_HANA_FWD_FLATTEN_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Collapse two levels of monadic structure into a single level. //! @ingroup group-Monad //! //! Given a monadic value wrapped into two levels of monad, `flatten` //! removes one such level. An implementation of `flatten` must satisfy //! @code //! flatten(xs) == chain(xs, id) //! @endcode //! //! For `Sequence`s, this simply takes a `Sequence` of `Sequence`s, and //! returns a (non-recursively) flattened `Sequence`. //! //! //! Signature //! --------- //! For a `Monad` `M`, the signature of `flatten` is //! @f$ //! \mathtt{flatten} : M(M(T)) \to M(T) //! @f$ //! //! @param xs //! A value with two levels of monadic structure, which should be //! collapsed into a single level of structure. //! //! //! Example //! ------- //! @include example/flatten.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto flatten = [](auto&& xs) { return tag-dispatched; }; #else template <typename M, typename = void> struct flatten_impl : flatten_impl<M, when<true>> { }; struct flatten_t { template <typename Xs> constexpr auto operator()(Xs&& xs) const; }; constexpr flatten_t flatten{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_FLATTEN_HPP PK �|!\� >� � fill.hppnu �[��� /*! @file Forward declares `boost::hana::fill`. @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_FILL_HPP #define BOOST_HANA_FWD_FILL_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Replace all the elements of a structure with a fixed value. //! @ingroup group-Functor //! //! //! Signature //! --------- //! Given `F` a Functor, the signature is //! \f$ //! \mathtt{fill} : F(T) \times U \to F(U) //! \f$ //! //! @param xs //! The structure to fill with a `value`. //! //! @param value //! A value by which every element `x` of the structure is replaced, //! unconditionally. //! //! //! Example //! ------- //! @include example/fill.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto fill = [](auto&& xs, auto&& value) { return tag-dispatched; }; #else template <typename Xs, typename = void> struct fill_impl : fill_impl<Xs, when<true>> { }; struct fill_t { template <typename Xs, typename Value> constexpr auto operator()(Xs&& xs, Value&& value) const; }; constexpr fill_t fill{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_FILL_HPP PK �|!\���h h intersection.hppnu �[��� /*! @file Forward declares `boost::hana::intersection`. @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_INTERSECTION_HPP #define BOOST_HANA_FWD_INTERSECTION_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN // Note: This function is documented per datatype/concept only. //! @cond template <typename S, typename = void> struct intersection_impl : intersection_impl<S, when<true>> { }; //! @endcond struct intersection_t { template <typename Xs, typename Ys> constexpr auto operator()(Xs&&, Ys&&) const; }; constexpr intersection_t intersection{}; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_INTERSECTION_HPP PK �|!\ empty.hppnu �[��� /*! @file Forward declares `boost::hana::empty`. @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_EMPTY_HPP #define BOOST_HANA_FWD_EMPTY_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Identity of the monadic combination `concat`. //! @ingroup group-MonadPlus //! //! Signature //! --------- //! Given a MonadPlus `M`, the signature is //! @f$ \mathtt{empty}_M : \emptyset \to M(T) @f$. //! //! @tparam M //! The tag of the monadic structure to return. This must be //! a model of the MonadPlus concept. //! //! //! Example //! ------- //! @include example/empty.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename M> constexpr auto empty = []() { return tag-dispatched; }; #else template <typename M, typename = void> struct empty_impl : empty_impl<M, when<true>> { }; template <typename M> struct empty_t { constexpr auto operator()() const; }; template <typename M> constexpr empty_t<M> empty{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_EMPTY_HPP PK �|!\�5�� � min.hppnu �[��� /*! @file Forward declares `boost::hana::min`. @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_MIN_HPP #define BOOST_HANA_FWD_MIN_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns the smallest of its arguments according to the `less` ordering. //! @ingroup group-Orderable //! //! //! @todo //! We can't specify the signature right now, because the tag of the //! returned object depends on whether `x < y` or not. If we wanted to be //! mathematically correct, we should probably ask that `if_(cond, x, y)` //! returns a common data type of `x` and `y`, and then the behavior //! of `min` would follow naturally. However, I'm unsure whether this //! is desirable because that's a big requirement. //! //! //! Example //! ------- //! @include example/min.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto min = [](auto&& x, auto&& y) -> decltype(auto) { return tag-dispatched; }; #else template <typename T, typename U, typename = void> struct min_impl : min_impl<T, U, when<true>> { }; struct min_t { template <typename X, typename Y> constexpr decltype(auto) operator()(X&& x, Y&& y) const; }; constexpr min_t min{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_MIN_HPP PK �|!\��qӷ � integral_constant.hppnu �[��� /*! @file Forward declares `boost::hana::integral_constant`. @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_INTEGRAL_CONSTANT_HPP #define BOOST_HANA_FWD_INTEGRAL_CONSTANT_HPP #include <boost/hana/config.hpp> #include <boost/hana/detail/integral_constant.hpp> #include <cstddef> BOOST_HANA_NAMESPACE_BEGIN //! Creates an `integral_constant` holding the given compile-time value. //! @relates hana::integral_constant //! //! Specifically, `integral_c<T, v>` is a `hana::integral_constant` //! holding the compile-time value `v` of an integral type `T`. //! //! //! @tparam T //! The type of the value to hold in the `integral_constant`. //! It must be an integral type. //! //! @tparam v //! The integral value to hold in the `integral_constant`. //! //! //! Example //! ------- //! @snippet example/integral_constant.cpp integral_c template <typename T, T v> constexpr integral_constant<T, v> integral_c{}; //! @relates hana::integral_constant template <bool b> using bool_ = integral_constant<bool, b>; //! @relates hana::integral_constant template <bool b> constexpr bool_<b> bool_c{}; //! @relates hana::integral_constant using true_ = bool_<true>; //! @relates hana::integral_constant constexpr auto true_c = bool_c<true>; //! @relates hana::integral_constant using false_ = bool_<false>; //! @relates hana::integral_constant constexpr auto false_c = bool_c<false>; //! @relates hana::integral_constant template <char c> using char_ = integral_constant<char, c>; //! @relates hana::integral_constant template <char c> constexpr char_<c> char_c{}; //! @relates hana::integral_constant template <short i> using short_ = integral_constant<short, i>; //! @relates hana::integral_constant template <short i> constexpr short_<i> short_c{}; //! @relates hana::integral_constant template <unsigned short i> using ushort_ = integral_constant<unsigned short, i>; //! @relates hana::integral_constant template <unsigned short i> constexpr ushort_<i> ushort_c{}; //! @relates hana::integral_constant template <int i> using int_ = integral_constant<int, i>; //! @relates hana::integral_constant template <int i> constexpr int_<i> int_c{}; //! @relates hana::integral_constant template <unsigned int i> using uint = integral_constant<unsigned int, i>; //! @relates hana::integral_constant template <unsigned int i> constexpr uint<i> uint_c{}; //! @relates hana::integral_constant template <long i> using long_ = integral_constant<long, i>; //! @relates hana::integral_constant template <long i> constexpr long_<i> long_c{}; //! @relates hana::integral_constant template <unsigned long i> using ulong = integral_constant<unsigned long, i>; //! @relates hana::integral_constant template <unsigned long i> constexpr ulong<i> ulong_c{}; //! @relates hana::integral_constant template <long long i> using llong = integral_constant<long long, i>; //! @relates hana::integral_constant template <long long i> constexpr llong<i> llong_c{}; //! @relates hana::integral_constant template <unsigned long long i> using ullong = integral_constant<unsigned long long, i>; //! @relates hana::integral_constant template <unsigned long long i> constexpr ullong<i> ullong_c{}; //! @relates hana::integral_constant template <std::size_t i> using size_t = integral_constant<std::size_t, i>; //! @relates hana::integral_constant template <std::size_t i> constexpr size_t<i> size_c{}; namespace literals { //! Creates a `hana::integral_constant` from a literal. //! @relatesalso boost::hana::integral_constant //! //! The literal is parsed at compile-time and the result is returned //! as a `llong<...>`. //! //! @note //! We use `llong<...>` instead of `ullong<...>` because using an //! unsigned type leads to unexpected behavior when doing stuff like //! `-1_c`. If we used an unsigned type, `-1_c` would be something //! like `ullong<-1>` which is actually `ullong<something huge>`. //! //! //! Example //! ------- //! @snippet example/integral_constant.cpp literals template <char ...c> constexpr auto operator"" _c(); } BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_INTEGRAL_CONSTANT_HPP PK �|!\�S��� � transform.hppnu �[��� /*! @file Forward declares `boost::hana::transform`. @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_TRANSFORM_HPP #define BOOST_HANA_FWD_TRANSFORM_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Map a function over a `Functor`. //! @ingroup group-Functor //! //! //! Signature //! --------- //! Given `F` a Functor, the signature is //! \f$ //! \mathtt{transform} : F(T) \times (T \to U) \to F(U) //! \f$ //! //! @param xs //! The structure to map `f` over. //! //! @param f //! A function called as `f(x)` on element(s) `x` of the structure, //! and returning a new value to replace `x` in the structure. //! //! //! Example //! ------- //! @include example/transform.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto transform = [](auto&& xs, auto&& f) { return tag-dispatched; }; #else template <typename Xs, typename = void> struct transform_impl : transform_impl<Xs, when<true>> { }; struct transform_t { template <typename Xs, typename F> constexpr auto operator()(Xs&& xs, F&& f) const; }; constexpr transform_t transform{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_TRANSFORM_HPP PK �|!\��_/� � replicate.hppnu �[��� /*! @file Forward declares `boost::hana::replicate`. @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_REPLICATE_HPP #define BOOST_HANA_FWD_REPLICATE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Create a monadic structure by combining a lifted value with itself //! `n` times. //! @ingroup group-MonadPlus //! //! Given a value `x`, a non-negative `IntegralConstant` `n` and the tag //! of a monadic structure `M`, `replicate` creates a new monadic structure //! which is the result of combining `x` with itself `n` times inside the //! monadic structure. In other words, `replicate` simply `lift`s `x` into //! the monadic structure, and then combines that with itself `n` times: //! @code //! replicate<M>(x, n) == cycle(lift<M>(x), n) //! @endcode //! //! If `n` is zero, then the identity of the `concat` operation is returned. //! In the case of sequences, this corresponds to creating a new sequence //! holding `n` copies of `x`. //! //! //! Signature //! --------- //! Given an `IntegralConstant` `C` and MonadPlus `M`, the signature is //! @f$ \mathtt{replicate}_M : T \times C \to M(T) @f$. //! //! @tparam M //! The tag of the returned monadic structure. It must be a //! model of the MonadPlus concept. //! //! @param x //! The value to lift into a monadic structure and then combine with //! itself. //! //! @param n //! A non-negative `IntegralConstant` representing the number of times to //! combine `lift<M>(x)` with itself. If `n == 0`, `replicate` returns //! `empty<M>()`. //! //! //! Example //! ------- //! @include example/replicate.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename M> constexpr auto replicate = [](auto&& x, auto const& n) { return tag-dispatched; }; #else template <typename M, typename = void> struct replicate_impl : replicate_impl<M, when<true>> { }; template <typename M> struct replicate_t { template <typename X, typename N> constexpr auto operator()(X&& x, N const& n) const; }; template <typename M> constexpr replicate_t<M> replicate{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_REPLICATE_HPP PK �|!\s��h h range.hppnu �[��� /*! @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 PK �|!\��ɀ � scan_left.hppnu �[��� /*! @file Forward declares `boost::hana::scan_left`. @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_SCAN_LEFT_HPP #define BOOST_HANA_FWD_SCAN_LEFT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Fold a Sequence to the left and return a list containing the //! successive reduction states. //! @ingroup group-Sequence //! //! Like `fold_left`, `scan_left` reduces a sequence to a single value //! using a binary operation. However, unlike `fold_left`, it builds up //! a sequence of the intermediary results computed along the way and //! returns that instead of only the final reduction state. Like //! `fold_left`, `scan_left` can be used with or without an initial //! reduction state. //! //! When the sequence is empty, two things may arise. If an initial state //! was provided, a singleton list containing that state is returned. //! Otherwise, if no initial state was provided, an empty list is //! returned. In particular, unlike for `fold_left`, using `scan_left` //! on an empty sequence without an initial state is not an error. //! //! More specifically, `scan_left([x1, ..., xn], state, f)` is a sequence //! whose `i`th element is equivalent to `fold_left([x1, ..., xi], state, f)`. //! The no-state variant is handled in an analogous way. For illustration, //! consider this left fold on a short sequence: //! @code //! fold_left([x1, x2, x3], state, f) == f(f(f(state, x1), x2), x3) //! @endcode //! //! The analogous sequence generated with `scan_left` will be //! @code //! scan_left([x1, x2, x3], state, f) == [ //! state, //! f(state, x1), //! f(f(state, x1), x2), //! f(f(f(state, x1), x2), x3) //! ] //! @endcode //! //! Similarly, consider this left fold (without an initial state) on //! a short sequence: //! @code //! fold_left([x1, x2, x3, x4], f) == f(f(f(x1, x2), x3), x4) //! @endcode //! //! The analogous sequence generated with `scan_left` will be //! @code //! scan_left([x1, x2, x3, x4], f) == [ //! x1, //! f(x1, x2), //! f(f(x1, x2), x3), //! f(f(f(x1, x2), x3), x4) //! ] //! @endcode //! //! @param xs //! The sequence to scan from the left. //! //! @param state //! The (optional) initial reduction state. //! //! @param f //! A binary function called as `f(state, x)`, where `state` is the //! result accumulated so far and `x` is an element in the sequence. //! If no initial state is provided, `f` is called as `f(x1, x2)`, //! where `x1` and `x2` are both elements of the sequence. //! //! //! Example //! ------- //! @include example/scan_left.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto scan_left = [](auto&& xs[, auto&& state], auto const& f) { return tag-dispatched; }; #else template <typename S, typename = void> struct scan_left_impl : scan_left_impl<S, when<true>> { }; struct scan_left_t { template <typename Xs, typename State, typename F> constexpr auto operator()(Xs&& xs, State&& state, F const& f) const; template <typename Xs, typename F> constexpr auto operator()(Xs&& xs, F const& f) const; }; constexpr scan_left_t scan_left{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_SCAN_LEFT_HPP PK �|!\ �� � none.hppnu �[��� /*! @file Forward declares `boost::hana::none`. @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_NONE_HPP #define BOOST_HANA_FWD_NONE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns whether all of the keys of the structure are false-valued. //! @ingroup group-Searchable //! //! The keys of the structure must be `Logical`s. If the structure is not //! finite, a true-valued key must appear at a finite "index" in order //! for this method to finish. //! //! //! Example //! ------- //! @include example/none.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto none = [](auto&& xs) -> decltype(auto) { return tag-dispatched; }; #else template <typename S, typename = void> struct none_impl : none_impl<S, when<true>> { }; struct none_t { template <typename Xs> constexpr auto operator()(Xs&& xs) const; }; constexpr none_t none{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_NONE_HPP PK �|!\� X� � find_if.hppnu �[��� /*! @file Forward declares `boost::hana::find_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_FIND_IF_HPP #define BOOST_HANA_FWD_FIND_IF_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Finds the value associated to the first key satisfying a predicate. //! @ingroup group-Searchable //! //! Given a `Searchable` structure `xs` and a predicate `pred`, //! `find_if(xs, pred)` returns `just` the first element whose key //! satisfies the predicate, or `nothing` if there is no such element. //! //! //! @param xs //! The structure to be searched. //! //! @param predicate //! A function called as `predicate(k)`, where `k` is a key of the //! structure, and returning whether `k` is the key of the element //! being searched for. In the current version of the library, the //! predicate has to return an `IntegralConstant` holding a value //! that can be converted to `bool`. //! //! //! Example //! ------- //! @include example/find_if.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto find_if = [](auto&& xs, auto&& predicate) { return tag-dispatched; }; #else template <typename S, typename = void> struct find_if_impl : find_if_impl<S, when<true>> { }; struct find_if_t { template <typename Xs, typename Pred> constexpr auto operator()(Xs&& xs, Pred&& pred) const; }; constexpr find_if_t find_if{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_FIND_IF_HPP PK �|!\� ��6 6 index_if.hppnu �[��� /*! @file Forward declares `boost::hana::index_if`. @copyright Louis Dionne 2013-2017 @copyright Jason Rice 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_INDEX_IF_HPP #define BOOST_HANA_FWD_INDEX_IF_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Finds the value associated to the first key satisfying a predicate. //! @ingroup group-Iterable //! //! Given an `Iterable` structure `xs` and a predicate `pred`, //! `index_if(xs, pred)` returns a `hana::optional` containing an `IntegralConstant` //! of the index of the first element that satisfies the predicate or nothing //! if no element satisfies the predicate. //! //! //! @param xs //! The structure to be searched. //! //! @param predicate //! A function called as `predicate(x)`, where `x` is an element of the //! `Iterable` structure and returning whether `x` is the element being //! searched for. In the current version of the library, the predicate //! has to return an `IntegralConstant` holding a value that can be //! converted to `bool`. //! //! //! Example //! ------- //! @include example/index_if.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto index_if = [](auto&& xs, auto&& predicate) { return tag-dispatched; }; #else template <typename S, typename = void> struct index_if_impl : index_if_impl<S, when<true>> { }; struct index_if_t { template <typename Xs, typename Pred> constexpr auto operator()(Xs&& xs, Pred&& pred) const; }; constexpr index_if_t index_if{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_INDEX_IF_HPP PK �|!\&��G� � take_while.hppnu �[��� /*! @file Forward declares `boost::hana::take_while`. @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_TAKE_WHILE_HPP #define BOOST_HANA_FWD_TAKE_WHILE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Take elements from a sequence while the `predicate` is satisfied. //! @ingroup group-Sequence //! //! Specifically, `take_while` returns a new sequence containing the //! longest prefix of `xs` in which all the elements satisfy the given //! predicate. //! //! //! @param xs //! The sequence to take elements from. //! //! @param predicate //! A function called as `predicate(x)`, where `x` is an element of the //! sequence, and returning a `Logical` representing whether `x` should be //! included in the resulting sequence. In the current version of the //! library, `predicate` has to return a `Constant Logical`. //! //! //! Example //! ------- //! @include example/take_while.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto take_while = [](auto&& xs, auto&& predicate) { return tag-dispatched; }; #else template <typename S, typename = void> struct take_while_impl : take_while_impl<S, when<true>> { }; struct take_while_t { template <typename Xs, typename Pred> constexpr auto operator()(Xs&& xs, Pred&& pred) const; }; constexpr take_while_t take_while{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_TAKE_WHILE_HPP PK �|!\�m~< < adapt_adt.hppnu �[��� /*! @file Documents the `BOOST_HANA_ADAPT_ADT` macro. @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_ADAPT_ADT_HPP #define BOOST_HANA_FWD_ADAPT_ADT_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN // Note: // The weird definition as a variable seems to exploit a glitch in Doxygen // which makes the macro appear in the related objects of Struct (as we // want it to). //! Defines a model of `Struct` with the given accessors. //! @ingroup group-Struct //! //! Using this macro at _global scope_ will define a model of the `Struct` //! concept for the given type. This can be used to easily adapt existing //! user-defined types in a ad-hoc manner. Unlike `BOOST_HANA_ADAPT_STRUCT`, //! this macro requires specifying the way to retrieve each member by //! providing a function that does the extraction. //! //! @note //! This macro only works if the tag of the user-defined type `T` is `T` //! itself. This is the case unless you specifically asked for something //! different; see `tag_of`'s documentation. //! //! //! Example //! ------- //! @include example/adapt_adt.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED auto BOOST_HANA_ADAPT_ADT(...) = ; #define BOOST_HANA_ADAPT_ADT(Name, ...) see documentation #else // defined in <boost/hana/adapt_adt.hpp> #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_ADAPT_ADT_HPP PK �|!\7oqdI dI optional.hppnu �[��� /*! @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 PK �|!\m� at_key.hppnu �[��� /*! @file Forward declares `boost::hana::at_key`. @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_AT_KEY_HPP #define BOOST_HANA_FWD_AT_KEY_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns the value associated to the given key in a structure, or fail. //! @ingroup group-Searchable //! //! Given a `key` and a `Searchable` structure, `at_key` returns the first //! value whose key is equal to the given `key`, and fails at compile-time //! if no such key exists. This requires the `key` to be compile-time //! `Comparable`, exactly like for `find`. `at_key` satisfies the following: //! @code //! at_key(xs, key) == find(xs, key).value() //! @endcode //! //! If the `Searchable` actually stores the elements it contains, `at_key` //! is required to return a lvalue reference, a lvalue reference to const //! or a rvalue reference to the found value, where the type of reference //! must match that of the structure passed to `at_key`. If the `Searchable` //! does not store the elements it contains (i.e. it generates them on //! demand), this requirement is dropped. //! //! //! @param xs //! The structure to be searched. //! //! @param key //! A key to be searched for in the structure. The key has to be //! `Comparable` with the other keys of the structure. In the current //! version of the library, the comparison of `key` with any other key //! of the structure must return a compile-time `Logical`. //! //! //! Example //! ------- //! @include example/at_key.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto at_key = [](auto&& xs, auto const& key) -> decltype(auto) { return tag-dispatched; }; #else template <typename S, typename = void> struct at_key_impl : at_key_impl<S, when<true>> { }; struct at_key_t { template <typename Xs, typename Key> constexpr decltype(auto) operator()(Xs&& xs, Key const& key) const; }; constexpr at_key_t at_key{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_AT_KEY_HPP PK �|!\c�ӑi i drop_front_exactly.hppnu �[��� /*! @file Forward declares `boost::hana::drop_front_exactly`. @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_DROP_FRONT_EXACTLY_HPP #define BOOST_HANA_FWD_DROP_FRONT_EXACTLY_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Drop the first `n` elements of an iterable, and return the rest. //! @ingroup group-Iterable //! //! Given an `Iterable` `xs` with a linearization of `[x1, x2, ...]` and //! a non-negative `IntegralConstant` `n`, `drop_front_exactly(xs, n)` is //! an iterable with the same tag as `xs` whose linearization is //! `[xn+1, xn+2, ...]`. In particular, note that this function does not //! mutate the original iterable in any way. If `n` is not given, it //! defaults to an `IntegralConstant` with a value equal to `1`. //! //! It is an error to use `drop_front_exactly` with `n > length(xs)`. This //! additional guarantee allows `drop_front_exactly` to be better optimized //! than the `drop_front` function, which allows `n > length(xs)`. //! //! //! @param xs //! The iterable from which elements are dropped. //! //! @param n //! A non-negative `IntegralConstant` representing the number of elements //! to be dropped from the iterable. In addition to being non-negative, //! `n` must be less than or equal to the number of elements in `xs`. //! If `n` is not given, it defaults to an `IntegralConstant` with a value //! equal to `1`. //! //! //! Example //! ------- //! @include example/drop_front_exactly.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto drop_front_exactly = [](auto&& xs[, auto const& n]) { return tag-dispatched; }; #else template <typename It, typename = void> struct drop_front_exactly_impl : drop_front_exactly_impl<It, when<true>> { }; struct drop_front_exactly_t { template <typename Xs, typename N> constexpr auto operator()(Xs&& xs, N const& n) const; template <typename Xs> constexpr auto operator()(Xs&& xs) const; }; constexpr drop_front_exactly_t drop_front_exactly{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_DROP_FRONT_EXACTLY_HPP PK �|!\4?֎� � symmetric_difference.hppnu �[��� /*! @file Forward declares `boost::hana::symmetric_difference`. @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_SYMMETRIC_DIFFERENCE_HPP #define BOOST_HANA_FWD_SYMMETRIC_DIFFERENCE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN // Note: This function is documented per datatype/concept only. //! @cond template <typename S, typename = void> struct symmetric_difference_impl : symmetric_difference_impl<S, when<true>> { }; //! @endcond struct symmetric_difference_t { template <typename Xs, typename Ys> constexpr auto operator()(Xs&&, Ys&&) const; }; constexpr symmetric_difference_t symmetric_difference{}; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_SYMMETRIC_DIFFERENCE_HPP PK �|!\T�d�M �M type.hppnu �[��� /*! @file Forward declares `boost::hana::type` and related utilities. @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_TYPE_HPP #define BOOST_HANA_FWD_TYPE_HPP #include <boost/hana/config.hpp> #include <boost/hana/fwd/core/make.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Base class of `hana::type`; used for pattern-matching. //! @relates hana::type //! //! Example //! ------- //! @include example/type/basic_type.cpp template <typename T> struct basic_type; //! @ingroup group-datatypes //! C++ type in value-level representation. //! //! A `type` is a special kind of object representing a C++ type like //! `int`, `void`, `std::vector<float>` or anything else you can imagine. //! //! This page explains how `type`s work at a low level. To gain //! intuition about type-level metaprogramming in Hana, you should //! read the [tutorial section](@ref tutorial-type) on type-level //! computations. //! //! //! @note //! For subtle reasons, the actual representation of `hana::type` is //! implementation-defined. In particular, `hana::type` may be a dependent //! type, so one should not attempt to do pattern matching on it. However, //! one can assume that `hana::type` _inherits_ from `hana::basic_type`, //! which can be useful when declaring overloaded functions: //! @code //! template <typename T> //! void f(hana::basic_type<T>) { //! // do something with T //! } //! @endcode //! The full story is that [ADL][] causes template arguments to be //! instantiated. Hence, if `hana::type` were defined naively, expressions //! like `hana::type<T>{} == hana::type<U>{}` would cause both `T` and `U` //! to be instantiated. This is usually not a problem, except when `T` or //! `U` should not be instantiated. To avoid these instantiations, //! `hana::type` is implemented using some cleverness, and that is //! why the representation is implementation-defined. When that //! behavior is not required, `hana::basic_type` can be used instead. //! //! //! @anchor type_lvalues_and_rvalues //! Lvalues and rvalues //! ------------------- //! When storing `type`s in heterogeneous containers, some algorithms //! will return references to those objects. Since we are primarily //! interested in accessing their nested `::%type`, receiving a reference //! is undesirable; we would end up trying to fetch the nested `::%type` //! inside a reference type, which is a compilation error: //! @code //! auto ts = make_tuple(type_c<int>, type_c<char>); //! using T = decltype(ts[0_c])::type; // error: 'ts[0_c]' is a reference! //! @endcode //! //! For this reason, `type`s provide an overload of the unary `+` //! operator that can be used to turn a lvalue into a rvalue. So when //! using a result which might be a reference to a `type` object, one //! can use `+` to make sure a rvalue is obtained before fetching its //! nested `::%type`: //! @code //! auto ts = make_tuple(type_c<int>, type_c<char>); //! using T = decltype(+ts[0_c])::type; // ok: '+ts[0_c]' is an rvalue //! @endcode //! //! //! Modeled concepts //! ---------------- //! 1. `Comparable`\n //! Two types are equal if and only if they represent the same C++ type. //! Hence, equality is equivalent to the `std::is_same` type trait. //! @include example/type/comparable.cpp //! //! 2. `Hashable`\n //! The hash of a type is just that type itself. In other words, `hash` //! is the identity function on `hana::type`s. //! @include example/type/hashable.cpp //! //! [ADL]: http://en.cppreference.com/w/cpp/language/adl #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename T> struct type { //! Returns rvalue of self. //! See @ref type_lvalues_and_rvalues "description". constexpr auto operator+() const; //! 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); }; #else template <typename T> struct type_impl; template <typename T> using type = typename type_impl<T>::_; #endif //! Tag representing `hana::type`. //! @relates hana::type struct type_tag { }; //! Creates an object representing the C++ type `T`. //! @relates hana::type template <typename T> constexpr type<T> type_c{}; //! `decltype` keyword, lifted to Hana. //! @relates hana::type //! //! @deprecated //! The semantics of `decltype_` can be confusing, and `hana::typeid_` //! should be preferred instead. `decltype_` may be removed in the next //! major version of the library. //! //! `decltype_` is somewhat equivalent to `decltype` in that it returns //! the type of an object, except it returns it as a `hana::type` which //! is a first-class citizen of Hana instead of a raw C++ type. //! Specifically, given an object `x`, `decltype_` satisfies //! @code //! decltype_(x) == type_c<decltype(x) with references stripped> //! @endcode //! //! As you can see, `decltype_` will strip any reference from the //! object's actual type. The reason for doing so is explained below. //! However, any `cv`-qualifiers will be retained. Also, when given a //! `hana::type`, `decltype_` is just the identity function. Hence, //! for any C++ type `T`, //! @code //! decltype_(type_c<T>) == type_c<T> //! @endcode //! //! In conjunction with the way `metafunction` & al. are specified, this //! behavior makes it easier to interact with both types and values at //! the same time. However, it does make it impossible to create a `type` //! containing another `type` with `decltype_`. In other words, it is //! not possible to create a `type_c<decltype(type_c<T>)>` with this //! utility, because `decltype_(type_c<T>)` would be just `type_c<T>` //! instead of `type_c<decltype(type_c<T>)>`. This use case is assumed //! to be rare and a hand-coded function can be used if this is needed. //! //! //! ### Rationale for stripping the references //! The rules for template argument deduction are such that a perfect //! solution that always matches `decltype` is impossible. Hence, we //! have to settle on a solution that's good and and consistent enough //! for our needs. One case where matching `decltype`'s behavior is //! impossible is when the argument is a plain, unparenthesized variable //! or function parameter. In that case, `decltype_`'s argument will be //! deduced as a reference to that variable, but `decltype` would have //! given us the actual type of that variable, without references. Also, //! given the current definition of `metafunction` & al., it would be //! mostly useless if `decltype_` could return a reference, because it //! is unlikely that `F` expects a reference in its simplest use case: //! @code //! int i = 0; //! auto result = metafunction<F>(i); //! @endcode //! //! Hence, always discarding references seems to be the least painful //! solution. //! //! //! Example //! ------- //! @include example/type/decltype.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto decltype_ = see documentation; #else struct decltype_t { template <typename T> constexpr auto operator()(T&&) const; }; constexpr decltype_t decltype_{}; #endif //! Returns a `hana::type` representing the type of a given object. //! @relates hana::type //! //! `hana::typeid_` is somewhat similar to `typeid` in that it returns //! something that represents the type of an object. However, what //! `typeid` returns represent the _runtime_ type of the object, while //! `hana::typeid_` returns the _static_ type of the object. Specifically, //! given an object `x`, `typeid_` satisfies //! @code //! typeid_(x) == type_c<decltype(x) with ref and cv-qualifiers stripped> //! @endcode //! //! As you can see, `typeid_` strips any reference and cv-qualifier from //! the object's actual type. The reason for doing so is that it faithfully //! models how the language's `typeid` behaves with respect to reference //! and cv-qualifiers, and it also turns out to be the desirable behavior //! most of the time. Also, when given a `hana::type`, `typeid_` is just //! the identity function. Hence, for any C++ type `T`, //! @code //! typeid_(type_c<T>) == type_c<T> //! @endcode //! //! In conjunction with the way `metafunction` & al. are specified, this //! behavior makes it easier to interact with both types and values at //! the same time. However, it does make it impossible to create a `type` //! containing another `type` using `typeid_`. This use case is assumed //! to be rare and a hand-coded function can be used if this is needed. //! //! //! Example //! ------- //! @include example/type/typeid.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto typeid_ = see documentation; #else struct typeid_t { template <typename T> constexpr auto operator()(T&&) const; }; constexpr typeid_t typeid_{}; #endif #ifdef BOOST_HANA_DOXYGEN_INVOKED //! Equivalent to `decltype_`, provided for convenience. //! @relates hana::type //! //! //! Example //! ------- //! @include example/type/make.cpp template <> constexpr auto make<type_tag> = hana::decltype_; #endif //! Equivalent to `make<type_tag>`, provided for convenience. //! @relates hana::type //! //! //! Example //! ------- //! @include example/type/make.cpp constexpr auto make_type = hana::make<type_tag>; //! `sizeof` keyword, lifted to Hana. //! @relates hana::type //! //! `sizeof_` is somewhat equivalent to `sizeof` in that it returns the //! size of an expression or type, but it takes an arbitrary expression //! or a `hana::type` and returns its size as an `integral_constant`. //! Specifically, given an expression `expr`, `sizeof_` satisfies //! @code //! sizeof_(expr) == size_t<sizeof(decltype(expr) with references stripped)> //! @endcode //! //! However, given a `type`, `sizeof_` will simply fetch the size //! of the C++ type represented by that object. In other words, //! @code //! sizeof_(type_c<T>) == size_t<sizeof(T)> //! @endcode //! //! The behavior of `sizeof_` is consistent with that of `decltype_`. //! In particular, see `decltype_`'s documentation to understand why //! references are always stripped by `sizeof_`. //! //! //! Example //! ------- //! @include example/type/sizeof.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto sizeof_ = [](auto&& x) { using T = typename decltype(hana::decltype_(x))::type; return hana::size_c<sizeof(T)>; }; #else struct sizeof_t { template <typename T> constexpr auto operator()(T&&) const; }; constexpr sizeof_t sizeof_{}; #endif //! `alignof` keyword, lifted to Hana. //! @relates hana::type //! //! `alignof_` is somewhat equivalent to `alignof` in that it returns the //! alignment required by any instance of a type, but it takes a `type` //! and returns its alignment as an `integral_constant`. Like `sizeof` //! which works for expressions and type-ids, `alignof_` can also be //! called on an arbitrary expression. Specifically, given an expression //! `expr` and a C++ type `T`, `alignof_` satisfies //! @code //! alignof_(expr) == size_t<alignof(decltype(expr) with references stripped)> //! alignof_(type_c<T>) == size_t<alignof(T)> //! @endcode //! //! The behavior of `alignof_` is consistent with that of `decltype_`. //! In particular, see `decltype_`'s documentation to understand why //! references are always stripped by `alignof_`. //! //! //! Example //! ------- //! @include example/type/alignof.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto alignof_ = [](auto&& x) { using T = typename decltype(hana::decltype_(x))::type; return hana::size_c<alignof(T)>; }; #else struct alignof_t { template <typename T> constexpr auto operator()(T&&) const; }; constexpr alignof_t alignof_{}; #endif //! Checks whether a SFINAE-friendly expression is valid. //! @relates hana::type //! //! Given a SFINAE-friendly function, `is_valid` returns whether the //! function call is valid with the given arguments. Specifically, given //! a function `f` and arguments `args...`, //! @code //! is_valid(f, args...) == whether f(args...) is valid //! @endcode //! //! The result is returned as a compile-time `Logical`. Furthermore, //! `is_valid` can be used in curried form as follows: //! @code //! is_valid(f)(args...) //! @endcode //! //! This syntax makes it easy to create functions that check the validity //! of a generic expression on any given argument(s). //! //! @warning //! To check whether calling a nullary function `f` is valid, one should //! use the `is_valid(f)()` syntax. Indeed, `is_valid(f /* no args */)` //! will be interpreted as the currying of `is_valid` to `f` rather than //! the application of `is_valid` to `f` and no arguments. //! //! //! Example //! ------- //! @include example/type/is_valid.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto is_valid = [](auto&& f) { return [](auto&& ...args) { return whether f(args...) is a valid expression; }; }; #else struct is_valid_t { template <typename F> constexpr auto operator()(F&&) const; template <typename F, typename ...Args> constexpr auto operator()(F&&, Args&&...) const; }; constexpr is_valid_t is_valid{}; #endif //! Lift a template to a Metafunction. //! @ingroup group-Metafunction //! //! Given a template class or template alias `f`, `template_<f>` is a //! `Metafunction` satisfying //! @code //! template_<f>(type_c<x>...) == type_c<f<x...>> //! decltype(template_<f>)::apply<x...>::type == f<x...> //! @endcode //! //! @note //! In a SFINAE context, the expression `template_<f>(type_c<x>...)` is //! valid whenever the expression `f<x...>` is valid. //! //! //! Example //! ------- //! @include example/type/template.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <template <typename ...> class F> constexpr auto template_ = [](basic_type<T>...) { return hana::type_c<F<T...>>; }; #else template <template <typename ...> class F> struct template_t; template <template <typename ...> class F> constexpr template_t<F> template_{}; #endif //! Lift a MPL-style metafunction to a Metafunction. //! @ingroup group-Metafunction //! //! Given a MPL-style metafunction, `metafunction<f>` is a `Metafunction` //! satisfying //! @code //! metafunction<f>(type_c<x>...) == type_c<f<x...>::type> //! decltype(metafunction<f>)::apply<x...>::type == f<x...>::type //! @endcode //! //! @note //! In a SFINAE context, the expression `metafunction<f>(type_c<x>...)` is //! valid whenever the expression `f<x...>::%type` is valid. //! //! //! Example //! ------- //! @include example/type/metafunction.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <template <typename ...> class F> constexpr auto metafunction = [](basic_type<T>...) { return hana::type_c<typename F<T...>::type>; }; #else template <template <typename ...> class f> struct metafunction_t; template <template <typename ...> class f> constexpr metafunction_t<f> metafunction{}; #endif //! Lift a MPL-style metafunction class to a Metafunction. //! @ingroup group-Metafunction //! //! Given a MPL-style metafunction class, `metafunction_class<f>` is a //! `Metafunction` satisfying //! @code //! metafunction_class<f>(type_c<x>...) == type_c<f::apply<x...>::type> //! decltype(metafunction_class<f>)::apply<x...>::type == f::apply<x...>::type //! @endcode //! //! @note //! In a SFINAE context, the expression `metafunction_class<f>(type_c<x>...)` //! is valid whenever the expression `f::apply<x...>::%type` is valid. //! //! //! Example //! ------- //! @include example/type/metafunction_class.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename F> constexpr auto metafunction_class = [](basic_type<T>...) { return hana::type_c<typename F::template apply<T...>::type>; }; #else template <typename F> struct metafunction_class_t; template <typename F> constexpr metafunction_class_t<F> metafunction_class{}; #endif //! Turn a `Metafunction` into a function taking `type`s and returning a //! default-constructed object. //! @ingroup group-Metafunction //! //! Given a `Metafunction` `f`, `integral` returns a new `Metafunction` //! that default-constructs an object of the type returned by `f`. More //! specifically, the following holds: //! @code //! integral(f)(t...) == decltype(f(t...))::type{} //! @endcode //! //! The principal use case for `integral` is to transform `Metafunction`s //! returning a type that inherits from a meaningful base like //! `std::integral_constant` into functions returning e.g. a //! `hana::integral_constant`. //! //! @note //! - This is not a `Metafunction` because it does not return a `type`. //! As such, it would not make sense to make `decltype(integral(f))` //! a MPL metafunction class like the usual `Metafunction`s are. //! //! - When using `integral` with metafunctions returning //! `std::integral_constant`s, don't forget to include the //! boost/hana/ext/std/integral_constant.hpp header to ensure //! Hana can interoperate with the result. //! //! - In a SFINAE context, the expression `integral(f)(t...)` is valid //! whenever the expression `decltype(f(t...))::%type` is valid. //! //! //! Example //! ------- //! @include example/type/integral.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto integral = [](auto f) { return [](basic_type<T>...) { return decltype(f)::apply<T...>::type{}; }; }; #else template <typename F> struct integral_t; struct make_integral_t { template <typename F> constexpr integral_t<F> operator()(F const&) const { return {}; } }; constexpr make_integral_t integral{}; #endif //! Alias to `integral(metafunction<F>)`, provided for convenience. //! @ingroup group-Metafunction //! //! //! Example //! ------- //! @include example/type/trait.cpp template <template <typename ...> class F> constexpr auto trait = hana::integral(hana::metafunction<F>); BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_TYPE_HPP PK �|!\��h� � bool.hppnu �[��� /*! @file Includes boost/hana/fwd/integral_constant.hpp. @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_BOOL_HPP #define BOOST_HANA_FWD_BOOL_HPP #include <boost/hana/fwd/integral_constant.hpp> #endif // !BOOST_HANA_FWD_BOOL_HPP PK �|!\�8��� � or.hppnu �[��� /*! @file Forward declares `boost::hana::or_`. @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_OR_HPP #define BOOST_HANA_FWD_OR_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Return whether any of the arguments is true-valued. //! @ingroup group-Logical //! //! `or_` can be called with one argument or more. When called with //! two arguments, `or_` uses tag-dispatching to find the right //! implementation. Otherwise, //! @code //! or_(x) == x //! or_(x, y, ...z) == or_(or_(x, y), z...) //! @endcode //! //! //! Example //! ------- //! @include example/or.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto or_ = [](auto&& x, auto&& ...y) -> decltype(auto) { return tag-dispatched; }; #else template <typename L, typename = void> struct or_impl : or_impl<L, when<true>> { }; struct or_t { template <typename X, typename Y> constexpr decltype(auto) operator()(X&& x, Y&& y) const; template <typename X, typename ...Y> constexpr decltype(auto) operator()(X&& x, Y&& ...y) const; }; constexpr or_t or_{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_OR_HPP PK �|!\��I permutations.hppnu �[��� /*! @file Forward declares `boost::hana::permutations`. @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_PERMUTATIONS_HPP #define BOOST_HANA_FWD_PERMUTATIONS_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Return a sequence of all the permutations of the given sequence. //! @ingroup group-Sequence //! //! Specifically, `permutations(xs)` is a sequence whose elements are //! permutations of the original sequence `xs`. The permutations are not //! guaranteed to be in any specific order. Also note that the number //! of permutations grows very rapidly as the length of the original //! sequence increases. The growth rate is `O(length(xs)!)`; with a //! sequence `xs` of length only 8, `permutations(xs)` contains over //! 40 000 elements! //! //! //! Example //! ------- //! @include example/permutations.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto permutations = [](auto&& xs) { return tag-dispatched; }; #else template <typename S, typename = void> struct permutations_impl : permutations_impl<S, when<true>> { }; struct permutations_t { template <typename Xs> constexpr auto operator()(Xs&& xs) const; }; constexpr permutations_t permutations{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_PERMUTATIONS_HPP PK �|!\> greater_equal.hppnu �[��� /*! @file Forward declares `boost::hana::greater_equal`. @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_GREATER_EQUAL_HPP #define BOOST_HANA_FWD_GREATER_EQUAL_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/detail/nested_than_fwd.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns a `Logical` representing whether `x` is greater than or //! equal to `y`. //! @ingroup group-Orderable //! //! //! Signature //! --------- //! Given a Logical `Bool` and two Orderables `A` and `B` with a common //! embedding, the signature is //! @f$ \mathrm{greater\_equal} : A \times B \to Bool @f$. //! //! @param x, y //! Two objects to compare. //! //! //! Example //! ------- //! @include example/greater_equal.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto greater_equal = [](auto&& x, auto&& y) -> decltype(auto) { return tag-dispatched; }; #else template <typename T, typename U, typename = void> struct greater_equal_impl : greater_equal_impl<T, U, when<true>> { }; struct greater_equal_t : detail::nested_than<greater_equal_t> { template <typename X, typename Y> constexpr decltype(auto) operator()(X&& x, Y&& y) const; }; constexpr greater_equal_t greater_equal{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_GREATER_EQUAL_HPP PK �|!\]��y� � all.hppnu �[��� /*! @file Forward declares `boost::hana::all`. @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_ALL_HPP #define BOOST_HANA_FWD_ALL_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns whether all the keys of the structure are true-valued. //! @ingroup group-Searchable //! //! The keys of the structure must be `Logical`s. If the structure is not //! finite, a false-valued key must appear at a finite "index" in order //! for this method to finish. //! //! //! Example //! ------- //! @include example/all.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto all = [](auto&& xs) { return tag-dispatched; }; #else template <typename S, typename = void> struct all_impl : all_impl<S, when<true>> { }; struct all_t { template <typename Xs> constexpr auto operator()(Xs&& xs) const; }; constexpr all_t all{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_ALL_HPP PK �|!\\g�� � greater.hppnu �[��� /*! @file Forward declares `boost::hana::greater`. @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_GREATER_HPP #define BOOST_HANA_FWD_GREATER_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/detail/nested_than_fwd.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns a `Logical` representing whether `x` is greater than `y`. //! @ingroup group-Orderable //! //! //! Signature //! --------- //! Given a Logical `Bool` and two Orderables `A` and `B` with a common //! embedding, the signature is //! @f$ \mathrm{greater} : A \times B \to Bool @f$. //! //! @param x, y //! Two objects to compare. //! //! //! Example //! ------- //! @include example/greater.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto greater = [](auto&& x, auto&& y) -> decltype(auto) { return tag-dispatched; }; #else template <typename T, typename U, typename = void> struct greater_impl : greater_impl<T, U, when<true>> { }; struct greater_t : detail::nested_than<greater_t> { template <typename X, typename Y> constexpr decltype(auto) operator()(X&& x, Y&& y) const; }; constexpr greater_t greater{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_GREATER_HPP PK �|!\�q3�� � extend.hppnu �[��� /*! @file Forward declares `boost::hana::extend`. @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_EXTEND_HPP #define BOOST_HANA_FWD_EXTEND_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Comonadic application of a function to a comonadic value. //! @ingroup group-Comonad //! //! Given a comonadic value and a function accepting a comonadic input, //! `extend` returns the result of applying the function to that input //! inside the comonadic context. //! //! //! Signature //! --------- //! Given a Comonad `W` and a function of type \f$ W(T) \to U \f$, the //! signature is //! \f$ //! \mathtt{extend} : W(T) \times (W(T) \to U) \to W(U) //! \f$ //! //! @param w //! A comonadic value to call the function with. //! //! @param f //! A function of signature \f$ W(T) \to U \f$ to be applied to its //! comonadic argument inside the comonadic context. //! //! //! Example //! ------- //! @include example/extend.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto extend = [](auto&& w, auto&& f) -> decltype(auto) { return tag-dispatched; }; #else template <typename W, typename = void> struct extend_impl : extend_impl<W, when<true>> { }; struct extend_t { template <typename W_, typename F> constexpr decltype(auto) operator()(W_&& w, F&& f) const; }; constexpr extend_t extend{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_EXTEND_HPP PK �|!\�T?� � all_of.hppnu �[��� /*! @file Forward declares `boost::hana::all_of`. @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_ALL_OF_HPP #define BOOST_HANA_FWD_ALL_OF_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns whether all the keys of the structure satisfy the `predicate`. //! @ingroup group-Searchable //! //! If the structure is not finite, `predicate` has to return a false- //! valued `Logical` after looking at a finite number of keys for this //! method to finish. //! //! //! @param xs //! The structure to search. //! //! @param predicate //! A function called as `predicate(k)`, where `k` is a key of the //! structure, and returning a `Logical`. //! //! //! Example //! ------- //! @include example/all_of.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto all_of = [](auto&& xs, auto&& predicate) { return tag-dispatched; }; #else template <typename S, typename = void> struct all_of_impl : all_of_impl<S, when<true>> { }; struct all_of_t { template <typename Xs, typename Pred> constexpr auto operator()(Xs&& xs, Pred&& pred) const; }; constexpr all_of_t all_of{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_ALL_OF_HPP PK �|!\'}-- - cartesian_product.hppnu �[��� /*! @file Forward declares `boost::hana::cartesian_product`. @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_CARTESIAN_PRODUCT_HPP #define BOOST_HANA_FWD_CARTESIAN_PRODUCT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Computes the cartesian product of a sequence of sequences. //! @ingroup group-Sequence //! //! Given a sequence of sequences, `cartesian_product` returns a new //! sequence of sequences containing the cartesian product of the //! original sequences. For this method to finish, a finite number //! of finite sequences must be provided. //! //! @note //! All the sequences must have the same tag, and that tag must also match //! that of the top-level sequence. //! //! //! Signature //! --------- //! Given a `Sequence` `S(T)`, the signature is //! \f[ //! \mathtt{cartesian\_product} : S(S(T)) \to S(S(T)) //! \f] //! //! @param xs //! A sequence of sequences of which the cartesian product is computed. //! //! //! Example //! ------- //! @include example/cartesian_product.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto cartesian_product = [](auto&& xs) { return tag-dispatched; }; #else template <typename S, typename = void> struct cartesian_product_impl : cartesian_product_impl<S, when<true>> { }; struct cartesian_product_t { template <typename Xs> constexpr auto operator()(Xs&& xs) const; }; constexpr cartesian_product_t cartesian_product{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CARTESIAN_PRODUCT_HPP PK �|!\\��� � while.hppnu �[��� /*! @file Forward declares `boost::hana::while_`. @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_WHILE_HPP #define BOOST_HANA_FWD_WHILE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Apply a function to an initial state while some predicate is satisfied. //! @ingroup group-Logical //! //! This method is a natural extension of the `while` language construct //! to manipulate a state whose type may change from one iteration to //! another. However, note that having a state whose type changes from //! one iteration to the other is only possible as long as the predicate //! returns a `Logical` whose truth value is known at compile-time. //! //! Specifically, `while_(pred, state, f)` is equivalent to //! @code //! f(...f(f(state))) //! @endcode //! where `f` is iterated as long as `pred(f(...))` is a true-valued //! `Logical`. //! //! //! @param pred //! A predicate called on the state or on the result of applying `f` a //! certain number of times to the state, and returning whether `f` //! should be applied one more time. //! //! @param state //! The initial state on which `f` is applied. //! //! @param f //! A function that is iterated on the initial state. Note that the //! return type of `f` may change from one iteration to the other, //! but only while `pred` returns a compile-time `Logical`. In other //! words, `decltype(f(stateN))` may differ from `decltype(f(stateN+1))`, //! but only if `pred(f(stateN))` returns a compile-time `Logical`. //! //! //! Example //! ------- //! @include example/while.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto while_ = [](auto&& pred, auto&& state, auto&& f) -> decltype(auto) { return tag-dispatched; }; #else template <typename L, typename = void> struct while_impl : while_impl<L, when<true>> { }; struct while_t { template <typename Pred, typename State, typename F> constexpr decltype(auto) operator()(Pred&& pred, State&& state, F&& f) const; }; constexpr while_t while_{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_WHILE_HPP PK �|!\U�:j� � minimum.hppnu �[��� /*! @file Forward declares `boost::hana::minimum`. @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_MINIMUM_HPP #define BOOST_HANA_FWD_MINIMUM_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/detail/nested_by_fwd.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Return the least element of a non-empty structure with respect to //! a `predicate`, by default `less`. //! @ingroup group-Foldable //! //! Given a non-empty structure and an optional binary predicate //! (`less` by default), `minimum` returns the least element of //! the structure, i.e. an element which is less than or equal to //! every other element in the structure, according to the predicate. //! //! If the structure contains heterogeneous objects, then the predicate //! must return a compile-time `Logical`. If no predicate is provided, //! the elements in the structure must be Orderable, or compile-time //! Orderable if the structure is heterogeneous. //! //! //! Signature //! --------- //! Given a `Foldable` `F`, a Logical `Bool` and a predicate //! \f$ \mathtt{pred} : T \times T \to Bool \f$, `minimum` has the //! following signatures. For the variant with a provided predicate, //! \f[ //! \mathtt{minimum} : F(T) \times (T \times T \to Bool) \to T //! \f] //! //! for the variant without a custom predicate, `T` is required to be //! Orderable. The signature is then //! \f[ //! \mathtt{minimum} : F(T) \to T //! \f] //! //! @param xs //! The structure to find the least element of. //! //! @param predicate //! A function called as `predicate(x, y)`, where `x` and `y` are elements //! of the structure. `predicate` should be a strict weak ordering on the //! elements of the structure and its return value should be a Logical, //! or a compile-time Logical if the structure is heterogeneous. //! //! ### Example //! @include example/minimum.cpp //! //! //! Syntactic sugar (`minimum.by`) //! ------------------------------ //! `minimum` can be called in a third way, which provides a nice syntax //! especially when working with the `ordering` combinator: //! @code //! minimum.by(predicate, xs) == minimum(xs, predicate) //! minimum.by(predicate) == minimum(-, predicate) //! @endcode //! //! where `minimum(-, predicate)` denotes the partial application of //! `minimum` to `predicate`. //! //! ### Example //! @include example/minimum_by.cpp //! //! //! Tag dispatching //! --------------- //! Both the non-predicated version and the predicated versions of //! `minimum` are tag-dispatched methods, and hence they can be //! customized independently. One reason for this is that some //! structures are able to provide a much more efficient implementation //! of `minimum` when the `less` predicate is used. Here is how the //! different versions of `minimum` are dispatched: //! @code //! minimum(xs) -> minimum_impl<tag of xs>::apply(xs) //! minimum(xs, pred) -> minimum_pred_impl<tag of xs>::apply(xs, pred) //! @endcode //! //! Also note that `minimum.by` is not tag-dispatched on its own, since it //! is just syntactic sugar for calling the corresponding `minimum`. #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto minimum = [](auto&& xs[, auto&& predicate]) -> decltype(auto) { return tag-dispatched; }; #else template <typename T, typename = void> struct minimum_impl : minimum_impl<T, when<true>> { }; template <typename T, typename = void> struct minimum_pred_impl : minimum_pred_impl<T, when<true>> { }; struct minimum_t : detail::nested_by<minimum_t> { template <typename Xs> constexpr decltype(auto) operator()(Xs&& xs) const; template <typename Xs, typename Predicate> constexpr decltype(auto) operator()(Xs&& xs, Predicate&& pred) const; }; constexpr minimum_t minimum{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_MINIMUM_HPP PK �|!\� �� � chain.hppnu �[��� /*! @file Forward declares `boost::hana::chain`. @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_CHAIN_HPP #define BOOST_HANA_FWD_CHAIN_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Feed a monadic value into a monadic computation. //! @ingroup group-Monad //! //! Given a monadic value and a monadic function, `chain` feeds the //! monadic value into the function, thus performing some Monad-specific //! effects, and returns the result. An implementation of `chain` must //! satisfy //! @code //! chain(xs, f) == flatten(transform(xs, f)) //! @endcode //! //! //! Signature //! --------- //! For a monad `M`, given a monadic value of type `M(A)` and a monadic //! function @f$ f : A \to M(B) @f$, `chain` has the signature //! @f$ //! \mathtt{chain} : M(A) \times (A \to M(B)) \to M(B) //! @f$. //! //! @param xs //! A monadic value to be fed to the function `f`. //! //! @param f //! A function taking a normal value in the `xs` structure, and returning //! a monadic value. This function is called as `f(x)`, where `x` is an //! element of the structure `xs`. //! //! //! Example //! ------- //! @include example/chain.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto chain = [](auto&& xs, auto&& f) -> decltype(auto) { return tag-dispatched; }; #else template <typename M, typename = void> struct chain_impl : chain_impl<M, when<true>> { }; struct chain_t { template <typename Xs, typename F> constexpr decltype(auto) operator()(Xs&& xs, F&& f) const; }; constexpr chain_t chain{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CHAIN_HPP PK �|!\ �?� � remove.hppnu �[��� /*! @file Forward declares `boost::hana::remove`. @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_REMOVE_HPP #define BOOST_HANA_FWD_REMOVE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Remove all the elements of a monadic structure that are equal to some //! value. //! @ingroup group-MonadPlus //! //! Given a monadic structure `xs` and a `value`, `remove` returns a new //! monadic structure equal to `xs` without all its elements that are //! equal to the given `value`. `remove` is equivalent to `remove_if` //! with the `equal.to(value)` predicate, i.e. //! @code //! remove(xs, value) == remove_if(xs, equal.to(value)) //! @endcode //! //! //! Signature //! --------- //! Given a MonadPlus `M` and a value of type `T`, the signature is //! \f$ //! \mathrm{remove} : M(T) \times T \to M(T) //! \f$ //! //! @param xs //! A monadic structure to remove some elements from. //! //! @param value //! A value that is compared to every element `x` of the structure. //! Elements of the structure that are equal to that value are removed //! from the structure. This requires every element to be Comparable //! with `value`. Furthermore, in the current version of the library, //! comparing `value` with any element of the structure must yield a //! compile-time Logical. //! //! //! Example //! ------- //! @include example/remove.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto remove = [](auto&& xs, auto&& value) { return tag-dispatched; }; #else template <typename M, typename = void> struct remove_impl : remove_impl<M, when<true>> { }; struct remove_t { template <typename Xs, typename Value> constexpr auto operator()(Xs&& xs, Value&& value) const; }; constexpr remove_t remove{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_REMOVE_HPP PK �|!\���0� � partition.hppnu �[��� /*! @file Forward declares `boost::hana::partition`. @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_PARTITION_HPP #define BOOST_HANA_FWD_PARTITION_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/detail/nested_by_fwd.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Partition a sequence based on a `predicate`. //! @ingroup group-Sequence //! //! Specifically, returns an unspecified `Product` whose first element is //! a sequence of the elements satisfying the predicate, and whose second //! element is a sequence of the elements that do not satisfy the predicate. //! //! //! Signature //! --------- //! Given a Sequence `S(T)`, an `IntegralConstant` `Bool` holding a value //! of type `bool`, and a predicate \f$ T \to Bool \f$, `partition` has //! the following signature: //! \f[ //! \mathtt{partition} : S(T) \times (T \to Bool) \to S(T) \times S(T) //! \f] //! //! @param xs //! The sequence to be partitioned. //! //! @param predicate //! A function called as `predicate(x)` for each element `x` in the //! sequence, and returning whether `x` should be added to the sequence //! in the first component or in the second component of the resulting //! pair. In the current version of the library, `predicate` must return //! an `IntegralConstant` holding a value convertible to `bool`. //! //! //! Syntactic sugar (`partition.by`) //! -------------------------------- //! `partition` can be called in an alternate way, which provides a nice //! syntax in some cases where the predicate is short: //! @code //! partition.by(predicate, xs) == partition(xs, predicate) //! partition.by(predicate) == partition(-, predicate) //! @endcode //! //! where `partition(-, predicate)` denotes the partial application of //! `partition` to `predicate`. //! //! //! Example //! ------- //! @include example/partition.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto partition = [](auto&& xs, auto&& predicate) { return tag-dispatched; }; #else template <typename S, typename = void> struct partition_impl : partition_impl<S, when<true>> { }; struct partition_t : detail::nested_by<partition_t> { template <typename Xs, typename Pred> constexpr auto operator()(Xs&& xs, Pred&& pred) const; }; constexpr partition_t partition{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_PARTITION_HPP PK �|!\�d�** ** string.hppnu �[��� /*! @file Forward declares `boost::hana::string`. @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_STRING_HPP #define BOOST_HANA_FWD_STRING_HPP #include <boost/hana/config.hpp> #include <boost/hana/fwd/core/make.hpp> #include <boost/hana/fwd/core/to.hpp> BOOST_HANA_NAMESPACE_BEGIN #ifdef BOOST_HANA_DOXYGEN_INVOKED //! @ingroup group-datatypes //! Compile-time string. //! //! Conceptually, a `hana::string` is like a tuple holding //! `integral_constant`s of underlying type `char`. However, the //! interface of `hana::string` is not as rich as that of a tuple, //! because a string can only hold compile-time characters as opposed //! to any kind of object. //! //! Compile-time strings are used for simple purposes like being keys in a //! `hana::map` or tagging the members of a `Struct`. However, you might //! find that `hana::string` does not provide enough functionality to be //! used as a full-blown compile-time string implementation (e.g. regexp //! matching or substring finding). Indeed, providing a comprehensive //! string interface is a lot of job, and it is out of the scope of the //! library for the time being. //! //! //! @note //! The representation of `hana::string` is implementation-defined. //! In particular, one should not take for granted that the template //! parameters are `char`s. The proper way to access the contents of //! a `hana::string` as character constants is to use `hana::unpack`, //! `.c_str()` or `hana::to<char const*>`, as documented below. More //! details [in the tutorial](@ref tutorial-containers-types). //! //! //! Modeled concepts //! ---------------- //! For most purposes, a `hana::string` is functionally equivalent to a //! tuple holding `Constant`s of underlying type `char`. //! //! 1. `Comparable`\n //! Two strings are equal if and only if they have the same number of //! characters and characters at corresponding indices are equal. //! @include example/string/comparable.cpp //! //! 2. `Orderable`\n //! The total order implemented for `Orderable` is the usual //! lexicographical comparison of strings. //! @include example/string/orderable.cpp //! //! 3. `Monoid`\n //! Strings form a monoid under concatenation, with the neutral element //! being the empty string. //! @include example/string/monoid.cpp //! //! 4. `Foldable`\n //! Folding a string is equivalent to folding the sequence of its //! characters. //! @include example/string/foldable.cpp //! //! 5. `Iterable`\n //! Iterating over a string is equivalent to iterating over the sequence //! of its characters. Also note that `operator[]` can be used instead of //! the `at` function. //! @include example/string/iterable.cpp //! //! 6. `Searchable`\n //! Searching through a string is equivalent to searching through the //! sequence of its characters. //! @include example/string/searchable.cpp //! //! 7. `Hashable`\n //! The hash of a compile-time string is a type uniquely representing //! that string. //! @include example/string/hashable.cpp //! //! //! Conversion to `char const*` //! --------------------------- //! A `hana::string` can be converted to a `constexpr` null-delimited //! string of type `char const*` by using the `c_str()` method or //! `hana::to<char const*>`. This makes it easy to turn a compile-time //! string into a runtime string. However, note that this conversion is //! not an embedding, because `char const*` does not model the same //! concepts as `hana::string` does. //! @include example/string/to.cpp //! //! Conversion from any Constant holding a `char const*` //! ---------------------------------------------------- //! A `hana::string` can be created from any `Constant` whose underlying //! value is convertible to a `char const*` by using `hana::to`. The //! contents of the `char const*` are used to build the content of the //! `hana::string`. //! @include example/string/from_c_str.cpp //! //! Rationale for `hana::string` not being a `Constant` itself //! ---------------------------------------------------------- //! The underlying type held by a `hana::string` could be either `char const*` //! or some other constexpr-enabled string-like container. In the first case, //! `hana::string` can not be a `Constant` because the models of several //! concepts would not be respected by the underlying type, causing `value` //! not to be structure-preserving. Providing an underlying value of //! constexpr-enabled string-like container type like `std::string_view` //! would be great, but that's a bit complicated for the time being. template <typename implementation_defined> struct string { // Default-construct a `hana::string`; no-op since `hana::string` is stateless. constexpr string() = default; // Copy-construct a `hana::string`; no-op since `hana::string` is stateless. constexpr string(string const&) = default; //! 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); //! Performs concatenation; equivalent to `hana::plus` 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); //! Returns a null-delimited C-style string. static constexpr char const* c_str(); }; #else template <char ...s> struct string; #endif //! Tag representing a compile-time string. //! @relates hana::string struct string_tag { }; #ifdef BOOST_HANA_DOXYGEN_INVOKED //! Create a compile-time `hana::string` from a parameter pack of `char` //! `integral_constant`s. //! @relates hana::string //! //! Given zero or more `integral_constant`s of underlying type `char`, //! `make<string_tag>` creates a `hana::string` containing those characters. //! This is provided mostly for consistency with the rest of the library, //! as `hana::string_c` is more convenient to use in most cases. //! //! //! Example //! ------- //! @include example/string/make.cpp template <> constexpr auto make<string_tag> = [](auto&& ...chars) { return string<implementation_defined>{}; }; #endif //! Alias to `make<string_tag>`; provided for convenience. //! @relates hana::string constexpr auto make_string = make<string_tag>; //! Equivalent to `to<string_tag>`; provided for convenience. //! @relates hana::string constexpr auto to_string = to<string_tag>; //! Create a compile-time string from a parameter pack of characters. //! @relates hana::string //! //! //! Example //! ------- //! @include example/string/string_c.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <char ...s> constexpr string<implementation_defined> string_c{}; #else template <char ...s> constexpr string<s...> string_c{}; #endif //! Create a compile-time string from a string literal. //! @relates hana::string //! //! This macro is a more convenient alternative to `string_c` for creating //! compile-time strings. However, since this macro uses a lambda //! internally, it can't be used in an unevaluated context, or where //! a constant expression is expected before C++17. //! //! //! Example //! ------- //! @include example/string/macro.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED auto BOOST_HANA_STRING(s) = see documentation; #define BOOST_HANA_STRING(s) see documentation // Note: // The trick above seems to exploit a bug in Doxygen, which makes the // BOOST_HANA_STRING macro appear in the related objects of hana::string // (as we want it to). #else // defined in <boost/hana/string.hpp> #endif #ifdef BOOST_HANA_CONFIG_ENABLE_STRING_UDL namespace literals { //! Creates a compile-time string from a string literal. //! @relatesalso boost::hana::string //! //! The string literal is parsed at compile-time and the result is //! returned as a `hana::string`. This feature is an extension that //! is disabled by default; see below for details. //! //! @note //! Only narrow string literals are supported right now; support for //! fancier types of string literals like wide or UTF-XX might be //! added in the future if there is a demand for it. See [this issue] //! [Hana.issue80] if you need this. //! //! @warning //! This user-defined literal is an extension which requires a special //! string literal operator that is not part of the standard yet. //! That operator is supported by both Clang and GCC, and several //! proposals were made for it to enter C++17. However, since it is //! not standard, it is disabled by default and defining the //! `BOOST_HANA_CONFIG_ENABLE_STRING_UDL` config macro is required //! to get this operator. Hence, if you want to stay safe, just use //! the `BOOST_HANA_STRING` macro instead. If you want to be fast and //! furious (I do), define `BOOST_HANA_CONFIG_ENABLE_STRING_UDL`. //! //! //! Example //! ------- //! @include example/string/literal.cpp //! //! [Hana.issue80]: https://github.com/boostorg/hana/issues/80 template <typename CharT, CharT ...s> constexpr auto operator"" _s(); } #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_STRING_HPP PK �|!\R���� � find.hppnu �[��� /*! @file Forward declares `boost::hana::find`. @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_FIND_HPP #define BOOST_HANA_FWD_FIND_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Finds the value associated to the given key in a structure. //! @ingroup group-Searchable //! //! Given a `key` and a `Searchable` structure, `find` returns the `just` //! the first value whose key is equal to the given `key`, or `nothing` if //! there is no such key. Comparison is done with `equal`. `find` satisfies //! the following: //! @code //! find(xs, key) == find_if(xs, equal.to(key)) //! @endcode //! //! //! @param xs //! The structure to be searched. //! //! @param key //! A key to be searched for in the structure. The key has to be //! `Comparable` with the other keys of the structure. In the current //! version of the library, the comparison of `key` with any other key //! of the structure must return a compile-time `Logical`. //! //! //! Example //! ------- //! @include example/find.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto find = [](auto&& xs, auto const& key) { return tag-dispatched; }; #else template <typename S, typename = void> struct find_impl : find_impl<S, when<true>> { }; struct find_t { template <typename Xs, typename Key> constexpr auto operator()(Xs&& xs, Key const& key) const; }; constexpr find_t find{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_FIND_HPP PK �|!\��i�~ ~ max.hppnu �[��� /*! @file Forward declares `boost::hana::max`. @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_MAX_HPP #define BOOST_HANA_FWD_MAX_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns the greatest of its arguments according to the `less` ordering. //! @ingroup group-Orderable //! //! //! @todo Can't specify the signature here either. See `min` for details. //! //! Example //! ------- //! @include example/max.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto max = [](auto&& x, auto&& y) -> decltype(auto) { return tag-dispatched; }; #else template <typename T, typename U, typename = void> struct max_impl : max_impl<T, U, when<true>> { }; struct max_t { template <typename X, typename Y> constexpr decltype(auto) operator()(X&& x, Y&& y) const; }; constexpr max_t max{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_MAX_HPP PK �|!\]�eW W value.hppnu �[��� /*! @file Forward declares `boost::hana::value`. @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_VALUE_HPP #define BOOST_HANA_FWD_VALUE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Return the compile-time value associated to a constant. //! @ingroup group-Constant //! //! This function returns the value associated to a `Constant`. That //! value is always a constant expression. The normal way of using //! `value` on an object `c` is //! @code //! constexpr auto result = hana::value<decltype(c)>(); //! @endcode //! //! However, for convenience, an overload of `value` is provided so that //! it can be called as: //! @code //! constexpr auto result = hana::value(c); //! @endcode //! //! This overload works by taking a `const&` to its argument, and then //! forwarding to the first version of `value`. Since it does not use //! its argument, the result can still be a constant expression, even //! if the argument is not a constant expression. //! //! @note //! `value<T>()` is tag-dispatched as `value_impl<C>::%apply<T>()`, where //! `C` is the tag of `T`. //! //! @note //! `hana::value` is an overloaded function, not a function object. //! Hence, it can't be passed to higher-order algorithms. If you need //! an equivalent function object, use `hana::value_of` instead. //! //! //! Example //! ------- //! @include example/value.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename T> constexpr auto value = []() -> decltype(auto) { return tag-dispatched; }; #else template <typename C, typename = void> struct value_impl : value_impl<C, when<true>> { }; template <typename T> constexpr decltype(auto) value(); template <typename T> constexpr decltype(auto) value(T const&) { return hana::value<T>(); } #endif //! Equivalent to `value`, but can be passed to higher-order algorithms. //! @ingroup group-Constant //! //! This function object is equivalent to `value`, except it can be passed //! to higher order algorithms because it is a function object. `value` //! can't be passed to higher-order algorithms because it is implemented //! as an overloaded function. //! //! @note //! This function is a simple alias to `value`, and hence it is not //! tag-dispatched and can't be customized. //! //! //! Example //! ------- //! @include example/value_of.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto value_of = [](auto const& c) -> decltype(auto) { return hana::value(c); }; #else struct value_of_t { template <typename T> constexpr decltype(auto) operator()(T const&) const { return hana::value<T>(); } }; constexpr value_of_t value_of{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_VALUE_HPP PK �|!\�X� � mult.hppnu �[��� /*! @file Forward declares `boost::hana::mult`. @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_MULT_HPP #define BOOST_HANA_FWD_MULT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Associative operation of a `Ring`. //! @ingroup group-Ring //! //! @param x, y //! Two `Ring` elements to combine with the `Ring` binary operation. //! //! //! Cross-type version of the method //! -------------------------------- //! The `mult` method is "overloaded" to handle distinct data types //! with certain properties. Specifically, `mult` is defined for //! _distinct_ data types `A` and `B` such that //! 1. `A` and `B` share a common data type `C`, as determined by the //! `common` metafunction //! 2. `A`, `B` and `C` are all `Ring`s when taken individually //! 3. `to<C> : A -> B` and `to<C> : B -> C` are `Ring`-embeddings, as //! determined by the `is_embedding` metafunction. //! //! The definition of `mult` for data types satisfying the above //! properties is obtained by setting //! @code //! mult(x, y) = mult(to<C>(x), to<C>(y)) //! @endcode //! //! //! Example //! ------- //! @include example/mult.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto mult = [](auto&& x, auto&& y) -> decltype(auto) { return tag-dispatched; }; #else template <typename T, typename U, typename = void> struct mult_impl : mult_impl<T, U, when<true>> { }; struct mult_t { template <typename X, typename Y> constexpr decltype(auto) operator()(X&& x, Y&& y) const; }; constexpr mult_t mult{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_MULT_HPP PK �|!\&�?� � insert.hppnu �[��� /*! @file Forward declares `boost::hana::insert`. @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_INSERT_HPP #define BOOST_HANA_FWD_INSERT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN // Note: This function is documented per datatype/concept only. //! @cond template <typename T, typename = void> struct insert_impl : insert_impl<T, when<true>> { }; //! @endcond struct insert_t { template <typename Set, typename ...Args> constexpr decltype(auto) operator()(Set&& set, Args&& ...args) const; }; constexpr insert_t insert{}; //! Insert a value at a given index in a sequence. //! @ingroup group-Sequence //! //! Given a sequence, an index and an element to insert, `insert` inserts //! the element at the given index. //! //! @param xs //! The sequence in which a value should be inserted. //! //! @param n //! The index at which an element should be inserted. This must be a //! non-negative `Constant` of an integral type, and it must also be //! true that `n < length(xs)` if `xs` is a finite sequence. //! //! @param element //! The element to insert in the sequence. //! //! //! Example //! ------- //! @include example/insert.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto insert = [](auto&& xs, auto&& n, auto&& element) { return tag-dispatched; }; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_INSERT_HPP PK �|!\�(pN N monadic_fold_right.hppnu �[��� /*! @file Forward declares `boost::hana::monadic_fold_right`. @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_MONADIC_FOLD_RIGHT_HPP #define BOOST_HANA_FWD_MONADIC_FOLD_RIGHT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Monadic right-fold of a structure with a binary operation and an //! optional initial reduction state. //! @ingroup group-Foldable //! //! @note //! This assumes the reader to be accustomed to non-monadic right-folds as //! explained by `hana::fold_right`, and to have read the [primer] //! (@ref monadic-folds) on monadic folds. //! //! `monadic_fold_right<M>` is a right-associative monadic fold. Given a //! structure containing `x1, ..., xn`, a function `f` and an optional //! initial state, `monadic_fold_right<M>` applies `f` as follows //! @code //! // with state //! (f(x1, -) | (f(x2, -) | (f(x3, -) | (... | f(xn, state))))) //! //! // without state //! (f(x1, -) | (f(x2, -) | (f(x3, -) | (... | f(xn-1, xn))))) //! @endcode //! //! where `f(xk, -)` denotes the partial application of `f` to `xk`, //! and `|` is just the operator version of the monadic `chain`. //! It is worth noting that the order in which the binary function should //! expect its arguments is reversed from `monadic_fold_left<M>`. //! //! When the structure is empty, one of two things may happen. If an //! initial state was provided, it is lifted to the given Monad and //! returned as-is. Otherwise, if the no-state version of the function //! was used, an error is triggered. When the stucture contains a single //! element and the no-state version of the function was used, that //! single element is lifted into the given Monad and returned as is. //! //! //! Signature //! --------- //! Given a `Monad` `M`, a `Foldable` `F`, an initial state of tag `S`, //! and a function @f$ f : T \times S \to M(S) @f$, the signatures of //! `monadic_fold_right<M>` are //! \f[ //! \mathtt{monadic\_fold\_right}_M : //! F(T) \times S \times (T \times S \to M(S)) \to M(S) //! \f] //! //! for the version with an initial state, and //! \f[ //! \mathtt{monadic\_fold\_right}_M : //! F(T) \times (T \times T \to M(T)) \to M(T) //! \f] //! //! for the version without an initial state. //! //! @tparam M //! The Monad representing the monadic context in which the fold happens. //! The return type of `f` must be in that Monad. //! //! @param xs //! The structure to fold. //! //! @param state //! The initial value used for folding. If the structure is empty, this //! value is lifted in to the `M` Monad and then returned as-is. //! //! @param f //! A binary function called as `f(x, state)`, where `state` is the result //! accumulated so far and `x` is an element in the structure. The //! function must return its result inside the `M` Monad. //! //! //! Example //! ------- //! @include example/monadic_fold_right.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename M> constexpr auto monadic_fold_right = [](auto&& xs[, auto&& state], auto&& f) -> decltype(auto) { return tag-dispatched; }; #else template <typename T, typename = void> struct monadic_fold_right_impl : monadic_fold_right_impl<T, when<true>> { }; template <typename M> struct monadic_fold_right_t { template <typename Xs, typename State, typename F> constexpr decltype(auto) operator()(Xs&& xs, State&& state, F&& f) const; template <typename Xs, typename F> constexpr decltype(auto) operator()(Xs&& xs, F&& f) const; }; template <typename M> constexpr monadic_fold_right_t<M> monadic_fold_right{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_MONADIC_FOLD_RIGHT_HPP PK �|!\� 2 2 replace.hppnu �[��� /*! @file Forward declares `boost::hana::replace`. @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_REPLACE_HPP #define BOOST_HANA_FWD_REPLACE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Replace all the elements of a structure that compare equal //! to some `value` with some new fixed value. //! @ingroup group-Functor //! //! //! Signature //! --------- //! Given `F` a Functor and `U` a type that can be compared with `T`, //! the signature is //! \f$ //! \mathtt{replace} : F(T) \times U \times T \to F(T) //! \f$ //! //! @param xs //! The structure to replace elements of. //! //! @param oldval //! An object compared with each element of the structure. Elements //! of the structure that compare equal to `oldval` are replaced //! by `newval` in the new structure. //! //! @param newval //! A value by which every element `x` of the structure that compares //! equal to `oldval` is replaced. //! //! //! Example //! ------- //! @include example/replace.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto replace = [](auto&& xs, auto&& oldval, auto&& newval) { return tag-dispatched; }; #else template <typename Xs, typename = void> struct replace_impl : replace_impl<Xs, when<true>> { }; struct replace_t { template <typename Xs, typename OldVal, typename NewVal> constexpr auto operator()(Xs&& xs, OldVal&& oldval, NewVal&& newval) const; }; constexpr replace_t replace{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_REPLACE_HPP PK �|!\�?t}( ( filter.hppnu �[��� /*! @file Forward declares `boost::hana::filter`. @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_FILTER_HPP #define BOOST_HANA_FWD_FILTER_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Filter a monadic structure using a custom predicate. //! @ingroup group-MonadPlus //! //! Given a monadic structure and a predicate, `filter` returns a new //! monadic structure containing only those elements that satisfy the //! predicate. This is a generalization of the usual `filter` function //! for sequences; it works for any MonadPlus. Intuitively, `filter` is //! somewhat equivalent to: //! @code //! filter(xs, pred) == flatten(transform(xs, [](auto x) { //! return pred(x) ? lift<Xs>(x) : empty<Xs>(); //! }) //! @endcode //! In other words, we basically turn a monadic structure containing //! `[x1, ..., xn]` into a monadic structure containing //! @code //! [ //! pred(x1) ? [x1] : [], //! pred(x2) ? [x2] : [], //! ... //! pred(xn) ? [xn] : [] //! ] //! @endcode //! and we then `flatten` that. //! //! //! Signature //! --------- //! Given a `MonadPlus` `M` and an `IntegralConstant` `Bool` holding a //! value of type `bool`, the signature is //! @f$ \mathtt{filter} : M(T) \times (T \to \mathtt{Bool}) \to M(T) @f$. //! //! @param xs //! The monadic structure to filter. //! //! @param pred //! A function called as `pred(x)` for each element `x` in the monadic //! structure and returning whether that element should be __kept__ in //! the resulting structure. In the current version of the library, the //! predicate has to return an `IntegralConstant` holding a value //! convertible to a `bool`. //! //! //! Example //! ------- //! @include example/filter.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto filter = [](auto&& xs, auto&& pred) { return tag-dispatched; }; #else template <typename M, typename = void> struct filter_impl : filter_impl<M, when<true>> { }; struct filter_t { template <typename Xs, typename Pred> constexpr auto operator()(Xs&& xs, Pred&& pred) const; }; constexpr filter_t filter{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_FILTER_HPP PK �|!\U�)t. . define_struct.hppnu �[��� /*! @file Documents the `BOOST_HANA_DEFINE_STRUCT` macro. @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_DEFINE_STRUCT_HPP #define BOOST_HANA_FWD_DEFINE_STRUCT_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN // Note: // The weird definition as a variable seems to exploit a glitch in Doxygen // which makes the macro appear in the related objects of Struct (as we // want it to). //! Defines members of a structure, while at the same time //! modeling `Struct`. //! @ingroup group-Struct //! //! Using this macro in the body of a user-defined type will define the //! given members inside that type, and will also provide a model of the //! `Struct` concept for that user-defined type. This macro is often the //! easiest way to define a model of the `Struct` concept. //! //! @note //! This macro only works if the tag of the user-defined type `T` is `T` //! itself. This is the case unless you specifically asked for something //! different; see `tag_of`'s documentation. //! //! //! Example //! ------- //! @include example/define_struct.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED auto BOOST_HANA_DEFINE_STRUCT(...) = ; #define BOOST_HANA_DEFINE_STRUCT(Name, ...) see documentation #else // defined in <boost/hana/define_struct.hpp> #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_DEFINE_STRUCT_HPP PK �|!\@��� � negate.hppnu �[��� /*! @file Forward declares `boost::hana::negate`. @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_NEGATE_HPP #define BOOST_HANA_FWD_NEGATE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Return the inverse of an element of a group. //! @ingroup group-Group //! //! //! Example //! ------- //! @include example/negate.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto negate = [](auto&& x) -> decltype(auto) { return tag-dispatched; }; #else template <typename G, typename = void> struct negate_impl : negate_impl<G, when<true>> { }; struct negate_t { template <typename X> constexpr decltype(auto) operator()(X&& x) const; }; constexpr negate_t negate{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_NEGATE_HPP PK �|!\��H�* * fold.hppnu �[��� /*! @file Forward declares `boost::hana::fold`. @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_FOLD_HPP #define BOOST_HANA_FWD_FOLD_HPP #include <boost/hana/config.hpp> #include <boost/hana/fwd/fold_left.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Equivalent to `fold_left`; provided for convenience. //! @ingroup group-Foldable //! //! `fold` is equivalent to `fold_left`. However, it is not tag-dispatched //! on its own because it is just an alias to `fold_left`. Also note that //! `fold` can be called with or without an initial state, just like //! `fold_left`: //! //! @code //! fold(xs, state, f) == fold_left(xs, state, f) //! fold(xs, f) == fold_left(xs, f) //! @endcode //! //! //! Example //! ------- //! @include example/fold.cpp constexpr auto fold = fold_left; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_FOLD_HPP PK �|!\D*�� � slice.hppnu �[��� /*! @file Forward declares `boost::hana::slice` and `boost::hana::slice_c`. @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_SLICE_HPP #define BOOST_HANA_FWD_SLICE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <cstddef> BOOST_HANA_NAMESPACE_BEGIN //! Extract the elements of a `Sequence` at the given indices. //! @ingroup group-Sequence //! //! Given an arbitrary sequence of `indices`, `slice` returns a new //! sequence of the elements of the original sequence that appear at //! those indices. In other words, //! @code //! slice([x1, ..., xn], [i1, ..., ik]) == [x_i1, ..., x_ik] //! @endcode //! //! The indices do not have to be ordered or contiguous in any particular //! way, but they must not be out of the bounds of the sequence. It is //! also possible to specify the same index multiple times, in which case //! the element at this index will be repeatedly included in the resulting //! sequence. //! //! //! @param xs //! The sequence from which a subsequence is extracted. //! //! @param indices //! A compile-time `Foldable` containing non-negative `IntegralConstant`s //! representing the indices. The indices are 0-based, and they must all //! be in bounds of the `xs` sequence. Note that any `Foldable` will //! really do (no need for an `Iterable`, for example); the linearization //! of the `indices` is used to determine the order of the elements //! included in the slice. //! //! //! Example //! ------- //! @include example/slice.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto slice = [](auto&& xs, auto&& indices) { return tag-dispatched; }; #else template <typename S, typename = void> struct slice_impl : slice_impl<S, when<true>> { }; struct slice_t { template <typename Xs, typename Indices> constexpr auto operator()(Xs&& xs, Indices&& indices) const; }; constexpr slice_t slice{}; #endif //! Shorthand to `slice` a contiguous range of elements. //! @ingroup group-Sequence //! //! `slice_c` is simply a shorthand to slice a contiguous range of //! elements. In particular, `slice_c<from, to>(xs)` is equivalent to //! `slice(xs, range_c<std::size_t, from, to>)`, which simply slices //! all the elements of `xs` contained in the half-open interval //! delimited by `[from, to)`. Like for `slice`, the indices used with //! `slice_c` are 0-based and they must be in the bounds of the sequence //! being sliced. //! //! //! @tparam from //! The index of the first element in the slice. //! //! @tparam to //! One-past the index of the last element in the slice. It must hold //! that `from <= to`. //! //! //! Example //! ------- //! @include example/slice_c.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <std::size_t from, std::size_t to> constexpr auto slice_c = [](auto&& xs) { return hana::slice(forwarded(xs), hana::range_c<std::size_t, from, to>); }; #else template <std::size_t from, std::size_t to> struct slice_c_t; template <std::size_t from, std::size_t to> constexpr slice_c_t<from, to> slice_c{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_SLICE_HPP PK �|!\��}#� � monadic_compose.hppnu �[��� /*! @file Forward declares `boost::hana::monadic_compose`. @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_MONADIC_COMPOSE_HPP #define BOOST_HANA_FWD_MONADIC_COMPOSE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Composition of monadic functions. //! @ingroup group-Monad //! //! Given two monadic functions `f` and `g`, `monadic_compose` returns //! a new function equivalent to the composition of `f` with `g`, except //! the result of `g` is `chain`ed into `f` instead of simply passed to //! it, as with normal composition. `monadic_compose` satisfies //! @code //! monadic_compose(f, g)(x) == chain(g(x), f) //! @endcode //! //! //! @note //! Unlike `compose`, `monadic_compose` does not generalize nicely to //! arities higher than one. Hence, only unary functions may be used //! with `monadic_compose`. //! //! //! Signature //! --------- //! Given a `Monad` `M` and two functions @f$ f : B \to M(C) @f$ and //! @f$ g : A \to M(B) @f$, the signature is //! @f$ //! \mathtt{monadic\_compose} //! : (B \to M(C)) \times (A \to M(B)) \to (A \to M(C)) //! @f$. //! //! @param f //! A monadic function with signature @f$ B \to M(C) @f$. //! //! @param g //! A monadic function with signature @f$ A \to M(B) @f$. //! //! //! @note //! This method is not tag-dispatched, so it can't be customized directly. //! //! //! Example //! ------- //! @include example/monadic_compose.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto monadic_compose = [](auto&& f, auto&& g) { return [perfect-capture](auto&& x) -> decltype(auto) { return hana::chain(forwarded(g)(forwarded(x)), forwarded(f)); }; }; #else struct monadic_compose_t { template <typename F, typename G> constexpr auto operator()(F&& f, G&& g) const; }; constexpr monadic_compose_t monadic_compose{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_MONADIC_COMPOSE_HPP PK �|!\?��j� � mod.hppnu �[��� /*! @file Forward declares `boost::hana::mod`. @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_MOD_HPP #define BOOST_HANA_FWD_MOD_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Generalized integer modulus. //! @ingroup group-EuclideanRing //! //! Given two elements of an EuclideanRing `x` and `y`, with `y` //! nonzero, `mod` returns the modulus of the division of `x` by `y`. //! In other words, `mod` can be seen as an equivalent to `%`. //! //! Cross-type version of the method //! -------------------------------- //! The `mod` method is "overloaded" to handle distinct data types //! with certain properties. Specifically, `mod` is defined for //! _distinct_ data types `A` and `B` such that //! 1. `A` and `B` share a common data type `C`, as determined by the //! `common` metafunction //! 2. `A`, `B` and `C` are all `EuclideanRing`s when taken individually //! 3. `to<C> : A -> B` and `to<C> : B -> C` are `Ring`-embeddings, as //! determined by the `is_embedding` metafunction. //! //! In that case, `mod` is defined as //! @code //! mod(x, y) = mod(to<C>(x), to<C>(y)) //! @endcode //! //! //! Example //! ------- //! @include example/mod.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto mod = [](auto&& x, auto&& y) -> decltype(auto) { return tag-dispatched; }; #else template <typename T, typename U, typename = void> struct mod_impl : mod_impl<T, U, when<true>> { }; struct mod_t { template <typename X, typename Y> constexpr decltype(auto) operator()(X&& x, Y&& y) const; }; constexpr mod_t mod{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_MOD_HPP PK �|!\˗!#s s if.hppnu �[��� /*! @file Forward declares `boost::hana::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_IF_HPP #define BOOST_HANA_FWD_IF_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Conditionally return one of two values based on a condition. //! @ingroup group-Logical //! //! Specifically, `then` is returned iff `cond` is true-valued, and //! `else_` is returned otherwise. Note that some `Logical` models may //! allow `then` and `else_` to have different types, while others may //! require both values to have the same type. //! //! //! @param cond //! The condition determining which of the two values is returned. //! //! @param then //! The value returned when `cond` is true-valued. //! //! @param else_ //! The value returned when `cond` is false-valued. //! //! //! Example //! ------- //! @include example/if.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto if_ = [](auto&& cond, auto&& then, auto&& else_) -> decltype(auto) { return tag-dispatched; }; #else template <typename L, typename = void> struct if_impl : if_impl<L, when<true>> { }; struct if_t { template <typename Cond, typename Then, typename Else> constexpr decltype(auto) operator()(Cond&& cond, Then&& then, Else&& else_) const; }; constexpr if_t if_{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_IF_HPP PK �|!\��h�s s zip_shortest_with.hppnu �[��� /*! @file Forward declares `boost::hana::zip_shortest_with`. @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_ZIP_SHORTEST_WITH_HPP #define BOOST_HANA_FWD_ZIP_SHORTEST_WITH_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Zip one sequence or more with a given function. //! @ingroup group-Sequence //! //! Given a `n`-ary function `f` and `n` sequences `s1, ..., sn`, //! `zip_shortest_with` produces a sequence whose `i`-th element is //! `f(s1[i], ..., sn[i])`, where `sk[i]` denotes the `i`-th element of //! the `k`-th sequence. In other words, `zip_shortest_with` produces a //! sequence of the form //! @code //! [ //! f(s1[0], ..., sn[0]), //! f(s1[1], ..., sn[1]), //! ... //! f(s1[M], ..., sn[M]) //! ] //! @endcode //! where `M` is the length of the shortest sequence. Hence, the returned //! sequence stops when the shortest input sequence is exhausted. If you //! know that all the sequences you are about to zip have the same length, //! you should use `zip_with` instead, since it can be more optimized. //! Also note that it is an error to provide no sequence at all, i.e. //! `zip_shortest_with` expects at least one sequence. //! //! //! Example //! ------- //! @include example/zip_shortest_with.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto zip_shortest_with = [](auto&& f, auto&& x1, ..., auto&& xn) { return tag-dispatched; }; #else template <typename S, typename = void> struct zip_shortest_with_impl : zip_shortest_with_impl<S, when<true>> { }; struct zip_shortest_with_t { template <typename F, typename Xs, typename ...Ys> constexpr auto operator()(F&& f, Xs&& xs, Ys&& ...ys) const; }; constexpr zip_shortest_with_t zip_shortest_with{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_ZIP_SHORTEST_WITH_HPP PK �|!\tVz�� � size.hppnu �[��� /*! @file Forward declares `boost::hana::size`. @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_SIZE_HPP #define BOOST_HANA_FWD_SIZE_HPP #include <boost/hana/config.hpp> #include <boost/hana/fwd/length.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Equivalent to `length`; provided for consistency with the //! standard library. //! @ingroup group-Foldable //! //! This method is an alias to `length` provided for convenience and //! consistency with the standard library. As an alias, `size` is not //! tag-dispatched on its own and `length` should be customized instead. //! //! //! Example //! ------- //! @include example/size.cpp constexpr auto size = hana::length; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_SIZE_HPP PK �|!\+A�gC C remove_at.hppnu �[��� /*! @file Forward declares `boost::hana::remove_at` and `boost::hana::remove_at_c`. @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_REMOVE_AT_HPP #define BOOST_HANA_FWD_REMOVE_AT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <cstddef> BOOST_HANA_NAMESPACE_BEGIN //! Remove the element at a given index from a sequence. //! @ingroup group-Sequence //! //! `remove_at` returns a new sequence identical to the original, except //! that the element at the given index is removed. Specifically, //! `remove_at([x0, ..., xn-1, xn, xn+1, ..., xm], n)` is a new //! sequence equivalent to `[x0, ..., xn-1, xn+1, ..., xm]`. //! //! @note //! The behavior is undefined if the index is out of the bounds of the //! sequence. //! //! //! @param xs //! A sequence from which an element is to be removed. //! //! @param n //! An non-negative `IntegralConstant` representing the index of the //! element to be removed from the sequence. The behavior is undefined //! if that index is not in the bounds of the sequence. //! //! //! Example //! ------- //! @include example/remove_at.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto remove_at = [](auto&& xs, auto const& n) { return tag-dispatched; }; #else template <typename S, typename = void> struct remove_at_impl : remove_at_impl<S, when<true>> { }; struct remove_at_t { template <typename Xs, typename N> constexpr auto operator()(Xs&& xs, N const& n) const; }; constexpr remove_at_t remove_at{}; #endif //! Equivalent to `remove_at`; provided for convenience. //! @ingroup group-Sequence //! //! //! Example //! ------- //! @include example/remove_at_c.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <std::size_t n> constexpr auto remove_at_c = [](auto&& xs) { return hana::remove_at(forwarded(xs), hana::size_c<n>); }; #else template <std::size_t n> struct remove_at_c_t; template <std::size_t n> constexpr remove_at_c_t<n> remove_at_c{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_REMOVE_AT_HPP PK �|!\ ��n n ordering.hppnu �[��� /*! @file Forward declares `boost::hana::ordering`. @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_ORDERING_HPP #define BOOST_HANA_FWD_ORDERING_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns a function performing `less` after applying a transformation //! to both arguments. //! @ingroup group-Orderable //! //! `ordering` creates a total order based on the result of applying a //! function to some objects, which is especially useful in conjunction //! with algorithms that accept a custom predicate that must represent //! a total order. //! //! Specifically, `ordering` is such that //! @code //! ordering(f) == less ^on^ f //! @endcode //! or, equivalently, //! @code //! ordering(f)(x, y) == less(f(x), f(y)) //! @endcode //! //! @note //! This is not a tag-dispatched method (hence it can't be customized), //! but just a convenience function provided with the `Orderable` concept. //! //! //! Signature //! --------- //! Given a Logical `Bool` and an Orderable `B`, the signature is //! @f$ \mathrm{ordering} : (A \to B) \to (A \times A \to Bool) @f$. //! //! //! Example //! ------- //! @include example/ordering.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto ordering = [](auto&& f) { return [perfect-capture](auto&& x, auto&& y) -> decltype(auto) { return less(f(forwarded(x)), f(forwarded(y))); }; }; #else struct ordering_t { template <typename F> constexpr auto operator()(F&& f) const; }; constexpr ordering_t ordering{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_ORDERING_HPP PK �|!\A�%ߵ � sum.hppnu �[��� /*! @file Forward declares `boost::hana::sum`. @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_SUM_HPP #define BOOST_HANA_FWD_SUM_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/fwd/integral_constant.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Compute the sum of the numbers of a structure. //! @ingroup group-Foldable //! //! More generally, `sum` will take any foldable structure containing //! objects forming a Monoid and reduce them using the Monoid's binary //! operation. The initial state for folding is the identity of the //! Monoid. It is sometimes necessary to specify the Monoid to use; //! this is possible by using `sum<M>`. If no Monoid is specified, //! the structure will use the Monoid formed by the elements it contains //! (if it knows it), or `integral_constant_tag<int>` otherwise. Hence, //! @code //! sum<M>(xs) = fold_left(xs, zero<M or inferred Monoid>(), plus) //! sum<> = sum<integral_constant_tag<int>> //! @endcode //! //! For numbers, this will just compute the sum of the numbers in the //! `xs` structure. //! //! //! @note //! The elements of the structure are not actually required to be in the //! same Monoid, but it must be possible to perform `plus` on any two //! adjacent elements of the structure, which requires each pair of //! adjacent element to at least have a common Monoid embedding. The //! meaning of "adjacent" as used here is that two elements of the //! structure `x` and `y` are adjacent if and only if they are adjacent //! in the linearization of that structure, as documented by the Iterable //! concept. //! //! //! Why must we sometimes specify the `Monoid` by using `sum<M>`? //! ------------------------------------------------------------- //! This is because sequence tags like `tuple_tag` are not parameterized //! (by design). Hence, we do not know what kind of objects are in the //! sequence, so we can't know a `0` value of which type should be //! returned when the sequence is empty. Therefore, the type of the //! `0` to return in the empty case must be specified explicitly. Other //! foldable structures like `hana::range`s will ignore the suggested //! Monoid because they know the tag of the objects they contain. This //! inconsistent behavior is a limitation of the current design with //! non-parameterized tags, but we have no good solution for now. //! //! //! Example //! ------- //! @include example/sum.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto sum = see documentation; #else template <typename T, typename = void> struct sum_impl : sum_impl<T, when<true>> { }; template <typename M> struct sum_t { template <typename Xs> constexpr decltype(auto) operator()(Xs&& xs) const; }; template <typename M = integral_constant_tag<int>> constexpr sum_t<M> sum{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_SUM_HPP PK �|!\b�H� � first.hppnu �[��� /*! @file Forward declares `boost::hana::first`. @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_FIRST_HPP #define BOOST_HANA_FWD_FIRST_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns the first element of a pair. //! @ingroup group-Product //! //! Note that if the `Product` actually stores the elements it contains, //! `hana::first` is required to return a lvalue reference, a lvalue //! reference to const or a rvalue reference to the first element, where //! the type of reference must match that of the pair passed to `first`. //! If the `Product` does not store the elements it contains (i.e. it //! generates them on demand), this requirement is dropped. //! //! //! Example //! ------- //! @include example/first.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto first = [](auto&& product) -> decltype(auto) { return tag-dispatched; }; #else template <typename P, typename = void> struct first_impl : first_impl<P, when<true>> { }; struct first_t { template <typename Pair> constexpr decltype(auto) operator()(Pair&& pair) const; }; constexpr first_t first{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_FIRST_HPP PK �|!\��q� � is_disjoint.hppnu �[��� /*! @file Forward declares `boost::hana::is_disjoint`. @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_IS_DISJOINT_HPP #define BOOST_HANA_FWD_IS_DISJOINT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns whether two `Searchable`s are disjoint. //! @ingroup group-Searchable //! //! Given two `Searchable`s `xs` and `ys`, `is_disjoint` returns a //! `Logical` representing whether the keys in `xs` are disjoint from //! the keys in `ys`, i.e. whether both structures have no keys in common. //! //! //! @param xs, ys //! Two `Searchable`s to test for disjointness. //! //! //! Example //! ------- //! @include example/is_disjoint.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto is_disjoint = [](auto const& xs, auto const& ys) { return tag-dispatched; }; #else template <typename S1, typename S2, typename = void> struct is_disjoint_impl : is_disjoint_impl<S1, S2, when<true>> { }; struct is_disjoint_t { template <typename Xs, typename Ys> constexpr auto operator()(Xs&& xs, Ys&& ys) const; }; constexpr is_disjoint_t is_disjoint{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_IS_DISJOINT_HPP PK �|!\�"�k k remove_if.hppnu �[��� /*! @file Forward declares `boost::hana::remove_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_REMOVE_IF_HPP #define BOOST_HANA_FWD_REMOVE_IF_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Remove all the elements of a monadic structure that satisfy some //! predicate. //! @ingroup group-MonadPlus //! //! Given a monadic structure `xs` and a unary predicate, `remove_if` //! returns a new monadic structure equal to `xs` without all its elements //! that satisfy the predicate. This is equivalent to `filter` with a //! negated predicate, i.e. //! @code //! remove_if(xs, predicate) == filter(xs, negated predicated) //! @endcode //! //! //! Signature //! --------- //! Given a MonadPlus `M` and a predicate of type \f$ T \to Bool \f$ for //! some compile-time Logical `Bool`, the signature is //! \f$ //! \mathrm{remove\_if} : M(T) \times (T \to Bool) \to M(T) //! \f$ //! //! @param xs //! A monadic structure to remove some elements from. //! //! @param predicate //! A unary predicate called as `predicate(x)`, where `x` is an element //! of the structure, and returning whether `x` should be removed from //! the structure. In the current version of the library, `predicate` //! must return a compile-time Logical. //! //! //! Example //! ------- //! @include example/remove_if.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto remove_if = [](auto&& xs, auto&& predicate) { return tag-dispatched; }; #else template <typename M, typename = void> struct remove_if_impl : remove_if_impl<M, when<true>> { }; struct remove_if_t { template <typename Xs, typename Pred> constexpr auto operator()(Xs&& xs, Pred&& pred) const; }; constexpr remove_if_t remove_if{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_REMOVE_IF_HPP PK �|!\� ��y y fold_right.hppnu �[��� /*! @file Forward declares `boost::hana::fold_right`. @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_FOLD_RIGHT_HPP #define BOOST_HANA_FWD_FOLD_RIGHT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Right-fold of a structure using a binary operation and an optional //! initial reduction state. //! @ingroup group-Foldable //! //! `fold_right` is a right-associative fold using a binary operation. //! Given a structure containing `x1, ..., xn`, a function `f` and //! an optional initial state, `fold_right` applies `f` as follows //! @code //! f(x1, f(x2, f(x3, f(x4, ... f(xn-1, xn) ... )))) // without state //! f(x1, f(x2, f(x3, f(x4, ... f(xn, state) ... )))) // with state //! @endcode //! //! @note //! It is worth noting that the order in which the binary function should //! expect its arguments is reversed from `fold_left`. //! //! When the structure is empty, two things may arise. If an initial //! state was provided, it is returned as-is. Otherwise, if the no-state //! version of the function was used, an error is triggered. When the //! stucture contains a single element and the no-state version of the //! function was used, that single element is returned as is. //! //! //! Signature //! --------- //! Given a `Foldable` `F` and an optional initial state of tag `S`, //! the signatures for `fold_right` are //! \f[ //! \mathtt{fold\_right} : F(T) \times S \times (T \times S \to S) \to S //! \f] //! //! for the variant with an initial state, and //! \f[ //! \mathtt{fold\_right} : F(T) \times (T \times T \to T) \to T //! \f] //! //! for the variant without an initial state. //! //! @param xs //! The structure to fold. //! //! @param state //! The initial value used for folding. //! //! @param f //! A binary function called as `f(x, state)`, where `state` is the //! result accumulated so far and `x` is an element in the structure. //! For right folds without an initial state, the function is called as //! `f(x1, x2)`, where `x1` and `x2` are elements of the structure. //! //! //! Example //! ------- //! @include example/fold_right.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto fold_right = [](auto&& xs[, auto&& state], auto&& f) -> decltype(auto) { return tag-dispatched; }; #else template <typename T, typename = void> struct fold_right_impl : fold_right_impl<T, when<true>> { }; struct fold_right_t { template <typename Xs, typename State, typename F> constexpr decltype(auto) operator()(Xs&& xs, State&& state, F&& f) const; template <typename Xs, typename F> constexpr decltype(auto) operator()(Xs&& xs, F&& f) const; }; constexpr fold_right_t fold_right{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_FOLD_RIGHT_HPP PK �|!\G�/ � � accessors.hppnu �[��� /*! @file Forward declares `boost::hana::accessors`. @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_ACCESSORS_HPP #define BOOST_HANA_FWD_ACCESSORS_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns a `Sequence` of pairs representing the accessors of the //! data structure. //! @ingroup group-Struct //! //! Given a `Struct` `S`, `accessors<S>()` is a `Sequence` of `Product`s //! where the first element of each pair is the "name" of a member of //! the `Struct`, and the second element of each pair is a function that //! can be used to access that member when given an object of the proper //! data type. As described in the global documentation for `Struct`, the //! accessor functions in this sequence must be move-independent. //! //! //! Example //! ------- //! @include example/accessors.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename S> constexpr auto accessors = []() { return tag-dispatched; }; #else template <typename S, typename = void> struct accessors_impl : accessors_impl<S, when<true>> { }; template <typename S> struct accessors_t; template <typename S> constexpr accessors_t<S> accessors{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_ACCESSORS_HPP PK �|!\_�B�� � drop_back.hppnu �[��� /*! @file Forward declares `boost::hana::drop_back`. @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_DROP_BACK_HPP #define BOOST_HANA_FWD_DROP_BACK_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Drop the last `n` elements of a finite sequence, and return the rest. //! @ingroup group-Sequence //! //! Given a finite `Sequence` `xs` with a linearization of `[x1, ..., xm]` //! and a non-negative `IntegralConstant` `n`, `drop_back(xs, n)` is a //! sequence with the same tag as `xs` whose linearization is //! `[x1, ..., xm-n]`. If `n` is not given, it defaults to an //! `IntegralConstant` with a value equal to `1`. //! //! In case `length(xs) <= n`, `drop_back` will simply drop the whole //! sequence without failing, thus returning an empty sequence. //! //! //! @param xs //! The sequence from which elements are dropped. //! //! @param n //! A non-negative `IntegralConstant` representing the number of elements //! to be dropped from the end of the sequence. If `n` is not given, it //! defaults to an `IntegralConstant` with a value equal to `1`. //! //! //! Example //! ------- //! @include example/drop_back.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto drop_back = [](auto&& xs[, auto const& n]) { return tag-dispatched; }; #else template <typename S, typename = void> struct drop_back_impl : drop_back_impl<S, when<true>> { }; struct drop_back_t { template <typename Xs, typename N> constexpr auto operator()(Xs&& xs, N const& n) const; template <typename Xs> constexpr auto operator()(Xs&& xs) const; }; constexpr drop_back_t drop_back{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_DROP_BACK_HPP PK �|!\�{�j� � unpack.hppnu �[��� /*! @file Forward declares `boost::hana::unpack`. @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_UNPACK_HPP #define BOOST_HANA_FWD_UNPACK_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Invoke a function with the elements of a Foldable as arguments. //! @ingroup group-Foldable //! //! Given a function and a foldable structure whose length can be known at //! compile-time, `unpack` invokes the function with the contents of that //! structure. In other words, `unpack(xs, f)` is equivalent to `f(x...)`, //! where `x...` are the elements of the structure. The length of the //! structure must be known at compile-time, because the version of `f`'s //! `operator()` that will be compiled depends on the number of arguments //! it is called with, which has to be known at compile-time. //! //! To create a function that accepts a foldable instead of variadic //! arguments, see `fuse` instead. //! //! //! @param xs //! The structure to expand into the function. //! //! @param f //! A function to be invoked as `f(x...)`, where `x...` are the elements //! of the structure as-if they had been linearized with `to<tuple_tag>`. //! //! //! Example //! ------- //! @include example/unpack.cpp //! //! //! Rationale: `unpack`'s name and parameter order //! ---------------------------------------------- //! It has been suggested a couple of times that `unpack` be called //! `apply` instead, and that the parameter order be reversed to match //! that of the [proposed std::apply function][1]. However, the name //! `apply` is already used to denote normal function application, an use //! which is consistent with the Boost MPL library and with the rest of //! the world, especially the functional programming community. //! Furthermore, the author of this library considers the proposed //! `std::apply` to have both an unfortunate name and an unfortunate //! parameter order. Indeed, taking the function as the first argument //! means that using `std::apply` with a lambda function looks like //! @code //! std::apply([](auto ...args) { //! use(args...); //! }, tuple); //! @endcode //! //! which is undeniably ugly because of the trailing `, tuple)` part //! on the last line. On the other hand, taking the function as a //! second argument allows one to write //! @code //! hana::unpack(tuple, [](auto ...args) { //! use(args...); //! }); //! @endcode //! //! which looks much nicer. Because of these observations, the author //! of this library feels justified to use `unpack` instead of `apply`, //! and to use a sane parameter order. //! //! [1]: http://en.cppreference.com/w/cpp/experimental/apply #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto unpack = [](auto&& xs, auto&& f) -> decltype(auto) { return tag-dispatched; }; #else template <typename T, typename = void> struct unpack_impl : unpack_impl<T, when<true>> { }; struct unpack_t { template <typename Xs, typename F> constexpr decltype(auto) operator()(Xs&& xs, F&& f) const; }; constexpr unpack_t unpack{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_UNPACK_HPP PK �|!\�q!�� � insert_range.hppnu �[��� /*! @file Forward declares `boost::hana::insert_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_INSERT_RANGE_HPP #define BOOST_HANA_FWD_INSERT_RANGE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Insert several values at a given index in a sequence. //! @ingroup group-Sequence //! //! Given a sequence, an index and any `Foldable` containing elements to //! insert, `insert_range` inserts the elements in the `Foldable` at the //! given index of the sequence. //! //! @param xs //! The sequence in which values should be inserted. //! //! @param n //! The index at which elements should be inserted. This must be a //! non-negative `Constant` of an integral type, and it must also be //! true that `n < length(xs)` if `xs` is a finite sequence. //! //! @param elements //! A `Foldable` containing elements to insert in the sequence. //! //! //! Example //! ------- //! @include example/insert_range.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto insert_range = [](auto&& xs, auto&& n, auto&& elements) { return tag-dispatched; }; #else template <typename S, typename = void> struct insert_range_impl : insert_range_impl<S, when<true>> { }; struct insert_range_t { template <typename Xs, typename N, typename Elements> constexpr auto operator()(Xs&& xs, N&& n, Elements&& elements) const; }; constexpr insert_range_t insert_range{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_INSERT_RANGE_HPP PK �|!\��M� unfold_right.hppnu �[��� /*! @file Forward declares `boost::hana::unfold_right`. @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_UNFOLD_RIGHT_HPP #define BOOST_HANA_FWD_UNFOLD_RIGHT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Dual operation to `fold_right` for sequences. //! @ingroup group-Sequence //! //! While `fold_right` reduces a structure to a summary value from the //! right, `unfold_right` builds a sequence from a seed value and a //! function, starting from the right. //! //! //! Signature //! --------- //! Given a `Sequence` `S`, an initial value `state` of tag `I`, an //! arbitrary Product `P` and a function \f$ f : I \to P(T, I) \f$, //! `unfold_right<S>` has the following signature: //! \f[ //! \mathtt{unfold\_right}_S : I \times (I \to P(T, I)) \to S(T) //! \f] //! //! @tparam S //! The tag of the sequence to build up. //! //! @param state //! An initial value to build the sequence from. //! //! @param f //! A function called as `f(state)`, where `state` is an initial value, //! and returning //! 1. `nothing` if it is done producing the sequence. //! 2. otherwise, `just(make<P>(x, state))`, where `state` is the new //! initial value used in the next call to `f`, `x` is an element to //! be prepended to the resulting sequence, and `P` is an arbitrary //! `Product`. //! //! //! Fun fact //! --------- //! In some cases, `unfold_right` can undo a `fold_right` operation: //! @code //! unfold_right<S>(fold_right(xs, state, f), g) == xs //! @endcode //! //! if the following holds //! @code //! g(f(x, y)) == just(make_pair(x, y)) //! g(state) == nothing //! @endcode //! //! //! Example //! ------- //! @include example/unfold_right.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename S> constexpr auto unfold_right = [](auto&& state, auto&& f) { return tag-dispatched; }; #else template <typename S, typename = void> struct unfold_right_impl : unfold_right_impl<S, when<true>> { }; template <typename S> struct unfold_right_t; template <typename S> constexpr unfold_right_t<S> unfold_right{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_UNFOLD_RIGHT_HPP PK �|!\��O[� � lexicographical_compare.hppnu �[��� /*! @file Forward declares `boost::hana::lexicographical_compare`. @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_LEXICOGRAPHICAL_COMPARE_HPP #define BOOST_HANA_FWD_LEXICOGRAPHICAL_COMPARE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Short-circuiting lexicographical comparison of two `Iterable`s with //! an optional custom predicate, by default `hana::less`. //! @ingroup group-Iterable //! //! Given two `Iterable`s `xs` and `ys` and a binary predicate `pred`, //! `lexicographical_compare` returns whether `xs` is to be considered //! less than `ys` in a lexicographical ordering. Specifically, let's //! denote the linearizations of `xs` and `ys` by `[x1, x2, ...]` and //! `[y1, y2, ...]`, respectively. If the first couple satisfying the //! predicate is of the form `xi, yi`, `lexicographical_compare` returns //! true. Otherwise, if the first couple to satisfy the predicate is of //! the form `yi, xi`, `lexicographical_compare` returns false. If no //! such couple can be found, `lexicographical_compare` returns whether //! `xs` has fewer elements than `ys`. //! //! @note //! This algorithm will short-circuit as soon as it can determine that one //! sequence is lexicographically less than the other. Hence, it can be //! used to compare infinite sequences. However, for the procedure to //! terminate on infinite sequences, the predicate has to be satisfied //! at a finite index. //! //! //! Signature //! --------- //! Given two `Iterable`s `It1(T)` and `It2(T)` and a predicate //! \f$ pred : T \times T \to Bool \f$ (where `Bool` is some `Logical`), //! `lexicographical_compare` has the following signatures. For the //! variant with a provided predicate, //! \f[ //! \mathtt{lexicographical\_compare} //! : It1(T) \times It2(T) \times (T \times T \to Bool) \to Bool //! \f] //! //! for the variant without a custom predicate, `T` is required to be //! `Orderable`. The signature is then //! \f[ //! \mathtt{lexicographical\_compare} : It1(T) \times It2(T) \to Bool //! \f] //! //! @param xs, ys //! Two `Iterable`s to compare lexicographically. //! //! @param pred //! A binary function called as `pred(x, y)` and `pred(y, x)`, where `x` //! and `y` are elements of `xs` and `ys`, respectively. `pred` must //! return a `Logical` representing whether its first argument is to be //! considered as less than its second argument. Also note that `pred` //! must define a total ordering as defined by the `Orderable` concept. //! When `pred` is not provided, it defaults to `less`. //! //! //! Example //! ------- //! @include example/lexicographical_compare.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto lexicographical_compare = [](auto const& xs, auto const& ys, auto const& pred = hana::less) { return tag-dispatched; }; #else template <typename T, typename = void> struct lexicographical_compare_impl : lexicographical_compare_impl<T, when<true>> { }; struct lexicographical_compare_t { template <typename Xs, typename Ys> constexpr auto operator()(Xs const& xs, Ys const& ys) const; template <typename Xs, typename Ys, typename Pred> constexpr auto operator()(Xs const& xs, Ys const& ys, Pred const& pred) const; }; constexpr lexicographical_compare_t lexicographical_compare{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_LEXICOGRAPHICAL_COMPARE_HPP PK �|!\�� power.hppnu �[��� /*! @file Forward declares `boost::hana::power`. @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_POWER_HPP #define BOOST_HANA_FWD_POWER_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Elevate a ring element to its `n`th power. //! @ingroup group-Ring //! //! Specifically, `power(x, n)`, is equivalent to multiplying `x` with //! itself `n` times using the Ring's multiplication. If the power is //! equal to `zero`, the Ring's identity (`one`) is returned. //! //! @param x //! A `Ring` element that is elevated to its `n`th power. //! //! @param n //! A non-negative `IntegralConstant` representing the power to which `x` //! is elevated. //! //! //! @note //! Only the tag of `x` is used for tag-dispatching. //! //! Example //! ------- //! @include example/power.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto power = [](auto&& x, auto const& n) -> decltype(auto) { return tag-dispatched; }; #else template <typename R, typename = void> struct power_impl : power_impl<R, when<true>> { }; struct power_t { template <typename X, typename N> constexpr decltype(auto) operator()(X&& x, N const& n) const; }; constexpr power_t power{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_POWER_HPP PK �|!\�O;5 5 minus.hppnu �[��� /*! @file Forward declares `boost::hana::minus`. @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_MINUS_HPP #define BOOST_HANA_FWD_MINUS_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Subtract two elements of a group. //! @ingroup group-Group //! //! Specifically, this performs the `Monoid` operation on the first //! argument and on the inverse of the second argument, thus being //! equivalent to: //! @code //! minus(x, y) == plus(x, negate(y)) //! @endcode //! //! //! Cross-type version of the method //! -------------------------------- //! The `minus` method is "overloaded" to handle distinct data types //! with certain properties. Specifically, `minus` is defined for //! _distinct_ data types `A` and `B` such that //! 1. `A` and `B` share a common data type `C`, as determined by the //! `common` metafunction //! 2. `A`, `B` and `C` are all `Group`s when taken individually //! 3. `to<C> : A -> B` and `to<C> : B -> C` are `Group`-embeddings, as //! determined by the `is_embedding` metafunction. //! //! The definition of `minus` for data types satisfying the above //! properties is obtained by setting //! @code //! minus(x, y) = minus(to<C>(x), to<C>(y)) //! @endcode //! //! //! Example //! ------- //! @include example/minus.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto minus = [](auto&& x, auto&& y) -> decltype(auto) { return tag-dispatched; }; #else template <typename T, typename U, typename = void> struct minus_impl : minus_impl<T, U, when<true>> { }; struct minus_t { template <typename X, typename Y> constexpr decltype(auto) operator()(X&& x, Y&& y) const; }; constexpr minus_t minus{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_MINUS_HPP PK �|!\E E\�& �& set.hppnu �[��� /*! @file Forward declares `boost::hana::set`. @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_SET_HPP #define BOOST_HANA_FWD_SET_HPP #include <boost/hana/config.hpp> #include <boost/hana/fwd/core/to.hpp> #include <boost/hana/fwd/core/make.hpp> #include <boost/hana/fwd/erase_key.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-datatypes //! Basic unordered container requiring unique, `Comparable` and //! `Hashable` keys. //! //! A set is an unordered container that can hold heterogeneous keys. //! A set requires (and ensures) that no duplicates are present when //! inserting new keys. //! //! @note //! The actual representation of a `hana::set` is implementation-defined. //! In particular, one should not take for granted the order of the //! template parameters and the presence of any additional constructors //! or assignment operators than what is documented. The canonical way of //! creating a `hana::set` is through `hana::make_set`. More details //! [in the tutorial](@ref tutorial-containers-types). //! //! //! Modeled concepts //! ---------------- //! 1. `Comparable`\n //! Two sets are equal iff they contain the same elements, regardless of //! the order. //! @include example/set/comparable.cpp //! //! 2. Foldable\n //! Folding a set is equivalent to folding the sequence of its values. //! However, note that the values are not required to be in any specific //! order, so using the folds provided here with an operation that is not //! both commutative and associative will yield non-deterministic behavior. //! @include example/set/foldable.cpp //! //! 3. Searchable\n //! The elements in a set act as both its keys and its values. Since the //! elements of a set are unique, searching for an element will return //! either the only element which is equal to the searched value, or //! `nothing`. Also note that `operator[]` can be used instead of the //! `at_key` function. //! @include example/set/searchable.cpp //! //! //! Conversion from any `Foldable` //! ------------------------------ //! Any `Foldable` structure can be converted into a `hana::set` with //! `to<set_tag>`. The elements of the structure must all be compile-time //! `Comparable`. If the structure contains duplicate elements, only //! the first occurence will appear in the resulting set. More //! specifically, conversion from a `Foldable` is equivalent to //! @code //! to<set_tag>(xs) == fold_left(xs, make_set(), insert) //! @endcode //! //! __Example__ //! @include example/set/to.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename implementation_defined> struct set { //! Default-construct a set. This constructor only exists when all the //! elements of the set are default-constructible. constexpr set() = default; //! Copy-construct a set from another set. This constructor only //! exists when all the elements of the set are copy-constructible. constexpr set(set const& other) = default; //! Move-construct a set from another set. This constructor only //! exists when all the elements of the set are move-constructible. constexpr set(set&& other) = default; //! 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_key` template <typename Key> constexpr decltype(auto) operator[](Key&& key); }; #else template <typename ...Xs> struct set; #endif //! Tag representing the `hana::set` container. //! @relates hana::set struct set_tag { }; //! Function object for creating a `hana::set`. //! @relates hana::set //! //! Given zero or more values `xs...`, `make<set_tag>` returns a `set` //! containing those values. The values must all be compile-time //! `Comparable`, and no duplicate values may be provided. To create //! a `set` from a sequence with possible duplicates, use `to<set_tag>` //! instead. //! //! //! Example //! ------- //! @include example/set/make.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <> constexpr auto make<set_tag> = [](auto&& ...xs) { return set<implementation_defined>{forwarded(xs)...}; }; #endif //! Equivalent to `make<set_tag>`; provided for convenience. //! @relates hana::set //! //! //! Example //! ------- //! @include example/set/make.cpp constexpr auto make_set = make<set_tag>; //! Insert an element in a `hana::set`. //! @relates hana::set //! //! If the set already contains an element that compares equal, then //! nothing is done and the set is returned as is. //! //! //! @param set //! The set in which to insert a value. //! //! @param element //! The value to insert. It must be compile-time `Comparable`. //! //! //! Example //! ------- //! @include example/set/insert.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto insert = [](auto&& set, auto&& element) { return tag-dispatched; }; #endif //! Remove an element from a `hana::set`. //! @relates hana::set //! //! Returns a new set containing all the elements of the original, //! except the one comparing `equal` to the given element. If the set //! does not contain such an element, a new set equal to the original //! set is returned. //! //! //! @param set //! The set in which to remove a value. //! //! @param element //! The value to remove. It must be compile-time `Comparable`. //! //! //! Example //! ------- //! @include example/set/erase_key.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto erase_key = [](auto&& set, auto&& element) { return tag-dispatched; }; #endif //! Returns the union of two sets. //! @relates hana::set //! //! Given two sets `xs` and `ys`, `union_(xs, ys)` is a new set containing //! all the elements of `xs` and all the elements of `ys`, without //! duplicates. For any object `x`, the following holds: `x` is in //! `hana::union_(xs, ys)` if and only if `x` is in `xs` or `x` is in `ys`. //! //! //! @param xs, ys //! Two sets to compute the union of. //! //! //! Example //! ------- //! @include example/set/union.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto union_ = [](auto&& xs, auto&& ys) { return tag-dispatched; }; #endif //! Returns the intersection of two sets. //! @relates hana::set //! //! Given two sets `xs` and `ys`, `intersection(xs, ys)` is a new set //! containing exactly those elements that are present both in `xs` and //! in `ys`. //! In other words, the following holds for any object `x`: //! @code //! x ^in^ intersection(xs, ys) if and only if x ^in^ xs && x ^in^ ys //! @endcode //! //! //! @param xs, ys //! Two sets to intersect. //! //! //! Example //! ------- //! @include example/set/intersection.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto intersection = [](auto&& xs, auto&& ys) { return tag-dispatched; }; #endif //! Equivalent to `to<set_tag>`; provided for convenience. //! @relates hana::set constexpr auto to_set = to<set_tag>; //! Returns the set-theoretic difference of two sets. //! @relates hana::set //! //! Given two sets `xs` and `ys`, `difference(xs, ys)` is a new set //! containing all the elements of `xs` that are _not_ contained in `ys`. //! For any object `x`, the following holds: //! @code //! x ^in^ difference(xs, ys) if and only if x ^in^ xs && !(x ^in^ ys) //! @endcode //! //! //! This operation is not commutative, i.e. `difference(xs, ys)` is not //! necessarily the same as `difference(ys, xs)`. Indeed, consider the //! case where `xs` is empty and `ys` isn't. Then, `difference(xs, ys)` //! is empty but `difference(ys, xs)` is equal to `ys`. For the symmetric //! version of this operation, see `symmetric_difference`. //! //! //! @param xs //! A set param to remove values from. //! //! @param ys //! The set whose values are removed from `xs`. //! //! //! Example //! ------- //! @include example/set/difference.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto difference = [](auto&& xs, auto&& ys) { return tag-dispatched; }; #endif //! Returns the symmetric set-theoretic difference of two sets. //! @relates hana::set //! //! Given two sets `xs` and `ys`, `symmetric_difference(xs, ys)` is a new //! set containing all the elements of `xs` that are not contained in `ys`, //! and all the elements of `ys` that are not contained in `xs`. The //! symmetric difference of two sets satisfies the following: //! @code //! symmetric_difference(xs, ys) == union_(difference(xs, ys), difference(ys, xs)) //! @endcode //! //! //! @param xs, ys //! Two sets to compute the symmetric difference of. //! //! //! Example //! ------- //! @include example/set/symmetric_difference.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto symmetric_difference = [](auto&& xs, auto&& ys) { return tag-dispatched; }; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_SET_HPP PK �|!\vh5�V3 V3 map.hppnu �[��� /*! @file Forward declares `boost::hana::map`. @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_MAP_HPP #define BOOST_HANA_FWD_MAP_HPP #include <boost/hana/config.hpp> #include <boost/hana/fwd/core/to.hpp> #include <boost/hana/fwd/core/make.hpp> #include <boost/hana/fwd/erase_key.hpp> #include <boost/hana/fwd/insert.hpp> #include <boost/hana/fwd/keys.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Tag representing `hana::map`s. //! @relates hana::map struct map_tag { }; namespace detail { template <typename ...Pairs> struct make_map_type; } //! @ingroup group-datatypes //! Basic associative container requiring unique, `Comparable` and //! `Hashable` keys. //! //! The order of the elements of the map is unspecified. Also, all the //! keys must be `Hashable`, and any two keys with equal hashes must be //! `Comparable` with each other at compile-time. //! //! @note //! The actual representation of a `hana::map` is an implementation //! detail. As such, one should not assume anything more than what is //! explicitly documented as being part of the interface of a map, //! such as: //! - the presence of additional constructors //! - the presence of additional assignment operators //! - the fact that `hana::map<Pairs...>` is, or is not, a dependent type //! . //! In particular, the last point is very important; `hana::map<Pairs...>` //! is basically equivalent to //! @code //! decltype(hana::make_pair(std::declval<Pairs>()...)) //! @endcode //! which is not something that can be pattern-matched on during template //! argument deduction, for example. More details [in the tutorial] //! (@ref tutorial-containers-types). //! //! //! Modeled concepts //! ---------------- //! 1. `Comparable`\n //! Two maps are equal iff all their keys are equal and are associated //! to equal values. //! @include example/map/comparable.cpp //! //! 2. `Searchable`\n //! A map can be searched by its keys with a predicate yielding a //! compile-time `Logical`. Also note that `operator[]` can be used //! instead of `at_key`. //! @include example/map/searchable.cpp //! //! 3. `Foldable`\n //! Folding a map is equivalent to folding a list of the key/value pairs //! it contains. In particular, since that list is not guaranteed to be //! in any specific order, folding a map with an operation that is not //! both commutative and associative will yield non-deterministic behavior. //! @include example/map/foldable.cpp //! //! //! Conversion from any `Foldable` //! ------------------------------ //! Any `Foldable` of `Product`s can be converted to a `hana::map` with //! `hana::to<hana::map_tag>` or, equivalently, `hana::to_map`. If the //! `Foldable` contains duplicate keys, only the value associated to the //! first occurence of each key is kept. //! @include example/map/to.cpp //! //! //! Example //! ------- //! @include example/map/map.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename ...Pairs> struct map { //! Default-construct a map. This constructor only exists when all the //! elements of the map are default-constructible. constexpr map() = default; //! Copy-construct a map from another map. This constructor only //! exists when all the elements of the map are copy-constructible. constexpr map(map const& other) = default; //! Move-construct a map from another map. This constructor only //! exists when all the elements of the map are move-constructible. constexpr map(map&& other) = default; //! Construct the map from the provided pairs. `P...` must be pairs of //! the same type (modulo ref and cv-qualifiers), and in the same order, //! as those appearing in `Pairs...`. The pairs provided to this //! constructor are emplaced into the map's storage using perfect //! forwarding. template <typename ...P> explicit constexpr map(P&& ...pairs); //! Assign a map to another map __with the exact same type__. Only //! exists when all the elements of the map are copy-assignable. constexpr map& operator=(map const& other); //! Move-assign a map to another map __with the exact same type__. //! Only exists when all the elements of the map are move-assignable. constexpr map& operator=(map&& other); //! 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_key` template <typename Key> constexpr decltype(auto) operator[](Key&& key); }; #else template <typename ...Pairs> using map = typename detail::make_map_type<Pairs...>::type; #endif //! Function object for creating a `hana::map`. //! @relates hana::map //! //! Given zero or more `Product`s representing key/value associations, //! `make<map_tag>` returns a `hana::map` associating these keys to these //! values. //! //! `make<map_tag>` requires all the keys to be unique and to have //! different hashes. If you need to create a map with duplicate keys //! or with keys whose hashes might collide, use `hana::to_map` or //! insert `(key, value)` pairs to an empty map successively. However, //! be aware that doing so will be much more compile-time intensive than //! using `make<map_tag>`, because the uniqueness of keys will have to be //! enforced. //! //! //! Example //! ------- //! @include example/map/make.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <> constexpr auto make<map_tag> = [](auto&& ...pairs) { return map<implementation_defined>{forwarded(pairs)...}; }; #endif //! Alias to `make<map_tag>`; provided for convenience. //! @relates hana::map //! //! //! Example //! ------- //! @include example/map/make.cpp constexpr auto make_map = make<map_tag>; //! Equivalent to `to<map_tag>`; provided for convenience. //! @relates hana::map constexpr auto to_map = to<map_tag>; //! Returns a `Sequence` of the keys of the map, in unspecified order. //! @relates hana::map //! //! //! Example //! ------- //! @include example/map/keys.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto keys = [](auto&& map) { return implementation_defined; }; #endif //! Returns a `Sequence` of the values of the map, in unspecified order. //! @relates hana::map //! //! //! Example //! ------- //! @include example/map/values.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto values = [](auto&& map) -> decltype(auto) { return implementation_defined; }; #else struct values_t { template <typename Map> constexpr decltype(auto) operator()(Map&& map) const; }; constexpr values_t values{}; #endif //! Inserts a new key/value pair in a map. //! @relates hana::map //! //! Given a `(key, value)` pair, `insert` inserts this new pair into a //! map. If the map already contains this key, nothing is done and the //! map is returned as-is. //! //! //! @param map //! The map in which to insert a `(key,value)` pair. //! //! @param pair //! An arbitrary `Product` representing a `(key, value)` pair to insert //! in the map. The `key` must be compile-time `Comparable`. //! //! //! Example //! ------- //! @include example/map/insert.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto insert = [](auto&& map, auto&& pair) { return tag-dispatched; }; #endif //! Removes a key/value pair from a map. //! @relates hana::map //! //! Returns a new `hana::map` containing all the elements of the original, //! except for the `(key, value)` pair whose `key` compares `equal` //! to the given key. If the map does not contain such an element, //! a new map equal to the original is returned. //! //! //! @param map //! The map in which to erase a `key`. //! //! @param key //! A key to remove from the map. It must be compile-time `Comparable`. //! //! //! Example //! ------- //! @include example/map/erase_key.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto erase_key = [](auto&& map, auto&& key) { return tag-dispatched; }; #endif //! Returns the union of two maps. //! @relates hana::map //! //! Given two maps `xs` and `ys`, `hana::union_(xs, ys)` is a new map //! containing all the elements of `xs` and all the elements of `ys`, //! without duplicates. If both `xs` and `ys` contain an element with the //! same `key`, the one in `ys` is taken. Functionally, //! `hana::union_(xs, ys)` is equivalent to //! @code //! hana::fold_left(xs, ys, hana::insert) //! @endcode //! //! @param xs, ys //! The two maps to compute the union of. //! //! //! Example //! ------- //! @include example/map/union.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto union_ = [](auto&& xs, auto&& ys) { return tag-dispatched; }; #endif //! Returns the intersection of two maps. //! @relates hana::map //! //! Given two maps `xs` and `ys`, `intersection(xs, ys)` is a new map //! containing exactly those (key, value) pairs from xs, for which key //! is present in `ys`. //! In other words, the following holds for any object `pair(k, v)`: //! @code //! pair(k, v) ^in^ intersection(xs, ys) if and only if (k, v) ^in^ xs && k ^in^ keys(ys) //! @endcode //! //! //! @note //! This function is not commutative, i.e. `intersection(xs, ys)` is not //! necessarily the same as `intersection(ys, xs)`. Indeed, the set of keys //! in `intersection(xs, ys)` is always the same as the set of keys in //! `intersection(ys, xs)`, but the value associated to each key may be //! different. `intersection(xs, ys)` contains values present in `xs`, and //! `intersection(ys, xs)` contains values present in `ys`. //! //! //! @param xs, ys //! Two maps to intersect. //! //! //! Example //! ------- //! @include example/map/intersection.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto intersection = [](auto&& xs, auto&& ys) { return tag-dispatched; }; #endif //! Returns the difference of two maps. //! @relates hana::map //! //! Given two maps `xs` and `ys`, `difference(xs, ys)` is a new map //! containing exactly those (key, value) pairs from xs, for which key //! is not present in `keys(ys)`. //! In other words, the following holds for any object `pair(k, v)`: //! @code //! pair(k, v) ^in^ difference(xs, ys) if and only if (k, v) ^in^ xs && k ^not in^ keys(ys) //! @endcode //! //! //! @note //! This function is not commutative, i.e. `difference(xs, ys)` is not //! necessarily the same as `difference(ys, xs)`. //! Indeed, consider the case where `xs` is empty and `ys` isn't. //! In that case, `difference(xs, ys)` is empty, but `difference(ys, xs)` //! is equal to `ys`. //! For symmetric version of this operation, see `symmetric_difference`. //! //! //! @param xs, ys //! Two maps to compute the difference of. //! //! //! Example //! ------- //! @include example/map/intersection.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto difference = [](auto&& xs, auto&& ys) { return tag-dispatched; }; #endif //! Returns the symmetric set-theoretic difference of two maps. //! @relates hana::map //! //! Given two sets `xs` and `ys`, `symmetric_difference(xs, ys)` is a new //! map containing all the elements of `xs` whose keys are not contained in `keys(ys)`, //! and all the elements of `ys` whose keys are not contained in `keys(xs)`. The //! symmetric difference of two maps satisfies the following: //! @code //! symmetric_difference(xs, ys) == union_(difference(xs, ys), difference(ys, xs)) //! @endcode //! //! //! @param xs, ys //! Two maps to compute the symmetric difference of. //! //! //! Example //! ------- //! @include example/map/symmetric_difference.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto symmetric_difference = [](auto&& xs, auto&& ys) { return tag-dispatched; }; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_MAP_HPP PK �|!\A��U� � div.hppnu �[��� /*! @file Forward declares `boost::hana::div`. @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_DIV_HPP #define BOOST_HANA_FWD_DIV_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Generalized integer division. //! @ingroup group-EuclideanRing //! //! //! Cross-type version of the method //! -------------------------------- //! The `div` method is "overloaded" to handle distinct data types //! with certain properties. Specifically, `div` is defined for //! _distinct_ data types `A` and `B` such that //! 1. `A` and `B` share a common data type `C`, as determined by the //! `common` metafunction //! 2. `A`, `B` and `C` are all `EuclideanRing`s when taken individually //! 3. `to<C> : A -> B` and `to<C> : B -> C` are `Ring`-embeddings, as //! determined by the `is_embedding` metafunction. //! //! In that case, the `div` method is defined as //! @code //! div(x, y) = div(to<C>(x), to<C>(y)) //! @endcode //! //! //! Example //! ------- //! @include example/div.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto div = [](auto&& x, auto&& y) -> decltype(auto) { return tag-dispatched; }; #else template <typename T, typename U, typename = void> struct div_impl : div_impl<T, U, when<true>> { }; struct div_t { template <typename X, typename Y> constexpr decltype(auto) operator()(X&& x, Y&& y) const; }; constexpr div_t div{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_DIV_HPP PK �|!\}���n n hash.hppnu �[��� /*! @file Forward declares `boost::hana::hash`. @copyright Louis Dionne 2016 @copyright Jason Rice 2016 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_HASH_HPP #define BOOST_HANA_FWD_HASH_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns a `hana::type` representing the compile-time hash of an object. //! @ingroup group-Hashable //! //! Given an arbitrary object `x`, `hana::hash` returns a `hana::type` //! representing the hash of `x`. In normal programming, hashes are //! usually numerical values that can be used e.g. as indices in an //! array as part of the implementation of a hash table. In the context //! of metaprogramming, we are interested in type-level hashes instead. //! Thus, `hana::hash` must return a `hana::type` object instead of an //! integer. This `hana::type` must somehow summarize the object being //! hashed, but that summary may of course lose some information. //! //! In order for the `hash` function to be defined properly, it must be //! the case that whenever `x` is equal to `y`, then `hash(x)` is equal //! to `hash(y)`. This ensures that `hana::hash` is a function in the //! mathematical sense of the term. //! //! //! Signature //! --------- //! Given a `Hashable` `H`, the signature is //! \f$ //! \mathtt{hash} : H \to \mathtt{type\_tag} //! \f$ //! //! @param x //! An object whose hash is to be computed. //! //! //! Example //! ------- //! @include example/hash.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto hash = [](auto const& x) { return tag-dispatched; }; #else template <typename T, typename = void> struct hash_impl : hash_impl<T, when<true>> { }; struct hash_t { template <typename X> constexpr auto operator()(X const& x) const; }; constexpr hash_t hash{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_HASH_HPP PK �|!\��}c� � take_front.hppnu �[��� /*! @file Forward declares `boost::hana::take_front` and `boost::hana::take_front_c`. @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_TAKE_FRONT_HPP #define BOOST_HANA_FWD_TAKE_FRONT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <cstddef> BOOST_HANA_NAMESPACE_BEGIN //! Returns the first `n` elements of a sequence, or the whole sequence //! if the sequence has less than `n` elements. //! @ingroup group-Sequence //! //! Given a `Sequence` `xs` and an `IntegralConstant` `n`, `take_front(xs, n)` //! is a new sequence containing the first `n` elements of `xs`, in the //! same order. If `length(xs) <= n`, the whole sequence is returned and //! no error is triggered. //! //! //! @param xs //! The sequence to take the elements from. //! //! @param n //! A non-negative `IntegralConstant` representing the number of elements //! to keep in the resulting sequence. //! //! //! Example //! ------- //! @include example/take_front.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto take_front = [](auto&& xs, auto const& n) { return tag-dispatched; }; #else template <typename S, typename = void> struct take_front_impl : take_front_impl<S, when<true>> { }; struct take_front_t { template <typename Xs, typename N> constexpr auto operator()(Xs&& xs, N const& n) const; }; constexpr take_front_t take_front{}; #endif //! Equivalent to `take_front`; provided for convenience. //! @ingroup group-Sequence //! //! //! Example //! ------- //! @include example/take_front_c.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <std::size_t n> constexpr auto take_front_c = [](auto&& xs) { return hana::take_front(forwarded(xs), hana::size_c<n>); }; #else template <std::size_t n> struct take_front_c_t; template <std::size_t n> constexpr take_front_c_t<n> take_front_c{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_TAKE_FRONT_HPP PK �|!\ ��Q! ! suffix.hppnu �[��� /*! @file Forward declares `boost::hana::suffix`. @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_SUFFIX_HPP #define BOOST_HANA_FWD_SUFFIX_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Inserts a value after each element of a monadic structure. //! @ingroup group-MonadPlus //! //! Given a monadic structure `xs` and a value `z` (called the suffix), //! `suffix` returns a new monadic structure such that //! @code //! suffix(xs, z) == flatten(transform(xs, [](auto x) { //! return concat(lift<M>(x), lift<M>(z)); //! })) //! @endcode //! //! For sequences, this simply corresponds to inserting the suffix after //! each element of the sequence. For example, given a sequence //! `[x1, ..., xn]`, `suffix` will return //! @code //! [x1, z, x2, z, ..., xn, z] //! @endcode //! As explained above, this can be generalized to other MonadPlus models, //! with various levels of interest. //! //! //! Signature //! --------- //! Given a MonadPlus `M`, the signature is //! @f$ \mathtt{suffix} : M(T) \times T \to M(T) @f$. //! //! @param xs //! A monadic structure. //! //! @param sfx //! A value (the suffix) to insert after each element of a monadic //! structure. //! //! //! Example //! ------- //! @include example/suffix.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto suffix = [](auto&& xs, auto&& sfx) { return tag-dispatched; }; #else template <typename M, typename = void> struct suffix_impl : suffix_impl<M, when<true>> { }; struct suffix_t { template <typename Xs, typename Sfx> constexpr auto operator()(Xs&& xs, Sfx&& sfx) const; }; constexpr suffix_t suffix{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_SUFFIX_HPP PK �|!\��� � eval.hppnu �[��� /*! @file Forward declares `boost::hana::eval`. @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_HPP #define BOOST_HANA_FWD_EVAL_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Evaluate a lazy value and return it. //! @relates hana::lazy //! //! Given a lazy expression `expr`, `eval` evaluates `expr` and returns //! the result as a normal value. However, for convenience, `eval` can //! also be used with nullary and unary function objects. Specifically, //! if `expr` is not a `hana::lazy`, it is called with no arguments at //! all and the result of that call (`expr()`) is returned. Otherwise, //! if `expr()` is ill-formed, then `expr(hana::id)` is returned instead. //! If that expression is ill-formed, then a compile-time error is //! triggered. //! //! The reason for allowing nullary callables in `eval` is because this //! allows using nullary lambdas as lazy branches to `eval_if`, which //! is convenient. The reason for allowing unary callables and calling //! them with `hana::id` is because this allows deferring the //! compile-time evaluation of selected expressions inside the callable. //! How this can be achieved is documented by `hana::eval_if`. //! //! //! Example //! ------- //! @include example/eval.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto eval = [](auto&& see_documentation) -> decltype(auto) { return tag-dispatched; }; #else template <typename T, typename = void> struct eval_impl : eval_impl<T, when<true>> { }; struct eval_t { template <typename Expr> constexpr decltype(auto) operator()(Expr&& expr) const; }; constexpr eval_t eval{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_EVAL_HPP PK �|!\<*��* * span.hppnu �[��� /*! @file Forward declares `boost::hana::span`. @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_SPAN_HPP #define BOOST_HANA_FWD_SPAN_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/detail/nested_by_fwd.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns a `Product` containing the longest prefix of a sequence //! satisfying a predicate, and the rest of the sequence. //! @ingroup group-Sequence //! //! The first component of the returned `Product` is a sequence for which //! all elements satisfy the given predicate. The second component of the //! returned `Product` is a sequence containing the remainder of the //! argument. Both or either sequences may be empty, depending on the //! input argument. More specifically, //! @code //! span(xs, predicate) == make_pair(take_while(xs, predicate), //! drop_while(xs, predicate)) //! @endcode //! except that `make_pair` may be an arbitrary `Product`. //! //! //! Signature //! --------- //! Given a `Sequence` `S(T)`, a `Logical` `Bool` and a predicate //! \f$ T \to Bool \f$, `span` has the following signature: //! \f[ //! \mathtt{span} : S(T) \times (T \to Bool) \to S(T) \times S(T) //! \f] //! //! @param xs //! The sequence to break into two parts. //! //! @param predicate //! A function called as `predicate(x)`, where `x` is an element of the //! sequence, and returning a `Logical. In the current implementation of //! the library, `predicate` has to return a compile-time `Logical`. //! //! //! Syntactic sugar (`span.by`) //! --------------------------- //! `span` can be called in an alternate way, which provides a nice syntax //! in some cases where the predicate is short: //! @code //! span.by(predicate, xs) == span(xs, predicate) //! span.by(predicate) == span(-, predicate) //! @endcode //! //! where `span(-, predicate)` denotes the partial application of //! `span` to `predicate`. //! //! //! Example //! ------- //! @include example/span.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto span = [](auto&& xs, auto&& predicate) { return tag-dispatched; }; #else template <typename S, typename = void> struct span_impl : span_impl<S, when<true>> { }; struct span_t : detail::nested_by<span_t> { template <typename Xs, typename Pred> constexpr auto operator()(Xs&& xs, Pred&& pred) const; }; constexpr span_t span{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_SPAN_HPP PK �|!\C� H1 1 prefix.hppnu �[��� /*! @file Forward declares `boost::hana::prefix`. @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_PREFIX_HPP #define BOOST_HANA_FWD_PREFIX_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Inserts a value before each element of a monadic structure. //! @ingroup group-MonadPlus //! //! Given a monadic structure `xs` and a value `z` called the prefix, //! `prefix` returns a new monadic structure. `prefix` satisfies //! @code //! prefix(xs, z) == flatten(transform(xs, [](auto x) { //! return concat(lift<M>(z), lift<M>(x)); //! })) //! @endcode //! //! For sequences, this simply corresponds to inserting the prefix before //! each element of the sequence. For example, given a sequence //! `[x1, ..., xn]`, `prefix` will return //! @code //! [z, x1, z, x2, ..., z, xn] //! @endcode //! As explained above, this can be generalized to other MonadPlus models, //! with various levels of interest. //! //! //! Signature //! --------- //! Given a MonadPlus `M`, the signature is //! @f$ \mathrm{prefix} : M(T) \times T \to M(T) @f$. //! //! @param xs //! A monadic structure. //! //! @param pref //! A value (the prefix) to insert before each element of a monadic //! structure. //! //! //! Example //! ------- //! @include example/prefix.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto prefix = [](auto&& xs, auto&& pref) { return tag-dispatched; }; #else template <typename M, typename = void> struct prefix_impl : prefix_impl<M, when<true>> { }; struct prefix_t { template <typename Xs, typename Pref> constexpr auto operator()(Xs&& xs, Pref&& pref) const; }; constexpr prefix_t prefix{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_PREFIX_HPP PK �|!\^We� � drop_front.hppnu �[��� /*! @file Forward declares `boost::hana::drop_front`. @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_DROP_FRONT_HPP #define BOOST_HANA_FWD_DROP_FRONT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Drop the first `n` elements of an iterable, and return the rest. //! @ingroup group-Iterable //! //! Given an `Iterable` `xs` with a linearization of `[x1, x2, ...]` and //! a non-negative `IntegralConstant` `n`, `drop_front(xs, n)` is an //! iterable with the same tag as `xs` whose linearization is //! `[xn+1, xn+2, ...]`. In particular, note that this function does not //! mutate the original iterable in any way. If `n` is not given, it //! defaults to an `IntegralConstant` with a value equal to `1`. //! //! In case `length(xs) <= n`, `drop_front` will simply drop the whole //! iterable without failing, thus returning an empty iterable. This is //! different from `drop_front_exactly`, which expects `n <= length(xs)` //! but can be better optimized because of this additional guarantee. //! //! //! @param xs //! The iterable from which elements are dropped. //! //! @param n //! A non-negative `IntegralConstant` representing the number of elements //! to be dropped from the iterable. If `n` is not given, it defaults to //! an `IntegralConstant` with a value equal to `1`. //! //! //! Example //! ------- //! @include example/drop_front.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto drop_front = [](auto&& xs[, auto const& n]) { return tag-dispatched; }; #else template <typename It, typename = void> struct drop_front_impl : drop_front_impl<It, when<true>> { }; struct drop_front_t { template <typename Xs, typename N> constexpr auto operator()(Xs&& xs, N const& n) const; template <typename Xs> constexpr auto operator()(Xs&& xs) const; }; constexpr drop_front_t drop_front{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_DROP_FRONT_HPP PK �|!\�Dӣ � reverse.hppnu �[��� /*! @file Forward declares `boost::hana::reverse`. @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_REVERSE_HPP #define BOOST_HANA_FWD_REVERSE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Reverse a sequence. //! @ingroup group-Sequence //! //! Specifically, `reverse(xs)` is a new sequence containing the same //! elements as `xs`, except in reverse order. //! //! //! @param xs //! The sequence to reverse. //! //! //! Example //! ------- //! @include example/reverse.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto reverse = [](auto&& xs) { return tag-dispatched; }; #else template <typename S, typename = void> struct reverse_impl : reverse_impl<S, when<true>> { }; struct reverse_t { template <typename Xs> constexpr auto operator()(Xs&& xs) const; }; constexpr reverse_t reverse{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_REVERSE_HPP PK �|!\��T�� � basic_tuple.hppnu �[��� /*! @file Forward declares `boost::hana::basic_tuple`. @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_BASIC_TUPLE_HPP #define BOOST_HANA_FWD_BASIC_TUPLE_HPP #include <boost/hana/config.hpp> #include <boost/hana/fwd/core/make.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-datatypes //! Stripped down version of `hana::tuple`. //! //! Whereas `hana::tuple` aims to provide an interface somewhat close to a //! `std::tuple`, `basic_tuple` provides the strict minimum required to //! implement a closure with maximum compile-time efficiency. //! //! @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). //! //! //! Modeled concepts //! ---------------- //! `Sequence`, and all the concepts it refines template <typename ...Xs> struct basic_tuple; //! Tag representing `hana::basic_tuple`. //! @relates hana::basic_tuple struct basic_tuple_tag { }; #ifdef BOOST_HANA_DOXYGEN_INVOKED //! Function object for creating a `basic_tuple`. //! @relates hana::basic_tuple //! //! Given zero or more objects `xs...`, `make<basic_tuple_tag>` returns a //! new `basic_tuple` containing those objects. The elements are held by //! value inside the resulting tuple, and they are hence copied or moved //! in. This is analogous to `std::make_tuple` for creating `basic_tuple`s. //! //! //! Example //! ------- //! @include example/basic_tuple/make.cpp template <> constexpr auto make<basic_tuple_tag> = [](auto&& ...xs) { return basic_tuple<std::decay_t<decltype(xs)>...>{forwarded(xs)...}; }; #endif //! Alias to `make<basic_tuple_tag>`; provided for convenience. //! @relates hana::basic_tuple //! //! //! Example //! ------- //! @include example/basic_tuple/make.cpp constexpr auto make_basic_tuple = make<basic_tuple_tag>; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_BASIC_TUPLE_HPP PK �|!\.b��l l erase_key.hppnu �[��� /*! @file Forward declares `boost::hana::erase_key`. @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_ERASE_KEY_HPP #define BOOST_HANA_FWD_ERASE_KEY_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN // Note: This function is documented per datatype/concept only. //! @cond template <typename T, typename = void> struct erase_key_impl : erase_key_impl<T, when<true>> { }; //! @endcond struct erase_key_t { template <typename Set, typename ...Args> constexpr decltype(auto) operator()(Set&& set, Args&& ...args) const; }; constexpr erase_key_t erase_key{}; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_ERASE_KEY_HPP PK �|!\H���� � members.hppnu �[��� /*! @file Forward declares `boost::hana::members`. @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_MEMBERS_HPP #define BOOST_HANA_FWD_MEMBERS_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns a `Sequence` containing the members of a `Struct`. //! @ingroup group-Struct //! //! Given a `Struct` object, `members` returns a `Sequence` containing //! all the members of the `Struct`, in the same order as their respective //! accessor appears in the `accessors` sequence. //! //! //! Example //! ------- //! @include example/members.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto members = [](auto&& object) { return tag-dispatched; }; #else template <typename S, typename = void> struct members_impl : members_impl<S, when<true>> { }; struct members_t { template <typename Object> constexpr auto operator()(Object&& object) const; }; constexpr members_t members{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_MEMBERS_HPP PK �|!\#�!�~ ~ zip.hppnu �[��� /*! @file Forward declares `boost::hana::zip`. @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_ZIP_HPP #define BOOST_HANA_FWD_ZIP_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Zip one sequence or more. //! @ingroup group-Sequence //! //! Given `n` sequences `s1, ..., sn`, `zip` produces a sequence whose //! `i`-th element is a tuple of `(s1[i], ..., sn[i])`, where `sk[i]` //! denotes the `i`-th element of the `k`-th sequence. In other words, //! `zip` produces a sequence of the form //! @code //! [ //! make_tuple(s1[0], ..., sn[0]), //! make_tuple(s1[1], ..., sn[1]), //! ... //! make_tuple(s1[M], ..., sn[M]) //! ] //! @endcode //! where `M` is the length of the sequences, which are all assumed to //! have the same length. Assuming the sequences to all have the same size //! allows the library to perform some optimizations. To zip sequences //! that may have different lengths, `zip_shortest` should be used //! instead. Also note that it is an error to provide no sequence at all, //! i.e. `zip` expects at least one sequence. //! //! //! Example //! ------- //! @include example/zip.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto zip = [](auto&& x1, ..., auto&& xn) { return tag-dispatched; }; #else template <typename S, typename = void> struct zip_impl : zip_impl<S, when<true>> { }; struct zip_t { template <typename Xs, typename ...Ys> constexpr auto operator()(Xs&& xs, Ys&& ...ys) const; }; constexpr zip_t zip{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_ZIP_HPP PK �|!\�D�� � fold_left.hppnu �[��� /*! @file Forward declares `boost::hana::fold_left`. @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_FOLD_LEFT_HPP #define BOOST_HANA_FWD_FOLD_LEFT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Left-fold of a structure using a binary operation and an optional //! initial reduction state. //! @ingroup group-Foldable //! //! `fold_left` is a left-associative fold using a binary operation. //! Given a structure containing `x1, ..., xn`, a function `f` and //! an optional initial state, `fold_left` applies `f` as follows //! @code //! f(... f(f(f(x1, x2), x3), x4) ..., xn) // without state //! f(... f(f(f(f(state, x1), x2), x3), x4) ..., xn) // with state //! @endcode //! //! When the structure is empty, two things may arise. If an initial //! state was provided, it is returned as-is. Otherwise, if the no-state //! version of the function was used, an error is triggered. When the //! stucture contains a single element and the no-state version of the //! function was used, that single element is returned as is. //! //! //! Signature //! --------- //! Given a `Foldable` `F` and an optional initial state of tag `S`, //! the signatures for `fold_left` are //! \f[ //! \mathtt{fold\_left} : F(T) \times S \times (S \times T \to S) \to S //! \f] //! //! for the variant with an initial state, and //! \f[ //! \mathtt{fold\_left} : F(T) \times (T \times T \to T) \to T //! \f] //! //! for the variant without an initial state. //! //! @param xs //! The structure to fold. //! //! @param state //! The initial value used for folding. //! //! @param f //! A binary function called as `f(state, x)`, where `state` is the //! result accumulated so far and `x` is an element in the structure. //! For left folds without an initial state, the function is called as //! `f(x1, x2)`, where `x1` and `x2` are elements of the structure. //! //! //! Example //! ------- //! @include example/fold_left.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto fold_left = [](auto&& xs[, auto&& state], auto&& f) -> decltype(auto) { return tag-dispatched; }; #else template <typename T, typename = void> struct fold_left_impl : fold_left_impl<T, when<true>> { }; struct fold_left_t { template <typename Xs, typename State, typename F> constexpr decltype(auto) operator()(Xs&& xs, State&& state, F&& f) const; template <typename Xs, typename F> constexpr decltype(auto) operator()(Xs&& xs, F&& f) const; }; constexpr fold_left_t fold_left{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_FOLD_LEFT_HPP PK �|!\�P�oK K back.hppnu �[��� /*! @file Forward declares `boost::hana::back`. @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_BACK_HPP #define BOOST_HANA_FWD_BACK_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns the last element of a non-empty and finite iterable. //! @ingroup group-Iterable //! //! Given a non-empty and finite iterable `xs` with a linearization of //! `[x1, ..., xN]`, `back(xs)` is equal to `xN`. Equivalently, `back(xs)` //! must be equivalent to `at_c<N-1>(xs)`, and that regardless of the //! value category of `xs` (`back` must respect the reference semantics //! of `at`). //! //! //! Example //! ------- //! @include example/back.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto back = [](auto&& xs) -> decltype(auto) { return tag-dispatched; }; #else template <typename It, typename = void> struct back_impl : back_impl<It, when<true>> { }; struct back_t { template <typename Xs> constexpr decltype(auto) operator()(Xs&& xs) const; }; constexpr back_t back{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_BACK_HPP PK �|!\ � ?� � is_empty.hppnu �[��� /*! @file Forward declares `boost::hana::is_empty`. @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_IS_EMPTY_HPP #define BOOST_HANA_FWD_IS_EMPTY_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns whether the iterable is empty. //! @ingroup group-Iterable //! //! Given an `Iterable` `xs`, `is_empty` returns whether `xs` contains //! no more elements. In other words, it returns whether trying to //! extract the tail of `xs` would be an error. In the current version //! of the library, `is_empty` must return an `IntegralConstant` holding //! a value convertible to `bool`. This is because only compile-time //! `Iterable`s are supported right now. //! //! //! Example //! ------- //! @include example/is_empty.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto is_empty = [](auto const& xs) { return tag-dispatched; }; #else template <typename It, typename = void> struct is_empty_impl : is_empty_impl<It, when<true>> { }; struct is_empty_t { template <typename Xs> constexpr auto operator()(Xs const& xs) const; }; constexpr is_empty_t is_empty{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_IS_EMPTY_HPP PK �|!\ ?�%C C not_equal.hppnu �[��� /*! @file Forward declares `boost::hana::not_equal`. @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_NOT_EQUAL_HPP #define BOOST_HANA_FWD_NOT_EQUAL_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/detail/nested_to_fwd.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns a `Logical` representing whether `x` is not equal to `y`. //! @ingroup group-Comparable //! //! The `not_equal` function can be called in two different ways. First, //! it can be called like a normal function: //! @code //! not_equal(x, y) //! @endcode //! //! However, it may also be partially applied to an argument by using //! `not_equal.to`: //! @code //! not_equal.to(x)(y) == not_equal(x, y) //! @endcode //! //! In other words, `not_equal.to(x)` is a function object that is //! equivalent to `partial(not_equal, x)`. This is provided to enhance //! the readability of some constructs, especially when using higher //! order algorithms. //! //! //! Signature //! --------- //! Given a Logical `Bool` and two Comparables `A` and `B` that //! share a common embedding, the signature is //! @f$ \mathtt{not\_equal} : A \times B \to Bool @f$. //! //! @param x, y //! Two objects to compare for inequality. //! //! //! Example //! ------- //! @include example/not_equal.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto not_equal = [](auto&& x, auto&& y) { return tag-dispatched; }; #else template <typename T, typename U, typename = void> struct not_equal_impl : not_equal_impl<T, U, when<true>> { }; struct not_equal_t : detail::nested_to<not_equal_t> { template <typename X, typename Y> constexpr auto operator()(X&& x, Y&& y) const; }; constexpr not_equal_t not_equal{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_NOT_EQUAL_HPP PK �|!\˩W� � is_subset.hppnu �[��� /*! @file Forward declares `boost::hana::is_subset`. @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_IS_SUBSET_HPP #define BOOST_HANA_FWD_IS_SUBSET_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/functional/infix.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns whether a structure contains a subset of the keys of //! another structure. //! @ingroup group-Searchable //! //! Given two `Searchable`s `xs` and `ys`, `is_subset` returns a `Logical` //! representing whether `xs` is a subset of `ys`. In other words, it //! returns whether all the keys of `xs` are also present in `ys`. This //! method does not return whether `xs` is a _strict_ subset of `ys`; if //! `xs` and `ys` are equal, all the keys of `xs` are also present in //! `ys`, and `is_subset` returns true. //! //! @note //! For convenience, `is_subset` can also be applied in infix notation. //! //! //! Cross-type version of the method //! -------------------------------- //! This method is tag-dispatched using the tags of both arguments. //! It can be called with any two `Searchable`s sharing a common //! `Searchable` embedding, as defined in the main documentation //! of the `Searchable` concept. When `Searchable`s with two different //! tags but sharing a common embedding are sent to `is_subset`, they //! are first converted to this common `Searchable` and the `is_subset` //! method of the common embedding is then used. Of course, the method //! can be overriden for custom `Searchable`s for efficieny. //! //! @note //! While cross-type dispatching for `is_subset` is supported, it is //! not currently used by the library because there are no models //! of `Searchable` with a common embedding. //! //! //! @param xs //! The structure to check whether it is a subset of `ys`. //! //! @param ys //! The structure to check whether it is a superset of `xs`. //! //! //! Example //! ------- //! @include example/is_subset.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto is_subset = [](auto&& xs, auto&& ys) { return tag-dispatched; }; #else template <typename S1, typename S2, typename = void> struct is_subset_impl : is_subset_impl<S1, S2, when<true>> { }; struct is_subset_t { template <typename Xs, typename Ys> constexpr auto operator()(Xs&& xs, Ys&& ys) const; }; constexpr auto is_subset = hana::infix(is_subset_t{}); #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_IS_SUBSET_HPP PK �|!\ ZY>G G zero.hppnu �[��� /*! @file Forward declares `boost::hana::zero`. @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_ZERO_HPP #define BOOST_HANA_FWD_ZERO_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Identity of `plus`. //! @ingroup group-Monoid //! //! @tparam M //! The tag (a `Monoid`) of the returned identity. //! //! //! Example //! ------- //! @include example/zero.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename M> constexpr auto zero = []() -> decltype(auto) { return tag-dispatched; }; #else template <typename M, typename = void> struct zero_impl : zero_impl<M, when<true>> { }; template <typename M> struct zero_t { constexpr decltype(auto) operator()() const; }; template <typename M> constexpr zero_t<M> zero{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_ZERO_HPP PK �|!\P��,o o prepend.hppnu �[��� /*! @file Forward declares `boost::hana::prepend`. @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_PREPEND_HPP #define BOOST_HANA_FWD_PREPEND_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Prepend an element to a monadic structure. //! @ingroup group-MonadPlus //! //! Given a monadic structure `xs` and an element `x`, `prepend` returns //! a new monadic structure which is the result of lifting `x` into the //! monadic structure and then combining that (to the left) with `xs`. //! In other words, //! @code //! prepend(xs, x) == concat(lift<Xs>(x), xs) //! @endcode //! //! For sequences, this has the intuitive behavior of simply prepending //! an element to the beginning of the sequence, hence the name. //! //! > #### Rationale for not calling this `push_front` //! > While `push_front` is the de-facto name used in the standard library, //! > it also strongly suggests mutation of the underlying sequence, which //! > is not the case here. The author also finds that `push_front` //! > suggests too strongly the sole interpretation of putting an //! > element to the front of a sequence, whereas `prepend` is slightly //! > more nuanced and bears its name better for e.g. `hana::optional`. //! //! //! Signature //! --------- //! Given a MonadPlus `M`, the signature is //! @f$ \mathtt{prepend} : M(T) \times T \to M(T) @f$. //! //! @param xs //! A monadic structure that will be combined to the right of the element. //! //! @param x //! An element to combine to the left of the monadic structure. //! //! //! Example //! ------- //! @include example/prepend.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto prepend = [](auto&& xs, auto&& x) { return tag-dispatched; }; #else template <typename M, typename = void> struct prepend_impl : prepend_impl<M, when<true>> { }; struct prepend_t { template <typename Xs, typename X> constexpr auto operator()(Xs&& xs, X&& x) const; }; constexpr prepend_t prepend{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_PREPEND_HPP PK �|!\�i݈ � pair.hppnu �[��� /*! @file Forward declares `boost::hana::pair`. @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_PAIR_HPP #define BOOST_HANA_FWD_PAIR_HPP #include <boost/hana/config.hpp> #include <boost/hana/fwd/core/make.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-datatypes //! Generic container for two elements. //! //! `hana::pair` is conceptually the same as `std::pair`. However, //! `hana::pair` automatically compresses the storage of empty types, //! and as a result it does not have the `.first` and `.second` members. //! Instead, one must use the `hana::first` and `hana::second` free //! functions to access the elements of a pair. //! //! @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). //! //! //! Modeled concepts //! ---------------- //! 1. `Comparable`\n //! Two pairs `(x, y)` and `(x', y')` are equal if and only if both //! `x == x'` and `y == y'`. //! @include example/pair/comparable.cpp //! //! 2. `Orderable`\n //! Pairs are ordered as-if they were 2-element tuples, using a //! lexicographical ordering. //! @include example/pair/orderable.cpp //! //! 3. `Foldable`\n //! Folding a pair is equivalent to folding a 2-element tuple. In other //! words: //! @code //! fold_left(make_pair(x, y), s, f) == f(f(s, x), y) //! fold_right(make_pair(x, y), s, f) == f(x, f(y, s)) //! @endcode //! Example: //! @include example/pair/foldable.cpp //! //! 4. `Product`\n //! The model of `Product` is the simplest one possible; the first element //! of a pair `(x, y)` is `x`, and its second element is `y`. //! @include example/pair/product.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename First, typename Second> struct pair { //! Default constructs the `pair`. Only exists when both elements //! of the pair are default constructible. constexpr pair(); //! Initialize each element of the pair with the corresponding element. //! Only exists when both elements of the pair are copy-constructible. constexpr pair(First const& first, Second const& second); //! Initialize both elements of the pair by perfect-forwarding the //! corresponding argument. Only exists when both arguments are //! implicitly-convertible to the corresponding element of the pair. template <typename T, typename U> constexpr pair(T&& t, U&& u); //! Copy-initialize a pair from another pair. Only exists when both //! elements of the source pair are implicitly convertible to the //! corresponding element of the constructed pair. template <typename T, typename U> constexpr pair(pair<T, U> const& other); //! Move-initialize a pair from another pair. Only exists when both //! elements of the source pair are implicitly convertible to the //! corresponding element of the constructed pair. template <typename T, typename U> constexpr pair(pair<T, U>&& other); //! Assign a pair to another pair. Only exists when both elements //! of the destination pair are assignable from the corresponding //! element in the source pair. template <typename T, typename U> constexpr pair& operator=(pair<T, U> const& other); //! Move-assign a pair to another pair. Only exists when both elements //! of the destination pair are move-assignable from the corresponding //! element in the source pair. template <typename T, typename U> constexpr pair& operator=(pair<T, U>&& other); //! 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 First, typename Second> struct pair; #endif //! Tag representing `hana::pair`. //! @relates hana::pair struct pair_tag { }; #ifdef BOOST_HANA_DOXYGEN_INVOKED //! Creates a `hana::pair` with the given elements. //! @relates hana::pair //! //! //! Example //! ------- //! @include example/pair/make.cpp template <> constexpr auto make<pair_tag> = [](auto&& first, auto&& second) -> hana::pair<std::decay_t<decltype(first)>, std::decay_t<decltype(second)>> { return {forwarded(first), forwarded(second)}; }; #endif //! Alias to `make<pair_tag>`; provided for convenience. //! @relates hana::pair //! //! Example //! ------- //! @include example/pair/make.cpp constexpr auto make_pair = make<pair_tag>; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_PAIR_HPP PK �|!\�yݬ� � maximum.hppnu �[��� /*! @file Forward declares `boost::hana::maximum`. @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_MAXIMUM_HPP #define BOOST_HANA_FWD_MAXIMUM_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/detail/nested_by_fwd.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Return the greatest element of a non-empty structure with respect to //! a `predicate`, by default `less`. //! @ingroup group-Foldable //! //! Given a non-empty structure and an optional binary predicate //! (`less` by default), `maximum` returns the greatest element of //! the structure, i.e. an element which is greater than or equal to //! every other element in the structure, according to the predicate. //! //! If the structure contains heterogeneous objects, then the predicate //! must return a compile-time `Logical`. If no predicate is provided, //! the elements in the structure must be Orderable, or compile-time //! Orderable if the structure is heterogeneous. //! //! //! Signature //! --------- //! Given a Foldable `F`, a Logical `Bool` and a predicate //! \f$ \mathtt{pred} : T \times T \to Bool \f$, `maximum` has the //! following signatures. For the variant with a provided predicate, //! \f[ //! \mathtt{maximum} : F(T) \times (T \times T \to Bool) \to T //! \f] //! //! for the variant without a custom predicate, `T` is required to be //! Orderable. The signature is then //! \f[ //! \mathtt{maximum} : F(T) \to T //! \f] //! //! @param xs //! The structure to find the greatest element of. //! //! @param predicate //! A function called as `predicate(x, y)`, where `x` and `y` are elements //! of the structure. `predicate` should be a strict weak ordering on the //! elements of the structure and its return value should be a Logical, //! or a compile-time Logical if the structure is heterogeneous. //! //! ### Example //! @include example/maximum.cpp //! //! //! Syntactic sugar (`maximum.by`) //! ------------------------------ //! `maximum` can be called in a third way, which provides a nice syntax //! especially when working with the `ordering` combinator: //! @code //! maximum.by(predicate, xs) == maximum(xs, predicate) //! maximum.by(predicate) == maximum(-, predicate) //! @endcode //! //! where `maximum(-, predicate)` denotes the partial application of //! `maximum` to `predicate`. //! //! ### Example //! @include example/maximum_by.cpp //! //! //! Tag dispatching //! --------------- //! Both the non-predicated version and the predicated versions of //! `maximum` are tag-dispatched methods, and hence they can be //! customized independently. One reason for this is that some //! structures are able to provide a much more efficient implementation //! of `maximum` when the `less` predicate is used. Here is how the //! different versions of `maximum` are dispatched: //! @code //! maximum(xs) -> maximum_impl<tag of xs>::apply(xs) //! maximum(xs, pred) -> maximum_pred_impl<tag of xs>::apply(xs, pred) //! @endcode //! //! Also note that `maximum.by` is not tag-dispatched on its own, since it //! is just syntactic sugar for calling the corresponding `maximum`. #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto maximum = [](auto&& xs[, auto&& predicate]) -> decltype(auto) { return tag-dispatched; }; #else template <typename T, typename = void> struct maximum_impl : maximum_impl<T, when<true>> { }; template <typename T, typename = void> struct maximum_pred_impl : maximum_pred_impl<T, when<true>> { }; struct maximum_t : detail::nested_by<maximum_t> { template <typename Xs> constexpr decltype(auto) operator()(Xs&& xs) const; template <typename Xs, typename Predicate> constexpr decltype(auto) operator()(Xs&& xs, Predicate&& pred) const; }; constexpr maximum_t maximum{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_MAXIMUM_HPP PK �|!\ Z&� � drop_while.hppnu �[��� /*! @file Forward declares `boost::hana::drop_while`. @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_DROP_WHILE_HPP #define BOOST_HANA_FWD_DROP_WHILE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Drop elements from an iterable up to, but excluding, the first //! element for which the `predicate` is not satisfied. //! @ingroup group-Iterable //! //! Specifically, `drop_while` returns an iterable containing all the //! elements of the original iterable except for those in the range //! delimited by [`head`, `e`), where `head` is the first element and //! `e` is the first element for which the `predicate` is not satisfied. //! If the iterable is not finite, the `predicate` has to return a false- //! valued `Logical` at a finite index for this method to return. //! //! //! @param iterable //! The iterable from which elements are dropped. //! //! @param predicate //! A function called as `predicate(x)`, where `x` is an element of the //! structure, and returning a `Logical` representing whether `x` should //! be dropped from the structure. In the current version of the library, //! `predicate` should return a compile-time `Logical`. //! //! //! Example //! ------- //! @include example/drop_while.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto drop_while = [](auto&& iterable, auto&& predicate) { return tag-dispatched; }; #else template <typename It, typename = void> struct drop_while_impl : drop_while_impl<It, when<true>> { }; struct drop_while_t { template <typename Xs, typename Pred> constexpr auto operator()(Xs&& xs, Pred&& pred) const; }; constexpr drop_while_t drop_while{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWDDROP_WHILE_HPP PK �|!\���+� � adjust.hppnu �[��� /*! @file Forward declares `boost::hana::adjust`. @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_ADJUST_HPP #define BOOST_HANA_FWD_ADJUST_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Apply a function on all the elements of a structure that compare //! equal to some value. //! @ingroup group-Functor //! //! //! Signature //! --------- //! Given `F` a Functor and `U` a type that can be compared with `T`'s, //! the signature is //! \f$ //! \mathtt{adjust} : F(T) \times U \times (T \to T) \to F(T) //! \f$ //! //! @param xs //! The structure to adjust with `f`. //! //! @param value //! An object that is compared with each element `x` of the structure. //! Elements of the structure that compare equal to `value` are adjusted //! with the `f` function. //! //! @param f //! A function called as `f(x)` on the element(s) of the structure that //! compare equal to `value`. //! //! //! Example //! ------- //! @include example/adjust.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto adjust = [](auto&& xs, auto&& value, auto&& f) { return tag-dispatched; }; #else template <typename Xs, typename = void> struct adjust_impl : adjust_impl<Xs, when<true>> { }; struct adjust_t { template <typename Xs, typename Value, typename F> constexpr auto operator()(Xs&& xs, Value&& value, F&& f) const; }; constexpr adjust_t adjust{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_ADJUST_HPP PK �|!\�-�� � cycle.hppnu �[��� /*! @file Forward declares `boost::hana::cycle`. @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_CYCLE_HPP #define BOOST_HANA_FWD_CYCLE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Combine a monadic structure with itself `n` times. //! @ingroup group-MonadPlus //! //! Given a monadic structure `xs` and a non-negative number `n`, //! `cycle` returns a new monadic structure which is the result of //! combining `xs` with itself `n` times using the `concat` operation. //! In other words, //! @code //! cycle(xs, n) == concat(xs, concat(xs, ... concat(xs, xs))) //! // ^^^^^ n times total //! @endcode //! //! Also note that since `concat` is required to be associative, we //! could also have written //! @code //! cycle(xs, n) == concat(concat(... concat(xs, xs), xs), xs) //! // ^^^^^ n times total //! @endcode //! //! If `n` is zero, then the identity of `concat`, `empty`, is returned. //! In the case of sequences, this boils down to returning a sequence //! containing `n` copies of itself; for other models it might differ. //! //! //! Signature //! --------- //! Given an `IntegralConstant` `C` and a `MonadPlus` `M`, the signature is //! @f$ \mathrm{cycle} : M(T) \times C \to M(T) @f$. //! //! @param xs //! A monadic structure to combine with itself a certain number of times. //! //! @param n //! A non-negative `IntegralConstant` representing the number of times to //! combine the monadic structure with itself. If `n` is zero, `cycle` //! returns `empty`. //! //! //! Example //! ------- //! @include example/cycle.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto cycle = [](auto&& xs, auto const& n) { return tag-dispatched; }; #else template <typename M, typename = void> struct cycle_impl : cycle_impl<M, when<true>> { }; struct cycle_t { template <typename Xs, typename N> constexpr auto operator()(Xs&& xs, N const& n) const; }; constexpr cycle_t cycle{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CYCLE_HPP PK �|!\��o� � second.hppnu �[��� /*! @file Forward declares `boost::hana::second`. @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_SECOND_HPP #define BOOST_HANA_FWD_SECOND_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns the second element of a pair. //! @ingroup group-Product //! //! Note that if the `Product` actually stores the elements it contains, //! `hana::second` is required to return a lvalue reference, a lvalue //! reference to const or a rvalue reference to the second element, where //! the type of reference must match that of the pair passed to `second`. //! If the `Product` does not store the elements it contains (i.e. it //! generates them on demand), this requirement is dropped. //! //! Example //! ------- //! @include example/second.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto second = [](auto&& product) -> decltype(auto) { return tag-dispatched; }; #else template <typename P, typename = void> struct second_impl : second_impl<P, when<true>> { }; struct second_t { template <typename Pair> constexpr decltype(auto) operator()(Pair&& pair) const; }; constexpr second_t second{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_SECOND_HPP PK �|!\ ��2� � for_each.hppnu �[��� /*! @file Forward declares `boost::hana::for_each`. @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_FOR_EACH_HPP #define BOOST_HANA_FWD_FOR_EACH_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Perform an action on each element of a foldable, discarding //! the result each time. //! @ingroup group-Foldable //! //! Iteration is done from left to right, i.e. in the same order as when //! using `fold_left`. If the structure is not finite, this method will //! not terminate. //! //! //! @param xs //! The structure to iterate over. //! //! @param f //! A function called as `f(x)` for each element `x` of the structure. //! The result of `f(x)`, whatever it is, is ignored. //! //! //! Example //! ------- //! @include example/for_each.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto for_each = [](auto&& xs, auto&& f) -> void { tag-dispatched; }; #else template <typename T, typename = void> struct for_each_impl : for_each_impl<T, when<true>> { }; struct for_each_t { template <typename Xs, typename F> constexpr void operator()(Xs&& xs, F&& f) const; }; constexpr for_each_t for_each{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_FOR_EACH_HPP PK �|!\�;OKj! j! tuple.hppnu �[��� /*! @file Forward declares `boost::hana::tuple`. @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_TUPLE_HPP #define BOOST_HANA_FWD_TUPLE_HPP #include <boost/hana/config.hpp> #include <boost/hana/fwd/core/make.hpp> #include <boost/hana/fwd/core/to.hpp> #include <boost/hana/fwd/integral_constant.hpp> #include <boost/hana/fwd/type.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-datatypes //! General purpose index-based heterogeneous sequence with a fixed length. //! //! The tuple is the bread and butter for static metaprogramming. //! Conceptually, it is like a `std::tuple`; it is a container able //! of holding objects of different types and whose size is fixed at //! compile-time. However, Hana's tuple provides much more functionality //! than its `std` counterpart, and it is also much more efficient than //! all standard library implementations tested so far. //! //! Tuples are index-based sequences. If you need an associative //! sequence with a key-based access, then you should consider //! `hana::map` or `hana::set` instead. //! //! @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). //! //! //! Modeled concepts //! ---------------- //! `Sequence`, and all the concepts it refines //! //! //! Provided operators //! ------------------ //! For convenience, the following operators are provided: //! @code //! xs == ys -> equal(xs, ys) //! xs != ys -> not_equal(xs, ys) //! //! xs < ys -> less(xs, ys) //! xs <= ys -> less_equal(xs, ys) //! xs > ys -> greater(xs, ys) //! xs >= ys -> greater_equal(xs, ys) //! //! xs | f -> chain(xs, f) //! //! xs[n] -> at(xs, n) //! @endcode //! //! //! Example //! ------- //! @include example/tuple/tuple.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename ...Xn> struct tuple { //! Default constructs the `tuple`. Only exists when all the elements //! of the tuple are default constructible. constexpr tuple(); //! Initialize each element of the tuple with the corresponding element //! from `xn...`. Only exists when all the elements of the tuple are //! copy-constructible. //! //! @note //! Unlike the corresponding constructor for `std::tuple`, this //! constructor is not explicit. This allows returning a tuple //! from a function with the brace-initialization syntax. constexpr tuple(Xn const& ...xn); //! Initialize each element of the tuple by perfect-forwarding the //! corresponding element in `yn...`. Only exists when all the //! elements of the created tuple are constructible from the //! corresponding perfect-forwarded value. //! //! @note //! Unlike the corresponding constructor for `std::tuple`, this //! constructor is not explicit. This allows returning a tuple //! from a function with the brace-initialization syntax. template <typename ...Yn> constexpr tuple(Yn&& ...yn); //! Copy-initialize a tuple from another tuple. Only exists when all //! the elements of the constructed tuple are copy-constructible from //! the corresponding element in the source tuple. template <typename ...Yn> constexpr tuple(tuple<Yn...> const& other); //! Move-initialize a tuple from another tuple. Only exists when all //! the elements of the constructed tuple are move-constructible from //! the corresponding element in the source tuple. template <typename ...Yn> constexpr tuple(tuple<Yn...>&& other); //! Assign a tuple to another tuple. Only exists when all the elements //! of the destination tuple are assignable from the corresponding //! element in the source tuple. template <typename ...Yn> constexpr tuple& operator=(tuple<Yn...> const& other); //! Move-assign a tuple to another tuple. Only exists when all the //! elements of the destination tuple are move-assignable from the //! corresponding element in the source tuple. template <typename ...Yn> constexpr tuple& operator=(tuple<Yn...>&& other); //! Equivalent to `hana::chain`. template <typename ...T, typename F> friend constexpr auto operator|(tuple<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); //! Equivalent to `hana::at` template <typename N> constexpr decltype(auto) operator[](N&& n); }; #else template <typename ...Xn> struct tuple; #endif //! Tag representing `hana::tuple`s. //! @related tuple struct tuple_tag { }; #ifdef BOOST_HANA_DOXYGEN_INVOKED //! Function object for creating a `tuple`. //! @relates hana::tuple //! //! Given zero or more objects `xs...`, `make<tuple_tag>` returns a new tuple //! containing those objects. The elements are held by value inside the //! resulting tuple, and they are hence copied or moved in. This is //! analogous to `std::make_tuple` for creating Hana tuples. //! //! //! Example //! ------- //! @include example/tuple/make.cpp template <> constexpr auto make<tuple_tag> = [](auto&& ...xs) { return tuple<std::decay_t<decltype(xs)>...>{forwarded(xs)...}; }; #endif //! Alias to `make<tuple_tag>`; provided for convenience. //! @relates hana::tuple constexpr auto make_tuple = make<tuple_tag>; //! Equivalent to `to<tuple_tag>`; provided for convenience. //! @relates hana::tuple constexpr auto to_tuple = to<tuple_tag>; //! Create a tuple specialized for holding `hana::type`s. //! @relates hana::tuple //! //! This is functionally equivalent to `make<tuple_tag>(type_c<T>...)`, except //! that using `tuple_t` allows the library to perform some compile-time //! optimizations. Also note that the type of the objects returned by //! `tuple_t` and an equivalent call to `make<tuple_tag>` may differ. //! //! //! Example //! ------- //! @include example/tuple/tuple_t.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename ...T> constexpr implementation_defined tuple_t{}; #else template <typename ...T> constexpr hana::tuple<hana::type<T>...> tuple_t{}; #endif //! Create a tuple specialized for holding `hana::integral_constant`s. //! @relates hana::tuple //! //! This is functionally equivalent to `make<tuple_tag>(integral_c<T, v>...)`, //! except that using `tuple_c` allows the library to perform some //! compile-time optimizations. Also note that the type of the objects //! returned by `tuple_c` and an equivalent call to `make<tuple_tag>` may differ. //! //! //! Example //! ------- //! @include example/tuple/tuple_c.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename T, T ...v> constexpr implementation_defined tuple_c{}; #else template <typename T, T ...v> constexpr hana::tuple<hana::integral_constant<T, v>...> tuple_c{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_TUPLE_HPP PK �|!\KZ�� extract.hppnu �[��� /*! @file Forward declares `boost::hana::extract`. @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_EXTRACT_HPP #define BOOST_HANA_FWD_EXTRACT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Extract a value in a given comonadic context. //! @ingroup group-Comonad //! //! Given a value inside a comonadic context, extract it from that //! context, performing whatever effects are mandated by that context. //! This can be seen as the dual operation to the `lift` method of the //! Applicative concept. //! //! //! Signature //! --------- //! Given a Comonad `W`, the signature is //! \f$ //! \mathtt{extract} : W(T) \to T //! \f$ //! //! @param w //! The value to be extracted inside a comonadic context. //! //! //! Example //! ------- //! @include example/extract.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto extract = [](auto&& w) -> decltype(auto) { return tag-dispatched; }; #else template <typename W, typename = void> struct extract_impl : extract_impl<W, when<true>> { }; struct extract_t { template <typename W_> constexpr decltype(auto) operator()(W_&& w) const; }; constexpr extract_t extract{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_EXTRACT_HPP PK �|!\�1�� � and.hppnu �[��� /*! @file Forward declares `boost::hana::and_`. @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_AND_HPP #define BOOST_HANA_FWD_AND_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Return whether all the arguments are true-valued. //! @ingroup group-Logical //! //! `and_` can be called with one argument or more. When called with //! two arguments, `and_` uses tag-dispatching to find the right //! implementation. Otherwise, //! @code //! and_(x) == x //! and_(x, y, ...z) == and_(and_(x, y), z...) //! @endcode //! //! //! Example //! ------- //! @include example/and.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto and_ = [](auto&& x, auto&& ...y) -> decltype(auto) { return tag-dispatched; }; #else template <typename L, typename = void> struct and_impl : and_impl<L, when<true>> { }; struct and_t { template <typename X, typename Y> constexpr decltype(auto) operator()(X&& x, Y&& y) const; template <typename X, typename ...Y> constexpr decltype(auto) operator()(X&& x, Y&& ...y) const; }; constexpr and_t and_{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_AND_HPP PK �|!\���. . concat.hppnu �[��� /*! @file Forward declares `boost::hana::concat`. @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_CONCAT_HPP #define BOOST_HANA_FWD_CONCAT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Combine two monadic structures together. //! @ingroup group-MonadPlus //! //! Given two monadic structures, `concat` combines them together and //! returns a new monadic structure. The exact definition of `concat` //! will depend on the exact model of MonadPlus at hand, but for //! sequences it corresponds intuitively to simple concatenation. //! //! Also note that combination is not required to be commutative. //! In other words, there is no requirement that //! @code //! concat(xs, ys) == concat(ys, xs) //! @endcode //! and indeed it does not hold in general. //! //! //! Signature //! --------- //! Given a `MonadPlus` `M`, the signature of `concat` is //! @f$ \mathtt{concat} : M(T) \times M(T) \to M(T) @f$. //! //! @param xs, ys //! Two monadic structures to combine together. //! //! //! Example //! ------- //! @include example/concat.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto concat = [](auto&& xs, auto&& ys) { return tag-dispatched; }; #else template <typename M, typename = void> struct concat_impl : concat_impl<M, when<true>> { }; struct concat_t { template <typename Xs, typename Ys> constexpr auto operator()(Xs&& xs, Ys&& ys) const; }; constexpr concat_t concat{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCAT_HPP PK �|!\ؙQΓ � count.hppnu �[��� /*! @file Forward declares `boost::hana::count`. @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_COUNT_HPP #define BOOST_HANA_FWD_COUNT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Return the number of elements in the structure that compare equal to //! a given value. //! @ingroup group-Foldable //! //! Given a Foldable structure `xs` and a value `value`, `count` returns //! an unsigned integral, or a Constant thereof, representing the number //! of elements of `xs` that compare equal to `value`. For this method to //! be well-defined, all the elements of the structure must be Comparable //! with the given value. //! //! //! @param xs //! The structure whose elements are counted. //! //! @param value //! A value compared with each element in the structure. Elements //! that compare equal to this value are counted, others are not. //! //! //! Example //! ------- //! @include example/count.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto count = [](auto&& xs, auto&& value) { return tag-dispatched; }; #else template <typename T, typename = void> struct count_impl : count_impl<T, when<true>> { }; struct count_t { template <typename Xs, typename Value> constexpr auto operator()(Xs&& xs, Value&& value) const; }; constexpr count_t count{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_COUNT_HPP PK �|!\��6�� � length.hppnu �[��� /*! @file Forward declares `boost::hana::length`. @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_LENGTH_HPP #define BOOST_HANA_FWD_LENGTH_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Return the number of elements in a foldable structure. //! @ingroup group-Foldable //! //! Given a `Foldable` `xs`, `length(xs)` must return an object of an //! unsigned integral type, or an `IntegralConstant` holding such an //! object, which represents the number of elements in the structure. //! //! @note //! Since only compile-time `Foldable`s are supported in the library //! right now, `length` must always return an `IntegralConstant`. //! //! //! Example //! ------- //! @include example/length.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto length = [](auto const& xs) { return tag-dispatched; }; #else template <typename T, typename = void> struct length_impl : length_impl<T, when<true>> { }; struct length_t { template <typename Xs> constexpr auto operator()(Xs const& xs) const; }; constexpr length_t length{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_LENGTH_HPP PK �|!\D�F� at.hppnu �[��� /*! @file Forward declares `boost::hana::at` and `boost::hana::at_c`. @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_AT_HPP #define BOOST_HANA_FWD_AT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <cstddef> BOOST_HANA_NAMESPACE_BEGIN //! Returns the `n`th element of an iterable. //! @ingroup group-Iterable //! //! Given an `Iterable` and an `IntegralConstant` index, `at` returns the //! element located at the index in the linearization of the iterable. //! Specifically, given an iterable `xs` with a linearization of //! `[x1, ..., xN]`, `at(xs, k)` is equivalent to `xk`. //! //! If the `Iterable` actually stores the elements it contains, `at` is //! required to return a lvalue reference, a lvalue reference to const //! or a rvalue reference to the matching element, where the type of //! reference must match that of the iterable passed to `at`. If the //! `Iterable` does not store the elements it contains (i.e. it generates //! them on demand), this requirement is dropped. //! //! //! @param xs //! The iterable in which an element is retrieved. The iterable must //! contain at least `n + 1` elements. //! //! @param n //! A non-negative `IntegralConstant` representing the 0-based index of //! the element to return. It is an error to call `at` with an index that //! out of bounds of the iterable. //! //! //! Example //! ------- //! @include example/at.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto at = [](auto&& xs, auto const& n) -> decltype(auto) { return tag-dispatched; }; #else template <typename It, typename = void> struct at_impl : at_impl<It, when<true>> { }; struct at_t { template <typename Xs, typename N> constexpr decltype(auto) operator()(Xs&& xs, N const& n) const; }; constexpr at_t at{}; #endif //! Equivalent to `at`; provided for convenience. //! @ingroup group-Iterable //! //! //! @note //! `hana::at_c<n>` is an overloaded function, not a function object. //! Hence, it can't be passed to higher-order algorithms. This is done //! for compile-time performance reasons. //! //! //! Example //! ------- //! @include example/at_c.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <std::size_t n> constexpr auto at_c = [](auto&& xs) { return hana::at(forwarded(xs), hana::size_c<n>); }; #else template <std::size_t n, typename Xs> constexpr decltype(auto) at_c(Xs&& xs); #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_AT_HPP PK �|!\�Ӏ�� � adjust_if.hppnu �[��� /*! @file Forward declares `boost::hana::adjust_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_ADJUST_IF_HPP #define BOOST_HANA_FWD_ADJUST_IF_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Apply a function on all the elements of a structure satisfying a predicate. //! @ingroup group-Functor //! //! Given a Functor, a predicate `pred` and a function `f`, `adjust_if` //! will _adjust_ the elements of the Functor that satisfy the predicate //! with the function `f`. In other words, `adjust_if` will return a new //! Functor equal to the original one, except that the elements satisfying //! the predicate will be transformed with the given function. Elements //! for which the predicate is not satisfied are left untouched, and they //! are kept as-is in the resulting Functor. //! //! //! Signature //! --------- //! Given a `Functor` `F` and a `Logical` `Bool`, the signature is //! \f$ //! \mathtt{adjust\_if} : F(T) \times (T \to Bool) \times (T \to T) \to F(T) //! \f$ //! //! @param xs //! The structure to adjust with `f`. //! //! @param pred //! A function called as `pred(x)` for each element of the Functor, //! and returning whether `f` should be applied on that element. //! //! @param f //! A function called as `f(x)` on the element(s) of the Functor that //! satisfy the predicate. //! //! //! Example //! ------- //! @include example/adjust_if.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto adjust_if = [](auto&& xs, auto const& pred, auto const& f) { return tag-dispatched; }; #else template <typename Xs, typename = void> struct adjust_if_impl : adjust_if_impl<Xs, when<true>> { }; struct adjust_if_t { template <typename Xs, typename Pred, typename F> constexpr auto operator()(Xs&& xs, Pred const& pred, F const& f) const; }; constexpr adjust_if_t adjust_if{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_ADJUST_IF_HPP PK �|!\�Ⓥ� � zip_shortest.hppnu �[��� /*! @file Forward declares `boost::hana::zip_shortest`. @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_ZIP_SHORTEST_HPP #define BOOST_HANA_FWD_ZIP_SHORTEST_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Zip one sequence or more. //! @ingroup group-Sequence //! //! Given `n` sequences `s1, ..., sn`, `zip_shortest` produces a sequence //! whose `i`-th element is a tuple of `(s1[i], ..., sn[i])`, where `sk[i]` //! denotes the `i`-th element of the `k`-th sequence. In other words, //! `zip_shortest` produces a sequence of the form //! @code //! [ //! make_tuple(s1[0], ..., sn[0]), //! make_tuple(s1[1], ..., sn[1]), //! ... //! make_tuple(s1[M], ..., sn[M]) //! ] //! @endcode //! where `M` is the length of the shortest sequence. Hence, the returned //! sequence stops when the shortest input sequence is exhausted. If you //! know that all the sequences you are about to zip have the same length, //! you should use `zip` instead, since it can be more optimized. Also //! note that it is an error to provide no sequence at all, i.e. //! `zip_shortest` expects at least one sequence. //! //! //! Example //! ------- //! @include example/zip_shortest.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto zip_shortest = [](auto&& x1, ..., auto&& xn) { return tag-dispatched; }; #else template <typename S, typename = void> struct zip_shortest_impl : zip_shortest_impl<S, when<true>> { }; struct zip_shortest_t { template <typename Xs, typename ...Ys> constexpr auto operator()(Xs&& xs, Ys&& ...ys) const; }; constexpr zip_shortest_t zip_shortest{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_ZIP_SHORTEST_HPP PK �|!\ �SW equal.hppnu �[��� /*! @file Forward declares `boost::hana::equal`. @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_EQUAL_HPP #define BOOST_HANA_FWD_EQUAL_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/detail/nested_to_fwd.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns a `Logical` representing whether `x` is equal to `y`. //! @ingroup group-Comparable //! //! The `equal` function can be called in two different ways. First, it //! can be called like a normal function: //! @code //! equal(x, y) //! @endcode //! //! However, it may also be partially applied to an argument by using //! `equal.to`: //! @code //! equal.to(x)(y) == equal(x, y) //! @endcode //! //! In other words, `equal.to(x)` is a function object that is equivalent //! to `partial(equal, x)`. This is provided to enhance the readability of //! some constructs, especially when using higher order algorithms. //! //! //! Signature //! --------- //! Given a Logical `Bool` and two Comparables `A` and `B` that //! share a common embedding, the signature is //! @f$ \mathtt{equal} : A \times B \to Bool @f$. //! //! @param x, y //! Two objects to compare for equality. //! //! //! Example //! ------- //! @include example/equal.cpp //! //! //! > #### Rationale for the arity of `equal` //! > It is a valid question whether `equal` should accept more than 2 //! > arguments and have semantics matching those of Python's `==`. This //! > is not supported right now for the following reasons: //! > - It was implemented in the MPL11, but it was not shown to be useful //! > so far. //! > - It does not make sense for `not_equal` to have an arity of more //! > than 2, only `equal` could maybe have those semantics, which would //! > break symmetry. #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto equal = [](auto&& x, auto&& y) { return tag-dispatched; }; #else template <typename T, typename U, typename = void> struct equal_impl : equal_impl<T, U, when<true>> { }; struct equal_t : detail::nested_to<equal_t> { template <typename X, typename Y> constexpr auto operator()(X&& x, Y&& y) const; }; constexpr equal_t equal{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_EQUAL_HPP PK �|!\�V�J� � not.hppnu �[��� /*! @file Forward declares `boost::hana::not_`. @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_NOT_HPP #define BOOST_HANA_FWD_NOT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Negates a `Logical`. //! @ingroup group-Logical //! //! This method returns a `Logical` with the same tag, but whose //! truth-value is negated. Specifically, `not_(x)` returns a false-valued //! `Logical` if `x` is a true-valued `Logical`, and a true-valued one //! otherwise. //! //! //! Example //! ------- //! @include example/not.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto not_ = [](auto&& x) -> decltype(auto) { return tag-dispatched; }; #else template <typename L, typename = void> struct not_impl : not_impl<L, when<true>> { }; struct not_t { template <typename X> constexpr decltype(auto) operator()(X&& x) const; }; constexpr not_t not_{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_NOT_HPP PK �|!\�_6� � none_of.hppnu �[��� /*! @file Forward declares `boost::hana::none_of`. @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_NONE_OF_HPP #define BOOST_HANA_FWD_NONE_OF_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns whether none of the keys of the structure satisfy the //! `predicate`. //! @ingroup group-Searchable //! //! If the structure is not finite, `predicate` has to return a true- //! valued `Logical` after looking at a finite number of keys for this //! method to finish. //! //! //! @param xs //! The structure to search. //! //! @param predicate //! A function called as `predicate(k)`, where `k` is a key of the //! structure, and returning a `Logical`. //! //! //! Example //! ------- //! @include example/none_of.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto none_of = [](auto&& xs, auto&& predicate) { return tag-dispatched; }; #else template <typename S, typename = void> struct none_of_impl : none_of_impl<S, when<true>> { }; struct none_of_t { template <typename Xs, typename Pred> constexpr auto operator()(Xs&& xs, Pred&& pred) const; }; constexpr none_of_t none_of{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_NONE_OF_HPP PK �|!\;��L L product.hppnu �[��� /*! @file Forward declares `boost::hana::product`. @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_PRODUCT_HPP #define BOOST_HANA_FWD_PRODUCT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/fwd/integral_constant.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Compute the product of the numbers of a structure. //! @ingroup group-Foldable //! //! More generally, `product` will take any foldable structure containing //! objects forming a Ring and reduce them using the Ring's binary //! operation. The initial state for folding is the identity of the //! Ring's operation. It is sometimes necessary to specify the Ring to //! use; this is possible by using `product<R>`. If no Ring is specified, //! the structure will use the Ring formed by the elements it contains //! (if it knows it), or `integral_constant_tag<int>` otherwise. //! Hence, //! @code //! product<R>(xs) = fold_left(xs, one<R or inferred Ring>(), mult) //! product<> = product<integral_constant_tag<int>> //! @endcode //! //! For numbers, this will just compute the product of the numbers in the //! `xs` structure. //! //! @note //! The elements of the structure are not actually required to be in the //! same Ring, but it must be possible to perform `mult` on any two //! adjacent elements of the structure, which requires each pair of //! adjacent element to at least have a common Ring embedding. The //! meaning of "adjacent" as used here is that two elements of the //! structure `x` and `y` are adjacent if and only if they are adjacent //! in the linearization of that structure, as documented by the Iterable //! concept. //! //! @note //! See the documentation for `sum` to understand why the Ring must //! sometimes be specified explicitly. //! //! //! Example //! ------- //! @include example/product.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto product = see documentation; #else template <typename T, typename = void> struct product_impl : product_impl<T, when<true>> { }; template <typename R> struct product_t { template <typename Xs> constexpr decltype(auto) operator()(Xs&& xs) const; }; template <typename R = integral_constant_tag<int>> constexpr product_t<R> product{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_PRODUCT_HPP PK �|!\S(��� � intersperse.hppnu �[��� /*! @file Forward declares `boost::hana::intersperse`. @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_INTERSPERSE_HPP #define BOOST_HANA_FWD_INTERSPERSE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Insert a value between each pair of elements in a finite sequence. //! @ingroup group-Sequence //! //! Given a finite `Sequence` `xs` with a linearization of //! `[x1, x2, ..., xn]`, `intersperse(xs, z)` is a new sequence with a //! linearization of `[x1, z, x2, z, x3, ..., xn-1, z, xn]`. In other //! words, it inserts the `z` element between every pair of elements of //! the original sequence. If the sequence is empty or has a single //! element, `intersperse` returns the sequence as-is. In all cases, //! the sequence must be finite. //! //! //! @param xs //! The sequence in which a value is interspersed. //! //! @param z //! The value to be inserted between every pair of elements of the sequence. //! //! //! Example //! ------- //! @include example/intersperse.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto intersperse = [](auto&& xs, auto&& z) { return tag-dispatched; }; #else template <typename S, typename = void> struct intersperse_impl : intersperse_impl<S, when<true>> { }; struct intersperse_t { template <typename Xs, typename Z> constexpr auto operator()(Xs&& xs, Z&& z) const; }; constexpr intersperse_t intersperse{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_INTERSPERSE_HPP PK �|!\2�� unique.hppnu �[��� /*! @file Forward declares `boost::hana::unique`. @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_UNIQUE_HPP #define BOOST_HANA_FWD_UNIQUE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/detail/nested_by_fwd.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Removes all consecutive duplicate elements from a Sequence. //! @ingroup group-Sequence //! //! Given a `Sequence` and an optional binary predicate, `unique` returns //! a new sequence containing only the first element of every subrange //! of the original sequence whose elements are all equal. In other words, //! it turns a sequence of the form `[a, a, b, c, c, c, d, d, d, a]` into //! a sequence `[a, b, c, d, a]`. The equality of two elements is //! determined by the provided `predicate`, or by `equal` if no //! `predicate` is provided. //! //! //! Signature //! --------- //! Given a `Sequence` `S(T)`, a `Logical` `Bool` and a binary predicate //! \f$ T \times T \to Bool \f$, `unique` has the following signature: //! \f[ //! \mathtt{unique} : S(T) \times (T \times T \to Bool) \to S(T) //! \f] //! //! @param xs //! The sequence from which to remove consecutive duplicates. //! //! @param predicate //! A function called as `predicate(x, y)`, where `x` and `y` are adjacent //! elements of the sequence, and returning a `Logical` representing //! whether `x` and `y` should be considered equal. `predicate` should //! define an [equivalence relation][1] over the elements of the sequence. //! In the current implementation of the library, `predicate` has to //! return a compile-time `Logical`. This parameter is optional; it //! defaults to `equal` if it is not provided, which then requires the //! elements of the sequence to be compile-time `Comparable`. //! //! //! Syntactic sugar (`unique.by`) //! ----------------------------- //! `unique` can be called in an alternate way, which provides a nice //! syntax, especially in conjunction with the `comparing` combinator: //! @code //! unique.by(predicate, xs) == unique(xs, predicate) //! unique.by(predicate) == unique(-, predicate) //! @endcode //! //! where `unique(-, predicate)` denotes the partial application of //! `unique` to `predicate`. //! //! //! Example //! ------- //! @include example/unique.cpp //! //! [1]: http://en.wikipedia.org/wiki/Equivalence_relation#Definition #if defined(BOOST_HANA_DOXYGEN_INVOKED) constexpr auto unique = [](auto&& xs[, auto&& predicate]) { return tag-dispatched; }; #else template <typename S, typename = void> struct unique_impl : unique_impl<S, when<true>> { }; struct unique_t : detail::nested_by<unique_t> { template <typename Xs> constexpr auto operator()(Xs&& xs) const; template <typename Xs, typename Predicate> constexpr auto operator()(Xs&& xs, Predicate&& predicate) const; }; constexpr unique_t unique{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_UNIQUE_HPP PK �|!\ ( : : keys.hppnu �[��� /*! @file Forward declares `boost::hana::keys`. @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_KEYS_HPP #define BOOST_HANA_FWD_KEYS_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN // Note: This function is documented per datatype/concept only. //! @cond template <typename T, typename = void> struct keys_impl : keys_impl<T, when<true>> { }; //! @endcond struct keys_t { template <typename Map> constexpr auto operator()(Map&& map) const; }; constexpr keys_t keys{}; //! Returns a `Sequence` containing the name of the members of //! the data structure. //! @ingroup group-Struct //! //! Given a `Struct` object, `keys` returns a `Sequence` containing the //! name of all the members of the `Struct`, in the same order as they //! appear in the `accessors` sequence. //! //! //! Example //! ------- //! @include example/struct/keys.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto keys = [](auto&& object) { return implementation_defined; }; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_KEYS_HPP PK �|!\a��& & duplicate.hppnu �[��� /*! @file Forward declares `boost::hana::duplicate`. @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_DUPLICATE_HPP #define BOOST_HANA_FWD_DUPLICATE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Add an extra layer of comonadic context to a comonadic value. //! @ingroup group-Comonad //! //! Given a value already in a comonadic context, `duplicate` wraps this //! value with an additional layer of comonadic context. This can be seen //! as the dual operation to `flatten` from the Monad concept. //! //! //! Signature //! --------- //! Given a Comonad `W`, the signature is //! \f$ //! \mathtt{duplicate} : W(T) \to W(W(T)) //! \f$ //! //! @param w //! The value to wrap in an additional level of comonadic context. //! //! //! Example //! ------- //! @include example/duplicate.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto duplicate = [](auto&& w) -> decltype(auto) { return tag-dispatched; }; #else template <typename W, typename = void> struct duplicate_impl : duplicate_impl<W, when<true>> { }; struct duplicate_t { template <typename W_> constexpr decltype(auto) operator()(W_&& w) const; }; constexpr duplicate_t duplicate{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_DUPLICATE_HPP PK �|!\& �� � sort.hppnu �[��� /*! @file Forward declares `boost::hana::sort`. @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_SORT_HPP #define BOOST_HANA_FWD_SORT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/detail/nested_by_fwd.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Sort a sequence, optionally based on a custom `predicate`. //! @ingroup group-Sequence //! //! Given a Sequence and an optional predicate (by default `less`), `sort` //! returns a new sequence containing the same elements as the original, //! except they are ordered in such a way that if `x` comes before `y` in //! the sequence, then either `predicate(x, y)` is true, or both //! `predicate(x, y)` and `predicate(y, x)` are false. //! //! Also note that the sort is guaranteed to be stable. Hence, if `x` //! comes before `y` in the original sequence and both `predicate(x, y)` //! and `predicate(y, x)` are false, then `x` will come before `y` in the //! resulting sequence. //! //! If no predicate is provided, the elements in the sequence must all be //! compile-time `Orderable`. //! //! Signature //! --------- //! Given a `Sequence` `S(T)`, a boolean `IntegralConstant` `Bool` and a //! binary predicate \f$ T \times T \to Bool \f$, `sort` has the following //! signatures. For the variant with a provided predicate, //! \f[ //! \mathtt{sort} : S(T) \times (T \times T \to Bool) \to S(T) //! \f] //! //! for the variant without a custom predicate, `T` is required to be //! `Orderable`. The signature is then //! \f[ //! \mathtt{sort} : S(T) \to S(T) //! \f] //! //! @param xs //! The sequence to sort. //! //! @param predicate //! A function called as `predicate(x, y)` for two elements `x` and `y` of //! the sequence, and returning a boolean `IntegralConstant` representing //! whether `x` is to be considered _less_ than `y`, i.e. whether `x` should //! appear _before_ `y` in the resulting sequence. More specifically, //! `predicate` must define a [strict weak ordering][1] on the elements //! of the sequence. When the predicate is not specified, this defaults //! to `less`. In the current version of the library, the predicate has //! to return an `IntegralConstant` holding a value convertible to a `bool`. //! //! //! Syntactic sugar (`sort.by`) //! --------------------------- //! `sort` can be called in a third way, which provides a nice syntax //! especially when working with the `ordering` combinator: //! @code //! sort.by(predicate, xs) == sort(xs, predicate) //! sort.by(predicate) == sort(-, predicate) //! @endcode //! //! where `sort(-, predicate)` denotes the partial application of //! `sort` to `predicate`. //! //! //! Example //! ------- //! @include example/sort.cpp //! //! [1]: http://en.wikipedia.org/wiki/Strict_weak_ordering #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto sort = [](auto&& xs[, auto&& predicate]) { return tag-dispatched; }; #else template <typename S, typename = void> struct sort_impl : sort_impl<S, when<true>> { }; struct sort_t : detail::nested_by<sort_t> { template <typename Xs> constexpr auto operator()(Xs&& xs) const; template <typename Xs, typename Predicate> constexpr auto operator()(Xs&& xs, Predicate&& pred) const; }; constexpr sort_t sort{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_SORT_HPP PK �|!\42��� � take_back.hppnu �[��� /*! @file Forward declares `boost::hana::take_back`. @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_TAKE_BACK_HPP #define BOOST_HANA_FWD_TAKE_BACK_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <cstddef> BOOST_HANA_NAMESPACE_BEGIN //! Returns the last `n` elements of a sequence, or the whole sequence //! if the sequence has less than `n` elements. //! @ingroup group-Sequence //! //! Given a `Sequence` `xs` and an `IntegralConstant` `n`, `take_back(xs, n)` //! is a new sequence containing the last `n` elements of `xs`, in the //! same order. If `length(xs) <= n`, the whole sequence is returned and //! no error is triggered. //! //! //! @param xs //! The sequence to take the elements from. //! //! @param n //! A non-negative `IntegralConstant` representing the number of elements //! to keep in the resulting sequence. //! //! //! Example //! ------- //! @include example/take_back.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto take_back = [](auto&& xs, auto const& n) { return tag-dispatched; }; #else template <typename S, typename = void> struct take_back_impl : take_back_impl<S, when<true>> { }; struct take_back_t { template <typename Xs, typename N> constexpr auto operator()(Xs&& xs, N const& n) const; }; constexpr take_back_t take_back{}; #endif //! Equivalent to `take_back`; provided for convenience. //! @ingroup group-Sequence //! //! //! Example //! ------- //! @include example/take_back_c.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <std::size_t n> constexpr auto take_back_c = [](auto&& xs) { return hana::take_back(forwarded(xs), hana::size_c<n>); }; #else template <std::size_t n> struct take_back_c_t; template <std::size_t n> constexpr take_back_c_t<n> take_back_c{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_TAKE_BACK_HPP PK �|!\����F F reverse_fold.hppnu �[��� /*! @file Forward declares `boost::hana::reverse_fold`. @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_REVERSE_FOLD_HPP #define BOOST_HANA_FWD_REVERSE_FOLD_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Equivalent to `reverse_fold` in Boost.Fusion and Boost.MPL. //! @ingroup group-Foldable //! //! This method has the same semantics as `reverse_fold` in Boost.Fusion //! and Boost.MPL, with the extension that an initial state is not //! required. This method is equivalent to `fold_right`, except that //! the accumulating function must take its arguments in reverse order, //! to match the order used in Fusion. In other words, //! @code //! reverse_fold(sequence, state, f) == fold_right(sequence, state, flip(f)) //! reverse_fold(sequence, f) == fold_right(sequence, flip(f)) //! @endcode //! //! @note //! This method is a convenience alias to `fold_right`. As an alias, //! `reverse_fold` is not tag-dispatched on its own and `fold_right` //! should be customized instead. //! //! //! Signature //! --------- //! Given a `Foldable` `F` and an optional initial state of tag `S`, //! the signatures for `reverse_fold` are //! \f[ //! \mathtt{reverse\_fold} : F(T) \times S \times (S \times T \to S) \to S //! \f] //! //! for the variant with an initial state, and //! \f[ //! \mathtt{reverse\_fold} : F(T) \times (T \times T \to T) \to T //! \f] //! //! for the variant without an initial state. //! //! @param xs //! The structure to fold. //! //! @param state //! The initial value used for folding. //! //! @param f //! A binary function called as `f(state, x)`, where `state` is the //! result accumulated so far and `x` is an element in the structure. //! For reverse folds without an initial state, the function is called as //! `f(x1, x2)`, where `x1` and `x2` are elements of the structure. //! //! //! Example //! ------- //! @include example/reverse_fold.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto reverse_fold = [](auto&& xs[, auto&& state], auto&& f) -> decltype(auto) { return fold_right(forwarded(xs), forwarded(state), flip(forwarded(f))); }; #else struct reverse_fold_t { template <typename Xs, typename S, typename F> constexpr decltype(auto) operator()(Xs&& xs, S&& s, F&& f) const; template <typename Xs, typename F> constexpr decltype(auto) operator()(Xs&& xs, F&& f) const; }; constexpr reverse_fold_t reverse_fold{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_REVERSE_FOLD_HPP PK �|!\Q��r r less.hppnu �[��� /*! @file Forward declares `boost::hana::less`. @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_LESS_HPP #define BOOST_HANA_FWD_LESS_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/detail/nested_than_fwd.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns a `Logical` representing whether `x` is less than `y`. //! @ingroup group-Orderable //! //! //! Signature //! --------- //! Given a Logical `Bool` and two Orderables `A` and `B` with a common //! embedding, the signature is //! @f$ \mathrm{less} : A \times B \to Bool @f$. //! //! @param x, y //! Two objects to compare. //! //! //! Example //! ------- //! @include example/less.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto less = [](auto&& x, auto&& y) { return tag-dispatched; }; #else template <typename T, typename U, typename = void> struct less_impl : less_impl<T, U, when<true>> { }; struct less_t : detail::nested_than<less_t> { template <typename X, typename Y> constexpr auto operator()(X&& x, Y&& y) const; }; constexpr less_t less{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_LESS_HPP PK �|!\�� � tap.hppnu �[��� /*! @file Forward declares `boost::hana::tap`. @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_TAP_HPP #define BOOST_HANA_FWD_TAP_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Tap inside a monadic chain. //! @ingroup group-Monad //! //! Given a function `f`, `tap<M>` returns a new function which performs //! `f` on its argument and then returns the argument lifted in the `M` //! `Monad`. Combined with the property that `chain(m, lift<M>) == m`, //! this provides a way of executing an action inside a monadic chain //! without influencing its overall result. This is useful to e.g. insert //! debug statements or perform actions that are not tied to the chain but //! that need to be executed inside of it. //! //! @note //! Since C++ is not a pure language, it is possible to perform side //! effects inside the `f` function. Actually, side effects are the //! only reason why one might want to use `tap`. However, one should //! not rely on the side effects being done in any specific order. //! //! //! @tparam M //! The tag (a `Monad`) of the monads in the tapped monadic chain. //! //! @param f //! A function to be executed inside a monadic chain. It will be called //! as `f(x)`, where `x` is a value inside the previous monad in the //! chain. The result of `f` is always discarded. //! //! //! Example //! ------- //! @include example/tap.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename M> constexpr auto tap = [](auto&& f) { return tag-dispatched; }; #else template <typename M, typename = void> struct tap_impl : tap_impl<M, when<true>> { }; template <typename M> struct tap_t { template <typename F> constexpr auto operator()(F&& f) const; }; template <typename M> constexpr tap_t<M> tap{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_TAP_HPP PK �|!\d��-� � remove_range.hppnu �[��� /*! @file Forward declares `boost::hana::remove_range` and `boost::hana::remove_range_c`. @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_REMOVE_RANGE_HPP #define BOOST_HANA_FWD_REMOVE_RANGE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <cstddef> BOOST_HANA_NAMESPACE_BEGIN //! Remove the elements inside a given range of indices from a sequence. //! @ingroup group-Sequence //! //! `remove_range` returns a new sequence identical to the original, //! except that elements at indices in the provided range are removed. //! Specifically, `remove_range([x0, ..., xn], from, to)` is a new //! sequence equivalent to `[x0, ..., x_from-1, x_to, ..., xn]`. //! //! //! @note //! The behavior is undefined if the range contains any index out of the //! bounds of the sequence. //! //! //! @param xs //! A sequence from which elements are removed. //! //! @param [from, to) //! An half-open interval of `IntegralConstant`s representing the indices //! of the elements to be removed from the sequence. The `IntegralConstant`s //! in the half-open interval must be non-negative and in the bounds of //! the sequence. The half-open interval must also be valid, meaning that //! `from <= to`. //! //! //! Example //! ------- //! @include example/remove_range.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto remove_range = [](auto&& xs, auto const& from, auto const& to) { return tag-dispatched; }; #else template <typename S, typename = void> struct remove_range_impl : remove_range_impl<S, when<true>> { }; struct remove_range_t { template <typename Xs, typename From, typename To> constexpr auto operator()(Xs&& xs, From const& from, To const& to) const; }; constexpr remove_range_t remove_range{}; #endif //! Equivalent to `remove_range`; provided for convenience. //! @ingroup group-Sequence //! //! //! Example //! ------- //! @include example/remove_range_c.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <std::size_t from, std::size_t to> constexpr auto remove_range_c = [](auto&& xs) { return hana::remove_range(forwarded(xs), hana::size_c<from>, hana::size_c<to>); }; #else template <std::size_t from, std::size_t to> struct remove_range_c_t; template <std::size_t from, std::size_t to> constexpr remove_range_c_t<from, to> remove_range_c{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_REMOVE_RANGE_HPP PK �|!\k�oJ J contains.hppnu �[��� /*! @file Forward declares `boost::hana::contains` and `boost::hana::in`. @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_CONTAINS_HPP #define BOOST_HANA_FWD_CONTAINS_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/functional/flip.hpp> #include <boost/hana/functional/infix.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns whether the key occurs in the structure. //! @ingroup group-Searchable //! //! Given a `Searchable` structure `xs` and a `key`, `contains` returns //! whether any of the keys of the structure is equal to the given `key`. //! If the structure is not finite, an equal key has to appear at a finite //! position in the structure for this method to finish. For convenience, //! `contains` can also be applied in infix notation. //! //! //! @param xs //! The structure to search. //! //! @param key //! A key to be searched for in the structure. The key has to be //! `Comparable` with the other keys of the structure. //! //! //! Example //! ------- //! @include example/contains.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto contains = [](auto&& xs, auto&& key) { return tag-dispatched; }; #else template <typename S, typename = void> struct contains_impl : contains_impl<S, when<true>> { }; struct contains_t { template <typename Xs, typename Key> constexpr auto operator()(Xs&& xs, Key&& key) const; }; constexpr auto contains = hana::infix(contains_t{}); #endif //! Return whether the key occurs in the structure. //! @ingroup group-Searchable //! //! Specifically, this is equivalent to `contains`, except `in` takes its //! arguments in reverse order. Like `contains`, `in` can also be applied //! in infix notation for increased expressiveness. This function is not a //! method that can be overriden; it is just a convenience function //! provided with the concept. //! //! //! Example //! ------- //! @include example/in.cpp constexpr auto in = hana::infix(hana::flip(hana::contains)); BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONTAINS_HPP PK �|!\QP?� � concept/group.hppnu �[��� /*! @file Forward declares `boost::hana::Group`. @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_CONCEPT_GROUP_HPP #define BOOST_HANA_FWD_CONCEPT_GROUP_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-Group Group //! The `Group` concept represents `Monoid`s where all objects have //! an inverse w.r.t. the `Monoid`'s binary operation. //! //! A [Group][1] is an algebraic structure built on top of a `Monoid` //! which adds the ability to invert the action of the `Monoid`'s binary //! operation on any element of the set. Specifically, a `Group` is a //! `Monoid` `(S, +)` such that every element `s` in `S` has an inverse //! (say `s'`) which is such that //! @code //! s + s' == s' + s == identity of the Monoid //! @endcode //! //! There are many examples of `Group`s, one of which would be the //! additive `Monoid` on integers, where the inverse of any integer //! `n` is the integer `-n`. The method names used here refer to //! exactly this model. //! //! //! Minimal complete definitions //! ---------------------------- //! 1. `minus`\n //! When `minus` is specified, the `negate` method is defaulted by setting //! @code //! negate(x) = minus(zero<G>(), x) //! @endcode //! //! 2. `negate`\n //! When `negate` is specified, the `minus` method is defaulted by setting //! @code //! minus(x, y) = plus(x, negate(y)) //! @endcode //! //! //! Laws //! ---- //! For all objects `x` of a `Group` `G`, the following laws must be //! satisfied: //! @code //! plus(x, negate(x)) == zero<G>() // right inverse //! plus(negate(x), x) == zero<G>() // left inverse //! @endcode //! //! //! Refined concept //! --------------- //! `Monoid` //! //! //! Concrete models //! --------------- //! `hana::integral_constant` //! //! //! Free model for non-boolean arithmetic data types //! ------------------------------------------------ //! A data type `T` is arithmetic if `std::is_arithmetic<T>::%value` is //! true. For a non-boolean arithmetic data type `T`, a model of `Group` //! is automatically defined by setting //! @code //! minus(x, y) = (x - y) //! negate(x) = -x //! @endcode //! //! @note //! The rationale for not providing a Group model for `bool` is the same //! as for not providing a `Monoid` model. //! //! //! Structure-preserving functions //! ------------------------------ //! Let `A` and `B` be two `Group`s. A function `f : A -> B` is said to //! be a [Group morphism][2] if it preserves the group structure between //! `A` and `B`. Rigorously, for all objects `x, y` of data type `A`, //! @code //! f(plus(x, y)) == plus(f(x), f(y)) //! @endcode //! Because of the `Group` structure, it is easy to prove that the //! following will then also be satisfied: //! @code //! f(negate(x)) == negate(f(x)) //! f(zero<A>()) == zero<B>() //! @endcode //! Functions with these properties interact nicely with `Group`s, which //! is why they are given such a special treatment. //! //! //! [1]: http://en.wikipedia.org/wiki/Group_(mathematics) //! [2]: http://en.wikipedia.org/wiki/Group_homomorphism template <typename G> struct Group; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_GROUP_HPP PK �|!\�J�J J concept/integral_constant.hppnu �[��� /*! @file Forward declares `boost::hana::IntegralConstant`. @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_CONCEPT_INTEGRAL_CONSTANT_HPP #define BOOST_HANA_FWD_CONCEPT_INTEGRAL_CONSTANT_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! The `IntegralConstant` concept represents compile-time integral values. //! //! The `IntegralConstant` concept represents objects that hold a //! `constexpr` value of an integral type. In other words, it describes //! the essential functionality provided by `std::integral_constant`. //! An `IntegralConstant` is also just a special kind of `Constant` //! whose inner value is of an integral type. //! //! //! Minimal complete definition //! --------------------------- //! The requirements for being an `IntegralConstant` are quite simple. //! First, an `IntegralConstant` `C` must be a `Constant` such that //! `Tag::value_type` is an integral type, where `Tag` is the tag of `C`. //! //! Secondly, `C` must have a nested `static constexpr` member named //! `value`, such that the following code is valid: //! @code //! constexpr auto v = C::value; //! @endcode //! Because of the requirement that `Tag::value_type` be an integral type, //! it follows that `C::value` must be an integral value. //! //! Finally, it is necessary to specialize the `IntegralConstant` template //! in the `boost::hana` namespace to tell Hana that a type is a model //! of `IntegralConstant`: //! @code //! namespace boost { namespace hana { //! template <> //! struct IntegralConstant<your_custom_tag> { //! static constexpr bool value = true; //! }; //! }} //! @endcode //! //! //! Refined concept //! --------------- //! 1. `Constant` (free implementation of `value`)\n //! The `value` function required to be a `Constant` can be implemented //! as follows for `IntegralConstant`s: //! @code //! value<C>() == C::value //! @endcode //! The `to` function must still be provided explicitly for the model //! of `Constant` to be complete. //! //! //! Concrete models //! --------------- //! `hana::integral_constant` template <typename C> struct IntegralConstant; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_INTEGRAL_CONSTANT_HPP PK �|!\л�K� � concept/foldable.hppnu �[��� /*! @file Forward declares `boost::hana::Foldable`. @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_CONCEPT_FOLDABLE_HPP #define BOOST_HANA_FWD_CONCEPT_FOLDABLE_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-Foldable Foldable //! The `Foldable` concept represents data structures that can be reduced //! to a single value. //! //! Generally speaking, folding refers to the concept of summarizing a //! complex structure as a single value, by successively applying a //! binary operation which reduces two elements of the structure to a //! single value. Folds come in many flavors; left folds, right folds, //! folds with and without an initial reduction state, and their monadic //! variants. This concept is able to express all of these fold variants. //! //! Another way of seeing `Foldable` is as data structures supporting //! internal iteration with the ability to accumulate a result. By //! internal iteration, we mean that the _loop control_ is in the hand //! of the structure, not the caller. Hence, it is the structure who //! decides when the iteration stops, which is normally when the whole //! structure has been consumed. Since C++ is an eager language, this //! requires `Foldable` structures to be finite, or otherwise one would //! need to loop indefinitely to consume the whole structure. //! //! @note //! While the fact that `Foldable` only works for finite structures may //! seem overly restrictive in comparison to the Haskell definition of //! `Foldable`, a finer grained separation of the concepts should //! mitigate the issue. For iterating over possibly infinite data //! structures, see the `Iterable` concept. For searching a possibly //! infinite data structure, see the `Searchable` concept. //! //! //! Minimal complete definition //! --------------------------- //! `fold_left` or `unpack` //! //! However, please note that a minimal complete definition provided //! through `unpack` will be much more compile-time efficient than one //! provided through `fold_left`. //! //! //! Concrete models //! --------------- //! `hana::map`, `hana::optional`, `hana::pair`, `hana::set`, //! `hana::range`, `hana::tuple` //! //! //! @anchor Foldable-lin //! The linearization of a `Foldable` //! --------------------------------- //! Intuitively, for a `Foldable` structure `xs`, the _linearization_ of //! `xs` is the sequence of all the elements in `xs` as if they had been //! put in a list: //! @code //! linearization(xs) = [x1, x2, ..., xn] //! @endcode //! //! Note that it is always possible to produce such a linearization //! for a finite `Foldable` by setting //! @code //! linearization(xs) = fold_left(xs, [], flip(prepend)) //! @endcode //! for an appropriate definition of `[]` and `prepend`. The notion of //! linearization is useful for expressing various properties of //! `Foldable` structures, and is used across the documentation. Also //! note that `Iterable`s define an [extended version](@ref Iterable-lin) //! of this allowing for infinite structures. //! //! //! Compile-time Foldables //! ---------------------- //! A compile-time `Foldable` is a `Foldable` whose total length is known //! at compile-time. In other words, it is a `Foldable` whose `length` //! method returns a `Constant` of an unsigned integral type. When //! folding a compile-time `Foldable`, the folding can be unrolled, //! because the final number of steps of the algorithm is known at //! compile-time. //! //! Additionally, the `unpack` method is only available to compile-time //! `Foldable`s. This is because the return _type_ of `unpack` depends //! on the number of objects in the structure. Being able to resolve //! `unpack`'s return type at compile-time hence requires the length of //! the structure to be known at compile-time too. //! //! __In the current version of the library, only compile-time `Foldable`s //! are supported.__ While it would be possible in theory to support //! runtime `Foldable`s too, doing so efficiently requires more research. //! //! //! Provided conversion to `Sequence`s //! ---------------------------------- //! Given a tag `S` which is a `Sequence`, an object whose tag is a model //! of the `Foldable` concept can be converted to an object of tag `S`. //! In other words, a `Foldable` can be converted to a `Sequence` `S`, by //! simply taking the linearization of the `Foldable` and creating the //! sequence with that. More specifically, given a `Foldable` `xs` with a //! linearization of `[x1, ..., xn]` and a `Sequence` tag `S`, `to<S>(xs)` //! is equivalent to `make<S>(x1, ..., xn)`. //! @include example/foldable/to.cpp //! //! //! Free model for builtin arrays //! ----------------------------- //! Builtin arrays whose size is known can be folded as-if they were //! homogeneous tuples. However, note that builtin arrays can't be //! made more than `Foldable` (e.g. `Iterable`) because they can't //! be empty and they also can't be returned from functions. //! //! //! @anchor monadic-folds //! Primer on monadic folds //! ----------------------- //! A monadic fold is a fold in which subsequent calls to the binary //! function are chained with the monadic `chain` operator of the //! corresponding Monad. This allows a structure to be folded in a //! custom monadic context. For example, performing a monadic fold with //! the `hana::optional` monad would require the binary function to return //! the result as a `hana::optional`, and the fold would abort and return //! `nothing` whenever one of the accumulation step would fail (i.e. //! return `nothing`). If, however, all the reduction steps succeed, //! then `just` the result would be returned. Different monads will of //! course result in different effects. template <typename T> struct Foldable; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_FOLDABLE_HPP PK �|!\�q� concept/logical.hppnu �[��� /*! @file Forward declares `boost::hana::Logical`. @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_CONCEPT_LOGICAL_HPP #define BOOST_HANA_FWD_CONCEPT_LOGICAL_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-Logical Logical //! The `Logical` concept represents types with a truth value. //! //! Intuitively, a `Logical` is just a `bool`, or something that can act //! like one. However, in the context of programming with heterogeneous //! objects, it becomes extremely important to distinguish between those //! objects whose truth value is known at compile-time, and those whose //! truth value is only known at runtime. The reason why this is so //! important is because it is possible to branch at compile-time on //! a condition whose truth value is known at compile-time, and hence //! the return type of the enclosing function can depend on that truth //! value. However, if the truth value is only known at runtime, then //! the compiler has to compile both branches (because any or both of //! them may end up being used), which creates the additional requirement //! that both branches must evaluate to the same type. //! //! More specifically, `Logical` (almost) represents a [boolean algebra][1], //! which is a mathematical structure encoding the usual properties that //! allow us to reason with `bool`. The exact properties that must be //! satisfied by any model of `Logical` are rigorously stated in the laws //! below. //! //! //! Truth, falsity and logical equivalence //! -------------------------------------- //! A `Logical` `x` is said to be _true-valued_, or sometimes also just //! _true_ as an abuse of notation, if //! @code //! if_(x, true, false) == true //! @endcode //! //! Similarly, `x` is _false-valued_, or sometimes just _false_, if //! @code //! if_(x, true, false) == false //! @endcode //! //! This provides a standard way of converting any `Logical` to a straight //! `bool`. The notion of truth value suggests another definition, which //! is that of logical equivalence. We will say that two `Logical`s `x` //! and `y` are _logically equivalent_ if they have the same truth value. //! To denote that some expressions `p` and `q` of a Logical data type are //! logically equivalent, we will sometimes also write //! @code //! p if and only if q //! @endcode //! which is very common in mathematics. The intuition behind this notation //! is that whenever `p` is true-valued, then `q` should be; but when `p` //! is false-valued, then `q` should be too. Hence, `p` should be //! true-valued when (and only when) `q` is true-valued. //! //! //! Minimal complete definition //! --------------------------- //! `eval_if`, `not_` and `while_` //! //! All the other functions can be defined in those terms: //! @code //! if_(cond, x, y) = eval_if(cond, lazy(x), lazy(y)) //! and_(x, y) = if_(x, y, x) //! or_(x, y) = if_(x, x, y) //! etc... //! @endcode //! //! //! Laws //! ---- //! As outlined above, the `Logical` concept almost represents a boolean //! algebra. The rationale for this laxity is to allow things like integers //! to act like `Logical`s, which is aligned with C++, even though they do //! not form a boolean algebra. Even though we depart from the usual //! axiomatization of boolean algebras, we have found through experience //! that the definition of a Logical given here is largely compatible with //! intuition. //! //! The following laws must be satisfied for any data type `L` modeling //! the `Logical` concept. Let `a`, `b` and `c` be objects of a `Logical` //! data type, and let `t` and `f` be arbitrary _true-valued_ and //! _false-valued_ `Logical`s of that data type, respectively. Then, //! @code //! // associativity //! or_(a, or_(b, c)) == or_(or_(a, b), c) //! and_(a, and_(b, c)) == and_(and_(a, b), c) //! //! // equivalence through commutativity //! or_(a, b) if and only if or_(b, a) //! and_(a, b) if and only if and_(b, a) //! //! // absorption //! or_(a, and_(a, b)) == a //! and_(a, or_(a, b)) == a //! //! // left identity //! or_(a, f) == a //! and_(a, t) == a //! //! // distributivity //! or_(a, and_(b, c)) == and_(or_(a, b), or_(a, c)) //! and_(a, or_(b, c)) == or_(and_(a, b), and_(a, c)) //! //! // complements //! or_(a, not_(a)) is true-valued //! and_(a, not_(a)) is false-valued //! @endcode //! //! > #### Why is the above not a boolean algebra? //! > If you look closely, you will find that we depart from the usual //! > boolean algebras because: //! > 1. we do not require the elements representing truth and falsity to //! > be unique //! > 2. we do not enforce commutativity of the `and_` and `or_` operations //! > 3. because we do not enforce commutativity, the identity laws become //! > left-identity laws //! //! //! Concrete models //! --------------- //! `hana::integral_constant` //! //! //! Free model for arithmetic data types //! ------------------------------------ //! A data type `T` is arithmetic if `std::is_arithmetic<T>::%value` is //! true. For an arithmetic data type `T`, a model of `Logical` is //! provided automatically by using the result of the builtin implicit //! conversion to `bool` as a truth value. Specifically, the minimal //! complete definition for those data types is //! @code //! eval_if(cond, then, else_) = cond ? then(id) : else(id) //! not_(cond) = static_cast<T>(cond ? false : true) //! while_(pred, state, f) = equivalent to a normal while loop //! @endcode //! //! > #### Rationale for not providing a model for all contextually convertible to bool data types //! > The `not_` method can not be implemented in a meaningful way for all //! > of those types. For example, one can not cast a pointer type `T*` //! > to bool and then back again to `T*` in a meaningful way. With an //! > arithmetic type `T`, however, it is possible to cast from `T` to //! > bool and then to `T` again; the result will be `0` or `1` depending //! > on the truth value. If you want to use a pointer type or something //! > similar in a conditional, it is suggested to explicitly convert it //! > to bool by using `to<bool>`. //! //! //! [1]: http://en.wikipedia.org/wiki/Boolean_algebra_(structure) template <typename L> struct Logical; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_LOGICAL_HPP PK �|!\b�#l< < concept/searchable.hppnu �[��� /*! @file Forward declares `boost::hana::Searchable`. @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_CONCEPT_SEARCHABLE_HPP #define BOOST_HANA_FWD_CONCEPT_SEARCHABLE_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-Searchable Searchable //! The `Searchable` concept represents structures that can be searched. //! //! Intuitively, a `Searchable` is any structure, finite or infinite, //! containing elements that can be searched using a predicate. Sometimes, //! `Searchable`s will associate keys to values; one can search for a key //! with a predicate, and the value associated to it is returned. This //! gives rise to map-like data structures. Other times, the elements of //! the structure that are searched (i.e. those to which the predicate is //! applied) are the same that are returned, which gives rise to set-like //! data structures. In general, we will refer to the _keys_ of a //! `Searchable` structure as those elements that are used for searching, //! and to the _values_ of a `Searchable` as those elements that are //! returned when a search is successful. As was explained, there is no //! requirement that both notions differ, and it is often useful to have //! keys and values coincide (think about `std::set`). //! //! Some methods like `any_of`, `all_of` and `none_of` allow simple queries //! to be performed on the keys of the structure, while other methods like //! `find` and `find_if` make it possible to find the value associated //! to a key. The most specific method should always be used if one //! cares about performance, because it is usually the case that heavy //! optimizations can be performed in more specific methods. For example, //! an associative data structure implemented as a hash table will be much //! faster to access using `find` than `find_if`, because in the second //! case it will have to do a linear search through all the entries. //! Similarly, using `contains` will likely be much faster than `any_of` //! with an equivalent predicate. //! //! > __Insight__\n //! > In a lazy evaluation context, any `Foldable` can also become a model //! > of `Searchable` because we can search lazily through the structure //! > with `fold_right`. However, in the context of C++, some `Searchable`s //! > can not be folded; think for example of an infinite set. //! //! //! Minimal complete definition //! --------------------------- //! `find_if` and `any_of` //! //! When `find_if` and `any_of` are provided, the other functions are //! implemented according to the laws explained below. //! //! @note //! We could implement `any_of(xs, pred)` by checking whether //! `find_if(xs, pred)` is an empty `optional` or not, and then reduce //! the minimal complete definition to `find_if`. However, this is not //! done because that implementation requires the predicate of `any_of` //! to return a compile-time `Logical`, which is more restrictive than //! what we have right now. //! //! //! Laws //! ---- //! In order for the semantics of the methods to be consistent, some //! properties must be satisfied by any model of the `Searchable` concept. //! Rigorously, for any `Searchable`s `xs` and `ys` and any predicate `p`, //! the following laws should be satisfied: //! @code //! any_of(xs, p) <=> !all_of(xs, negated p) //! <=> !none_of(xs, p) //! //! contains(xs, x) <=> any_of(xs, equal.to(x)) //! //! find(xs, x) == find_if(xs, equal.to(x)) //! find_if(xs, always(false_)) == nothing //! //! is_subset(xs, ys) <=> all_of(xs, [](auto x) { return contains(ys, x); }) //! is_disjoint(xs, ys) <=> none_of(xs, [](auto x) { return contains(ys, x); }) //! @endcode //! //! Additionally, if all the keys of the `Searchable` are `Logical`s, //! the following laws should be satisfied: //! @code //! any(xs) <=> any_of(xs, id) //! all(xs) <=> all_of(xs, id) //! none(xs) <=> none_of(xs, id) //! @endcode //! //! //! Concrete models //! --------------- //! `hana::map`, `hana::optional`, `hana::range`, `hana::set`, //! `hana::string`, `hana::tuple` //! //! //! Free model for builtin arrays //! ----------------------------- //! Builtin arrays whose size is known can be searched as-if they were //! homogeneous tuples. However, since arrays can only hold objects of //! a single type and the predicate to `find_if` must return a compile-time //! `Logical`, the `find_if` method is fairly useless. For similar reasons, //! the `find` method is also fairly useless. This model is provided mainly //! because of the `any_of` method & friends, which are both useful and //! compile-time efficient. //! //! //! Structure preserving functions //! ------------------------------ //! Given two `Searchables` `S1` and `S2`, a function //! @f$ f : S_1(X) \to S_2(X) @f$ is said to preserve the `Searchable` //! structure if for all `xs` of data type `S1(X)` and predicates //! @f$ \mathtt{pred} : X \to Bool @f$ (for a `Logical` `Bool`), //! @code //! any_of(xs, pred) if and only if any_of(f(xs), pred) //! find_if(xs, pred) == find_if(f(xs), pred) //! @endcode //! //! This is really just a generalization of the following, more intuitive //! requirements. For all `xs` of data type `S1(X)` and `x` of data type //! `X`, //! @code //! x ^in^ xs if and only if x ^in^ f(xs) //! find(xs, x) == find(f(xs), x) //! @endcode //! //! These requirements can be understood as saying that `f` does not //! change the content of `xs`, although it may reorder elements. //! As usual, such a structure-preserving transformation is said to //! be an embedding if it is also injective, i.e. if it is a lossless //! transformation. template <typename S> struct Searchable; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_SEARCHABLE_HPP PK �|!\��� � concept/comonad.hppnu �[��� /*! @file Forward declares `boost::hana::Comonad`. @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_CONCEPT_COMONAD_HPP #define BOOST_HANA_FWD_CONCEPT_COMONAD_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN // Note: We use a multiline C++ comment because there's a double backslash // symbol in the documentation (for LaTeX), which triggers // warning: multi-line comment [-Wcomment] // on GCC. /*! @ingroup group-concepts @defgroup group-Comonad Comonad The `Comonad` concept represents context-sensitive computations and data. Formally, the Comonad concept is dual to the Monad concept. But unless you're a mathematician, you don't care about that and it's fine. So intuitively, a Comonad represents context sensitive values and computations. First, Comonads make it possible to extract context-sensitive values from their context with `extract`. In contrast, Monads make it possible to wrap raw values into a given context with `lift` (from Applicative). Secondly, Comonads make it possible to apply context-sensitive values to functions accepting those, and to return the result as a context-sensitive value using `extend`. In contrast, Monads make it possible to apply a monadic value to a function accepting a normal value and returning a monadic value, and to return the result as a monadic value (with `chain`). Finally, Comonads make it possible to wrap a context-sensitive value into an extra layer of context using `duplicate`, while Monads make it possible to take a value with an extra layer of context and to strip it with `flatten`. Whereas `lift`, `chain` and `flatten` from Applicative and Monad have signatures \f{align*}{ \mathtt{lift}_M &: T \to M(T) \\ \mathtt{chain} &: M(T) \times (T \to M(U)) \to M(U) \\ \mathtt{flatten} &: M(M(T)) \to M(T) \f} `extract`, `extend` and `duplicate` from Comonad have signatures \f{align*}{ \mathtt{extract} &: W(T) \to T \\ \mathtt{extend} &: W(T) \times (W(T) \to U) \to W(U) \\ \mathtt{duplicate} &: W(T) \to W(W(T)) \f} Notice how the "arrows" are reversed. This symmetry is essentially what we mean by Comonad being the _dual_ of Monad. @note The [Typeclassopedia][1] is a nice Haskell-oriented resource for further reading about Comonads. Minimal complete definition --------------------------- `extract` and (`extend` or `duplicate`) satisfying the laws below. A `Comonad` must also be a `Functor`. Laws ---- For all Comonads `w`, the following laws must be satisfied: @code extract(duplicate(w)) == w transform(duplicate(w), extract) == w duplicate(duplicate(w)) == transform(duplicate(w), duplicate) @endcode @note There are several equivalent ways of defining Comonads, and this one is just one that was picked arbitrarily for simplicity. Refined concept --------------- 1. Functor\n Every Comonad is also required to be a Functor. At first, one might think that it should instead be some imaginary concept CoFunctor. However, it turns out that a CoFunctor is the same as a `Functor`, hence the requirement that a `Comonad` also is a `Functor`. Concrete models --------------- `hana::lazy` [1]: https://wiki.haskell.org/Typeclassopedia#Comonad */ template <typename W> struct Comonad; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_COMONAD_HPP PK �|!\�{�� � concept/hashable.hppnu �[��� /*! @file Forward declares `boost::hana::Hashable`. @copyright Louis Dionne 2016 @copyright Jason Rice 2016 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_CONCEPT_HASHABLE_HPP #define BOOST_HANA_FWD_CONCEPT_HASHABLE_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-Hashable Hashable //! The `Hashable` concept represents objects that can be normalized to //! a type-level hash. //! //! In day to day programming, hashes are very important as a way to //! efficiently lookup objects in maps. While the implementation of //! maps is very different, the same idea of using hashes for efficient //! lookup applies in metaprogramming. The `Hashable` concept represents //! objects that can be summarized (possibly with loss of information) to //! a type, in a way suitable for use in hash-based data structures. Of //! course, in order for a hash to be well-behaved, it must obey some laws //! that are explained below. //! //! //! Minimal complete definition //! --------------------------- //! `hash`, satisfying the laws below //! //! //! Laws //! ---- //! First, `hana::hash` must return a `hana::type`. Furthermore, for any //! two `Hashable` objects `x` and `y`, it must be the case that //! @code //! x == y implies hash(x) == hash(y) //! @endcode //! //! where `==` denotes `hana::equal`. In other words, any two objects that //! compare equal (with `hana::equal`) must also have the same hash. //! However, the reverse is not true, and two different objects may have //! the same hash. This situation of two different objects having the same //! hash is called a _collision_. //! //! //! Concrete models //! --------------- //! `hana::integral_constant`, `hana::type`, `hana::string` //! //! //! Free model for `IntegralConstant`s //! ---------------------------------- //! Any `IntegralConstant` is `Hashable`, by normalizing its value to a //! `hana::integral_constant`. The type of the value held in the normalized //! `integral_constant` is `unsigned long long` for unsigned integral //! types, and `signed long long` for signed integral types. template <typename T> struct Hashable; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_HASHABLE_HPP PK �|!\%t��`$ `$ concept/monad.hppnu �[��� /*! @file Forward declares `boost::hana::Monad`. @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_CONCEPT_MONAD_HPP #define BOOST_HANA_FWD_CONCEPT_MONAD_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-Monad Monad //! The `Monad` concept represents `Applicative`s with the ability to //! flatten nested levels of structure. //! //! Historically, Monads are a construction coming from category theory, //! an abstract branch of mathematics. The functional programming //! community eventually discovered how Monads could be used to //! formalize several useful things like side effects, which led //! to the wide adoption of Monads in that community. However, even //! in a multi-paradigm language like C++, there are several constructs //! which turn out to be Monads, like `std::optional`, `std::vector` and //! others. //! //! Everybody tries to introduce `Monad`s with a different analogy, and //! most people fail. This is called the [Monad tutorial fallacy][1]. We //! will try to avoid this trap by not presenting a specific intuition, //! and we will instead present what monads are mathematically. //! For specific intuitions, we will let readers who are new to this //! concept read one of the many excellent tutorials available online. //! Understanding Monads might take time at first, but once you get it, //! a lot of patterns will become obvious Monads; this enlightening will //! be your reward for the hard work. //! //! There are different ways of defining a Monad; Haskell uses a function //! called `bind` (`>>=`) and another one called `return` (it has nothing //! to do with C++'s `return` statement). They then introduce relationships //! that must be satisfied for a type to be a Monad with those functions. //! Mathematicians sometimes use a function called `join` and another one //! called `unit`, or they also sometimes use other category theoretic //! constructions like functor adjunctions and the Kleisli category. //! //! This library uses a composite approach. First, we use the `flatten` //! function (equivalent to `join`) along with the `lift` function from //! `Applicative` (equivalent to `unit`) to introduce the notion of //! monadic function composition. We then write the properties that must //! be satisfied by a Monad using this monadic composition operator, //! because we feel it shows the link between Monads and Monoids more //! clearly than other approaches. //! //! Roughly speaking, we will say that a `Monad` is an `Applicative` which //! also defines a way to compose functions returning a monadic result, //! as opposed to only being able to compose functions returning a normal //! result. We will then ask for this composition to be associative and to //! have a neutral element, just like normal function composition. For //! usual composition, the neutral element is the identity function `id`. //! For monadic composition, the neutral element is the `lift` function //! defined by `Applicative`. This construction is made clearer in the //! laws below. //! //! @note //! Monads are known to be a big chunk to swallow. However, it is out of //! the scope of this documentation to provide a full-blown explanation //! of the concept. The [Typeclassopedia][2] is a nice Haskell-oriented //! resource where more information about Monads can be found. //! //! //! Minimal complete definitions //! ---------------------------- //! First, a `Monad` must be both a `Functor` and an `Applicative`. //! Also, an implementation of `flatten` or `chain` satisfying the //! laws below for monadic composition must be provided. //! //! @note //! The `ap` method for `Applicatives` may be derived from the minimal //! complete definition of `Monad` and `Functor`; see below for more //! information. //! //! //! Laws //! ---- //! To simplify writing the laws, we use the comparison between functions. //! For two functions `f` and `g`, we define //! @code //! f == g if and only if f(x) == g(x) for all x //! @endcode //! //! With the usual composition of functions, we are given two functions //! @f$ f : A \to B @f$ and @f$ g : B \to C @f$, and we must produce a //! new function @f$ compose(g, f) : A \to C @f$. This composition of //! functions is associative, which means that //! @code //! compose(h, compose(g, f)) == compose(compose(h, g), f) //! @endcode //! //! Also, this composition has an identity element, which is the identity //! function. This simply means that //! @code //! compose(f, id) == compose(id, f) == f //! @endcode //! //! This is probably nothing new if you are reading the `Monad` laws. //! Now, we can observe that the above is equivalent to saying that //! functions with the composition operator form a `Monoid`, where the //! neutral element is the identity function. //! //! Given an `Applicative` `F`, what if we wanted to compose two functions //! @f$ f : A \to F(B) @f$ and @f$ g : B \to F(C) @f$? When the //! `Applicative` `F` is also a `Monad`, such functions taking normal //! values but returning monadic values are called _monadic functions_. //! To compose them, we obviously can't use normal function composition, //! since the domains and codomains of `f` and `g` do not match properly. //! Instead, we'll need a new operator -- let's call it `monadic_compose`: //! @f[ //! \mathtt{monadic\_compose} : //! (B \to F(C)) \times (A \to F(B)) \to (A \to F(C)) //! @f] //! //! How could we go about implementing this function? Well, since we know //! `F` is an `Applicative`, the only functions we have are `transform` //! (from `Functor`), and `lift` and `ap` (from `Applicative`). Hence, //! the only thing we can do at this point while respecting the signatures //! of `f` and `g` is to set (for `x` of type `A`) //! @code //! monadic_compose(g, f)(x) = transform(f(x), g) //! @endcode //! //! Indeed, `f(x)` is of type `F(B)`, so we can map `g` (which takes `B`'s) //! on it. Doing so will leave us with a result of type `F(F(C))`, but what //! we wanted was a result of type `F(C)` to respect the signature of //! `monadic_compose`. If we had a joker of type @f$ F(F(C)) \to F(C) @f$, //! we could simply set //! @code //! monadic_compose(g, f)(x) = joker(transform(f(x), g)) //! @endcode //! //! and we would be happy. It turns out that `flatten` is precisely this //! joker. Now, we'll want our joker to satisfy some properties to make //! sure this composition is associative, just like our normal composition //! was. These properties are slightly cumbersome to specify, so we won't //! do it here. Also, we'll need some kind of neutral element for the //! composition. This neutral element can't be the usual identity function, //! because it does not have the right type: our neutral element needs to //! be a function of type @f$ X \to F(X) @f$ but the identity function has //! type @f$ X \to X @f$. It is now the right time to observe that `lift` //! from `Applicative` has exactly the right signature, and so we'll take //! this for our neutral element. //! //! We are now ready to formulate the `Monad` laws using this composition //! operator. For a `Monad` `M` and functions @f$ f : A \to M(B) @f$, //! @f$ g : B \to M(C) @f$ and @f$ h : C \to M(D) @f$, the following //! must be satisfied: //! @code //! // associativity //! monadic_compose(h, monadic_compose(g, f)) == monadic_compose(monadic_compose(h, g), f) //! //! // right identity //! monadic_compose(f, lift<M(A)>) == f //! //! // left identity //! monadic_compose(lift<M(B)>, f) == f //! @endcode //! //! which is to say that `M` along with monadic composition is a Monoid //! where the neutral element is `lift`. //! //! //! Refined concepts //! ---------------- //! 1. `Functor` //! 2. `Applicative` (free implementation of `ap`)\n //! When the minimal complete definition for `Monad` and `Functor` are //! both satisfied, it is possible to implement `ap` by setting //! @code //! ap(fs, xs) = chain(fs, [](auto f) { //! return transform(xs, f); //! }) //! @endcode //! //! //! Concrete models //! --------------- //! `hana::lazy`, `hana::optional`, `hana::tuple` //! //! //! [1]: https://byorgey.wordpress.com/2009/01/12/abstraction-intuition-and-the-monad-tutorial-fallacy/ //! [2]: https://wiki.haskell.org/Typeclassopedia#Monad template <typename M> struct Monad; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_MONAD_HPP PK �|!\Xx=_ _ concept/iterable.hppnu �[��� /*! @file Forward declares `boost::hana::Iterable`. @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_CONCEPT_ITERABLE_HPP #define BOOST_HANA_FWD_CONCEPT_ITERABLE_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-Iterable Iterable //! The `Iterable` concept represents data structures supporting external //! iteration. //! //! Intuitively, an `Iterable` can be seen as a kind of container whose //! elements can be pulled out one at a time. An `Iterable` also provides //! a way to know when the _container_ is empty, i.e. when there are no //! more elements to pull out. //! //! Whereas `Foldable` represents data structures supporting internal //! iteration with the ability to accumulate a result, the `Iterable` //! concept allows inverting the control of the iteration. This is more //! flexible than `Foldable`, since it allows iterating over only some //! part of the structure. This, in turn, allows `Iterable` to work on //! infinite structures, while trying to fold such a structure would //! never finish. //! //! //! Minimal complete definition //! --------------------------- //! `at`, `drop_front` and `is_empty` //! //! //! @anchor Iterable-lin //! The linearization of an `Iterable` //! ---------------------------------- //! Intuitively, for an `Iterable` structure `xs`, the _linearization_ of //! `xs` is the sequence of all the elements in `xs` as if they had been //! put in a (possibly infinite) list: //! @code //! linearization(xs) = [x1, x2, x3, ...] //! @endcode //! //! The `n`th element of the linearization of an `Iterable` can be //! accessed with the `at` function. In other words, `at(xs, n) == xn`. //! //! Note that this notion is precisely the extension of the [linearization] //! (@ref Foldable-lin) notion of `Foldable`s to the infinite case. This //! notion is useful for expressing various properties of `Iterable`s, //! and is used for that elsewhere in the documentation. //! //! //! Compile-time `Iterable`s //! ------------------------ //! A _compile-time_ `Iterable` is an `Iterable` for which `is_empty` //! returns a compile-time `Logical`. These structures allow iteration //! to be done at compile-time, in the sense that the "loop" doing the //! iteration can be unrolled because the total length of the structure //! is kown at compile-time. //! //! In particular, note that being a compile-time `Iterable` has nothing //! to do with being finite or infinite. For example, it would be possible //! to create a sequence representing the Pythagorean triples as //! `integral_constant`s. Such a sequence would be infinite, but iteration //! on the sequence would still be done at compile-time. However, if one //! tried to iterate over _all_ the elements of the sequence, the compiler //! would loop indefinitely, in contrast to your program looping //! indefinitely if the sequence was a runtime one. //! //! __In the current version of the library, only compile-time `Iterable`s //! are supported.__ While it would be possible in theory to support //! runtime `Iterable`s, doing it efficiently is the subject of some //! research. In particular, follow [this issue][1] for the current //! status of runtime `Iterable`s. //! //! //! Laws //! ---- //! First, we require the equality of two `Iterable`s to be related to the //! equality of the elements in their linearizations. More specifically, //! if `xs` and `ys` are two `Iterable`s of data type `It`, then //! @code //! xs == ys => at(xs, i) == at(ys, i) for all i //! @endcode //! //! This conveys that two `Iterable`s must have the same linearization //! in order to be considered equal. //! //! Secondly, since every `Iterable` is also a `Searchable`, we require //! the models of `Iterable` and `Searchable` to be consistent. This is //! made precise by the following laws. For any `Iterable` `xs` with a //! linearization of `[x1, x2, x3, ...]`, //! @code //! any_of(xs, equal.to(z)) <=> xi == z //! @endcode //! for some _finite_ index `i`. Furthermore, //! @code //! find_if(xs, pred) == just(the first xi such that pred(xi) is satisfied) //! @endcode //! or `nothing` if no such `xi` exists. //! //! //! Refined concepts //! ---------------- //! 1. `Searchable` (free model)\n //! Any `Iterable` gives rise to a model of `Searchable`, where the keys //! and the values are both the elements in the structure. Searching for //! a key is just doing a linear search through the elements of the //! structure. //! @include example/iterable/searchable.cpp //! //! 2. `Foldable` for finite `Iterable`s\n //! Every finite `Iterable` gives rise to a model of `Foldable`. For //! these models to be consistent, we require the models of both `Foldable` //! and `Iterable` to have the same linearization. //! //! @note //! As explained above, `Iterable`s are also `Searchable`s and their //! models have to be consistent. By the laws presented here, it also //! means that the `Foldable` model for finite `Iterable`s has to be //! consistent with the `Searchable` model. //! //! For convenience, finite `Iterable`s must only provide a definition of //! `length` to model the `Foldable` concept; defining the more powerful //! `unpack` or `fold_left` is not necessary (but still possible). The //! default implementation of `unpack` derived from `Iterable` + `length` //! uses the fact that `at(xs, i)` denotes the `i`th element of `xs`'s //! linearization, and that the linearization of a finite `Iterable` must //! be the same as its linearization as a `Foldable`. //! //! //! Concrete models //! --------------- //! `hana::tuple`, `hana::string`, `hana::range` //! //! //! [1]: https://github.com/boostorg/hana/issues/40 template <typename It> struct Iterable; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_ITERABLE_HPP PK �|!\u��*�' �' concept/constant.hppnu �[��� /*! @file Forward declares `boost::hana::Constant`. @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_CONCEPT_CONSTANT_HPP #define BOOST_HANA_FWD_CONCEPT_CONSTANT_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-Constant Constant //! The `Constant` concept represents data that can be manipulated at //! compile-time. //! //! At its core, `Constant` is simply a generalization of the principle //! behind `std::integral_constant` to all types that can be constructed //! at compile-time, i.e. to all types with a `constexpr` constructor //! (also called [Literal types][1]). More specifically, a `Constant` is //! an object from which a `constexpr` value may be obtained (through the //! `value` method) regardless of the `constexpr`ness of the object itself. //! //! All `Constant`s must be somewhat equivalent, in the following sense. //! Let `C(T)` and `D(U)` denote the tags of `Constant`s holding objects //! of type `T` and `U`, respectively. Then, an object with tag `D(U)` //! must be convertible to an object with tag `C(T)` whenever `U` is //! convertible to `T`, as determined by `is_convertible`. The //! interpretation here is that a `Constant` is just a box holding //! an object of some type, and it should be possible to swap between //! boxes whenever the objects inside the boxes can be swapped. //! //! Because of this last requirement, one could be tempted to think that //! specialized "boxes" like `std::integral_constant` are prevented from //! being `Constant`s because they are not able to hold objects of any //! type `T` (`std::integral_constant` may only hold integral types). //! This is false; the requirement should be interpreted as saying that //! whenever `C(T)` is _meaningful_ (e.g. only when `T` is integral for //! `std::integral_constant`) _and_ there exists a conversion from `U` //! to `T`, then a conversion from `D(U)` to `C(T)` should also exist. //! The precise requirements for being a `Constant` are embodied in the //! following laws. //! //! //! Minimal complete definition //! --------------------------- //! `value` and `to`, satisfying the laws below. //! //! //! Laws //! ---- //! Let `c` be an object of with tag `C`, which represents a `Constant` //! holding an object with tag `T`. The first law ensures that the value //! of the wrapped object is always a constant expression by requiring //! the following to be well-formed: //! @code //! constexpr auto x = hana::value<decltype(c)>(); //! @endcode //! //! This means that the `value` function must return an object that can //! be constructed at compile-time. It is important to note how `value` //! only receives the type of the object and not the object itself. //! This is the core of the `Constant` concept; it means that the only //! information required to implement `value` must be stored in the _type_ //! of its argument, and hence be available statically. //! //! The second law that must be satisfied ensures that `Constant`s are //! basically dumb boxes, which makes it possible to provide models for //! many concepts without much work from the user. The law simply asks //! for the following expression to be valid: //! @code //! to<C>(i) //! @endcode //! where, `i` is an _arbitrary_ `Constant` holding an internal value //! with a tag that can be converted to `T`, as determined by the //! `hana::is_convertible` metafunction. In other words, whenever `U` is //! convertible to `T`, a `Constant` holding a `U` is convertible to //! a `Constant` holding a `T`, if such a `Constant` can be created. //! //! Finally, the tag `C` must provide a nested `value_type` alias to `T`, //! which allows us to query the tag of the inner value held by objects //! with tag `C`. In other words, the following must be true for any //! object `c` with tag `C`: //! @code //! std::is_same< //! C::value_type, //! tag_of<decltype(hana::value(c))>::type //! >::value //! @endcode //! //! //! Refined concepts //! ---------------- //! In certain cases, a `Constant` can automatically be made a model of //! another concept. In particular, if a `Constant` `C` is holding an //! object of tag `T`, and if `T` models a concept `X`, then `C` may //! in most cases model `X` by simply performing whatever operation is //! required on its underlying value, and then wrapping the result back //! in a `C`. //! //! More specifically, if a `Constant` `C` has an underlying value //! (`C::value_type`) which is a model of `Comparable`, `Orderable`, //! `Logical`, or `Monoid` up to `EuclideanRing`, then `C` must also //! be a model of those concepts. In other words, when `C::value_type` //! models one of the listed concepts, `C` itself must also model that //! concept. However, note that free models are provided for all of //! those concepts, so no additional work must be done. //! //! While it would be possible in theory to provide models for concepts //! like `Foldable` too, only a couple of concepts are useful to have as //! `Constant` in practice. Providing free models for the concepts listed //! above is useful because it allows various types of integral constants //! (`std::integral_constant`, `mpl::integral_c`, etc...) to easily have //! models for them just by defining the `Constant` concept. //! //! @remark //! An interesting observation is that `Constant` is actually the //! canonical embedding of the subcategory of `constexpr` things //! into the Hana category, which contains everything in this library. //! Hence, whatever is true in that subcategory is also true here, via //! this functor. This is why we can provide models of any concept that //! works on `constexpr` things for Constants, by simply passing them //! through that embedding. //! //! //! Concrete models //! --------------- //! `hana::integral_constant` //! //! //! Provided conversion to the tag of the underlying value //! ------------------------------------------------------ //! Any `Constant` `c` holding an underlying value of tag `T` is //! convertible to any tag `U` such that `T` is convertible to `U`. //! Specifically, the conversion is equivalent to //! @code //! to<U>(c) == to<U>(value<decltype(c)>()) //! @endcode //! //! Also, those conversions are marked as an embedding whenever the //! conversion of underlying types is an embedding. This is to allow //! Constants to inter-operate with `constexpr` objects easily: //! @code //! plus(int_c<1>, 1) == 2 //! @endcode //! //! Strictly speaking, __this is sometimes a violation__ of what it means //! to be an embedding. Indeed, while there exists an embedding from any //! Constant to a `constexpr` object (since Constant is just the canonical //! inclusion), there is no embedding from a Constant to a runtime //! object since we would lose the ability to define the `value` method //! (the `constexpr`ness of the object would have been lost). Since there //! is no way to distinguish `constexpr` and non-`constexpr` objects based //! on their type, Hana has no way to know whether the conversion is to a //! `constexpr` object of not. In other words, the `to` method has no way //! to differentiate between //! @code //! constexpr int i = hana::to<int>(int_c<1>); //! @endcode //! which is an embedding, and //! @code //! int i = hana::to<int>(int_c<1>); //! @endcode //! //! which isn't. To be on the safer side, we could mark the conversion //! as not-an-embedding. However, if e.g. the conversion from //! `integral_constant_tag<int>` to `int` was not marked as an embedding, //! we would have to write `plus(to<int>(int_c<1>), 1)` instead of just //! `plus(int_c<1>, 1)`, which is cumbersome. Hence, the conversion is //! marked as an embedding, but this also means that code like //! @code //! int i = 1; //! plus(int_c<1>, i); //! @endcode //! will be considered valid, which implicitly loses the fact that //! `int_c<1>` is a Constant, and hence does not follow the usual rules //! for cross-type operations in Hana. //! //! //! Provided common data type //! ------------------------- //! Because of the requirement that `Constant`s be interchangeable when //! their contents are compatible, two `Constant`s `A` and `B` will have //! a common data type whenever `A::value_type` and `B::value_type` have //! one. Their common data type is an unspecified `Constant` `C` such //! that `C::value_type` is exactly `common_t<A::value_type, B::value_type>`. //! A specialization of the `common` metafunction is provided for //! `Constant`s to reflect this. //! //! In the same vein, a common data type is also provided from any //! constant `A` to a type `T` such that `A::value_type` and `T` share //! a common type. The common type between `A` and `T` is obviously the //! common type between `A::value_type` and `T`. As explained above in //! the section on conversions, this is sometimes a violation of the //! definition of a common type, because there must be an embedding //! to the common type, which is not always the case. For the same //! reasons as explained above, this common type is still provided. //! //! //! [1]: http://en.cppreference.com/w/cpp/named_req/LiteralType template <typename C> struct Constant; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_CONSTANT_HPP PK �|!\��1�� � concept/sequence.hppnu �[��� /*! @file Forward declares `boost::hana::Sequence`. @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_CONCEPT_SEQUENCE_HPP #define BOOST_HANA_FWD_CONCEPT_SEQUENCE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-Sequence Sequence //! The `Sequence` concept represents generic index-based sequences. //! //! Compared to other abstract concepts, the Sequence concept is very //! specific. It represents generic index-based sequences. The reason //! why such a specific concept is provided is because there are a lot //! of models that behave exactly the same while being implemented in //! wildly different ways. It is useful to regroup all those data types //! under the same umbrella for the purpose of generic programming. //! //! In fact, models of this concept are not only _similar_. They are //! actually _isomorphic_, in a sense that we define below, which is //! a fancy way of rigorously saying that they behave exactly the same //! to an external observer. //! //! //! Minimal complete definition //! --------------------------- //! `Iterable`, `Foldable`, and `make` //! //! The `Sequence` concept does not provide basic methods that could be //! used as a minimal complete definition; instead, it borrows methods //! from other concepts and add laws to them. For this reason, it is //! necessary to specialize the `Sequence` metafunction in Hana's //! namespace to tell Hana that a type is indeed a `Sequence`. Explicitly //! specializing the `Sequence` metafunction can be seen like a seal //! saying "this data type satisfies the additional laws of a `Sequence`", //! since those can't be checked by Hana automatically. //! //! //! Laws //! ---- //! The laws for being a `Sequence` are simple, and their goal is to //! restrict the semantics that can be associated to the functions //! provided by other concepts. First, a `Sequence` must be a finite //! `Iterable` (thus a `Foldable` too). Secondly, for a `Sequence` tag //! `S`, `make<S>(x1, ..., xn)` must be an object of tag `S` and whose //! linearization is `[x1, ..., xn]`. This basically ensures that objects //! of tag `S` are equivalent to their linearization, and that they can //! be created from such a linearization (with `make`). //! //! While it would be possible in theory to handle infinite sequences, //! doing so complicates the implementation of many algorithms. For //! simplicity, the current version of the library only handles finite //! sequences. However, note that this does not affect in any way the //! potential for having infinite `Searchable`s and `Iterable`s. //! //! //! Refined concepts //! ---------------- //! 1. `Comparable` (definition provided automatically)\n //! Two `Sequence`s are equal if and only if they contain the same number //! of elements and their elements at any given index are equal. //! @include example/sequence/comparable.cpp //! //! 2. `Orderable` (definition provided automatically)\n //! `Sequence`s are ordered using the traditional lexicographical ordering. //! @include example/sequence/orderable.cpp //! //! 3. `Functor` (definition provided automatically)\n //! `Sequence`s implement `transform` as the mapping of a function over //! each element of the sequence. This is somewhat equivalent to what //! `std::transform` does to ranges of iterators. Also note that mapping //! a function over an empty sequence returns an empty sequence and never //! applies the function, as would be expected. //! @include example/sequence/functor.cpp //! //! 4. `Applicative` (definition provided automatically)\n //! First, `lift`ing a value into a `Sequence` is the same as creating a //! singleton sequence containing that value. Second, applying a sequence //! of functions to a sequence of values will apply each function to //! all the values in the sequence, and then return a list of all the //! results. In other words, //! @code //! ap([f1, ..., fN], [x1, ..., xM]) == [ //! f1(x1), ..., f1(xM), //! ... //! fN(x1), ..., fN(xM) //! ] //! @endcode //! Example: //! @include example/sequence/applicative.cpp //! //! 5. `Monad` (definition provided automatically)\n //! First, `flaten`ning a `Sequence` takes a sequence of sequences and //! concatenates them to get a larger sequence. In other words, //! @code //! flatten([[a1, ..., aN], ..., [z1, ..., zM]]) == [ //! a1, ..., aN, ..., z1, ..., zM //! ] //! @endcode //! This acts like a `std::tuple_cat` function, except it receives a //! sequence of sequences instead of a variadic pack of sequences to //! flatten.\n //! __Example__: //! @include example/sequence/monad.ints.cpp //! Also note that the model of `Monad` for `Sequence`s can be seen as //! modeling nondeterminism. A nondeterministic computation can be //! modeled as a function which returns a sequence of possible results. //! In this line of thought, `chain`ing a sequence of values into such //! a function will return a sequence of all the possible output values, //! i.e. a sequence of all the values applied to all the functions in //! the sequences.\n //! __Example__: //! @include example/sequence/monad.types.cpp //! //! 6. `MonadPlus` (definition provided automatically)\n //! `Sequence`s are models of the `MonadPlus` concept by considering the //! empty sequence as the unit of `concat`, and sequence concatenation //! as `concat`. //! @include example/sequence/monad_plus.cpp //! //! 7. `Foldable`\n //! The model of `Foldable` for `Sequence`s is uniquely determined by the //! model of `Iterable`. //! @include example/sequence/foldable.cpp //! //! 8. `Iterable`\n //! The model of `Iterable` for `Sequence`s corresponds to iteration over //! each element of the sequence, in order. This model is not provided //! automatically, and it is in fact part of the minimal complete //! definition for the `Sequence` concept. //! @include example/sequence/iterable.cpp //! //! 9. `Searchable` (definition provided automatically)\n //! Searching through a `Sequence` is equivalent to just searching through //! a list of the values it contains. The keys and the values on which //! the search is performed are both the elements of the sequence. //! @include example/sequence/searchable.cpp //! //! //! Concrete models //! --------------- //! `hana::tuple` //! //! //! [1]: http://en.wikipedia.org/wiki/Isomorphism#Isomorphism_vs._bijective_morphism #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename S> struct Sequence; #else template <typename S, typename = void> struct Sequence : Sequence<S, when<true>> { }; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_SEQUENCE_HPP PK �|!\�k[�q q concept/applicative.hppnu �[��� /*! @file Forward declares `boost::hana::Applicative`. @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_CONCEPT_APPLICATIVE_HPP #define BOOST_HANA_FWD_CONCEPT_APPLICATIVE_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-Applicative Applicative //! The `Applicative` concept represents `Functor`s with the ability //! to lift values and combine computations. //! //! A `Functor` can only take a normal function and map it over a //! structure containing values to obtain a new structure containing //! values. Intuitively, an `Applicative` can also take a value and //! lift it into the structure. In addition, an `Applicative` can take //! a structure containing functions and apply it to a structure //! containing values to obtain a new structure containing values. //! By currying the function(s) inside the structure, it is then //! also possible to apply n-ary functions to n structures containing //! values. //! //! @note //! This documentation does not go into much details about the nature //! of applicatives. However, the [Typeclassopedia][1] is a nice //! Haskell-oriented resource where such information can be found. //! //! //! Minimal complete definition //! --------------------------- //! `lift` and `ap` satisfying the laws below. An `Applicative` must //! also be a `Functor`. //! //! //! Laws //! ---- //! Given an `Applicative` `F`, the following laws must be satisfied: //! 1. Identity\n //! For all objects `xs` of tag `F(A)`, //! @code //! ap(lift<F>(id), xs) == xs //! @endcode //! //! 2. Composition\n //! For all objects `xs` of tag `F(A)` and functions-in-an-applicative //! @f$ fs : F(B \to C) @f$, //! @f$ gs : F(A \to B) @f$, //! @code //! ap(ap(lift<F>(compose), fs, gs), xs) == ap(fs, ap(gs, xs)) //! @endcode //! //! 3. Homomorphism\n //! For all objects `x` of tag `A` and functions @f$ f : A \to B @f$, //! @code //! ap(lift<F>(f), lift<F>(x)) == lift<F>(f(x)) //! @endcode //! //! 4. Interchange\n //! For all objects `x` of tag `A` and functions-in-an-applicative //! @f$ fs : F(A \to B) @f$, //! @code //! ap(fs, lift<F>(x)) == ap(lift<F>(apply(-, x)), fs) //! @endcode //! where `apply(-, x)` denotes the partial application of the `apply` //! function from the @ref group-functional module to the `x` argument. //! //! As a consequence of these laws, the model of `Functor` for `F` will //! satisfy the following for all objects `xs` of tag `F(A)` and functions //! @f$ f : A \to B @f$: //! @code //! transform(xs, f) == ap(lift<F>(f), xs) //! @endcode //! //! //! Refined concept //! --------------- //! 1. `Functor` (free model)\n //! As a consequence of the laws, any `Applicative F` can be made a //! `Functor` by setting //! @code //! transform(xs, f) = ap(lift<F>(f), xs) //! @endcode //! //! //! Concrete models //! --------------- //! `hana::lazy`, `hana::optional`, `hana::tuple` //! //! //! @anchor applicative-transformation //! Structure-preserving functions //! ------------------------------ //! An _applicative transformation_ is a function @f$ t : F(X) \to G(X) @f$ //! between two Applicatives `F` and `G`, where `X` can be any tag, and //! which preserves the operations of an Applicative. In other words, for //! all objects `x` of tag `X`, functions-in-an-applicative //! @f$ fs : F(X \to Y) @f$ and objects `xs` of tag `F(X)`, //! @code //! t(lift<F>(x)) == lift<G>(x) //! t(ap(fs, xs)) == ap(t(fs), t(xs)) //! @endcode //! //! [1]: https://wiki.haskell.org/Typeclassopedia#Applicative template <typename A> struct Applicative; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_APPLICATIVE_HPP PK �|!\��"� � concept/functor.hppnu �[��� /*! @file Forward declares `boost::hana::Functor`. @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_CONCEPT_FUNCTOR_HPP #define BOOST_HANA_FWD_CONCEPT_FUNCTOR_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-Functor Functor //! The `Functor` concept represents types that can be mapped over. //! //! Intuitively, a [Functor][1] is some kind of box that can hold generic //! data and map a function over this data to create a new, transformed //! box. Because we are only interested in mapping a function over the //! contents of a black box, the only real requirement for being a functor //! is to provide a function which can do the mapping, along with a couple //! of guarantees that the mapping is well-behaved. Those requirements are //! made precise in the laws below. The pattern captured by `Functor` is //! very general, which makes it widely useful. A lot of objects can be //! made `Functor`s in one way or another, the most obvious example being //! sequences with the usual mapping of the function on each element. //! While this documentation will not go into much more details about //! the nature of functors, the [Typeclassopedia][2] is a nice //! Haskell-oriented resource for such information. //! //! Functors are parametric data types which are parameterized over the //! data type of the objects they contain. Like everywhere else in Hana, //! this parametricity is only at the documentation level and it is not //! enforced. //! //! In this library, the mapping function is called `transform` after the //! `std::transform` algorithm, but other programming languages have given //! it different names (usually `map`). //! //! @note //! The word _functor_ comes from functional programming, where the //! concept has been used for a while, notably in the Haskell programming //! language. Haskell people borrowed the term from [category theory][3], //! which, broadly speaking, is a field of mathematics dealing with //! abstract structures and transformations between those structures. //! //! //! Minimal complete definitions //! ---------------------------- //! 1. `transform`\n //! When `transform` is specified, `adjust_if` is defined analogously to //! @code //! adjust_if(xs, pred, f) = transform(xs, [](x){ //! if pred(x) then f(x) else x //! }) //! @endcode //! //! 2. `adjust_if`\n //! When `adjust_if` is specified, `transform` is defined analogously to //! @code //! transform(xs, f) = adjust_if(xs, always(true), f) //! @endcode //! //! //! Laws //! ---- //! Let `xs` be a Functor with tag `F(A)`, //! \f$ f : A \to B \f$ and //! \f$ g : B \to C \f$. //! The following laws must be satisfied: //! @code //! transform(xs, id) == xs //! transform(xs, compose(g, f)) == transform(transform(xs, f), g) //! @endcode //! The first line says that mapping the identity function should not do //! anything, which precludes the functor from doing something nasty //! behind the scenes. The second line states that mapping the composition //! of two functions is the same as mapping the first function, and then //! the second on the result. While the usual functor laws are usually //! restricted to the above, this library includes other convenience //! methods and they should satisfy the following equations. //! Let `xs` be a Functor with tag `F(A)`, //! \f$ f : A \to A \f$, //! \f$ \mathrm{pred} : A \to \mathrm{Bool} \f$ //! for some `Logical` `Bool`, and `oldval`, `newval`, `value` objects //! of tag `A`. Then, //! @code //! adjust(xs, value, f) == adjust_if(xs, equal.to(value), f) //! adjust_if(xs, pred, f) == transform(xs, [](x){ //! if pred(x) then f(x) else x //! }) //! replace_if(xs, pred, value) == adjust_if(xs, pred, always(value)) //! replace(xs, oldval, newval) == replace_if(xs, equal.to(oldval), newval) //! fill(xs, value) == replace_if(xs, always(true), value) //! @endcode //! The default definition of the methods will satisfy these equations. //! //! //! Concrete models //! --------------- //! `hana::lazy`, `hana::optional`, `hana::tuple` //! //! //! Structure-preserving functions for Functors //! ------------------------------------------- //! A mapping between two functors which also preserves the functor //! laws is called a natural transformation (the term comes from //! category theory). A natural transformation is a function `f` //! from a functor `F` to a functor `G` such that for every other //! function `g` with an appropriate signature and for every object //! `xs` of tag `F(X)`, //! @code //! f(transform(xs, g)) == transform(f(xs), g) //! @endcode //! //! There are several examples of such transformations, like `to<tuple_tag>` //! when applied to an optional value. Indeed, for any function `g` and //! `hana::optional` `opt`, //! @code //! to<tuple_tag>(transform(opt, g)) == transform(to<tuple_tag>(opt), g) //! @endcode //! //! Of course, natural transformations are not limited to the `to<...>` //! functions. However, note that any conversion function between Functors //! should be natural for the behavior of the conversion to be intuitive. //! //! //! [1]: http://en.wikipedia.org/wiki/Functor //! [2]: https://wiki.haskell.org/Typeclassopedia#Functor //! [3]: http://en.wikipedia.org/wiki/Category_theory template <typename F> struct Functor; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_FUNCTOR_HPP PK �|!\�|R�n n concept/struct.hppnu �[��� /*! @file Forward declares `boost::hana::Struct`. @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_CONCEPT_STRUCT_HPP #define BOOST_HANA_FWD_CONCEPT_STRUCT_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-Struct Struct //! The `Struct` concept represents `struct`-like user-defined types. //! //! The `Struct` concept allows restricted compile-time reflection over //! user-defined types. In particular, it allows accessing the names of //! the members of a user-defined type, and also the value of those //! members. `Struct`s can also be folded, searched and converted to //! some types of containers, where more advanced transformations can //! be performed. //! //! While all types can _in theory_ be made `Struct`s, only a subset of //! them are actually interesting to see as such. More precisely, it is //! only interesting to make a type a `Struct` when it is conceptually //! a C++ `struct`, i.e. a mostly dumb aggregate of named data. The way //! this data is accessed is mostly unimportant to the `Struct` concept; //! it could be through getters and setters, through public members, //! through non-member functions or it could even be generated on-the-fly. //! The important part, which is made precise below, is that those accessor //! methods should be move-independent. //! //! Another way to see a `Struct` is as a map where the keys are the names //! of the members and the values are the values of those members. However, //! there are subtle differences like the fact that one can't add a member //! to a `Struct`, and also that the order of the members inside a `Struct` //! plays a role in determining the equality of `Struct`s, which is not //! the case for maps. //! //! //! Minimal complete definition //! --------------------------- //! `accessors` //! //! A model of `Struct` is created by specifying a sequence of key/value //! pairs with the `accessors` function. The first element of a pair in //! this sequence represents the "name" of a member of the `Struct`, while //! the second element is a function which retrieves this member from an //! object. The "names" do not have to be in any special form; they just //! have to be compile-time `Comparable`. For example, it is common to //! provide "names" that are `hana::string`s representing the actual names //! of the members, but one could provide `hana::integral_constant`s just //! as well. The values must be functions which, when given an object, //! retrieve the appropriate member from it. //! //! There are several ways of providing the `accessors` method, some of //! which are more flexible and others which are more convenient. First, //! one can define it through tag-dispatching, as usual. //! @snippet example/struct.mcd.tag_dispatching.cpp main //! //! Secondly, it is possible to provide a nested `hana_accessors_impl` //! type, which should be equivalent to a specialization of //! `accessors_impl` for tag-dispatching. However, for a type `S`, this //! technique only works when the data type of `S` is `S` itself, which //! is the case unless you explicitly asked for something else. //! @snippet example/struct.mcd.nested.cpp main //! //! Finally, the most convenient (but least flexible) option is to use //! the `BOOST_HANA_DEFINE_STRUCT`, the `BOOST_HANA_ADAPT_STRUCT` or the //! `BOOST_HANA_ADAPT_ADT` macro, which provide a minimal syntactic //! overhead. See the documentation of these macros for details on how //! to use them. //! //! Also note that it is not important that the accessor functions retrieve //! an actual member of the struct (e.g. `x.member`). Indeed, an accessor //! function could call a custom getter or even compute the value of the //! member on the fly: //! @snippet example/struct.custom_accessor.cpp main //! //! The only important thing is that the accessor functions are //! move-independent, a notion which is defined below. //! //! //! @anchor move-independence //! Move-independence //! ----------------- //! The notion of move-independence presented here defines rigorously //! when it is legitimate to "double-move" from an object. //! //! A collection of functions `f1, ..., fn` sharing the same domain is //! said to be _move-independent_ if for every fresh (not moved-from) //! object `x` in the domain, any permutation of the following statements //! is valid and leaves the `zk` objects in a fresh (not moved-from) state: //! @code //! auto z1 = f1(std::move(x)); //! ... //! auto zn = fn(std::move(x)); //! @endcode //! //! @note //! In the special case where some functions return objects that can't be //! bound to with `auto zk =` (like `void` or a non-movable, non-copyable //! type), just pretend the return value is ignored. //! //! Intuitively, this ensures that we can treat `f1, ..., fn` as //! "accessors" that decompose `x` into independent subobjects, and //! that do so without moving from `x` more than that subobject. This //! is important because it allows us to optimally decompose `Struct`s //! into their subparts inside the library. //! //! //! Laws //! ---- //! For any `Struct` `S`, the accessors in the `accessors<S>()` sequence //! must be move-independent, as defined above. //! //! //! Refined concepts //! ---------------- //! 1. `Comparable` (free model)\n //! `Struct`s are required to be `Comparable`. Specifically, two `Struct`s //! of the same data type `S` must be equal if and only if all of their //! members are equal. By default, a model of `Comparable` doing just that //! is provided for models of `Struct`. In particular, note that the //! comparison of the members is made in the same order as they appear in //! the `hana::members` sequence. //! @include example/struct/comparable.cpp //! //! 2. `Foldable` (free model)\n //! A `Struct` can be folded by considering it as a list of pairs each //! containing the name of a member and the value associated to that //! member, in the same order as they appear in the `hana::members` //! sequence. By default, a model of `Foldable` doing just that is //! provided for models of the `Struct` concept. //! @include example/struct/foldable.cpp //! Being a model of `Foldable` makes it possible to turn a `Struct` //! into basically any `Sequence`, but also into a `hana::map` by simply //! using the `to<...>` function! //! @include example/struct/to.cpp //! //! 3. `Searchable` (free model)\n //! A `Struct` can be searched by considering it as a map where the keys //! are the names of the members of the `Struct`, and the values are the //! members associated to those names. By default, a model of `Searchable` //! is provided for any model of the `Struct` concept. //! @include example/struct/searchable.cpp template <typename S> struct Struct; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_STRUCT_HPP PK �|!\n�=�� � concept/comparable.hppnu �[��� /*! @file Forward declares `boost::hana::Comparable`. @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_CONCEPT_COMPARABLE_HPP #define BOOST_HANA_FWD_CONCEPT_COMPARABLE_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-Comparable Comparable //! The `Comparable` concept defines equality and inequality. //! //! Intuitively, `Comparable` objects must define a binary predicate named //! `equal` that returns whether both objects represent the same abstract //! value. In other words, `equal` must check for deep equality. Since //! "representing the same abstract value" is difficult to express //! formally, the exact meaning of equality is partially left to //! interpretation by the programmer with the following guidelines:\n //! 1. Equality should be compatible with copy construction; copy //! constructing a value yields an `equal` value. //! 2. Equality should be independent of representation; an object //! representing a fraction as `4/8` should be `equal` to an object //! representing a fraction as `2/4`, because they both represent //! the mathematical object `1/2`. //! //! Moreover, `equal` must exhibit properties that make it intuitive to //! use for determining the equivalence of objects, which is formalized //! by the laws for `Comparable`. //! //! //! Minimal complete definition //! --------------------------- //! 1. `equal`\n //! When `equal` is defined, `not_equal` is implemented by default as its //! complement. For all objects `x`, `y` of a `Comparable` tag, //! @code //! not_equal(x, y) == not_(equal(x, y)) //! @endcode //! //! //! Laws //! ---- //! `equal` must define an [equivalence relation][1], and `not_equal` must //! be its complement. In other words, for all objects `a`, `b`, `c` with //! a `Comparable` tag, the following must hold: //! @code //! equal(a, a) // Reflexivity //! if equal(a, b) then equal(b, a) // Symmetry //! if equal(a, b) && equal(b, c) then equal(a, c) // Transitivity //! not_equal(a, b) is equivalent to not_(equal(a, b)) //! @endcode //! //! //! Concrete models //! --------------- //! `hana::integral_constant`, `hana::map`, `hana::optional`, `hana::pair`, //! `hana::range`, `hana::set`, `hana::string`, `hana::tuple`, //! `hana::type` //! //! //! Free model for `EqualityComparable` data types //! ---------------------------------------------- //! Two data types `T` and `U` that model the cross-type EqualityComparable //! concept presented in [N3351][2] automatically model the `Comparable` //! concept by setting //! @code //! equal(x, y) = (x == y) //! @endcode //! Note that this also makes EqualityComparable types in the //! [usual sense][3] models of `Comparable` in the same way. //! //! //! Equality-preserving functions //! ----------------------------- //! Let `A` and `B` be two `Comparable` tags. A function @f$f : A \to B@f$ //! is said to be equality-preserving if it preserves the structure of the //! `Comparable` concept, which can be rigorously stated as follows. For //! all objects `x`, `y` of tag `A`, //! @code //! if equal(x, y) then equal(f(x), f(y)) //! @endcode //! Equivalently, we simply require that `f` is a function in the usual //! mathematical sense. Another property is [injectivity][4], which can be //! viewed as being a "lossless" mapping. This property can be stated as //! @code //! if equal(f(x), f(y)) then equal(x, y) //! @endcode //! This is equivalent to saying that `f` maps distinct elements to //! distinct elements, hence the "lossless" analogy. In other words, `f` //! will not collapse distinct elements from its domain into a single //! element in its image, thus losing information. //! //! These functions are very important, especially equality-preserving //! ones, because they allow us to reason simply about programs. Also //! note that the property of being equality-preserving is taken for //! granted in mathematics because it is part of the definition of a //! function. We feel it is important to make the distinction here //! because programming has evolved differently and as a result //! programmers are used to work with functions that do not preserve //! equality. //! //! //! Cross-type version of the methods //! --------------------------------- //! The `equal` and `not_equal` methods are "overloaded" to handle //! distinct tags with certain properties. Specifically, they are //! defined for _distinct_ tags `A` and `B` such that //! 1. `A` and `B` share a common tag `C`, as determined by the //! `common` metafunction //! 2. `A`, `B` and `C` are all `Comparable` when taken individually //! 3. @f$ \mathtt{to<C>} : A \to C @f$ and @f$\mathtt{to<C>} : B \to C@f$ //! are both equality-preserving and injective (i.e. they are embeddings), //! as determined by the `is_embedding` metafunction. //! //! The method definitions for tags satisfying the above properties are //! @code //! equal(x, y) = equal(to<C>(x), to<C>(y)) //! not_equal(x, y) = not_equal(to<C>(x), to<C>(y)) //! @endcode //! //! //! Important note: special behavior of `equal` //! ------------------------------------------- //! In the context of programming with heterogeneous values, it is useful //! to have unrelated objects compare `false` instead of triggering an //! error. For this reason, `equal` adopts a special behavior for //! unrelated objects of tags `T` and `U` that do not satisfy the above //! requirements for the cross-type overloads. Specifically, when `T` and //! `U` are unrelated (i.e. `T` can't be converted to `U` and vice-versa), //! comparing objects with those tags yields a compile-time false value. //! This has the effect that unrelated objects like `float` and //! `std::string` will compare false, while comparing related objects that //! can not be safely embedded into the same super structure (like //! `long long` and `float` because of the precision loss) will trigger a //! compile-time assertion. Also note that for any tag `T` for which the //! minimal complete definition of `Comparable` is not provided, a //! compile-time assertion will also be triggered because `T` and `T` //! trivially share the common tag `T`, which is the expected behavior. //! This design choice aims to provide more flexibility for comparing //! objects, while still rejecting usage patterns that are most likely //! programming errors. //! //! //! [1]: http://en.wikipedia.org/wiki/Equivalence_relation#Definition //! [2]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3351.pdf //! [3]: http://en.cppreference.com/w/cpp/named_req/EqualityComparable //! [4]: http://en.wikipedia.org/wiki/Injective_function template <typename T> struct Comparable; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_COMPARABLE_HPP PK �|!\DD�g g concept/euclidean_ring.hppnu �[��� /*! @file Forward declares `boost::hana::EuclideanRing`. @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_CONCEPT_EUCLIDEAN_RING_HPP #define BOOST_HANA_FWD_CONCEPT_EUCLIDEAN_RING_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-EuclideanRing Euclidean Ring //! The `EuclideanRing` concept represents a commutative `Ring` that //! can also be endowed with a division algorithm. //! //! A Ring defines a binary operation often called _multiplication_ that //! can be used to combine two elements of the ring into a new element of //! the ring. An [Euclidean ring][1], also called an Euclidean domain, adds //! the ability to define a special function that generalizes the Euclidean //! division of integers. //! //! However, an Euclidean ring must also satisfy one more property, which //! is that of having no non-zero zero divisors. In a Ring `(R, +, *)`, it //! follows quite easily from the axioms that `x * 0 == 0` for any ring //! element `x`. However, there is nothing that mandates `0` to be the //! only ring element sending other elements to `0`. Hence, in some Rings, //! it is possible to have elements `x` and `y` such that `x * y == 0` //! while not having `x == 0` nor `y == 0`. We call these elements divisors //! of zero, or zero divisors. For example, this situation arises in the //! Ring of integers modulo 4 (the set `{0, 1, 2, 3}`) with addition and //! multiplication `mod 4` as binary operations. In this case, we have that //! @code //! 2 * 2 == 4 //! == 0 (mod 4) //! @endcode //! even though `2 != 0 (mod 4)`. //! //! Following this line of thought, an Euclidean ring requires its only //! zero divisor is zero itself. In other words, the multiplication in an //! Euclidean won't send two non-zero elements to zero. Also note that //! since multiplication in a `Ring` is not necessarily commutative, it //! is not always the case that //! @code //! x * y == 0 implies y * x == 0 //! @endcode //! To be rigorous, we should then distinguish between elements that are //! zero divisors when multiplied to the right and to the left. //! Fortunately, the concept of an Euclidean ring requires the Ring //! multiplication to be commutative. Hence, //! @code //! x * y == y * x //! @endcode //! and we do not have to distinguish between left and right zero divisors. //! //! Typical examples of Euclidean rings include integers and polynomials //! over a field. The method names used here refer to the Euclidean ring //! of integers under the usual addition, multiplication and division //! operations. //! //! //! Minimal complete definition //! --------------------------- //! `div` and `mod` satisfying the laws below //! //! //! Laws //! ---- //! To simplify the reading, we will use the `+`, `*`, `/` and `%` //! operators with infix notation to denote the application of the //! corresponding methods in Monoid, Group, Ring and EuclideanRing. //! For all objects `a` and `b` of an `EuclideanRing` `R`, the //! following laws must be satisfied: //! @code //! a * b == b * a // commutativity //! (a / b) * b + a % b == a if b is non-zero //! zero<R>() % b == zero<R>() if b is non-zero //! @endcode //! //! //! Refined concepts //! ---------------- //! `Monoid`, `Group`, `Ring` //! //! //! Concrete models //! --------------- //! `hana::integral_constant` //! //! //! Free model for non-boolean integral data types //! ---------------------------------------------- //! A data type `T` is integral if `std::is_integral<T>::%value` is true. //! For a non-boolean integral data type `T`, a model of `EuclideanRing` //! is automatically defined by using the `Ring` model provided for //! arithmetic data types and setting //! @code //! div(x, y) = (x / y) //! mod(x, y) = (x % y) //! @endcode //! //! @note //! The rationale for not providing an EuclideanRing model for `bool` is //! the same as for not providing Monoid, Group and Ring models. //! //! //! [1]: https://en.wikipedia.org/wiki/Euclidean_domain template <typename R> struct EuclideanRing; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_EUCLIDEAN_RING_HPP PK �|!\��� concept/metafunction.hppnu �[��� /*! @file Forward declares `boost::hana::Metafunction`. @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_CONCEPT_METAFUNCTION_HPP #define BOOST_HANA_FWD_CONCEPT_METAFUNCTION_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-Metafunction Metafunction //! A `Metafunction` is a function that takes `hana::type`s as inputs and //! returns a `hana::type` as output. //! //! A `Metafunction` is an object satisfying the [FunctionObject][1] //! concept, but with additional requirements. First, it must be possible //! to apply a `Metafunction` to arguments whose tag is `type_tag`, and //! the result of such an application must be an object whose tag is also //! `type_tag`. Note that `hana::type` and `hana::basic_type` are the //! only such types. //! //! Secondly, a `Metafunction` must provide a nested `::%apply` template //! which allows performing the same type-level computation as is done by //! the call operator. In Boost.MPL parlance, a `Metafunction` `F` is //! hence a [MetafunctionClass][2] in addition to being a `FunctionObject`. //! Rigorously, the following must be satisfied by any object `f` of type //! `F` which is a `Metafunction`, and for arbitrary types `T...`: //! @code //! f(hana::type_c<T>...) == hana::type_c<F::apply<T...>::type> //! @endcode //! //! Thirdly, to ease the inter-operation of values and types, //! `Metafunction`s must also allow being called with arguments that //! are not `hana::type`s. In that case, the result is equivalent to //! calling the metafunction on the types of the arguments. Rigorously, //! this means that for arbitrary objects `x...`, //! @code //! f(x...) == f(hana::type_c<decltype(x)>...) //! @endcode //! //! //! Minimal complete definition //! --------------------------- //! The `Metafunction` concept does not have a minimal complete definition //! in terms of tag-dispatched methods. Instead, the syntactic requirements //! documented above should be satisfied, and the `Metafunction` struct //! should be specialized explicitly in Hana's namespace. //! //! //! Concrete models //! --------------- //! `hana::metafunction`, `hana::metafunction_class`, `hana::template_` //! //! //! Rationale: Why aren't `Metafunction`s `Comparable`? //! --------------------------------------------------- //! When seeing `hana::template_`, a question that naturally arises is //! whether `Metafunction`s should be made `Comparable`. Indeed, it //! would seem to make sense to compare two templates `F` and `G` with //! `template_<F> == template_<G>`. However, in the case where `F` and/or //! `G` are alias templates, it makes sense to talk about two types of //! comparisons. The first one is _shallow_ comparison, and it determines //! that two alias templates are equal if they are the same alias //! template. The second one is _deep_ comparison, and it determines //! that two template aliases are equal if they alias the same type for //! any template argument. For example, given `F` and `G` defined as //! @code //! template <typename T> //! using F = void; //! //! template <typename T> //! using G = void; //! @endcode //! //! shallow comparison would determine that `F` and `G` are different //! because they are two different template aliases, while deep comparison //! would determine that `F` and `G` are equal because they always //! expand to the same type, `void`. Unfortunately, deep comparison is //! impossible to implement because one would have to check `F` and `G` //! on all possible types. On the other hand, shallow comparison is not //! satisfactory because `Metafunction`s are nothing but functions on //! `type`s, and the equality of two functions is normally defined with //! deep comparison. Hence, we adopt a conservative stance and avoid //! providing comparison for `Metafunction`s. //! //! [1]: http://en.cppreference.com/w/cpp/named_req/FunctionObject //! [2]: http://www.boost.org/doc/libs/release/libs/mpl/doc/refmanual/metafunction-class.html template <typename F> struct Metafunction; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_METAFUNCTION_HPP PK �|!\bzy�� � concept/monoid.hppnu �[��� /*! @file Forward declares `boost::hana::Monoid`. @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_CONCEPT_MONOID_HPP #define BOOST_HANA_FWD_CONCEPT_MONOID_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-Monoid Monoid //! The `Monoid` concept represents data types with an associative //! binary operation that has an identity. //! //! Specifically, a [Monoid][1] is a basic algebraic structure typically //! used in mathematics to construct more complex algebraic structures //! like `Group`s, `Ring`s and so on. They are useful in several contexts, //! notably to define the properties of numbers in a granular way. At its //! core, a `Monoid` is a set `S` of objects along with a binary operation //! (let's say `+`) that is associative and that has an identity in `S`. //! There are many examples of `Monoid`s: //! - strings with concatenation and the empty string as the identity //! - integers with addition and `0` as the identity //! - integers with multiplication and `1` as the identity //! - many others... //! //! As you can see with the integers, there are some sets that can be //! viewed as a monoid in more than one way, depending on the choice //! of the binary operation and identity. The method names used here //! refer to the monoid of integers under addition; `plus` is the binary //! operation and `zero` is the identity element of that operation. //! //! //! Minimal complete definition //! --------------------------- //! `plus` and `zero` satisfying the laws //! //! //! Laws //! ---- //! For all objects `x`, `y` and `z` of a `Monoid` `M`, the following //! laws must be satisfied: //! @code //! plus(zero<M>(), x) == x // left zero //! plus(x, zero<M>()) == x // right zero //! plus(x, plus(y, z)) == plus(plus(x, y), z) // associativity //! @endcode //! //! //! Concrete models //! --------------- //! `hana::integral_constant` //! //! //! Free model for non-boolean arithmetic data types //! ------------------------------------------------ //! A data type `T` is arithmetic if `std::is_arithmetic<T>::%value` is //! true. For a non-boolean arithmetic data type `T`, a model of `Monoid` //! is automatically defined by setting //! @code //! plus(x, y) = (x + y) //! zero<T>() = static_cast<T>(0) //! @endcode //! //! > #### Rationale for not making `bool` a `Monoid` by default //! > First, it makes no sense whatsoever to define an additive `Monoid` //! > over the `bool` type. Also, it could make sense to define a `Monoid` //! > with logical conjunction or disjunction. However, C++ allows `bool`s //! > to be added, and the method names of this concept really suggest //! > addition. In line with the principle of least surprise, no model //! > is provided by default. //! //! //! Structure-preserving functions //! ------------------------------ //! Let `A` and `B` be two `Monoid`s. A function `f : A -> B` is said //! to be a [Monoid morphism][2] if it preserves the monoidal structure //! between `A` and `B`. Rigorously, for all objects `x, y` of data //! type `A`, //! @code //! f(plus(x, y)) == plus(f(x), f(y)) //! f(zero<A>()) == zero<B>() //! @endcode //! Functions with these properties interact nicely with `Monoid`s, which //! is why they are given such a special treatment. //! //! //! [1]: http://en.wikipedia.org/wiki/Monoid //! [2]: http://en.wikipedia.org/wiki/Monoid#Monoid_homomorphisms template <typename M> struct Monoid; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_MONOID_HPP PK �|!\C Vu concept/orderable.hppnu �[��� /*! @file Forward declares `boost::hana::Orderable`. @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_CONCEPT_ORDERABLE_HPP #define BOOST_HANA_FWD_CONCEPT_ORDERABLE_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-Orderable Orderable //! The `Orderable` concept represents totally ordered data types. //! //! Intuitively, `Orderable` objects must define a binary predicate named //! `less` returning whether the first argument is to be considered less //! than the second argument. The word "total" means that _distinct_ //! objects must always be ordered; if `a` and `b` are not equal, then //! exactly one of `less(a, b)` and `less(b, a)` must be true. This is //! a contrast with weaker kinds of orders that would allow some objects //! to be incomparable (neither less than nor greater than). Also note //! that a non-strict total order may always be obtained from a strict //! total order (and vice-versa) by setting //! @code //! a <= b = !(b < a) //! a < b = !(b <= a) //! @endcode //! The non-strict version is used in the description of the laws because //! it makes them easier to parse for humans, but they could be formulated //! equivalently using the strict order. //! //! //! Minimal complete definition //! --------------------------- //! `less` //! //! When `less` is defined, the other methods are defined from it using //! the same definition as mandated in the laws below. //! //! //! Laws //! ---- //! Rigorously speaking, a [total order][1] `<=` on a set `S` is a binary //! predicate @f$ <= \;: S \times S \to bool @f$ such that for all //! `a`, `b`, `c` in `S`, //! @code //! if a <= b and b <= a then a == b // Antisymmetry //! if a <= b and b <= c then a <= c // Transitivity //! either a <= b or b <= a // Totality //! @endcode //! Additionally, the `less`, `greater` and `greater_equal` methods should //! have the following intuitive meanings: //! @code //! a < b if and only if !(b <= a) //! a > b if and only if b < a //! a >= b if and only if !(a < b) //! @endcode //! //! //! Refined concept //! --------------- //! 1. `Comparable` (free model)\n //! Since `Orderable` requires `less_equal` to be a total order, a model //! of `Comparable` may always be obtained by setting //! @code //! equal(x, y) = less_equal(x, y) && less_equal(y, x) //! @endcode //! //! //! Concrete models //! --------------- //! `hana::integral_constant`, `hana::optional`, `hana::pair`, //! `hana::string`, `hana::tuple` //! //! //! Free model for `LessThanComparable` data types //! ---------------------------------------------- //! Two data types `T` and `U` that model the cross-type version of the //! usual [LessThanComparable][2] C++ concept are automatically a model //! of `Orderable` by setting //! @code //! less(x, y) = (x < y) //! @endcode //! The cross-type version of the LessThanComparable concept is analogous //! to the cross-type version of the EqualityComparable concept presented //! in [N3351][3], which is compatible with the usual single type //! definition. //! However, note that the LessThanComparable concept only requires `<` //! to be a [strict weak ordering][4], which is a weaker requirement //! than being a total order. Hence, if `less` is used with objects //! of a LessThanComparable data type that do not define a total order, //! some algorithms may have an unexpected behavior. It is the author's //! opinion that defining `operator<` as a non-total order is a bad idea, //! but this is debatable and so the design choice of providing a model //! for LessThanComparable data types is open to debate. Waiting for //! some user input. //! //! //! Order-preserving functions //! -------------------------- //! Let `A` and `B` be two `Orderable` data types. A function //! @f$ f : A \to B@f$ is said to be order-preserving (also called //! monotone) if it preserves the structure of the `Orderable` concept, //! which can be rigorously stated as follows. For all objects `x`, `y` //! of data type `A`, //! @code //! if less(x, y) then less(f(x), f(y)) //! @endcode //! Another important property is that of being order-reflecting, which //! can be stated as //! @code //! if less(f(x), f(y)) then less(x, y) //! @endcode //! We say that a function is an order-embedding if it is both //! order-preserving and order-reflecting, i.e. if //! @code //! less(x, y) if and only if less(f(x), f(y)) //! @endcode //! //! //! Cross-type version of the methods //! --------------------------------- //! The comparison methods (`less`, `less_equal`, `greater` and //! `greater_equal`) are "overloaded" to handle distinct data types //! with certain properties. Specifically, they are defined for //! _distinct_ data types `A` and `B` such that //! 1. `A` and `B` share a common data type `C`, as determined by the //! `common` metafunction //! 2. `A`, `B` and `C` are all `Orderable` when taken individually //! 3. @f$\mathrm{to<C>} : A \to C@f$ and @f$\mathrm{to<C>} : B \to C@f$ //! are both order-embeddings as determined by the `is_embedding` //! metafunction. //! //! The method definitions for data types satisfying the above //! properties are //! @code //! less(x, y) = less(to<C>(x), to<C>(y)) //! less_equal(x, y) = less_equal(to<C>(x), to<C>(y)) //! greater_equal(x, y) = greater_equal(to<C>(x), to<C>(y)) //! greater(x, y) = greater(to<C>(x), to<C>(y)) //! @endcode //! //! //! Partial application of the methods //! ---------------------------------- //! The `less`, `greater`, `less_equal` and `greater_equal` methods can //! be called in two different ways. First, they can be called like //! normal functions: //! @code //! less(x, y) //! greater(x, y) //! //! less_equal(x, y) //! greater_equal(x, y) //! @endcode //! //! However, they may also be partially applied to an argument as follows: //! @code //! less.than(x)(y) == less(y, x) //! greater.than(x)(y) == greater(y, x) //! //! less_equal.than(x)(y) == less_equal(y, x) //! greater_equal.than(x)(y) == greater_equal(y, x) //! @endcode //! //! Take good note that the order of the arguments is reversed, so //! for example `less.than(x)(y)` is equivalent to `less(y, x)`, not //! `less(x, y)`. This is because those variants are meant to be used //! with higher order algorithms, where the chosen application order //! makes sense. //! //! //! [1]: http://en.wikipedia.org/wiki/Total_order //! [2]: http://en.cppreference.com/w/cpp/named_req/LessThanComparable //! [3]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3351.pdf //! [4]: http://en.wikipedia.org/wiki/Strict_weak_ordering template <typename Ord> struct Orderable; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_ORDERABLE_HPP PK �|!\�t��o o concept/product.hppnu �[��� /*! @file Forward declares `boost::hana::Product`. @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_CONCEPT_PRODUCT_HPP #define BOOST_HANA_FWD_CONCEPT_PRODUCT_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-Product Product //! Represents types that are generic containers of two elements. //! //! This concept basically represents types that are like `std::pair`. //! The motivation for making such a precise concept is similar to the //! motivation behind the `Sequence` concept; there are many different //! implementations of `std::pair` in different libraries, and we would //! like to manipulate any of them generically. //! //! Since a `Product` is basically a pair, it is unsurprising that the //! operations provided by this concept are getting the first and second //! element of a pair, creating a pair from two elements and other //! simmilar operations. //! //! @note //! Mathematically, this concept represents types that are category //! theoretical [products][1]. This is also where the name comes //! from. //! //! //! Minimal complete definition //! --------------------------- //! `first`, `second` and `make` //! //! `first` and `second` must obviously return the first and the second //! element of the pair, respectively. `make` must take two arguments `x` //! and `y` representing the first and the second element of the pair, //! and return a pair `p` such that `first(p) == x` and `second(p) == y`. //! @include example/product/make.cpp //! //! //! Laws //! ---- //! For a model `P` of `Product`, the following laws must be satisfied. //! For every data types `X` and `Y`, there must be a unique function //! @f$ \mathtt{make} : X \times Y \to P @f$ such that for every `x`, `y`, //! @code //! x == first(make<P>(x, y)) //! y == second(make<P>(x, y)) //! @endcode //! //! @note //! This law is less general than the universal property typically used to //! define category theoretical products, but it is vastly enough for what //! we need. //! //! This is basically saying that a `Product` must be the most general //! object able to contain a pair of objects `(P1, P2)`, but nothing //! more. Since the categorical product is defined by a universal //! property, all the models of this concept are isomorphic, and //! the isomorphism is unique. In other words, there is one and only //! one way to convert one `Product` to another. //! //! Another property that must be satisfied by `first` and `second` is //! that of @ref move-independence, which ensures that we can optimally //! decompose a `Product` into its two members without making redundant //! copies. //! //! //! Refined concepts //! ---------------- //! 1. `Comparable` (free model)\n //! Two products `x` and `y` are equal iff they are equal element-wise, //! by comparing the first element before the second element. //! @include example/product/comparable.cpp //! //! 2. `Orderable` (free model)\n //! Products are ordered using a lexicographical ordering as-if they //! were 2-element tuples. //! //! 3. `Foldable` (free model)\n //! Folding a `Product` `p` is equivalent to folding a list containing //! `first(p)` and `second(p)`, in that order. //! //! //! Concrete models //! --------------- //! `hana::pair` //! //! //! [1]: http://en.wikipedia.org/wiki/Product_(category_theory) template <typename P> struct Product; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_PRODUCT_HPP PK �|!\�ǧ. . concept/ring.hppnu �[��� /*! @file Forward declares `boost::hana::Ring`. @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_CONCEPT_RING_HPP #define BOOST_HANA_FWD_CONCEPT_RING_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-Ring Ring //! The `Ring` concept represents `Group`s that also form a `Monoid` //! under a second binary operation that distributes over the first. //! //! A [Ring][1] is an algebraic structure built on top of a `Group` //! which requires a monoidal structure with respect to a second binary //! operation. This second binary operation must distribute over the //! first one. Specifically, a `Ring` is a triple `(S, +, *)` such that //! `(S, +)` is a `Group`, `(S, *)` is a `Monoid` and `*` distributes //! over `+`, i.e. //! @code //! x * (y + z) == (x * y) + (x * z) //! @endcode //! //! The second binary operation is often written `*` with its identity //! written `1`, in reference to the `Ring` of integers under //! multiplication. The method names used here refer to this exact ring. //! //! //! Minimal complete definintion //! ---------------------------- //! `one` and `mult` satisfying the laws //! //! //! Laws //! ---- //! For all objects `x`, `y`, `z` of a `Ring` `R`, the following laws must //! be satisfied: //! @code //! mult(x, mult(y, z)) == mult(mult(x, y), z) // associativity //! mult(x, one<R>()) == x // right identity //! mult(one<R>(), x) == x // left identity //! mult(x, plus(y, z)) == plus(mult(x, y), mult(x, z)) // distributivity //! @endcode //! //! //! Refined concepts //! ---------------- //! `Monoid`, `Group` //! //! //! Concrete models //! --------------- //! `hana::integral_constant` //! //! //! Free model for non-boolean arithmetic data types //! ------------------------------------------------ //! A data type `T` is arithmetic if `std::is_arithmetic<T>::%value` is //! true. For a non-boolean arithmetic data type `T`, a model of `Ring` is //! automatically defined by using the provided `Group` model and setting //! @code //! mult(x, y) = (x * y) //! one<T>() = static_cast<T>(1) //! @endcode //! //! @note //! The rationale for not providing a Ring model for `bool` is the same //! as for not providing Monoid and Group models. //! //! //! Structure-preserving functions //! ------------------------------ //! Let `A` and `B` be two `Ring`s. A function `f : A -> B` is said to //! be a [Ring morphism][2] if it preserves the ring structure between //! `A` and `B`. Rigorously, for all objects `x, y` of data type `A`, //! @code //! f(plus(x, y)) == plus(f(x), f(y)) //! f(mult(x, y)) == mult(f(x), f(y)) //! f(one<A>()) == one<B>() //! @endcode //! Because of the `Ring` structure, it is easy to prove that the //! following will then also be satisfied: //! @code //! f(zero<A>()) == zero<B>() //! f(negate(x)) == negate(f(x)) //! @endcode //! which is to say that `f` will then also be a `Group` morphism. //! Functions with these properties interact nicely with `Ring`s, //! which is why they are given such a special treatment. //! //! //! [1]: http://en.wikipedia.org/wiki/Ring_(mathematics) //! [2]: http://en.wikipedia.org/wiki/Ring_homomorphism template <typename R> struct Ring; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_RING_HPP PK �|!\�O��L L concept/monad_plus.hppnu �[��� /*! @file Forward declares `boost::hana::MonadPlus`. @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_CONCEPT_MONAD_PLUS_HPP #define BOOST_HANA_FWD_CONCEPT_MONAD_PLUS_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-concepts //! @defgroup group-MonadPlus MonadPlus //! The `MonadPlus` concept represents Monads with a monoidal structure. //! //! Intuitively, whereas a Monad can be seen as some kind of container //! or context, a MonadPlus can be seen as a container or a context that //! can be concatenated with other containers or contexts. There must //! also be an identity element for this combining operation. For example, //! a tuple is a MonadPlus, because tuples can be concatenated and the //! empty tuple would act as an identity for concatenation. How is this //! different from a Monad which is also a Monoid? The answer is that the //! monoidal structure on a MonadPlus must _not_ depend of the contents //! of the structure; it must not require the contents to be a Monoid //! in order to work. //! //! While sequences are not the only possible model for MonadPlus, the //! method names used here refer to the MonadPlus of sequences under //! concatenation. Several useful functions generalizing operations on //! sequences are included with this concept, like `append`, `prepend` //! and `filter`. //! //! @note //! This documentation does not go into much details about the nature //! of the MonadPlus concept. However, there is a nice Haskell-oriented //! [WikiBook][1] going into further details. //! //! //! Minimal complete definition //! --------------------------- //! `concat` and `empty` //! //! //! Laws //! ---- //! First, a MonadPlus is required to have a monoidal structure. Hence, it //! is no surprise that for any MonadPlus `M`, we require `M(T)` to be a //! valid monoid. However, we do not enforce that `M(T)` actually models //! the Monoid concept provided by Hana. Further, for all objects `a, b, c` //! of data type `M(T)`, //! @code //! // identity //! concat(empty<M(T)>(), a) == a //! concat(a, empty<M(T)>()) == a //! //! // associativity //! concat(a, concat(b, c)) == concat(concat(a, b), c) //! @endcode //! //! Secondly, a MonadPlus is also required to obey the following laws, //! which represent the fact that `empty<M(T)>()` must be some kind of //! absorbing element for the `chain` operation. For all objects `a` of //! data type `M(T)` and functions @f$ f : T \to M(U) @f$, //! @code //! chain(empty<M(T)>(), f) == empty<M(U)>() //! chain(a, always(empty<M(T)>())) == empty<M(U)>() //! @endcode //! //! //! Refined concepts //! ---------------- //! `Functor`, `Applicative` and `Monad` //! //! //! Concrete models //! --------------- //! `hana::optional`, `hana::tuple` //! //! [1]: https://en.wikibooks.org/wiki/Haskell/MonadPlus template <typename M> struct MonadPlus; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CONCEPT_MONAD_PLUS_HPP PK �|!\�5�+ + union.hppnu �[��� /*! @file Forward declares `boost::hana::union_`. @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_UNION_HPP #define BOOST_HANA_FWD_UNION_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN // Note: This function is documented per datatype/concept only. //! @cond template <typename T, typename = void> struct union_impl : union_impl<T, when<true>> { }; //! @endcond struct union_t { template <typename Xs, typename Ys> constexpr auto operator()(Xs&&, Ys&&) const; }; constexpr union_t union_{}; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_UNION_HPP PK �|!\Zi��Y Y ap.hppnu �[��� /*! @file Forward declares `boost::hana::ap`. @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_AP_HPP #define BOOST_HANA_FWD_AP_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Lifted application. //! @ingroup group-Applicative //! //! Specifically, `ap` applies a structure containing functions to a //! structure containing values, and returns a new structure containing //! values. The exact way in which the functions are applied to the values //! depends on the `Applicative`. //! //! `ap` can be called with two arguments or more; the functions in the `f` //! structure are curried and then applied to the values in each `x...` //! structure using the binary form of `ap`. Note that this requires the //! number of `x...` must match the arity of the functions in the `f` //! structure. In other words, `ap(f, x1, ..., xN)` is equivalent to //! @code //! ((curry(f) ap x1) ap x2) ... ap xN //! @endcode //! where `x ap y` is just `ap(x, y)` written in infix notation to //! emphasize the left associativity. //! //! //! Signature //! --------- //! Given an Applicative `A`, the signature is //! @f$ \mathtt{ap} : A(T_1 \times \cdots \times T_n \to U) //! \times A(T_1) \times \cdots \times A(T_n) //! \to A(U) @f$. //! //! @param f //! A structure containing function(s). //! //! @param x... //! Structure(s) containing value(s) and on which `f` is applied. The //! number of structures must match the arity of the functions in the //! `f` structure. //! //! //! Example //! ------- //! @include example/ap.cpp //! //! @todo //! Consider giving access to all the arguments to the tag-dispatched //! implementation for performance purposes. #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto ap = [](auto&& f, auto&& ...x) -> decltype(auto) { return tag-dispatched; }; #else template <typename A, typename = void> struct ap_impl : ap_impl<A, when<true>> { }; struct ap_t { template <typename F, typename X> constexpr decltype(auto) operator()(F&& f, X&& x) const; template <typename F, typename ...Xs> constexpr decltype(auto) operator()(F&& f, Xs&& ...xs) const; }; constexpr ap_t ap{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_AP_HPP PK �|!\D�ێ� � less_equal.hppnu �[��� /*! @file Forward declares `boost::hana::less_equal`. @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_LESS_EQUAL_HPP #define BOOST_HANA_FWD_LESS_EQUAL_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> #include <boost/hana/detail/nested_than_fwd.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns a `Logical` representing whether `x` is less than or //! equal to `y`. //! @ingroup group-Orderable //! //! //! Signature //! --------- //! Given a Logical `Bool` and two Orderables `A` and `B` with a common //! embedding, the signature is //! @f$ \mathrm{less\_equal} : A \times B \to Bool @f$. //! //! @param x, y //! Two objects to compare. //! //! //! Example //! ------- //! @include example/less_equal.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto less_equal = [](auto&& x, auto&& y) { return tag-dispatched; }; #else template <typename T, typename U, typename = void> struct less_equal_impl : less_equal_impl<T, U, when<true>> { }; struct less_equal_t : detail::nested_than<less_equal_t> { template <typename X, typename Y> constexpr auto operator()(X&& x, Y&& y) const; }; constexpr less_equal_t less_equal{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_LESS_EQUAL_HPP PK �|!\)^WT T core/make.hppnu �[��� /*! @file Forward declares `boost::hana::make`. @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_CORE_MAKE_HPP #define BOOST_HANA_FWD_CORE_MAKE_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-core //! Create an object of the given tag with the given arguments. //! //! This function serves the same purpose as constructors in usual C++. //! However, instead of creating an object of a specific C++ type, it //! creates an object of a specific tag, regardless of the C++ type //! of that object. //! //! This function is actually a variable template, so `make<T>` can be //! passed around as a function object creating an object of tag `T`. //! Also, it uses tag-dispatching so this is how it should be customized //! for user-defined tags. //! //! Finally, the default implementation of `make` is equivalent to calling //! the constructor of the given tag with the corresponding arguments. //! In other words, by default, //! @code //! make<T>(args...) == T(args...) //! @endcode //! //! Note that the arguments are perfectly forwarded and the form of //! construction which is used is exactly as documented, i.e. `T(args...)`. //! However, if `T(args...)` is not a valid expression, a compilation //! error is triggered. This default behavior is useful because it makes //! foreign C++ types that have no notion of tag constructible with `make` //! out-of-the-box, since their tag is exactly themselves. //! //! //! Example //! ------- //! @include example/core/make.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename Tag> constexpr auto make = [](auto&& ...x) -> decltype(auto) { return tag-dispatched; }; #else template <typename Tag, typename = void> struct make_impl; template <typename Tag> struct make_t { template <typename ...X> constexpr decltype(auto) operator()(X&& ...x) const { return make_impl<Tag>::apply(static_cast<X&&>(x)...); } }; template <typename Tag> constexpr make_t<Tag> make{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CORE_MAKE_HPP PK �|!\�$ � � core/when.hppnu �[��� /*! @file Forward declares `boost::hana::when` and `boost::hana::when_valid`. @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_CORE_WHEN_HPP #define BOOST_HANA_FWD_CORE_WHEN_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-core //! Enable a partial specialization only if a boolean condition is true. //! //! You might also want to take a look at `when_valid`, which provides //! similar functionality but enables a specialziation only when some //! expression is well-formed. //! //! > #### Rationale for using `when` instead of `std::enable_if` //! > `when` is used to control the priority of partial specializations //! > in a finer grained manner than what can be achieved with the usual //! > `typename Enable = void` and `std::enable_if` pattern. For example, //! > a partially specialized tag-dispatched method will have a higher //! > priority than an equivalent specialization that uses `when`. For //! > more details, see the tutorial section on [tag-dispatching][1]. //! //! //! Example //! ------- //! @include example/core/when.cpp //! //! [1]: @ref tutorial-core-tag_dispatching template <bool condition> struct when; namespace core_detail { template <typename ...> struct always_true { static constexpr bool value = true; }; } //! @ingroup group-core //! Variant of `when` allowing specializations to be enabled only if an //! expression is well-formed. //! //! `when_valid<...>` is always equivalent to `when<true>`. However, when //! used inside a partial specialization, SFINAE will cause the partial //! specialization to be ignored when the expression is ill-formed. //! //! //! Example //! ------- //! @include example/core/when_valid.cpp //! //! //! @bug //! Using `when_valid` seems to trigger ambiguous partial specializations //! on GCC. #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename ...> using when_valid = when<true>; #else template <typename ...Dummy> using when_valid = when< core_detail::always_true<Dummy...>::value >; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CORE_WHEN_HPP PK �|!\W�\�B B core/is_a.hppnu �[��� /*! @file Forward declares `boost::hana::is_a` and `boost::hana::is_an`. @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_CORE_IS_A_HPP #define BOOST_HANA_FWD_CORE_IS_A_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-core //! Returns whether the tag of an object matches a given tag. //! //! Given a tag `Tag` and a C++ type `T`, `is_a<Tag, T>` is a compile-time //! Logical representing whether the tag of `T` is exactly `Tag`. In other //! words, it is equivalent to //! @code //! std::is_same<Tag, tag_of<T>::type> //! @endcode //! //! For convenience, an alternate syntax is provided for using `is_a`. //! Specifically, `is_a<Tag>` is a function object returning whether the //! argument it is passed has the given tag. In other words, //! @code //! is_a<Tag>(x) == is_a<Tag, decltype(x)> //! @endcode //! //! //! Example //! ------- //! @include example/core/is_a.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename Tag, typename optional_T> constexpr auto is_a = see-documentation; #else template <typename Tag, typename ...T> struct is_a_t; template <typename Tag, typename ...T> constexpr is_a_t<Tag, T...> is_a{}; #endif //! @ingroup group-core //! Equivalent to `is_a`; provided for consistency with the rules of the //! English language. #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename Tag, typename ...T> constexpr auto is_an = is_a<Tag, T...>; #else template <typename Tag, typename ...T> constexpr is_a_t<Tag, T...> is_an{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CORE_IS_A_HPP PK �|!\ ���G G core/default.hppnu �[��� /*! @file Forward declares `boost::hana::default_` and `boost::hana::is_default`. @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_CORE_DEFAULT_HPP #define BOOST_HANA_FWD_CORE_DEFAULT_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-core //! Mark a tag-dispatched method implementation as a default implementation. //! //! When defining a new concept with tag-dispatched methods, it is //! sometimes possible to provide a default implementation for some //! method(s). Making `default_` a base class of such a default //! implementation makes it possible to detect whether the method //! was dispatched to the default implementation afterwards. //! //! //! Example //! ------- //! @include example/core/default.cpp struct default_ { }; //! @ingroup group-core //! Returns whether a tag-dispatched method implementation is a default //! implementation. //! //! Given a tag-dispatched method implementation `method_impl<T...>`, //! `is_default<method_impl<T...>>` returns whether `method_impl<T...>` //! is a default implementation. Note that if there is no default //! implementation for the method, then `is_default` should not be //! used unless a static assertion saying that "the method is not //! implemented" is acceptable. //! //! //! Example //! ------- //! @include example/core/default.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename Method> struct is_default { see documentation }; #else template <typename T, typename = void> struct is_default; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CORE_DEFAULT_HPP PK �|!\c1%� � core/tag_of.hppnu �[��� /*! @file Forward declares `boost::hana::tag_of` and `boost::hana::tag_of_t`. @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_CORE_TAG_OF_HPP #define BOOST_HANA_FWD_CORE_TAG_OF_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-core //! %Metafunction returning the tag associated to `T`. //! //! There are several ways to specify the tag of a C++ type. If it's a //! user-defined type, one can define a nested `hana_tag` alias: //! @code //! struct MyUserDefinedType { //! using hana_tag = MyTag; //! }; //! @endcode //! //! Sometimes, however, the C++ type can't be modified (if it's in a //! foreign library) or simply can't have nested types (if it's not a //! struct or class). In those cases, using a nested alias is impossible //! and so ad-hoc customization is also supported by specializing //! `tag_of` in the `boost::hana` namespace: //! @code //! struct i_cant_modify_this; //! //! namespace boost { namespace hana { //! template <> //! struct tag_of<i_cant_modify_this> { //! using type = MyTag; //! }; //! }} //! @endcode //! //! `tag_of` can also be specialized for all C++ types satisfying some //! boolean condition using `when`. `when` accepts a single compile-time //! boolean and enables the specialization of `tag_of` if and only if //! that boolean is `true`. This is similar to the well known C++ idiom //! of using a dummy template parameter with `std::enable_if` and relying //! on SFINAE. For example, we could specify the tag of all //! `fusion::vector`s by doing: //! @code //! struct BoostFusionVector; //! //! namespace boost { namespace hana { //! template <typename T> //! struct tag_of<T, when< //! std::is_same< //! typename fusion::traits::tag_of<T>::type, //! fusion::traits::tag_of<fusion::vector<>>::type //! >::value //! >> { //! using type = BoostFusionVector; //! }; //! }} //! @endcode //! //! Also, when it is not specialized and when the given C++ type does not //! have a nested `hana_tag` alias, `tag_of<T>` returns `T` itself. This //! makes tags a simple extension of normal C++ types. This is _super_ //! useful, mainly for two reasons. First, this allows Hana to adopt a //! reasonable default behavior for some operations involving types that //! have no notion of tags. For example, Hana allows comparing with `equal` //! any two objects for which a valid `operator==` is defined, and that //! without any work on the user side. Second, it also means that you can //! ignore tags completely if you don't need their functionality; just use //! the normal C++ type of your objects and everything will "just work". //! //! Finally, also note that `tag_of<T>` is always equivalent to `tag_of<U>`, //! where `U` is the type `T` after being stripped of all references and //! cv-qualifiers. This makes it unnecessary to specialize `tag_of` for //! all reference and cv combinations, which would be a real pain. Also, //! `tag_of` is required to be idempotent. In other words, it must always //! be the case that `tag_of<tag_of<T>::%type>::%type` is equivalent to //! `tag_of<T>::%type`. //! //! > __Tip 1__\n //! > If compile-time performance is a serious concern, consider //! > specializing the `tag_of` metafunction in Hana's namespace. //! > When unspecialized, the metafunction has to use SFINAE, which //! > tends to incur a larger compile-time overhead. For heavily used //! > templated types, this can potentially make a difference. //! //! > __Tip 2__\n //! > Consider using `tag_of_t` alias instead of `tag_of`, which //! > reduces the amount of typing in dependent contexts. //! //! //! Example //! ------- //! @include example/core/tag_of.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename T, optional when-based enabler> struct tag_of { unspecified }; #else template <typename T, typename = void> struct tag_of; #endif //! @ingroup group-core //! Alias to `tag_of<T>::%type`, provided for convenience. //! //! //! Example //! ------- //! @include example/core/tag_of_t.cpp template <typename T> using tag_of_t = typename hana::tag_of<T>::type; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CORE_TAG_OF_HPP PK �|!\�b��_ _ core/to.hppnu �[��� /*! @file Forward declares `boost::hana::to` and related utilities. @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_CORE_TO_HPP #define BOOST_HANA_FWD_CORE_TO_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-core //! Converts an object from one data type to another. //! //! `to` is a natural extension of the `static_cast` language construct to //! data types. Given a destination data type `To` and an object `x`, `to` //! creates a new object of data type `To` from `x`. Note, however, that //! `to` is not required to actually create a new object, and may return a //! reference to the original object (for example when trying to convert //! an object to its own data type). //! //! As a natural extension to `static_cast`, `to` provides a default //! behavior. For the purpose of what follows, let `To` be the destination //! data type and `From` be the data type of `x`, i.e. the source data type. //! Then, `to` has the following default behavior: //! 1. If the `To` and `From` data types are the same, then the object //! is forwarded as-is. //! 2. Otherwise, if `From` is convertible to `To` using `static_cast`, //! `x` is converted to `From` using `static_cast`. //! 3. Otherwise, calling `to<From>(x)` triggers a static assertion. //! //! However, `to` is a tag-dispatched function, which means that `to_impl` //! may be specialized in the `boost::hana` namespace to customize its //! behavior for arbitrary data types. Also note that `to` is tag-dispatched //! using both the `To` and the `From` data types, which means that `to_impl` //! is called as `to_impl<To, From>::%apply(x)`. Also note that some //! concepts provide conversions to or from their models. For example, //! any `Foldable` may be converted into a `Sequence`. This is achieved //! by specializing `to_impl<To, From>` whenever `To` is a `Sequence` and //! `From` is a `Foldable`. When such conversions are provided, they are //! documented in the source concept, in this case `Foldable`. //! //! //! Hana-convertibility //! ------------------- //! When an object `x` of data type `From` can be converted to a data type //! `To` using `to`, we say that `x` is Hana-convertible to the data type //! `To`. We also say that there is a Hana-conversion from `From` to `To`. //! This bit of terminology is useful to avoid mistaking the various kinds //! of conversions C++ offers. //! //! //! Embeddings //! ---------- //! As you might have seen by now, Hana uses algebraic and category- //! theoretical structures all around the place to help specify concepts //! in a rigorous way. These structures always have operations associated //! to them, which is why they are useful. The notion of embedding captures //! the idea of injecting a smaller structure into a larger one while //! preserving the operations of the structure. In other words, an //! embedding is an injective mapping that is also structure-preserving. //! Exactly what it means for a structure's operations to be preserved is //! left to explain by the documentation of each structure. For example, //! when we talk of a Monoid-embedding from a Monoid `A` to a Monoid `B`, //! we simply mean an injective transformation that preserves the identity //! and the associative operation, as documented in `Monoid`. //! //! But what does this have to do with the `to` function? Quite simply, //! the `to` function is a mapping between two data types, which will //! sometimes be some kind of structure, and it is sometimes useful to //! know whether such a mapping is well-behaved, i.e. lossless and //! structure preserving. The criterion for this conversion to be well- //! behaved is exactly that of being an embedding. To specify that a //! conversion is an embedding, simply use the `embedding` type as a //! base class of the corresponding `to_impl` specialization. Obviously, //! you should make sure the conversion is really an embedding, unless //! you want to shoot yourself in the foot. //! //! //! @tparam To //! The data type to which `x` should be converted. //! //! @param x //! The object to convert to the given data type. //! //! //! Example //! ------- //! @include example/core/convert/to.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename To> constexpr auto to = [](auto&& x) -> decltype(auto) { return tag-dispatched; }; #else template <typename To, typename From, typename = void> struct to_impl; template <typename To> struct to_t { template <typename X> constexpr decltype(auto) operator()(X&& x) const; }; template <typename To> constexpr to_t<To> to{}; #endif //! @ingroup group-core //! Returns whether there is a Hana-conversion from a data type to another. //! //! Specifically, `is_convertible<From, To>` is whether calling `to<To>` //! with an object of data type `From` would _not_ trigger a static //! assertion. //! //! //! Example //! ------- //! @include example/core/convert/is_convertible.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename From, typename To> struct is_convertible { see documentation }; #else template <typename From, typename To, typename = void> struct is_convertible; #endif //! @ingroup group-core //! Marks a conversion between data types as being an embedding. //! //! To mark a conversion between two data types `To` and `From` as //! an embedding, simply use `embedding<true>` (or simply `embedding<>`) //! as a base class of the corresponding `to_impl` specialization. //! If a `to_impl` specialization does not inherit `embedding<true>` //! or `embedding<>`, then it is not considered an embedding by the //! `is_embedded` metafunction. //! //! > #### Tip //! > The boolean template parameter is useful for marking a conversion //! > as an embedding only when some condition is satisfied. //! //! //! Example //! ------- //! @include example/core/convert/embedding.cpp template <bool = true> struct embedding { }; //! @ingroup group-core //! Returns whether a data type can be embedded into another data type. //! //! Given two data types `To` and `From`, `is_embedded<From, To>` returns //! whether `From` is convertible to `To`, and whether that conversion is //! also an embedding, as signaled by the `embedding` type. //! //! //! Example //! ------- //! @include example/core/convert/is_embedded.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename From, typename To> struct is_embedded { see documentation }; #else template <typename From, typename To, typename = void> struct is_embedded; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CORE_TO_HPP PK �|!\�T� � � core/common.hppnu �[��� /*! @file Forward declares `boost::hana::common` and `boost::hana::common_t`. @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_CORE_COMMON_HPP #define BOOST_HANA_FWD_CORE_COMMON_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! @ingroup group-core //! %Metafunction returning the common data type between two data types. //! //! `common` is a natural extension of the `std::common_type` metafunction //! to data types. Given two data types `T` and `U`, we say that they share //! a common type `C` if both objects of data type `T` and objects of data //! type `U` may be converted (using `to`) to an object of data type `C`, //! and if that conversion is equality preserving. In other words, this //! means that for any objects `t1, t2` of data type `T` and `u1, u2` of //! data type `U`, the following law is satisfied: //! @code //! to<C>(t1) == to<C>(t2) if and only if t1 == t2 //! to<C>(u1) == to<C>(u2) if and only if u1 == u2 //! @endcode //! //! The role of `common` is to provide an alias to such a `C` if it exists. //! In other words, if `T` and `U` have a common data type `C`, //! `common<T, U>::%type` is an alias to `C`. Otherwise, `common<T, U>` //! has no nested `type` and can be used in dependent contexts to exploit //! SFINAE. By default, the exact steps followed by `common` to determine //! the common type `C` of `T` and `U` are //! 1. If `T` and `U` are the same, then `C` is `T`. //! 2. Otherwise, if `true ? std::declval<T>() : std::declval<U>()` is //! well-formed, then `C` is the type of this expression after using //! `std::decay` on it. This is exactly the type that would have been //! returned by `std::common_type`, except that custom specializations //! of `std::common_type` are not taken into account. //! 3. Otherwise, no common data type is detected and `common<T, U>` does //! not have a nested `type` alias, unless it is specialized explicitly. //! //! As point 3 suggests, it is also possible (and sometimes necessary) to //! specialize `common` in the `boost::hana` namespace for pairs of custom //! data types when the default behavior of `common` is not sufficient. //! Note that `when`-based specialization is supported when specializing //! `common` in the `boost::hana` namespace. //! //! > #### Rationale for requiring the conversion to be equality-preserving //! > This decision is aligned with a proposed concept design for the //! > standard library ([N3351][1]). Also, if we did not require this, //! > then all data types would trivially share the common data type //! > `void`, since all objects can be converted to it. //! //! //! Example //! ------- //! @include example/core/common/common.cpp //! //! //! [1]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3351.pdf #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename T, typename U, optional when-based enabler> struct common { see documentation }; #else template <typename T, typename U, typename = void> struct common; #endif //! @ingroup group-core //! %Metafunction returning whether two data types share a common data type. //! //! Given two data types `T` and `U`, this metafunction simply returns //! whether `common<T, U>::%type` is well-formed. //! //! //! Example //! ------- //! @include example/core/common/has_common.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename T, typename U> struct has_common { whether common<T, U>::type is well-formed }; #else template <typename T, typename U, typename = void> struct has_common; #endif //! @ingroup group-core //! Alias to `common<T, U>::%type`, provided for convenience. //! //! //! Example //! ------- //! @include example/core/common/common_t.cpp template <typename T, typename U> using common_t = typename common<T, U>::type; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_CORE_COMMON_HPP PK �|!\��= = replace_if.hppnu �[��� /*! @file Forward declares `boost::hana::replace_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_REPLACE_IF_HPP #define BOOST_HANA_FWD_REPLACE_IF_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Replace all the elements of a structure satisfying a `predicate` //! with a fixed value. //! @ingroup group-Functor //! //! //! Signature //! --------- //! Given `F` a Functor and `Bool` a Logical, the signature is //! \f$ //! \mathtt{replace\_if} : F(T) \times (T \to Bool) \times T \to F(T) //! \f$ //! //! @param xs //! The structure to replace elements of. //! //! @param predicate //! A function called as `predicate(x)` for element(s) `x` of the //! structure and returning a `Logical` representing whether `x` //! should be replaced by `value`. //! //! @param value //! A value by which every element `x` of the structure for which //! `predicate` returns a true-valued `Logical` is replaced. //! //! //! Example //! ------- //! @include example/replace_if.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto replace_if = [](auto&& xs, auto&& predicate, auto&& value) { return tag-dispatched; }; #else template <typename Xs, typename = void> struct replace_if_impl : replace_if_impl<Xs, when<true>> { }; struct replace_if_t { template <typename Xs, typename Pred, typename Value> constexpr auto operator()(Xs&& xs, Pred&& pred, Value&& value) const; }; constexpr replace_if_t replace_if{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_REPLACE_IF_HPP PK �|!\8�~� � comparing.hppnu �[��� /*! @file Forward declares `boost::hana::comparing`. @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_COMPARING_HPP #define BOOST_HANA_FWD_COMPARING_HPP #include <boost/hana/config.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns a function performing `equal` after applying a transformation //! to both arguments. //! @ingroup group-Comparable //! //! `comparing` creates an equivalence relation based on the result of //! applying a function to some objects, which is especially useful in //! conjunction with algorithms that accept a custom predicate that must //! represent an equivalence relation. //! //! Specifically, `comparing` is such that //! @code //! comparing(f) == equal ^on^ f //! @endcode //! or, equivalently, //! @code //! comparing(f)(x, y) == equal(f(x), f(y)) //! @endcode //! //! @note //! This is not a tag-dispatched method (hence it can't be customized), //! but just a convenience function provided with the `Comparable` concept. //! //! //! Signature //! --------- //! Given a Logical `Bool` and a Comparable `B`, the signature is //! @f$ \mathtt{comparing} : (A \to B) \to (A \times A \to Bool) @f$. //! //! //! Example //! ------- //! @include example/comparing.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto comparing = [](auto&& f) { return [perfect-capture](auto&& x, auto&& y) { return equal(f(forwarded(x)), f(forwarded(y))); }; }; #else struct comparing_t { template <typename F> constexpr auto operator()(F&& f) const; }; constexpr comparing_t comparing{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_COMPARING_HPP PK �|!\�3�U5 5 eval_if.hppnu �[��� /*! @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 PK �|!\{!V V difference.hppnu �[��� /*! @file Forward declares `boost::hana::difference`. @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_DIFFERENCE_HPP #define BOOST_HANA_FWD_DIFFERENCE_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN // Note: This function is documented per datatype/concept only. //! @cond template <typename S, typename = void> struct difference_impl : difference_impl<S, when<true>> { }; //! @endcond struct difference_t { template <typename Xs, typename Ys> constexpr auto operator()(Xs&&, Ys&&) const; }; constexpr difference_t difference{}; BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_DIFFERENCE_HPP PK �|!\�Hy� � lift.hppnu �[��� /*! @file Forward declares `boost::hana::lift`. @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_LIFT_HPP #define BOOST_HANA_FWD_LIFT_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Lift a value into an `Applicative` structure. //! @ingroup group-Applicative //! //! `lift<A>` takes a normal value and embeds it into a structure whose //! shape is represented by the `A` `Applicative`. Note that the value //! may be a function, in which case the created structure may be //! `ap`plied to another `Applicative` structure containing values. //! //! //! Signature //! --------- //! Given an Applicative `A`, the signature is //! @f$ \mathtt{lift}_A : T \to A(T) @f$. //! //! @tparam A //! A tag representing the `Applicative` into which the value is lifted. //! //! @param x //! The value to lift into the applicative. //! //! //! Example //! ------- //! @include example/lift.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED template <typename A> constexpr auto lift = [](auto&& x) { return tag-dispatched; }; #else template <typename A, typename = void> struct lift_impl : lift_impl<A, when<true>> { }; template <typename A> struct lift_t { template <typename X> constexpr auto operator()(X&& x) const; }; template <typename A> constexpr lift_t<A> lift{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_LIFT_HPP PK �|!\���� � then.hppnu �[��� /*! @file Forward declares `boost::hana::then`. @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_THEN_HPP #define BOOST_HANA_FWD_THEN_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Sequentially compose two monadic actions, discarding any value //! produced by the first but not its effects. //! @ingroup group-Monad //! //! //! @param before //! The first `Monad` in the monadic composition chain. The result of //! this monad is ignored, but its effects are combined with that of the //! second monad. //! //! @param xs //! The second `Monad` in the monadic composition chain. //! //! //! Example //! ------- //! @include example/then.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto then = [](auto&& before, auto&& xs) -> decltype(auto) { return tag-dispatched; }; #else template <typename M, typename = void> struct then_impl : then_impl<M, when<true>> { }; struct then_t { template <typename Before, typename Xs> constexpr decltype(auto) operator()(Before&& before, Xs&& xs) const; }; constexpr then_t then{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_THEN_HPP PK �|!\��� � plus.hppnu �[��� /*! @file Forward declares `boost::hana::plus`. @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_PLUS_HPP #define BOOST_HANA_FWD_PLUS_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Associative binary operation on a `Monoid`. //! @ingroup group-Monoid //! //! @param x, y //! Two objects to combine with the `Monoid`'s binary operation. //! //! //! Cross-type version of the method //! -------------------------------- //! The `plus` method is "overloaded" to handle distinct data types //! with certain properties. Specifically, `plus` is defined for //! _distinct_ data types `A` and `B` such that //! 1. `A` and `B` share a common data type `C`, as determined by the //! `common` metafunction //! 2. `A`, `B` and `C` are all `Monoid`s when taken individually //! 3. `to<C> : A -> B` and `to<C> : B -> C` are `Monoid`-embeddings, as //! determined by the `is_embedding` metafunction. //! //! The definition of `plus` for data types satisfying the above //! properties is obtained by setting //! @code //! plus(x, y) = plus(to<C>(x), to<C>(y)) //! @endcode //! //! //! Example //! ------- //! @include example/plus.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto plus = [](auto&& x, auto&& y) -> decltype(auto) { return tag-dispatched; }; #else template <typename T, typename U, typename = void> struct plus_impl : plus_impl<T, U, when<true>> { }; struct plus_t { template <typename X, typename Y> constexpr decltype(auto) operator()(X&& x, Y&& y) const; }; constexpr plus_t plus{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_PLUS_HPP PK �|!\�� њ � any.hppnu �[��� /*! @file Forward declares `boost::hana::any`. @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_ANY_HPP #define BOOST_HANA_FWD_ANY_HPP #include <boost/hana/config.hpp> #include <boost/hana/core/when.hpp> BOOST_HANA_NAMESPACE_BEGIN //! Returns whether any key of the structure is true-valued. //! @ingroup group-Searchable //! //! The keys of the structure must be `Logical`s. If the structure is not //! finite, a true-valued key must appear at a finite "index" in order for //! this method to finish. //! //! //! Example //! ------- //! @include example/any.cpp #ifdef BOOST_HANA_DOXYGEN_INVOKED constexpr auto any = [](auto&& xs) { return tag-dispatched; }; #else template <typename S, typename = void> struct any_impl : any_impl<S, when<true>> { }; struct any_t { template <typename Xs> constexpr auto operator()(Xs&& xs) const; }; constexpr any_t any{}; #endif BOOST_HANA_NAMESPACE_END #endif // !BOOST_HANA_FWD_ANY_HPP PK �|!\#tX X repeat.hppnu �[��� PK �|!\VTn�b b � count_if.hppnu �[��� PK �|!\+� 0 group.hppnu �[��� PK �|!\��cy y � front.hppnu �[��� PK �|!\�'BF� � ;" scan_right.hppnu �[��� PK �|!\C�#?2 2 \1 adapt_struct.hppnu �[��� PK �|!\�:, , �7 fuse.hppnu �[��� PK �|!\,f5ۥ � 2> any_of.hppnu �[��� PK �|!\"��2� � D lazy.hppnu �[��� PK �|!\Ud;k k :V core.hppnu �[��� PK �|!\;���� � �X unfold_left.hppnu �[��� PK �|!\�pd\ \ c one.hppnu �[��� PK �|!\3ooϰ � �g monadic_fold_left.hppnu �[��� PK �|!\?��� � �w zip_with.hppnu �[��� PK �|!\?�h� � � append.hppnu �[��� PK �|!\!^m�� � � flatten.hppnu �[��� PK �|!\� >� � �� fill.hppnu �[��� PK �|!\���h h �� intersection.hppnu �[��� PK �|!\ `� empty.hppnu �[��� PK �|!\�5�� � �� min.hppnu �[��� PK �|!\��qӷ � ߣ integral_constant.hppnu �[��� PK �|!\�S��� � ۶ transform.hppnu �[��� PK �|!\��_/� � Ӽ replicate.hppnu �[��� PK �|!\s��h h �� range.hppnu �[��� PK �|!\��ɀ � �� scan_left.hppnu �[��� PK �|!\ �� � =� none.hppnu �[��� PK �|!\� X� � 6� find_if.hppnu �[��� PK �|!\� ��6 6 7� index_if.hppnu �[��� PK �|!\&��G� � �� take_while.hppnu �[��� PK �|!\�m~< < � adapt_adt.hppnu �[��� PK �|!\7oqdI dI � optional.hppnu �[��� PK �|!\m� �U at_key.hppnu �[��� PK �|!\c�ӑi i �^ drop_front_exactly.hppnu �[��� PK �|!\4?֎� � �h symmetric_difference.hppnu �[��� PK �|!\T�d�M �M �l type.hppnu �[��� PK �|!\��h� � [� bool.hppnu �[��� PK �|!\�8��� � � or.hppnu �[��� PK �|!\��I � permutations.hppnu �[��� PK �|!\> 6� greater_equal.hppnu �[��� PK �|!\]��y� � �� all.hppnu �[��� PK �|!\\g�� � j� greater.hppnu �[��� PK �|!\�q3�� � ]� extend.hppnu �[��� PK �|!\�T?� � \� all_of.hppnu �[��� PK �|!\'}-- - Z� cartesian_product.hppnu �[��� PK �|!\\��� � �� while.hppnu �[��� PK �|!\U�:j� � �� minimum.hppnu �[��� PK �|!\� �� � � chain.hppnu �[��� PK �|!\ �?� � � remove.hppnu �[��� PK �|!\���0� � N partition.hppnu �[��� PK �|!\�d�** ** 6$ string.hppnu �[��� PK �|!\R���� � �N find.hppnu �[��� PK �|!\��i�~ ~ �U max.hppnu �[��� PK �|!\]�eW W yZ value.hppnu �[��� PK �|!\�X� � g mult.hppnu �[��� PK �|!\&�?� � �n insert.hppnu �[��� PK �|!\�(pN N �u monadic_fold_right.hppnu �[��� PK �|!\� 2 2 ;� replace.hppnu �[��� PK �|!\�?t}( ( �� filter.hppnu �[��� PK �|!\U�)t. . � define_struct.hppnu �[��� PK �|!\@��� � y� negate.hppnu �[��� PK �|!\��H�* * �� fold.hppnu �[��� PK �|!\D*�� � � slice.hppnu �[��� PK �|!\��}#� � � monadic_compose.hppnu �[��� PK �|!\?��j� � K� mod.hppnu �[��� PK �|!\˗!#s s 4� if.hppnu �[��� PK �|!\��h�s s �� zip_shortest_with.hppnu �[��� PK �|!\tVz�� � �� size.hppnu �[��� PK �|!\+A�gC C n� remove_at.hppnu �[��� PK �|!\ ��n n �� ordering.hppnu �[��� PK �|!\A�%ߵ � �� sum.hppnu �[��� PK �|!\b�H� � �� first.hppnu �[��� PK �|!\��q� � {� is_disjoint.hppnu �[��� PK �|!\�"�k k _ remove_if.hppnu �[��� PK �|!\� ��y y fold_right.hppnu �[��� PK �|!\G�/ � � � accessors.hppnu �[��� PK �|!\_�B�� � � drop_back.hppnu �[��� PK �|!\�{�j� � ' unpack.hppnu �[��� PK �|!\�q!�� � )5 insert_range.hppnu �[��� PK �|!\��M� [< unfold_right.hppnu �[��� PK �|!\��O[� � �F lexicographical_compare.hppnu �[��� PK �|!\�� �U power.hppnu �[��� PK �|!\�O;5 5 +\ minus.hppnu �[��� PK �|!\E E\�& �& �d set.hppnu �[��� PK �|!\vh5�V3 V3 ͋ map.hppnu �[��� PK �|!\A��U� � Z� div.hppnu �[��� PK �|!\}���n n }� hash.hppnu �[��� PK �|!\��}c� � #� take_front.hppnu �[��� PK �|!\ ��Q! ! � suffix.hppnu �[��� PK �|!\��� � s� eval.hppnu �[��� PK �|!\<*��* * �� span.hppnu �[��� PK �|!\C� H1 1 �� prefix.hppnu �[��� PK �|!\^We� � T� drop_front.hppnu �[��� PK �|!\�Dӣ � n reverse.hppnu �[��� PK �|!\��T�� � L basic_tuple.hppnu �[��� PK �|!\.b��l l erase_key.hppnu �[��� PK �|!\H���� � ( members.hppnu �[��� PK �|!\#�!�~ ~ K zip.hppnu �[��� PK �|!\�D�� � $ fold_left.hppnu �[��� PK �|!\�P�oK K �/ back.hppnu �[��� PK �|!\ � ?� � |5 is_empty.hppnu �[��� PK �|!\ ?�%C C e; not_equal.hppnu �[��� PK �|!\˩W� � �C is_subset.hppnu �[��� PK �|!\ ZY>G G O zero.hppnu �[��� PK �|!\P��,o o �S prepend.hppnu �[��� PK �|!\�i݈ � ;] pair.hppnu �[��� PK �|!\�yݬ� � �s maximum.hppnu �[��� PK �|!\ Z&� � .� drop_while.hppnu �[��� PK �|!\���+� � k� adjust.hppnu �[��� PK �|!\�-�� � �� cycle.hppnu �[��� PK �|!\��o� � u� second.hppnu �[��� PK �|!\ ��2� � t� for_each.hppnu �[��� PK �|!\�;OKj! j! �� tuple.hppnu �[��� PK �|!\KZ�� <� extract.hppnu �[��� PK �|!\�1�� � �� and.hppnu �[��� PK �|!\���. . Z� concat.hppnu �[��� PK �|!\ؙQΓ � �� count.hppnu �[��� PK �|!\��6�� � �� length.hppnu �[��� PK �|!\D�F� O� at.hppnu �[��� PK �|!\�Ӏ�� � �� adjust_if.hppnu �[��� PK �|!\�Ⓥ� � � zip_shortest.hppnu �[��� PK �|!\ �SW � equal.hppnu �[��� PK �|!\�V�J� � 5 not.hppnu �[��� PK �|!\�_6� � 0 none_of.hppnu �[��� PK �|!\;��L L E product.hppnu �[��� PK �|!\S(��� � �( intersperse.hppnu �[��� PK �|!\2�� �/ unique.hppnu �[��� PK �|!\ ( : : B= keys.hppnu �[��� PK �|!\a��& & �B duplicate.hppnu �[��� PK �|!\& �� � I sort.hppnu �[��� PK �|!\42��� � X take_back.hppnu �[��� PK �|!\����F F �` reverse_fold.hppnu �[��� PK �|!\Q��r r Nl less.hppnu �[��� PK �|!\�� � �q tap.hppnu �[��� PK �|!\d��-� � �z remove_range.hppnu �[��� PK �|!\k�oJ J �� contains.hppnu �[��� PK �|!\QP?� � 5� concept/group.hppnu �[��� PK �|!\�J�J J � concept/integral_constant.hppnu �[��� PK �|!\л�K� � �� concept/foldable.hppnu �[��� PK �|!\�q� t� concept/logical.hppnu �[��� PK �|!\b�#l< < �� concept/searchable.hppnu �[��� PK �|!\��� � >� concept/comonad.hppnu �[��� PK �|!\�{�� � # concept/hashable.hppnu �[��� PK �|!\%t��`$ `$ ^ concept/monad.hppnu �[��� PK �|!\Xx=_ _ �5 concept/iterable.hppnu �[��� PK �|!\u��*�' �' �O concept/constant.hppnu �[��� PK �|!\��1�� � �w concept/sequence.hppnu �[��� PK �|!\�k[�q q � concept/applicative.hppnu �[��� PK �|!\��"� � �� concept/functor.hppnu �[��� PK �|!\�|R�n n �� concept/struct.hppnu �[��� PK �|!\n�=�� � o� concept/comparable.hppnu �[��� PK �|!\DD�g g V� concept/euclidean_ring.hppnu �[��� PK �|!\��� concept/metafunction.hppnu �[��� PK �|!\bzy�� � Y concept/monoid.hppnu �[��� PK �|!\C Vu y. concept/orderable.hppnu �[��� PK �|!\�t��o o �L concept/product.hppnu �[��� PK �|!\�ǧ. . w\ concept/ring.hppnu �[��� PK �|!\�O��L L �k concept/monad_plus.hppnu �[��� PK �|!\�5�+ + wy union.hppnu �[��� PK �|!\Zi��Y Y �| ap.hppnu �[��� PK �|!\D�ێ� � j� less_equal.hppnu �[��� PK �|!\)^WT T }� core/make.hppnu �[��� PK �|!\�$ � � � core/when.hppnu �[��� PK �|!\W�\�B B ̠ core/is_a.hppnu �[��� PK �|!\ ���G G K� core/default.hppnu �[��� PK �|!\c1%� � ү core/tag_of.hppnu �[��� PK �|!\�b��_ _ �� core/to.hppnu �[��� PK �|!\�T� � � �� core/common.hppnu �[��� PK �|!\��= = �� replace_if.hppnu �[��� PK �|!\8�~� � � comparing.hppnu �[��� PK �|!\�3�U5 5 � eval_if.hppnu �[��� PK �|!\{!V V 4 difference.hppnu �[��� PK �|!\�Hy� � � lift.hppnu �[��� PK �|!\���� � �# then.hppnu �[��� PK �|!\��� � Z) plus.hppnu �[��� PK �|!\�� њ � *1 any.hppnu �[��� PK � � Q4 �5
| ver. 1.6 |
Github
|
.
| PHP 8.2.30 | ??????????? ?????????: 0.1 |
proxy
|
phpinfo
|
???????????