[view] cartesian_product

  - Adds cartesian_product_view_t and cartesian_product_element_view_t
    with specializations for the following:
      - at_impl
      - is_empty_impl
      - length_impl
      - unpack_impl

Author: ricejasonf

include/boost/hana/cartesian_product.hpp

@@ -49,7 +49,7 @@ BOOST_HANA_NAMESPACE_BEGIN
         template <std::size_t ...Lengths>
         struct cartesian_product_indices {
             static constexpr std::size_t total_length() {
-                std::size_t lengths[] = {Lengths...};
+                std::size_t lengths[sizeof...(Lengths)] = {Lengths...};
                 std::size_t r = 1;
                 for (std::size_t len: lengths)
                     r *= len;
@@ -59,31 +59,85 @@ BOOST_HANA_NAMESPACE_BEGIN
             static constexpr std::size_t length = total_length();
 
             static constexpr auto indices_of(std::size_t i) {
-                constexpr std::size_t lengths[] = {Lengths...};
                 constexpr std::size_t n = sizeof...(Lengths);
+                constexpr std::size_t lengths[n] = {Lengths...};
                 detail::array<std::size_t, n> result{};
+                if (length == 0) {
+                    return result;
+                }
                 for (std::size_t j = n; j--;) {
                     result[j] = i % lengths[j];
                     i /= lengths[j];
                 }
                 return result;
             }
 
-            template <typename S, std::size_t n, std::size_t ...k, typename ...Xs>
+            template <std::size_t n, typename F, std::size_t ...k, typename ...Xs>
             static constexpr auto
-            product_element(std::index_sequence<k...>, Xs&& ...xs) {
+            product_element(std::index_sequence<k...>, F&& f, Xs&& ...xs) {
                 constexpr auto indices = indices_of(n);
-                return hana::make<S>(hana::at_c<indices[k]>(xs)...);
+                return static_cast<F&&>(f)(hana::at_c<indices[k]>(xs)...);
             }
 
-            template <typename S, std::size_t ...n, typename ...Xs>
+            template <std::size_t ...n, typename F, typename ...Xs>
             static constexpr auto
-            create_product(std::index_sequence<n...>, Xs&& ...xs) {
-                return hana::make<S>(product_element<S, n>(
-                    std::make_index_sequence<sizeof...(Xs)>{}, xs...
+            create_product(std::index_sequence<n...>, F&& f, Xs&& ...xs) {
+                return F{}(product_element<n>(
+                    std::make_index_sequence<sizeof...(Xs)>{},
+                    static_cast<F&&>(f), xs...
                 )...);
             }
         };
+
+        template <>
+        struct cartesian_product_indices<> {
+            static constexpr std::size_t total_length()
+            { return 0; }
+
+            static constexpr std::size_t length = 0;
+        };
+
+        struct make_cartesian_product_indices_helper_t {
+            template <typename ...Xs>
+            constexpr auto operator()(Xs&& ...xs) const
+                -> detail::cartesian_product_indices<
+                       decltype(hana::length(xs))::value...
+                   >
+            { return {}; }
+        };
+
+        struct make_cartesian_product_indices_t {
+            template <typename Xs>
+            constexpr auto operator()(Xs&& xs) const {
+                return hana::unpack(
+                    static_cast<Xs&&>(xs),
+                    make_cartesian_product_indices_helper_t{});
+            }
+        };
+
+        constexpr make_cartesian_product_indices_t make_cartesian_product_indices{};
+
+        template <typename F, std::size_t n>
+        struct make_cartesian_product_element_t {
+            F const& f;
+
+            constexpr auto operator()() const {
+                return f();
+            }
+
+            template <typename X1, typename ...Xs>
+            constexpr auto operator()(X1&& x1, Xs&& ...xs) const {
+                constexpr auto indices = detail::cartesian_product_indices<
+                    decltype(hana::length(x1))::value,
+                    decltype(hana::length(xs))::value...
+                >{};
+                return indices.template product_element<n>(
+                    std::make_index_sequence<sizeof...(Xs) + 1>{}, f,
+                    static_cast<X1&&>(x1),
+                    static_cast<Xs&&>(xs)...
+                );
+            }
+        };
     }
 
     // Credits: implementation adapted from http://github.com/alexk7/hel.
@@ -99,8 +153,9 @@ BOOST_HANA_NAMESPACE_BEGIN
             using indices = detail::cartesian_product_indices<
                 decltype(hana::length(xs))::value...
             >;
-            return indices::template create_product<S>(
+            return indices::template create_product(
                         std::make_index_sequence<indices::length>{},
+                        hana::make<S>,
                         static_cast<Xs&&>(xs)...);
         }
 

include/boost/hana/view.hpp

@@ -16,6 +16,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/and.hpp>
 #include <boost/hana/at.hpp>
 #include <boost/hana/bool.hpp>
+#include <boost/hana/cartesian_product.hpp>
 #include <boost/hana/config.hpp>
 #include <boost/hana/detail/algorithm.hpp>
 #include <boost/hana/detail/decay.hpp>
@@ -58,6 +59,43 @@ BOOST_HANA_NAMESPACE_BEGIN
             detail::is_view<Sequence>::value, Sequence, Sequence&
         >::type;
 
+        //////////////////////////////////////////////////////////////////////
+        // cartesian_product_element_view
+        //////////////////////////////////////////////////////////////////////
+        template <typename Sequences, std::size_t i>
+        struct cartesian_product_element_view_t {
+            detail::view_storage<Sequences> sequences_;
+            using hana_tag = view_tag;
+        };
+
+        template <typename Sequences, std::size_t i>
+        struct is_view<cartesian_product_element_view_t<Sequences, i>> {
+            static constexpr bool value = true;
+        };
+
+        //////////////////////////////////////////////////////////////////////
+        // cartesian_product_view
+        //////////////////////////////////////////////////////////////////////
+        template <typename Sequences>
+        struct cartesian_product_view_t {
+            detail::view_storage<Sequences> sequences_;
+            using hana_tag = view_tag;
+        };
+
+        struct make_cartesian_product_view_t {
+            template <typename Sequences>
+            constexpr cartesian_product_view_t<Sequences> operator()(Sequences& s) const {
+                return {s};
+            }
+        };
+
+        constexpr make_cartesian_product_view_t cartesian_product_view{};
+
+        template <typename Sequences>
+        struct is_view<cartesian_product_view_t<Sequences>> {
+            static constexpr bool value = true;
+        };
+
         //////////////////////////////////////////////////////////////////////
         // sliced_view
         //////////////////////////////////////////////////////////////////////
@@ -212,6 +250,33 @@ BOOST_HANA_NAMESPACE_BEGIN
     //////////////////////////////////////////////////////////////////////////
     template <>
     struct unpack_impl<hana::view_tag> {
+        // cartesian_product_element_view
+        template <typename Sequences, std::size_t i, typename F>
+        static constexpr decltype(auto)
+        apply(detail::cartesian_product_element_view_t<Sequences, i> view, F const& f) {
+            using Indices = decltype(detail::make_cartesian_product_indices(view.sequences_));
+            return hana::unpack(view.sequences_,
+                detail::make_cartesian_product_element_t<F, i>{f});
+        }
+
+        // cartesian_product_view
+        template <typename View, typename F, std::size_t ...i>
+        static constexpr decltype(auto)
+        unpack_cartesian_product(View view, F&& f, std::index_sequence<i...>) {
+          return static_cast<F&&>(f)(
+              detail::cartesian_product_element_view_t<decltype(view.sequences_), i>{
+                view.sequences_
+              }...);
+        }
+
+        template <typename Sequences, typename F>
+        static constexpr decltype(auto)
+        apply(detail::cartesian_product_view_t<Sequences> view, F&& f) {
+          using Indices = decltype(detail::make_cartesian_product_indices(view.sequences_));
+          return unpack_cartesian_product(view, static_cast<F&&>(f),
+              std::make_index_sequence<Indices::length>{});
+        }
+
         // sliced_view
         template <typename Sequence, std::size_t ...i, typename F>
         static constexpr decltype(auto)
@@ -279,6 +344,22 @@ BOOST_HANA_NAMESPACE_BEGIN
     //////////////////////////////////////////////////////////////////////////
     template <>
     struct at_impl<hana::view_tag> {
+        // cartesian_product_element_view
+        template <typename Sequences, std::size_t i, typename N>
+        static constexpr decltype(auto)
+        apply(detail::cartesian_product_element_view_t<Sequences, i> view, N const&) {
+            using Indices = decltype(detail::make_cartesian_product_indices(view.sequences_));
+            return hana::at_c<Indices::indices_of(i)[N::value]>(
+                      hana::at_c<N::value>(view.sequences_));
+        }
+
+        // cartesian_product_view
+        template <typename Sequences, typename N>
+        static constexpr decltype(auto)
+        apply(detail::cartesian_product_view_t<Sequences> view, N const&) {
+          return detail::cartesian_product_element_view_t<Sequences, N::value>{view.sequences_};
+        }
+
         // sliced_view
         template <typename Sequence, std::size_t ...i, typename N>
         static constexpr decltype(auto)
@@ -368,6 +449,19 @@ BOOST_HANA_NAMESPACE_BEGIN
 
     template <>
     struct length_impl<hana::view_tag> {
+        // cartesian_product_view_element
+        template <typename Sequences, std::size_t i>
+        static constexpr auto apply(detail::cartesian_product_element_view_t<Sequences, i> view) {
+            return hana::length(view.sequences_);
+        }
+
+        // cartesian_product_view
+        template <typename Sequences>
+        static constexpr auto apply(detail::cartesian_product_view_t<Sequences> view) {
+            using Indices = decltype(detail::make_cartesian_product_indices(view.sequences_));
+            return hana::size_c<Indices::length>;
+        }
+
         // sliced_view
         template <typename Sequence, std::size_t ...i>
         static constexpr auto
@@ -394,11 +488,12 @@ BOOST_HANA_NAMESPACE_BEGIN
         struct sum_lengths {
             template <typename ...S>
             constexpr auto operator()(S const& ...s) const {
-                constexpr std::size_t lengths[] = {decltype(hana::length(s))::value...};
+                constexpr std::size_t lengths[sizeof...(S)] = {decltype(hana::length(s))::value...};
                 constexpr std::size_t sum = detail::accumulate(lengths, lengths+sizeof...(S), 0);
                 return hana::size_t<sum>{};
             }
         };
+
         template <typename Sequences>
         static constexpr auto apply(detail::flattened_view_t<Sequences> view) {
             return hana::unpack(view.sequences_, sum_lengths{});
@@ -424,6 +519,20 @@ BOOST_HANA_NAMESPACE_BEGIN
 
     template <>
     struct is_empty_impl<hana::view_tag> {
+        // cartesian_product_view_element
+        template <typename Sequences, std::size_t i>
+        static constexpr auto apply(detail::cartesian_product_element_view_t<Sequences, i> view) {
+            using Indices = decltype(detail::make_cartesian_product_indices(view.sequences_));
+            return hana::bool_c<Indices::length == 0>;
+        }
+
+        // cartesian_product_view
+        template <typename Sequences>
+        static constexpr auto apply(detail::cartesian_product_view_t<Sequences> view) {
+            using Indices = decltype(detail::make_cartesian_product_indices(view.sequences_));
+            return hana::bool_c<Indices::length == 0>;
+        }
+
         // sliced_view
         template <typename Sequence, std::size_t ...i>
         static constexpr auto

test/view/cartesian_product/at.cpp

@@ -0,0 +1,88 @@
+// Copyright Louis Dionne 2013-2016
+// 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)
+
+#include <boost/hana/assert.hpp>
+#include <boost/hana/at.hpp>
+#include <boost/hana/equal.hpp>
+#include <boost/hana/integral_constant.hpp>
+#include <boost/hana/view.hpp>
+
+#include <laws/base.hpp>
+#include <support/seq.hpp>
+namespace hana = boost::hana;
+using hana::test::ct_eq;
+
+
+int main() {
+    auto container = ::seq;
+
+    {
+        const auto storage = container(
+            container(ct_eq<0>{})
+        );
+
+        auto view = hana::detail::cartesian_product_view(storage);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at(view, hana::size_c<0>),
+            container(ct_eq<0>{})
+        ));
+    }
+
+    {
+        const auto storage = container(
+            container(ct_eq<0>{}),
+            container(ct_eq<0>{})
+        );
+
+        auto view = hana::detail::cartesian_product_view(storage);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at(view, hana::size_c<0>),
+            container(ct_eq<0>{}, ct_eq<0>{})
+        ));
+    }
+
+    {
+        const auto storage = container(
+            container(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}),
+            container(ct_eq<3>{}, ct_eq<4>{})
+        );
+
+        auto view = hana::detail::cartesian_product_view(storage);
+
+        auto expected = container(
+            container(ct_eq<0>{}, ct_eq<3>{}),
+            container(ct_eq<0>{}, ct_eq<4>{}),
+            container(ct_eq<1>{}, ct_eq<3>{}),
+            container(ct_eq<1>{}, ct_eq<4>{}),
+            container(ct_eq<2>{}, ct_eq<3>{}),
+            container(ct_eq<2>{}, ct_eq<4>{})
+        );
+
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at(view,     hana::size_c<0>),
+            hana::at(expected, hana::size_c<0>)
+        ));
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at(view,     hana::size_c<1>),
+            hana::at(expected, hana::size_c<1>)
+        ));
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at(view,     hana::size_c<2>),
+            hana::at(expected, hana::size_c<2>)
+        ));
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at(view,     hana::size_c<3>),
+            hana::at(expected, hana::size_c<3>)
+        ));
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at(view,     hana::size_c<4>),
+            hana::at(expected, hana::size_c<4>)
+        ));
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at(view,     hana::size_c<5>),
+            hana::at(expected, hana::size_c<5>)
+        ));
+    }
+}