Adding upstream version 16.2.11+ds.upstream/16.2.11+dsupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

25 files changed, 1402 insertions, 0 deletions

diff --git a/src/boost/libs/hana/test/experimental/view/empty/is_empty.cpp b/src/boost/libs/hana/test/experimental/view/empty/is_empty.cpp
new file mode 100644
index 000000000..c3efb7e25
--- /dev/null
+++ b/src/boost/libs/hana/test/experimental/view/empty/is_empty.cpp
@@ -0,0 +1,16 @@
+// 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)
+
+#include <boost/hana/assert.hpp>
+#include <boost/hana/experimental/view.hpp>
+#include <boost/hana/is_empty.hpp>
+namespace hana = boost::hana;
+
+
+int main() {
+    {
+        auto empty = hana::experimental::empty_view();
+        BOOST_HANA_CONSTANT_CHECK(hana::is_empty(empty));
+    }
+}
diff --git a/src/boost/libs/hana/test/experimental/view/empty/length.cpp b/src/boost/libs/hana/test/experimental/view/empty/length.cpp
new file mode 100644
index 000000000..3325ec9c7
--- /dev/null
+++ b/src/boost/libs/hana/test/experimental/view/empty/length.cpp
@@ -0,0 +1,21 @@
+// 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)
+
+#include <boost/hana/assert.hpp>
+#include <boost/hana/equal.hpp>
+#include <boost/hana/experimental/view.hpp>
+#include <boost/hana/integral_constant.hpp>
+#include <boost/hana/length.hpp>
+namespace hana = boost::hana;
+
+
+int main() {
+    {
+        auto empty = hana::experimental::empty_view();
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::length(empty),
+            hana::size_c<0>
+        ));
+    }
+}
diff --git a/src/boost/libs/hana/test/experimental/view/empty/unpack.cpp b/src/boost/libs/hana/test/experimental/view/empty/unpack.cpp
new file mode 100644
index 000000000..6942e35af
--- /dev/null
+++ b/src/boost/libs/hana/test/experimental/view/empty/unpack.cpp
@@ -0,0 +1,24 @@
+// 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)
+
+#include <boost/hana/assert.hpp>
+#include <boost/hana/equal.hpp>
+#include <boost/hana/experimental/view.hpp>
+#include <boost/hana/unpack.hpp>
+
+#include <laws/base.hpp>
+namespace hana = boost::hana;
+
+
+int main() {
+    auto f = hana::test::_injection<0>{};
+
+    {
+        auto empty = hana::experimental::empty_view();
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::unpack(empty, f),
+            f()
+        ));
+    }
+}
diff --git a/src/boost/libs/hana/test/experimental/view/joined/at.cpp b/src/boost/libs/hana/test/experimental/view/joined/at.cpp
new file mode 100644
index 000000000..ec4e00170
--- /dev/null
+++ b/src/boost/libs/hana/test/experimental/view/joined/at.cpp
@@ -0,0 +1,97 @@
+// 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)
+
+#include <boost/hana/assert.hpp>
+#include <boost/hana/at.hpp>
+#include <boost/hana/equal.hpp>
+#include <boost/hana/experimental/view.hpp>
+#include <boost/hana/integral_constant.hpp>
+
+#include <laws/base.hpp>
+#include <support/seq.hpp>
+namespace hana = boost::hana;
+using hana::test::ct_eq;
+
+
+int main() {
+    auto container = ::seq;
+
+    {
+        auto storage1 = container(ct_eq<0>{});
+        auto storage2 = container();
+        auto joined = hana::experimental::joined(storage1, storage2);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at(joined, hana::size_c<0>),
+            ct_eq<0>{}
+        ));
+    }{
+        auto storage1 = container();
+        auto storage2 = container(ct_eq<0>{});
+        auto joined = hana::experimental::joined(storage1, storage2);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at(joined, hana::size_c<0>),
+            ct_eq<0>{}
+        ));
+    }
+
+    {
+        auto storage1 = container(ct_eq<0>{}, ct_eq<1>{});
+        auto storage2 = container();
+        auto joined = hana::experimental::joined(storage1, storage2);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at(joined, hana::size_c<0>),
+            ct_eq<0>{}
+        ));
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at(joined, hana::size_c<1>),
+            ct_eq<1>{}
+        ));
+    }{
+        auto storage1 = container(ct_eq<0>{});
+        auto storage2 = container(ct_eq<1>{});
+        auto joined = hana::experimental::joined(storage1, storage2);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at(joined, hana::size_c<0>),
+            ct_eq<0>{}
+        ));
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at(joined, hana::size_c<1>),
+            ct_eq<1>{}
+        ));
+    }{
+        auto storage1 = container();
+        auto storage2 = container(ct_eq<0>{}, ct_eq<1>{});
+        auto joined = hana::experimental::joined(storage1, storage2);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at(joined, hana::size_c<0>),
+            ct_eq<0>{}
+        ));
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at(joined, hana::size_c<1>),
+            ct_eq<1>{}
+        ));
+    }
+
+    {
+        auto storage1 = container(ct_eq<0>{}, ct_eq<1>{});
+        auto storage2 = container(ct_eq<2>{}, ct_eq<3>{});
+        auto joined = hana::experimental::joined(storage1, storage2);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at(joined, hana::size_c<0>),
+            ct_eq<0>{}
+        ));
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at(joined, hana::size_c<1>),
+            ct_eq<1>{}
+        ));
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at(joined, hana::size_c<2>),
+            ct_eq<2>{}
+        ));
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at(joined, hana::size_c<3>),
+            ct_eq<3>{}
+        ));
+    }
+}
diff --git a/src/boost/libs/hana/test/experimental/view/joined/is_empty.cpp b/src/boost/libs/hana/test/experimental/view/joined/is_empty.cpp
new file mode 100644
index 000000000..b8a5e0ae5
--- /dev/null
+++ b/src/boost/libs/hana/test/experimental/view/joined/is_empty.cpp
@@ -0,0 +1,43 @@
+// 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)
+
+#include <boost/hana/assert.hpp>
+#include <boost/hana/experimental/view.hpp>
+#include <boost/hana/is_empty.hpp>
+#include <boost/hana/not.hpp>
+
+#include <support/seq.hpp>
+namespace hana = boost::hana;
+
+
+template <int> struct undefined { };
+
+int main() {
+    auto container = ::seq;
+
+    {
+        auto storage1 = container();
+        auto storage2 = container();
+        auto joined = hana::experimental::joined(storage1, storage2);
+        BOOST_HANA_CONSTANT_CHECK(hana::is_empty(joined));
+    }
+    {
+        auto storage1 = container(undefined<0>{});
+        auto storage2 = container();
+        auto joined = hana::experimental::joined(storage1, storage2);
+        BOOST_HANA_CONSTANT_CHECK(hana::not_(hana::is_empty(joined)));
+    }
+    {
+        auto storage1 = container(undefined<0>{});
+        auto storage2 = container(undefined<1>{});
+        auto joined = hana::experimental::joined(storage1, storage2);
+        BOOST_HANA_CONSTANT_CHECK(hana::not_(hana::is_empty(joined)));
+    }
+    {
+        auto storage1 = container();
+        auto storage2 = container(undefined<0>{});
+        auto joined = hana::experimental::joined(storage1, storage2);
+        BOOST_HANA_CONSTANT_CHECK(hana::not_(hana::is_empty(joined)));
+    }
+}
diff --git a/src/boost/libs/hana/test/experimental/view/joined/length.cpp b/src/boost/libs/hana/test/experimental/view/joined/length.cpp
new file mode 100644
index 000000000..457d5f626
--- /dev/null
+++ b/src/boost/libs/hana/test/experimental/view/joined/length.cpp
@@ -0,0 +1,89 @@
+// 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)
+
+#include <boost/hana/assert.hpp>
+#include <boost/hana/equal.hpp>
+#include <boost/hana/experimental/view.hpp>
+#include <boost/hana/integral_constant.hpp>
+#include <boost/hana/length.hpp>
+
+#include <support/seq.hpp>
+namespace hana = boost::hana;
+
+
+template <int> struct undefined { };
+
+int main() {
+    auto container = ::seq;
+
+    {
+        auto storage1 = container();
+        auto storage2 = container();
+        auto joined = hana::experimental::joined(storage1, storage2);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::length(joined),
+            hana::size_c<0>
+        ));
+    }
+
+    {
+        auto storage1 = container(undefined<0>{});
+        auto storage2 = container();
+        auto joined = hana::experimental::joined(storage1, storage2);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::length(joined),
+            hana::size_c<1>
+        ));
+    }
+
+    {
+        auto storage1 = container();
+        auto storage2 = container(undefined<0>{});
+        auto joined = hana::experimental::joined(storage1, storage2);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::length(joined),
+            hana::size_c<1>
+        ));
+    }
+
+    {
+        auto storage1 = container(undefined<0>{});
+        auto storage2 = container(undefined<1>{});
+        auto joined = hana::experimental::joined(storage1, storage2);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::length(joined),
+            hana::size_c<2>
+        ));
+    }
+
+    {
+        auto storage1 = container(undefined<0>{});
+        auto storage2 = container(undefined<1>{});
+        auto joined = hana::experimental::joined(storage1, storage2);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::length(joined),
+            hana::size_c<2>
+        ));
+    }
+
+    {
+        auto storage1 = container(undefined<0>{}, undefined<1>{});
+        auto storage2 = container(undefined<2>{});
+        auto joined = hana::experimental::joined(storage1, storage2);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::length(joined),
+            hana::size_c<3>
+        ));
+    }
+
+    {
+        auto storage1 = container(undefined<0>{}, undefined<1>{}, undefined<2>{});
+        auto storage2 = container(undefined<3>{}, undefined<4>{});
+        auto joined = hana::experimental::joined(storage1, storage2);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::length(joined),
+            hana::size_c<5>
+        ));
+    }
+}
diff --git a/src/boost/libs/hana/test/experimental/view/joined/unpack.cpp b/src/boost/libs/hana/test/experimental/view/joined/unpack.cpp
new file mode 100644
index 000000000..cf0896d8f
--- /dev/null
+++ b/src/boost/libs/hana/test/experimental/view/joined/unpack.cpp
@@ -0,0 +1,81 @@
+// 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)
+
+#include <boost/hana/assert.hpp>
+#include <boost/hana/equal.hpp>
+#include <boost/hana/experimental/view.hpp>
+#include <boost/hana/unpack.hpp>
+
+#include <laws/base.hpp>
+#include <support/seq.hpp>
+namespace hana = boost::hana;
+using hana::test::ct_eq;
+
+
+int main() {
+    auto container = ::seq;
+    auto f = hana::test::_injection<0>{};
+
+    {
+        auto storage1 = container();
+        auto storage2 = container();
+        auto joined = hana::experimental::joined(storage1, storage2);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::unpack(joined, f),
+            f()
+        ));
+    }
+
+    {
+        auto storage1 = container(ct_eq<0>{});
+        auto storage2 = container();
+        auto joined = hana::experimental::joined(storage1, storage2);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::unpack(joined, f),
+            f(ct_eq<0>{})
+        ));
+    }{
+        auto storage1 = container();
+        auto storage2 = container(ct_eq<0>{});
+        auto joined = hana::experimental::joined(storage1, storage2);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::unpack(joined, f),
+            f(ct_eq<0>{})
+        ));
+    }{
+        auto storage1 = container(ct_eq<0>{});
+        auto storage2 = container(ct_eq<1>{});
+        auto joined = hana::experimental::joined(storage1, storage2);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::unpack(joined, f),
+            f(ct_eq<0>{}, ct_eq<1>{})
+        ));
+    }
+
+    {
+        auto storage1 = container(ct_eq<0>{}, ct_eq<1>{});
+        auto storage2 = container();
+        auto joined = hana::experimental::joined(storage1, storage2);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::unpack(joined, f),
+            f(ct_eq<0>{}, ct_eq<1>{})
+        ));
+    }{
+        auto storage1 = container();
+        auto storage2 = container(ct_eq<0>{}, ct_eq<1>{});
+        auto joined = hana::experimental::joined(storage1, storage2);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::unpack(joined, f),
+            f(ct_eq<0>{}, ct_eq<1>{})
+        ));
+    }{
+        auto storage1 = container(ct_eq<0>{}, ct_eq<1>{});
+        auto storage2 = container(ct_eq<2>{}, ct_eq<3>{});
+        auto joined = hana::experimental::joined(storage1, storage2);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::unpack(joined, f),
+            f(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}, ct_eq<3>{})
+        ));
+    }
+}
diff --git a/src/boost/libs/hana/test/experimental/view/single/at.cpp b/src/boost/libs/hana/test/experimental/view/single/at.cpp
new file mode 100644
index 000000000..20d1490be
--- /dev/null
+++ b/src/boost/libs/hana/test/experimental/view/single/at.cpp
@@ -0,0 +1,24 @@
+// 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)
+
+#include <boost/hana/assert.hpp>
+#include <boost/hana/at.hpp>
+#include <boost/hana/equal.hpp>
+#include <boost/hana/experimental/view.hpp>
+#include <boost/hana/integral_constant.hpp>
+
+#include <laws/base.hpp>
+namespace hana = boost::hana;
+using hana::test::ct_eq;
+
+
+int main() {
+    {
+        auto single = hana::experimental::single_view(ct_eq<0>{});
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at(single, hana::size_c<0>),
+            ct_eq<0>{}
+        ));
+    }
+}
diff --git a/src/boost/libs/hana/test/experimental/view/single/is_empty.cpp b/src/boost/libs/hana/test/experimental/view/single/is_empty.cpp
new file mode 100644
index 000000000..4422b3e40
--- /dev/null
+++ b/src/boost/libs/hana/test/experimental/view/single/is_empty.cpp
@@ -0,0 +1,19 @@
+// 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)
+
+#include <boost/hana/assert.hpp>
+#include <boost/hana/experimental/view.hpp>
+#include <boost/hana/is_empty.hpp>
+#include <boost/hana/not.hpp>
+namespace hana = boost::hana;
+
+
+template <int> struct undefined { };
+
+int main() {
+    {
+        auto single = hana::experimental::single_view(undefined<0>{});
+        BOOST_HANA_CONSTANT_CHECK(hana::not_(hana::is_empty(single)));
+    }
+}
diff --git a/src/boost/libs/hana/test/experimental/view/single/length.cpp b/src/boost/libs/hana/test/experimental/view/single/length.cpp
new file mode 100644
index 000000000..8153f8199
--- /dev/null
+++ b/src/boost/libs/hana/test/experimental/view/single/length.cpp
@@ -0,0 +1,23 @@
+// 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)
+
+#include <boost/hana/assert.hpp>
+#include <boost/hana/equal.hpp>
+#include <boost/hana/experimental/view.hpp>
+#include <boost/hana/integral_constant.hpp>
+#include <boost/hana/length.hpp>
+namespace hana = boost::hana;
+
+
+template <int> struct undefined { };
+
+int main() {
+    {
+        auto single = hana::experimental::single_view(undefined<0>{});
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::length(single),
+            hana::size_c<1>
+        ));
+    }
+}
diff --git a/src/boost/libs/hana/test/experimental/view/single/unpack.cpp b/src/boost/libs/hana/test/experimental/view/single/unpack.cpp
new file mode 100644
index 000000000..ca2398412
--- /dev/null
+++ b/src/boost/libs/hana/test/experimental/view/single/unpack.cpp
@@ -0,0 +1,25 @@
+// 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)
+
+#include <boost/hana/assert.hpp>
+#include <boost/hana/equal.hpp>
+#include <boost/hana/experimental/view.hpp>
+#include <boost/hana/unpack.hpp>
+
+#include <laws/base.hpp>
+namespace hana = boost::hana;
+using hana::test::ct_eq;
+
+
+int main() {
+    auto f = hana::test::_injection<0>{};
+
+    {
+        auto single = hana::experimental::single_view(ct_eq<0>{});
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::unpack(single, f),
+            f(ct_eq<0>{})
+        ));
+    }
+}
diff --git a/src/boost/libs/hana/test/experimental/view/sliced/at.cpp b/src/boost/libs/hana/test/experimental/view/sliced/at.cpp
new file mode 100644
index 000000000..c8d201a59
--- /dev/null
+++ b/src/boost/libs/hana/test/experimental/view/sliced/at.cpp
@@ -0,0 +1,91 @@
+// 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)
+
+#include <boost/hana/assert.hpp>
+#include <boost/hana/at.hpp>
+#include <boost/hana/equal.hpp>
+#include <boost/hana/experimental/view.hpp>
+#include <boost/hana/integral_constant.hpp>
+#include <boost/hana/tuple.hpp>
+
+#include <laws/base.hpp>
+#include <support/seq.hpp>
+namespace hana = boost::hana;
+using hana::test::ct_eq;
+
+
+int main() {
+    auto container = ::seq;
+
+    {
+        auto storage = container(ct_eq<0>{});
+        auto sliced = hana::experimental::sliced(storage, hana::tuple_c<int, 0>);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at(sliced, hana::size_c<0>),
+            ct_eq<0>{}
+        ));
+    }
+
+    {
+        auto storage = container(ct_eq<0>{}, ct_eq<1>{});
+        auto sliced = hana::experimental::sliced(storage, hana::tuple_c<int, 0>);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at(sliced, hana::size_c<0>),
+            ct_eq<0>{}
+        ));
+    }{
+        auto storage = container(ct_eq<0>{}, ct_eq<1>{});
+        auto sliced = hana::experimental::sliced(storage, hana::tuple_c<int, 1>);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at(sliced, hana::size_c<0>),
+            ct_eq<1>{}
+        ));
+    }{
+        auto storage = container(ct_eq<0>{}, ct_eq<1>{});
+        auto sliced = hana::experimental::sliced(storage, hana::tuple_c<int, 0, 1>);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at(sliced, hana::size_c<0>),
+            ct_eq<0>{}
+        ));
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at(sliced, hana::size_c<1>),
+            ct_eq<1>{}
+        ));
+    }{
+        auto storage = container(ct_eq<0>{}, ct_eq<1>{});
+        auto sliced = hana::experimental::sliced(storage, hana::tuple_c<int, 1, 0>);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at(sliced, hana::size_c<0>),
+            ct_eq<1>{}
+        ));
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at(sliced, hana::size_c<1>),
+            ct_eq<0>{}
+        ));
+    }{
+        auto storage = container(ct_eq<0>{}, ct_eq<1>{});
+        auto sliced = hana::experimental::sliced(storage, hana::tuple_c<int, 0, 0>);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at(sliced, hana::size_c<0>),
+            ct_eq<0>{}
+        ));
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at(sliced, hana::size_c<1>),
+            ct_eq<0>{}
+        ));
+    }
+
+    {
+        auto storage = container(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}, ct_eq<3>{});
+        auto sliced = hana::experimental::sliced(storage, hana::tuple_c<int, 1, 3>);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at(sliced, hana::size_c<0>),
+            ct_eq<1>{}
+        ));
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at(sliced, hana::size_c<1>),
+            ct_eq<3>{}
+        ));
+    }
+}
diff --git a/src/boost/libs/hana/test/experimental/view/sliced/is_empty.cpp b/src/boost/libs/hana/test/experimental/view/sliced/is_empty.cpp
new file mode 100644
index 000000000..d6f0d267e
--- /dev/null
+++ b/src/boost/libs/hana/test/experimental/view/sliced/is_empty.cpp
@@ -0,0 +1,49 @@
+// 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)
+
+#include <boost/hana/assert.hpp>
+#include <boost/hana/experimental/view.hpp>
+#include <boost/hana/is_empty.hpp>
+#include <boost/hana/not.hpp>
+#include <boost/hana/tuple.hpp>
+
+#include <support/seq.hpp>
+namespace hana = boost::hana;
+
+
+template <int> struct undefined { };
+
+int main() {
+    auto container = ::seq;
+
+    {
+        auto storage = container();
+        auto sliced = hana::experimental::sliced(storage, hana::tuple_c<int>);
+        BOOST_HANA_CONSTANT_CHECK(hana::is_empty(sliced));
+    }{
+        auto storage = container(undefined<0>{});
+        auto sliced = hana::experimental::sliced(storage, hana::tuple_c<int>);
+        BOOST_HANA_CONSTANT_CHECK(hana::is_empty(sliced));
+    }{
+        auto storage = container(undefined<0>{}, undefined<1>{});
+        auto sliced = hana::experimental::sliced(storage, hana::tuple_c<int>);
+        BOOST_HANA_CONSTANT_CHECK(hana::is_empty(sliced));
+    }
+
+    {
+        auto storage = container(undefined<0>{});
+        auto sliced = hana::experimental::sliced(storage, hana::tuple_c<int, 0>);
+        BOOST_HANA_CONSTANT_CHECK(hana::not_(hana::is_empty(sliced)));
+    }{
+        auto storage = container(undefined<0>{});
+        auto sliced = hana::experimental::sliced(storage, hana::tuple_c<int, 0, 0>);
+        BOOST_HANA_CONSTANT_CHECK(hana::not_(hana::is_empty(sliced)));
+    }
+
+    {
+        auto storage = container(undefined<0>{}, undefined<1>{});
+        auto sliced = hana::experimental::sliced(storage, hana::tuple_c<int, 0, 1>);
+        BOOST_HANA_CONSTANT_CHECK(hana::not_(hana::is_empty(sliced)));
+    }
+}
diff --git a/src/boost/libs/hana/test/experimental/view/sliced/length.cpp b/src/boost/libs/hana/test/experimental/view/sliced/length.cpp
new file mode 100644
index 000000000..c975960aa
--- /dev/null
+++ b/src/boost/libs/hana/test/experimental/view/sliced/length.cpp
@@ -0,0 +1,68 @@
+// 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)
+
+#include <boost/hana/assert.hpp>
+#include <boost/hana/equal.hpp>
+#include <boost/hana/experimental/view.hpp>
+#include <boost/hana/integral_constant.hpp>
+#include <boost/hana/length.hpp>
+#include <boost/hana/tuple.hpp>
+
+#include <support/seq.hpp>
+namespace hana = boost::hana;
+
+
+template <int> struct undefined { };
+
+int main() {
+    auto container = ::seq;
+
+    {
+        auto storage = container();
+        auto sliced = hana::experimental::sliced(storage, hana::tuple_c<int>);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::length(sliced),
+            hana::size_c<0>
+        ));
+    }
+
+    {
+        auto storage = container(undefined<0>{});
+        auto sliced = hana::experimental::sliced(storage, hana::tuple_c<int, 0>);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::length(sliced),
+            hana::size_c<1>
+        ));
+    }{
+        auto storage = container(undefined<0>{});
+        auto sliced = hana::experimental::sliced(storage, hana::tuple_c<int>);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::length(sliced),
+            hana::size_c<0>
+        ));
+    }
+
+    {
+        auto storage = container(undefined<0>{}, undefined<1>{});
+        auto sliced = hana::experimental::sliced(storage, hana::tuple_c<int, 0>);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::length(sliced),
+            hana::size_c<1>
+        ));
+    }{
+        auto storage = container(undefined<0>{}, undefined<1>{});
+        auto sliced = hana::experimental::sliced(storage, hana::tuple_c<int, 0, 1>);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::length(sliced),
+            hana::size_c<2>
+        ));
+    }{
+        auto storage = container(undefined<0>{}, undefined<1>{});
+        auto sliced = hana::experimental::sliced(storage, hana::tuple_c<int, 0, 0>);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::length(sliced),
+            hana::size_c<2>
+        ));
+    }
+}
diff --git a/src/boost/libs/hana/test/experimental/view/sliced/unpack.cpp b/src/boost/libs/hana/test/experimental/view/sliced/unpack.cpp
new file mode 100644
index 000000000..710e8246e
--- /dev/null
+++ b/src/boost/libs/hana/test/experimental/view/sliced/unpack.cpp
@@ -0,0 +1,135 @@
+// 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)
+
+#include <boost/hana/assert.hpp>
+#include <boost/hana/equal.hpp>
+#include <boost/hana/experimental/view.hpp>
+#include <boost/hana/tuple.hpp>
+#include <boost/hana/unpack.hpp>
+
+#include <laws/base.hpp>
+#include <support/seq.hpp>
+namespace hana = boost::hana;
+using hana::test::ct_eq;
+
+
+int main() {
+    auto container = ::seq;
+    auto f = hana::test::_injection<0>{};
+
+    {
+        auto storage = container();
+        auto sliced = hana::experimental::sliced(storage, hana::tuple_c<int>);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::unpack(sliced, f),
+            f()
+        ));
+    }
+
+    {
+        auto storage = container(ct_eq<0>{});
+        auto sliced = hana::experimental::sliced(storage, hana::tuple_c<int>);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::unpack(sliced, f),
+            f()
+        ));
+    }{
+        auto storage = container(ct_eq<0>{});
+        auto sliced = hana::experimental::sliced(storage, hana::tuple_c<int, 0>);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::unpack(sliced, f),
+            f(ct_eq<0>{})
+        ));
+    }
+
+    {
+        auto storage = container(ct_eq<0>{}, ct_eq<1>{});
+        auto sliced = hana::experimental::sliced(storage, hana::tuple_c<int>);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::unpack(sliced, f),
+            f()
+        ));
+    }{
+        auto storage = container(ct_eq<0>{}, ct_eq<1>{});
+        auto sliced = hana::experimental::sliced(storage, hana::tuple_c<int, 0>);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::unpack(sliced, f),
+            f(ct_eq<0>{})
+        ));
+    }{
+        auto storage = container(ct_eq<0>{}, ct_eq<1>{});
+        auto sliced = hana::experimental::sliced(storage, hana::tuple_c<int, 0, 1>);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::unpack(sliced, f),
+            f(ct_eq<0>{}, ct_eq<1>{})
+        ));
+    }{
+        auto storage = container(ct_eq<0>{}, ct_eq<1>{});
+        auto sliced = hana::experimental::sliced(storage, hana::tuple_c<int, 1>);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::unpack(sliced, f),
+            f(ct_eq<1>{})
+        ));
+    }{
+        auto storage = container(ct_eq<0>{}, ct_eq<1>{});
+        auto sliced = hana::experimental::sliced(storage, hana::tuple_c<int, 1, 0>);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::unpack(sliced, f),
+            f(ct_eq<1>{}, ct_eq<0>{})
+        ));
+    }
+
+    {
+        auto storage = container(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{});
+        auto sliced = hana::experimental::sliced(storage, hana::tuple_c<int>);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::unpack(sliced, f),
+            f()
+        ));
+    }{
+        auto storage = container(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{});
+        auto sliced = hana::experimental::sliced(storage, hana::tuple_c<int, 0>);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::unpack(sliced, f),
+            f(ct_eq<0>{})
+        ));
+    }{
+        auto storage = container(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{});
+        auto sliced = hana::experimental::sliced(storage, hana::tuple_c<int, 1>);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::unpack(sliced, f),
+            f(ct_eq<1>{})
+        ));
+    }{
+        auto storage = container(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{});
+        auto sliced = hana::experimental::sliced(storage, hana::tuple_c<int, 2>);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::unpack(sliced, f),
+            f(ct_eq<2>{})
+        ));
+    }{
+        auto storage = container(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{});
+        auto sliced = hana::experimental::sliced(storage, hana::tuple_c<int, 0, 2>);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::unpack(sliced, f),
+            f(ct_eq<0>{}, ct_eq<2>{})
+        ));
+    }{
+        auto storage = container(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{});
+        auto sliced = hana::experimental::sliced(storage, hana::tuple_c<int, 1, 1>);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::unpack(sliced, f),
+            f(ct_eq<1>{}, ct_eq<1>{})
+        ));
+    }
+
+    {
+        auto storage = container(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}, ct_eq<3>{});
+        auto sliced = hana::experimental::sliced(storage, hana::tuple_c<int, 3, 1, 0, 2, 2>);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::unpack(sliced, f),
+            f(ct_eq<3>{}, ct_eq<1>{}, ct_eq<0>{}, ct_eq<2>{}, ct_eq<2>{})
+        ));
+    }
+}
diff --git a/src/boost/libs/hana/test/experimental/view/transformed/ap.cpp b/src/boost/libs/hana/test/experimental/view/transformed/ap.cpp
new file mode 100644
index 000000000..b04d54fe5
--- /dev/null
+++ b/src/boost/libs/hana/test/experimental/view/transformed/ap.cpp
@@ -0,0 +1,122 @@
+// 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)
+
+#include <boost/hana/ap.hpp>
+#include <boost/hana/assert.hpp>
+#include <boost/hana/equal.hpp>
+#include <boost/hana/experimental/view.hpp>
+#include <boost/hana/functional/id.hpp>
+
+#include <laws/base.hpp>
+#include <support/seq.hpp>
+namespace hana = boost::hana;
+using hana::test::_injection;
+using hana::test::ct_eq;
+
+
+int main() {
+    auto container = ::seq;
+    auto f = hana::test::_injection<99>{};
+
+    {
+        auto storage = container();
+        auto functions = container();
+        auto transformed_storage = hana::experimental::transformed(storage, f);
+        auto transformed_functions = hana::experimental::transformed(functions, hana::id);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::ap(transformed_functions, transformed_storage),
+            container()
+        ));
+    }{
+        auto storage = container(ct_eq<0>{});
+        auto functions = container();
+        auto transformed_storage = hana::experimental::transformed(storage, f);
+        auto transformed_functions = hana::experimental::transformed(functions, hana::id);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::ap(transformed_functions, transformed_storage),
+            container()
+        ));
+    }{
+        auto storage = container();
+        auto functions = container(ct_eq<0>{});
+        auto transformed_storage = hana::experimental::transformed(storage, f);
+        auto transformed_functions = hana::experimental::transformed(functions, hana::id);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::ap(transformed_functions, transformed_storage),
+            container()
+        ));
+    }
+
+    {
+        auto storage = container(ct_eq<0>{});
+        auto functions = container(_injection<0>{});
+        auto transformed_storage = hana::experimental::transformed(storage, f);
+        auto transformed_functions = hana::experimental::transformed(functions, hana::id);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::ap(transformed_functions, transformed_storage),
+            container(_injection<0>{}(f(ct_eq<0>{})))
+        ));
+    }{
+        auto storage = container(ct_eq<0>{});
+        auto functions = container(_injection<0>{}, _injection<1>{});
+        auto transformed_storage = hana::experimental::transformed(storage, f);
+        auto transformed_functions = hana::experimental::transformed(functions, hana::id);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::ap(transformed_functions, transformed_storage),
+            container(_injection<0>{}(f(ct_eq<0>{})),
+                      _injection<1>{}(f(ct_eq<0>{})))
+        ));
+    }{
+        auto storage = container(ct_eq<0>{});
+        auto functions = container(_injection<0>{}, _injection<1>{}, _injection<2>{});
+        auto transformed_storage = hana::experimental::transformed(storage, f);
+        auto transformed_functions = hana::experimental::transformed(functions, hana::id);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::ap(transformed_functions, transformed_storage),
+            container(_injection<0>{}(f(ct_eq<0>{})),
+                      _injection<1>{}(f(ct_eq<0>{})),
+                      _injection<2>{}(f(ct_eq<0>{})))
+        ));
+    }
+
+    {
+        auto storage = container(ct_eq<0>{}, ct_eq<1>{});
+        auto functions = container(_injection<0>{});
+        auto transformed_storage = hana::experimental::transformed(storage, f);
+        auto transformed_functions = hana::experimental::transformed(functions, hana::id);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::ap(transformed_functions, transformed_storage),
+            container(_injection<0>{}(f(ct_eq<0>{})),
+                      _injection<0>{}(f(ct_eq<1>{})))
+        ));
+    }{
+        auto storage = container(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{});
+        auto functions = container(_injection<0>{});
+        auto transformed_storage = hana::experimental::transformed(storage, f);
+        auto transformed_functions = hana::experimental::transformed(functions, hana::id);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::ap(transformed_functions, transformed_storage),
+            container(_injection<0>{}(f(ct_eq<0>{})),
+                      _injection<0>{}(f(ct_eq<1>{})),
+                      _injection<0>{}(f(ct_eq<2>{})))
+        ));
+    }
+
+    {
+        auto storage = container(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{});
+        auto functions = container(_injection<0>{}, _injection<1>{});
+        auto transformed_storage = hana::experimental::transformed(storage, f);
+        auto transformed_functions = hana::experimental::transformed(functions, hana::id);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::ap(transformed_functions, transformed_storage),
+            container(_injection<0>{}(f(ct_eq<0>{})),
+                      _injection<0>{}(f(ct_eq<1>{})),
+                      _injection<0>{}(f(ct_eq<2>{})),
+
+                      _injection<1>{}(f(ct_eq<0>{})),
+                      _injection<1>{}(f(ct_eq<1>{})),
+                      _injection<1>{}(f(ct_eq<2>{})))
+        ));
+    }
+}
diff --git a/src/boost/libs/hana/test/experimental/view/transformed/at.cpp b/src/boost/libs/hana/test/experimental/view/transformed/at.cpp
new file mode 100644
index 000000000..2379f2878
--- /dev/null
+++ b/src/boost/libs/hana/test/experimental/view/transformed/at.cpp
@@ -0,0 +1,73 @@
+// 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)
+
+#include <boost/hana/assert.hpp>
+#include <boost/hana/at.hpp>
+#include <boost/hana/equal.hpp>
+#include <boost/hana/experimental/view.hpp>
+
+#include <laws/base.hpp>
+#include <support/seq.hpp>
+namespace hana = boost::hana;
+using hana::test::ct_eq;
+
+
+int main() {
+    auto container = ::seq;
+    auto f = hana::test::_injection<0>{};
+
+    {
+        auto storage = container(ct_eq<0>{});
+        auto transformed = hana::experimental::transformed(storage, f);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at_c<0>(transformed),
+            f(ct_eq<0>{})
+        ));
+    }{
+        auto storage = container(ct_eq<0>{}, ct_eq<1>{});
+        auto transformed = hana::experimental::transformed(storage, f);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at_c<0>(transformed),
+            f(ct_eq<0>{})
+        ));
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at_c<1>(transformed),
+            f(ct_eq<1>{})
+        ));
+    }{
+        auto storage = container(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{});
+        auto transformed = hana::experimental::transformed(storage, f);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at_c<0>(transformed),
+            f(ct_eq<0>{})
+        ));
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at_c<1>(transformed),
+            f(ct_eq<1>{})
+        ));
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at_c<2>(transformed),
+            f(ct_eq<2>{})
+        ));
+    }{
+        auto storage = container(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}, ct_eq<3>{});
+        auto transformed = hana::experimental::transformed(storage, f);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at_c<0>(transformed),
+            f(ct_eq<0>{})
+        ));
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at_c<1>(transformed),
+            f(ct_eq<1>{})
+        ));
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at_c<2>(transformed),
+            f(ct_eq<2>{})
+        ));
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::at_c<3>(transformed),
+            f(ct_eq<3>{})
+        ));
+    }
+}
diff --git a/src/boost/libs/hana/test/experimental/view/transformed/drop_front.cpp b/src/boost/libs/hana/test/experimental/view/transformed/drop_front.cpp
new file mode 100644
index 000000000..0db64fd41
--- /dev/null
+++ b/src/boost/libs/hana/test/experimental/view/transformed/drop_front.cpp
@@ -0,0 +1,98 @@
+// 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)
+
+#include <boost/hana/assert.hpp>
+#include <boost/hana/drop_front.hpp>
+#include <boost/hana/equal.hpp>
+#include <boost/hana/experimental/view.hpp>
+#include <boost/hana/integral_constant.hpp>
+
+#include <laws/base.hpp>
+#include <support/seq.hpp>
+namespace hana = boost::hana;
+using hana::test::ct_eq;
+
+
+int main() {
+    auto container = ::seq;
+    auto f = hana::test::_injection<0>{};
+
+    {
+        auto storage = container();
+        auto transformed = hana::experimental::transformed(storage, f);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::drop_front(transformed, hana::size_c<0>),
+            container()
+        ));
+    }
+
+    {
+        auto storage = container(ct_eq<0>{});
+        auto transformed = hana::experimental::transformed(storage, f);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::drop_front(transformed, hana::size_c<0>),
+            container(f(ct_eq<0>{}))
+        ));
+    }{
+        auto storage = container(ct_eq<0>{});
+        auto transformed = hana::experimental::transformed(storage, f);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::drop_front(transformed, hana::size_c<1>),
+            container()
+        ));
+    }
+
+    {
+        auto storage = container(ct_eq<0>{}, ct_eq<1>{});
+        auto transformed = hana::experimental::transformed(storage, f);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::drop_front(transformed, hana::size_c<0>),
+            container(f(ct_eq<0>{}), f(ct_eq<1>{}))
+        ));
+    }{
+        auto storage = container(ct_eq<0>{}, ct_eq<1>{});
+        auto transformed = hana::experimental::transformed(storage, f);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::drop_front(transformed, hana::size_c<1>),
+            container(f(ct_eq<1>{}))
+        ));
+    }{
+        auto storage = container(ct_eq<0>{}, ct_eq<1>{});
+        auto transformed = hana::experimental::transformed(storage, f);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::drop_front(transformed, hana::size_c<2>),
+            container()
+        ));
+    }
+
+    {
+        auto storage = container(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{});
+        auto transformed = hana::experimental::transformed(storage, f);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::drop_front(transformed, hana::size_c<0>),
+            container(f(ct_eq<0>{}), f(ct_eq<1>{}), f(ct_eq<2>{}))
+        ));
+    }{
+        auto storage = container(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{});
+        auto transformed = hana::experimental::transformed(storage, f);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::drop_front(transformed, hana::size_c<1>),
+            container(f(ct_eq<1>{}), f(ct_eq<2>{}))
+        ));
+    }{
+        auto storage = container(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{});
+        auto transformed = hana::experimental::transformed(storage, f);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::drop_front(transformed, hana::size_c<2>),
+            container(f(ct_eq<2>{}))
+        ));
+    }{
+        auto storage = container(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{});
+        auto transformed = hana::experimental::transformed(storage, f);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::drop_front(transformed, hana::size_c<3>),
+            container()
+        ));
+    }
+}
diff --git a/src/boost/libs/hana/test/experimental/view/transformed/equal.cpp b/src/boost/libs/hana/test/experimental/view/transformed/equal.cpp
new file mode 100644
index 000000000..f7723c0cf
--- /dev/null
+++ b/src/boost/libs/hana/test/experimental/view/transformed/equal.cpp
@@ -0,0 +1,50 @@
+// 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)
+
+#include <boost/hana/assert.hpp>
+#include <boost/hana/equal.hpp>
+#include <boost/hana/experimental/view.hpp>
+#include <boost/hana/functional/id.hpp>
+#include <boost/hana/not.hpp>
+
+#include <support/seq.hpp>
+namespace hana = boost::hana;
+
+
+int main() {
+    auto container = ::seq;
+
+    auto xs = container(0, '1', 2.2);
+    auto tr = hana::experimental::transformed(xs, hana::id);
+
+    BOOST_HANA_CONSTANT_CHECK(hana::not_(hana::equal(
+        tr,
+        container()
+    )));
+
+    BOOST_HANA_CONSTANT_CHECK(hana::not_(hana::equal(
+        tr,
+        container(0)
+    )));
+
+    BOOST_HANA_CONSTANT_CHECK(hana::not_(hana::equal(
+        tr,
+        container(0, '1')
+    )));
+
+    BOOST_HANA_RUNTIME_CHECK(hana::equal(
+        tr,
+        container(0, '1', 2.2)
+    ));
+
+    BOOST_HANA_CONSTANT_CHECK(hana::not_(hana::equal(
+        tr,
+        container(0, '1', 2.2, 345)
+    )));
+
+    BOOST_HANA_RUNTIME_CHECK(hana::not_(hana::equal(
+        tr,
+        container('0', '1', '2')
+    )));
+}
diff --git a/src/boost/libs/hana/test/experimental/view/transformed/is_empty.cpp b/src/boost/libs/hana/test/experimental/view/transformed/is_empty.cpp
new file mode 100644
index 000000000..aafec8ab5
--- /dev/null
+++ b/src/boost/libs/hana/test/experimental/view/transformed/is_empty.cpp
@@ -0,0 +1,36 @@
+// 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)
+
+#include <boost/hana/assert.hpp>
+#include <boost/hana/experimental/view.hpp>
+#include <boost/hana/is_empty.hpp>
+#include <boost/hana/not.hpp>
+
+#include <support/seq.hpp>
+namespace hana = boost::hana;
+
+
+struct undefined { };
+
+int main() {
+    auto container = ::seq;
+
+    {
+        auto xs = container();
+        auto tr = hana::experimental::transformed(xs, undefined{});
+        BOOST_HANA_CONSTANT_CHECK(hana::is_empty(tr));
+    }
+
+    {
+        auto xs = container(undefined{});
+        auto tr = hana::experimental::transformed(xs, undefined{});
+        BOOST_HANA_CONSTANT_CHECK(hana::not_(hana::is_empty(tr)));
+    }
+
+    {
+        auto xs = container(undefined{}, undefined{});
+        auto tr = hana::experimental::transformed(xs, undefined{});
+        BOOST_HANA_CONSTANT_CHECK(hana::not_(hana::is_empty(tr)));
+    }
+}
diff --git a/src/boost/libs/hana/test/experimental/view/transformed/laziness.cpp b/src/boost/libs/hana/test/experimental/view/transformed/laziness.cpp
new file mode 100644
index 000000000..c1c9fc4ca
--- /dev/null
+++ b/src/boost/libs/hana/test/experimental/view/transformed/laziness.cpp
@@ -0,0 +1,20 @@
+// 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)
+
+#include <boost/hana/experimental/view.hpp>
+
+#include <laws/base.hpp>
+#include <support/seq.hpp>
+namespace hana = boost::hana;
+using hana::test::ct_eq;
+
+
+struct undefined { };
+
+int main() {
+    // Make sure we do not evaluate the function unless required
+    auto storage = ::seq(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{});
+    auto transformed = hana::experimental::transformed(storage, undefined{});
+    (void)transformed;
+}
diff --git a/src/boost/libs/hana/test/experimental/view/transformed/length.cpp b/src/boost/libs/hana/test/experimental/view/transformed/length.cpp
new file mode 100644
index 000000000..516df7da8
--- /dev/null
+++ b/src/boost/libs/hana/test/experimental/view/transformed/length.cpp
@@ -0,0 +1,49 @@
+// 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)
+
+#include <boost/hana/assert.hpp>
+#include <boost/hana/equal.hpp>
+#include <boost/hana/experimental/view.hpp>
+#include <boost/hana/integral_constant.hpp>
+#include <boost/hana/length.hpp>
+
+#include <support/seq.hpp>
+namespace hana = boost::hana;
+
+
+template <int> struct undefined { };
+
+int main() {
+    auto container = ::seq;
+
+    {
+        auto storage = container();
+        auto transformed = hana::experimental::transformed(storage, undefined<99>{});
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::length(transformed),
+            hana::size_c<0>
+        ));
+    }{
+        auto storage = container(undefined<0>{});
+        auto transformed = hana::experimental::transformed(storage, undefined<99>{});
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::length(transformed),
+            hana::size_c<1>
+        ));
+    }{
+        auto storage = container(undefined<0>{}, undefined<1>{});
+        auto transformed = hana::experimental::transformed(storage, undefined<99>{});
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::length(transformed),
+            hana::size_c<2>
+        ));
+    }{
+        auto storage = container(undefined<0>{}, undefined<1>{}, undefined<2>{});
+        auto transformed = hana::experimental::transformed(storage, undefined<99>{});
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::length(transformed),
+            hana::size_c<3>
+        ));
+    }
+}
diff --git a/src/boost/libs/hana/test/experimental/view/transformed/less.cpp b/src/boost/libs/hana/test/experimental/view/transformed/less.cpp
new file mode 100644
index 000000000..562e0a462
--- /dev/null
+++ b/src/boost/libs/hana/test/experimental/view/transformed/less.cpp
@@ -0,0 +1,58 @@
+// 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)
+
+#include <boost/hana/assert.hpp>
+#include <boost/hana/experimental/view.hpp>
+#include <boost/hana/less.hpp>
+#include <boost/hana/not.hpp>
+
+#include <laws/base.hpp>
+#include <support/seq.hpp>
+namespace hana = boost::hana;
+using hana::test::ct_ord;
+
+
+int main() {
+    auto container = ::seq;
+    auto f = hana::test::_injection<0>{};
+
+    {
+        auto storage = container();
+        auto transformed = hana::experimental::transformed(storage, f);
+        BOOST_HANA_CONSTANT_CHECK(hana::not_(hana::less(
+            transformed,
+            container()
+        )));
+    }{
+        auto storage = container(ct_ord<0>{});
+        auto transformed = hana::experimental::transformed(storage, f);
+        BOOST_HANA_CONSTANT_CHECK(hana::less(
+            container(),
+            transformed
+        ));
+        BOOST_HANA_CONSTANT_CHECK(hana::not_(hana::less(
+            container(f(ct_ord<0>{})),
+            transformed
+        )));
+        BOOST_HANA_CONSTANT_CHECK(hana::not_(hana::less(
+            transformed,
+            container()
+        )));
+    }{
+        auto storage = container(ct_ord<0>{}, ct_ord<1>{});
+        auto transformed = hana::experimental::transformed(storage, f);
+        BOOST_HANA_CONSTANT_CHECK(hana::less(
+            container(),
+            transformed
+        ));
+        BOOST_HANA_CONSTANT_CHECK(hana::less(
+            container(f(ct_ord<0>{})),
+            transformed
+        ));
+        BOOST_HANA_CONSTANT_CHECK(hana::less(
+            container(f(ct_ord<0>{}), f(ct_ord<0>{})),
+            transformed
+        ));
+    }
+}
diff --git a/src/boost/libs/hana/test/experimental/view/transformed/transform.cpp b/src/boost/libs/hana/test/experimental/view/transformed/transform.cpp
new file mode 100644
index 000000000..6fbab6789
--- /dev/null
+++ b/src/boost/libs/hana/test/experimental/view/transformed/transform.cpp
@@ -0,0 +1,57 @@
+// 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)
+
+#include <boost/hana/assert.hpp>
+#include <boost/hana/equal.hpp>
+#include <boost/hana/experimental/view.hpp>
+#include <boost/hana/transform.hpp>
+
+#include <laws/base.hpp>
+#include <support/seq.hpp>
+namespace hana = boost::hana;
+using hana::test::ct_eq;
+
+
+int main() {
+    auto container = ::seq;
+    auto f = hana::test::_injection<0>{};
+    auto g = hana::test::_injection<1>{};
+
+    {
+        auto storage = container();
+        auto transformed = hana::experimental::transformed(storage, f);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::transform(transformed, g),
+            container()
+        ));
+    }{
+        auto storage = container(ct_eq<0>{});
+        auto transformed = hana::experimental::transformed(storage, f);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::transform(transformed, g),
+            container(g(f(ct_eq<0>{})))
+        ));
+    }{
+        auto storage = container(ct_eq<0>{}, ct_eq<1>{});
+        auto transformed = hana::experimental::transformed(storage, f);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::transform(transformed, g),
+            container(g(f(ct_eq<0>{})), g(f(ct_eq<1>{})))
+        ));
+    }{
+        auto storage = container(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{});
+        auto transformed = hana::experimental::transformed(storage, f);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::transform(transformed, g),
+            container(g(f(ct_eq<0>{})), g(f(ct_eq<1>{})), g(f(ct_eq<2>{})))
+        ));
+    }{
+        auto storage = container(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}, ct_eq<3>{});
+        auto transformed = hana::experimental::transformed(storage, f);
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::transform(transformed, g),
+            container(g(f(ct_eq<0>{})), g(f(ct_eq<1>{})), g(f(ct_eq<2>{})), g(f(ct_eq<3>{})))
+        ));
+    }
+}
diff --git a/src/boost/libs/hana/test/experimental/view/transformed/unpack.cpp b/src/boost/libs/hana/test/experimental/view/transformed/unpack.cpp
new file mode 100644
index 000000000..6ade5ed2e
--- /dev/null
+++ b/src/boost/libs/hana/test/experimental/view/transformed/unpack.cpp
@@ -0,0 +1,34 @@
+// 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)
+
+#include <boost/hana/assert.hpp>
+#include <boost/hana/equal.hpp>
+#include <boost/hana/experimental/view.hpp>
+#include <boost/hana/unpack.hpp>
+
+#include <laws/base.hpp>
+#include <support/seq.hpp>
+namespace hana = boost::hana;
+using hana::test::ct_eq;
+
+
+int main() {
+    auto f = hana::test::_injection<0>{};
+    auto g = hana::test::_injection<1>{};
+    auto check = [=](auto ...x) {
+        auto storage = ::seq(x...);
+        auto transformed = hana::experimental::transformed(storage, f);
+
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(
+            hana::unpack(transformed, g),
+            g(f(x)...)
+        ));
+    };
+
+    check();
+    check(ct_eq<0>{});
+    check(ct_eq<0>{}, ct_eq<1>{});
+    check(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{});
+    check(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}, ct_eq<3>{});
+}