diff --git a/include/fmt/core.h b/include/fmt/core.h
index f7a5da68..4b59fe5d 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -289,7 +289,7 @@ typedef basic_string_view<char> string_view;
 typedef basic_string_view<wchar_t> wstring_view;
 
 template <typename Context>
-class basic_arg;
+class basic_format_arg;
 
 template <typename Context>
 class basic_format_args;
@@ -546,7 +546,7 @@ struct typed_value : value<Context> {
 };
 
 template <typename Context, typename T>
-FMT_CONSTEXPR basic_arg<Context> make_arg(const T &value);
+FMT_CONSTEXPR basic_format_arg<Context> make_arg(const T &value);
 
 #define FMT_MAKE_VALUE(TAG, ArgType, ValueType) \
   template <typename C> \
@@ -641,7 +641,7 @@ inline typename std::enable_if<
 template <typename C, typename T>
 typed_value<C, name_arg_type>
     make_value(const named_arg<T, typename C::char_type> &val) {
-  basic_arg<C> arg = make_arg<C>(val.value);
+  basic_format_arg<C> arg = make_arg<C>(val.value);
   std::memcpy(val.data, &arg, sizeof(arg));
   return static_cast<const void*>(&val);
 }
@@ -666,17 +666,18 @@ struct result_of<F(Args...)> {
 // A formatting argument. It is a trivially copyable/constructible type to
 // allow storage in basic_memory_buffer.
 template <typename Context>
-class basic_arg {
+class basic_format_arg {
  private:
   internal::value<Context> value_;
   internal::type type_;
 
   template <typename ContextType, typename T>
-  friend FMT_CONSTEXPR basic_arg<ContextType> internal::make_arg(const T &value);
+  friend FMT_CONSTEXPR basic_format_arg<ContextType>
+    internal::make_arg(const T &value);
 
   template <typename Visitor, typename Ctx>
   friend FMT_CONSTEXPR typename internal::result_of<Visitor(int)>::type
-    visit(Visitor &&vis, basic_arg<Ctx> arg);
+    visit(Visitor &&vis, basic_format_arg<Ctx> arg);
 
   friend class basic_format_args<Context>;
   friend class internal::arg_map<Context>;
@@ -694,7 +695,7 @@ class basic_arg {
     internal::custom_value<Context> custom_;
   };
 
-  FMT_CONSTEXPR basic_arg() : type_(internal::none_type) {}
+  FMT_CONSTEXPR basic_format_arg() : type_(internal::none_type) {}
 
   FMT_EXPLICIT operator bool() const FMT_NOEXCEPT {
     return type_ != internal::none_type;
@@ -771,7 +772,7 @@ class arg_map {
 
   struct entry {
     basic_string_view<char_type> name;
-    basic_arg<Context> arg;
+    basic_format_arg<Context> arg;
   };
 
   entry *map_;
@@ -788,13 +789,13 @@ class arg_map {
   void init(const basic_format_args<Context> &args);
   ~arg_map() { delete [] map_; }
 
-  basic_arg<Context> find(basic_string_view<char_type> name) const {
+  basic_format_arg<Context> find(basic_string_view<char_type> name) const {
     // The list is unsorted, so just return the first matching name.
     for (auto it = map_, end = map_ + size_; it != end; ++it) {
       if (it->name == name)
         return it->arg;
     }
-    return basic_arg<Context>();
+    return basic_format_arg<Context>();
   }
 };
 
@@ -810,7 +811,7 @@ class context_base {
 
  protected:
   typedef Char char_type;
-  typedef basic_arg<Context> format_arg;
+  typedef basic_format_arg<Context> format_arg;
 
   context_base(OutputIt out, basic_string_view<char_type> format_str,
                basic_format_args<Context> args)
@@ -932,8 +933,8 @@ FMT_CONSTEXPR uint64_t get_types() {
 }
 
 template <typename Context, typename T>
-FMT_CONSTEXPR basic_arg<Context> make_arg(const T &value) {
-  basic_arg<Context> arg;
+FMT_CONSTEXPR basic_format_arg<Context> make_arg(const T &value) {
+  basic_format_arg<Context> arg;
   arg.type_ = get_type<Context, T>::value;
   arg.value_ = make_value<Context>(value);
   return arg;
@@ -946,7 +947,7 @@ inline typename std::enable_if<IS_PACKED, value<Context>>::type
 }
 
 template <bool IS_PACKED, typename Context, typename T>
-inline typename std::enable_if<!IS_PACKED, basic_arg<Context>>::type
+inline typename std::enable_if<!IS_PACKED, basic_format_arg<Context>>::type
     make_arg(const T &value) {
   return make_arg<Context>(value);
 }
@@ -960,15 +961,15 @@ inline typename std::enable_if<!IS_PACKED, basic_arg<Context>>::type
   \endrst
  */
 template <typename Context, typename ...Args>
-class arg_store {
+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;
 
-  typedef typename std::conditional<
-    IS_PACKED, internal::value<Context>, basic_arg<Context>>::type value_type;
+  typedef typename std::conditional<IS_PACKED,
+    internal::value<Context>, basic_format_arg<Context>>::type value_type;
 
   // If the arguments are not packed, add one more element to mark the end.
   value_type data_[NUM_ARGS + (IS_PACKED && NUM_ARGS != 0 ? 0 : 1)];
@@ -980,11 +981,11 @@ class arg_store {
 
 #if FMT_GCC_VERSION && FMT_GCC_VERSION <= 405
   // Workaround an array initialization bug in gcc 4.5 and earlier.
-  arg_store(const Args &... args) {
+  format_arg_store(const Args &... args) {
     data_ = {internal::make_arg<IS_PACKED, Context>(args)...};
   }
 #else
-  arg_store(const Args &... args)
+  format_arg_store(const Args &... args)
     : data_{internal::make_arg<IS_PACKED, Context>(args)...} {}
 #endif
 
@@ -992,25 +993,25 @@ class arg_store {
 };
 
 template <typename Context, typename ...Args>
-const uint64_t arg_store<Context, Args...>::TYPES = IS_PACKED ?
+const uint64_t format_arg_store<Context, Args...>::TYPES = IS_PACKED ?
     internal::get_types<Context, Args...>() :
     -static_cast<int64_t>(NUM_ARGS);
 
 /**
   \rst
-  Constructs an `~fmt::arg_store` object that contains references to arguments
-  and can be implicitly converted to `~fmt::format_args`. `Context` can be
-  omitted in which case it defaults to `~fmt::context`.
+  Constructs an `~fmt::format_arg_store` object that contains references to
+  arguments and can be implicitly converted to `~fmt::format_args`. `Context` can
+  be omitted in which case it defaults to `~fmt::context`.
   \endrst
  */
 template <typename Context, typename ...Args>
-inline arg_store<Context, Args...> make_args(const Args & ... args) {
-  return arg_store<Context, Args...>(args...);
+inline format_arg_store<Context, Args...> make_args(const Args & ... args) {
+  return format_arg_store<Context, Args...>(args...);
 }
 
 template <typename ...Args>
-inline arg_store<context, Args...> make_args(const Args & ... args) {
-  return arg_store<context, Args...>(args...);
+inline format_arg_store<context, Args...> make_args(const Args & ... args) {
+  return format_arg_store<context, Args...>(args...);
 }
 
 /** Formatting arguments. */
@@ -1018,7 +1019,7 @@ template <typename Context>
 class basic_format_args {
  public:
   typedef unsigned size_type;
-  typedef basic_arg<Context>  format_arg;
+  typedef basic_format_arg<Context>  format_arg;
 
  private:
   // To reduce compiled code size per formatting function call, types of first
@@ -1068,11 +1069,11 @@ class basic_format_args {
 
   /**
    \rst
-   Constructs a `basic_format_args` object from `~fmt::arg_store`.
+   Constructs a `basic_format_args` object from `~fmt::format_arg_store`.
    \endrst
    */
   template <typename... Args>
-  basic_format_args(const arg_store<Context, Args...> &store)
+  basic_format_args(const format_arg_store<Context, Args...> &store)
   : types_(store.TYPES) {
     set_data(store.data_);
   }
@@ -1107,14 +1108,14 @@ struct named_arg_base {
   basic_string_view<Char> name;
 
   // Serialized value<context>.
-  mutable char data[sizeof(basic_arg<context>)];
+  mutable char data[sizeof(basic_format_arg<context>)];
 
   named_arg_base(basic_string_view<Char> nm) : name(nm) {}
 
   template <typename Context>
-  basic_arg<Context> deserialize() const {
-    basic_arg<Context> arg;
-    std::memcpy(&arg, data, sizeof(basic_arg<Context>));
+  basic_format_arg<Context> deserialize() const {
+    basic_format_arg<Context> arg;
+    std::memcpy(&arg, data, sizeof(basic_format_arg<Context>));
     return arg;
   }
 };
@@ -1212,12 +1213,12 @@ inline std::string format(string_view format_str, const Args & ... args) {
   // This should be just
   // return vformat(format_str, make_args(args...));
   // but gcc has trouble optimizing the latter, so break it down.
-  arg_store<context, Args...> as(args...);
+  format_arg_store<context, Args...> as(args...);
   return vformat(format_str, as);
 }
 template <typename... Args>
 inline std::wstring format(wstring_view format_str, const Args & ... args) {
-  arg_store<wcontext, Args...> as(args...);
+  format_arg_store<wcontext, Args...> as(args...);
   return vformat(format_str, as);
 }
 
@@ -1234,7 +1235,7 @@ FMT_API void vprint(std::FILE *f, string_view format_str, format_args args);
  */
 template <typename... Args>
 inline void print(std::FILE *f, string_view format_str, const Args & ... args) {
-  arg_store<context, Args...> as(args...);
+  format_arg_store<context, Args...> as(args...);
   vprint(f, format_str, as);
 }
 
@@ -1251,7 +1252,7 @@ FMT_API void vprint(string_view format_str, format_args args);
  */
 template <typename... Args>
 inline void print(string_view format_str, const Args & ... args) {
-  arg_store<context, Args...> as(args...);
+  format_arg_store<context, Args...> as(args...);
   vprint(format_str, as);
 }
 }  // namespace fmt
diff --git a/include/fmt/format.h b/include/fmt/format.h
index 4bb8f15d..165c22ae 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -1068,7 +1068,7 @@ struct monostate {};
  */
 template <typename Visitor, typename Context>
 FMT_CONSTEXPR typename internal::result_of<Visitor(int)>::type
-    visit(Visitor &&vis, basic_arg<Context> arg) {
+    visit(Visitor &&vis, basic_format_arg<Context> arg) {
   typedef typename Context::char_type char_type;
   switch (arg.type_) {
   case internal::none_type:
@@ -1100,7 +1100,7 @@ FMT_CONSTEXPR typename internal::result_of<Visitor(int)>::type
   case internal::pointer_type:
     return vis(arg.value_.pointer);
   case internal::custom_type:
-    return vis(typename basic_arg<Context>::handle(arg.value_.custom));
+    return vis(typename basic_format_arg<Context>::handle(arg.value_.custom));
   }
   return vis(monostate());
 }
@@ -1560,7 +1560,7 @@ class custom_formatter: public function<bool> {
  public:
   explicit custom_formatter(Context &ctx): ctx_(ctx) {}
 
-  bool operator()(typename basic_arg<Context>::handle h) const {
+  bool operator()(typename basic_format_arg<Context>::handle h) const {
     h.format(ctx_);
     return true;
   }
@@ -1726,7 +1726,7 @@ class specs_checker : public Handler {
 template <template <typename> class Handler, typename T,
           typename Context, typename ErrorHandler>
 FMT_CONSTEXPR void set_dynamic_spec(
-    T &value, basic_arg<Context> arg, ErrorHandler eh) {
+    T &value, basic_format_arg<Context> arg, ErrorHandler eh) {
   unsigned long long big_value = visit(Handler<ErrorHandler>(eh), arg);
   if (big_value > (std::numeric_limits<int>::max)())
     eh.on_error("number is too big");
@@ -1761,12 +1761,12 @@ class specs_handler: public specs_setter<typename Context::char_type> {
   }
 
  private:
-  FMT_CONSTEXPR basic_arg<Context> get_arg(auto_id) {
+  FMT_CONSTEXPR basic_format_arg<Context> get_arg(auto_id) {
     return context_.next_arg();
   }
 
   template <typename Id>
-  FMT_CONSTEXPR basic_arg<Context> get_arg(Id arg_id) {
+  FMT_CONSTEXPR basic_format_arg<Context> get_arg(Id arg_id) {
     context_.parse_context().check_arg_id(arg_id);
     return context_.get_arg(arg_id);
   }
@@ -2212,7 +2212,7 @@ class arg_formatter:
   using base::operator();
 
   /** Formats an argument of a user-defined type. */
-  iterator operator()(typename basic_arg<context_type>::handle handle) {
+  iterator operator()(typename basic_format_arg<context_type>::handle handle) {
     handle.format(ctx_);
     return this->out();
   }
@@ -3256,7 +3256,7 @@ struct format_handler : internal::error_handler {
   }
 
   Context context;
-  basic_arg<Context> arg;
+  basic_format_arg<Context> arg;
 };
 
 /** Formats arguments and writes the output to the range. */
@@ -3473,7 +3473,8 @@ inline typename std::enable_if<internal::is_format_string<String>::value>::type
 
 // Counts the number of characters in the output of format(format_str, args...).
 template <typename... Args>
-inline std::size_t count(string_view format_str, const Args & ... args) {
+inline std::size_t formatted_size(string_view format_str,
+                                  const Args & ... args) {
   auto it = format_to(internal::counting_iterator<char>(), format_str, args...);
   return it.count();
 }
diff --git a/include/fmt/printf.h b/include/fmt/printf.h
index 43d700dc..9e605b0a 100644
--- a/include/fmt/printf.h
+++ b/include/fmt/printf.h
@@ -81,11 +81,11 @@ class arg_converter: public function<void> {
  private:
   typedef typename Context::char_type Char;
 
-  basic_arg<Context> &arg_;
+  basic_format_arg<Context> &arg_;
   typename Context::char_type type_;
 
  public:
-  arg_converter(basic_arg<Context> &arg, Char type)
+  arg_converter(basic_format_arg<Context> &arg, Char type)
     : arg_(arg), type_(type) {}
 
   void operator()(bool value) {
@@ -133,7 +133,7 @@ class arg_converter: public function<void> {
 // type depending on the type specifier: 'd' and 'i' - signed, other -
 // unsigned).
 template <typename T, typename Context, typename Char>
-void convert_arg(basic_arg<Context> &arg, Char type) {
+void convert_arg(basic_format_arg<Context> &arg, Char type) {
   visit(arg_converter<T, Context>(arg, type), arg);
 }
 
@@ -141,12 +141,12 @@ void convert_arg(basic_arg<Context> &arg, Char type) {
 template <typename Context>
 class char_converter: public function<void> {
  private:
-  basic_arg<Context> &arg_;
+  basic_format_arg<Context> &arg_;
 
   FMT_DISALLOW_COPY_AND_ASSIGN(char_converter);
 
  public:
-  explicit char_converter(basic_arg<Context> &arg) : arg_(arg) {}
+  explicit char_converter(basic_format_arg<Context> &arg) : arg_(arg) {}
 
   template <typename T>
   typename std::enable_if<std::is_integral<T>::value>::type
@@ -286,7 +286,7 @@ class printf_arg_formatter:
   }
 
   /** Formats an argument of a custom (user-defined) type. */
-  iterator operator()(typename basic_arg<context_type>::handle handle) {
+  iterator operator()(typename basic_format_arg<context_type>::handle handle) {
     handle.format(context_);
     return this->out();
   }
@@ -545,8 +545,10 @@ struct printf_context {
 };
 
 template <typename ...Args>
-inline arg_store<printf_context<internal::buffer>::type, Args...> make_printf_args(const Args & ... args) {
-  return arg_store<printf_context<internal::buffer>::type, Args...>(args...);
+inline format_arg_store<printf_context<internal::buffer>::type, Args...>
+    make_printf_args(const Args & ... args) {
+  return format_arg_store<printf_context<internal::buffer>::type, Args...>(
+      args...);
 }
 typedef basic_format_args<printf_context<internal::buffer>::type> printf_args;
 
diff --git a/test/format-test.cc b/test/format-test.cc
index b4a53c7a..6c182073 100644
--- a/test/format-test.cc
+++ b/test/format-test.cc
@@ -1421,7 +1421,7 @@ class mock_arg_formatter:
     return base::operator()(value);
   }
 
-  iterator operator()(fmt::basic_arg<fmt::context>::handle) {
+  iterator operator()(fmt::basic_format_arg<fmt::context>::handle) {
     return base::operator()(fmt::monostate());
   }
 };
@@ -1506,8 +1506,8 @@ TEST(FormatTest, OutputIterators) {
   EXPECT_EQ("42", s.str());
 }
 
-TEST(FormatTest, OutputSize) {
-  EXPECT_EQ(2u, fmt::count("{}", 42));
+TEST(FormatTest, FormattedSize) {
+  EXPECT_EQ(2u, fmt::formatted_size("{}", 42));
 }
 
 TEST(FormatTest, FormatToN) {
@@ -1633,12 +1633,12 @@ TEST(FormatTest, ConstexprParseFormatSpecs) {
 struct test_context {
   typedef char char_type;
 
-  FMT_CONSTEXPR fmt::basic_arg<test_context> next_arg() {
+  FMT_CONSTEXPR fmt::basic_format_arg<test_context> next_arg() {
     return fmt::internal::make_arg<test_context>(11);
   }
 
   template <typename Id>
-  FMT_CONSTEXPR fmt::basic_arg<test_context> get_arg(Id) {
+  FMT_CONSTEXPR fmt::basic_format_arg<test_context> get_arg(Id) {
     return fmt::internal::make_arg<test_context>(22);
   }
 
diff --git a/test/util-test.cc b/test/util-test.cc
index 474177bb..1c9897fa 100644
--- a/test/util-test.cc
+++ b/test/util-test.cc
@@ -33,7 +33,7 @@
 #undef min
 #undef max
 
-using fmt::basic_arg;
+using fmt::basic_format_arg;
 using fmt::internal::basic_buffer;
 using fmt::basic_memory_buffer;
 using fmt::string_view;
@@ -48,7 +48,7 @@ namespace {
 struct Test {};
 
 template <typename Context, typename T>
-basic_arg<Context> make_arg(const T &value) {
+basic_format_arg<Context> make_arg(const T &value) {
   return fmt::internal::make_arg<Context>(value);
 }
 }  // namespace
@@ -579,7 +579,7 @@ TEST(UtilTest, PointerArg) {
 }
 
 struct check_custom {
-  Result operator()(fmt::basic_arg<fmt::context>::handle h) const {
+  Result operator()(fmt::basic_format_arg<fmt::context>::handle h) const {
     fmt::memory_buffer buffer;
     fmt::internal::basic_buffer<char> &base = buffer;
     fmt::context ctx(std::back_inserter(base), "", fmt::format_args());
@@ -591,7 +591,7 @@ struct check_custom {
 
 TEST(UtilTest, CustomArg) {
   ::Test test;
-  typedef MockVisitor<fmt::basic_arg<fmt::context>::handle> visitor;
+  typedef MockVisitor<fmt::basic_format_arg<fmt::context>::handle> visitor;
   testing::StrictMock<visitor> v;
   EXPECT_CALL(v, visit(_)).WillOnce(testing::Invoke(check_custom()));
   fmt::visit(v, make_arg<fmt::context>(test));
@@ -601,7 +601,7 @@ TEST(ArgVisitorTest, VisitInvalidArg) {
   typedef MockVisitor<fmt::monostate> Visitor;
   testing::StrictMock<Visitor> visitor;
   EXPECT_CALL(visitor, visit(_));
-  fmt::basic_arg<fmt::context> arg;
+  fmt::basic_format_arg<fmt::context> arg;
   visit(visitor, arg);
 }