[ext/mpl] MPL vectors are not Sequences anymore

example/CMakeLists.txt

@@ -13,6 +13,7 @@ file(GLOB_RECURSE BOOST_HANA_EXAMPLES_REQUIRING_BOOST
     "ext/boost/*.cpp"
     "record.macros.cpp"
     "tutorial/type_computations.cpp"
+    "tutorial/mpl_cheatsheet.cpp"
     "mini_mpl.cpp")
 list(APPEND BOOST_HANA_FILES_REQUIRING_BOOST ${BOOST_HANA_EXAMPLES_REQUIRING_BOOST})
 

example/ext/boost/mpl/integral_c/constant.cpp → example/ext/boost/mpl/integral_c.cpp

@@ -14,11 +14,18 @@ using namespace boost::hana;
 namespace mpl = boost::mpl;
 
 
+int main() {
+
+{
+
+//! [constant]
 static_assert(value(mpl::integral_c<int, 3>{}) == 3, "");
 
 BOOST_HANA_CONSTANT_CHECK(equal(mpl::integral_c<int, 3>{}, mpl::int_<3>{}));
 BOOST_HANA_CONSTANT_CHECK(equal(mpl::integral_c<int, 3>{}, mpl::long_<3>{}));
 BOOST_HANA_CONSTANT_CHECK(not_equal(mpl::integral_c<int, 3>{}, mpl::int_<0>{}));
+//! [constant]
 
+}
 
-int main() { }
+}

example/ext/boost/mpl/vector.cpp

@@ -0,0 +1,81 @@
+/*
+@copyright Louis Dionne 2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+
+#include <boost/hana/assert.hpp>
+#include <boost/hana/ext/boost/mpl/vector.hpp>
+#include <boost/hana/ext/std/integral_constant.hpp>
+#include <boost/hana/maybe.hpp>
+#include <boost/hana/type.hpp>
+
+#include <boost/mpl/vector.hpp>
+#include <type_traits>
+using namespace boost::hana;
+namespace mpl = boost::mpl;
+
+
+int main() {
+
+{
+
+//! [comparable]
+BOOST_HANA_CONSTANT_CHECK(
+    equal(mpl::vector2<int, char>{}, mpl::vector<int, char>{})
+);
+BOOST_HANA_CONSTANT_CHECK(
+    not_equal(mpl::vector2<int, char>{}, mpl::vector<int, char, float>{})
+);
+//! [comparable]
+
+}{
+
+//! [foldable]
+auto types = mpl::vector<long, float, short, float, long, long double>{};
+auto number_of_floats = foldl(types, int_<0>, [](auto count, auto t) {
+    return if_(trait<std::is_floating_point>(t),
+        count + int_<1>,
+        count
+    );
+});
+
+BOOST_HANA_CONSTANT_CHECK(number_of_floats == int_<3>);
+//! [foldable]
+
+}{
+
+//! [iterable]
+BOOST_HANA_CONSTANT_CHECK(head(mpl::vector<int, char, void>{}) == type<int>);
+
+BOOST_HANA_CONSTANT_CHECK(equal(
+    tail(mpl::vector<int, char, void>{}),
+    mpl::vector<char, void>{}
+));
+
+BOOST_HANA_CONSTANT_CHECK(equal(
+    drop_while(mpl::vector<float, double const, int, float&>{},
+               trait<std::is_floating_point>),
+    mpl::vector<int, float&>{}
+));
+//! [iterable]
+
+}{
+
+//! [searchable]
+BOOST_HANA_CONSTANT_CHECK(
+    find(mpl::vector<int, float, char const*>{}, equal.to(type<float>))
+    ==
+    just(type<float>)
+);
+
+BOOST_HANA_CONSTANT_CHECK(
+    lookup(mpl::vector<int, float, char const*>{}, type<void>)
+    ==
+    nothing
+);
+//! [searchable]
+
+}
+
+}

include/boost/hana.hpp

@@ -101,6 +101,9 @@ namespace boost { namespace hana {
 //! @defgroup group-core Core
 //! Core utilities of the library.
 
+//! @defgroup group-ext External adapters
+//! Adapters for external libraries.
+
 //! @defgroup group-config Configuration options
 //! Configurable options to tweak the global behavior of the library.
 
@@ -789,6 +792,8 @@ the library was also intentionally kept simple, because we all love simplicity.
     This subdirectory contains the forward declaration of every concept
     and data type in the library. Basically, `boost/hana/fwd/[XXX].hpp`
     is the forward declaration for the concept or data type named `XXX`.
+    Also note that forward declarations for headers in `boost/hana/ext/`
+    are not provided.
 
   - `boost/hana/functional/`\n
     This subdirectory contains various function objects that are often useful,
@@ -858,6 +863,11 @@ The structure of the reference (available in the menu to the left) goes as
     also documents the methods tied to that data type but not to any concept,
     for example `make<Tuple>`.
 
+  - @ref group-ext\n
+    Documentation for all the adapters for external libraries. Basically, we
+    assign a data type to some objects in external libraries and we document
+    them as if they were normal data types provided by Hana.
+
   - @ref group-config\n
     Macros that can be used to tweak the global behavior of the library.
 

include/boost/hana/ext/boost/mpl/integral_c.hpp

@@ -10,15 +10,14 @@ Distributed under the Boost Software License, Version 1.0.
 #ifndef BOOST_HANA_EXT_BOOST_MPL_INTEGRAL_C_HPP
 #define BOOST_HANA_EXT_BOOST_MPL_INTEGRAL_C_HPP
 
-#include <boost/hana/fwd/ext/boost/mpl/integral_c.hpp>
-
 #include <boost/hana/comparable.hpp>
 #include <boost/hana/constant.hpp>
 #include <boost/hana/core/convert.hpp>
+#include <boost/hana/core/datatype.hpp>
 #include <boost/hana/core/is_a.hpp>
-#include <boost/hana/core/models.hpp>
 #include <boost/hana/core/when.hpp>
 #include <boost/hana/detail/std/is_integral.hpp>
+#include <boost/hana/detail/std/is_same.hpp>
 #include <boost/hana/enumerable.hpp>
 #include <boost/hana/group.hpp>
 #include <boost/hana/integral_domain.hpp>
@@ -28,9 +27,37 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/ring.hpp>
 
 #include <boost/mpl/integral_c.hpp>
+#include <boost/mpl/integral_c_tag.hpp>
 
 
 namespace boost { namespace hana {
+    namespace ext { namespace boost { namespace mpl {
+        //! @ingroup group-ext
+        //! Adapter for IntegralConstants from the Boost.MPL.
+        //!
+        //! Provided models
+        //! ---------------
+        //! 1. `Constant`\n
+        //! As Constants holding an integral type, `IntegralC`s are models
+        //! not only of Constant, but also all the other concepts that are
+        //! provided for Constants of an integral type.
+        //! @snippet example/ext/boost/mpl/integral_c.cpp constant
+        template <typename T>
+        struct IntegralC { using value_type = T; };
+    }}}
+
+    template <typename T>
+    struct datatype<T, when<
+        detail::std::is_same<
+            typename T::tag,
+            ::boost::mpl::integral_c_tag
+        >::value
+    >> {
+        using type = ext::boost::mpl::IntegralC<
+            typename datatype<typename T::value_type>::type
+        >;
+    };
+
     //////////////////////////////////////////////////////////////////////////
     // Constant
     //////////////////////////////////////////////////////////////////////////