diff --git a/example/tuple.cpp b/example/tuple.cpp
new file mode 100644
index 000000000..64a41acca
--- /dev/null
+++ b/example/tuple.cpp
@@ -0,0 +1,79 @@
+/*
+@copyright Louis Dionne 2014
+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/detail/constexpr.hpp>
+#include <boost/hana/ext/std/array.hpp>
+#include <boost/hana/ext/std/tuple.hpp>
+#include <boost/hana/foldable.hpp>
+#include <boost/hana/integral_constant.hpp>
+#include <boost/hana/logical.hpp>
+#include <boost/hana/range.hpp>
+#include <boost/hana/sequence.hpp>
+#include <boost/hana/tuple.hpp>
+
+#include <array>
+#include <tuple>
+using namespace boost::hana;
+
+
+int main() {
+
+{
+
+//! [tuple_t]
+BOOST_HANA_CONSTANT_CHECK(
+    to<Tuple>(tuple_t<int, char, void, int(float)>)
+    ==
+    tuple(type<int>, type<char>, type<void>, type<int(float)>)
+);
+//! [tuple_t]
+
+}{
+
+//! [tuple_c]
+BOOST_HANA_CONSTANT_CHECK(
+    to<Tuple>(tuple_c<int, 0, 1, 2>)
+    ==
+    tuple(int_<0>, int_<1>, int_<2>)
+);
+BOOST_HANA_CONSTANT_CHECK(head(tuple_c<int, 0, 1, 2>) == int_<0>);
+//! [tuple_c]
+
+}{
+
+//! [Foldable]
+using namespace literals;
+
+constexpr auto numbers = tuple_c<int, 5, -1, 0, -7, -2, 0, -5, 4>;
+constexpr auto negatives = tuple_c<int, -1, -7, -2, -5>;
+
+BOOST_HANA_CONSTEXPR_LAMBDA auto keep_negatives = [](auto n, auto acc) {
+    return if_(n < 0_c, prepend(n, acc), acc);
+};
+
+BOOST_HANA_CONSTANT_CHECK(foldr(numbers, tuple_c<int>, keep_negatives) == negatives);
+//! [Foldable]
+
+}{
+
+//! [Tuple_interop]
+BOOST_HANA_CONSTEXPR_CHECK(
+    to<Tuple>(std::make_tuple(1, '2', 3.3)) == tuple(1, '2', 3.3)
+);
+
+BOOST_HANA_CONSTANT_CHECK(
+    to<Tuple>(range(int_<1>, int_<4>)) == tuple(int_<1>, int_<2>, int_<3>)
+);
+
+BOOST_HANA_CONSTEXPR_CHECK(
+    to<Tuple>(std::array<int, 3>{{1, 2, 3}}) == tuple(1, 2, 3)
+);
+//! [Tuple_interop]
+
+}
+
+}
\ No newline at end of file
diff --git a/test/tuple.cpp b/test/tuple.cpp
index 82ce6864b..efa1c79ae 100644
--- a/test/tuple.cpp
+++ b/test/tuple.cpp
@@ -40,12 +40,13 @@ namespace boost { namespace hana { namespace test {
     );
 }}}
 
+struct x0; struct x1; struct x2; struct x3;
 
 int main() {
     test::check_datatype<Tuple>();
     using test::x;
 
-    // move-only friendlyness and reference semantics
+    // move-only friendliness and reference semantics
     {
         struct movable {
             movable() = default;
@@ -84,12 +85,28 @@ int main() {
         }
     }
 
+    // Comparable
+    {
+        // equal
+        {
+            BOOST_HANA_CONSTANT_CHECK(equal(tuple_t<>, tuple_t<>));
+            BOOST_HANA_CONSTANT_CHECK(not_(equal(tuple_t<x0>, tuple_t<>)));
+            BOOST_HANA_CONSTANT_CHECK(not_(equal(tuple_t<>, tuple_t<x0>)));
+            BOOST_HANA_CONSTANT_CHECK(equal(tuple_t<x0>, tuple_t<x0>));
+            BOOST_HANA_CONSTANT_CHECK(not_(equal(tuple_t<x0, x1>, tuple_t<x0>)));
+            BOOST_HANA_CONSTANT_CHECK(not_(equal(tuple_t<x0>, tuple_t<x0, x1>)));
+            BOOST_HANA_CONSTANT_CHECK(equal(tuple_t<x0, x1>, tuple_t<x0, x1>));
+            BOOST_HANA_CONSTANT_CHECK(equal(tuple_t<x0, x1, x2>, tuple_t<x0, x1, x2>));
+        }
+    }
+
     // Foldable
     {
         // unpack
         {
             auto f = test::injection([]{});
 
+            // tuple
             BOOST_HANA_CONSTANT_CHECK(equal(
                 unpack(tuple(), f),
                 f()
@@ -106,17 +123,149 @@ int main() {
                 unpack(tuple(x<0>, x<1>, x<2>), f),
                 f(x<0>, x<1>, x<2>)
             ));
+
+            // tuple_t
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                unpack(tuple_t<>, f),
+                f()
+            ));
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                unpack(tuple_t<x0>, f),
+                f(type<x0>)
+            ));
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                unpack(tuple_t<x0, x1>, f),
+                f(type<x0>, type<x1>)
+            ));
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                unpack(tuple_t<x0, x1, x2>, f),
+                f(type<x0>, type<x1>, type<x2>)
+            ));
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                unpack(tuple_t<x0, x1, x2, x3>, f),
+                f(type<x0>, type<x1>, type<x2>, type<x3>)
+            ));
         }
     }
 
     // Iterable
     {
+        ///////////////////
+        // tuple_t
+        //////////////////
+        // head
+        {
+            BOOST_HANA_CONSTANT_CHECK(equal(head(tuple_t<x0>), type<x0>));
+            BOOST_HANA_CONSTANT_CHECK(equal(head(tuple_t<x0, x1>), type<x0>));
+            BOOST_HANA_CONSTANT_CHECK(equal(head(tuple_t<x0, x1, x2>), type<x0>));
+        }
+
+        // is_empty
+        {
+            BOOST_HANA_CONSTANT_CHECK(is_empty(tuple_t<>));
+            BOOST_HANA_CONSTANT_CHECK(not_(is_empty(tuple_t<x0>)));
+            BOOST_HANA_CONSTANT_CHECK(not_(is_empty(tuple_t<x0, x1>)));
+        }
+
+        // tail
+        {
+            BOOST_HANA_CONSTANT_CHECK(equal(tail(tuple_t<x0>), tuple_t<>));
+            BOOST_HANA_CONSTANT_CHECK(equal(tail(tuple_t<x0, x1>), tuple_t<x1>));
+            BOOST_HANA_CONSTANT_CHECK(equal(tail(tuple_t<x0, x1, x2>), tuple_t<x1, x2>));
+        }
+
+        //////////////////
+        // tuple_c
+        /////////////////
+
+        // head
+        {
+            BOOST_HANA_CONSTANT_CHECK(equal(head(tuple_c<int, 0>), int_<0>));
+            BOOST_HANA_CONSTANT_CHECK(equal(head(tuple_c<int, 0, 1>), int_<0>));
+            BOOST_HANA_CONSTANT_CHECK(equal(head(tuple_c<int, 0, 1, 2>), int_<0>));
+        }
+
+        // is_empty
+        {
+            BOOST_HANA_CONSTANT_CHECK(is_empty(tuple_c<int>));
+            BOOST_HANA_CONSTANT_CHECK(not_(is_empty(tuple_c<int, 0>)));
+            BOOST_HANA_CONSTANT_CHECK(not_(is_empty(tuple_c<int, 0, 1>)));
+            BOOST_HANA_CONSTANT_CHECK(not_(is_empty(tuple_c<int, 0, 1, 2>)));
+        }
+
+        // tail
+        {
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                tail(tuple_c<int, 0>),
+                tuple_c<int>
+            ));
+
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                tail(tuple_c<int, 0, 1>),
+                tuple_c<int, 1>
+            ));
+
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                tail(tuple_c<int, 0, 1, 2>),
+                tuple_c<int, 1, 2>
+            ));
+        }
+
         // operators
         {
             BOOST_HANA_CONSTANT_CHECK(equal(
                 tuple(x<0>, x<1>)[size_t<0>],
                 x<0>
             ));
+
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                tuple_t<int, void>[size_t<0>],
+                type<int>
+            ));
+
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                tuple_t<int, void>[size_t<1>],
+                type<void>
+            ));
+        }
+    }
+
+    // MonadPlus
+    {
+        // prepend
+        {
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                prepend(long_<0>, tuple_c<long>),
+                tuple_c<long, 0>
+            ));
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                prepend(uint<0>, tuple_c<unsigned int, 1>),
+                tuple_c<unsigned int, 0, 1>
+            ));
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                prepend(llong<0>, tuple_c<long long, 1, 2>),
+                tuple_c<long long, 0, 1, 2>
+            ));
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                prepend(ulong<0>, tuple_c<unsigned long, 1, 2, 3>),
+                tuple_c<unsigned long, 0, 1, 2, 3>
+            ));
+        }
+
+        // nil
+        {
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                nil<Tuple>(),
+                tuple_c<int>
+            ));
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                nil<Tuple>(),
+                tuple_c<long>
+            ));
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                nil<Tuple>(),
+                tuple_c<void>
+            ));
         }
     }
 }