diff --git a/include/libint2/boys.h b/include/libint2/boys.h
index 8c83ef75a..cc539f4df 100644
--- a/include/libint2/boys.h
+++ b/include/libint2/boys.h
@@ -1496,7 +1496,7 @@ namespace libint2 {
           }
         }
 
-        typedef typename std::vector<std::pair<AnyReal, AnyReal> >::const_iterator citer;
+        using citer = typename std::vector<std::pair<AnyReal, AnyReal> >::const_iterator;
         const citer gend = geminal.end();
         for(citer i=geminal.begin(); i!= gend; ++i) {
 
@@ -1582,7 +1582,7 @@ namespace libint2 {
   template <typename GmEvalFunction>
   struct GenericGmEval : private GmEvalFunction {
 
-    typedef typename GmEvalFunction::value_type Real;
+    using Real = typename GmEvalFunction::value_type;
 
       GenericGmEval(int mmax, Real precision) : GmEvalFunction(mmax, precision),
           mmax_(mmax), precision_(precision) {}
@@ -1640,7 +1640,7 @@ namespace libint2 {
     /// core integral evaluator delta function kernels
   template <typename Real>
   struct delta_gm_eval {
-    typedef Real value_type;
+    using value_type = Real;
 
     delta_gm_eval(unsigned int, Real) {}
     void operator()(Real* Gm, Real rho, Real T, int mmax) const {
@@ -1661,8 +1661,8 @@ namespace libint2 {
   template <typename Real>
   struct r12_xx_K_gm_eval<Real, 1>
       : private detail::CoreEvalScratch<r12_xx_K_gm_eval<Real, 1>> {
-    typedef detail::CoreEvalScratch<r12_xx_K_gm_eval<Real, 1>> base_type;
-    typedef Real value_type;
+    using base_type = detail::CoreEvalScratch<r12_xx_K_gm_eval<Real, 1>>;
+    using value_type = Real;
 
 #ifndef LIBINT_USER_DEFINED_REAL
     using FmEvalType = libint2::FmEval_Chebyshev7<double>;
@@ -1694,7 +1694,7 @@ namespace libint2 {
   /// core integral evaluator for \f$ \mathrm{erf}(\omega r) / r \f$ kernel
   template <typename Real>
   struct erf_coulomb_gm_eval {
-    typedef Real value_type;
+    using value_type = Real;
 
 #ifndef LIBINT_USER_DEFINED_REAL
     using FmEvalType = libint2::FmEval_Chebyshev7<double>;
@@ -1735,8 +1735,8 @@ namespace libint2 {
   template <typename Real>
   struct erfc_coulomb_gm_eval : private
   detail::CoreEvalScratch<erfc_coulomb_gm_eval<Real>> {
-    typedef detail::CoreEvalScratch<erfc_coulomb_gm_eval<Real>> base_type;
-    typedef Real value_type;
+    using base_type = detail::CoreEvalScratch<erfc_coulomb_gm_eval<Real>>;
+    using value_type = Real;
 
     #ifndef LIBINT_USER_DEFINED_REAL
     using FmEvalType = libint2::FmEval_Chebyshev7<double>;
diff --git a/include/libint2/diis.h b/include/libint2/diis.h
index 5e0640971..0c1eb861b 100644
--- a/include/libint2/diis.h
+++ b/include/libint2/diis.h
@@ -57,8 +57,8 @@ namespace libint2 {
 
     template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
     struct traits<Eigen::Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >> {
-        typedef Eigen::Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > D;
-        typedef typename D::Scalar element_type;
+        using D = Eigen::Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >;
+        using element_type = typename D::Scalar;
     };
 
     template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
@@ -131,7 +131,7 @@ namespace libint2 {
   template <typename D>
   class DIIS {
     public:
-      typedef typename diis::traits<D>::element_type value_type;
+      using value_type = typename diis::traits<D>::element_type;
 
       /// Constructor
 
@@ -330,8 +330,8 @@ namespace libint2 {
       value_type damping_factor;
       value_type mixing_fraction;
 
-      typedef Eigen::Matrix<value_type, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> EigenMatrixX;
-      typedef Eigen::Matrix<value_type, Eigen::Dynamic, 1> EigenVectorX;
+      using EigenMatrixX = Eigen::Matrix<value_type, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>;
+      using EigenVectorX = Eigen::Matrix<value_type, Eigen::Dynamic, 1>;
 
       EigenMatrixX B_; //!< B(i,j) = <ei|ej>
 
diff --git a/include/libint2/engine.h b/include/libint2/engine.h
index 179ed093b..110f1b017 100644
--- a/include/libint2/engine.h
+++ b/include/libint2/engine.h
@@ -74,7 +74,7 @@ namespace libint2 {
 /// contracted Gaussian geminal = \f$ \sum_i c_i \exp(- \alpha r_{12}^2) \f$,
 /// represented as a vector of
 /// {\f$ \alpha_i \f$, \f$ c_i \f$ } pairs
-typedef std::vector<std::pair<double, double>> ContractedGaussianGeminal;
+using ContractedGaussianGeminal = std::vector<std::pair<double, double>>;
 
 constexpr size_t num_geometrical_derivatives(size_t ncenter,
                                              size_t deriv_order) {
@@ -181,8 +181,8 @@ inline constexpr int rank(Operator oper) {
 
 namespace detail {
 struct default_operator_traits {
-  typedef struct {
-  } oper_params_type;
+  struct oper_params_type {
+  };
   static oper_params_type default_params() { return oper_params_type{}; }
   static constexpr auto nopers = 1u;
   struct _core_eval_type {
@@ -207,13 +207,12 @@ template <>
 struct operator_traits<Operator::nuclear>
     : public detail::default_operator_traits {
   /// point charges and their positions
-  typedef std::vector<std::pair<scalar_type, std::array<scalar_type, 3>>>
-      oper_params_type;
+  using oper_params_type = std::vector<std::pair<scalar_type, std::array<scalar_type, 3>>>;
   static oper_params_type default_params() { return oper_params_type{}; }
 #ifndef LIBINT_USER_DEFINED_REAL
-  typedef const libint2::FmEval_Chebyshev7<scalar_type> core_eval_type;
+  using core_eval_type = const libint2::FmEval_Chebyshev7<scalar_type>;
 #else
-  typedef const libint2::FmEval_Reference<scalar_type> core_eval_type;
+  using core_eval_type = const libint2::FmEval_Reference<scalar_type>;
 #endif
 };
 
@@ -222,14 +221,12 @@ struct operator_traits<Operator::erf_nuclear>
     : public detail::default_operator_traits {
   /// the attenuation parameter (0 = zero potential, +infinity = no attenuation)
   /// + point charges and positions
-  typedef std::tuple<
-      scalar_type, typename operator_traits<Operator::nuclear>::oper_params_type>
-      oper_params_type;
+  using oper_params_type = std::tuple<
+      scalar_type, typename operator_traits<Operator::nuclear>::oper_params_type>;
   static oper_params_type default_params() {
     return std::make_tuple(0,operator_traits<Operator::nuclear>::default_params());
   }
-  typedef const libint2::GenericGmEval<libint2::os_core_ints::erf_coulomb_gm_eval<scalar_type>>
-      core_eval_type;
+  using core_eval_type = const libint2::GenericGmEval<libint2::os_core_ints::erf_coulomb_gm_eval<scalar_type>>;
 };
 
 template <>
@@ -237,12 +234,11 @@ struct operator_traits<Operator::erfc_nuclear>
     : public detail::default_operator_traits {
   /// the attenuation parameter (0 = no attenuation, +infinity = zero potential)
   /// + point charges and positions
-  typedef typename operator_traits<Operator::erf_nuclear>::oper_params_type oper_params_type;
+  using oper_params_type = typename operator_traits<Operator::erf_nuclear>::oper_params_type;
   static oper_params_type default_params() {
     return std::make_tuple(0,operator_traits<Operator::nuclear>::default_params());
   }
-  typedef const libint2::GenericGmEval<libint2::os_core_ints::erfc_coulomb_gm_eval<scalar_type>>
-      core_eval_type;
+  using core_eval_type = const libint2::GenericGmEval<libint2::os_core_ints::erfc_coulomb_gm_eval<scalar_type>>;
 };
 
 template <>
@@ -250,7 +246,7 @@ struct operator_traits<Operator::emultipole1>
     : public detail::default_operator_traits {
   /// Cartesian coordinates of the origin with respect to which the dipole
   /// moment is defined
-  typedef std::array<double, 3> oper_params_type;
+  using oper_params_type = std::array<double, 3>;
   static oper_params_type default_params() {
     return oper_params_type{{0,0,0}};
   }
@@ -280,16 +276,16 @@ template <>
 struct operator_traits<Operator::coulomb>
     : public detail::default_operator_traits {
 #ifndef LIBINT_USER_DEFINED_REAL
-  typedef const libint2::FmEval_Chebyshev7<scalar_type> core_eval_type;
+  using core_eval_type = const libint2::FmEval_Chebyshev7<scalar_type>;
 #else
-  typedef const libint2::FmEval_Reference<scalar_type> core_eval_type;
+  using core_eval_type = const libint2::FmEval_Reference<scalar_type>;
 #endif
 };
 namespace detail {
 template <int K>
 struct cgtg_operator_traits : public detail::default_operator_traits {
-  typedef libint2::GaussianGmEval<scalar_type, K> core_eval_type;
-  typedef ContractedGaussianGeminal oper_params_type;
+  using core_eval_type = libint2::GaussianGmEval<scalar_type, K>;
+  using oper_params_type = ContractedGaussianGeminal;
 };
 }  // namespace detail
 template <>
@@ -305,62 +301,56 @@ struct operator_traits<Operator::delcgtg2>
 template <>
 struct operator_traits<Operator::delta>
     : public detail::default_operator_traits {
-  typedef const libint2::GenericGmEval<libint2::os_core_ints::delta_gm_eval<scalar_type>>
-      core_eval_type;
+  using core_eval_type = const libint2::GenericGmEval<libint2::os_core_ints::delta_gm_eval<scalar_type>>;
 };
 
 template <>
 struct operator_traits<Operator::r12>
     : public detail::default_operator_traits {
-  typedef const libint2::GenericGmEval<libint2::os_core_ints::r12_xx_K_gm_eval<scalar_type, 1>>
-      core_eval_type;
+  using core_eval_type = const libint2::GenericGmEval<libint2::os_core_ints::r12_xx_K_gm_eval<scalar_type, 1>>;
 };
 
 template <>
 struct operator_traits<Operator::erf_coulomb>
     : public detail::default_operator_traits {
   /// the attenuation parameter (0 = zero potential, +infinity = no attenuation)
-  typedef scalar_type oper_params_type;
+  using oper_params_type = scalar_type;
   static oper_params_type default_params() {
     return oper_params_type{0};
   }
-  typedef const libint2::GenericGmEval<libint2::os_core_ints::erf_coulomb_gm_eval<scalar_type>>
-      core_eval_type;
+  using core_eval_type = const libint2::GenericGmEval<libint2::os_core_ints::erf_coulomb_gm_eval<scalar_type>>;
 };
 template <>
 struct operator_traits<Operator::erfc_coulomb>
     : public detail::default_operator_traits {
   /// the attenuation parameter (0 = no attenuation, +infinity = zero potential)
-  typedef scalar_type oper_params_type;
+  using oper_params_type = scalar_type;
   static oper_params_type default_params() {
     return oper_params_type{0};
   }
-  typedef const libint2::GenericGmEval<libint2::os_core_ints::erfc_coulomb_gm_eval<scalar_type>>
-      core_eval_type;
+  using core_eval_type = const libint2::GenericGmEval<libint2::os_core_ints::erfc_coulomb_gm_eval<scalar_type>>;
 };
 
 template <>
 struct operator_traits<Operator::stg>
     : public detail::default_operator_traits {
   /// the attenuation parameter (0 = constant, infinity = delta-function)
-  typedef scalar_type oper_params_type;
+  using oper_params_type = scalar_type;
   static oper_params_type default_params() {
     return oper_params_type{0};
   }
-  typedef const libint2::TennoGmEval<scalar_type>
-      core_eval_type;
+  using core_eval_type = const libint2::TennoGmEval<scalar_type>;
 };
 
 template <>
 struct operator_traits<Operator::stg_x_coulomb>
     : public detail::default_operator_traits {
   /// the attenuation parameter (0 = coulomb, infinity = delta-function)
-  typedef scalar_type oper_params_type;
+  using oper_params_type = scalar_type;
   static oper_params_type default_params() {
     return oper_params_type{0};
   }
-  typedef const libint2::TennoGmEval<scalar_type>
-      core_eval_type;
+  using core_eval_type = const libint2::TennoGmEval<scalar_type>;
 };
 
 /// the runtime version of \c operator_traits<oper>::default_params()
@@ -411,8 +401,8 @@ constexpr size_t nderivorders_2body = LIBINT2_MAX_DERIV_ORDER + 1;
  */
 class Engine {
  private:
-  typedef struct {
-  } empty_pod;
+  struct empty_pod {
+  };
 
  public:
 
diff --git a/include/libint2/engine.impl.h b/include/libint2/engine.impl.h
index a1ee9c1c7..a8e1bc373 100644
--- a/include/libint2/engine.impl.h
+++ b/include/libint2/engine.impl.h
@@ -1796,9 +1796,8 @@ __libint2_engine_inline const Engine::target_ptr_vec& Engine::compute2(
       constexpr auto using_scalar_real = sizeof(value_type) == sizeof(scalar_type);
       static_assert(using_scalar_real,
                     "Libint2 C++11 API only supports scalar real types");
-      typedef Eigen::Matrix<scalar_type, Eigen::Dynamic, Eigen::Dynamic,
-                            Eigen::RowMajor>
-          Matrix;
+      using Matrix = Eigen::Matrix<scalar_type, Eigen::Dynamic, Eigen::Dynamic,
+                            Eigen::RowMajor>;
 
       // a 2-d view of the 4-d source tensor
       const auto nr1_cart = bra1.cartesian_size();
@@ -1894,11 +1893,10 @@ __libint2_engine_inline const Engine::target_ptr_vec& Engine::compute2(
 
           for (auto r1 = 0; r1 != nr1; ++r1) {
             for (auto r2 = 0; r2 != nr2; ++r2, src_row_ptr += ncol) {
-              typedef Eigen::Map<const Matrix> ConstMap;
-              typedef Eigen::Map<Matrix> Map;
-              typedef Eigen::Map<Matrix, Eigen::Unaligned,
-                                 Eigen::Stride<Eigen::Dynamic, Eigen::Dynamic>>
-                  StridedMap;
+              using ConstMap = Eigen::Map<const Matrix>;
+              using Map = Eigen::Map<Matrix>;
+              using StridedMap = Eigen::Map<Matrix, Eigen::Unaligned,
+                                 Eigen::Stride<Eigen::Dynamic, Eigen::Dynamic>>;
 
               // represent this source row as a matrix
               ConstMap src_blk_mat(src_row_ptr, nc1, nc2);
diff --git a/include/libint2/lcao/1body.h b/include/libint2/lcao/1body.h
index cf0ad5480..f07a6336c 100644
--- a/include/libint2/lcao/1body.h
+++ b/include/libint2/lcao/1body.h
@@ -50,20 +50,19 @@
 #include <omp.h>
 #endif
 
-typedef btas::RangeNd<CblasRowMajor, std::array<long, 2>> Range2;
-typedef btas::RangeNd<CblasRowMajor, std::array<long, 3>> Range3;
-typedef btas::RangeNd<CblasRowMajor, std::array<long, 4>> Range4;
-typedef btas::Tensor<double, Range2> Tensor2d;
-typedef btas::Tensor<double, Range3> Tensor3d;
-typedef btas::Tensor<double, Range3> Tensor4d;
-
-typedef Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>
-    Matrix;  // import dense, dynamically sized Matrix type from Eigen;
-             // this is a matrix with row-major storage
-             // (http://en.wikipedia.org/wiki/Row-major_order)
+using Range2 = btas::RangeNd<CblasRowMajor, std::array<long, 2>>;
+using Range3 = btas::RangeNd<CblasRowMajor, std::array<long, 3>>;
+using Range4 = btas::RangeNd<CblasRowMajor, std::array<long, 4>>;
+using Tensor2d = btas::Tensor<double, Range2>;
+using Tensor3d = btas::Tensor<double, Range3>;
+using Tensor4d = btas::Tensor<double, Range3>;
+
+// import dense, dynamically sized Matrix type from Eigen;
+// this is a matrix with row-major storage
+// (http://en.wikipedia.org/wiki/Row-major_order)
+using Matrix = Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>;
 // to meet the layout of the integrals returned by the Libint integral library
-typedef Eigen::DiagonalMatrix<double, Eigen::Dynamic, Eigen::Dynamic>
-    DiagonalMatrix;
+using DiagonalMatrix = Eigen::DiagonalMatrix<double, Eigen::Dynamic, Eigen::Dynamic>;
 
 using libint2::Shell;
 using libint2::libint2::Atom;
@@ -151,8 +150,8 @@ struct DFFockEngine {
   DFFockEngine(const BasisSet& _obs, const BasisSet& _dfbs)
       : obs(_obs), dfbs(_dfbs) {}
 
-  typedef btas::RangeNd<CblasRowMajor, std::array<long, 3>> Range3d;
-  typedef btas::Tensor<double, Range3d> Tensor3d;
+  using Range3d = btas::RangeNd<CblasRowMajor, std::array<long, 3>>;
+  using Tensor3d = btas::Tensor<double, Range3d>;
   Tensor3d xyK;
 
   // a DF-based builder, using coefficients of occupied MOs
@@ -853,8 +852,7 @@ std::array<Matrix, libint2::operator_traits<obtype>::nopers> compute_1body_ints(
   const auto n = obs.nbf();
   const auto nshells = obs.size();
   using libint2::nthreads;
-  typedef std::array<Matrix, libint2::operator_traits<obtype>::nopers>
-      result_type;
+  using result_type = std::array<Matrix, libint2::operator_traits<obtype>::nopers>;
   const unsigned int nopers = libint2::operator_traits<obtype>::nopers;
   result_type result;
   for (auto& r : result) r = Matrix::Zero(n, n);
@@ -928,7 +926,7 @@ std::vector<Matrix> compute_1body_ints_deriv(unsigned deriv_order,
   constexpr auto nopers = libint2::operator_traits<obtype>::nopers;
   const auto nresults =
       nopers * libint2::num_geometrical_derivatives(atoms.size(), deriv_order);
-  typedef std::vector<Matrix> result_type;
+  using result_type = std::vector<Matrix>;
   result_type result(nresults);
   for (auto& r : result) r = Matrix::Zero(n, n);
 
@@ -2019,10 +2017,10 @@ Matrix DFFockEngine::compute_2body_fock_dfC(const Matrix& Cocc) {
   std::vector<libint2::Timers<5>> timers(nthreads);
   for(auto& timer: timers) timer.set_now_overhead(25);
 
-  typedef btas::RangeNd<CblasRowMajor, std::array<long, 1>> Range1d;
-  typedef btas::RangeNd<CblasRowMajor, std::array<long, 2>> Range2d;
-  typedef btas::Tensor<double, Range1d> Tensor1d;
-  typedef btas::Tensor<double, Range2d> Tensor2d;
+  using Range1d = btas::RangeNd<CblasRowMajor, std::array<long, 1>>;
+  using Range2d = btas::RangeNd<CblasRowMajor, std::array<long, 2>>;
+  using Tensor1d = btas::Tensor<double, Range1d>;
+  using Tensor2d = btas::Tensor<double, Range2d>;
 
   // using first time? compute 3-center ints and transform to inv sqrt
   // representation
diff --git a/include/libint2/shell.h b/include/libint2/shell.h
index 0f7c6d51b..0ee614b79 100644
--- a/include/libint2/shell.h
+++ b/include/libint2/shell.h
@@ -79,7 +79,7 @@ namespace libint2 {
    *  normalization-free primitives before computing integrals (see \c Shell::renorm() ).
    */
   struct Shell {
-      typedef double real_t;
+      using real_t = double;
 
       /// contracted Gaussian = angular momentum + sph/cart flag + contraction coefficients
       struct Contraction {
@@ -199,7 +199,7 @@ namespace libint2 {
       }
 
       struct defaultable_boolean {
-          typedef enum {false_value=0,true_value=1,default_value=2} value_t;
+          enum value_t {false_value=0,true_value=1,default_value=2};
           defaultable_boolean() : value_(default_value) {}
           defaultable_boolean(bool v) : value_(static_cast<value_t>(v?1:0)) {}
           bool is_default() const { return value_ == default_value; }
@@ -392,7 +392,7 @@ namespace libint2 {
 
   /// ShellPair contains pre-computed shell-pair data, primitive pairs are screened to finite precision
   struct ShellPair {
-      typedef Shell::real_t real_t;
+      using real_t = Shell::real_t;
 
       // clang-format off
       /// PrimPairData contains pre-computed primitive pair data
diff --git a/include/libint2/solidharmonics.h b/include/libint2/solidharmonics.h
index e39f242db..161e21015 100644
--- a/include/libint2/solidharmonics.h
+++ b/include/libint2/solidharmonics.h
@@ -55,7 +55,7 @@ namespace libint2 {
     template <typename Real>
     class SolidHarmonicsCoefficients {
       public:
-        typedef ::libint2::value_type real_t;
+        using real_t = ::libint2::value_type;
 
         SolidHarmonicsCoefficients() : l_(-1) {
         }
diff --git a/include/libint2/util/array_adaptor.h b/include/libint2/util/array_adaptor.h
index 21a2e830a..212bd5294 100644
--- a/include/libint2/util/array_adaptor.h
+++ b/include/libint2/util/array_adaptor.h
@@ -44,7 +44,7 @@ class ext_stack_allocator {
   using propagate_on_container_move_assignment = std::true_type;
 
   static auto constexpr size = N;
-  typedef T array_type[N];
+  using array_type = T[N];
 
  private:
   T* stack_;  // stack-allocated storage
diff --git a/include/libint2/util/compressed_pair.h b/include/libint2/util/compressed_pair.h
index 44aceba93..2b56e966c 100644
--- a/include/libint2/util/compressed_pair.h
+++ b/include/libint2/util/compressed_pair.h
@@ -29,16 +29,16 @@ namespace libint2 {
     class compressed_pair : private T1, private T2
     {
       public:
-        typedef T1                                                 first_type;
-        typedef T2                                                 second_type;
-        typedef typename std::add_const<first_type>::type          first_const_type;
-        typedef typename std::add_const<second_type>::type         second_const_type;
-        typedef typename std::add_lvalue_reference<first_type>::type   first_reference;
-        typedef typename std::add_lvalue_reference<second_type>::type  second_reference;
-        typedef typename std::add_lvalue_reference<first_const_type>::type   first_const_reference;
-        typedef typename std::add_lvalue_reference<second_const_type>::type  second_const_reference;
-        typedef typename std::add_rvalue_reference<first_type>::type   first_rvalue_reference;
-        typedef typename std::add_rvalue_reference<second_type>::type  second_rvalue_reference;
+        using first_type = T1;
+        using second_type = T2;
+        using first_const_type = typename std::add_const<first_type>::type;
+        using second_const_type = typename std::add_const<second_type>::type;
+        using first_reference = typename std::add_lvalue_reference<first_type>::type;
+        using second_reference = typename std::add_lvalue_reference<second_type>::type;
+        using first_const_reference = typename std::add_lvalue_reference<first_const_type>::type;
+        using second_const_reference = typename std::add_lvalue_reference<second_const_type>::type;
+        using first_rvalue_reference = typename std::add_rvalue_reference<first_type>::type;
+        using second_rvalue_reference = typename std::add_rvalue_reference<second_type>::type;
 
         compressed_pair() = default;
         compressed_pair(const first_type& x, const second_type& y) :
diff --git a/include/libint2/util/intpart_iter.h b/include/libint2/util/intpart_iter.h
index b8e0af2dc..e28cd2595 100644
--- a/include/libint2/util/intpart_iter.h
+++ b/include/libint2/util/intpart_iter.h
@@ -73,10 +73,10 @@ template <typename Sequence,
               typename Sequence::value_type>::is_integer>::type>
 struct FixedOrderedIntegerPartitionIterator {
  public:
-  typedef const Sequence& value_type;
-  typedef typename Sequence::value_type integer_type;
-  typedef typename std::make_unsigned<integer_type>::type unsigned_integer_type;
-  typedef typename Sequence::size_type size_type;
+  using value_type = const Sequence&;
+  using integer_type = typename Sequence::value_type;
+  using unsigned_integer_type = typename std::make_unsigned<integer_type>::type;
+  using size_type = typename Sequence::size_type;
 
   /// \param n the positive integer to be partitioned
   template <typename Seq = Sequence>