diff --git a/pandas/native.pxd b/pandas/native.pxd
index caf3d2d96..429993804 100644
--- a/pandas/native.pxd
+++ b/pandas/native.pxd
@@ -27,7 +27,7 @@ cdef extern from "<iostream>":
     pass
 
 
-cdef extern from "pandas/status.h" namespace "pandas" nogil:
+cdef extern from "pandas/common.h" namespace "pandas" nogil:
 
     # We can later add more of the common status factory methods as needed
     cdef Status Status_OK "Status::OK"()
@@ -44,28 +44,30 @@ cdef extern from "pandas/status.h" namespace "pandas" nogil:
         c_bool IsUnknownError()
         c_bool IsNotImplemented()
 
-cdef extern from "pandas/api.h" namespace "pandas":
+cdef extern from "pandas/api.h" namespace "pandas::DataType":
 
     enum TypeId:
-        TypeId_NA " pandas::DataType::NA"
-        TypeId_UINT8 " pandas::DataType::UINT8"
-        TypeId_UINT16 " pandas::DataType::UINT16"
-        TypeId_UINT32 " pandas::DataType::UINT32"
-        TypeId_UINT64 " pandas::DataType::UINT64"
-        TypeId_INT8 " pandas::DataType::INT8"
-        TypeId_INT16 " pandas::DataType::INT16"
-        TypeId_INT32 " pandas::DataType::INT32"
-        TypeId_INT64 " pandas::DataType::INT64"
-        TypeId_BOOL " pandas::DataType::BOOL"
-        TypeId_FLOAT " pandas::DataType::FLOAT"
-        TypeId_DOUBLE " pandas::DataType::DOUBLE"
-        TypeId_PYOBJECT " pandas::DataType::PYOBJECT"
-        TypeId_CATEGORY " pandas::DataType::CATEGORY"
-        TypeId_TIMESTAMP " pandas::DataType::TIMESTAMP"
-        TypeId_TIMESTAMP_TZ " pandas::DataType::TIMESTAMP_TZ"
+        TypeId_NA " pandas::DataType::TypeId::NA"
+        TypeId_UINT8 " pandas::DataType::TypeId::UINT8"
+        TypeId_UINT16 " pandas::DataType::TypeId::UINT16"
+        TypeId_UINT32 " pandas::DataType::TypeId::UINT32"
+        TypeId_UINT64 " pandas::DataType::TypeId::UINT64"
+        TypeId_INT8 " pandas::DataType::TypeId::INT8"
+        TypeId_INT16 " pandas::DataType::TypeId::INT16"
+        TypeId_INT32 " pandas::DataType::TypeId::INT32"
+        TypeId_INT64 " pandas::DataType::TypeId::INT64"
+        TypeId_BOOL " pandas::DataType::TypeId::BOOL"
+        TypeId_FLOAT32 " pandas::DataType::TypeId::FLOAT32"
+        TypeId_FLOAT64 " pandas::DataType::TypeId::FLOAT64"
+        TypeId_PYOBJECT " pandas::DataType::TypeId::PYOBJECT"
+        TypeId_CATEGORY " pandas::DataType::TypeId::CATEGORY"
+        TypeId_TIMESTAMP " pandas::DataType::TypeId::TIMESTAMP"
+        TypeId_TIMESTAMP_TZ " pandas::DataType::TypeId::TIMESTAMP_TZ"
+
+cdef extern from "pandas/api.h" namespace "pandas":
 
     cdef cppclass DataType:
-        TypeId type
+        TypeId type()
 
         DataType()
 
@@ -116,8 +118,8 @@ cdef extern from "pandas/api.h" namespace "pandas":
         TypeId type_id()
         size_t length()
 
-        object GetValue(size_t i)
-        void SetValue(size_t i, object val)
+        object GetItem(size_t i)
+        void SetItem(size_t i, object val)
 
     cdef cppclass CCategoryArray" pandas::CategoryArray"(CArray):
         pass
diff --git a/pandas/native.pyx b/pandas/native.pyx
index 12a1cdef2..b700dedbe 100644
--- a/pandas/native.pyx
+++ b/pandas/native.pyx
@@ -209,7 +209,7 @@ cdef class Array:
     cdef inline _getitem(self, size_t i):
         if i >= self.ap.length():
             raise IndexError('Out of bounds: %d' % i)
-        return self.ap.GetValue(i)
+        return self.ap.GetItem(i)
 
     def __setitem__(self, i, val):
         cdef:
@@ -226,7 +226,7 @@ cdef class Array:
     cdef inline _setitem(self, size_t i, object val):
         if i >= self.ap.length():
             raise IndexError('Out of bounds: %d' % i)
-        self.ap.SetValue(i, val)
+        self.ap.SetItem(i, val)
 
     def slice(self, start, end):
         pass
@@ -251,7 +251,7 @@ cdef class Float32Array(FloatingArray):
 
 cdef class BooleanArray(Array):
     cdef:
-        lp.cBooleanArray* inst
+        lp.CBooleanArray* inst
 
     cdef init(self, const ArrayPtr& arr):
         Array.init(self, arr)
@@ -265,7 +265,7 @@ cdef Array wrap_array(const lp.ArrayPtr& arr):
     cdef:
         Array result
 
-    if arr.get().type_enum() == lp.TypeId_CATEGORY:
+    if arr.get().type_id() == lp.TypeId_CATEGORY:
         result = CategoryArray()
     else:
         result = Array()
@@ -280,7 +280,7 @@ cdef PandasType wrap_type(const lp.TypePtr& sp_type):
         lp.DataType* type = sp_type.get()
         PandasType result
 
-    if type.type == lp.TypeId_CATEGORY:
+    if type.type() == lp.TypeId_CATEGORY:
         result = Category()
     else:
         result = PandasType()
diff --git a/src/pandas/array-test.cc b/src/pandas/array-test.cc
index b2868db45..04acf5ba9 100644
--- a/src/pandas/array-test.cc
+++ b/src/pandas/array-test.cc
@@ -40,7 +40,7 @@ class TestArray : public ::testing::Test {
 TEST_F(TestArray, Attrs) {
   DoubleType ex_type;
   ASSERT_TRUE(array_->type()->Equals(ex_type));
-  ASSERT_EQ(DataType::DOUBLE, array_->type_id());
+  ASSERT_EQ(DataType::FLOAT64, array_->type_id());
 
   ASSERT_EQ(values_.size(), array_->length());
 }
diff --git a/src/pandas/array.h b/src/pandas/array.h
index ada03d7bf..a22076f55 100644
--- a/src/pandas/array.h
+++ b/src/pandas/array.h
@@ -92,4 +92,6 @@ class ArrayView {
   int64_t length_;
 };
 
+using ArrayPtr = std::shared_ptr<Array>;
+
 }  // namespace pandas
diff --git a/src/pandas/dispatch.cc b/src/pandas/dispatch.cc
index 15c65b26e..5cced21d2 100644
--- a/src/pandas/dispatch.cc
+++ b/src/pandas/dispatch.cc
@@ -22,8 +22,8 @@ Status primitive_type_from_enum(DataType::TypeId tp_enum, DataType** out) {
     MAKE_TYPE_CASE(DataType::UINT16, UInt16);
     MAKE_TYPE_CASE(DataType::UINT32, UInt32);
     MAKE_TYPE_CASE(DataType::UINT64, UInt64);
-    MAKE_TYPE_CASE(DataType::FLOAT, Float);
-    MAKE_TYPE_CASE(DataType::DOUBLE, Double);
+    MAKE_TYPE_CASE(DataType::FLOAT32, Float);
+    MAKE_TYPE_CASE(DataType::FLOAT64, Double);
     MAKE_TYPE_CASE(DataType::BOOL, Boolean);
     MAKE_TYPE_CASE(DataType::PYOBJECT, PyObject);
     default:
diff --git a/src/pandas/numpy_interop.cc b/src/pandas/numpy_interop.cc
index 15b43c17b..2e46c730c 100644
--- a/src/pandas/numpy_interop.cc
+++ b/src/pandas/numpy_interop.cc
@@ -50,8 +50,8 @@ Status numpy_type_num_to_pandas(int type_num, DataType::TypeId* pandas_type) {
     TYPE_MAP_CASE(UINT16, UINT16);
     TYPE_MAP_CASE(UINT32, UINT32);
     TYPE_MAP_CASE(UINT64, UINT64);
-    TYPE_MAP_CASE(FLOAT32, FLOAT);
-    TYPE_MAP_CASE(FLOAT64, DOUBLE);
+    TYPE_MAP_CASE(FLOAT32, FLOAT32);
+    TYPE_MAP_CASE(FLOAT64, FLOAT64);
     TYPE_MAP_CASE(BOOL, BOOL);
     TYPE_MAP_CASE(OBJECT, PYOBJECT);
     default:
diff --git a/src/pandas/type.cc b/src/pandas/type.cc
index 31241aefa..458c10689 100644
--- a/src/pandas/type.cc
+++ b/src/pandas/type.cc
@@ -28,4 +28,17 @@ std::string TimestampType::ToString() const {
   return ss.str();
 }
 
+// Constexpr numeric type names
+constexpr const char* UInt8Type::NAME;
+constexpr const char* Int8Type::NAME;
+constexpr const char* UInt16Type::NAME;
+constexpr const char* Int16Type::NAME;
+constexpr const char* UInt32Type::NAME;
+constexpr const char* Int32Type::NAME;
+constexpr const char* UInt64Type::NAME;
+constexpr const char* Int64Type::NAME;
+constexpr const char* FloatType::NAME;
+constexpr const char* DoubleType::NAME;
+constexpr const char* BooleanType::NAME;
+
 }  // namespace pandas
diff --git a/src/pandas/type.h b/src/pandas/type.h
index bef14d9c1..a185f58f2 100644
--- a/src/pandas/type.h
+++ b/src/pandas/type.h
@@ -32,10 +32,10 @@ class DataType {
     BOOL = 9,
 
     // 4-byte floating point value
-    FLOAT = 10,
+    FLOAT32 = 10,
 
     // 8-byte floating point value
-    DOUBLE = 11,
+    FLOAT64 = 11,
 
     // PyObject*
     PYOBJECT = 12,
@@ -94,72 +94,96 @@ class PANDAS_EXPORT PyObjectType : public DataType {
   std::string ToString() const override;
 };
 
-template <typename Derived>
-class PANDAS_EXPORT PrimitiveType : public DataType {
+template <typename DERIVED, typename C_TYPE, DataType::TypeId TYPE_ID,
+    std::size_t SIZE = sizeof(C_TYPE)>
+class PANDAS_EXPORT NumericType : public DataType {
  public:
-  PrimitiveType() : DataType(Derived::type_enum) {}
+  using c_type = C_TYPE;
+  static constexpr DataType::TypeId type_id = TYPE_ID;
+  static constexpr size_t size = SIZE;
 
-  std::string ToString() const override {
-    return std::string(static_cast<const Derived*>(this)->name());
-  }
+  NumericType() : DataType(type_id) {}
+
+  std::string ToString() const override { return std::string(DERIVED::NAME); }
+
+  static std::shared_ptr<DERIVED> SINGLETON;
 };
 
-#define PRIMITIVE_DECL(TYPENAME, C_TYPE, ENUM, SIZE, NAME)      \
- public:                                                        \
-  typedef C_TYPE c_type;                                        \
-  static constexpr DataType::TypeId type_enum = DataType::ENUM; \
-  static constexpr size_t size = SIZE;                          \
-                                                                \
-  explicit TYPENAME() : PrimitiveType<TYPENAME>() {}            \
-                                                                \
-  static const char* name() { return NAME; }
+template <typename DERIVED, typename C_TYPE, DataType::TypeId TYPE_ID, std::size_t SIZE>
+std::shared_ptr<DERIVED> NumericType<DERIVED, C_TYPE, TYPE_ID, SIZE>::SINGLETON(
+    std::move(std::make_shared<DERIVED>()));
+
+class PANDAS_EXPORT NullType : public DataType {
+ public:
+  NullType() : DataType(DataType::TypeId::NA) {}
 
-class PANDAS_EXPORT NullType : public PrimitiveType<NullType> {
-  PRIMITIVE_DECL(NullType, void, NA, 0, "null");
+  std::string ToString() const override { return std::string("null"); }
 };
 
-class PANDAS_EXPORT UInt8Type : public PrimitiveType<UInt8Type> {
-  PRIMITIVE_DECL(UInt8Type, uint8_t, UINT8, 1, "uint8");
+class PANDAS_EXPORT UInt8Type
+    : public NumericType<UInt8Type, std::uint8_t, DataType::TypeId::UINT8> {
+ public:
+  constexpr static const char* NAME = "uint8";
 };
 
-class PANDAS_EXPORT Int8Type : public PrimitiveType<Int8Type> {
-  PRIMITIVE_DECL(Int8Type, int8_t, INT8, 1, "int8");
+class PANDAS_EXPORT Int8Type
+    : public NumericType<Int8Type, std::int8_t, DataType::TypeId::INT8> {
+ public:
+  constexpr static const char* NAME = "int8";
 };
 
-class PANDAS_EXPORT UInt16Type : public PrimitiveType<UInt16Type> {
-  PRIMITIVE_DECL(UInt16Type, uint16_t, UINT16, 2, "uint16");
+class PANDAS_EXPORT UInt16Type
+    : public NumericType<UInt16Type, std::uint16_t, DataType::TypeId::UINT16> {
+ public:
+  constexpr static const char* NAME = "uint16";
 };
 
-class PANDAS_EXPORT Int16Type : public PrimitiveType<Int16Type> {
-  PRIMITIVE_DECL(Int16Type, int16_t, INT16, 2, "int16");
+class PANDAS_EXPORT Int16Type
+    : public NumericType<Int16Type, std::int16_t, DataType::TypeId::INT16> {
+ public:
+  constexpr static const char* NAME = "int16";
 };
 
-class PANDAS_EXPORT UInt32Type : public PrimitiveType<UInt32Type> {
-  PRIMITIVE_DECL(UInt32Type, uint32_t, UINT32, 4, "uint32");
+class PANDAS_EXPORT UInt32Type
+    : public NumericType<UInt32Type, std::uint32_t, DataType::TypeId::UINT32> {
+ public:
+  constexpr static const char* NAME = "uint32";
 };
 
-class PANDAS_EXPORT Int32Type : public PrimitiveType<Int32Type> {
-  PRIMITIVE_DECL(Int32Type, int32_t, INT32, 4, "int32");
+class PANDAS_EXPORT Int32Type
+    : public NumericType<Int32Type, std::int32_t, DataType::TypeId::INT32> {
+ public:
+  constexpr static const char* NAME = "int32";
 };
 
-class PANDAS_EXPORT UInt64Type : public PrimitiveType<UInt64Type> {
-  PRIMITIVE_DECL(UInt64Type, uint64_t, UINT64, 8, "uint64");
+class PANDAS_EXPORT UInt64Type
+    : public NumericType<UInt64Type, std::uint64_t, DataType::TypeId::UINT64> {
+ public:
+  constexpr static const char* NAME = "uint64";
 };
 
-class PANDAS_EXPORT Int64Type : public PrimitiveType<Int64Type> {
-  PRIMITIVE_DECL(Int64Type, int64_t, INT64, 8, "int64");
+class PANDAS_EXPORT Int64Type
+    : public NumericType<Int64Type, std::int64_t, DataType::TypeId::INT64> {
+ public:
+  constexpr static const char* NAME = "int64";
 };
 
-class PANDAS_EXPORT FloatType : public PrimitiveType<FloatType> {
-  PRIMITIVE_DECL(FloatType, float, FLOAT, 4, "float");
+class PANDAS_EXPORT FloatType
+    : public NumericType<FloatType, float, DataType::TypeId::FLOAT32> {
+ public:
+  constexpr static const char* NAME = "float32";
 };
 
-class PANDAS_EXPORT DoubleType : public PrimitiveType<DoubleType> {
-  PRIMITIVE_DECL(DoubleType, double, DOUBLE, 8, "double");
+class PANDAS_EXPORT DoubleType
+    : public NumericType<DoubleType, double, DataType::TypeId::FLOAT64> {
+ public:
+  constexpr static const char* NAME = "float64";
 };
 
-class PANDAS_EXPORT BooleanType : public PrimitiveType<BooleanType> {
-  PRIMITIVE_DECL(BooleanType, uint8_t, BOOL, 1, "bool");
+class PANDAS_EXPORT BooleanType
+    : public NumericType<BooleanType, std::uint8_t, DataType::TypeId::BOOL> {
+ public:
+  constexpr static const char* NAME = "bool";
 };
 
 }  // namespace pandas
diff --git a/src/pandas/types/numeric.cc b/src/pandas/types/numeric.cc
index 38a1770c1..467a162de 100644
--- a/src/pandas/types/numeric.cc
+++ b/src/pandas/types/numeric.cc
@@ -3,6 +3,7 @@
 
 #include "pandas/types/numeric.h"
 
+#include <cstddef>
 #include <cstdint>
 #include <cstring>
 #include <memory>
@@ -15,148 +16,122 @@
 
 namespace pandas {
 
-template <typename T>
-static inline std::shared_ptr<DataType> get_type_singleton() {
-  return nullptr;
-}
-
-#define MAKE_TYPE_SINGLETON(NAME)                                     \
-  static const auto k##NAME = std::make_shared<NAME##Type>();         \
-  template <>                                                         \
-  inline std::shared_ptr<DataType> get_type_singleton<NAME##Type>() { \
-    return k##NAME;                                                   \
-  }
+// ----------------------------------------------------------------------
+// Generic numeric class
 
-MAKE_TYPE_SINGLETON(Int8);
-MAKE_TYPE_SINGLETON(UInt8);
-MAKE_TYPE_SINGLETON(Int16);
-MAKE_TYPE_SINGLETON(UInt16);
-MAKE_TYPE_SINGLETON(Int32);
-MAKE_TYPE_SINGLETON(UInt32);
-MAKE_TYPE_SINGLETON(Int64);
-MAKE_TYPE_SINGLETON(UInt64);
-MAKE_TYPE_SINGLETON(Float);
-MAKE_TYPE_SINGLETON(Double);
+template <typename TYPE>
+NumericArray<TYPE>::NumericArray(
+    const DataTypePtr& type, int64_t length, const std::shared_ptr<Buffer>& data)
+    : Array(type, length), data_(data) {}
 
-// ----------------------------------------------------------------------
-// Floating point base class
+template <typename TYPE>
+auto NumericArray<TYPE>::data() const -> const T* {
+  return reinterpret_cast<const T*>(data_->data());
+}
 
-FloatingArray::FloatingArray(
-    const TypePtr type, int64_t length, const std::shared_ptr<Buffer>& data)
-    : NumericArray(type, length), data_(data) {}
+template <typename TYPE>
+auto NumericArray<TYPE>::mutable_data() const -> T* {
+  auto mutable_buf = static_cast<MutableBuffer*>(data_.get());
+  return reinterpret_cast<T*>(mutable_buf->mutable_data());
+}
 
 // ----------------------------------------------------------------------
-// Specific implementations
+// Floating point class
 
 template <typename TYPE>
-FloatingArrayImpl<TYPE>::FloatingArrayImpl(
-    int64_t length, const std::shared_ptr<Buffer>& data)
-    : FloatingArray(get_type_singleton<TYPE>(), length, data) {}
+FloatingArray<TYPE>::FloatingArray(int64_t length, const std::shared_ptr<Buffer>& data)
+    : NumericArray<TYPE>(TYPE::SINGLETON, length, data) {}
 
 template <typename TYPE>
-int64_t FloatingArrayImpl<TYPE>::GetNullCount() {
+int64_t FloatingArray<TYPE>::GetNullCount() {
   // TODO(wesm)
   return 0;
 }
 
 template <typename TYPE>
-PyObject* FloatingArrayImpl<TYPE>::GetItem(int64_t i) {
+PyObject* FloatingArray<TYPE>::GetItem(int64_t i) {
   return NULL;
 }
 
 template <typename TYPE>
-Status FloatingArrayImpl<TYPE>::Copy(
+Status FloatingArray<TYPE>::Copy(
     int64_t offset, int64_t length, std::shared_ptr<Array>* out) const {
   size_t itemsize = sizeof(typename TYPE::c_type);
 
   std::shared_ptr<Buffer> copied_data;
 
-  RETURN_NOT_OK(data_->Copy(offset * itemsize, length * itemsize, &copied_data));
+  RETURN_NOT_OK(this->data_->Copy(offset * itemsize, length * itemsize, &copied_data));
 
-  *out = std::make_shared<FloatingArrayImpl<TYPE>>(length, copied_data);
+  *out = std::make_shared<FloatingArray<TYPE>>(length, copied_data);
   return Status::OK();
 }
 
 template <typename TYPE>
-Status FloatingArrayImpl<TYPE>::SetItem(int64_t i, PyObject* val) {
+Status FloatingArray<TYPE>::SetItem(int64_t i, PyObject* val) {
   return Status::OK();
 }
 
 template <typename TYPE>
-bool FloatingArrayImpl<TYPE>::owns_data() const {
-  return data_.use_count() == 1;
+bool FloatingArray<TYPE>::owns_data() const {
+  return this->data_.use_count() == 1;
 }
 
 // Instantiate templates
-template class FloatingArrayImpl<FloatType>;
-template class FloatingArrayImpl<DoubleType>;
+template class FloatingArray<FloatType>;
+template class FloatingArray<DoubleType>;
 
 // ----------------------------------------------------------------------
-// Any integer
-
-IntegerArray::IntegerArray(
-    const TypePtr type, int64_t length, const std::shared_ptr<Buffer>& data)
-    : NumericArray(type, length), data_(data), valid_bits_(nullptr) {}
-
-IntegerArray::IntegerArray(const TypePtr type, int64_t length,
-    const std::shared_ptr<Buffer>& data, const std::shared_ptr<Buffer>& valid_bits)
-    : NumericArray(type, length), data_(data), valid_bits_(valid_bits) {}
-
-int64_t IntegerArray::GetNullCount() {
-  // TODO(wesm)
-  // return nulls_.set_count();
-  return 0;
-}
+// Types integers
 
 // ----------------------------------------------------------------------
 // Typed integers
 
 template <typename TYPE>
-IntegerArrayImpl<TYPE>::IntegerArrayImpl(
-    int64_t length, const std::shared_ptr<Buffer>& data)
-    : IntegerArray(get_type_singleton<TYPE>(), length, data) {}
+IntegerArray<TYPE>::IntegerArray(int64_t length, const std::shared_ptr<Buffer>& data)
+    : IntegerArray(length, data, nullptr) {}
 
 template <typename TYPE>
-const typename TYPE::c_type* IntegerArrayImpl<TYPE>::data() const {
-  return reinterpret_cast<const T*>(data_->data());
-}
+IntegerArray<TYPE>::IntegerArray(int64_t length, const std::shared_ptr<Buffer>& data,
+    const std::shared_ptr<Buffer>& valid_bits)
+    : NumericArray<TYPE>(TYPE::SINGLETON, length, data), valid_bits_(valid_bits) {}
 
 template <typename TYPE>
-typename TYPE::c_type* IntegerArrayImpl<TYPE>::mutable_data() const {
-  auto mutable_buf = static_cast<MutableBuffer*>(data_.get());
-  return reinterpret_cast<T*>(mutable_buf->mutable_data());
+int64_t IntegerArray<TYPE>::GetNullCount() {
+  // TODO(wesm)
+  // return nulls_.set_count();
+  return 0;
 }
 
 template <typename TYPE>
-PyObject* IntegerArrayImpl<TYPE>::GetItem(int64_t i) {
+PyObject* IntegerArray<TYPE>::GetItem(int64_t i) {
   if (valid_bits_ && BitUtil::BitNotSet(valid_bits_->data(), i)) {
     Py_INCREF(py::NA);
     return py::NA;
   }
-  return PyLong_FromLongLong(data()[i]);
+  return PyLong_FromLongLong(this->data()[i]);
 }
 
 template <typename TYPE>
-bool IntegerArrayImpl<TYPE>::owns_data() const {
-  bool owns_data = data_.use_count() == 1;
+bool IntegerArray<TYPE>::owns_data() const {
+  bool owns_data = this->data_.use_count() == 1;
   if (valid_bits_) { owns_data &= valid_bits_.use_count() == 1; }
   return owns_data;
 }
 
 template <typename TYPE>
-Status IntegerArrayImpl<TYPE>::Copy(
+Status IntegerArray<TYPE>::Copy(
     int64_t offset, int64_t length, std::shared_ptr<Array>* out) const {
   size_t itemsize = sizeof(typename TYPE::c_type);
 
   std::shared_ptr<Buffer> copied_data;
   std::shared_ptr<Buffer> copied_valid_bits;
 
-  RETURN_NOT_OK(data_->Copy(offset * itemsize, length * itemsize, &copied_data));
+  RETURN_NOT_OK(this->data_->Copy(offset * itemsize, length * itemsize, &copied_data));
 
   if (valid_bits_) {
-    RETURN_NOT_OK(CopyBitmap(data_, offset, length, &copied_valid_bits));
+    RETURN_NOT_OK(CopyBitmap(this->data_, offset, length, &copied_valid_bits));
   }
-  *out = std::make_shared<FloatingArrayImpl<TYPE>>(length, copied_data);
+  *out = std::make_shared<FloatingArray<TYPE>>(length, copied_data);
   return Status::OK();
 }
 
@@ -170,8 +145,8 @@ static Status PyObjectToInt64(PyObject* obj, int64_t* out) {
 }
 
 template <typename TYPE>
-Status IntegerArrayImpl<TYPE>::SetItem(int64_t i, PyObject* val) {
-  if (!data_->is_mutable()) {
+Status IntegerArray<TYPE>::SetItem(int64_t i, PyObject* val) {
+  if (!this->data_->is_mutable()) {
     // TODO(wesm): copy-on-write?
     return Status::Invalid("Underlying buffer is immutable");
   }
@@ -184,7 +159,7 @@ Status IntegerArrayImpl<TYPE>::SetItem(int64_t i, PyObject* val) {
   if (py::is_na(val)) {
     if (!valid_bits_) {
       // TODO: raise Python exception on error status
-      RETURN_NOT_OK(AllocateValidityBitmap(length_, &valid_bits_));
+      RETURN_NOT_OK(AllocateValidityBitmap(this->length_, &valid_bits_));
     }
     auto mutable_bits = static_cast<MutableBuffer*>(valid_bits_.get())->mutable_data();
     BitUtil::ClearBit(mutable_bits, i);
@@ -195,20 +170,20 @@ Status IntegerArrayImpl<TYPE>::SetItem(int64_t i, PyObject* val) {
     RETURN_NOT_OK(PyObjectToInt64(val, &cval));
 
     // Overflow issues
-    mutable_data()[i] = cval;
+    this->mutable_data()[i] = cval;
   }
   RETURN_IF_PYERROR();
   return Status::OK();
 }
 
 // Instantiate templates
-template class IntegerArrayImpl<UInt8Type>;
-template class IntegerArrayImpl<Int8Type>;
-template class IntegerArrayImpl<UInt16Type>;
-template class IntegerArrayImpl<Int16Type>;
-template class IntegerArrayImpl<UInt32Type>;
-template class IntegerArrayImpl<Int32Type>;
-template class IntegerArrayImpl<UInt64Type>;
-template class IntegerArrayImpl<Int64Type>;
+template class IntegerArray<UInt8Type>;
+template class IntegerArray<Int8Type>;
+template class IntegerArray<UInt16Type>;
+template class IntegerArray<Int16Type>;
+template class IntegerArray<UInt32Type>;
+template class IntegerArray<Int32Type>;
+template class IntegerArray<UInt64Type>;
+template class IntegerArray<Int64Type>;
 
 }  // namespace pandas
diff --git a/src/pandas/types/numeric.h b/src/pandas/types/numeric.h
index 1dcd5a16d..b5901102c 100644
--- a/src/pandas/types/numeric.h
+++ b/src/pandas/types/numeric.h
@@ -11,30 +11,31 @@
 
 namespace pandas {
 
+template <typename TYPE>
 class PANDAS_EXPORT NumericArray : public Array {
  public:
+  using T = typename TYPE::c_type;
+  using DataTypePtr = std::shared_ptr<TYPE>;
   using Array::Array;
-};
 
-class PANDAS_EXPORT IntegerArray : public NumericArray {
- public:
-  int64_t GetNullCount() override;
+  NumericArray(
+      const DataTypePtr& type, int64_t length, const std::shared_ptr<Buffer>& data);
 
- protected:
-  IntegerArray(const TypePtr type, int64_t length, const std::shared_ptr<Buffer>& data);
-  IntegerArray(const TypePtr type, int64_t length, const std::shared_ptr<Buffer>& data,
-      const std::shared_ptr<Buffer>& valid_bits);
+  auto data() const -> const T*;
+  auto mutable_data() const -> T*;
 
+ protected:
   std::shared_ptr<Buffer> data_;
-  std::shared_ptr<Buffer> valid_bits_;
 };
 
 template <typename TYPE>
-class PANDAS_EXPORT IntegerArrayImpl : public IntegerArray {
+class PANDAS_EXPORT IntegerArray : public NumericArray<TYPE> {
  public:
-  using T = typename TYPE::c_type;
+  IntegerArray(int64_t length, const std::shared_ptr<Buffer>& data);
+  IntegerArray(int64_t length, const std::shared_ptr<Buffer>& data,
+      const std::shared_ptr<Buffer>& valid_bits);
 
-  IntegerArrayImpl(int64_t length, const std::shared_ptr<Buffer>& data);
+  int64_t GetNullCount() override;
 
   Status Copy(int64_t offset, int64_t length, std::shared_ptr<Array>* out) const override;
 
@@ -43,22 +44,14 @@ class PANDAS_EXPORT IntegerArrayImpl : public IntegerArray {
 
   bool owns_data() const override;
 
-  const T* data() const;
-  T* mutable_data() const;
-};
-
-class PANDAS_EXPORT FloatingArray : public NumericArray {
- protected:
-  FloatingArray(const TypePtr type, int64_t length, const std::shared_ptr<Buffer>& data);
-  std::shared_ptr<Buffer> data_;
+ private:
+  std::shared_ptr<Buffer> valid_bits_;
 };
 
 template <typename TYPE>
-class PANDAS_EXPORT FloatingArrayImpl : public FloatingArray {
+class PANDAS_EXPORT FloatingArray : public NumericArray<TYPE> {
  public:
-  using T = typename TYPE::c_type;
-
-  FloatingArrayImpl(int64_t length, const std::shared_ptr<Buffer>& data);
+  FloatingArray(int64_t length, const std::shared_ptr<Buffer>& data);
 
   Status Copy(int64_t offset, int64_t length, std::shared_ptr<Array>* out) const override;
   PyObject* GetItem(int64_t i) override;
@@ -67,36 +60,33 @@ class PANDAS_EXPORT FloatingArrayImpl : public FloatingArray {
   int64_t GetNullCount() override;
 
   bool owns_data() const override;
-
-  const T* data() const;
-  T* mutable_data() const;
 };
 
-using FloatArray = FloatingArrayImpl<FloatType>;
-using DoubleArray = FloatingArrayImpl<DoubleType>;
+using FloatArray = FloatingArray<FloatType>;
+using DoubleArray = FloatingArray<DoubleType>;
 
-using Int8Array = IntegerArrayImpl<Int8Type>;
-using UInt8Array = IntegerArrayImpl<UInt8Type>;
+using Int8Array = IntegerArray<Int8Type>;
+using UInt8Array = IntegerArray<UInt8Type>;
 
-using Int16Array = IntegerArrayImpl<Int16Type>;
-using UInt16Array = IntegerArrayImpl<UInt16Type>;
+using Int16Array = IntegerArray<Int16Type>;
+using UInt16Array = IntegerArray<UInt16Type>;
 
-using Int32Array = IntegerArrayImpl<Int32Type>;
-using UInt32Array = IntegerArrayImpl<UInt32Type>;
+using Int32Array = IntegerArray<Int32Type>;
+using UInt32Array = IntegerArray<UInt32Type>;
 
-using Int64Array = IntegerArrayImpl<Int64Type>;
-using UInt64Array = IntegerArrayImpl<UInt64Type>;
+using Int64Array = IntegerArray<Int64Type>;
+using UInt64Array = IntegerArray<UInt64Type>;
 
 // Only instantiate these templates once
-extern template class PANDAS_EXPORT IntegerArrayImpl<Int8Type>;
-extern template class PANDAS_EXPORT IntegerArrayImpl<UInt8Type>;
-extern template class PANDAS_EXPORT IntegerArrayImpl<Int16Type>;
-extern template class PANDAS_EXPORT IntegerArrayImpl<UInt16Type>;
-extern template class PANDAS_EXPORT IntegerArrayImpl<Int32Type>;
-extern template class PANDAS_EXPORT IntegerArrayImpl<UInt32Type>;
-extern template class PANDAS_EXPORT IntegerArrayImpl<Int64Type>;
-extern template class PANDAS_EXPORT IntegerArrayImpl<UInt64Type>;
-extern template class PANDAS_EXPORT FloatingArrayImpl<FloatType>;
-extern template class PANDAS_EXPORT FloatingArrayImpl<DoubleType>;
+extern template class PANDAS_EXPORT IntegerArray<Int8Type>;
+extern template class PANDAS_EXPORT IntegerArray<UInt8Type>;
+extern template class PANDAS_EXPORT IntegerArray<Int16Type>;
+extern template class PANDAS_EXPORT IntegerArray<UInt16Type>;
+extern template class PANDAS_EXPORT IntegerArray<Int32Type>;
+extern template class PANDAS_EXPORT IntegerArray<UInt32Type>;
+extern template class PANDAS_EXPORT IntegerArray<Int64Type>;
+extern template class PANDAS_EXPORT IntegerArray<UInt64Type>;
+extern template class PANDAS_EXPORT FloatingArray<FloatType>;
+extern template class PANDAS_EXPORT FloatingArray<DoubleType>;
 
 }  // namespace pandas