text: /*!
  @file
  Forward declares `boost::hana::tag_of` and `boost::hana::tag_of_t`.
  
  @copyright Louis Dionne 2013-2017
  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
   */
  
  #ifndef BOOST_HANA_FWD_CORE_TAG_OF_HPP
  #define BOOST_HANA_FWD_CORE_TAG_OF_HPP
  
  #include <boost/hana/config.hpp>
  
  
  BOOST_HANA_NAMESPACE_BEGIN
      //! @ingroup group-core
      //! %Metafunction returning the tag associated to `T`.
      //!
      //! There are several ways to specify the tag of a C++ type. If it's a
      //! user-defined type, one can define a nested `hana_tag` alias:
      //! @code
      //!     struct MyUserDefinedType {
      //!         using hana_tag = MyTag;
      //!     };
      //! @endcode
      //!
      //! Sometimes, however, the C++ type can't be modified (if it's in a
      //! foreign library) or simply can't have nested types (if it's not a
      //! struct or class). In those cases, using a nested alias is impossible
      //! and so ad-hoc customization is also supported by specializing
      //! `tag_of` in the `boost::hana` namespace:
      //! @code
      //!     struct i_cant_modify_this;
      //!
      //!     namespace boost { namespace hana {
      //!         template <>
      //!         struct tag_of<i_cant_modify_this> {
      //!             using type = MyTag;
      //!         };
      //!     }}
      //! @endcode
      //!
      //! `tag_of` can also be specialized for all C++ types satisfying some
      //! boolean condition using `when`. `when` accepts a single compile-time
      //! boolean and enables the specialization of `tag_of` if and only if
      //! that boolean is `true`. This is similar to the well known C++ idiom
      //! of using a dummy template parameter with `std::enable_if` and relying
      //! on SFINAE. For example, we could specify the tag of all
      //! `fusion::vector`s by doing:
      //! @code
      //!     struct BoostFusionVector;
      //!
      //!     namespace boost { namespace hana {
      //!         template <typename T>
      //!         struct tag_of<T, when<
      //!             std::is_same<
      //!                 typename fusion::traits::tag_of<T>::type,
      //!                 fusion::traits::tag_of<fusion::vector<>>::type
      //!             >::value
      //!         >> {
      //!             using type = BoostFusionVector;
      //!         };
      //!     }}
      //! @endcode
      //!
      //! Also, when it is not specialized and when the given C++ type does not
      //! have a nested `hana_tag` alias, `tag_of<T>` returns `T` itself. This
      //! makes tags a simple extension of normal C++ types. This is _super_
      //! useful, mainly for two reasons. First, this allows Hana to adopt a
      //! reasonable default behavior for some operations involving types that
      //! have no notion of tags. For example, Hana allows comparing with `equal`
      //! any two objects for which a valid `operator==` is defined, and that
      //! without any work on the user side. Second, it also means that you can
      //! ignore tags completely if you don't need their functionality; just use
      //! the normal C++ type of your objects and everything will "just work".
      //!
      //! Finally, also note that `tag_of<T>` is always equivalent to `tag_of<U>`,
      //! where `U` is the type `T` after being stripped of all references and
      //! cv-qualifiers. This makes it unnecessary to specialize `tag_of` for
      //! all reference and cv combinations, which would be a real pain. Also,
      //! `tag_of` is required to be idempotent. In other words, it must always
      //! be the case that `tag_of<tag_of<T>::%type>::%type` is equivalent to
      //! `tag_of<T>::%type`.
      //!
      //! > __Tip 1__\n
      //! > If compile-time performance is a serious concern, consider
      //! > specializing the `tag_of` metafunction in Hana's namespace.
      //! > When unspecialized, the metafunction has to use SFINAE, which
      //! > tends to incur a larger compile-time overhead. For heavily used
      //! > templated types, this can potentially make a difference.
      //!
      //! > __Tip 2__\n
      //! > Consider using `tag_of_t` alias instead of `tag_of`, which
      //! > reduces the amount of typing in dependent contexts.
      //!
      //!
      //! Example
      //! -------
      //! @include example/core/tag_of.cpp
  #ifdef BOOST_HANA_DOXYGEN_INVOKED
      template <typename T, optional when-based enabler>
      struct tag_of { unspecified };
  #else
      template <typename T, typename = void>
      struct tag_of;
  #endif
  
      //! @ingroup group-core
      //! Alias to `tag_of<T>::%type`, provided for convenience.
      //!
      //!
      //! Example
      //! -------
      //! @include example/core/tag_of_t.cpp
      template <typename T>
      using tag_of_t = typename hana::tag_of<T>::type;
  BOOST_HANA_NAMESPACE_END
  
  #endif // !BOOST_HANA_FWD_CORE_TAG_OF_HPP
  