diff --git a/benchmark/foldable/CMakeLists.txt b/benchmark/foldable/CMakeLists.txt
index b8012efa5..061a15b2b 100644
--- a/benchmark/foldable/CMakeLists.txt
+++ b/benchmark/foldable/CMakeLists.txt
@@ -3,17 +3,17 @@
 # (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
 
 foreach(method IN ITEMS count foldl foldl1 foldr foldr1 for_each length maximum maximum_by minimum minimum_by product sum unpack)
-    # Methods requiring `Integral` elements in the `Foldable`.
+    # Methods requiring integral `Constant`s (or stronger) in the `Foldable`.
     if(${method} MATCHES "maximum|minimum|product|sum")
         set(hana_tuple_env "
             ((1..50).to_a + (51..500).step(25).to_a).map { |n|
                 xs = (1..n).to_a.map { |i|
-                    \"boost::hana::integral<int, #{i}>\"
+                    \"boost::hana::integral_constant<int, #{i}>\"
                 }.join(', ')
 
                 {
                     setup: '
-                        #include <boost/hana/integral.hpp>
+                        #include <boost/hana/integral_constant.hpp>
                         #include <boost/hana/tuple.hpp>
                     ',
                     foldable: \"boost::hana::tuple(#{xs})\",
@@ -25,13 +25,13 @@ foreach(method IN ITEMS count foldl foldl1 foldr foldr1 for_each length maximum
         set(std_tuple_env "
             ((1..50).to_a + (51..500).step(25).to_a).map { |n|
                 xs = (1..n).to_a.map { |i|
-                    \"boost::hana::integral<int, #{i}>\"
+                    \"boost::hana::integral_constant<int, #{i}>\"
                 }.join(', ')
 
                 {
                     setup: '
                         #include <boost/hana/ext/std/tuple.hpp>
-                        #include <boost/hana/integral.hpp>
+                        #include <boost/hana/integral_constant.hpp>
                         #include <tuple>
                     ',
                     foldable: \"std::make_tuple(#{xs})\",
diff --git a/benchmark/iterable/at.cpp b/benchmark/iterable/at.cpp
index a055b73bd..5ba68b2d7 100644
--- a/benchmark/iterable/at.cpp
+++ b/benchmark/iterable/at.cpp
@@ -5,7 +5,7 @@ Distributed under the Boost Software License, Version 1.0.
  */
 
 #include <boost/hana/fwd/iterable.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 
 #include "benchmark.hpp"
 
diff --git a/benchmark/iterable/drop.cpp b/benchmark/iterable/drop.cpp
index 47f29b5f6..8f500afe2 100644
--- a/benchmark/iterable/drop.cpp
+++ b/benchmark/iterable/drop.cpp
@@ -5,7 +5,7 @@ Distributed under the Boost Software License, Version 1.0.
  */
 
 #include <boost/hana/fwd/iterable.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 
 #include "benchmark.hpp"
 
diff --git a/benchmark/list/sort.cpp b/benchmark/list/sort.cpp
index 2a562d06a..7c858ff30 100644
--- a/benchmark/list/sort.cpp
+++ b/benchmark/list/sort.cpp
@@ -5,7 +5,7 @@ Distributed under the Boost Software License, Version 1.0.
  */
 
 #include <boost/hana/fwd/list.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 
 #include "benchmark.hpp"
 
diff --git a/benchmark/list/take.cpp b/benchmark/list/take.cpp
index a543ad629..42c96e5bc 100644
--- a/benchmark/list/take.cpp
+++ b/benchmark/list/take.cpp
@@ -4,7 +4,7 @@ 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/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/fwd/list.hpp>
 
 #include "benchmark.hpp"
diff --git a/benchmark/searchable/CMakeLists.txt b/benchmark/searchable/CMakeLists.txt
index 87c11bd12..32766fc80 100644
--- a/benchmark/searchable/CMakeLists.txt
+++ b/benchmark/searchable/CMakeLists.txt
@@ -8,11 +8,11 @@ foreach(method IN ITEMS all any elem find lookup none subset)
         set(hana_tuple_env
             "((1..50).to_a + (51..500).step(25).to_a).map { |n|
                 xs = (1..n).to_a.map { |i|
-                    \"boost::hana::integral<int, #{i}>\"
+                    \"boost::hana::integral_constant<int, #{i}>\"
                 }.join(', ')
                 {
                     setup: '
-                        #include <boost/hana/integral.hpp>
+                        #include <boost/hana/integral_constant.hpp>
                         #include <boost/hana/tuple.hpp>
                     ',
                     searchable: \"boost::hana::tuple(#{xs})\",
@@ -24,12 +24,12 @@ foreach(method IN ITEMS all any elem find lookup none subset)
         set(std_tuple_env
             "((1..50).to_a + (51..500).step(25).to_a).map { |n|
                 xs = (1..n).to_a.map { |i|
-                    \"boost::hana::integral<int, #{i}>\"
+                    \"boost::hana::integral_constant<int, #{i}>\"
                 }.join(', ')
                 {
                     setup: '
                         #include <boost/hana/ext/std/tuple.hpp>
-                        #include <boost/hana/integral.hpp>
+                        #include <boost/hana/integral_constant.hpp>
                         #include <tuple>
                     ',
                     searchable: \"std::make_tuple(#{xs})\",
diff --git a/example/constant.cpp b/example/constant.cpp
index c5f6e8b99..71d7dd159 100644
--- a/example/constant.cpp
+++ b/example/constant.cpp
@@ -5,13 +5,13 @@ Distributed under the Boost Software License, Version 1.0.
  */
 
 #include <boost/hana/assert.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 using namespace boost::hana;
 
 
 int main() {
     //! [value]
-    auto i = integral<int, 3>; // notice no constexpr
+    auto i = integral_constant<int, 3>; // notice no constexpr
     static_assert(value(i) == 3, "value(i) is always a constant expression!");
     //! [value]
 }
diff --git a/example/core/is_a.cpp b/example/core/is_a.cpp
index bce18b82b..6d1e13ed5 100644
--- a/example/core/is_a.cpp
+++ b/example/core/is_a.cpp
@@ -10,7 +10,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/is_a.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/ext/std/tuple.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/iterable.hpp>
 #include <boost/hana/logical.hpp>
 #include <boost/hana/maybe.hpp>
diff --git a/example/core/to.cpp b/example/core/to.cpp
index 9e272a03f..5ef901ada 100644
--- a/example/core/to.cpp
+++ b/example/core/to.cpp
@@ -7,7 +7,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/assert.hpp>
 #include <boost/hana/ext/std/array.hpp>
 #include <boost/hana/ext/std/tuple.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/range.hpp>
 #include <boost/hana/tuple.hpp>
 
diff --git a/example/cppcon_2014/functor.cpp b/example/cppcon_2014/functor.cpp
index fc52e3ac1..a4fbe5899 100644
--- a/example/cppcon_2014/functor.cpp
+++ b/example/cppcon_2014/functor.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/assert.hpp>
 #include <boost/hana/functional/placeholder.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 
 #include "matrix/comparable.hpp"
 #include "matrix/functor.hpp"
diff --git a/example/cppcon_2014/matrix.cpp b/example/cppcon_2014/matrix.cpp
index 006ba968b..9c46ed22c 100644
--- a/example/cppcon_2014/matrix.cpp
+++ b/example/cppcon_2014/matrix.cpp
@@ -5,7 +5,7 @@ Distributed under the Boost Software License, Version 1.0.
  */
 
 #include <boost/hana/assert.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 
 #include "matrix/comparable.hpp"
 using namespace boost::hana;
diff --git a/example/cppcon_2014/matrix/det.hpp b/example/cppcon_2014/matrix/det.hpp
index a33258c71..c784418c9 100644
--- a/example/cppcon_2014/matrix/det.hpp
+++ b/example/cppcon_2014/matrix/det.hpp
@@ -16,7 +16,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/functional/partial.hpp>
 #include <boost/hana/functional/placeholder.hpp>
 #include <boost/hana/functor.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/iterable.hpp>
 #include <boost/hana/list.hpp>
 #include <boost/hana/logical.hpp>
diff --git a/example/cppcon_2014/matrix/monoid.hpp b/example/cppcon_2014/matrix/monoid.hpp
index c4f993d56..3ad0d7e35 100644
--- a/example/cppcon_2014/matrix/monoid.hpp
+++ b/example/cppcon_2014/matrix/monoid.hpp
@@ -11,7 +11,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/core/models.hpp>
 #include <boost/hana/detail/std/integral_constant.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/list.hpp>
 #include <boost/hana/monoid.hpp>
 #include <boost/hana/range.hpp>
diff --git a/example/cppcon_2014/matrix/ring.hpp b/example/cppcon_2014/matrix/ring.hpp
index fba15a842..f3df359e8 100644
--- a/example/cppcon_2014/matrix/ring.hpp
+++ b/example/cppcon_2014/matrix/ring.hpp
@@ -12,7 +12,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/models.hpp>
 #include <boost/hana/detail/std/integral_constant.hpp>
 #include <boost/hana/foldable.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/list.hpp>
 #include <boost/hana/range.hpp>
 #include <boost/hana/ring.hpp>
diff --git a/example/either.cpp b/example/either.cpp
index b0bcc98ed..aef96f129 100644
--- a/example/either.cpp
+++ b/example/either.cpp
@@ -8,7 +8,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/bool.hpp>
 #include <boost/hana/either.hpp>
 #include <boost/hana/functional.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/tuple.hpp>
 
 #include <string>
diff --git a/example/enumerable.cpp b/example/enumerable.cpp
index e7ef64344..56686e9d6 100644
--- a/example/enumerable.cpp
+++ b/example/enumerable.cpp
@@ -5,7 +5,7 @@ Distributed under the Boost Software License, Version 1.0.
  */
 
 #include <boost/hana/assert.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 using namespace boost::hana;
 
 
diff --git a/example/ext/boost/mpl/vector/cheatsheet/fold.cpp b/example/ext/boost/mpl/vector/cheatsheet/fold.cpp
index 2f355c174..7906f5d5d 100644
--- a/example/ext/boost/mpl/vector/cheatsheet/fold.cpp
+++ b/example/ext/boost/mpl/vector/cheatsheet/fold.cpp
@@ -8,7 +8,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/ext/boost/mpl/vector.hpp>
 #include <boost/hana/ext/std/integral_constant.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/type_list.hpp>
 
 #include <boost/mpl/fold.hpp>
diff --git a/example/foldable.cpp b/example/foldable.cpp
index dbb64a2ac..9a17ca67a 100644
--- a/example/foldable.cpp
+++ b/example/foldable.cpp
@@ -9,7 +9,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/ext/std/integral_constant.hpp>
 #include <boost/hana/functional.hpp>
 #include <boost/hana/integer_list.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/maybe.hpp>
 #include <boost/hana/range.hpp>
 #include <boost/hana/tuple.hpp>
diff --git a/example/functional/on/infix.cpp b/example/functional/on/infix.cpp
index f79b81f4b..14c80084e 100644
--- a/example/functional/on/infix.cpp
+++ b/example/functional/on/infix.cpp
@@ -7,7 +7,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/functional.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/pair.hpp>
 #include <boost/hana/tuple.hpp>
 #include <boost/hana/type.hpp>
diff --git a/example/group.cpp b/example/group.cpp
index f1a947997..ed7622308 100644
--- a/example/group.cpp
+++ b/example/group.cpp
@@ -5,7 +5,7 @@ Distributed under the Boost Software License, Version 1.0.
  */
 
 #include <boost/hana/assert.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 using namespace boost::hana;
 
 
diff --git a/example/integer_list/foldable.cpp b/example/integer_list/foldable.cpp
index fd14bdee3..e2b898e16 100644
--- a/example/integer_list/foldable.cpp
+++ b/example/integer_list/foldable.cpp
@@ -7,7 +7,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/integer_list.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 using namespace boost::hana;
 
 
diff --git a/example/integer_list/integer_list.cpp b/example/integer_list/integer_list.cpp
index 6e546e92e..c0fad94d6 100644
--- a/example/integer_list/integer_list.cpp
+++ b/example/integer_list/integer_list.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/assert.hpp>
 #include <boost/hana/integer_list.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/tuple.hpp>
 using namespace boost::hana;
 
diff --git a/example/integral.cpp b/example/integral.cpp
deleted file mode 100644
index a77a63d20..000000000
--- a/example/integral.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
-@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/integral.hpp>
-using namespace boost::hana;
-
-
-int main() {
-    //! [comparable]
-    BOOST_HANA_CONSTANT_CHECK(equal(int_<1>, int_<1>));
-    BOOST_HANA_CONSTANT_CHECK(not_equal(int_<1>, int_<2>));
-
-    BOOST_HANA_CONSTANT_CHECK(equal(int_<1>, long_<1>));
-    BOOST_HANA_CONSTANT_CHECK(not_equal(int_<1>, long_<2>));
-    //! [comparable]
-
-    //! [literals]
-    using namespace literals; // contains the _c suffix
-
-    BOOST_HANA_CONSTANT_CHECK(1234_c == llong<1234>);
-    BOOST_HANA_CONSTANT_CHECK(-1234_c == llong<-1234>);
-    BOOST_HANA_CONSTANT_CHECK(1_c + (3_c * 4_c) == llong<1 + (3 * 4)>);
-    //! [literals]
-
-    //! [operators]
-    BOOST_HANA_CONSTANT_CHECK(int_<1> + int_<3> == int_<4>);
-
-    // Mixed-type operations are supported, but only when it involves a
-    // promotion, and not a conversion that could be lossy.
-    BOOST_HANA_CONSTANT_CHECK(size_t<3> * ushort<5> == size_t<15>);
-    BOOST_HANA_CONSTANT_CHECK(llong<15> == int_<15>);
-    //! [operators]
-
-    //! [orderable]
-    BOOST_HANA_CONSTANT_CHECK(less(int_<-3>, int_<3>));
-    BOOST_HANA_CONSTANT_CHECK(max(int_<-3>, long_<2>) == long_<2>);
-    BOOST_HANA_CONSTANT_CHECK(min(int_<-3>, long_<2>) == int_<-3>);
-    //! [orderable]
-}
diff --git a/example/integral_constant.cpp b/example/integral_constant.cpp
new file mode 100644
index 000000000..c3426ad15
--- /dev/null
+++ b/example/integral_constant.cpp
@@ -0,0 +1,98 @@
+/*
+@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/integral_constant.hpp>
+#include <boost/hana/tuple.hpp>
+
+#include <string>
+#include <vector>
+using namespace boost::hana;
+
+
+int main() {
+
+{
+
+//! [operators]
+BOOST_HANA_CONSTANT_CHECK(int_<1> + int_<3> == int_<4>);
+
+// Mixed-type operations are supported, but only when it involves a
+// promotion, and not a conversion that could be lossy.
+BOOST_HANA_CONSTANT_CHECK(size_t<3> * ushort<5> == size_t<15>);
+BOOST_HANA_CONSTANT_CHECK(llong<15> == int_<15>);
+//! [operators]
+
+}{
+
+//! [times_loop_unrolling]
+std::string s;
+for (char c = 'x'; c <= 'z'; ++c)
+    int_<5>.times([&] { s += c; });
+
+BOOST_HANA_RUNTIME_CHECK(s == "xxxxxyyyyyzzzzz");
+//! [times_loop_unrolling]
+
+}{
+
+//! [as_static_member]
+std::string s;
+for (char c = 'x'; c <= 'z'; ++c)
+    decltype(int_<5>)::times([&] { s += c; });
+
+BOOST_HANA_RUNTIME_CHECK(s == "xxxxxyyyyyzzzzz");
+//! [as_static_member]
+
+}{
+
+//! [times_higher_order]
+std::string s;
+BOOST_HANA_CONSTEXPR_LAMBDA auto functions = tuple(
+    [&] { s += "x"; },
+    [&] { s += "y"; },
+    [&] { s += "z"; }
+);
+for_each(functions, int_<5>.times);
+BOOST_HANA_RUNTIME_CHECK(s == "xxxxxyyyyyzzzzz");
+//! [times_higher_order]
+
+}{
+
+//! [times_with_index_runtime]
+std::vector<int> v;
+int_<5>.times.with_index([&](auto index) { v.push_back(index); });
+
+BOOST_HANA_RUNTIME_CHECK(v == std::vector<int>{0, 1, 2, 3, 4});
+//! [times_with_index_runtime]
+
+//! [times_with_index_compile_time]
+constexpr auto xs = tuple(0, 1, 2);
+int_<3>.times.with_index([xs](auto index) {
+    static_assert(xs[index] == index, "");
+});
+//! [times_with_index_compile_time]
+
+}{
+
+//! [literals]
+using namespace literals; // contains the _c suffix
+
+BOOST_HANA_CONSTANT_CHECK(1234_c == llong<1234>);
+BOOST_HANA_CONSTANT_CHECK(-1234_c == llong<-1234>);
+BOOST_HANA_CONSTANT_CHECK(1_c + (3_c * 4_c) == llong<1 + (3 * 4)>);
+//! [literals]
+
+}{
+
+//! [integral_constant]
+BOOST_HANA_CONSTANT_CHECK(integral_constant<int, 2> == int_<2>);
+static_assert(decltype(integral_constant<int, 2>)::value == 2, "");
+//! [integral_constant]
+
+}
+
+}
diff --git a/example/integral_domain.cpp b/example/integral_domain.cpp
index 9a68349d5..8bd5f8733 100644
--- a/example/integral_domain.cpp
+++ b/example/integral_domain.cpp
@@ -5,7 +5,7 @@ Distributed under the Boost Software License, Version 1.0.
  */
 
 #include <boost/hana/assert.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 using namespace boost::hana;
 
 
diff --git a/example/iterable.cpp b/example/iterable.cpp
index 41f19742b..54a41dccb 100644
--- a/example/iterable.cpp
+++ b/example/iterable.cpp
@@ -7,7 +7,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/ext/std/integral_constant.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/maybe.hpp>
 #include <boost/hana/range.hpp>
 #include <boost/hana/tuple.hpp>
diff --git a/example/list.cpp b/example/list.cpp
index 2741ddccc..d67060f78 100644
--- a/example/list.cpp
+++ b/example/list.cpp
@@ -9,7 +9,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/ext/std/integral_constant.hpp>
 #include <boost/hana/functional.hpp>
 #include <boost/hana/integer_list.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/maybe.hpp>
 #include <boost/hana/pair.hpp>
 #include <boost/hana/tuple.hpp>
diff --git a/example/list/traversable.cpp b/example/list/traversable.cpp
index a53c4b281..92fd47123 100644
--- a/example/list/traversable.cpp
+++ b/example/list/traversable.cpp
@@ -5,7 +5,7 @@ Distributed under the Boost Software License, Version 1.0.
  */
 
 #include <boost/hana/assert.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/maybe.hpp>
 #include <boost/hana/tuple.hpp>
 
diff --git a/example/logical.cpp b/example/logical.cpp
index 21ad91cf6..9a7e42bdf 100644
--- a/example/logical.cpp
+++ b/example/logical.cpp
@@ -10,7 +10,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/ext/std/integral_constant.hpp>
 #include <boost/hana/functional.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/tuple.hpp>
 #include <boost/hana/type.hpp>
 
diff --git a/example/map.cpp b/example/map.cpp
index 4f3d004f4..b6770de5f 100644
--- a/example/map.cpp
+++ b/example/map.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/map.hpp>
 #include <boost/hana/maybe.hpp>
 #include <boost/hana/pair.hpp>
diff --git a/example/maybe.cpp b/example/maybe.cpp
index eccfea20f..518d982c1 100644
--- a/example/maybe.cpp
+++ b/example/maybe.cpp
@@ -7,7 +7,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/assert.hpp>
 #include <boost/hana/bool.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/maybe.hpp>
 #include <boost/hana/tuple.hpp>
 using namespace boost::hana;
diff --git a/example/monoid.cpp b/example/monoid.cpp
index 4c491855e..ebbf9cb1c 100644
--- a/example/monoid.cpp
+++ b/example/monoid.cpp
@@ -5,7 +5,7 @@ Distributed under the Boost Software License, Version 1.0.
  */
 
 #include <boost/hana/assert.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 using namespace boost::hana;
 
 
@@ -14,7 +14,7 @@ int main() {
 {
 
 //! [zero]
-BOOST_HANA_CONSTANT_CHECK(zero<Integral<int>>() == int_<0>);
+BOOST_HANA_CONSTANT_CHECK(zero<IntegralConstant<int>>() == int_<0>);
 BOOST_HANA_CONSTEXPR_CHECK(zero<long>() == 0l);
 //! [zero]
 
diff --git a/example/orderable.cpp b/example/orderable.cpp
index e8c3e7344..a9fbb667d 100644
--- a/example/orderable.cpp
+++ b/example/orderable.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/tuple.hpp>
 #include <boost/hana/type.hpp>
 using namespace boost::hana;
diff --git a/example/range.cpp b/example/range.cpp
index 12a7fd680..f7cbfe637 100644
--- a/example/range.cpp
+++ b/example/range.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/monoid.hpp>
 #include <boost/hana/range.hpp>
 #include <boost/hana/tuple.hpp>
diff --git a/example/ring.cpp b/example/ring.cpp
index 9af6a6691..dc2f925ce 100644
--- a/example/ring.cpp
+++ b/example/ring.cpp
@@ -5,7 +5,7 @@ Distributed under the Boost Software License, Version 1.0.
  */
 
 #include <boost/hana/assert.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 using namespace boost::hana;
 
 
@@ -22,7 +22,7 @@ BOOST_HANA_CONSTEXPR_CHECK(mult(4, 2) == 8);
 }{
 
 //! [one]
-BOOST_HANA_CONSTANT_CHECK(one<Integral<int>>() == int_<1>);
+BOOST_HANA_CONSTANT_CHECK(one<IntegralConstant<int>>() == int_<1>);
 BOOST_HANA_CONSTEXPR_CHECK(one<long>() == 1l);
 //! [one]
 
diff --git a/example/searchable.cpp b/example/searchable.cpp
index f5b1fe89f..14e01396a 100644
--- a/example/searchable.cpp
+++ b/example/searchable.cpp
@@ -9,7 +9,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/ext/std/integral_constant.hpp>
 #include <boost/hana/functional.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/map.hpp>
 #include <boost/hana/maybe.hpp>
 #include <boost/hana/pair.hpp>
diff --git a/example/set.cpp b/example/set.cpp
index 6da5e9edc..96b963ef2 100644
--- a/example/set.cpp
+++ b/example/set.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/maybe.hpp>
 #include <boost/hana/set.hpp>
 #include <boost/hana/string.hpp>
diff --git a/example/string.cpp b/example/string.cpp
index a92bddf88..e0c29e80a 100644
--- a/example/string.cpp
+++ b/example/string.cpp
@@ -7,7 +7,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/assert.hpp>
 #include <boost/hana/core/models.hpp>
 #include <boost/hana/detail/constexpr.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/maybe.hpp>
 #include <boost/hana/string.hpp>
 using namespace boost::hana;
diff --git a/example/traversable.cpp b/example/traversable.cpp
index bc7a23d45..199c9158f 100644
--- a/example/traversable.cpp
+++ b/example/traversable.cpp
@@ -5,7 +5,7 @@ Distributed under the Boost Software License, Version 1.0.
  */
 
 #include <boost/hana/assert.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/maybe.hpp>
 #include <boost/hana/tuple.hpp>
 using namespace boost::hana;
diff --git a/example/tutorial/basic_concepts/constant/integral.cpp b/example/tutorial/basic_concepts/constant/integral.cpp
index 9805ebb3a..cc4e6979f 100644
--- a/example/tutorial/basic_concepts/constant/integral.cpp
+++ b/example/tutorial/basic_concepts/constant/integral.cpp
@@ -5,15 +5,15 @@ Distributed under the Boost Software License, Version 1.0.
  */
 
 #include <boost/hana/assert.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 
 #include <type_traits>
 using namespace boost::hana;
 
 
 //! [integral_create]
-auto two = integral<int, 2>;
-auto yes = integral<bool, true>;
+auto two = integral_constant<int, 2>;
+auto yes = integral_constant<bool, true>;
 //! [integral_create]
 
 //! [integral_api]
@@ -47,7 +47,7 @@ BOOST_HANA_CONSTANT_CHECK(-1234_c == llong<-1234>);
 }
 
 //! [integral_operators]
-BOOST_HANA_CONSTANT_CHECK(int_<1> == integral<int, 1>);
+BOOST_HANA_CONSTANT_CHECK(int_<1> == integral_constant<int, 1>);
 BOOST_HANA_CONSTANT_CHECK(int_<1> + long_<2> == long_<3>);
 BOOST_HANA_CONSTANT_CHECK(!(bool_<true> && bool_<false>));
 //! [integral_operators]
diff --git a/example/type.cpp b/example/type.cpp
index 948d45233..e744fd787 100644
--- a/example/type.cpp
+++ b/example/type.cpp
@@ -8,7 +8,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/ext/std/integral_constant.hpp>
 #include <boost/hana/functional/on.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/tuple.hpp>
 #include <boost/hana/type.hpp>
 
diff --git a/include/boost/hana.hpp b/include/boost/hana.hpp
index c8f15e208..436309a05 100644
--- a/include/boost/hana.hpp
+++ b/include/boost/hana.hpp
@@ -54,7 +54,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/bool.hpp>
 #include <boost/hana/either.hpp>
 #include <boost/hana/integer_list.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/lazy.hpp>
 #include <boost/hana/map.hpp>
 #include <boost/hana/maybe.hpp>
@@ -462,7 +462,7 @@ variable template:
     constexpr unspecified integral{};
 @endcode
 
-where the type of `integral<...>`, while being unspecified, actually looks a
+where the type of `integral_constant<...>`, while being unspecified, actually looks a
 lot like a `std::integral_constant`. Indeed, an `Integral` is guaranteed to
 have the same members as an equivalent `std::integral_constant`, so they can
 be used as such
@@ -481,7 +481,7 @@ Additionally, `Integral`s can be created with the help of [user-defined literals
 
 However, this syntax only allows creating `Integral`s with an underlying value
 of type `long long`. Another feature of `Integral`s is that they overload
-common operators so that `integral<...>`s can be used with an intuitive
+common operators so that `integral_constant<...>`s can be used with an intuitive
 syntax:
 
 @snippet example/tutorial/basic_concepts/constant/integral.cpp integral_operators
@@ -490,7 +490,7 @@ It is important to realize that these operators return `Integral`s, not normal
 values of an integral type. Specifically, for an operator `@`,
 
 @code
-    integral<X, x> @ integral<Y, y> == integral<decltype(x @ y), x @ y>
+    integral_constant<X, x> @ integral_constant<Y, y> == integral_constant<decltype(x @ y), x @ y>
 @endcode
 
 This is very important because it allows all the information that's known at
diff --git a/include/boost/hana/constant.hpp b/include/boost/hana/constant.hpp
index f03f807e3..9147aa2ea 100644
--- a/include/boost/hana/constant.hpp
+++ b/include/boost/hana/constant.hpp
@@ -53,7 +53,9 @@ namespace boost { namespace hana {
         //! @todo
         //! This is an awful hack to avoid having
         //! @code
-        //!     common<Integral<int>, Integral<long>> == CanonicalConstant<long>
+        //!     common<IntegralConstant<int>, IntegralConstant<long>>
+        //!         ==
+        //!     CanonicalConstant<long>
         //! @endcode
         template <typename A, typename B, typename C>
         struct which {
diff --git a/include/boost/hana/foldable.hpp b/include/boost/hana/foldable.hpp
index 82b334651..007c243e2 100644
--- a/include/boost/hana/foldable.hpp
+++ b/include/boost/hana/foldable.hpp
@@ -27,7 +27,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/enumerable.hpp>
 #include <boost/hana/functional/id.hpp>
 #include <boost/hana/functional/partial.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/logical.hpp>
 #include <boost/hana/monoid.hpp>
 #include <boost/hana/orderable.hpp>
@@ -184,14 +184,14 @@ namespace boost { namespace hana {
         //! @todo Make it possible to specify the Monoid that's used?
         template <typename Xs>
         static constexpr decltype(auto) sum_impl(Xs&& xs) {
-            using M = Integral<int>;
+            using M = IntegralConstant<int>;
             return foldl(detail::std::forward<Xs>(xs), zero<M>(), plus);
         }
 
         //! @todo Make it possible to specify the Ring that's used?
         template <typename Xs>
         static constexpr decltype(auto) product_impl(Xs&& xs) {
-            using R = Integral<int>;
+            using R = IntegralConstant<int>;
             return foldl(detail::std::forward<Xs>(xs), one<R>(), mult);
         }
 
diff --git a/include/boost/hana/fwd/integer_list.hpp b/include/boost/hana/fwd/integer_list.hpp
index 574d5f705..68025c277 100644
--- a/include/boost/hana/fwd/integer_list.hpp
+++ b/include/boost/hana/fwd/integer_list.hpp
@@ -42,7 +42,7 @@ namespace boost { namespace hana {
     //! Creates a list containing the given `Integral`s.
     //! @relates IntegerList
     //!
-    //! This is functionally equivalent to `tuple(integral<T, xs>...)`.
+    //! This is functionally equivalent to `tuple(integral_constant<T, xs>...)`.
     //!
     //! ### Example
     //! @snippet example/integer_list/integer_list.cpp main
diff --git a/include/boost/hana/fwd/integral.hpp b/include/boost/hana/fwd/integral.hpp
deleted file mode 100644
index d567ec6d8..000000000
--- a/include/boost/hana/fwd/integral.hpp
+++ /dev/null
@@ -1,261 +0,0 @@
-/*!
-@file
-Forward declares `boost::hana::Integral`.
-
-@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)
- */
-
-#ifndef BOOST_HANA_FWD_INTEGRAL_HPP
-#define BOOST_HANA_FWD_INTEGRAL_HPP
-
-#include <boost/hana/core/datatype.hpp>
-#include <boost/hana/core/operators.hpp>
-#include <boost/hana/detail/n_times.hpp>
-#include <boost/hana/detail/std/forward.hpp>
-#include <boost/hana/detail/std/remove_cv.hpp>
-#include <boost/hana/detail/std/size_t.hpp>
-#include <boost/hana/fwd/comparable.hpp>
-#include <boost/hana/fwd/group.hpp>
-#include <boost/hana/fwd/integral_domain.hpp>
-#include <boost/hana/fwd/logical.hpp>
-#include <boost/hana/fwd/monoid.hpp>
-#include <boost/hana/fwd/orderable.hpp>
-#include <boost/hana/fwd/ring.hpp>
-
-
-namespace boost { namespace hana {
-    //! @ingroup group-datatypes
-    //! Represents a compile-time value of an integral type.
-    //!
-    //! `Integral`s are guaranteed to have the same members and capabilities
-    //! as the corresponding `std::integral_constant`. For example, `Integral`s
-    //! are `constexpr`-convertible to their underlying type, they have a
-    //! nested static constant named `value` holding their underlying value,
-    //! and so on.
-    //!
-    //! `Integral`s also have a member function named `times`, which allows a
-    //! nullary function to be invoked `n` times.
-    //!
-    //! For convenience, common operators are overloaded to return the result
-    //! of the corresponding operator as an `integral<...>`.
-    //!
-    //! ## Overloaded operators
-    //! - Arithmetic: binary `+`, binary `-`, `/`, `*`, `%`, unary `+`,
-    //!                                                      unary `-`
-    //! - Bitwise: `~`, `&`, `|`, `^`, `<<`, `>>`
-    //! - Comparison: `==`, `!=`, `<`, `<=`, `>`, `>=`
-    //! - Logical: `||`, `&&`, `!`
-    //! - Member access: `*` (dereference)
-    //!
-    //! ## Example
-    //! @snippet example/integral.cpp operators
-    //!
-    //! ## Instance of
-    //! `Comparable`, `Orderable`, `Constant`, `Logical`, `Monoid`, `Group`,
-    //! `Ring`, `IntegralDomain`, and `IntegralConstant`.
-    //!
-    //! @todo
-    //! Implicit conversions to the underlying integral type can be problematic:
-    //! @code
-    //!     constexpr auto odd = [](auto x) {
-    //!         return x % int_<2>;
-    //!     };
-    //!
-    //!     if_(odd(int_<1>), something_of_type_A, something_of_type_B)
-    //! @endcode
-    //! This will fail because `odd(int_<1>)` has type `Int<1 % 2>`, which is
-    //! convertible to `bool` but not to `Bool<...>`. Because of this, the
-    //! runtime `if_` is used and compilation fails.
-    //!
-    //! @todo
-    //! `times` should be a shortcut to some type class method. Specifically,
-    //! anything that can be incremented, decremented and compared to some
-    //! "zero" value can implement a `times` method with the same semantics.
-    template <typename T>
-    struct Integral {
-        struct hana {
-            struct enabled_operators
-                : Comparable, Orderable,
-                  Logical,
-                  Monoid, Group, Ring, IntegralDomain
-            { };
-        };
-        using value_type = T;
-    };
-
-    namespace integral_detail {
-        template <typename T, T v>
-        struct integral : operators::enable_adl {
-            using type = integral;
-            using value_type = T;
-            static constexpr value_type value = v;
-            constexpr operator value_type() const noexcept { return value; }
-            constexpr value_type operator()() const noexcept { return value; }
-
-            struct hana {
-                using datatype = Integral<
-                    typename boost::hana::datatype<T>::type
-                >;
-            };
-
-            template <typename F>
-            constexpr void times(F&& f) const {
-                detail::n_times<v>(detail::std::forward<F>(f));
-            }
-        };
-
-#define BOOST_HANA_INTEGRAL_BINARY_OP(op)                                   \
-    template <typename U, U u, typename V, V v>                             \
-    constexpr integral<decltype(u op v), (u op v)>                          \
-    operator op(integral<U, u>, integral<V, v>)                             \
-    { return {}; }                                                          \
-/**/
-
-#define BOOST_HANA_INTEGRAL_UNARY_OP(op)                                    \
-    template <typename U, U u>                                              \
-    constexpr integral<decltype(op u), (op u)>                              \
-    operator op(integral<U, u>)                                             \
-    { return {}; }                                                          \
-/**/
-
-        // Arithmetic
-        BOOST_HANA_INTEGRAL_UNARY_OP(+)
-
-        // Bitwise
-        BOOST_HANA_INTEGRAL_UNARY_OP(~)
-        BOOST_HANA_INTEGRAL_BINARY_OP(&)
-        BOOST_HANA_INTEGRAL_BINARY_OP(|)
-        BOOST_HANA_INTEGRAL_BINARY_OP(^)
-        BOOST_HANA_INTEGRAL_BINARY_OP(<<)
-        BOOST_HANA_INTEGRAL_BINARY_OP(>>)
-
-#undef BOOST_HANA_INTEGRAL_UNARY_OP
-#undef BOOST_HANA_INTEGRAL_BINARY_OP
-    } // end namespace integral_detail
-
-    //! A compile-time integral value of the given type and value.
-    //! @relates Integral
-    //!
-    //! @note
-    //! For any `const-volatility` specifier `cv`, `integral<T cv, n>` is
-    //! always the same as `integral<T, n>`.
-    //!
-    //! @internal
-    //! ### Rationale for striping cv-specifiers
-    //! In the following idiom,
-    //! @code
-    //!     integral<decltype(Trait::value), Trait::value>
-    //! @endcode
-    //! if `Trait::value` is declared as `static const T value = ...;`, then
-    //! `decltype(Trait::value)` is `T const` instead of `T`. This causes
-    //! unintuitive behavior in some cases. For example, with a definition
-    //! of `trait::is_floating_point` using the above idiom,
-    //! @code
-    //!     static_assert(
-    //!         decltype_(trait::is_floating_point(type<char>)) ==
-    //!         decltype_(false_)
-    //!     , "");
-    //! @endcode
-    //! will fail, but the following will succeed
-    //! @code
-    //!     static_assert(
-    //!         decltype_(trait::is_floating_point(type<char>)) ==
-    //!         decltype_(integral<bool const, false>)
-    //!     , "");
-    //! @endcode
-    //! Since there does not seem to be a lot of use cases for keeping
-    //! cv-qualifiers in the integral type, we just remove them.
-    //!
-    //! @todo
-    //! Do we want `char_<1> + char_<2> == char_<3>` or
-    //! `char_<1> + char_<2> == int_<3>`?
-    //!
-    //! @todo
-    //! Consider specifying the type of `integral<...>` to allow overloading
-    //! on its type. Not sure yet whether that's desirable or not.
-    template <typename T, T v>
-    constexpr integral_detail::integral<
-        typename detail::std::remove_cv<T>::type, v
-    > integral{};
-
-    //! @relates Integral
-    template <char c>
-    constexpr auto char_ = decltype(integral<char, c>){};
-
-    //! @relates Integral
-    template <short i>
-    constexpr auto short_ = decltype(integral<short, i>){};
-
-    //! @relates Integral
-    template <unsigned short i>
-    constexpr auto ushort = decltype(integral<unsigned short, i>){};
-
-    //! @relates Integral
-    template <int i>
-    constexpr auto int_ = decltype(integral<int, i>){};
-
-    //! @relates Integral
-    template <unsigned int i>
-    constexpr auto uint = decltype(integral<unsigned int, i>){};
-
-    //! @relates Integral
-    template <long i>
-    constexpr auto long_ = decltype(integral<long, i>){};
-
-    //! @relates Integral
-    template <unsigned long i>
-    constexpr auto ulong = decltype(integral<unsigned long, i>){};
-
-    //! @relates Integral
-    template <long long i>
-    constexpr auto llong = decltype(integral<long long, i>){};
-
-    //! @relates Integral
-    template <unsigned long long i>
-    constexpr auto ullong = decltype(integral<unsigned long long, i>){};
-
-    //! @relates Integral
-    template <detail::std::size_t i>
-    constexpr auto size_t = decltype(integral<detail::std::size_t, i>){};
-
-    namespace integral_detail {
-        constexpr int to_int(char c)
-        { return static_cast<int>(c) - 48; }
-
-        template <detail::std::size_t N>
-        constexpr long long parse(const char (&arr)[N]) {
-            long long number = 0, base = 1;
-            for (decltype(N) i = 0; i < N; ++i) {
-                number += to_int(arr[N - 1 - i]) * base;
-                base *= 10;
-            }
-            return number;
-        }
-    }
-
-    namespace literals {
-        //! Creates an `Integral` from a literal.
-        //! @relates boost::hana::Integral
-        //!
-        //! The literal is parsed at compile-time and the result is returned
-        //! as an `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.cpp literals
-        //!
-        //! @todo Add support for stuff like `0x1234_c`.
-        template <char ...c>
-        constexpr auto operator"" _c()
-        { return llong<integral_detail::parse<sizeof...(c)>({c...})>; }
-    }
-}} // end namespace boost::hana
-
-#endif // !BOOST_HANA_FWD_INTEGRAL_HPP
diff --git a/include/boost/hana/fwd/integral_constant.hpp b/include/boost/hana/fwd/integral_constant.hpp
new file mode 100644
index 000000000..232707a58
--- /dev/null
+++ b/include/boost/hana/fwd/integral_constant.hpp
@@ -0,0 +1,247 @@
+/*!
+@file
+Forward declares `boost::hana::IntegralConstant`.
+
+@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)
+ */
+
+#ifndef BOOST_HANA_FWD_INTEGRAL_CONSTANT_HPP
+#define BOOST_HANA_FWD_INTEGRAL_CONSTANT_HPP
+
+#include <boost/hana/detail/std/size_t.hpp>
+
+
+namespace boost { namespace hana {
+    //! @ingroup group-datatypes
+    //! Represents a compile-time value of an integral type.
+    //!
+    //! An `IntegralConstant` is an object that represents a compile-time
+    //! integral value. In fact, as the name suggests, an `IntegralConstant`
+    //! is basically equivalent to a `std::integral_constant`, except that
+    //! Hana's `IntegralConstant`s also provide other goodies to make them
+    //! easier to use. In particular, `IntegralConstant`s are guaranteed to
+    //! have the same members and capabilities as `std::integral_constant`s.
+    //! For example, `IntegralConstant`s are `constexpr`-convertible to their
+    //! underlying type, they have a nested static constant named `value`
+    //! holding their underlying value, and so on.
+    //!
+    //! > #### Rationale for not sticking with `std::integral_constant`
+    //! > First, we wanted to have arithmetic operators and other goodies,
+    //! > which is much harder if we don't use our own objects. Second, using
+    //! > `std::integral_constant` requires including the whole `<type_traits>`
+    //! > header, which is about half the size of the whole Hana library.
+    //!
+    //!
+    //! As outlined above, the interface of an `IntegralConstant` is a
+    //! superset of what's provided by `std::integral_constant`. The sections
+    //! below explain those additions.
+    //!
+    //!
+    //! Arithmetic operators
+    //! --------------------
+    //! `IntegralConstant` provides arithmetic operators that return
+    //! `IntegralConstant`s, so compile-time arithmetic can be done easily:
+    //! @snippet example/integral_constant.cpp operators
+    //!
+    //! All those operators work pretty much in the same way. Simply put,
+    //! @code
+    //!     integral_constant<T, x> op integral_constant<T, y> == integral_constant<T, x op y>
+    //! @endcode
+    //!
+    //! The full range of provided operators is
+    //! - Arithmetic: binary `+`, binary `-`, `/`, `*`, `%`, unary `+`, unary `-`
+    //! - Bitwise: `~`, `&`, `|`, `^`, `<<`, `>>`
+    //! - Comparison: `==`, `!=`, `<`, `<=`, `>`, `>=`
+    //! - Logical: `||`, `&&`, `!`
+    //! - Member access: `*` (dereference)
+    //!
+    //!
+    //! `times` function
+    //! ----------------
+    //! `IntegralConstant`s also have a static member function object named
+    //! `times`, which allows a nullary function to be invoked `n` times:
+    //! @code
+    //!     int_<3>.times(f)
+    //! @endcode
+    //! should be expanded by any decent compiler to
+    //! @code
+    //!     f(); f(); f();
+    //! @endcode
+    //!
+    //! This can be useful in several contexts, e.g. for loop unrolling:
+    //! @snippet example/integral_constant.cpp times_loop_unrolling
+    //!
+    //! Note that `times` is really a static function object. Since static
+    //! members can be accessed using both the `.` and the `::` syntax, Hana
+    //! takes advantage of this (loophole?) to make `times` accessible both
+    //! from the type of an `IntegralConstant` object and from an object
+    //! itself:
+    //! @snippet example/integral_constant.cpp as_static_member
+    //!
+    //! Also, since `times` is a function object instead of an
+    //! overloaded function, it does not need to be called right away, which
+    //! can be useful in conjunction with some higher-order algorithms:
+    //! @snippet example/integral_constant.cpp times_higher_order
+    //!
+    //! Sometimes, it is also useful to know the index we're at inside the
+    //! function. This is also possible:
+    //! @snippet example/integral_constant.cpp times_with_index_runtime
+    //!
+    //! Remember that `times` is a _function object_, and hence it can have
+    //! subobjects. `with_index` is then just a function object nested inside
+    //! `times`, which allows for this nice little interface. Also note that
+    //! the indices passed to the function are `IntegralConstant`s; they are
+    //! known at compile-time. Hence, we can do compile-time stuff with them,
+    //! like indexing inside a tuple:
+    //! @snippet example/integral_constant.cpp times_with_index_compile_time
+    //!
+    //!
+    //! Construction with user-defined literals
+    //! ---------------------------------------
+    //! `IntegralConstant`s of type `long long` can be created with the
+    //! `_c` user-defined literal, which is contained in the `literals`
+    //! namespace:
+    //! @snippet example/integral_constant.cpp literals
+    //!
+    //!
+    //! Modeled concepts
+    //! ----------------
+    //! 1. `Constant`\n
+    //! An `IntegralConstant` is a model of the `Constant` concept in the most
+    //! obvious way possible. Specifically,
+    //! @code
+    //!     constexpr auto c = integral_constant<int, 10>;
+    //!     static_assert(value2<decltype(c)>() == 10, "");
+    //! @endcode
+    //!
+    //! 2. `Comparable`, `Orderable`, `Logical`, `Monoid`, `Group`, `Ring`,
+    //!    and `IntegralDomain` (operators provided)\n
+    //! Those models are exactly those provided for `Constant`s, which are
+    //! documented in their respective concepts.
+    //!
+    //!
+    //! @todo
+    //! `times` should be a shortcut to some tag-dispatched method. Specifically,
+    //! anything that can be incremented, decremented and compared to some
+    //! "zero" value can implement a `times` method with the same semantics.
+    //!
+    //! @todo
+    //! Implicit conversions to the underlying integral type can be problematic:
+    //! @code
+    //!     constexpr auto odd = [](auto x) {
+    //!         return x % int_<2>;
+    //!     };
+    //!
+    //!     if_(odd(int_<1>), something_of_type_A, something_of_type_B)
+    //! @endcode
+    //! This will fail because `odd(int_<1>)` has type `Int<1 % 2>`, which is
+    //! convertible to `bool` but not to `Bool<...>`. Because of this, the
+    //! runtime `if_` is used and compilation fails.
+    template <typename T>
+    struct IntegralConstant {
+        using value_type = T;
+    };
+
+    //! Creates an `IntegralConstant` holding the given compile-time value.
+    //! @relates IntegralConstant
+    //!
+    //! Specifically, `integral_constant<T, v` is an `IntegralConstant`
+    //! holding the compile-time value `v` of an integral type `T`.
+    //!
+    //!
+    //! @tparam T
+    //! The type of the value to hold in the `IntegralConstant`. It must be an
+    //! integral type.
+    //!
+    //! @tparam v
+    //! The integral value to hold in the `IntegralConstant`.
+    //!
+    //!
+    //! Example
+    //! -------
+    //! @snippet example/integral_constant.cpp integral_constant
+    //!
+    //!
+    //! @todo
+    //! - Do we want `char_<1> + char_<2> == char_<3>` or
+    //!   `char_<1> + char_<2> == int_<3>`?
+    //! - Consider specifying the type of `integral_constant<...>` to allow
+    //!   overloading on its type. Not sure yet whether that's desirable or not.
+#ifdef BOOST_HANA_DOXYGEN_INVOKED
+    template <typename T, T v>
+    constexpr unspecified-type integral_constant{};
+#else
+    template <typename T, T v>
+    struct _integral_constant;
+
+    template <typename T, T v>
+    constexpr _integral_constant<T, v> integral_constant{};
+#endif
+
+    //! @relates IntegralConstant
+    template <char c>
+    constexpr auto char_ = integral_constant<char, c>;
+
+    //! @relates IntegralConstant
+    template <short i>
+    constexpr auto short_ = integral_constant<short, i>;
+
+    //! @relates IntegralConstant
+    template <unsigned short i>
+    constexpr auto ushort = integral_constant<unsigned short, i>;
+
+    //! @relates IntegralConstant
+    template <int i>
+    constexpr auto int_ = integral_constant<int, i>;
+
+    //! @relates IntegralConstant
+    template <unsigned int i>
+    constexpr auto uint = integral_constant<unsigned int, i>;
+
+    //! @relates IntegralConstant
+    template <long i>
+    constexpr auto long_ = integral_constant<long, i>;
+
+    //! @relates IntegralConstant
+    template <unsigned long i>
+    constexpr auto ulong = integral_constant<unsigned long, i>;
+
+    //! @relates IntegralConstant
+    template <long long i>
+    constexpr auto llong = integral_constant<long long, i>;
+
+    //! @relates IntegralConstant
+    template <unsigned long long i>
+    constexpr auto ullong = integral_constant<unsigned long long, i>;
+
+    //! @relates IntegralConstant
+    template <detail::std::size_t i>
+    constexpr auto size_t = integral_constant<detail::std::size_t, i>;
+
+    namespace literals {
+        //! Creates an `IntegralConstant` from a literal.
+        //! @relates boost::hana::IntegralConstant
+        //!
+        //! The literal is parsed at compile-time and the result is returned
+        //! as an `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
+        //!
+        //! @todo Add support for stuff like `0x1234_c`.
+        template <char ...c>
+        constexpr auto operator"" _c();
+    }
+}} // end namespace boost::hana
+
+#endif // !BOOST_HANA_FWD_INTEGRAL_CONSTANT_HPP
diff --git a/include/boost/hana/fwd/iterable.hpp b/include/boost/hana/fwd/iterable.hpp
index 712981dd4..16c0345ef 100644
--- a/include/boost/hana/fwd/iterable.hpp
+++ b/include/boost/hana/fwd/iterable.hpp
@@ -15,7 +15,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/core/when.hpp>
 #include <boost/hana/detail/std/forward.hpp>
 #include <boost/hana/detail/std/size_t.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 
 
 namespace boost { namespace hana {
diff --git a/include/boost/hana/fwd/list.hpp b/include/boost/hana/fwd/list.hpp
index 22ddc261e..b9faa2118 100644
--- a/include/boost/hana/fwd/list.hpp
+++ b/include/boost/hana/fwd/list.hpp
@@ -19,7 +19,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/detail/std/forward.hpp>
 #include <boost/hana/detail/std/is_same.hpp>
 #include <boost/hana/detail/std/size_t.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 
 
 namespace boost { namespace hana {
diff --git a/include/boost/hana/fwd/range.hpp b/include/boost/hana/fwd/range.hpp
index 59d7fd98b..6d8d7e7b9 100644
--- a/include/boost/hana/fwd/range.hpp
+++ b/include/boost/hana/fwd/range.hpp
@@ -11,7 +11,7 @@ Distributed under the Boost Software License, Version 1.0.
 #define BOOST_HANA_FWD_RANGE_HPP
 
 #include <boost/hana/core/operators.hpp>
-#include <boost/hana/fwd/integral.hpp>
+#include <boost/hana/fwd/integral_constant.hpp>
 
 
 namespace boost { namespace hana {
@@ -91,7 +91,8 @@ namespace boost { namespace hana {
     //! This shorthand is provided for convenience only and it is equivalent
     //! to `range`. Specifically, `range_c<T, from, to>` is such that
     //! @code
-    //!     range_c<T, from, to> == range(integral<T, from>, integral<T, to>)
+    //!     range_c<T, from, to> == range(integral_constant<T, from>,
+    //!                                   integral_constant<T, to>)
     //! @endcode
     //!
     //!
@@ -109,7 +110,8 @@ namespace boost { namespace hana {
     //! -------
     //! @snippet example/range.cpp range_c
     template <typename T, T from, T to>
-    constexpr auto range_c = range(integral<T, from>, integral<T, to>);
+    constexpr auto range_c = range(integral_constant<T, from>,
+                                   integral_constant<T, to>);
 }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_RANGE_HPP
diff --git a/include/boost/hana/fwd/ring.hpp b/include/boost/hana/fwd/ring.hpp
index b1ed24fc7..37b41a87b 100644
--- a/include/boost/hana/fwd/ring.hpp
+++ b/include/boost/hana/fwd/ring.hpp
@@ -198,7 +198,7 @@ namespace boost { namespace hana {
     //! A `Ring` element that is elevated to its `n`th power.
     //!
     //! @param n
-    //! An `IntegralConstant` representing the power to which `r` is elevated.
+    //! An integral `Constant` representing the power to which `r` is elevated.
     //!
     //!
     //! @note
diff --git a/include/boost/hana/fwd/tuple.hpp b/include/boost/hana/fwd/tuple.hpp
index 2a4a2b9e4..0f1bf61de 100644
--- a/include/boost/hana/fwd/tuple.hpp
+++ b/include/boost/hana/fwd/tuple.hpp
@@ -16,7 +16,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/fwd/comparable.hpp>
 #include <boost/hana/fwd/iterable.hpp>
 #include <boost/hana/fwd/monad.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/type.hpp>
 
 
@@ -63,7 +63,7 @@ namespace boost { namespace hana {
     constexpr auto tuple_t = tuple(type<T>...);
 
     template <typename T, T ...v>
-    constexpr auto tuple_c = tuple(integral<T, v>...);
+    constexpr auto tuple_c = tuple(integral_constant<T, v>...);
 }} // end namespace boost::hana
 
 #endif // !BOOST_HANA_FWD_TUPLE_HPP
diff --git a/include/boost/hana/fwd/type.hpp b/include/boost/hana/fwd/type.hpp
index 4773f10a3..b4ce24ebb 100644
--- a/include/boost/hana/fwd/type.hpp
+++ b/include/boost/hana/fwd/type.hpp
@@ -410,7 +410,7 @@ namespace boost { namespace hana {
     //! Specifically, `trait<f>(t...)` is equivalent to `template_<f>(t...)()`.
     //! The principal use case for `trait` is to transform metafunctions
     //! inheriting from a meaningful base like `std::integral_constant`
-    //! into functions returning e.g. an `Integral`.
+    //! into functions returning e.g. an `IntegralConstant`.
     //!
     //! The word `trait` is used because a name was needed and the principal
     //! use case involves metafunctions from the standard that we also call
diff --git a/include/boost/hana/integer_list.hpp b/include/boost/hana/integer_list.hpp
index 949742b8e..4cb098f94 100644
--- a/include/boost/hana/integer_list.hpp
+++ b/include/boost/hana/integer_list.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/fwd/integer_list.hpp>
 
 #include <boost/hana/bool.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 
 // instances
 #include <boost/hana/iterable.hpp>
@@ -23,14 +23,14 @@ Distributed under the Boost Software License, Version 1.0.
 namespace boost { namespace hana {
     //! Instance of `Iterable` for `IntegerList`s.
     //!
-    //! The head of `integer_list<T, x, xs...>` is `integral<T, x>`, its tail
+    //! The head of `integer_list<T, x, xs...>` is `integral_constant<T, x>`, its tail
     //! is `integer_list<T, xs...>` and an integer list is empty if and only
     //! if it contains no integers at all.
     template <>
     struct Iterable::instance<IntegerList> : Iterable::mcd {
         template <typename T, T x, T ...xs>
         static constexpr auto head_impl(ilist_detail::integer_list<T, x, xs...>) {
-            return integral<T, x>;
+            return integral_constant<T, x>;
         }
 
         template <typename T, T x, T ...xs>
diff --git a/include/boost/hana/integral.hpp b/include/boost/hana/integral.hpp
deleted file mode 100644
index eaae467d2..000000000
--- a/include/boost/hana/integral.hpp
+++ /dev/null
@@ -1,67 +0,0 @@
-/*!
-@file
-Defines `boost::hana::Integral`.
-
-@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)
- */
-
-#ifndef BOOST_HANA_INTEGRAL_HPP
-#define BOOST_HANA_INTEGRAL_HPP
-
-#include <boost/hana/fwd/integral.hpp>
-
-#include <boost/hana/comparable.hpp>
-#include <boost/hana/constant.hpp>
-#include <boost/hana/core/convert.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/integral_constant.hpp>
-#include <boost/hana/detail/std/is_integral.hpp>
-#include <boost/hana/enumerable.hpp>
-#include <boost/hana/group.hpp>
-#include <boost/hana/integral_domain.hpp>
-#include <boost/hana/logical.hpp>
-#include <boost/hana/monoid.hpp>
-#include <boost/hana/orderable.hpp>
-#include <boost/hana/ring.hpp>
-
-
-namespace boost { namespace hana {
-    //////////////////////////////////////////////////////////////////////////
-    // Constant
-    //////////////////////////////////////////////////////////////////////////
-    template <typename T>
-    struct models<Constant(Integral<T>)>
-        : detail::std::true_type
-    { };
-
-    template <typename T>
-    struct value_impl<Integral<T>> {
-        template <typename C>
-        static constexpr auto apply(C const&)
-        { return C::value; }
-    };
-
-    template <typename T, typename C>
-    struct to_impl<Integral<T>, C, when<
-        models<Constant(C)>{} &&
-        detail::std::is_integral<typename C::value_type>{}
-    >>
-        : embedding<is_embedded<typename C::value_type, T>{}>
-    {
-        static_assert(detail::std::is_integral<T>{},
-        "trying to convert a Constant to an Integral of a non-integral "
-        "type; boost::hana::Integral may only hold integral types");
-
-        template <typename X>
-        static constexpr auto apply(X x) {
-            constexpr auto v = hana::value(x);
-            return integral<T, static_cast<T>(v)>;
-        }
-    };
-}} // end namespace boost::hana
-
-#endif // !BOOST_HANA_INTEGRAL_HPP
diff --git a/include/boost/hana/integral_constant.hpp b/include/boost/hana/integral_constant.hpp
new file mode 100644
index 000000000..6c899a026
--- /dev/null
+++ b/include/boost/hana/integral_constant.hpp
@@ -0,0 +1,197 @@
+/*!
+@file
+Defines `boost::hana::IntegralConstant`.
+
+@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)
+ */
+
+#ifndef BOOST_HANA_INTEGRAL_CONSTANT_HPP
+#define BOOST_HANA_INTEGRAL_CONSTANT_HPP
+
+#include <boost/hana/fwd/integral_constant.hpp>
+
+#include <boost/hana/constant.hpp>
+#include <boost/hana/core/convert.hpp>
+#include <boost/hana/core/datatype.hpp>
+#include <boost/hana/core/models.hpp>
+#include <boost/hana/core/operators.hpp>
+#include <boost/hana/detail/std/forward.hpp>
+#include <boost/hana/detail/std/integer_sequence.hpp>
+#include <boost/hana/detail/std/integral_constant.hpp>
+#include <boost/hana/detail/std/is_integral.hpp>
+#include <boost/hana/detail/std/size_t.hpp>
+
+// provided models
+#include <boost/hana/comparable.hpp>
+#include <boost/hana/group.hpp>
+#include <boost/hana/integral_domain.hpp>
+#include <boost/hana/logical.hpp>
+#include <boost/hana/monoid.hpp>
+#include <boost/hana/orderable.hpp>
+#include <boost/hana/ring.hpp>
+
+
+namespace boost { namespace hana {
+    //////////////////////////////////////////////////////////////////////////
+    // integral_constant
+    //////////////////////////////////////////////////////////////////////////
+    namespace ic_detail {
+        template <typename T, T N, typename = detail::std::make_integer_sequence<T, N>>
+        struct go;
+
+        template <typename T, T N, T ...i>
+        struct go<T, N, detail::std::integer_sequence<T, i...>> {
+            using swallow = T[];
+
+            template <typename F>
+            static constexpr void with_index(F&& f)
+            { (void)swallow{T{}, ((void)f(integral_constant<T, i>), i)...}; }
+
+            template <typename F>
+            static constexpr void without_index(F&& f)
+            { (void)swallow{T{}, ((void)f(), i)...}; }
+        };
+
+        template <typename T, T v>
+        struct _with_index {
+            template <typename F>
+            constexpr void operator()(F&& f) const
+            { go<T, (sizeof(F), v)>::with_index(detail::std::forward<F>(f)); }
+        };
+
+        template <typename T, T v>
+        struct _times {
+            static constexpr _with_index<T, v> with_index{};
+
+            template <typename F>
+            constexpr void operator()(F&& f) const
+            { go<T, (sizeof(F), v)>::without_index(detail::std::forward<F>(f)); }
+        };
+
+        // avoid link-time error
+        template <typename T, T v>
+        constexpr _with_index<T, v> _times<T, v>::with_index;
+    }
+
+    template <typename T, T v>
+    struct _integral_constant : operators::enable_adl {
+        // std::integral_constant interface
+        using type = _integral_constant;
+        using value_type = T;
+        static constexpr value_type value = v;
+        constexpr operator value_type() const noexcept { return value; }
+        constexpr value_type operator()() const noexcept { return value; }
+
+        // times
+        static constexpr ic_detail::_times<T, v> times{};
+    };
+
+    // avoid link-time error
+    template <typename T, T v>
+    constexpr ic_detail::_times<T, v> _integral_constant<T, v>::times;
+
+    template <typename T, T v>
+    struct datatype<_integral_constant<T, v>> {
+        using type = IntegralConstant<T>;
+    };
+
+    //////////////////////////////////////////////////////////////////////////
+    // Operators (most of them are provided by the concepts)
+    //////////////////////////////////////////////////////////////////////////
+    template <typename T>
+    struct enabled_operators<IntegralConstant<T>>
+        : Comparable, Orderable
+        , Logical
+        , Monoid, Group, Ring, IntegralDomain
+    { };
+
+#define BOOST_HANA_INTEGRAL_CONSTANT_BINARY_OP(op)                          \
+    template <typename U, U u, typename V, V v>                             \
+    constexpr _integral_constant<decltype(u op v), (u op v)>                \
+    operator op(_integral_constant<U, u>, _integral_constant<V, v>)         \
+    { return {}; }                                                          \
+    /**/
+
+#define BOOST_HANA_INTEGRAL_CONSTANT_UNARY_OP(op)                           \
+    template <typename U, U u>                                              \
+    constexpr _integral_constant<decltype(op u), (op u)>                    \
+    operator op(_integral_constant<U, u>)                                   \
+    { return {}; }                                                          \
+    /**/
+
+    // Arithmetic
+    BOOST_HANA_INTEGRAL_CONSTANT_UNARY_OP(+)
+
+    // Bitwise
+    BOOST_HANA_INTEGRAL_CONSTANT_UNARY_OP(~)
+    BOOST_HANA_INTEGRAL_CONSTANT_BINARY_OP(&)
+    BOOST_HANA_INTEGRAL_CONSTANT_BINARY_OP(|)
+    BOOST_HANA_INTEGRAL_CONSTANT_BINARY_OP(^)
+    BOOST_HANA_INTEGRAL_CONSTANT_BINARY_OP(<<)
+    BOOST_HANA_INTEGRAL_CONSTANT_BINARY_OP(>>)
+
+#undef BOOST_HANA_INTEGRAL_CONSTANT_UNARY_OP
+#undef BOOST_HANA_INTEGRAL_CONSTANT_BINARY_OP
+
+
+    //////////////////////////////////////////////////////////////////////////
+    // User-defined literal
+    //////////////////////////////////////////////////////////////////////////
+    namespace ic_detail {
+        constexpr int to_int(char c)
+        { return static_cast<int>(c) - 48; }
+
+        template <detail::std::size_t N>
+        constexpr long long parse(const char (&arr)[N]) {
+            long long number = 0, base = 1;
+            for (detail::std::size_t i = 0; i < N; ++i) {
+                number += to_int(arr[N - 1 - i]) * base;
+                base *= 10;
+            }
+            return number;
+        }
+    }
+
+    namespace literals {
+        template <char ...c>
+        constexpr auto operator"" _c()
+        { return llong<ic_detail::parse<sizeof...(c)>({c...})>; }
+    }
+
+    //////////////////////////////////////////////////////////////////////////
+    // Model of Constant
+    //////////////////////////////////////////////////////////////////////////
+    template <typename T>
+    struct models<Constant(IntegralConstant<T>)>
+        : detail::std::true_type
+    { };
+
+    template <typename T>
+    struct value_impl<IntegralConstant<T>> {
+        template <typename C>
+        static constexpr auto apply(C const&)
+        { return C::value; }
+    };
+
+    template <typename T, typename C>
+    struct to_impl<IntegralConstant<T>, C, when<
+        models<Constant(C)>{} &&
+        detail::std::is_integral<typename C::value_type>{}
+    >>
+        : embedding<is_embedded<typename C::value_type, T>{}>
+    {
+        static_assert(detail::std::is_integral<T>{},
+        "trying to convert a Constant to an IntegralConstant of a non-integral "
+        "type; boost::hana::IntegralConstant may only hold integral types");
+
+        template <typename X>
+        static constexpr auto apply(X x) {
+            constexpr auto v = hana::value(x);
+            return integral_constant<T, static_cast<T>(v)>;
+        }
+    };
+}} // end namespace boost::hana
+
+#endif // !BOOST_HANA_INTEGRAL_CONSTANT_HPP
diff --git a/include/boost/hana/list.hpp b/include/boost/hana/list.hpp
index 126f63f4b..15b1ac5f7 100644
--- a/include/boost/hana/list.hpp
+++ b/include/boost/hana/list.hpp
@@ -30,7 +30,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/functional/partial.hpp>
 #include <boost/hana/functor.hpp>
 #include <boost/hana/group.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/iterable.hpp>
 #include <boost/hana/logical.hpp>
 #include <boost/hana/maybe.hpp>
diff --git a/include/boost/hana/range.hpp b/include/boost/hana/range.hpp
index 8d9246b57..16cce589a 100644
--- a/include/boost/hana/range.hpp
+++ b/include/boost/hana/range.hpp
@@ -26,7 +26,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/enumerable.hpp>
 #include <boost/hana/foldable.hpp>
 #include <boost/hana/group.hpp>
-#include <boost/hana/integral.hpp> // required by fwd decl
+#include <boost/hana/integral_constant.hpp> // required by fwd decl
 #include <boost/hana/iterable.hpp>
 #include <boost/hana/logical.hpp>
 #include <boost/hana/monoid.hpp>
@@ -115,7 +115,7 @@ namespace boost { namespace hana {
         unpack_helper(R r, F&& f, detail::std::integer_sequence<T, v...>) {
             using U = typename R::underlying;
             constexpr auto from = hana::value(r.from);
-            return detail::std::forward<F>(f)(to<U>(integral<T, from + v>)...);
+            return detail::std::forward<F>(f)(to<U>(integral_constant<T, from + v>)...);
         }
 
         template <typename R, typename F>
@@ -184,7 +184,7 @@ namespace boost { namespace hana {
             constexpr auto from = hana::value(r.from);
             constexpr auto to = hana::value(r.to);
             constexpr auto s = from == to ? 0 : sum_helper(from, to-1);
-            return hana::to<U>(integral<decltype(s), s>);
+            return hana::to<U>(integral_constant<decltype(s), s>);
         }
     };
 
@@ -209,7 +209,7 @@ namespace boost { namespace hana {
             constexpr auto from = hana::value(r.from);
             constexpr auto to = hana::value(r.to);
             constexpr auto s = product_helper(from, to);
-            return hana::to<U>(integral<decltype(s), s>);
+            return hana::to<U>(integral_constant<decltype(s), s>);
         }
     };
 
diff --git a/include/boost/hana/sandbox/lambda_tuple.hpp b/include/boost/hana/sandbox/lambda_tuple.hpp
index fb8e59a89..0bc9865a8 100644
--- a/include/boost/hana/sandbox/lambda_tuple.hpp
+++ b/include/boost/hana/sandbox/lambda_tuple.hpp
@@ -79,7 +79,7 @@ namespace boost { namespace hana { namespace sandbox {
 #include <boost/hana/functional/always.hpp>
 #include <boost/hana/functional/id.hpp>
 #include <boost/hana/functional/on.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/orderable.hpp>
 #include <boost/hana/range.hpp>
 
diff --git a/include/boost/hana/string.hpp b/include/boost/hana/string.hpp
index 22d0ff0e5..6ad350d55 100644
--- a/include/boost/hana/string.hpp
+++ b/include/boost/hana/string.hpp
@@ -24,7 +24,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/detail/std/integral_constant.hpp>
 #include <boost/hana/detail/std/size_t.hpp>
 #include <boost/hana/foldable.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/iterable.hpp>
 #include <boost/hana/logical.hpp>
 #include <boost/hana/maybe.hpp>
diff --git a/include/boost/hana/tuple.hpp b/include/boost/hana/tuple.hpp
index 442af3d30..3512558e2 100644
--- a/include/boost/hana/tuple.hpp
+++ b/include/boost/hana/tuple.hpp
@@ -26,7 +26,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/detail/std/size_t.hpp>
 #include <boost/hana/functional/apply.hpp>
 #include <boost/hana/functional/curry.hpp>
-#include <boost/hana/integral.hpp> // size_t
+#include <boost/hana/integral_constant.hpp> // size_t
 
 // instances
 #include <boost/hana/foldable.hpp>
diff --git a/include/boost/hana/type.hpp b/include/boost/hana/type.hpp
index ca8f4e0cc..21e646985 100644
--- a/include/boost/hana/type.hpp
+++ b/include/boost/hana/type.hpp
@@ -16,7 +16,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/comparable.hpp>
 #include <boost/hana/core/models.hpp>
 #include <boost/hana/detail/std/integral_constant.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 
 
 namespace boost { namespace hana {
diff --git a/test/bugs/integral_constexpr_init.cpp b/test/bugs/integral_constexpr_init.cpp
index 876b18e01..b7f739fdf 100644
--- a/test/bugs/integral_constexpr_init.cpp
+++ b/test/bugs/integral_constexpr_init.cpp
@@ -5,7 +5,7 @@ Distributed under the Boost Software License, Version 1.0.
  */
 
 #include <boost/hana/bool.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 using namespace boost::hana;
 
 
@@ -13,16 +13,16 @@ using namespace boost::hana;
 When we use `int_<...>` in a template, Clang 3.5 says:
 
 --------------------------------
-include/boost/hana/integral.hpp:80:20: error: constexpr variable 'int_<1>' must be initialized by a constant expression
+include/boost/hana/integral_constant.hpp:80:20: error: constexpr variable 'int_<1>' must be initialized by a constant expression
     constexpr auto int_ = integral<int, i>;
                    ^      ~~~~~~~~~~~~~~~~
 test/integral/constexpr_bug.cpp:41:37: note: in instantiation of variable template specialization 'boost::hana::int_' requested here
 constexpr auto check_int() { return int_<1>; }
                                     ^
-include/boost/hana/integral.hpp:80:27: note: subexpression not valid in a constant expression
+include/boost/hana/integral_constant.hpp:80:27: note: subexpression not valid in a constant expression
     constexpr auto int_ = integral<int, i>;
                           ^
-include/boost/hana/integral.hpp:80:27: note: in call to 'integral_type(integral)'
+include/boost/hana/integral_constant.hpp:80:27: note: in call to 'integral_type(integral)'
 --------------------------------
 
 if we define int_ & friends like
diff --git a/test/bugs/integral_strip_cv.cpp b/test/bugs/integral_strip_cv.cpp
deleted file mode 100644
index 48338c0c3..000000000
--- a/test/bugs/integral_strip_cv.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
-@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/integral.hpp>
-
-#include <boost/hana/assert.hpp>
-#include <boost/hana/type.hpp>
-using namespace boost::hana;
-
-
-template <typename T>
-constexpr void test_for() {
-    BOOST_HANA_CONSTANT_CHECK(equal(
-        decltype_(integral<T const, 0>),
-        decltype_(integral<T, 0>)
-    ));
-    BOOST_HANA_CONSTANT_CHECK(equal(
-        decltype_(integral<T volatile, 0>),
-        decltype_(integral<T, 0>)
-    ));
-    BOOST_HANA_CONSTANT_CHECK(equal(
-        decltype_(integral<T const volatile, 0>),
-        decltype_(integral<T, 0>)
-    ));
-}
-
-int main() {
-    test_for<bool>();
-    test_for<int>();
-    test_for<unsigned int>();
-    test_for<char>();
-    test_for<unsigned long long>();
-}
diff --git a/test/bugs/type_usability_in_tuple.cpp b/test/bugs/type_usability_in_tuple.cpp
index 7a1a128ac..37a0ce7a6 100644
--- a/test/bugs/type_usability_in_tuple.cpp
+++ b/test/bugs/type_usability_in_tuple.cpp
@@ -4,7 +4,7 @@ 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/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/tuple.hpp>
 #include <boost/hana/type.hpp>
 
diff --git a/test/ext/boost/mpl/integral_c.cpp b/test/ext/boost/mpl/integral_c.cpp
index 4f1799cc1..05d0e6f08 100644
--- a/test/ext/boost/mpl/integral_c.cpp
+++ b/test/ext/boost/mpl/integral_c.cpp
@@ -8,7 +8,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/assert.hpp>
 #include <boost/hana/core/datatype.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/tuple.hpp>
 #include <boost/hana/type.hpp>
 
diff --git a/test/ext/std/integral_constant.cpp b/test/ext/std/integral_constant.cpp
index 5e5955213..d10fd7613 100644
--- a/test/ext/std/integral_constant.cpp
+++ b/test/ext/std/integral_constant.cpp
@@ -7,7 +7,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/ext/std/integral_constant.hpp>
 
 #include <boost/hana/assert.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/tuple.hpp>
 #include <boost/hana/type.hpp>
 
diff --git a/test/functional/fix.cpp b/test/functional/fix.cpp
index 1e52e4d29..3d02a703f 100644
--- a/test/functional/fix.cpp
+++ b/test/functional/fix.cpp
@@ -9,7 +9,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/functional/always.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 using namespace boost::hana;
 
 
diff --git a/test/include/test/auto/iterable.hpp b/test/include/test/auto/iterable.hpp
index ab38d60d2..1e031c7cf 100644
--- a/test/include/test/auto/iterable.hpp
+++ b/test/include/test/auto/iterable.hpp
@@ -13,7 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/bool.hpp>
 #include <boost/hana/foldable.hpp>
 #include <boost/hana/functional/always.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/map.hpp>
 #include <boost/hana/maybe.hpp>
 #include <boost/hana/range.hpp>
diff --git a/test/include/test/auto/list.hpp b/test/include/test/auto/list.hpp
index 11bdedfda..0adbc048e 100644
--- a/test/include/test/auto/list.hpp
+++ b/test/include/test/auto/list.hpp
@@ -14,7 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/functional/compose.hpp>
 #include <boost/hana/functional/id.hpp>
 #include <boost/hana/functional/partial.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/maybe.hpp>
 
 // provided instances
diff --git a/test/include/test/auto/ring.hpp b/test/include/test/auto/ring.hpp
index 1172580bb..e43ed66b5 100644
--- a/test/include/test/auto/ring.hpp
+++ b/test/include/test/auto/ring.hpp
@@ -12,7 +12,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/assert.hpp>
 #include <boost/hana/comparable.hpp>
 #include <boost/hana/group.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/monoid.hpp>
 #include <test/auto/group.hpp>
 
diff --git a/test/integer_list.cpp b/test/integer_list.cpp
index b29db589a..868ee8e3e 100644
--- a/test/integer_list.cpp
+++ b/test/integer_list.cpp
@@ -7,7 +7,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/integer_list.hpp>
 
 #include <boost/hana/assert.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/tuple.hpp>
 #include <boost/hana/type.hpp>
 
@@ -84,19 +84,19 @@ int main() {
         // cons
         {
             BOOST_HANA_CONSTANT_CHECK(equal(
-                cons(integral<int, 0>, integer_list<long>),
+                cons(int_<0>, integer_list<long>),
                 integer_list<long, 0>
             ));
             BOOST_HANA_CONSTANT_CHECK(equal(
-                cons(integral<int, 0>, integer_list<unsigned int, 1>),
+                cons(int_<0>, integer_list<unsigned int, 1>),
                 integer_list<unsigned int, 0, 1>
             ));
             BOOST_HANA_CONSTANT_CHECK(equal(
-                cons(integral<long, 0>, integer_list<long long, 1, 2>),
+                cons(long_<0>, integer_list<long long, 1, 2>),
                 integer_list<long long, 0, 1, 2>
             ));
             BOOST_HANA_CONSTANT_CHECK(equal(
-                cons(integral<unsigned long, 0>, integer_list<unsigned long, 1, 2, 3>),
+                cons(ulong<0>, integer_list<unsigned long, 1, 2, 3>),
                 integer_list<unsigned long, 0, 1, 2, 3>
             ));
         }
diff --git a/test/integral.cpp b/test/integral_constant.cpp
similarity index 88%
rename from test/integral.cpp
rename to test/integral_constant.cpp
index a63708306..4f7501433 100644
--- a/test/integral.cpp
+++ b/test/integral_constant.cpp
@@ -4,7 +4,7 @@ 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/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 
 #include <boost/hana/tuple.hpp>
 #include <boost/hana/type.hpp>
@@ -19,24 +19,24 @@ using namespace boost::hana;
 
 namespace boost { namespace hana { namespace test {
     template <typename T>
-    auto objects<Integral<T>> = tuple(
-        integral<T, 0>,
-        integral<T, 1>,
-        integral<T, 2>,
-        integral<T, 3>
+    auto objects<IntegralConstant<T>> = tuple(
+        integral_constant<T, 0>,
+        integral_constant<T, 1>,
+        integral_constant<T, 2>,
+        integral_constant<T, 3>
     );
 
     template <typename T>
-    auto instances<Integral<T>> = tuple(
+    auto instances<IntegralConstant<T>> = tuple(
         type<Constant>
     );
 }}}
 
 
 int main() {
-    test::check_datatype<Integral<int>>();
+    test::check_datatype<IntegralConstant<int>>();
 
-    // Integral's API (like std::integral_constant)
+    // IntegralConstant's API (like std::integral_constant)
     {
         // operator()
         static_assert(size_t<0>() == 0, "");
@@ -133,8 +133,8 @@ int main() {
     {
         // value
         {
-            static_assert(value(integral<int, 0>) == 0, "");
-            static_assert(value(integral<int, 1>) == 1, "");
+            static_assert(value(integral_constant<int, 0>) == 0, "");
+            static_assert(value(integral_constant<int, 1>) == 1, "");
         }
     }
 }
diff --git a/test/range.cpp b/test/range.cpp
index 54ee8182e..0b32206d2 100644
--- a/test/range.cpp
+++ b/test/range.cpp
@@ -7,7 +7,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/range.hpp>
 
 #include <boost/hana/core/datatype.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/tuple.hpp>
 #include <boost/hana/type.hpp>
 
@@ -53,28 +53,28 @@ int main() {
         using T = int;
         BOOST_HANA_CONSTANT_CHECK(equal(
             range_c<T, 0, 0>,
-            range(integral<T, 0>, integral<T, 0>)
+            range(integral_constant<T, 0>, integral_constant<T, 0>)
         ));
         BOOST_HANA_CONSTANT_CHECK(equal(
             range_c<T, 0, 1>,
-            range(integral<T, 0>, integral<T, 1>)
+            range(integral_constant<T, 0>, integral_constant<T, 1>)
         ));
         BOOST_HANA_CONSTANT_CHECK(equal(
             range_c<T, 0, 2>,
-            range(integral<T, 0>, integral<T, 2>)
+            range(integral_constant<T, 0>, integral_constant<T, 2>)
         ));
 
         BOOST_HANA_CONSTANT_CHECK(equal(
             range_c<T, 1, 1>,
-            range(integral<T, 1>, integral<T, 1>)
+            range(integral_constant<T, 1>, integral_constant<T, 1>)
         ));
         BOOST_HANA_CONSTANT_CHECK(equal(
             range_c<T, 1, 2>,
-            range(integral<T, 1>, integral<T, 2>)
+            range(integral_constant<T, 1>, integral_constant<T, 2>)
         ));
         BOOST_HANA_CONSTANT_CHECK(equal(
             range_c<T, 1, 3>,
-            range(integral<T, 1>, integral<T, 3>)
+            range(integral_constant<T, 1>, integral_constant<T, 3>)
         ));
     }
 
diff --git a/test/record_macros.cpp b/test/record_macros.cpp
index 7cef0309c..ab8939807 100644
--- a/test/record_macros.cpp
+++ b/test/record_macros.cpp
@@ -10,7 +10,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/assert.hpp>
 #include <boost/hana/core/is_a.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/maybe.hpp>
 #include <boost/hana/pair.hpp>
 #include <boost/hana/string.hpp>
diff --git a/test/sandbox/function.cpp b/test/sandbox/function.cpp
index 7147adbd8..f2242e7fb 100644
--- a/test/sandbox/function.cpp
+++ b/test/sandbox/function.cpp
@@ -88,7 +88,7 @@ namespace boost { namespace hana {
 
 
 #include <boost/hana/assert.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/range.hpp>
 #include <boost/hana/tuple.hpp>
 using namespace boost::hana;
diff --git a/test/sandbox/hash_map.cpp b/test/sandbox/hash_map.cpp
index 9e8269eba..a64cac0e2 100644
--- a/test/sandbox/hash_map.cpp
+++ b/test/sandbox/hash_map.cpp
@@ -9,7 +9,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/assert.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/functional.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/pair.hpp>
 
 #include <boost/hana/tuple.hpp>
diff --git a/test/sandbox/repeat.cpp b/test/sandbox/repeat.cpp
index d2c6924d7..96584239a 100644
--- a/test/sandbox/repeat.cpp
+++ b/test/sandbox/repeat.cpp
@@ -7,7 +7,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/assert.hpp>
 #include <boost/hana/bool.hpp>
 #include <boost/hana/functional.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/iterable.hpp>
 #include <boost/hana/lazy.hpp>
 #include <boost/hana/list.hpp>
diff --git a/test/sandbox/tuple_opts.cpp b/test/sandbox/tuple_opts.cpp
index b0f899dd3..c40714cfa 100644
--- a/test/sandbox/tuple_opts.cpp
+++ b/test/sandbox/tuple_opts.cpp
@@ -43,7 +43,7 @@ auto tuple = [](auto ...xs) {
 };
 
 template <typename T, T v>
-constexpr auto constant = boost::hana::integral<T, v>;
+constexpr auto constant = boost::hana::integral_constant<T, v>;
 
 
 
@@ -134,11 +134,11 @@ namespace boost { namespace hana {
 
 
         template <typename X, typename T>
-        static constexpr auto cons_helper(X x, decltype(::tuple()) const&, Integral<T>)
+        static constexpr auto cons_helper(X x, decltype(::tuple()) const&, IntegralConstant<T>)
         { return tuple_c<decltype(value(x)), value(x)>; }
 
         template <typename X, typename T, T ...vs, typename U>
-        static constexpr auto cons_helper(X x, ::detail::tuple_c<T, vs...> xs, Integral<U>)
+        static constexpr auto cons_helper(X x, ::detail::tuple_c<T, vs...> xs, IntegralConstant<U>)
         { return tuple_c<T, value(x), vs...>; }
 
 
diff --git a/test/seq/main.hpp b/test/seq/main.hpp
index c7f6d6570..f6fbb02d9 100644
--- a/test/seq/main.hpp
+++ b/test/seq/main.hpp
@@ -8,7 +8,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/assert.hpp>
 #include <boost/hana/core/operators.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/tuple.hpp>
 #include <boost/hana/type.hpp>
 
diff --git a/test/tuple.cpp b/test/tuple.cpp
index def12d5c3..ca09001b0 100644
--- a/test/tuple.cpp
+++ b/test/tuple.cpp
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/tuple.hpp>
 
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/type.hpp>
 
 #include <test/auto/base.hpp>
diff --git a/test/type.cpp b/test/type.cpp
index 45d334b2a..be1d832fa 100644
--- a/test/type.cpp
+++ b/test/type.cpp
@@ -7,7 +7,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/type.hpp>
 
 #include <boost/hana/assert.hpp>
-#include <boost/hana/integral.hpp>
+#include <boost/hana/integral_constant.hpp>
 #include <boost/hana/tuple.hpp>
 
 #include <test/auto/base.hpp>