diff --git a/example/CMakeLists.txt b/example/CMakeLists.txt
index 3611812b3..908e5abb9 100644
--- a/example/CMakeLists.txt
+++ b/example/CMakeLists.txt
@@ -14,6 +14,9 @@ endfunction()
 
 boost_hana_add_example(bool.logical.eval_if)
 
+boost_hana_add_example(core.defaults)
+boost_hana_add_example(core.instance)
+
 boost_hana_add_example(functional.always.basic)
 boost_hana_add_example(functional.always.dependent)
 boost_hana_add_example(functional.apply)
diff --git a/example/core/defaults.cpp b/example/core/defaults.cpp
new file mode 100644
index 000000000..1bec161a0
--- /dev/null
+++ b/example/core/defaults.cpp
@@ -0,0 +1,73 @@
+/*
+@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/core.hpp>
+#include <boost/hana/detail/constexpr.hpp>
+#include <boost/hana/detail/static_assert.hpp>
+
+#include <type_traits>
+namespace hana = boost::hana;
+
+
+template <typename T, typename Enable = void>
+struct Incrementable;
+
+BOOST_HANA_CONSTEXPR_LAMBDA auto next = [](auto x) {
+    return Incrementable<hana::datatype_t<decltype(x)>>::next_impl(x);
+};
+
+BOOST_HANA_CONSTEXPR_LAMBDA auto next_n = [](auto x, unsigned int n) {
+    return Incrementable<hana::datatype_t<decltype(x)>>::next_n_impl(x, n);
+};
+
+namespace boost { namespace hana {
+    template <>
+    struct instance<Incrementable> {
+        template <typename T, typename Enable = void>
+        struct with { };
+    };
+
+    template <>
+    struct defaults<Incrementable> {
+        template <typename T, typename Enable = void>
+        struct with {
+            template <typename X>
+            static constexpr auto next_n_impl(X x, unsigned int n) {
+                if (n == 0) return x;
+                else        return next_n_impl(next(x), n - 1);
+            }
+
+            template <typename X>
+            static constexpr auto next_impl(X x)
+            { return next_n(x, 1); }
+        };
+    };
+}}
+
+template <typename T, typename Enable>
+struct Incrementable
+    : hana::instance<Incrementable>::template with<T>
+{ };
+
+template <>
+struct Incrementable<int> : hana::defaults<Incrementable>::with<int> {
+    static constexpr auto next_impl(int x)
+    { return x + 1; }
+};
+
+template <>
+struct Incrementable<long> : hana::defaults<Incrementable>::with<long> {
+    static constexpr auto next_n_impl(long x, unsigned int n)
+    { return x + n; }
+};
+
+int main() {
+    BOOST_HANA_STATIC_ASSERT(next(1) == 2);
+    BOOST_HANA_STATIC_ASSERT(next_n(1, 3) == 4); // default implementation
+
+    BOOST_HANA_STATIC_ASSERT(next(1l) == 2l); // default implementation
+    BOOST_HANA_STATIC_ASSERT(next_n(1l, 3) == 4l);
+}
diff --git a/example/core/instance.cpp b/example/core/instance.cpp
new file mode 100644
index 000000000..e6dd20b74
--- /dev/null
+++ b/example/core/instance.cpp
@@ -0,0 +1,59 @@
+/*
+@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/core.hpp>
+#include <boost/hana/detail/constexpr.hpp>
+#include <boost/hana/detail/static_assert.hpp>
+
+#include <type_traits>
+namespace hana = boost::hana;
+
+
+template <typename T, typename Enable = void>
+struct Incrementable;
+
+BOOST_HANA_CONSTEXPR_LAMBDA auto next = [](auto x) {
+    return Incrementable<hana::datatype_t<decltype(x)>>::next_impl(x);
+};
+
+namespace boost { namespace hana {
+    template <>
+    struct instance<Incrementable> {
+        template <typename T, typename Enable = void>
+        struct with { };
+    };
+
+    template <>
+    struct defaults<Incrementable> {
+        template <typename T, typename Enable = void>
+        struct with { };
+    };
+}}
+
+template <typename T, typename Enable>
+struct Incrementable
+    : hana::instance<Incrementable>::template with<T>
+{ };
+
+namespace boost { namespace hana {
+    template <typename T>
+    struct instance<Incrementable>::with<T,
+        std::enable_if_t<std::is_integral<T>{} || std::is_floating_point<T>{}>
+    >
+        : defaults<Incrementable>::template with<T>
+    {
+        template <typename X>
+        static constexpr auto next_impl(X x)
+        { return x + 1; }
+    };
+}}
+
+
+int main() {
+    BOOST_HANA_STATIC_ASSERT(next(1) == 2);
+    BOOST_HANA_STATIC_ASSERT(next(3.3) == 4.3);
+    BOOST_HANA_STATIC_ASSERT(next('a') == 'b');
+}
diff --git a/include/boost/hana.hpp b/include/boost/hana.hpp
index 40bbf84eb..3f735b2c7 100644
--- a/include/boost/hana.hpp
+++ b/include/boost/hana.hpp
@@ -20,7 +20,7 @@ General purpose type classes provided by the library.
 @todo
 - Provide an integrated way of checking laws for type classes.
 - Creating new type classes is __way__ too complicated with the new
-dispatching system.
+  dispatching system.
  */
 
 //! @defgroup datatypes Data types
diff --git a/include/boost/hana/core.hpp b/include/boost/hana/core.hpp
index 7ed605ec9..1cddb24d5 100644
--- a/include/boost/hana/core.hpp
+++ b/include/boost/hana/core.hpp
@@ -13,6 +13,15 @@ Distributed under the Boost Software License, Version 1.0.
 namespace boost { namespace hana {
     //! @defgroup Core Core
     //! Miscellaneous core utilities.
+    //!
+    //!
+    //! @note
+    //! Users who only wish to instantiate a type class do not need to include
+    //! this header to get the declarations of `defaults` and `instance` in
+    //! scope. Type classes are required to either forward declare them or
+    //! include this header so users are free from that burden when they
+    //! include the type class' header.
+    //!
     //! @{
 
     /*!
@@ -40,11 +49,13 @@ namespace boost { namespace hana {
     @endcode
 
     The `Args...` are specific to each type class; the documentation should
-    explain their purpose.
+    explain their purpose. When possible, it is nice to include a dummy
+    template parameter for SFINAE, which allows `defaults` to be specialized
+    for all types satisfying a predicate.
+
+    ### Example
+    @include example/core/defaults.cpp
 
-    @todo
-    - Document best practices with Enablers.
-    - Show examples with enablers and other useful stuff.
     */
     template <template <typename ...> class Typeclass>
     struct defaults;
@@ -53,15 +64,15 @@ namespace boost { namespace hana {
     Allows complimentary type class instances to be provided.
 
     Every type class instance must inherit exactly one of `defaults<>::%with<>`
-    and `instance<>::%with<>`. The latter may not be provided, in which case
-    the only choice is to inherit `defaults<>::%with<>`. Complimentary
-    instances, if any, should be documented for each type class.
+    and `instance<>::%with<>`. The latter may not be provided (see below), in
+    which case the only choice is to inherit `defaults<>::%with<>`.
+    Complimentary instances, if any, should be documented for each type class.
 
-    When implementing a new type class, one has to inherit from
-    `instance<>::%with<>` as follows:
+    When implementing a new type class, the primary template has to inherit
+    from `instance<>::%with<>` as follows:
     @code
         template <typename ...>
-        struct Typeclass : instance<Typeclass>::template with<...> { };
+        struct Typeclass : instance<Typeclass>::with<...> { };
     @endcode
 
     This allows complimentary instances to be found when no explicit instance
@@ -72,13 +83,25 @@ namespace boost { namespace hana {
         template <>
         struct instance<Typeclass> {
             template <typename ...Args>
-            struct with;
+            struct with { };
         };
     @endcode
 
+    Anything appearing in the primary template of `instance<Typeclass>::%with`
+    will be available to all data types by default. This can be used to
+    provide a default behavior for all data types while still allowing
+    this behavior to be customized. However, this should seldom be used
+    because methods with a meaningful behavior for all data types are rare.
+    This feature is provided for flexibility, but it should be a hint to
+    reconsider your type class design if you are about to use it.
+
     The `Args...` are specific to each type class; the documentation should
-    explain their purpose. Then, to provide a complimentary instance, one can
-    specialize `instance` as follows:
+    explain their purpose. When possible, it is nice to include a dummy
+    template parameter for SFINAE, which allows `instance` to be specialized
+    for all types satisfying a predicate.
+
+    To provide a complimentary instance, one can then specialize `instance`
+    as follows:
     @code
         template <...>
         struct instance<Typeclass>::with<...>
@@ -96,9 +119,9 @@ namespace boost { namespace hana {
     relying on the fact that a data type is _not_ an instance of a given type
     class could break when the complimentary instance is made available.
 
-    @todo
-    - Document best practices with Enablers.
-    - Show examples with enablers and other useful stuff.
+    ### Example
+    @include example/core/instance.cpp
+
      */
     template <template <typename ...> class Typeclass>
     struct instance;
diff --git a/include/boost/hana/integral.hpp b/include/boost/hana/integral.hpp
index 3bd87e497..2cb9717f2 100644
--- a/include/boost/hana/integral.hpp
+++ b/include/boost/hana/integral.hpp
@@ -11,7 +11,6 @@ Distributed under the Boost Software License, Version 1.0.
 #define BOOST_HANA_INTEGRAL_HPP
 
 #include <boost/hana/comparable.hpp>
-#include <boost/hana/core.hpp>
 #include <boost/hana/detail/integral_fwd.hpp>
 #include <boost/hana/logical.hpp>
 
diff --git a/include/boost/hana/list.hpp b/include/boost/hana/list.hpp
index c53ce0fd6..3043f399b 100644
--- a/include/boost/hana/list.hpp
+++ b/include/boost/hana/list.hpp
@@ -11,7 +11,6 @@ Distributed under the Boost Software License, Version 1.0.
 #define BOOST_HANA_LIST_HPP
 
 #include <boost/hana/comparable.hpp>
-#include <boost/hana/core.hpp>
 #include <boost/hana/detail/at_index/best.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/left_folds/variadic.hpp>
diff --git a/include/boost/hana/maybe.hpp b/include/boost/hana/maybe.hpp
index a1880e156..580f49bbc 100644
--- a/include/boost/hana/maybe.hpp
+++ b/include/boost/hana/maybe.hpp
@@ -11,7 +11,6 @@ Distributed under the Boost Software License, Version 1.0.
 #define BOOST_HANA_MAYBE_HPP
 
 #include <boost/hana/comparable.hpp>
-#include <boost/hana/core.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/functor.hpp>
 #include <boost/hana/integral.hpp>
diff --git a/test/list/sort_by.cpp b/test/list/sort_by.cpp
index 08badcb38..2171c0cac 100644
--- a/test/list/sort_by.cpp
+++ b/test/list/sort_by.cpp
@@ -7,7 +7,6 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/list.hpp>
 
 #include <boost/hana/comparable.hpp>
-#include <boost/hana/core.hpp>
 #include <boost/hana/detail/constexpr.hpp>
 #include <boost/hana/detail/static_assert.hpp>
 #include <boost/hana/functional.hpp>
diff --git a/test/logical/minimal_logical.hpp b/test/logical/minimal_logical.hpp
index 00802b69b..136458e69 100644
--- a/test/logical/minimal_logical.hpp
+++ b/test/logical/minimal_logical.hpp
@@ -7,7 +7,6 @@ Distributed under the Boost Software License, Version 1.0.
 #ifndef BOOST_HANA_TEST_LOGICAL_MINIMAL_LOGICAL_HPP
 #define BOOST_HANA_TEST_LOGICAL_MINIMAL_LOGICAL_HPP
 
-#include <boost/hana/core.hpp>
 #include <boost/hana/logical.hpp>
 
 
@@ -25,9 +24,7 @@ constexpr _logical<b> logical{};
 
 namespace boost { namespace hana {
     template <>
-    struct Logical<MinimalLogical>
-        : defaults<Logical>::template with<MinimalLogical>
-    {
+    struct Logical<MinimalLogical> : defaults<Logical>::with<MinimalLogical> {
         template <typename Then, typename Else>
         static constexpr auto eval_if_impl(_logical<true>, Then t, Else)
         { return t([](auto x) { return x; }); }
diff --git a/test/sandbox/function.cpp b/test/sandbox/function.cpp
index 7a2ccb77e..63d8acf08 100644
--- a/test/sandbox/function.cpp
+++ b/test/sandbox/function.cpp
@@ -60,7 +60,7 @@ namespace boost { namespace hana {
 
     template <>
     struct Comparable<Function, Function>
-        : defaults<Comparable>::template with<Function, Function>
+        : defaults<Comparable>::with<Function, Function>
     {
         template <typename F, typename G>
         static constexpr auto equal_impl(F f, G g) {