Boost C++ Libraries

namespace boost {
  namespace type_erasure {
    template<typename Concept, typename T = _self> class any;

    template<typename Concept, typename T> class any<Concept, const T &>;
    template<typename Concept, typename T> class any<Concept, T &>;
    template<typename Concept, typename T> class any<Concept, T &&>;

    typedef any< Concept, T & > any_ref;
    typedef any< Concept, const T & > any_cref;
    typedef any< Concept, T && > any_rvref;
  }
}

namespace boost {
  namespace type_erasure {
    template<typename T, typename Concept, typename Tag> 
      T any_cast(any< Concept, Tag > &);
    template<typename T, typename Concept, typename Tag> 
      T any_cast(const any< Concept, Tag > &);
    template<typename T, typename Concept, typename Tag> 
      T any_cast(any< Concept, Tag > *);
    template<typename T, typename Concept, typename Tag> 
      T any_cast(const any< Concept, Tag > *);
  }
}

namespace boost {
  namespace type_erasure {
    template<typename Concept> class binding;
  }
}

namespace boost {
  namespace type_erasure {
    template<typename Concept, typename T> 
      const binding< Concept > & binding_of(const any< Concept, T > &);
  }
}

namespace boost {
  namespace type_erasure {
    template<typename T = _self, typename U = const T&> struct assignable;
    template<typename T = _self> struct copy_constructible;
    template<typename T = _self> struct destructible;
    template<typename T = _self> struct typeid_;
  }
}

namespace boost {
  namespace type_erasure {
    template<typename Concept, typename Op, class... U> 
      unspecified call(const binding< Concept > &, const Op &, U &&...);
    template<typename Op, class... U> unspecified call(const Op &, U &&...);
  }
}

namespace boost {
  namespace type_erasure {
    template<typename Sig, typename F = _self> struct callable;
  }
}

namespace boost {
  namespace type_erasure {
    template<typename Concept, typename Op, class... U> 
      bool check_match(const binding< Concept > &, const Op &, U &&...);
    template<typename Op, class... U> bool check_match(const Op &, U &&...);
  }
}

namespace boost {
  namespace type_erasure {
    template<typename Concept, typename Base, typename ID, 
             typename Enable = void> 
      struct concept_interface;
  }
}

namespace boost {
  namespace type_erasure {
    template<typename T> struct concept_of;

    typedef typename ::boost::type_erasure::concept_of< T >::type concept_of_t;
  }
}

BOOST_TYPE_ERASURE_MAX_FUNCTIONS
BOOST_TYPE_ERASURE_MAX_ARITY
BOOST_TYPE_ERASURE_MAX_TUPLE_SIZE

namespace boost {
  namespace type_erasure {
    template<typename Sig> struct constructible;
  }
}

namespace boost {
  namespace type_erasure {
    template<typename Metafunction> struct deduced;
  }
}

namespace boost {
  namespace type_erasure {
    template<typename T> struct derived;

    typedef typename T::_boost_type_erasure_derived_type derived_t;
  }
}

namespace boost {
  namespace type_erasure {
    template<typename R, typename Any> R dynamic_any_cast(Any &&);
    template<typename R, typename Any, typename Map> 
      R dynamic_any_cast(Any &&, const static_binding< Map > &);
  }
}

namespace boost {
  namespace type_erasure {
    template<typename PlaceholderList> class dynamic_binding;
  }
}

namespace boost {
  namespace type_erasure {
    class bad_any_cast;
    class bad_function_call;
  }
}

BOOST_TYPE_ERASURE_FREE(concept_name, function_name)

namespace boost {
  namespace type_erasure {
    template<typename T> bool is_empty(const T &);
  }
}

namespace boost {
  namespace type_erasure {
    template<typename T> struct is_placeholder;
  }
}

namespace boost {
  namespace type_erasure {
    template<typename Sub, typename Super, typename PlaceholderMap = void> 
      struct is_subconcept;
  }
}

namespace boost {
  namespace type_erasure {
    template<typename T = _self, typename Reference = boost::use_default, 
             typename DifferenceType = std::ptrdiff_t> 
      struct bidirectional_iterator;
    template<typename T = _self, typename Reference = boost::use_default, 
             typename DifferenceType = std::ptrdiff_t> 
      struct forward_iterator;
    template<typename Traversal, typename T = _self, 
             typename Reference = boost::use_default, 
             typename DifferenceType = std::ptrdiff_t> 
      struct iterator;
    template<typename T = _self, typename Reference = boost::use_default, 
             typename DifferenceType = std::ptrdiff_t> 
      struct random_access_iterator;
  }
}

BOOST_TYPE_ERASURE_MEMBER(concept_name, member)

namespace boost {
  namespace type_erasure {
    template<typename T = _self, typename U = T> struct add_assignable;
    template<typename T = _self, typename U = T, typename R = T> struct addable;
    template<typename T = _self, typename U = T> struct bitand_assignable;
    template<typename T = _self, typename U = T, typename R = T> 
      struct bitandable;
    template<typename T = _self, typename U = T> struct bitor_assignable;
    template<typename T = _self, typename U = T, typename R = T> 
      struct bitorable;
    template<typename T = _self, typename U = T> struct bitxor_assignable;
    template<typename T = _self, typename U = T, typename R = T> 
      struct bitxorable;
    template<typename T = _self, typename R = T> struct complementable;
    template<typename T = _self> struct decrementable;
    template<typename R, typename T = _self> struct dereferenceable;
    template<typename T = _self, typename U = T, typename R = T> 
      struct dividable;
    template<typename T = _self, typename U = T> struct divide_assignable;
    template<typename T = _self, typename U = T> struct equality_comparable;
    template<typename T = _self> struct incrementable;
    template<typename Is = std::istream, typename T = _self> struct istreamable;
    template<typename T = _self, typename U = T> struct left_shift_assignable;
    template<typename T = _self, typename U = T, typename R = T> 
      struct left_shiftable;
    template<typename T = _self, typename U = T> struct less_than_comparable;
    template<typename T = _self, typename U = T> struct mod_assignable;
    template<typename T = _self, typename U = T, typename R = T> struct modable;
    template<typename T = _self, typename U = T, typename R = T> 
      struct multipliable;
    template<typename T = _self, typename U = T> struct multiply_assignable;
    template<typename T = _self, typename R = T> struct negatable;
    template<typename Os = std::ostream, typename T = _self> struct ostreamable;
    template<typename T = _self, typename U = T> struct right_shift_assignable;
    template<typename T = _self, typename U = T, typename R = T> 
      struct right_shiftable;
    template<typename R, typename T = _self, typename N = std::ptrdiff_t> 
      struct subscriptable;
    template<typename T = _self, typename U = T> struct subtract_assignable;
    template<typename T = _self, typename U = T, typename R = T> 
      struct subtractable;
  }
}

namespace boost {
  namespace type_erasure {
    template<typename Any, typename T> struct as_param;

    template<typename Concept, typename T> class param;

    typedef typename ::boost::type_erasure::as_param< Any, T >::type as_param_t;
  }
}

namespace boost {
  namespace type_erasure {
    struct _a;
    struct _b;
    struct _c;
    struct _d;
    struct _e;
    struct _f;
    struct _g;
    struct _self;
    struct placeholder;
  }
}

namespace boost {
  namespace type_erasure {
    template<typename T> struct placeholder_of;

    typedef typename ::boost::type_erasure::placeholder_of< T >::type placeholder_of_t;
  }
}

namespace boost {
  namespace type_erasure {
    template<typename Any, typename T> struct rebind_any;

    typedef typename ::boost::type_erasure::rebind_any< Any, T >::type rebind_any_t;
  }
}

namespace boost {
  namespace type_erasure {
    template<typename Concept, typename Map> 
      void register_binding(const static_binding< Map > &);
    template<typename Concept, typename T> void register_binding();
  }
}

namespace boost {
  namespace type_erasure {
    template<typename Concept> struct is_relaxed;
    struct relaxed;
  }
}

namespace boost {
  namespace type_erasure {
    template<typename Concept, typename Op, class... U> 
      void require_match(const binding< Concept > &, const Op &, U &&...);
    template<typename Op, class... U> void require_match(const Op &, U &&...);
  }
}

namespace boost {
  namespace type_erasure {
    template<typename T, typename U> struct same_type;
  }
}

namespace boost {
  namespace type_erasure {
    template<typename Map> struct static_binding;
    template<typename Map> static_binding< Map > make_binding();
  }
}

namespace boost {
  namespace type_erasure {
    template<typename Concept, class... T> class tuple;
    template<int N, typename Concept, class... T> 
      any< Concept, TN > & get(tuple< Concept, T... > &);
    template<int N, typename Concept, class... T> 
      const any< Concept, TN > & get(const tuple< Concept, T... > &);
  }
}

namespace boost {
  namespace type_erasure {
    template<typename Concept, typename T> 
      const std::type_info & typeid_of(const any< Concept, T > &);
    template<typename T, typename Concept> 
      const std::type_info & typeid_of(const binding< Concept > &);
  }
}