diff --git a/doc/api.rst b/doc/api.rst
index c1eceaaf5a1e..ab02bffb71f9 100644
--- a/doc/api.rst
+++ b/doc/api.rst
@@ -40,7 +40,7 @@ participate in an overload resolution if the latter is not a string.
 .. _format:
 
 .. doxygenfunction:: format(const S&, const Args&...)
-.. doxygenfunction:: vformat(const S&, basic_format_args<typename buffer_context<Char>::type>)
+.. doxygenfunction:: vformat(const S&, basic_format_args<buffer_context<Char>>)
 
 .. _print:
 
@@ -183,7 +183,7 @@ You can also write a formatter for a hierarchy of classes::
 Output Iterator Support
 -----------------------
 
-.. doxygenfunction:: fmt::format_to(OutputIt, const S &, const Args &...)
+.. doxygenfunction:: fmt::format_to(OutputIt, const S&, const Args&...)
 .. doxygenfunction:: fmt::format_to_n(OutputIt, std::size_t, string_view, const Args&...)
 .. doxygenstruct:: fmt::format_to_n_result
    :members:
@@ -200,7 +200,7 @@ The following user-defined literals are defined in ``fmt/format.h``.
 Utilities
 ---------
 
-.. doxygenclass:: fmt::is_char
+.. doxygenstruct:: fmt::is_char
 
 .. doxygentypedef:: fmt::char_t
 
@@ -357,7 +357,7 @@ user-defined types that have overloaded ``operator<<``::
   std::string s = fmt::format("The date is {}", date(2012, 12, 9));
   // s == "The date is 2012-12-9"
 
-.. doxygenfunction:: print(std::basic_ostream<fmt::char_t<S>>&, const S&, const Args&...)
+.. doxygenfunction:: print(std::basic_ostream<Char>&, const S&, const Args&...)
 
 .. _printf-api:
 
@@ -375,6 +375,6 @@ argument type doesn't match its format specification.
 
 .. doxygenfunction:: fprintf(std::FILE *, const S&, const Args&...)
 
-.. doxygenfunction:: fprintf(std::basic_ostream<fmt::char_t<S>>&, const S&, const Args&...)
+.. doxygenfunction:: fprintf(std::basic_ostream<Char>&, const S&, const Args&...)
 
 .. doxygenfunction:: sprintf(const S&, const Args&...)
diff --git a/include/fmt/chrono.h b/include/fmt/chrono.h
index f2c7e8081274..060ce31e0485 100644
--- a/include/fmt/chrono.h
+++ b/include/fmt/chrono.h
@@ -430,7 +430,7 @@ template <typename T> struct make_unsigned_or_unchanged<T, true> {
 };
 
 template <typename Rep, typename Period,
-          typename std::enable_if<std::is_integral<Rep>::value, int>::type = 0>
+          FMT_ENABLE_IF(std::is_integral<Rep>::value)>
 inline std::chrono::duration<Rep, std::milli> get_milliseconds(
     std::chrono::duration<Rep, Period> d) {
   // this may overflow and/or the result may not fit in the
@@ -466,9 +466,8 @@ inline std::chrono::duration<Rep, std::milli> get_milliseconds(
 #endif
 }
 
-template <
-    typename Rep, typename Period,
-    typename std::enable_if<std::is_floating_point<Rep>::value, int>::type = 0>
+template <typename Rep, typename Period,
+          FMT_ENABLE_IF(std::is_floating_point<Rep>::value)>
 inline std::chrono::duration<Rep, std::milli> get_milliseconds(
     std::chrono::duration<Rep, Period> d) {
   return std::chrono::duration<Rep, std::milli>(
diff --git a/include/fmt/core.h b/include/fmt/core.h
index c339d0b028b8..342738c5ca27 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -70,16 +70,6 @@
 #  define FMT_CONSTEXPR_DECL
 #endif
 
-#ifndef FMT_USE_CONSTEXPR11
-#  define FMT_USE_CONSTEXPR11 \
-    (FMT_USE_CONSTEXPR || FMT_GCC_VERSION >= 406 || FMT_MSC_VER >= 1900)
-#endif
-#if FMT_USE_CONSTEXPR11
-#  define FMT_CONSTEXPR11 constexpr
-#else
-#  define FMT_CONSTEXPR11
-#endif
-
 #ifndef FMT_OVERRIDE
 #  if FMT_HAS_FEATURE(cxx_override) || \
       (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900
@@ -205,6 +195,7 @@ template <bool B, class T = void>
 using enable_if_t = typename std::enable_if<B, T>::type;
 template <bool B, class T, class F>
 using conditional_t = typename std::conditional<B, T, F>::type;
+template <bool B> using bool_constant = std::integral_constant<bool, B>;
 
 // An enable_if helper to be used in template parameters which results in much
 // shorter symbols: https://godbolt.org/z/sWw4vP. Extra parentheses are needed
@@ -239,119 +230,6 @@ FMT_CONSTEXPR typename std::make_unsigned<Int>::type to_unsigned(Int value) {
   FMT_ASSERT(value >= 0, "negative value");
   return static_cast<typename std::make_unsigned<Int>::type>(value);
 }
-
-/** A contiguous memory buffer with an optional growing ability. */
-template <typename T> class buffer {
- private:
-  buffer(const buffer&) = delete;
-  void operator=(const buffer&) = delete;
-
-  T* ptr_;
-  std::size_t size_;
-  std::size_t capacity_;
-
- protected:
-  // Don't initialize ptr_ since it is not accessed to save a few cycles.
-  buffer(std::size_t sz) FMT_NOEXCEPT : size_(sz), capacity_(sz) {}
-
-  buffer(T* p = nullptr, std::size_t sz = 0, std::size_t cap = 0) FMT_NOEXCEPT
-      : ptr_(p),
-        size_(sz),
-        capacity_(cap) {}
-
-  /** Sets the buffer data and capacity. */
-  void set(T* buf_data, std::size_t buf_capacity) FMT_NOEXCEPT {
-    ptr_ = buf_data;
-    capacity_ = buf_capacity;
-  }
-
-  /** Increases the buffer capacity to hold at least *capacity* elements. */
-  virtual void grow(std::size_t capacity) = 0;
-
- public:
-  using value_type = T;
-  using const_reference = const T&;
-
-  virtual ~buffer() {}
-
-  T* begin() FMT_NOEXCEPT { return ptr_; }
-  T* end() FMT_NOEXCEPT { return ptr_ + size_; }
-
-  /** Returns the size of this buffer. */
-  std::size_t size() const FMT_NOEXCEPT { return size_; }
-
-  /** Returns the capacity of this buffer. */
-  std::size_t capacity() const FMT_NOEXCEPT { return capacity_; }
-
-  /** Returns a pointer to the buffer data. */
-  T* data() FMT_NOEXCEPT { return ptr_; }
-
-  /** Returns a pointer to the buffer data. */
-  const T* data() const FMT_NOEXCEPT { return ptr_; }
-
-  /**
-    Resizes the buffer. If T is a POD type new elements may not be initialized.
-   */
-  void resize(std::size_t new_size) {
-    reserve(new_size);
-    size_ = new_size;
-  }
-
-  /** Clears this buffer. */
-  void clear() { size_ = 0; }
-
-  /** Reserves space to store at least *capacity* elements. */
-  void reserve(std::size_t new_capacity) {
-    if (new_capacity > capacity_) grow(new_capacity);
-  }
-
-  void push_back(const T& value) {
-    reserve(size_ + 1);
-    ptr_[size_++] = value;
-  }
-
-  /** Appends data to the end of the buffer. */
-  template <typename U> void append(const U* begin, const U* end);
-
-  T& operator[](std::size_t index) { return ptr_[index]; }
-  const T& operator[](std::size_t index) const { return ptr_[index]; }
-};
-
-// A container-backed buffer.
-template <typename Container>
-class container_buffer : public buffer<typename Container::value_type> {
- private:
-  Container& container_;
-
- protected:
-  void grow(std::size_t capacity) FMT_OVERRIDE {
-    container_.resize(capacity);
-    this->set(&container_[0], capacity);
-  }
-
- public:
-  explicit container_buffer(Container& c)
-      : buffer<typename Container::value_type>(c.size()), container_(c) {}
-};
-
-// Extracts a reference to the container from back_insert_iterator.
-template <typename Container>
-inline Container& get_container(std::back_insert_iterator<Container> it) {
-  using bi_iterator = std::back_insert_iterator<Container>;
-  struct accessor : bi_iterator {
-    accessor(bi_iterator iter) : bi_iterator(iter) {}
-    using bi_iterator::container;
-  };
-  return *accessor(it).container;
-}
-
-struct error_handler {
-  FMT_CONSTEXPR error_handler() {}
-  FMT_CONSTEXPR error_handler(const error_handler&) {}
-
-  // This function is intentionally not constexpr to give a compile-time error.
-  FMT_API FMT_NORETURN void on_error(const char* message);
-};
 }  // namespace internal
 
 /**
@@ -498,11 +376,39 @@ template <typename S>
 struct is_compile_string : std::is_base_of<compile_string, S> {};
 
 template <typename S, FMT_ENABLE_IF(is_compile_string<S>::value)>
-FMT_CONSTEXPR basic_string_view<typename S::char_type> to_string_view(
-    const S& s) {
+constexpr basic_string_view<typename S::char_type> to_string_view(const S& s) {
   return s;
 }
 
+namespace internal {
+void to_string_view(...);
+using fmt::v5::to_string_view;
+
+// Specifies whether S is a string type convertible to fmt::basic_string_view.
+// It should be a constexpr function but MSVC 2017 fails to compile it in
+// enable_if and MSVC 2015 fails to compile it as an alias template.
+template <typename S>
+struct is_string : std::is_class<decltype(to_string_view(std::declval<S>()))> {
+};
+
+template <typename S, typename = void> struct char_t_impl {};
+template <typename S> struct char_t_impl<S, enable_if_t<is_string<S>::value>> {
+  using result = decltype(to_string_view(std::declval<S>()));
+  using type = typename result::char_type;
+};
+
+struct error_handler {
+  FMT_CONSTEXPR error_handler() {}
+  FMT_CONSTEXPR error_handler(const error_handler&) {}
+
+  // This function is intentionally not constexpr to give a compile-time error.
+  FMT_API FMT_NORETURN void on_error(const char* message);
+};
+}  // namespace internal
+
+/** String's character type. */
+template <typename S> using char_t = typename internal::char_t_impl<S>::type;
+
 // Parsing context consisting of a format string range being parsed and an
 // argument counter for automatic indexing.
 template <typename Char, typename ErrorHandler = internal::error_handler>
@@ -534,7 +440,11 @@ class basic_parse_context : private ErrorHandler {
   }
 
   // Returns the next argument index.
-  FMT_CONSTEXPR unsigned next_arg_id();
+  FMT_CONSTEXPR unsigned next_arg_id() {
+    if (next_arg_id_ >= 0) return internal::to_unsigned(next_arg_id_++);
+    on_error("cannot switch from manual to automatic argument indexing");
+    return 0;
+  }
 
   FMT_CONSTEXPR bool check_arg_id(unsigned) {
     if (next_arg_id_ > 0) {
@@ -566,49 +476,139 @@ template <typename Context> class basic_format_args;
 // A formatter for objects of type T.
 template <typename T, typename Char = char, typename Enable = void>
 struct formatter {
+  // A deleted default constructor indicates a disabled formatter.
   formatter() = delete;
 };
 
 template <typename T, typename Char, typename Enable = void>
-struct convert_to_int
-    : std::integral_constant<bool, !std::is_arithmetic<T>::value &&
-                                       std::is_convertible<T, int>::value> {};
+struct FMT_DEPRECATED convert_to_int
+    : bool_constant<!std::is_arithmetic<T>::value &&
+                    std::is_convertible<T, int>::value> {};
 
 namespace internal {
 
-template <typename T> struct no_formatter_error : std::false_type {};
+// Specifies if T has an enabled formatter specialization. A type can be
+// formattable even if it doesn't have a formatter e.g. via a conversion.
+template <typename T, typename Context>
+using has_formatter =
+    std::is_constructible<typename Context::template formatter_type<T>>;
 
-template <typename T, typename Char = char, typename Enable = void>
-struct fallback_formatter {
-  static_assert(
-      no_formatter_error<T>::value,
-      "don't know how to format the type, include fmt/ostream.h if it provides "
-      "an operator<< that should be used");
+/** A contiguous memory buffer with an optional growing ability. */
+template <typename T> class buffer {
+ private:
+  buffer(const buffer&) = delete;
+  void operator=(const buffer&) = delete;
+
+  T* ptr_;
+  std::size_t size_;
+  std::size_t capacity_;
+
+ protected:
+  // Don't initialize ptr_ since it is not accessed to save a few cycles.
+  buffer(std::size_t sz) FMT_NOEXCEPT : size_(sz), capacity_(sz) {}
+
+  buffer(T* p = nullptr, std::size_t sz = 0, std::size_t cap = 0) FMT_NOEXCEPT
+      : ptr_(p),
+        size_(sz),
+        capacity_(cap) {}
+
+  /** Sets the buffer data and capacity. */
+  void set(T* buf_data, std::size_t buf_capacity) FMT_NOEXCEPT {
+    ptr_ = buf_data;
+    capacity_ = buf_capacity;
+  }
+
+  /** Increases the buffer capacity to hold at least *capacity* elements. */
+  virtual void grow(std::size_t capacity) = 0;
+
+ public:
+  using value_type = T;
+  using const_reference = const T&;
+
+  virtual ~buffer() {}
+
+  T* begin() FMT_NOEXCEPT { return ptr_; }
+  T* end() FMT_NOEXCEPT { return ptr_ + size_; }
+
+  /** Returns the size of this buffer. */
+  std::size_t size() const FMT_NOEXCEPT { return size_; }
+
+  /** Returns the capacity of this buffer. */
+  std::size_t capacity() const FMT_NOEXCEPT { return capacity_; }
+
+  /** Returns a pointer to the buffer data. */
+  T* data() FMT_NOEXCEPT { return ptr_; }
+
+  /** Returns a pointer to the buffer data. */
+  const T* data() const FMT_NOEXCEPT { return ptr_; }
+
+  /**
+    Resizes the buffer. If T is a POD type new elements may not be initialized.
+   */
+  void resize(std::size_t new_size) {
+    reserve(new_size);
+    size_ = new_size;
+  }
+
+  /** Clears this buffer. */
+  void clear() { size_ = 0; }
+
+  /** Reserves space to store at least *capacity* elements. */
+  void reserve(std::size_t new_capacity) {
+    if (new_capacity > capacity_) grow(new_capacity);
+  }
+
+  void push_back(const T& value) {
+    reserve(size_ + 1);
+    ptr_[size_++] = value;
+  }
+
+  /** Appends data to the end of the buffer. */
+  template <typename U> void append(const U* begin, const U* end);
+
+  T& operator[](std::size_t index) { return ptr_[index]; }
+  const T& operator[](std::size_t index) const { return ptr_[index]; }
 };
 
-struct dummy_string_view {
-  typedef void char_type;
+// A container-backed buffer.
+template <typename Container>
+class container_buffer : public buffer<typename Container::value_type> {
+ private:
+  Container& container_;
+
+ protected:
+  void grow(std::size_t capacity) FMT_OVERRIDE {
+    container_.resize(capacity);
+    this->set(&container_[0], capacity);
+  }
+
+ public:
+  explicit container_buffer(Container& c)
+      : buffer<typename Container::value_type>(c.size()), container_(c) {}
 };
-dummy_string_view to_string_view(...);
-using fmt::v5::to_string_view;
 
-// Specifies whether S is a string type convertible to fmt::basic_string_view.
-// It should be a constexpr function but MSVC 2017 fails to compile it in
-// enable_if.
-template <typename S>
-struct is_string
-    : std::integral_constant<
-          bool,
-          !std::is_same<dummy_string_view,
-                        decltype(to_string_view(std::declval<S>()))>::value> {};
-
-template <typename S> struct char_t_impl {
-  typedef decltype(to_string_view(std::declval<S>())) result;
-  typedef typename result::char_type type;
+// Extracts a reference to the container from back_insert_iterator.
+template <typename Container>
+inline Container& get_container(std::back_insert_iterator<Container> it) {
+  using bi_iterator = std::back_insert_iterator<Container>;
+  struct accessor : bi_iterator {
+    accessor(bi_iterator iter) : bi_iterator(iter) {}
+    using bi_iterator::container;
+  };
+  return *accessor(it).container;
+}
+
+template <typename T, typename Char = char, typename Enable = void>
+struct fallback_formatter {
+  fallback_formatter() = delete;
 };
 
-template <typename Char> struct named_arg_base;
+// Specifies if T has an enabled fallback_formatter specialization.
+template <typename T, typename Context>
+using has_fallback_formatter =
+    std::is_constructible<fallback_formatter<T, typename Context::char_type>>;
 
+template <typename Char> struct named_arg_base;
 template <typename T, typename Char> struct named_arg;
 
 enum type {
@@ -632,6 +632,26 @@ enum type {
   custom_type
 };
 
+// Maps core type T to the corresponding type enum constant.
+template <typename T, typename Char>
+struct type_constant : std::integral_constant<type, none_type> {};
+
+#define FMT_TYPE_CONSTANT(Type, constant) \
+  template <typename Char>                \
+  struct type_constant<Type, Char> : std::integral_constant<type, constant> {}
+
+FMT_TYPE_CONSTANT(int, int_type);
+FMT_TYPE_CONSTANT(unsigned, uint_type);
+FMT_TYPE_CONSTANT(long long, long_long_type);
+FMT_TYPE_CONSTANT(unsigned long long, ulong_long_type);
+FMT_TYPE_CONSTANT(bool, bool_type);
+FMT_TYPE_CONSTANT(Char, char_type);
+FMT_TYPE_CONSTANT(double, double_type);
+FMT_TYPE_CONSTANT(long double, long_double_type);
+FMT_TYPE_CONSTANT(const Char*, cstring_type);
+FMT_TYPE_CONSTANT(basic_string_view<Char>, string_type);
+FMT_TYPE_CONSTANT(const void*, pointer_type);
+
 FMT_CONSTEXPR bool is_integral(type t) {
   FMT_ASSERT(t != internal::named_arg_type, "invalid argument type");
   return t > internal::none_type && t <= internal::last_integer_type;
@@ -653,10 +673,6 @@ template <typename Context> struct custom_value {
   void (*format)(const void* arg, parse_context& parse_ctx, Context& ctx);
 };
 
-template <typename T, typename Context>
-using is_formattable =
-    std::is_constructible<typename Context::template formatter_type<T>>;
-
 // A formatting argument value.
 template <typename Context> class value {
  public:
@@ -671,33 +687,32 @@ template <typename Context> class value {
     long double long_double_value;
     const void* pointer;
     string_value<char_type> string;
-    string_value<signed char> sstring;
-    string_value<unsigned char> ustring;
     custom_value<Context> custom;
+    const named_arg_base<char_type>* named_arg;
   };
 
   FMT_CONSTEXPR value(int val = 0) : int_value(val) {}
   FMT_CONSTEXPR value(unsigned val) : uint_value(val) {}
-  value(long long val) { long_long_value = val; }
-  value(unsigned long long val) { ulong_long_value = val; }
-  value(double val) { double_value = val; }
-  value(long double val) { long_double_value = val; }
+  value(long long val) : long_long_value(val) {}
+  value(unsigned long long val) : ulong_long_value(val) {}
+  value(double val) : double_value(val) {}
+  value(long double val) : long_double_value(val) {}
   value(const char_type* val) { string.value = val; }
   value(const signed char* val) {
     static_assert(std::is_same<char, char_type>::value,
                   "incompatible string types");
-    sstring.value = val;
+    string.value = reinterpret_cast<const char*>(val);
   }
   value(const unsigned char* val) {
     static_assert(std::is_same<char, char_type>::value,
                   "incompatible string types");
-    ustring.value = val;
+    string.value = reinterpret_cast<const char*>(val);
   }
   value(basic_string_view<char_type> val) {
     string.value = val.data();
     string.size = val.size();
   }
-  value(const void* val) { pointer = val; }
+  value(const void* val) : pointer(val) {}
 
   template <typename T> explicit value(const T& val) {
     custom.value = &val;
@@ -705,14 +720,12 @@ template <typename Context> class value {
     // have different extension points, e.g. `formatter<T>` for `format` and
     // `printf_formatter<T>` for `printf`.
     custom.format = &format_custom_arg<
-        T, conditional_t<is_formattable<T, Context>::value,
+        T, conditional_t<has_formatter<T, Context>::value,
                          typename Context::template formatter_type<T>,
                          internal::fallback_formatter<T, char_type>>>;
   }
 
-  const named_arg_base<char_type>& as_named_arg() {
-    return *static_cast<const named_arg_base<char_type>*>(pointer);
-  }
+  value(const named_arg_base<char_type>& val) { named_arg = &val; }
 
  private:
   // Formats an argument of a custom type, such as a user-defined class.
@@ -771,6 +784,7 @@ FMT_MAKE_VALUE_SAME(long_long_type, long long)
 FMT_MAKE_VALUE_SAME(ulong_long_type, unsigned long long)
 FMT_MAKE_VALUE(int_type, signed char, int)
 FMT_MAKE_VALUE(uint_type, unsigned char, unsigned)
+FMT_MAKE_VALUE(char_type, char, int)
 
 // This doesn't use FMT_MAKE_VALUE because of ambiguity in gcc 4.4.
 template <typename C, typename Char,
@@ -779,10 +793,11 @@ FMT_CONSTEXPR init<C, int, char_type> make_value(Char val) {
   return {val};
 }
 
-template <typename C,
-          FMT_ENABLE_IF(!std::is_same<typename C::char_type, char>::value)>
-FMT_CONSTEXPR init<C, int, char_type> make_value(char val) {
-  return val;
+template <typename C, typename T,
+          FMT_ENABLE_IF(is_char<T>::value && !std::is_same<T, char>::value &&
+                        !std::is_same<T, typename C::char_type>::value)>
+FMT_CONSTEXPR init<C, int, char_type> make_value(const T&) {
+  static_assert(!sizeof(T), "mixing character types is disallowed");
 }
 
 FMT_MAKE_VALUE(double_type, float, double)
@@ -795,17 +810,27 @@ FMT_MAKE_VALUE(cstring_type, typename C::char_type*,
                const typename C::char_type*)
 FMT_MAKE_VALUE(cstring_type, const typename C::char_type*,
                const typename C::char_type*)
-
 FMT_MAKE_VALUE(cstring_type, signed char*, const signed char*)
 FMT_MAKE_VALUE_SAME(cstring_type, const signed char*)
 FMT_MAKE_VALUE(cstring_type, unsigned char*, const unsigned char*)
 FMT_MAKE_VALUE_SAME(cstring_type, const unsigned char*)
-FMT_MAKE_VALUE_SAME(string_type, basic_string_view<typename C::char_type>)
-FMT_MAKE_VALUE(string_type,
-               typename basic_string_view<typename C::char_type>::type,
-               basic_string_view<typename C::char_type>)
-FMT_MAKE_VALUE(string_type, const std::basic_string<typename C::char_type>&,
-               basic_string_view<typename C::char_type>)
+
+template <typename C, typename S, FMT_ENABLE_IF(internal::is_string<S>::value)>
+constexpr init<C, basic_string_view<typename C::char_type>, string_type>
+make_value(const S& val) {
+  static_assert(std::is_same<typename C::char_type, char_t<S>>::value,
+                "mismatch between char-types of context and argument");
+  return to_string_view(val);
+}
+
+template <
+    typename C, typename T, typename Char = typename C::char_type,
+    FMT_ENABLE_IF(std::is_constructible<basic_string_view<Char>, T>::value &&
+                  !internal::is_string<T>::value)>
+inline init<C, basic_string_view<Char>, string_type> make_value(const T& val) {
+  return basic_string_view<Char>(val);
+}
+
 FMT_MAKE_VALUE(pointer_type, void*, const void*)
 FMT_MAKE_VALUE_SAME(pointer_type, const void*)
 FMT_MAKE_VALUE(pointer_type, std::nullptr_t, const void*)
@@ -821,27 +846,20 @@ void make_value(const T*) {
 }
 
 template <typename C, typename T,
-          FMT_ENABLE_IF(convert_to_int<T, typename C::char_type>::value&&
-                            std::is_enum<T>::value)>
+          FMT_ENABLE_IF(std::is_enum<T>::value && !has_formatter<T, C>::value &&
+                        !has_fallback_formatter<T, C>::value)>
 inline init<C, int, int_type> make_value(const T& val) {
   return static_cast<int>(val);
 }
 
-template <
-    typename C, typename T, typename Char = typename C::char_type,
-    FMT_ENABLE_IF(std::is_constructible<basic_string_view<Char>, T>::value &&
-                  !internal::is_string<T>::value)>
-inline init<C, basic_string_view<Char>, string_type> make_value(const T& val) {
-  return basic_string_view<Char>(val);
-}
-
-// Implicit conversion to std::string is not handled here because it's
-// unsafe: https://github.com/fmtlib/fmt/issues/729
+// Implicit conversion to std::string is disallowed because it would be unsafe:
+// https://github.com/fmtlib/fmt/issues/729
 template <
     typename C, typename T, typename Char = typename C::char_type,
     typename U = typename std::remove_volatile<T>::type,
-    FMT_ENABLE_IF(!convert_to_int<U, Char>::value &&
-                  !std::is_same<U, Char>::value &&
+    FMT_ENABLE_IF(!std::is_same<U, Char>::value &&
+                  (!std::is_convertible<U, int>::value ||
+                   has_fallback_formatter<U, C>::value) &&
                   !std::is_convertible<U, basic_string_view<Char>>::value &&
                   !std::is_constructible<basic_string_view<Char>, U>::value &&
                   !internal::is_string<U>::value)>
@@ -849,22 +867,20 @@ inline init<C, const T&, custom_type> make_value(const T& val) {
   return val;
 }
 
-template <typename C, typename T>
-init<C, const void*, named_arg_type> make_value(
-    const named_arg<T, typename C::char_type>& val) {
-  basic_format_arg<C> arg = make_arg<C>(val.value);
-  std::memcpy(val.data, &arg, sizeof(arg));
-  return static_cast<const void*>(&val);
+template <typename C, typename T,
+          FMT_ENABLE_IF(std::is_class<T>::value&& std::is_convertible<
+                            T, int>::value&& has_formatter<T, C>::value &&
+                        !std::is_same<T, typename C::char_type>::value)>
+inline init<C, const T&, custom_type> make_value(const T& val) {
+  return val;
 }
 
-template <typename C, typename S, FMT_ENABLE_IF(internal::is_string<S>::value)>
-FMT_CONSTEXPR11 init<C, basic_string_view<typename C::char_type>, string_type>
-make_value(const S& val) {
-  // Handle adapted strings.
-  static_assert(std::is_same<typename C::char_type,
-                             typename internal::char_t_impl<S>::type>::value,
-                "mismatch between char-types of context and argument");
-  return to_string_view(val);
+template <typename C, typename T, typename Char = typename C::char_type>
+init<C, const named_arg_base<Char>&, named_arg_type> make_value(
+    const named_arg<T, Char>& val) {
+  basic_format_arg<C> arg = make_arg<C>(val.value);
+  std::memcpy(val.data, &arg, sizeof(arg));
+  return val;
 }
 
 // Maximum number of arguments with packed types.
@@ -991,7 +1007,7 @@ template <typename Context> class arg_map {
   unsigned size_;
 
   void push_back(value<Context> val) {
-    const internal::named_arg_base<char_type>& named = val.as_named_arg();
+    const auto& named = *val.named_arg;
     map_[size_] = entry{named.name, named.template deserialize<Context>()};
     ++size_;
   }
@@ -1029,12 +1045,12 @@ template <typename Context, typename T> struct get_type {
   static const type value = value_type::type_tag;
 };
 
-template <typename Context> FMT_CONSTEXPR11 unsigned long long get_types() {
+template <typename Context> constexpr unsigned long long get_types() {
   return 0;
 }
 
 template <typename Context, typename Arg, typename... Args>
-FMT_CONSTEXPR11 unsigned long long get_types() {
+constexpr unsigned long long get_types() {
   return get_type<Context, Arg>::value | (get_types<Context, Args...>() << 4);
 }
 
@@ -1123,53 +1139,26 @@ using wformat_context = buffer_context<wchar_t>;
  */
 template <typename Context, typename... Args> class format_arg_store {
  private:
-  static const size_t NUM_ARGS = sizeof...(Args);
-
-  // Packed is a macro on MinGW so use IS_PACKED instead.
-  static const bool IS_PACKED = NUM_ARGS < internal::max_packed_args;
+  static const size_t num_args = sizeof...(Args);
+  static const bool is_packed = num_args < internal::max_packed_args;
 
-  using value_type = conditional_t<IS_PACKED, internal::value<Context>,
+  using value_type = conditional_t<is_packed, internal::value<Context>,
                                    basic_format_arg<Context>>;
 
   // If the arguments are not packed, add one more element to mark the end.
-  static const size_t DATA_SIZE =
-      NUM_ARGS + (IS_PACKED && NUM_ARGS != 0 ? 0 : 1);
-  value_type data_[DATA_SIZE];
+  value_type data_[num_args + (!is_packed || num_args == 0 ? 1 : 0)];
 
   friend class basic_format_args<Context>;
 
-  static FMT_CONSTEXPR11 unsigned long long get_types() {
-    return IS_PACKED ? internal::get_types<Context, Args...>()
-                     : internal::is_unpacked_bit | NUM_ARGS;
-  }
-
  public:
-#if FMT_USE_CONSTEXPR11
-  static FMT_CONSTEXPR11 unsigned long long TYPES = get_types();
-#else
-  static const unsigned long long TYPES;
-#endif
+  static constexpr unsigned long long TYPES =
+      is_packed ? internal::get_types<Context, Args...>()
+                : internal::is_unpacked_bit | num_args;
 
-#if (FMT_GCC_VERSION && FMT_GCC_VERSION <= 405) || \
-    (FMT_MSC_VER && FMT_MSC_VER <= 1800)
-  // Workaround array initialization issues in gcc <= 4.5 and MSVC <= 2013.
-  format_arg_store(const Args&... args) {
-    value_type init[DATA_SIZE] = {
-        internal::make_arg<IS_PACKED, Context>(args)...};
-    std::memcpy(data_, init, sizeof(init));
-  }
-#else
   format_arg_store(const Args&... args)
-      : data_{internal::make_arg<IS_PACKED, Context>(args)...} {}
-#endif
+      : data_{internal::make_arg<is_packed, Context>(args)...} {}
 };
 
-#if !FMT_USE_CONSTEXPR11
-template <typename Context, typename... Args>
-const unsigned long long format_arg_store<Context, Args...>::TYPES =
-    get_types();
-#endif
-
 /**
   \rst
   Constructs an `~fmt::format_arg_store` object that contains references to
@@ -1260,7 +1249,7 @@ template <typename Context> class basic_format_args {
   format_arg get(size_type index) const {
     format_arg arg = do_get(index);
     if (arg.type_ == internal::named_arg_type)
-      arg = arg.value_.as_named_arg().template deserialize<Context>();
+      arg = arg.value_.named_arg->template deserialize<Context>();
     return arg;
   }
 
@@ -1284,9 +1273,6 @@ struct wformat_args : basic_format_args<wformat_context> {
       : basic_format_args<wformat_context>(std::forward<Args>(arg)...) {}
 };
 
-/** String's character type. */
-template <typename S> using char_t = typename internal::char_t_impl<S>::type;
-
 namespace internal {
 template <typename Context>
 FMT_CONSTEXPR typename Context::format_arg get_arg(Context& ctx, unsigned id) {
@@ -1317,15 +1303,12 @@ template <typename T, typename Char> struct named_arg : named_arg_base<Char> {
       : named_arg_base<Char>(name), value(val) {}
 };
 
-template <typename... Args, typename S,
-          FMT_ENABLE_IF(!is_compile_string<S>::value)>
+template <typename..., typename S, FMT_ENABLE_IF(!is_compile_string<S>::value)>
 inline void check_format_string(const S&) {}
-template <typename... Args, typename S,
-          FMT_ENABLE_IF(is_compile_string<S>::value)>
+template <typename..., typename S, FMT_ENABLE_IF(is_compile_string<S>::value)>
 void check_format_string(S);
 
-template <typename S, typename... Args,
-          typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
+template <typename S, typename... Args, typename Char = char_t<S>>
 inline format_arg_store<buffer_context<Char>, Args...> make_args_checked(
     const S& format_str, const Args&... args) {
   internal::check_format_string<Args...>(format_str);
@@ -1406,8 +1389,7 @@ inline std::back_insert_iterator<Container> format_to(
                     {internal::make_args_checked(format_str, args...)});
 }
 
-template <typename S,
-          typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
+template <typename S, typename Char = char_t<S>>
 inline std::basic_string<Char> vformat(
     const S& format_str, basic_format_args<buffer_context<Char>> args) {
   return internal::vformat(to_string_view(format_str), args);
@@ -1425,8 +1407,7 @@ inline std::basic_string<Char> vformat(
 */
 // Pass char_t as a default template parameter instead of using
 // std::basic_string<char_t<S>> to reduce the symbol size.
-template <typename S, typename... Args,
-          typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
+template <typename S, typename... Args, typename Char = char_t<S>>
 inline std::basic_string<Char> format(const S& format_str,
                                       const Args&... args) {
   return internal::vformat(to_string_view(format_str),
diff --git a/include/fmt/format.h b/include/fmt/format.h
index b60bb95f0299..e4327b6a0e5a 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -785,10 +785,10 @@ inline char8_t to_char8_t(char c) { return static_cast<char8_t>(c); }
 
 template <typename InputIt, typename OutChar>
 struct needs_conversion
-    : std::integral_constant<
-          bool, std::is_same<typename std::iterator_traits<InputIt>::value_type,
-                             char>::value &&
-                    std::is_same<OutChar, char8_t>::value> {};
+    : bool_constant<
+          std::is_same<typename std::iterator_traits<InputIt>::value_type,
+                       char>::value &&
+          std::is_same<OutChar, char8_t>::value> {};
 
 template <typename OutChar, typename InputIt, typename OutputIt,
           FMT_ENABLE_IF(!needs_conversion<InputIt, OutChar>::value)>
@@ -1117,13 +1117,6 @@ struct basic_format_specs : align_spec, core_format_specs {
 
 typedef basic_format_specs<char> format_specs;
 
-template <typename Char, typename ErrorHandler>
-FMT_CONSTEXPR unsigned basic_parse_context<Char, ErrorHandler>::next_arg_id() {
-  if (next_arg_id_ >= 0) return internal::to_unsigned(next_arg_id_++);
-  on_error("cannot switch from manual to automatic argument indexing");
-  return 0;
-}
-
 namespace internal {
 
 namespace grisu_options {
@@ -1817,11 +1810,9 @@ struct string_view_metadata {
       : offset_(view.data() - primary_string.data()), size_(view.size()) {}
   FMT_CONSTEXPR string_view_metadata(std::size_t offset, std::size_t size)
       : offset_(offset), size_(size) {}
-  template <typename S, typename Char = enable_if_t<
-                            internal::is_string<S>::value, char_t<S>>>
-  FMT_CONSTEXPR basic_string_view<Char> to_view(S&& str) const {
-    const auto view = to_string_view(str);
-    return basic_string_view<Char>(view.data() + offset_, size_);
+  template <typename Char>
+  FMT_CONSTEXPR basic_string_view<Char> to_view(const Char* str) const {
+    return {str + offset_, size_};
   }
 
   std::size_t offset_;
@@ -2192,7 +2183,7 @@ FMT_CONSTEXPR const typename ParseContext::char_type* parse_format_specs(
     ParseContext& ctx) {
   // GCC 7.2 requires initializer.
   typedef typename ParseContext::char_type char_type;
-  conditional_t<is_formattable<T, format_context>::value,
+  conditional_t<has_formatter<T, buffer_context<char_type>>::value,
                 formatter<T, char_type>,
                 internal::fallback_formatter<T, char_type>>
       f;
@@ -2268,14 +2259,6 @@ void check_format_string(S format_str) {
   (void)invalid_format;
 }
 
-// Specifies whether to format T using the standard formatter.
-// It is not possible to use get_type in formatter specialization directly
-// because of a bug in MSVC.
-template <typename Context, typename T>
-struct format_type
-    : std::integral_constant<bool, get_type<Context, T>::value != custom_type> {
-};
-
 template <template <typename> class Handler, typename Spec, typename Context>
 void handle_dynamic_spec(Spec& value, arg_ref<typename Context::char_type> ref,
                          Context& ctx,
@@ -3056,24 +3039,24 @@ class format_int {
   std::string str() const { return std::string(str_, size()); }
 };
 
-// Formatter of objects of type T.
+// A formatter specialization for the core types corresponding to internal::type
+// constants.
 template <typename T, typename Char>
 struct formatter<T, Char,
-                 typename std::enable_if<internal::format_type<
-                     buffer_context<Char>, T>::value>::type> {
+                 enable_if_t<internal::type_constant<T, Char>::value !=
+                             internal::none_type>> {
   FMT_CONSTEXPR formatter() : format_str_(nullptr) {}
 
   // Parses format specifiers stopping either at the end of the range or at the
   // terminating '}'.
   template <typename ParseContext>
-  FMT_CONSTEXPR typename ParseContext::iterator parse(ParseContext& ctx) {
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
     format_str_ = ctx.begin();
-    typedef internal::dynamic_specs_handler<ParseContext> handler_type;
-    auto type = internal::get_type<buffer_context<Char>, T>::value;
+    using handler_type = internal::dynamic_specs_handler<ParseContext>;
+    auto type = internal::type_constant<T, Char>::value;
     internal::specs_checker<handler_type> handler(handler_type(specs_, ctx),
                                                   type);
     auto it = parse_format_specs(ctx.begin(), ctx.end(), handler);
-    auto type_spec = specs_.type;
     auto eh = ctx.error_handler();
     switch (type) {
     case internal::none_type:
@@ -3085,27 +3068,27 @@ struct formatter<T, Char,
     case internal::long_long_type:
     case internal::ulong_long_type:
     case internal::bool_type:
-      handle_int_type_spec(type_spec,
+      handle_int_type_spec(specs_.type,
                            internal::int_type_checker<decltype(eh)>(eh));
       break;
     case internal::char_type:
       handle_char_specs(
-          &specs_, internal::char_specs_checker<decltype(eh)>(type_spec, eh));
+          &specs_, internal::char_specs_checker<decltype(eh)>(specs_.type, eh));
       break;
     case internal::double_type:
     case internal::long_double_type:
-      handle_float_type_spec(type_spec,
+      handle_float_type_spec(specs_.type,
                              internal::float_type_checker<decltype(eh)>(eh));
       break;
     case internal::cstring_type:
       internal::handle_cstring_type_spec(
-          type_spec, internal::cstring_type_checker<decltype(eh)>(eh));
+          specs_.type, internal::cstring_type_checker<decltype(eh)>(eh));
       break;
     case internal::string_type:
-      internal::check_string_type_spec(type_spec, eh);
+      internal::check_string_type_spec(specs_.type, eh);
       break;
     case internal::pointer_type:
-      internal::check_pointer_type_spec(type_spec, eh);
+      internal::check_pointer_type_spec(specs_.type, eh);
       break;
     case internal::custom_type:
       // Custom format specifiers should be checked in parse functions of
@@ -3121,9 +3104,8 @@ struct formatter<T, Char,
         specs_.width_, specs_.width_ref, ctx, format_str_);
     internal::handle_dynamic_spec<internal::precision_checker>(
         specs_.precision, specs_.precision_ref, ctx, format_str_);
-    typedef output_range<typename FormatContext::iterator,
-                         typename FormatContext::char_type>
-        range_type;
+    using range_type = output_range<typename FormatContext::iterator,
+                                    typename FormatContext::char_type>;
     return visit_format_arg(arg_formatter<range_type>(ctx, nullptr, &specs_),
                             internal::make_arg<FormatContext>(val));
   }
@@ -3133,6 +3115,42 @@ struct formatter<T, Char,
   const Char* format_str_;
 };
 
+#define FMT_FORMAT_AS(Type, Base)                                             \
+  template <typename Char>                                                    \
+  struct formatter<Type, Char> : formatter<Base, Char> {                      \
+    template <typename FormatContext>                                         \
+    auto format(const Type& val, FormatContext& ctx) -> decltype(ctx.out()) { \
+      return formatter<Base, Char>::format(val, ctx);                         \
+    }                                                                         \
+  }
+
+FMT_FORMAT_AS(signed char, int);
+FMT_FORMAT_AS(unsigned char, unsigned);
+FMT_FORMAT_AS(short, int);
+FMT_FORMAT_AS(unsigned short, unsigned);
+FMT_FORMAT_AS(long, long long);
+FMT_FORMAT_AS(unsigned long, unsigned long long);
+FMT_FORMAT_AS(float, double);
+FMT_FORMAT_AS(Char*, const Char*);
+FMT_FORMAT_AS(std::basic_string<Char>, basic_string_view<Char>);
+FMT_FORMAT_AS(std::nullptr_t, const void*);
+
+template <typename Char>
+struct formatter<void*, Char> : formatter<const void*, Char> {
+  template <typename FormatContext>
+  auto format(void* val, FormatContext& ctx) -> decltype(ctx.out()) {
+    return formatter<const void*, Char>::format(val, ctx);
+  }
+};
+
+template <typename Char, size_t N>
+struct formatter<Char[N], Char> : formatter<basic_string_view<Char>, Char> {
+  template <typename FormatContext>
+  auto format(const Char* val, FormatContext& ctx) -> decltype(ctx.out()) {
+    return formatter<basic_string_view<Char>, Char>::format(val, ctx);
+  }
+};
+
 // A formatter for types known only at run time such as variant alternatives.
 //
 // Usage:
diff --git a/include/fmt/ostream.h b/include/fmt/ostream.h
index 4c2acf4ae96a..49aa58054c65 100644
--- a/include/fmt/ostream.h
+++ b/include/fmt/ostream.h
@@ -96,9 +96,8 @@ void format_value(buffer<Char>& buf, const T& value) {
 
 // Formats an object of type T that has an overloaded ostream operator<<.
 template <typename T, typename Char>
-struct fallback_formatter<
-    T, Char,
-    typename std::enable_if<internal::is_streamable<T, Char>::value>::type>
+struct fallback_formatter<T, Char,
+                          enable_if_t<internal::is_streamable<T, Char>::value>>
     : formatter<basic_string_view<Char>, Char> {
   template <typename Context>
   auto format(const T& value, Context& ctx) -> decltype(ctx.out()) {
@@ -110,15 +109,6 @@ struct fallback_formatter<
 };
 }  // namespace internal
 
-// Disable conversion to int if T has an overloaded operator<< which is a free
-// function (not a member of std::ostream).
-template <typename T, typename Char>
-struct convert_to_int<
-    T, Char,
-    typename std::enable_if<internal::is_streamable<T, Char>::value>::type> {
-  static const bool value = false;
-};
-
 template <typename Char>
 void vprint(std::basic_ostream<Char>& os, basic_string_view<Char> format_str,
             basic_format_args<buffer_context<Char>> args) {
diff --git a/include/fmt/prepare.h b/include/fmt/prepare.h
index a7078ef80294..0ac9218875a2 100644
--- a/include/fmt/prepare.h
+++ b/include/fmt/prepare.h
@@ -262,7 +262,7 @@ class prepared_format {
 
       switch (part.which) {
       case format_part_t::which_value::text: {
-        const auto text = value.text.to_view(format_view);
+        const auto text = value.text.to_view(format_view.data());
         auto output = ctx.out();
         auto&& it = internal::reserve(output, text.size());
         it = std::copy_n(text.begin(), text.size(), it);
@@ -276,16 +276,17 @@ class prepared_format {
 
       case format_part_t::which_value::named_argument_id: {
         advance_parse_context_to_specification(parse_ctx, part);
-        const auto named_arg_id = value.named_arg_id.to_view(format_view);
+        const auto named_arg_id =
+            value.named_arg_id.to_view(format_view.data());
         format_arg<Range>(parse_ctx, ctx, named_arg_id);
       } break;
       case format_part_t::which_value::specification: {
         const auto& arg_id_value = value.spec.arg_id.val;
-        const auto arg =
-            value.spec.arg_id.which ==
-                    format_part_t::argument_id::which_arg_id::index
-                ? ctx.arg(arg_id_value.index)
-                : ctx.arg(arg_id_value.named_index.to_view(format_));
+        const auto arg = value.spec.arg_id.which ==
+                                 format_part_t::argument_id::which_arg_id::index
+                             ? ctx.arg(arg_id_value.index)
+                             : ctx.arg(arg_id_value.named_index.to_view(
+                                   to_string_view(format_).data()));
 
         auto specs = value.spec.parsed_specs;
 
diff --git a/include/fmt/ranges.h b/include/fmt/ranges.h
index 18124d3a4fa0..9128f25a1954 100644
--- a/include/fmt/ranges.h
+++ b/include/fmt/ranges.h
@@ -194,9 +194,7 @@ template <typename T> struct is_tuple_like {
 };
 
 template <typename TupleT, typename Char>
-struct formatter<
-    TupleT, Char,
-    typename std::enable_if<fmt::is_tuple_like<TupleT>::value>::type> {
+struct formatter<TupleT, Char, enable_if_t<fmt::is_tuple_like<TupleT>::value>> {
  private:
   // C++11 generic lambda for format()
   template <typename FormatContext> struct format_each {
@@ -250,8 +248,7 @@ template <typename T> struct is_range {
 };
 
 template <typename RangeT, typename Char>
-struct formatter<RangeT, Char,
-                 typename std::enable_if<fmt::is_range<RangeT>::value>::type> {
+struct formatter<RangeT, Char, enable_if_t<fmt::is_range<RangeT>::value>> {
   formatting_range<Char> formatting;
 
   template <typename ParseContext>
diff --git a/test/core-test.cc b/test/core-test.cc
index ff868e14535e..474c4973a0db 100644
--- a/test/core-test.cc
+++ b/test/core-test.cc
@@ -432,18 +432,48 @@ TEST(StringViewTest, Compare) {
   check_op<std::greater_equal>();
 }
 
-enum basic_enum {};
+struct enabled_formatter {};
+struct disabled_formatter {};
+struct disabled_formatter_convertible {
+  operator int() const { return 42; }
+};
+
+FMT_BEGIN_NAMESPACE
+template <> struct formatter<enabled_formatter> {
+  auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+  auto format(enabled_formatter, format_context& ctx) -> decltype(ctx.out()) {
+    return ctx.out();
+  }
+};
+FMT_END_NAMESPACE
 
-TEST(CoreTest, ConvertToInt) {
-  EXPECT_FALSE((fmt::convert_to_int<char, char>::value));
-  EXPECT_FALSE((fmt::convert_to_int<const char*, char>::value));
-  EXPECT_TRUE((fmt::convert_to_int<basic_enum, char>::value));
+TEST(CoreTest, HasFormatter) {
+  using fmt::internal::has_formatter;
+  using context = fmt::format_context;
+  EXPECT_TRUE((has_formatter<enabled_formatter, context>::value));
+  EXPECT_FALSE((has_formatter<disabled_formatter, context>::value));
+  EXPECT_FALSE((has_formatter<disabled_formatter_convertible, context>::value));
 }
 
-enum enum_with_underlying_type : char {};
+struct convertible_to_int {
+  operator int() const { return 42; }
+};
+
+FMT_BEGIN_NAMESPACE
+template <> struct formatter<convertible_to_int> {
+  auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+  auto format(convertible_to_int, format_context& ctx) -> decltype(ctx.out()) {
+    return std::copy_n("foo", 3, ctx.out());
+  }
+};
+FMT_END_NAMESPACE
 
-TEST(CoreTest, IsEnumConvertibleToInt) {
-  EXPECT_TRUE((fmt::convert_to_int<enum_with_underlying_type, char>::value));
+TEST(CoreTest, FormatterOverridesImplicitConversion) {
+  EXPECT_EQ(fmt::format("{}", convertible_to_int()), "foo");
 }
 
 namespace my_ns {
diff --git a/test/format-test.cc b/test/format-test.cc
index a0f877113abb..0157b65c40ca 100644
--- a/test/format-test.cc
+++ b/test/format-test.cc
@@ -1876,9 +1876,9 @@ enum TestEnum { A };
 
 TEST(FormatTest, Enum) { EXPECT_EQ("0", fmt::format("{}", A)); }
 
-TEST(FormatTest, EnumFormatterUnambiguous) {
-  fmt::formatter<TestEnum> f;
-  ASSERT_GE(sizeof(f), 0);  // use f to avoid compiler warning
+TEST(FormatTest, FormatterNotSpecialized) {
+  EXPECT_FALSE((fmt::internal::has_formatter<fmt::formatter<TestEnum>,
+                                             fmt::format_context>::value));
 }
 
 #if FMT_HAS_FEATURE(cxx_strong_enums)
diff --git a/test/ostream-test.cc b/test/ostream-test.cc
index 3527958b704a..27c62347c4e4 100644
--- a/test/ostream-test.cc
+++ b/test/ostream-test.cc
@@ -46,24 +46,22 @@ struct type_with_comma_op {};
 template <typename T> void operator,(type_with_comma_op, const T&);
 template <typename T> type_with_comma_op operator<<(T&, const Date&);
 
-enum TestEnum {};
-static std::ostream& operator<<(std::ostream& os, TestEnum) {
-  return os << "TestEnum";
+enum streamable_enum {};
+static std::ostream& operator<<(std::ostream& os, streamable_enum) {
+  return os << "streamable_enum";
 }
 
-static std::wostream& operator<<(std::wostream& os, TestEnum) {
-  return os << L"TestEnum";
+static std::wostream& operator<<(std::wostream& os, streamable_enum) {
+  return os << L"streamable_enum";
 }
 
-enum TestEnum2 { A };
+enum unstreamable_enum {};
 
 TEST(OStreamTest, Enum) {
-  EXPECT_FALSE((fmt::convert_to_int<TestEnum, char>::value));
-  EXPECT_EQ("TestEnum", fmt::format("{}", TestEnum()));
-  EXPECT_EQ("0", fmt::format("{}", A));
-  EXPECT_FALSE((fmt::convert_to_int<TestEnum, wchar_t>::value));
-  EXPECT_EQ(L"TestEnum", fmt::format(L"{}", TestEnum()));
-  EXPECT_EQ(L"0", fmt::format(L"{}", A));
+  EXPECT_EQ("streamable_enum", fmt::format("{}", streamable_enum()));
+  EXPECT_EQ("0", fmt::format("{}", unstreamable_enum()));
+  EXPECT_EQ(L"streamable_enum", fmt::format(L"{}", streamable_enum()));
+  EXPECT_EQ(L"0", fmt::format(L"{}", unstreamable_enum()));
 }
 
 typedef fmt::back_insert_range<fmt::internal::buffer<char>> range;
@@ -81,8 +79,8 @@ TEST(OStreamTest, CustomArg) {
   fmt::format_specs spec;
   test_arg_formatter af(ctx, spec);
   fmt::visit_format_arg(
-      af, fmt::internal::make_arg<fmt::format_context>(TestEnum()));
-  EXPECT_EQ("TestEnum", std::string(buffer.data(), buffer.size()));
+      af, fmt::internal::make_arg<fmt::format_context>(streamable_enum()));
+  EXPECT_EQ("streamable_enum", std::string(buffer.data(), buffer.size()));
 }
 
 TEST(OStreamTest, Format) {
diff --git a/test/scan-test.cc b/test/scan-test.cc
index 82e83249a2d4..0b49fd9f0848 100644
--- a/test/scan-test.cc
+++ b/test/scan-test.cc
@@ -1,172 +1,16 @@
-// Formatting library for C++ - scanning API proof of concept
+// Formatting library for C++ - scanning API test
 //
-// Copyright (c) 2012 - present, Victor Zverovich
+// Copyright (c) 2019 - present, Victor Zverovich
 // All rights reserved.
 //
 // For the license information refer to format.h.
 
-#include <array>
+#include <time.h>
 #include <climits>
 
-#include "fmt/format.h"
 #include "gmock.h"
 #include "gtest-extra.h"
-
-FMT_BEGIN_NAMESPACE
-namespace internal {
-enum class scan_type {
-  none_type,
-  int_type,
-  uint_type,
-  long_long_type,
-  ulong_long_type,
-  string_type,
-  string_view_type
-};
-
-struct scan_arg {
-  scan_type arg_type;
-  union {
-    int* int_value;
-    unsigned* uint_value;
-    long long* long_long_value;
-    unsigned long long* ulong_long_value;
-    std::string* string;
-    fmt::string_view* string_view;
-    // TODO: more types
-  };
-
-  scan_arg() : arg_type(scan_type::none_type) {}
-  scan_arg(int& value) : arg_type(scan_type::int_type), int_value(&value) {}
-  scan_arg(unsigned& value)
-      : arg_type(scan_type::uint_type), uint_value(&value) {}
-  scan_arg(long long& value)
-      : arg_type(scan_type::long_long_type), long_long_value(&value) {}
-  scan_arg(unsigned long long& value)
-      : arg_type(scan_type::ulong_long_type), ulong_long_value(&value) {}
-  scan_arg(std::string& value)
-      : arg_type(scan_type::string_type), string(&value) {}
-  scan_arg(fmt::string_view& value)
-      : arg_type(scan_type::string_view_type), string_view(&value) {}
-};
-}  // namespace internal
-
-struct scan_args {
-  int size;
-  const internal::scan_arg* data;
-
-  template <size_t N>
-  scan_args(const std::array<internal::scan_arg, N>& store)
-      : size(N), data(store.data()) {
-    static_assert(N < INT_MAX, "too many arguments");
-  }
-};
-
-namespace internal {
-
-struct scan_handler : error_handler {
- private:
-  const char* begin_;
-  const char* end_;
-  scan_args args_;
-  int next_arg_id_;
-  scan_arg arg_;
-
-  template <typename T = unsigned> T read_uint() {
-    T value = 0;
-    while (begin_ != end_) {
-      char c = *begin_++;
-      if (c < '0' || c > '9') on_error("invalid input");
-      // TODO: check overflow
-      value = value * 10 + (c - '0');
-    }
-    return value;
-  }
-
-  template <typename T = int> T read_int() {
-    T value = 0;
-    bool negative = begin_ != end_ && *begin_ == '-';
-    if (negative) ++begin_;
-    value = read_uint<typename std::make_unsigned<T>::type>();
-    if (negative) value = -value;
-    return value;
-  }
-
- public:
-  scan_handler(string_view input, scan_args args)
-      : begin_(input.data()),
-        end_(begin_ + input.size()),
-        args_(args),
-        next_arg_id_(0) {}
-
-  const char* pos() const { return begin_; }
-
-  void on_text(const char* begin, const char* end) {
-    auto size = end - begin;
-    if (begin_ + size > end_ || !std::equal(begin, end, begin_))
-      on_error("invalid input");
-    begin_ += size;
-  }
-
-  void on_arg_id() {
-    if (next_arg_id_ >= args_.size) on_error("argument index out of range");
-    arg_ = args_.data[next_arg_id_++];
-  }
-  void on_arg_id(unsigned) { on_error("invalid format"); }
-  void on_arg_id(string_view) { on_error("invalid format"); }
-
-  void on_replacement_field(const char*) {
-    switch (arg_.arg_type) {
-    case scan_type::int_type:
-      *arg_.int_value = read_int();
-      break;
-    case scan_type::uint_type:
-      *arg_.uint_value = read_uint();
-      break;
-    case scan_type::long_long_type:
-      *arg_.long_long_value = read_int<long long>();
-      break;
-    case scan_type::ulong_long_type:
-      *arg_.ulong_long_value = read_uint<unsigned long long>();
-      break;
-    case scan_type::string_type:
-      while (begin_ != end_ && *begin_ != ' ')
-        arg_.string->push_back(*begin_++);
-      break;
-    case scan_type::string_view_type: {
-      auto s = begin_;
-      while (begin_ != end_ && *begin_ != ' ')
-        ++begin_;
-      *arg_.string_view = fmt::string_view(s, begin_ - s);
-      break;
-    }
-    default:
-      assert(false);
-    }
-  }
-
-  const char* on_format_specs(const char* begin, const char*) { return begin; }
-};
-}  // namespace internal
-
-template <typename... Args>
-std::array<internal::scan_arg, sizeof...(Args)> make_scan_args(Args&... args) {
-  return std::array<internal::scan_arg, sizeof...(Args)>{args...};
-}
-
-string_view::iterator vscan(string_view input, string_view format_str,
-                            scan_args args) {
-  internal::scan_handler h(input, args);
-  internal::parse_format_string<false>(format_str, h);
-  return input.begin() + (h.pos() - &*input.begin());
-}
-
-template <typename... Args>
-string_view::iterator scan(string_view input, string_view format_str,
-                           Args&... args) {
-  return vscan(input, format_str, make_scan_args(args...));
-}
-FMT_END_NAMESPACE
+#include "scan.h"
 
 TEST(ScanTest, ReadText) {
   fmt::string_view s = "foo";
@@ -219,6 +63,41 @@ TEST(ScanTest, ReadStringView) {
   EXPECT_EQ(s, "foo");
 }
 
+#ifndef _WIN32
+namespace fmt {
+template <> struct scanner<tm> {
+  std::string format;
+
+  scan_parse_context::iterator parse(scan_parse_context& ctx) {
+    auto it = ctx.begin();
+    if (it != ctx.end() && *it == ':') ++it;
+    auto end = it;
+    while (end != ctx.end() && *end != '}') ++end;
+    format.reserve(internal::to_unsigned(end - it + 1));
+    format.append(it, end);
+    format.push_back('\0');
+    return end;
+  }
+
+  template <class ScanContext>
+  typename ScanContext::iterator scan(tm& t, ScanContext& ctx) {
+    auto result = strptime(ctx.begin(), format.c_str(), &t);
+    if (!result) throw format_error("failed to parse time");
+    return result;
+  }
+};
+}  // namespace fmt
+
+TEST(ScanTest, ReadCustom) {
+  const char* input = "Date: 1985-10-25";
+  auto t = tm();
+  fmt::scan(input, "Date: {0:%Y-%m-%d}", t);
+  EXPECT_EQ(t.tm_year, 85);
+  EXPECT_EQ(t.tm_mon, 9);
+  EXPECT_EQ(t.tm_mday, 25);
+}
+#endif
+
 TEST(ScanTest, InvalidFormat) {
   EXPECT_THROW_MSG(fmt::scan("", "{}"), fmt::format_error,
                    "argument index out of range");
diff --git a/test/scan.h b/test/scan.h
new file mode 100644
index 000000000000..9f0b35f44150
--- /dev/null
+++ b/test/scan.h
@@ -0,0 +1,233 @@
+// Formatting library for C++ - scanning API proof of concept
+//
+// Copyright (c) 2019 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include <array>
+
+#include "fmt/format.h"
+
+FMT_BEGIN_NAMESPACE
+template <typename T, typename Char = char> struct scanner {
+  // A deleted default constructor indicates a disabled scanner.
+  scanner() = delete;
+};
+
+class scan_parse_context {
+ private:
+  string_view format_;
+
+ public:
+  using iterator = string_view::iterator;
+
+  explicit FMT_CONSTEXPR scan_parse_context(string_view format)
+      : format_(format) {}
+
+  FMT_CONSTEXPR iterator begin() const { return format_.begin(); }
+  FMT_CONSTEXPR iterator end() const { return format_.end(); }
+
+  void advance_to(iterator it) {
+    format_.remove_prefix(internal::to_unsigned(it - begin()));
+  }
+};
+
+struct scan_context {
+ private:
+  string_view input_;
+
+ public:
+  using iterator = const char*;
+
+  explicit scan_context(string_view input) : input_(input) {}
+
+  iterator begin() const { return input_.data(); }
+  iterator end() const { return begin() + input_.size(); }
+
+  void advance_to(iterator it) {
+    input_.remove_prefix(internal::to_unsigned(it - begin()));
+  }
+};
+
+namespace internal {
+enum class scan_type {
+  none_type,
+  int_type,
+  uint_type,
+  long_long_type,
+  ulong_long_type,
+  string_type,
+  string_view_type,
+  custom_type
+};
+
+struct custom_scan_arg {
+  void* value;
+  void (*scan)(void* arg, scan_parse_context& parse_ctx, scan_context& ctx);
+};
+
+class scan_arg {
+ public:
+  scan_type type;
+  union {
+    int* int_value;
+    unsigned* uint_value;
+    long long* long_long_value;
+    unsigned long long* ulong_long_value;
+    std::string* string;
+    fmt::string_view* string_view;
+    custom_scan_arg custom;
+    // TODO: more types
+  };
+
+  scan_arg() : type(scan_type::none_type) {}
+  scan_arg(int& value) : type(scan_type::int_type), int_value(&value) {}
+  scan_arg(unsigned& value) : type(scan_type::uint_type), uint_value(&value) {}
+  scan_arg(long long& value)
+      : type(scan_type::long_long_type), long_long_value(&value) {}
+  scan_arg(unsigned long long& value)
+      : type(scan_type::ulong_long_type), ulong_long_value(&value) {}
+  scan_arg(std::string& value) : type(scan_type::string_type), string(&value) {}
+  scan_arg(fmt::string_view& value)
+      : type(scan_type::string_view_type), string_view(&value) {}
+  template <typename T> scan_arg(T& value) : type(scan_type::custom_type) {
+    custom.value = &value;
+    custom.scan = scan_custom_arg<T>;
+  }
+
+ private:
+  template <typename T>
+  static void scan_custom_arg(void* arg, scan_parse_context& parse_ctx,
+                              scan_context& ctx) {
+    scanner<T> s;
+    parse_ctx.advance_to(s.parse(parse_ctx));
+    ctx.advance_to(s.scan(*static_cast<T*>(arg), ctx));
+  }
+};
+}  // namespace internal
+
+struct scan_args {
+  int size;
+  const internal::scan_arg* data;
+
+  template <size_t N>
+  scan_args(const std::array<internal::scan_arg, N>& store)
+      : size(N), data(store.data()) {
+    static_assert(N < INT_MAX, "too many arguments");
+  }
+};
+
+namespace internal {
+
+struct scan_handler : error_handler {
+ private:
+  scan_parse_context parse_ctx_;
+  scan_context scan_ctx_;
+  scan_args args_;
+  int next_arg_id_;
+  scan_arg arg_;
+
+  template <typename T = unsigned> T read_uint() {
+    T value = 0;
+    auto it = scan_ctx_.begin(), end = scan_ctx_.end();
+    while (it != end) {
+      char c = *it++;
+      if (c < '0' || c > '9') on_error("invalid input");
+      // TODO: check overflow
+      value = value * 10 + (c - '0');
+    }
+    scan_ctx_.advance_to(it);
+    return value;
+  }
+
+  template <typename T = int> T read_int() {
+    T value = 0;
+    auto it = scan_ctx_.begin(), end = scan_ctx_.end();
+    bool negative = it != end && *it == '-';
+    if (negative) ++it;
+    scan_ctx_.advance_to(it);
+    value = read_uint<typename std::make_unsigned<T>::type>();
+    if (negative) value = -value;
+    return value;
+  }
+
+ public:
+  scan_handler(string_view format, string_view input, scan_args args)
+      : parse_ctx_(format), scan_ctx_(input), args_(args), next_arg_id_(0) {}
+
+  const char* pos() const { return scan_ctx_.begin(); }
+
+  void on_text(const char* begin, const char* end) {
+    auto size = end - begin;
+    auto it = scan_ctx_.begin();
+    if (it + size > scan_ctx_.end() || !std::equal(begin, end, it))
+      on_error("invalid input");
+    scan_ctx_.advance_to(it + size);
+  }
+
+  void on_arg_id() { on_arg_id(next_arg_id_++); }
+  void on_arg_id(unsigned id) {
+    if (id >= args_.size) on_error("argument index out of range");
+    arg_ = args_.data[id];
+  }
+  void on_arg_id(string_view) { on_error("invalid format"); }
+
+  void on_replacement_field(const char*) {
+    auto it = scan_ctx_.begin(), end = scan_ctx_.end();
+    switch (arg_.type) {
+    case scan_type::int_type:
+      *arg_.int_value = read_int();
+      break;
+    case scan_type::uint_type:
+      *arg_.uint_value = read_uint();
+      break;
+    case scan_type::long_long_type:
+      *arg_.long_long_value = read_int<long long>();
+      break;
+    case scan_type::ulong_long_type:
+      *arg_.ulong_long_value = read_uint<unsigned long long>();
+      break;
+    case scan_type::string_type:
+      while (it != end && *it != ' ') arg_.string->push_back(*it++);
+      scan_ctx_.advance_to(it);
+      break;
+    case scan_type::string_view_type: {
+      auto s = it;
+      while (it != end && *it != ' ') ++it;
+      *arg_.string_view = fmt::string_view(s, it - s);
+      scan_ctx_.advance_to(it);
+      break;
+    }
+    default:
+      assert(false);
+    }
+  }
+
+  const char* on_format_specs(const char* begin, const char*) {
+    if (arg_.type != scan_type::custom_type) return begin;
+    parse_ctx_.advance_to(begin);
+    arg_.custom.scan(arg_.custom.value, parse_ctx_, scan_ctx_);
+    return parse_ctx_.begin();
+  }
+};
+}  // namespace internal
+
+template <typename... Args>
+std::array<internal::scan_arg, sizeof...(Args)> make_scan_args(Args&... args) {
+  return std::array<internal::scan_arg, sizeof...(Args)>{args...};
+}
+
+string_view::iterator vscan(string_view input, string_view format_str,
+                            scan_args args) {
+  internal::scan_handler h(format_str, input, args);
+  internal::parse_format_string<false>(format_str, h);
+  return input.begin() + (h.pos() - &*input.begin());
+}
+
+template <typename... Args>
+string_view::iterator scan(string_view input, string_view format_str,
+                           Args&... args) {
+  return vscan(input, format_str, make_scan_args(args...));
+}
+FMT_END_NAMESPACE