diff --git a/Src/AmrCore/AMReX_FillPatchUtil.H b/Src/AmrCore/AMReX_FillPatchUtil.H
index fab29231bf3..467b8c46eab 100644
--- a/Src/AmrCore/AMReX_FillPatchUtil.H
+++ b/Src/AmrCore/AMReX_FillPatchUtil.H
@@ -10,7 +10,7 @@
 #include <AMReX_MFInterpolater.H>
 #include <AMReX_Array.H>
 #include <AMReX_Utility.H>
-
+#include <AMReX_Concepts.H>
 /**
  * \file AMReX_FillPatchUtil.H
  * \brief High-level FillPatch helpers for AMR coarse-to-fine synchronization.
@@ -37,13 +37,13 @@ namespace amrex
     template <typename MFFAB>
     struct NullInterpHook
     {
-        template <class F=MFFAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+        template <BaseFabType T = MFFAB>
         void operator() (MFFAB& /*fab*/, const Box& /*bx*/, int /*icomp*/, int /*ncomp*/) const {}
 
-        template <class F=MFFAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+        template <BaseFabType T = MFFAB>
         void operator() (Array<MFFAB*, AMREX_SPACEDIM> /*fab*/, const Box& /*bx*/, int /*icomp*/, int /*ncomp*/) const {}
 
-        template <class F=MFFAB, std::enable_if_t<IsFabArray<F>::value,int> = 0>
+        template <FabArrayType T = MFFAB>
         void operator() (MFFAB& /*mf*/, int /*icomp*/, int /*ncomp*/) const {}
     };
 
@@ -87,9 +87,8 @@ namespace amrex
      * \param physbcf functor for physical boundaries
      * \param bcfcomp starting component for physbcf
      */
-    template <typename MF, typename BC>
-    std::enable_if_t<IsFabArray<MF>::value>
-    FillPatchSingleLevel (MF& mf, IntVect const& nghost, Real time,
+    template <FabArrayType MF, typename BC>
+    void FillPatchSingleLevel (MF& mf, IntVect const& nghost, Real time,
                           const Vector<MF*>& smf, const Vector<Real>& stime,
                           int scomp, int dcomp, int ncomp,
                           const Geometry& geom,
@@ -118,9 +117,8 @@ namespace amrex
      * \param physbcf functor for physical boundaries
      * \param bcfcomp starting component for physbcf
      */
-    template <typename MF, typename BC>
-    std::enable_if_t<IsFabArray<MF>::value>
-    FillPatchSingleLevel (MF& mf, Real time,
+    template <FabArrayType MF, typename BC>
+    void FillPatchSingleLevel (MF& mf, Real time,
                           const Vector<MF*>& smf, const Vector<Real>& stime,
                           int scomp, int dcomp, int ncomp,
                           const Geometry& geom,
@@ -164,11 +162,10 @@ namespace amrex
      * \param pre_interp pre-interpolation hook
      * \param post_interp post-interpolation hook
      */
-    template <typename MF, typename BC, typename Interp,
+    template <FabArrayType MF, typename BC, typename Interp,
               typename PreInterpHook=NullInterpHook<typename MF::FABType::value_type>,
               typename PostInterpHook=NullInterpHook<typename MF::FABType::value_type> >
-    std::enable_if_t<IsFabArray<MF>::value>
-    FillPatchTwoLevels (MF& mf, IntVect const& nghost, Real time,
+    void FillPatchTwoLevels (MF& mf, IntVect const& nghost, Real time,
                         const Vector<MF*>& cmf, const Vector<Real>& ct,
                         const Vector<MF*>& fmf, const Vector<Real>& ft,
                         int scomp, int dcomp, int ncomp,
@@ -218,11 +215,10 @@ namespace amrex
      * \param pre_interp pre-interpolation hook
      * \param post_interp post-interpolation hook
      */
-    template <typename MF, typename BC, typename Interp,
+    template <FabArrayType MF, typename BC, typename Interp,
               typename PreInterpHook=NullInterpHook<typename MF::FABType::value_type>,
               typename PostInterpHook=NullInterpHook<typename MF::FABType::value_type> >
-    std::enable_if_t<IsFabArray<MF>::value>
-    FillPatchTwoLevels (MF& mf, Real time,
+    void FillPatchTwoLevels (MF& mf, Real time,
                         const Vector<MF*>& cmf, const Vector<Real>& ct,
                         const Vector<MF*>& fmf, const Vector<Real>& ft,
                         int scomp, int dcomp, int ncomp,
@@ -276,11 +272,10 @@ namespace amrex
      * \param pre_interp pre-interpolation hook
      * \param post_interp post-interpolation hook
      */
-    template <typename MF, typename BC, typename Interp,
+    template <FabArrayType MF, typename BC, typename Interp,
               typename PreInterpHook=NullInterpHook<typename MF::FABType::value_type>,
               typename PostInterpHook=NullInterpHook<typename MF::FABType::value_type> >
-    std::enable_if_t<IsFabArray<MF>::value>
-    FillPatchTwoLevels (Array<MF*, AMREX_SPACEDIM> const& mf, IntVect const& nghost, Real time,
+    void FillPatchTwoLevels (Array<MF*, AMREX_SPACEDIM> const& mf, IntVect const& nghost, Real time,
                         const Vector<Array<MF*, AMREX_SPACEDIM> >& cmf, const Vector<Real>& ct,
                         const Vector<Array<MF*, AMREX_SPACEDIM> >& fmf, const Vector<Real>& ft,
                         int scomp, int dcomp, int ncomp,
@@ -334,11 +329,10 @@ namespace amrex
      * \param pre_interp pre-interpolation hook
      * \param post_interp post-interpolation hook
      */
-    template <typename MF, typename BC, typename Interp,
+    template <FabArrayType MF, typename BC, typename Interp,
               typename PreInterpHook=NullInterpHook<typename MF::FABType::value_type>,
               typename PostInterpHook=NullInterpHook<typename MF::FABType::value_type> >
-    std::enable_if_t<IsFabArray<MF>::value>
-    FillPatchTwoLevels (Array<MF*, AMREX_SPACEDIM> const& mf, IntVect const& nghost, Real time,
+    void FillPatchTwoLevels (Array<MF*, AMREX_SPACEDIM> const& mf, IntVect const& nghost, Real time,
                         const Vector<Array<MF*, AMREX_SPACEDIM> >& cmf, const Vector<Real>& ct,
                         const Vector<Array<MF*, AMREX_SPACEDIM> >& fmf, const Vector<Real>& ft,
                         int scomp, int dcomp, int ncomp,
@@ -391,11 +385,10 @@ namespace amrex
      * \param pre_interp pre-interpolation hook
      * \param post_interp post-interpolation hook
      */
-    template <typename MF, typename BC, typename Interp,
+    template <FabArrayType MF, typename BC, typename Interp,
               typename PreInterpHook=NullInterpHook<typename MF::FABType::value_type>,
               typename PostInterpHook=NullInterpHook<typename MF::FABType::value_type> >
-    std::enable_if_t<IsFabArray<MF>::value>
-    FillPatchTwoLevels (Array<MF*, AMREX_SPACEDIM> const& mf, Real time,
+    void FillPatchTwoLevels (Array<MF*, AMREX_SPACEDIM> const& mf, Real time,
                         const Vector<Array<MF*, AMREX_SPACEDIM> >& cmf, const Vector<Real>& ct,
                         const Vector<Array<MF*, AMREX_SPACEDIM> >& fmf, const Vector<Real>& ft,
                         int scomp, int dcomp, int ncomp,
@@ -448,9 +441,8 @@ namespace amrex
      * \param pre_interp pre-interpolation hook
      * \param post_interp post-interpolation hook
      */
-    template <typename MF, typename BC, typename Interp, typename PreInterpHook, typename PostInterpHook>
-    std::enable_if_t<IsFabArray<MF>::value>
-    FillPatchTwoLevels (MF& mf, IntVect const& nghost, Real time,
+    template <FabArrayType MF, typename BC, typename Interp, typename PreInterpHook, typename PostInterpHook>
+    void FillPatchTwoLevels (MF& mf, IntVect const& nghost, Real time,
                         const EB2::IndexSpace& index_space,
                         const Vector<MF*>& cmf, const Vector<Real>& ct,
                         const Vector<MF*>& fmf, const Vector<Real>& ft,
@@ -502,9 +494,8 @@ namespace amrex
      * \param pre_interp pre-interpolation hook
      * \param post_interp post-interpolation hook
      */
-    template <typename MF, typename BC, typename Interp, typename PreInterpHook, typename PostInterpHook>
-    std::enable_if_t<IsFabArray<MF>::value>
-    FillPatchTwoLevels (MF& mf, Real time,
+    template <FabArrayType MF, typename BC, typename Interp, typename PreInterpHook, typename PostInterpHook>
+    void FillPatchTwoLevels (MF& mf, Real time,
                         const EB2::IndexSpace& index_space,
                         const Vector<MF*>& cmf, const Vector<Real>& ct,
                         const Vector<MF*>& fmf, const Vector<Real>& ft,
@@ -549,11 +540,10 @@ namespace amrex
      * \param pre_interp pre-interpolation hook
      * \param post_interp post-interpolation hook
      */
-    template <typename MF, typename BC, typename Interp,
+    template <FabArrayType MF, typename BC, typename Interp,
               typename PreInterpHook=NullInterpHook<typename MF::FABType::value_type>,
               typename PostInterpHook=NullInterpHook<typename MF::FABType::value_type> >
-    std::enable_if_t<IsFabArray<MF>::value>
-    InterpFromCoarseLevel (MF& mf, Real time,
+    void InterpFromCoarseLevel (MF& mf, Real time,
                            const MF& cmf, int scomp, int dcomp, int ncomp,
                            const Geometry& cgeom, const Geometry& fgeom,
                            BC& cbc, int cbccomp,
@@ -593,11 +583,10 @@ namespace amrex
      * \param pre_interp pre-interpolation hook
      * \param post_interp post-interpolation hook
      */
-    template <typename MF, typename BC, typename Interp,
+    template <FabArrayType MF, typename BC, typename Interp,
               typename PreInterpHook=NullInterpHook<typename MF::FABType::value_type>,
               typename PostInterpHook=NullInterpHook<typename MF::FABType::value_type> >
-    std::enable_if_t<IsFabArray<MF>::value>
-    InterpFromCoarseLevel (MF& mf, IntVect const& nghost, Real time,
+    void InterpFromCoarseLevel (MF& mf, IntVect const& nghost, Real time,
                            const MF& cmf, int scomp, int dcomp, int ncomp,
                            const Geometry& cgeom, const Geometry& fgeom,
                            BC& cbc, int cbccomp,
@@ -638,11 +627,10 @@ namespace amrex
      * \param pre_interp pre-interpolation hook
      * \param post_interp post-interpolation hook
      */
-    template <typename MF, typename BC, typename Interp,
+    template <FabArrayType MF, typename BC, typename Interp,
               typename PreInterpHook=NullInterpHook<typename MF::FABType::value_type>,
               typename PostInterpHook=NullInterpHook<typename MF::FABType::value_type> >
-    std::enable_if_t<IsFabArray<MF>::value>
-    InterpFromCoarseLevel (MF& mf, IntVect const& nghost, Real time,
+    void InterpFromCoarseLevel (MF& mf, IntVect const& nghost, Real time,
                            const EB2::IndexSpace* index_space,
                            const MF& cmf, int scomp, int dcomp, int ncomp,
                            const Geometry& cgeom, const Geometry& fgeom,
@@ -684,11 +672,10 @@ namespace amrex
      * \param pre_interp pre-interpolation hook
      * \param post_interp post-interpolation hook
      */
-    template <typename MF, typename BC, typename Interp,
+    template <FabArrayType MF, typename BC, typename Interp,
               typename PreInterpHook=NullInterpHook<typename MF::FABType::value_type>,
               typename PostInterpHook=NullInterpHook<typename MF::FABType::value_type> >
-    std::enable_if_t<IsFabArray<MF>::value>
-    InterpFromCoarseLevel (Array<MF*, AMREX_SPACEDIM> const& mf, Real time,
+    void InterpFromCoarseLevel (Array<MF*, AMREX_SPACEDIM> const& mf, Real time,
                            const Array<MF*, AMREX_SPACEDIM>& cmf, int scomp, int dcomp, int ncomp,
                            const Geometry& cgeom, const Geometry& fgeom,
                            Array<BC, AMREX_SPACEDIM>& cbc, int cbccomp,
@@ -730,11 +717,10 @@ namespace amrex
      * \param pre_interp pre-interpolation hook
      * \param post_interp post-interpolation hook
      */
-    template <typename MF, typename BC, typename Interp,
+    template <FabArrayType MF, typename BC, typename Interp,
               typename PreInterpHook=NullInterpHook<typename MF::FABType::value_type>,
               typename PostInterpHook=NullInterpHook<typename MF::FABType::value_type> >
-    std::enable_if_t<IsFabArray<MF>::value>
-    InterpFromCoarseLevel (Array<MF*, AMREX_SPACEDIM> const& mf, IntVect const& nghost, Real time,
+    void InterpFromCoarseLevel (Array<MF*, AMREX_SPACEDIM> const& mf, IntVect const& nghost, Real time,
                            const Array<MF*, AMREX_SPACEDIM>& cmf, int scomp, int dcomp, int ncomp,
                            const Geometry& cgeom, const Geometry& fgeom,
                            Array<BC, AMREX_SPACEDIM>& cbc, int cbccomp,
@@ -771,9 +757,8 @@ namespace amrex
      * \param bcs boundar types for each component
      * \param bcscomp starting component for bcs
      */
-    template <typename MF, typename Interp>
-    std::enable_if_t<IsFabArray<MF>::value>
-    InterpFromCoarseLevel (MF& mf, IntVect const& nghost,
+    template <FabArrayType MF, typename Interp>
+    void InterpFromCoarseLevel (MF& mf, IntVect const& nghost,
                            IntVect const& nghost_outside_domain,
                            const MF& cmf, int scomp, int dcomp, int ncomp,
                            const Geometry& cgeom, const Geometry& fgeom,
@@ -802,9 +787,8 @@ namespace amrex
      * \param ncomp number of components
      * \param geom Geometry for this level
      */
-    template <typename MF>
-    std::enable_if_t<IsFabArray<MF>::value>
-    FillPatchSingleLevel (MF& mf, IntVect const& nghost, Real time,
+    template <FabArrayType MF>
+    void FillPatchSingleLevel (MF& mf, IntVect const& nghost, Real time,
                           const Vector<MF*>& smf, IntVect const& snghost,
                           const Vector<Real>& stime, int scomp, int dcomp, int ncomp,
                           const Geometry& geom);
@@ -839,9 +823,8 @@ namespace amrex
      * \param bcs boundary types for each component.
      * \param bcscomp starting component for bcs
      */
-    template <typename MF, typename Interp>
-    std::enable_if_t<IsFabArray<MF>::value>
-    FillPatchTwoLevels (MF& mf, IntVect const& nghost,
+    template <FabArrayType MF, typename Interp>
+    void FillPatchTwoLevels (MF& mf, IntVect const& nghost,
                         IntVect const& nghost_outside_domain, Real time,
                         const Vector<MF*>& cmf, const Vector<Real>& ct,
                         const Vector<MF*>& fmf, const Vector<Real>& ft,
@@ -904,9 +887,8 @@ namespace amrex
      * \param bcr boundary types for each component. We need this because some interpolaters need it.
      * \param bcrcomp starting component for bcr
      */
-    template <typename MF, typename BC, typename Interp>
-    std::enable_if_t<IsFabArray<MF>::value>
-    FillPatchNLevels (MF& mf, int level, const IntVect& nghost, Real time,
+    template <FabArrayType MF, typename BC, typename Interp>
+    void FillPatchNLevels (MF& mf, int level, const IntVect& nghost, Real time,
                       const Vector<Vector<MF*>>& smf, const Vector<Vector<Real>>& st,
                       int scomp, int dcomp, int ncomp,
                       const Vector<Geometry>& geom,
diff --git a/Src/AmrCore/AMReX_FillPatchUtil_I.H b/Src/AmrCore/AMReX_FillPatchUtil_I.H
index 593f0edee4a..1bd80aec539 100644
--- a/Src/AmrCore/AMReX_FillPatchUtil_I.H
+++ b/Src/AmrCore/AMReX_FillPatchUtil_I.H
@@ -58,9 +58,8 @@ bool ProperlyNested (const IntVect& ratio, const IntVect& blocking_factor, int n
     return crse_box.contains(fine_box_coarsened);
 }
 
-template <typename MF, typename BC>
-std::enable_if_t<IsFabArray<MF>::value>
-FillPatchSingleLevel (MF& mf, Real time,
+template <FabArrayType MF, typename BC>
+void FillPatchSingleLevel (MF& mf, Real time,
                       const Vector<MF*>& smf, const Vector<Real>& stime,
                       int scomp, int dcomp, int ncomp,
                       const Geometry& geom,
@@ -70,9 +69,8 @@ FillPatchSingleLevel (MF& mf, Real time,
                          geom, physbcf, bcfcomp);
 }
 
-template <typename MF, typename BC>
-std::enable_if_t<IsFabArray<MF>::value>
-FillPatchSingleLevel (MF& mf, IntVect const& nghost, Real time,
+template <FabArrayType MF, typename BC>
+void FillPatchSingleLevel (MF& mf, IntVect const& nghost, Real time,
                       const Vector<MF*>& smf, const Vector<Real>& stime,
                       int scomp, int dcomp, int ncomp,
                       const Geometry& geom,
@@ -216,9 +214,9 @@ void FillPatchInterp (MultiFab& mf_fine_patch, int fcomp, MultiFab const& mf_crs
                       Box const& dest_domain, const IntVect& ratio,
                       MFInterpolater* mapper, const Vector<BCRec>& bcs, int bcscomp);
 
-template <typename MF, typename Interp>
-std::enable_if_t<IsFabArray<MF>::value && !std::is_same_v<Interp,MFInterpolater>>
-FillPatchInterp (MF& mf_fine_patch, int fcomp, MF const& mf_crse_patch, int ccomp,
+template <FabArrayType MF, typename Interp>
+requires (!std::is_same_v<Interp, MFInterpolater>)
+void FillPatchInterp (MF& mf_fine_patch, int fcomp, MF const& mf_crse_patch, int ccomp,
                  int ncomp, IntVect const& ng, const Geometry& cgeom, const Geometry& fgeom,
                  Box const& dest_domain, const IntVect& ratio,
                  Interp* mapper, const Vector<BCRec>& bcs, int bcscomp)
@@ -247,9 +245,8 @@ FillPatchInterp (MF& mf_fine_patch, int fcomp, MF const& mf_crse_patch, int ccom
     }
 }
 
-template <typename MF>
-std::enable_if_t<IsFabArray<MF>::value>
-FillPatchInterp (MF& mf_fine_patch, int fcomp, MF const& mf_crse_patch, int ccomp,
+template <FabArrayType MF>
+void FillPatchInterp (MF& mf_fine_patch, int fcomp, MF const& mf_crse_patch, int ccomp,
                  int ncomp, IntVect const& ng, const Geometry& cgeom, const Geometry& fgeom,
                  Box const& dest_domain, const IntVect& ratio,
                  InterpBase* mapper, const Vector<BCRec>& bcs, int bcscomp)
@@ -267,9 +264,9 @@ FillPatchInterp (MF& mf_fine_patch, int fcomp, MF const& mf_crse_patch, int ccom
     }
 }
 
-template <typename MF, typename iMF, typename Interp>
-std::enable_if_t<IsFabArray<MF>::value  && !std::is_same_v<Interp,MFInterpolater>>
-InterpFace (Interp *interp,
+template <FabArrayType MF, typename iMF, typename Interp>
+requires (!std::is_same_v<Interp, MFInterpolater>)
+void InterpFace (Interp *interp,
             MF const& mf_crse_patch,    int crse_comp,
             MF&       mf_refined_patch, int fine_comp,
             int ncomp, const IntVect&   ratio,
@@ -293,9 +290,8 @@ InterpFace (Interp *interp,
     }
 }
 
-template <typename MF, typename iMF>
-std::enable_if_t<IsFabArray<MF>::value>
-InterpFace (InterpBase *interp,
+template <FabArrayType MF, typename iMF>
+void InterpFace (InterpBase *interp,
             MF const& mf_crse_patch,    int crse_comp,
             MF&       mf_refined_patch, int fine_comp,
             int ncomp, const IntVect&   ratio,
@@ -467,9 +463,8 @@ namespace detail {
         // nothing
     }
 
-    template <typename MF, typename BC, typename Interp, typename PreInterpHook, typename PostInterpHook>
-    std::enable_if_t<IsFabArray<MF>::value,int>
-    FillPatchTwoLevels_doit (MF& mf, IntVect const& nghost, Real time,
+    template <FabArrayType MF, typename BC, typename Interp, typename PreInterpHook, typename PostInterpHook>
+    int FillPatchTwoLevels_doit (MF& mf, IntVect const& nghost, Real time,
                              const Vector<MF*>& cmf, const Vector<Real>& ct,
                              const Vector<MF*>& fmf, const Vector<Real>& ft,
                              int scomp, int dcomp, int ncomp,
@@ -640,9 +635,8 @@ namespace detail {
         return success_code;
     }
 
-    template <typename MF, typename BC, typename Interp, typename PreInterpHook, typename PostInterpHook>
-    std::enable_if_t<IsFabArray<MF>::value>
-    FillPatchTwoLevels_doit (Array<MF*, AMREX_SPACEDIM> const& mf, IntVect const& nghost, Real time,
+    template <FabArrayType MF, typename BC, typename Interp, typename PreInterpHook, typename PostInterpHook>
+    void FillPatchTwoLevels_doit (Array<MF*, AMREX_SPACEDIM> const& mf, IntVect const& nghost, Real time,
                              const Vector<Array<MF*, AMREX_SPACEDIM> >& cmf, const Vector<Real>& ct,
                              const Vector<Array<MF*, AMREX_SPACEDIM> >& fmf, const Vector<Real>& ft,
                              int scomp, int dcomp, int ncomp,
@@ -812,9 +806,8 @@ namespace detail {
 } // namespace detail
 /// \endcond
 
-template <typename MF, typename BC, typename Interp, typename PreInterpHook, typename PostInterpHook>
-std::enable_if_t<IsFabArray<MF>::value>
-FillPatchTwoLevels (MF& mf, IntVect const& nghost, Real time,
+template <FabArrayType MF, typename BC, typename Interp, typename PreInterpHook, typename PostInterpHook>
+void FillPatchTwoLevels (MF& mf, IntVect const& nghost, Real time,
                     const Vector<MF*>& cmf, const Vector<Real>& ct,
                     const Vector<MF*>& fmf, const Vector<Real>& ft,
                     int scomp, int dcomp, int ncomp,
@@ -838,9 +831,8 @@ FillPatchTwoLevels (MF& mf, IntVect const& nghost, Real time,
                             pre_interp,post_interp,index_space);
 }
 
-template <typename MF, typename BC, typename Interp, typename PreInterpHook, typename PostInterpHook>
-std::enable_if_t<IsFabArray<MF>::value>
-FillPatchTwoLevels (MF& mf, Real time,
+template <FabArrayType MF, typename BC, typename Interp, typename PreInterpHook, typename PostInterpHook>
+void FillPatchTwoLevels (MF& mf, Real time,
                     const Vector<MF*>& cmf, const Vector<Real>& ct,
                     const Vector<MF*>& fmf, const Vector<Real>& ft,
                     int scomp, int dcomp, int ncomp,
@@ -865,9 +857,8 @@ FillPatchTwoLevels (MF& mf, Real time,
                             pre_interp,post_interp,index_space);
 }
 
-template <typename MF, typename BC, typename Interp, typename PreInterpHook, typename PostInterpHook>
-std::enable_if_t<IsFabArray<MF>::value>
-FillPatchTwoLevels (Array<MF*, AMREX_SPACEDIM> const& mf, IntVect const& nghost, Real time,
+template <FabArrayType MF, typename BC, typename Interp, typename PreInterpHook, typename PostInterpHook>
+void FillPatchTwoLevels (Array<MF*, AMREX_SPACEDIM> const& mf, IntVect const& nghost, Real time,
                     const Vector<Array<MF*, AMREX_SPACEDIM> >& cmf, const Vector<Real>& ct,
                     const Vector<Array<MF*, AMREX_SPACEDIM> >& fmf, const Vector<Real>& ft,
                     int scomp, int dcomp, int ncomp,
@@ -892,9 +883,8 @@ FillPatchTwoLevels (Array<MF*, AMREX_SPACEDIM> const& mf, IntVect const& nghost,
                             pre_interp,post_interp,index_space);
 }
 
-template <typename MF, typename BC, typename Interp, typename PreInterpHook, typename PostInterpHook>
-std::enable_if_t<IsFabArray<MF>::value>
-FillPatchTwoLevels (Array<MF*, AMREX_SPACEDIM> const& mf, IntVect const& nghost, Real time,
+template <FabArrayType MF, typename BC, typename Interp, typename PreInterpHook, typename PostInterpHook>
+void FillPatchTwoLevels (Array<MF*, AMREX_SPACEDIM> const& mf, IntVect const& nghost, Real time,
                     const Vector<Array<MF*, AMREX_SPACEDIM> >& cmf, const Vector<Real>& ct,
                     const Vector<Array<MF*, AMREX_SPACEDIM> >& fmf, const Vector<Real>& ft,
                     int scomp, int dcomp, int ncomp,
@@ -923,9 +913,8 @@ FillPatchTwoLevels (Array<MF*, AMREX_SPACEDIM> const& mf, IntVect const& nghost,
                             pre_interp,post_interp,index_space);
 }
 
-template <typename MF, typename BC, typename Interp, typename PreInterpHook, typename PostInterpHook>
-std::enable_if_t<IsFabArray<MF>::value>
-FillPatchTwoLevels (Array<MF*, AMREX_SPACEDIM> const& mf, Real time,
+template <FabArrayType MF, typename BC, typename Interp, typename PreInterpHook, typename PostInterpHook>
+void FillPatchTwoLevels (Array<MF*, AMREX_SPACEDIM> const& mf, Real time,
                     const Vector<Array<MF*, AMREX_SPACEDIM> >& cmf, const Vector<Real>& ct,
                     const Vector<Array<MF*, AMREX_SPACEDIM> >& fmf, const Vector<Real>& ft,
                     int scomp, int dcomp, int ncomp,
@@ -955,9 +944,8 @@ FillPatchTwoLevels (Array<MF*, AMREX_SPACEDIM> const& mf, Real time,
 }
 
 #ifdef AMREX_USE_EB
-template <typename MF, typename BC, typename Interp, typename PreInterpHook, typename PostInterpHook>
-std::enable_if_t<IsFabArray<MF>::value>
-FillPatchTwoLevels (MF& mf, IntVect const& nghost, Real time,
+template <FabArrayType MF, typename BC, typename Interp, typename PreInterpHook, typename PostInterpHook>
+void FillPatchTwoLevels (MF& mf, IntVect const& nghost, Real time,
                     const EB2::IndexSpace& index_space,
                     const Vector<MF*>& cmf, const Vector<Real>& ct,
                     const Vector<MF*>& fmf, const Vector<Real>& ft,
@@ -977,9 +965,8 @@ FillPatchTwoLevels (MF& mf, IntVect const& nghost, Real time,
                             pre_interp,post_interp,&index_space);
 }
 
-template <typename MF, typename BC, typename Interp, typename PreInterpHook, typename PostInterpHook>
-std::enable_if_t<IsFabArray<MF>::value>
-FillPatchTwoLevels (MF& mf, Real time,
+template <FabArrayType MF, typename BC, typename Interp, typename PreInterpHook, typename PostInterpHook>
+void FillPatchTwoLevels (MF& mf, Real time,
                     const EB2::IndexSpace& index_space,
                     const Vector<MF*>& cmf, const Vector<Real>& ct,
                     const Vector<MF*>& fmf, const Vector<Real>& ft,
@@ -1000,9 +987,8 @@ FillPatchTwoLevels (MF& mf, Real time,
 }
 #endif
 
-template <typename MF, typename BC, typename Interp, typename PreInterpHook, typename PostInterpHook>
-std::enable_if_t<IsFabArray<MF>::value>
-InterpFromCoarseLevel (MF& mf, Real time,
+template <FabArrayType MF, typename BC, typename Interp, typename PreInterpHook, typename PostInterpHook>
+void InterpFromCoarseLevel (MF& mf, Real time,
                        const MF& cmf, int scomp, int dcomp, int ncomp,
                        const Geometry& cgeom, const Geometry& fgeom,
                        BC& cbc, int cbccomp,
@@ -1024,9 +1010,8 @@ InterpFromCoarseLevel (MF& mf, Real time,
                           pre_interp,post_interp);
 }
 
-template <typename MF, typename BC, typename Interp, typename PreInterpHook, typename PostInterpHook>
-std::enable_if_t<IsFabArray<MF>::value>
-InterpFromCoarseLevel (Array<MF*, AMREX_SPACEDIM> const& mf, Real time,
+template <FabArrayType MF, typename BC, typename Interp, typename PreInterpHook, typename PostInterpHook>
+void InterpFromCoarseLevel (Array<MF*, AMREX_SPACEDIM> const& mf, Real time,
                        const Array<MF*, AMREX_SPACEDIM>& cmf, int scomp, int dcomp, int ncomp,
                        const Geometry& cgeom, const Geometry& fgeom,
                        Array<BC, AMREX_SPACEDIM>& cbc, int cbccomp,
@@ -1042,9 +1027,8 @@ InterpFromCoarseLevel (Array<MF*, AMREX_SPACEDIM> const& mf, Real time,
                           pre_interp,post_interp);
 }
 
-template <typename MF, typename BC, typename Interp, typename PreInterpHook, typename PostInterpHook>
-std::enable_if_t<IsFabArray<MF>::value>
-InterpFromCoarseLevel (MF& mf, IntVect const& nghost, Real time,
+template <FabArrayType MF, typename BC, typename Interp, typename PreInterpHook, typename PostInterpHook>
+void InterpFromCoarseLevel (MF& mf, IntVect const& nghost, Real time,
                        const MF& cmf, int scomp, int dcomp, int ncomp,
                        const Geometry& cgeom, const Geometry& fgeom,
                        BC& cbc, int cbccomp,
@@ -1066,9 +1050,8 @@ InterpFromCoarseLevel (MF& mf, IntVect const& nghost, Real time,
                           pre_interp,post_interp);
 }
 
-template <typename MF, typename BC, typename Interp, typename PreInterpHook, typename PostInterpHook>
-std::enable_if_t<IsFabArray<MF>::value>
-InterpFromCoarseLevel (MF& mf, IntVect const& nghost, Real time,
+template <FabArrayType MF, typename BC, typename Interp, typename PreInterpHook, typename PostInterpHook>
+void InterpFromCoarseLevel (MF& mf, IntVect const& nghost, Real time,
                        const EB2::IndexSpace* index_space,
                        const MF& cmf, int scomp, int dcomp, int ncomp,
                        const Geometry& cgeom, const Geometry& fgeom,
@@ -1162,9 +1145,8 @@ InterpFromCoarseLevel (MF& mf, IntVect const& nghost, Real time,
     fbc(mf, dcomp, ncomp, nghost, time, fbccomp);
 }
 
-template <typename MF, typename BC, typename Interp, typename PreInterpHook, typename PostInterpHook>
-std::enable_if_t<IsFabArray<MF>::value>
-InterpFromCoarseLevel (Array<MF*, AMREX_SPACEDIM> const& mf, IntVect const& nghost, Real time,
+template <FabArrayType MF, typename BC, typename Interp, typename PreInterpHook, typename PostInterpHook>
+void InterpFromCoarseLevel (Array<MF*, AMREX_SPACEDIM> const& mf, IntVect const& nghost, Real time,
                        const Array<MF*, AMREX_SPACEDIM>& cmf, int scomp, int dcomp, int ncomp,
                        const Geometry& cgeom, const Geometry& fgeom,
                        Array<BC, AMREX_SPACEDIM>& cbc, int cbccomp,
@@ -1312,9 +1294,8 @@ InterpFromCoarseLevel (Array<MF*, AMREX_SPACEDIM> const& mf, IntVect const& ngho
     }
 }
 
-template <typename MF, typename Interp>
-std::enable_if_t<IsFabArray<MF>::value>
-InterpFromCoarseLevel (MF& mf, IntVect const& nghost,
+template <FabArrayType MF, typename Interp>
+void InterpFromCoarseLevel (MF& mf, IntVect const& nghost,
                        IntVect const& nghost_outside_domain,
                        const MF& cmf, int scomp, int dcomp, int ncomp,
                        const Geometry& cgeom, const Geometry& fgeom,
@@ -1327,9 +1308,8 @@ InterpFromCoarseLevel (MF& mf, IntVect const& nghost,
                           bcs, bcscomp);
 }
 
-template <typename MF>
-std::enable_if_t<IsFabArray<MF>::value>
-FillPatchSingleLevel (MF& mf, IntVect const& nghost, Real time,
+template <FabArrayType MF>
+void FillPatchSingleLevel (MF& mf, IntVect const& nghost, Real time,
                       const Vector<MF*>& smf, IntVect const& snghost,
                       const Vector<Real>& stime, int scomp, int dcomp, int ncomp,
                       const Geometry& geom)
@@ -1339,9 +1319,8 @@ FillPatchSingleLevel (MF& mf, IntVect const& nghost, Real time,
                          erfbc, 0);
 }
 
-template <typename MF, typename Interp>
-std::enable_if_t<IsFabArray<MF>::value>
-FillPatchTwoLevels (MF& mf, IntVect const& nghost,
+template <FabArrayType MF, typename Interp>
+void FillPatchTwoLevels (MF& mf, IntVect const& nghost,
                     IntVect const& nghost_outside_domain, Real time,
                     const Vector<MF*>& cmf, const Vector<Real>& ct,
                     const Vector<MF*>& fmf, const Vector<Real>& ft,
@@ -1358,9 +1337,8 @@ FillPatchTwoLevels (MF& mf, IntVect const& nghost,
                        bcs, bcscomp);
 }
 
-template <typename MF, typename BC, typename Interp>
-std::enable_if_t<IsFabArray<MF>::value>
-FillPatchNLevels (MF& mf, int level, const IntVect& nghost, Real time,
+template <FabArrayType MF, typename BC, typename Interp>
+void FillPatchNLevels (MF& mf, int level, const IntVect& nghost, Real time,
                   const Vector<Vector<MF*>>& smf, const Vector<Vector<Real>>& st,
                   int scomp, int dcomp, int ncomp,
                   const Vector<Geometry>& geom,
diff --git a/Src/Base/AMReX_Concepts.H b/Src/Base/AMReX_Concepts.H
new file mode 100644
index 00000000000..26f64bf2194
--- /dev/null
+++ b/Src/Base/AMReX_Concepts.H
@@ -0,0 +1,21 @@
+#ifndef AMREX_CONCEPTS_H_
+#define AMREX_CONCEPTS_H_
+
+#include <AMReX_Config.H>
+#include <AMReX_TypeTraits.H>
+#include <concepts>
+
+namespace amrex {
+/**
+ * \brief Checks if a type is derived from amrex::BaseFab.
+ */
+template <typename T>
+concept BaseFabType = amrex::IsBaseFab<T>::value;
+
+/**
+ * \brief Checks if a type is an amrex::FabArray (like MultiFab).
+ */
+template <typename T>
+concept FabArrayType = amrex::IsFabArray<T>::value;
+} // namespace amrex
+#endif
diff --git a/Src/Base/AMReX_FabArray.H b/Src/Base/AMReX_FabArray.H
index 3186ae4276b..5c86148534c 100644
--- a/Src/Base/AMReX_FabArray.H
+++ b/Src/Base/AMReX_FabArray.H
@@ -30,6 +30,7 @@
 #include <AMReX_MFParallelFor.H>
 #include <AMReX_TagParallelFor.H>
 #include <AMReX_ParReduce.H>
+#include <AMReX_Concepts.H>
 
 #include <AMReX_Gpu.H>
 
@@ -54,7 +55,8 @@
 
 namespace amrex {
 
-template <typename T, std::enable_if_t<!IsBaseFab<T>::value,int> = 0>
+template <typename T>
+requires (!BaseFabType<T>)
 Long nBytesOwned (T const&) noexcept { return 0; }
 
 template <typename T>
@@ -238,16 +240,14 @@ Copy (FabArray<DFAB>& dst, FabArray<SFAB> const& src, int srccomp, int dstcomp,
     }
 }
 
-template <class FAB,
-          class bar = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB>
 void
 Add (FabArray<FAB>& dst, FabArray<FAB> const& src, int srccomp, int dstcomp, int numcomp, int nghost)
 {
     Add(dst,src,srccomp,dstcomp,numcomp,IntVect(nghost));
 }
 
-template <class FAB,
-          class bar = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB>
 void
 Add (FabArray<FAB>& dst, FabArray<FAB> const& src, int srccomp, int dstcomp, int numcomp, const IntVect& nghost)
 {
@@ -544,7 +544,7 @@ public:
     FAB      * fabPtr (int K) noexcept;  // Here K is global index
     FAB const* fabPtr (int K) const noexcept;
 
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     void prefetchToHost (const MFIter& mfi) const noexcept
     {
 #ifdef AMREX_USE_CUDA
@@ -554,7 +554,7 @@ public:
 #endif
     }
 
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     void prefetchToDevice (const MFIter& mfi) const noexcept
     {
 #ifdef AMREX_USE_CUDA
@@ -564,93 +564,93 @@ public:
 #endif
     }
 
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     Array4<typename FabArray<FAB>::value_type const> array (const MFIter& mfi) const noexcept
     {
         return fabPtr(mfi)->const_array();
     }
 
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     Array4<typename FabArray<FAB>::value_type> array (const MFIter& mfi) noexcept
     {
         return fabPtr(mfi)->array();
     }
 
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     Array4<typename FabArray<FAB>::value_type const> array (int K) const noexcept
     {
         return fabPtr(K)->const_array();
     }
 
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     Array4<typename FabArray<FAB>::value_type> array (int K) noexcept
     {
         return fabPtr(K)->array();
     }
 
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     Array4<typename FabArray<FAB>::value_type const> const_array (const MFIter& mfi) const noexcept
     {
         return fabPtr(mfi)->const_array();
     }
 
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     Array4<typename FabArray<FAB>::value_type const> const_array (int K) const noexcept
     {
         return fabPtr(K)->const_array();
     }
 
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     Array4<typename FabArray<FAB>::value_type const> array (const MFIter& mfi, int start_comp) const noexcept
     {
         return fabPtr(mfi)->const_array(start_comp);
     }
 
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     Array4<typename FabArray<FAB>::value_type> array (const MFIter& mfi, int start_comp) noexcept
     {
         return fabPtr(mfi)->array(start_comp);
     }
 
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     Array4<typename FabArray<FAB>::value_type const> array (int K, int start_comp) const noexcept
     {
         return fabPtr(K)->const_array(start_comp);
     }
 
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     Array4<typename FabArray<FAB>::value_type> array (int K, int start_comp) noexcept
     {
         return fabPtr(K)->array(start_comp);
     }
 
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     Array4<typename FabArray<FAB>::value_type const> const_array (const MFIter& mfi, int start_comp) const noexcept
     {
         return fabPtr(mfi)->const_array(start_comp);
     }
 
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     Array4<typename FabArray<FAB>::value_type const> const_array (int K, int start_comp) const noexcept
     {
         return fabPtr(K)->const_array(start_comp);
     }
 
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     MultiArray4<typename FabArray<FAB>::value_type> arrays () noexcept
     {
         build_arrays();
         return m_arrays;
     }
 
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     MultiArray4<typename FabArray<FAB>::value_type const> arrays () const noexcept
     {
         build_arrays();
         return m_const_arrays;
     }
 
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     MultiArray4<typename FabArray<FAB>::value_type const> const_arrays () const noexcept
     {
         build_arrays();
@@ -716,16 +716,16 @@ public:
      * \param ncomp  number of components
      * \param nghost number of ghost cells
      */
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     void LocalAdd (FabArray<FAB> const& src, int scomp, int dcomp, int ncomp,
                    IntVect const& nghost);
 
     //! Set all components in the entire region of each FAB to val.
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     void setVal (value_type val);
 
     //! Set all components in the entire region of each FAB to val.
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     FabArray<FAB>& operator= (value_type val);
 
     /**
@@ -733,13 +733,13 @@ public:
     * each FAB in the FabArray, starting at component comp to val.
     * Also set the value of nghost boundary cells.
     */
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     void setVal (value_type val,
                  int        comp,
                  int        ncomp,
                  int        nghost = 0);
 
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     void setVal (value_type val,
                  int        comp,
                  int        ncomp,
@@ -751,14 +751,14 @@ public:
     * as nghost boundary cells, to val, provided they also intersect
     * with the Box region.
     */
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     void setVal (value_type val,
                  const Box& region,
                  int        comp,
                  int        ncomp,
                  int        nghost = 0);
 
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     void setVal (value_type val,
                  const Box& region,
                  int        comp,
@@ -768,10 +768,10 @@ public:
     * \brief Set all components in the valid region of each FAB in the
     * FabArray to val, including nghost boundary cells.
     */
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     void setVal (value_type val, int nghost);
 
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     void setVal (value_type val, const IntVect& nghost);
 
     /**
@@ -779,54 +779,54 @@ public:
     * FabArray to val, including nghost boundary cells, that also
     * intersect the Box region.
     */
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     void setVal (value_type val, const Box& region, int nghost);
 
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     void setVal (value_type val, const Box& region, const IntVect& nghost);
 
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     void abs (int comp, int ncomp, int nghost = 0);
 
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     void abs (int comp, int ncomp, const IntVect& nghost);
 
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     void plus (value_type val, int comp, int num_comp, int nghost = 0);
 
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     void plus (value_type val, const Box& region, int comp, int num_comp, int nghost = 0);
 
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     void mult (value_type val, int comp, int num_comp, int nghost = 0);
 
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     void mult (value_type val, const Box& region, int comp, int num_comp, int nghost = 0);
 
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     void invert (value_type numerator, int comp, int num_comp, int nghost = 0);
 
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     void invert (value_type numerator, const Box& region, int comp, int num_comp, int nghost = 0);
 
     //! Set all values in the boundary region to val.
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     void setBndry (value_type val);
 
     //! Set ncomp values in the boundary region, starting at start_comp to val.
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     void setBndry (value_type val, int strt_comp, int ncomp);
 
    //! Set all values outside the Geometry domain to val.
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     void setDomainBndry (value_type val, const Geometry& geom);
 
     //! Set ncomp values outside the Geometry domain to val, starting at start_comp.
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     void setDomainBndry (value_type val, int strt_comp, int ncomp, const Geometry& geom);
 
     //! Get capacity of the FabArray
-    template <typename I, class F=FAB, std::enable_if_t<IsBaseFab<F>::value && std::is_integral_v<I> && (sizeof(I) >= sizeof(Long)), int> = 0>
+    template <typename I, BaseFabType F=FAB, std::enable_if_t<std::is_integral_v<I> && (sizeof(I) >= sizeof(Long)), int> = 0>
     void capacityOfFabs (LayoutData<I>& mem) const;
 
     /**
@@ -838,7 +838,7 @@ public:
     * \warning Unless \p local is true, this routine performs an MPI collective
     * and every rank in the current active MPI communicator must participate.
     */
-    template <typename F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     typename F::value_type
     sum (int comp, IntVect const& nghost, bool local = false) const;
 
@@ -1166,7 +1166,7 @@ public:
     void FillBoundary_nowait (int scomp, int ncomp, const IntVect& nghost, const Periodicity& period, bool cross = false);
 
     template <typename BUF=value_type,
-              class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+              BaseFabType F=FAB>
     void FillBoundary_finish ();
 
     void FillBoundary_test ();
@@ -1329,7 +1329,7 @@ public:
     //             (including ghost cells outside periodic boundaries)
     // physbnd   : boundary cells outside the domain (excluding periodic boundaries)
     // interior  : interior cells (i.e., valid cells)
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     void BuildMask (const Box& phys_domain, const Periodicity& period,
                     value_type covered, value_type notcovered,
                     value_type physbnd, value_type interior);
@@ -1337,7 +1337,7 @@ public:
     // The following are private functions.  But we have to make them public for cuda.
 
     template <typename BUF=value_type,
-              class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+              BaseFabType F=FAB>
     void FBEP_nowait (int scomp, int ncomp, const IntVect& nghost,
                       const Periodicity& period, bool cross,
                       bool enforce_periodicity_only = false,
@@ -1350,10 +1350,10 @@ public:
     void PC_local_cpu (const CPC& thecpc, FabArray<FAB> const& src,
                        int scomp, int dcomp, int ncomp, CpOp op);
 
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     void setVal (value_type val, const CommMetaData& thecmd, int scomp, int ncomp);
 
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     LayoutData<int> RecvLayoutMask (const CommMetaData& thecmd);
 
 #ifdef AMREX_USE_GPU
@@ -1453,7 +1453,7 @@ public:
      * \warning Unless \p local is true, this routine performs an MPI collective
      * and every rank in the current active MPI communicator must participate.
      */
-    template <typename F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     typename F::value_type
     norminf (int comp, int ncomp, IntVect const& nghost, bool local = false,
              [[maybe_unused]] bool ignore_covered = false) const;
@@ -1470,7 +1470,7 @@ public:
      * \warning Unless \p local is true, this routine performs an MPI collective
      * and every rank in the current active MPI communicator must participate.
      */
-    template <typename IFAB, typename F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <typename IFAB, BaseFabType F=FAB>
     typename F::value_type
     norminf (FabArray<IFAB> const& mask, int comp, int ncomp, IntVect const& nghost,
              bool local = false) const;
@@ -1559,7 +1559,7 @@ private:
 
     void setFab_assert (int K, FAB const& fab) const;
 
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     void build_arrays () const;
 
     void clear_arrays ();
@@ -1649,7 +1649,7 @@ public:
      * \param ncomp  number of components
      * \param nghost number of ghost cells
      */
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     static void Saxpy (FabArray<FAB>& y, value_type a, FabArray<FAB> const& x,
                        int xcomp, int ycomp, int ncomp, IntVect const& nghost);
 
@@ -1664,7 +1664,7 @@ public:
      * \param ncomp  number of components
      * \param nghost number of ghost cells
      */
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     static void Xpay (FabArray<FAB>& y, value_type a, FabArray<FAB> const& x,
                       int xcomp, int ycomp, int ncomp, IntVect const& nghost);
 
@@ -1682,7 +1682,7 @@ public:
      * \param numcomp number of components
      * \param nghost  number of ghost cells
      */
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     static void LinComb (FabArray<FAB>& dst,
                          value_type a, const FabArray<FAB>& x, int xcomp,
                          value_type b, const FabArray<FAB>& y, int ycomp,
@@ -1701,7 +1701,7 @@ public:
      * \param ncomp  number of components
      * \param nghost number of ghost cells
      */
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     static void Saxpy_Xpay (FabArray<FAB>& y, value_type a1, FabArray<FAB> const& x1,
                             value_type a2, FabArray<FAB> const& x2,
                             int xcomp, int ycomp, int ncomp, IntVect const& nghost);
@@ -1720,7 +1720,7 @@ public:
      * \param ncomp  number of components
      * \param nghost number of ghost cells
      */
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     static void Saxpy_Saxpy (FabArray<FAB>& y1, value_type a1, FabArray<FAB> const& x1,
                              FabArray<FAB>& y2, value_type a2, FabArray<FAB> const& x2,
                              int xcomp, int ycomp, int ncomp, IntVect const& nghost);
@@ -1738,7 +1738,7 @@ public:
      * \param ncomp  number of components
      * \param nghost number of ghost cells
      */
-    template <class F=FAB, std::enable_if_t<IsBaseFab<F>::value,int> = 0>
+    template <BaseFabType F=FAB>
     static void Saypy_Saxpy (FabArray<FAB>& y1, value_type a1,
                              FabArray<FAB>& y2, value_type a2, FabArray<FAB> const& x,
                              int xcomp, int ycomp, int ncomp, IntVect const& nghost);
@@ -1815,7 +1815,7 @@ FabArray<FAB>::fabPtr (int K) const noexcept
 }
 
 template <class FAB>
-template <class F, std::enable_if_t<IsBaseFab<F>::value,int>>
+template <BaseFabType F>
 void
 FabArray<FAB>::build_arrays () const
 {
@@ -1967,7 +1967,7 @@ FabArray<FAB>::LocalCopy (FabArray<SFAB> const& src, int scomp, int dcomp, int n
 }
 
 template <class FAB>
-template <class F, std::enable_if_t<IsBaseFab<F>::value,int>>
+template <BaseFabType F>
 void
 FabArray<FAB>::LocalAdd (FabArray<FAB> const& src, int scomp, int dcomp, int ncomp,
                          IntVect const& nghost)
@@ -1976,7 +1976,7 @@ FabArray<FAB>::LocalAdd (FabArray<FAB> const& src, int scomp, int dcomp, int nco
 }
 
 template <class FAB>
-template <class F, std::enable_if_t<IsBaseFab<F>::value,int>>
+template <BaseFabType F>
 void
 FabArray<FAB>::setVal (value_type val, int nghost)
 {
@@ -1984,7 +1984,7 @@ FabArray<FAB>::setVal (value_type val, int nghost)
 }
 
 template <class FAB>
-template <class F, std::enable_if_t<IsBaseFab<F>::value,int>>
+template <BaseFabType F>
 void
 FabArray<FAB>::setVal (value_type val, const IntVect& nghost)
 {
@@ -1992,7 +1992,7 @@ FabArray<FAB>::setVal (value_type val, const IntVect& nghost)
 }
 
 template <class FAB>
-template <class F, std::enable_if_t<IsBaseFab<F>::value,int>>
+template <BaseFabType F>
 void
 FabArray<FAB>::setVal (value_type val, const Box& region, int nghost)
 {
@@ -2000,7 +2000,7 @@ FabArray<FAB>::setVal (value_type val, const Box& region, int nghost)
 }
 
 template <class FAB>
-template <class F, std::enable_if_t<IsBaseFab<F>::value,int>>
+template <BaseFabType F>
 void
 FabArray<FAB>::setVal (value_type val, const Box& region, const IntVect& nghost)
 {
@@ -2448,7 +2448,7 @@ FabArray<FAB>::setFab (const MFIter& mfi, FAB&& elem)
 }
 
 template <class FAB>
-template <class F, std::enable_if_t<IsBaseFab<F>::value,int>>
+template <BaseFabType F>
 void
 FabArray<FAB>::setBndry (value_type val)
 {
@@ -2456,7 +2456,7 @@ FabArray<FAB>::setBndry (value_type val)
 }
 
 template <class FAB>
-template <class F, std::enable_if_t<IsBaseFab<F>::value,int>Z>
+template <BaseFabType F>
 void
 FabArray<FAB>::setBndry (value_type val,
                          int        strt_comp,
@@ -2559,7 +2559,7 @@ FabArray<FAB>::setBndry (value_type val,
 }
 
 template <class FAB>
-template <class F, std::enable_if_t<IsBaseFab<F>::value,int>>
+template <BaseFabType F>
 void
 FabArray<FAB>::setDomainBndry (value_type val, const Geometry& geom)
 {
@@ -2567,7 +2567,7 @@ FabArray<FAB>::setDomainBndry (value_type val, const Geometry& geom)
 }
 
 template <class FAB>
-template <class F, std::enable_if_t<IsBaseFab<F>::value,int>>
+template <BaseFabType F>
 void
 FabArray<FAB>::setDomainBndry (value_type val,
                                int        strt_comp,
@@ -2599,7 +2599,7 @@ FabArray<FAB>::setDomainBndry (value_type val,
 
 
 template <class FAB>
-template <typename I, class F, std::enable_if_t<IsBaseFab<F>::value && std::is_integral_v<I> && (sizeof(I) >= sizeof(Long)), int> FOO>
+template <typename I, BaseFabType F, std::enable_if_t<std::is_integral_v<I> && (sizeof(I) >= sizeof(Long)), int> FOO>
 void
 FabArray<FAB>::capacityOfFabs (LayoutData<I>& mem) const {
     AMREX_ASSERT(amrex::isMFIterSafe(*this, mem));
@@ -2609,7 +2609,7 @@ FabArray<FAB>::capacityOfFabs (LayoutData<I>& mem) const {
 }
 
 template <class FAB>
-template <class F, std::enable_if_t<IsBaseFab<F>::value,int> FOO>
+template <BaseFabType F>
 typename F::value_type
 FabArray<FAB>::sum (int comp, IntVect const& nghost, bool local) const
 {
@@ -2660,7 +2660,7 @@ FabArray<FAB>::copyTo (FAB& dest, int  nghost) const
 }
 
 template <class FAB>
-template <class F, std::enable_if_t<IsBaseFab<F>::value,int>>
+template <BaseFabType F>
 void
 FabArray<FAB>::setVal (value_type val)
 {
@@ -2668,7 +2668,7 @@ FabArray<FAB>::setVal (value_type val)
 }
 
 template <class FAB>
-template <class F, std::enable_if_t<IsBaseFab<F>::value,int>>
+template <BaseFabType F>
 FabArray<FAB>&
 FabArray<FAB>::operator= (value_type val)
 {
@@ -2677,7 +2677,7 @@ FabArray<FAB>::operator= (value_type val)
 }
 
 template <class FAB>
-template <class F, std::enable_if_t<IsBaseFab<F>::value,int>>
+template <BaseFabType F>
 void
 FabArray<FAB>::setVal (value_type val,
                        int        comp,
@@ -2688,7 +2688,7 @@ FabArray<FAB>::setVal (value_type val,
 }
 
 template <class FAB>
-template <class F, std::enable_if_t<IsBaseFab<F>::value,int>Z>
+template <BaseFabType F>
 void
 FabArray<FAB>::setVal (value_type val,
                        int        comp,
@@ -2730,7 +2730,7 @@ FabArray<FAB>::setVal (value_type val,
 }
 
 template <class FAB>
-template <class F, std::enable_if_t<IsBaseFab<F>::value,int>>
+template <BaseFabType F>
 void
 FabArray<FAB>::setVal (value_type val,
                        const Box& region,
@@ -2742,7 +2742,7 @@ FabArray<FAB>::setVal (value_type val,
 }
 
 template <class FAB>
-template <class F, std::enable_if_t<IsBaseFab<F>::value,int>Z>
+template <BaseFabType F>
 void
 FabArray<FAB>::setVal (value_type val,
                        const Box& region,
@@ -2791,7 +2791,7 @@ FabArray<FAB>::setVal (value_type val,
 }
 
 template <class FAB>
-template <class F, std::enable_if_t<IsBaseFab<F>::value,int>>
+template <BaseFabType F>
 void
 FabArray<FAB>::abs (int comp, int ncomp, int nghost)
 {
@@ -2799,7 +2799,7 @@ FabArray<FAB>::abs (int comp, int ncomp, int nghost)
 }
 
 template <class FAB>
-template <class F, std::enable_if_t<IsBaseFab<F>::value,int>Z>
+template <BaseFabType F>
 void
 FabArray<FAB>::abs (int comp, int ncomp, const IntVect& nghost)
 {
@@ -2837,7 +2837,7 @@ FabArray<FAB>::abs (int comp, int ncomp, const IntVect& nghost)
 }
 
 template <class FAB>
-template <class F, std::enable_if_t<IsBaseFab<F>::value,int>Z>
+template <BaseFabType F>
 void
 FabArray<FAB>::plus (value_type val, int comp, int num_comp, int nghost)
 {
@@ -2873,7 +2873,7 @@ FabArray<FAB>::plus (value_type val, int comp, int num_comp, int nghost)
 }
 
 template <class FAB>
-template <class F, std::enable_if_t<IsBaseFab<F>::value,int>Z>
+template <BaseFabType F>
 void
 FabArray<FAB>::plus (value_type val, const Box& region, int comp, int num_comp, int nghost)
 {
@@ -2913,7 +2913,7 @@ FabArray<FAB>::plus (value_type val, const Box& region, int comp, int num_comp,
 }
 
 template <class FAB>
-template <class F, std::enable_if_t<IsBaseFab<F>::value,int>Z>
+template <BaseFabType F>
 void
 FabArray<FAB>::mult (value_type val, int comp, int num_comp, int nghost)
 {
@@ -2949,7 +2949,7 @@ FabArray<FAB>::mult (value_type val, int comp, int num_comp, int nghost)
 }
 
 template <class FAB>
-template <class F, std::enable_if_t<IsBaseFab<F>::value,int>Z>
+template <BaseFabType F>
 void
 FabArray<FAB>::mult (value_type val, const Box& region, int comp, int num_comp, int nghost)
 {
@@ -2989,7 +2989,7 @@ FabArray<FAB>::mult (value_type val, const Box& region, int comp, int num_comp,
 }
 
 template <class FAB>
-template <class F, std::enable_if_t<IsBaseFab<F>::value,int>Z>
+template <BaseFabType F>
 void
 FabArray<FAB>::invert (value_type numerator, int comp, int num_comp, int nghost)
 {
@@ -3025,7 +3025,7 @@ FabArray<FAB>::invert (value_type numerator, int comp, int num_comp, int nghost)
 }
 
 template <class FAB>
-template <class F, std::enable_if_t<IsBaseFab<F>::value,int>Z>
+template <BaseFabType F>
 void
 FabArray<FAB>::invert (value_type numerator, const Box& region, int comp, int num_comp, int nghost)
 {
@@ -3082,7 +3082,7 @@ FabArray<FAB>::shift (const IntVect& v)
 }
 
 template <class FAB>
-template <class F, std::enable_if_t<IsBaseFab<F>::value,int> FOO>
+template <BaseFabType F>
 void FabArray<FAB>::Saxpy (FabArray<FAB>& y, value_type a, FabArray<FAB> const& x,
                            int xcomp, int ycomp, int ncomp, IntVect const& nghost)
 {
@@ -3127,7 +3127,7 @@ void FabArray<FAB>::Saxpy (FabArray<FAB>& y, value_type a, FabArray<FAB> const&
 }
 
 template <class FAB>
-template <class F, std::enable_if_t<IsBaseFab<F>::value,int> FOO>
+template <BaseFabType F>
 void
 FabArray<FAB>::Xpay (FabArray<FAB>& y, value_type a, FabArray<FAB> const& x,
                      int xcomp, int ycomp, int ncomp, IntVect const& nghost)
@@ -3172,7 +3172,7 @@ FabArray<FAB>::Xpay (FabArray<FAB>& y, value_type a, FabArray<FAB> const& x,
 }
 
 template <class FAB>
-template <class F, std::enable_if_t<IsBaseFab<F>::value,int> FOO>
+template <BaseFabType F>
 void FabArray<FAB>::Saxpy_Xpay (FabArray<FAB>& y, value_type a1, FabArray<FAB> const& x1,
                                 value_type a2, FabArray<FAB> const& x2,
                                 int xcomp, int ycomp, int ncomp, IntVect const& nghost)
@@ -3228,7 +3228,7 @@ void FabArray<FAB>::Saxpy_Xpay (FabArray<FAB>& y, value_type a1, FabArray<FAB> c
 }
 
 template <class FAB>
-template <class F, std::enable_if_t<IsBaseFab<F>::value,int> FOO>
+template <BaseFabType F>
 void FabArray<FAB>::Saxpy_Saxpy (FabArray<FAB>& y1, value_type a1, FabArray<FAB> const& x1,
                                  FabArray<FAB>& y2, value_type a2, FabArray<FAB> const& x2,
                                  int xcomp, int ycomp, int ncomp, IntVect const& nghost)
@@ -3287,7 +3287,7 @@ void FabArray<FAB>::Saxpy_Saxpy (FabArray<FAB>& y1, value_type a1, FabArray<FAB>
 }
 
 template <class FAB>
-template <class F, std::enable_if_t<IsBaseFab<F>::value,int> FOO>
+template <BaseFabType F>
 void FabArray<FAB>::Saypy_Saxpy (FabArray<FAB>& y1, value_type a1,
                                  FabArray<FAB>& y2, value_type a2, FabArray<FAB> const& x,
                                  int xcomp, int ycomp, int ncomp, IntVect const& nghost)
@@ -3341,7 +3341,7 @@ void FabArray<FAB>::Saypy_Saxpy (FabArray<FAB>& y1, value_type a1,
 }
 
 template <class FAB>
-template <class F, std::enable_if_t<IsBaseFab<F>::value,int> FOO>
+template <BaseFabType F>
 void
 FabArray<FAB>::LinComb (FabArray<FAB>& dst,
                         value_type a, const FabArray<FAB>& x, int xcomp,
@@ -3716,7 +3716,7 @@ FabArray<FAB>::FillBoundary_nowait (int scomp, int ncomp, const IntVect& nghost,
 }
 
 template <class FAB>
-template <class F, std::enable_if_t<IsBaseFab<F>::value,int>Z>
+template <BaseFabType F>
 void
 FabArray<FAB>::BuildMask (const Box& phys_domain, const Periodicity& period,
                           value_type covered, value_type notcovered,
@@ -3784,7 +3784,7 @@ FabArray<FAB>::BuildMask (const Box& phys_domain, const Periodicity& period,
 }
 
 template <class FAB>
-template <class F, std::enable_if_t<IsBaseFab<F>::value,int>>
+template <BaseFabType F>
 void
 FabArray<FAB>::setVal (value_type val, const CommMetaData& thecmd, int scomp, int ncomp)
 {
@@ -3825,7 +3825,7 @@ FabArray<FAB>::setVal (value_type val, const CommMetaData& thecmd, int scomp, in
 }
 
 template <class FAB>
-template <class F, std::enable_if_t<IsBaseFab<F>::value,int>>
+template <BaseFabType F>
 LayoutData<int>
 FabArray<FAB>::RecvLayoutMask (const CommMetaData& thecmd)
 {
@@ -3859,7 +3859,7 @@ FabArray<FAB>::RecvLayoutMask (const CommMetaData& thecmd)
 }
 
 template <class FAB>
-template <typename F, std::enable_if_t<IsBaseFab<F>::value,int> FOO>
+template <BaseFabType F>
 typename F::value_type
 FabArray<FAB>::norminf (int comp, int ncomp, IntVect const& nghost, bool local,
                         [[maybe_unused]] bool ignore_covered) const
@@ -3950,7 +3950,7 @@ FabArray<FAB>::norminf (int comp, int ncomp, IntVect const& nghost, bool local,
 }
 
 template <class FAB>
-template <typename IFAB, typename F, std::enable_if_t<IsBaseFab<F>::value,int> FOO>
+template <typename IFAB, BaseFabType F>
 typename F::value_type
 FabArray<FAB>::norminf (FabArray<IFAB> const& mask, int comp, int ncomp,
                         IntVect const& nghost, bool local) const
diff --git a/Src/Base/AMReX_FabArrayCommI.H b/Src/Base/AMReX_FabArrayCommI.H
index 1eec379844c..b890e2f8f99 100644
--- a/Src/Base/AMReX_FabArrayCommI.H
+++ b/Src/Base/AMReX_FabArrayCommI.H
@@ -5,7 +5,7 @@
 namespace amrex {
 
 template <class FAB>
-template <typename BUF, class F, std::enable_if_t<IsBaseFab<F>::value,int>Z>
+template <typename BUF, BaseFabType F>
 void
 FabArray<FAB>::FBEP_nowait (int scomp, int ncomp, const IntVect& nghost,
                             const Periodicity& period, bool cross,
@@ -214,7 +214,7 @@ FabArray<FAB>::FBEP_nowait (int scomp, int ncomp, const IntVect& nghost,
 }
 
 template <class FAB>
-template <typename BUF, class F, std::enable_if_t<IsBaseFab<F>::value,int>Z>
+template <typename BUF, BaseFabType F>
 void
 FabArray<FAB>::FillBoundary_finish ()
 {
@@ -1062,9 +1062,8 @@ void fbv_copy (Vector<TagT> const& tags)
  *  \param cross  Optional cross-stencil flags; non-zero entries skip
  *                corner ghost cells for the corresponding FabArray.
  */
-template <class MF>
-std::enable_if_t<IsFabArray<MF>::value>
-FillBoundary_nowait (Vector<MF*> const& mf, Vector<int> const& scomp,
+template <FabArrayType MF>
+void FillBoundary_nowait (Vector<MF*> const& mf, Vector<int> const& scomp,
                      Vector<int> const& ncomp, Vector<IntVect> const& nghost,
                      Vector<Periodicity> const& period,
                      Vector<int> const& cross = {})
@@ -1085,9 +1084,8 @@ FillBoundary_nowait (Vector<MF*> const& mf, Vector<int> const& scomp,
  *  \param mf       FabArray pointers that should be updated.
  *  \param a_period Periodicity applied to every FabArray.
  */
-template <class MF>
-std::enable_if_t<IsFabArray<MF>::value>
-FillBoundary_nowait (Vector<MF*> const& mf,
+template <FabArrayType MF>
+void FillBoundary_nowait (Vector<MF*> const& mf,
                      const Periodicity& a_period = Periodicity::NonPeriodic())
 {
     Vector<int> scomp(mf.size(), 0);
@@ -1108,9 +1106,8 @@ FillBoundary_nowait (Vector<MF*> const& mf,
  *
  *  \param mf FabArray pointers whose FillBoundary_nowait calls should finish.
  */
-template <class MF>
-std::enable_if_t<IsFabArray<MF>::value>
-FillBoundary_finish (Vector<MF*> const& mf)
+template <FabArrayType MF>
+void FillBoundary_finish (Vector<MF*> const& mf)
 {
     BL_PROFILE("FillBoundary_finish(Vector)");
     const int N = mf.size();
@@ -1131,9 +1128,8 @@ FillBoundary_finish (Vector<MF*> const& mf)
  *  \param nghost Number of ghost cells to populate per FabArray.
  *  \param period Periodicity description per FabArray.
  */
-template <class MF>
-std::enable_if_t<IsFabArray<MF>::value>
-FillBoundaryAndSync_nowait (Vector<MF*> const& mf, Vector<int> const& scomp,
+template <FabArrayType MF>
+void FillBoundaryAndSync_nowait (Vector<MF*> const& mf, Vector<int> const& scomp,
                             Vector<int> const& ncomp, Vector<IntVect> const& nghost,
                             Vector<Periodicity> const& period)
 {
@@ -1150,9 +1146,8 @@ FillBoundaryAndSync_nowait (Vector<MF*> const& mf, Vector<int> const& scomp,
  *  \param mf       FabArray pointers that should be updated.
  *  \param a_period Periodicity applied to every FabArray.
  */
-template <class MF>
-std::enable_if_t<IsFabArray<MF>::value>
-FillBoundaryAndSync_nowait (Vector<MF*> const& mf,
+template <FabArrayType MF>
+void FillBoundaryAndSync_nowait (Vector<MF*> const& mf,
                             const Periodicity& a_period = Periodicity::NonPeriodic())
 {
     Vector<int> scomp(mf.size(), 0);
@@ -1173,9 +1168,8 @@ FillBoundaryAndSync_nowait (Vector<MF*> const& mf,
  *
  *  \param mf FabArray pointers whose FillBoundaryAndSync_nowait calls should finish.
  */
-template <class MF>
-std::enable_if_t<IsFabArray<MF>::value>
-FillBoundaryAndSync_finish (Vector<MF*> const& mf)
+template <FabArrayType MF>
+void FillBoundaryAndSync_finish (Vector<MF*> const& mf)
 {
     BL_PROFILE("FillBoundaryAndSync_finish(Vector)");
     const int N = mf.size();
@@ -1199,9 +1193,8 @@ FillBoundaryAndSync_finish (Vector<MF*> const& mf)
  *  \param cross  Optional flags; non-zero entries skip corner ghost cells
  *                (cross stencil) for the corresponding FabArray.
  */
-template <class MF>
-std::enable_if_t<IsFabArray<MF>::value>
-FillBoundary (Vector<MF*> const& mf, Vector<int> const& scomp,
+template <FabArrayType MF>
+void FillBoundary (Vector<MF*> const& mf, Vector<int> const& scomp,
               Vector<int> const& ncomp, Vector<IntVect> const& nghost,
               Vector<Periodicity> const& period, Vector<int> const& cross = {})
 {
@@ -1465,9 +1458,8 @@ FillBoundary (Vector<MF*> const& mf, Vector<int> const& scomp,
  *  \param nghost Number of ghost cells to fill for each FabArray.
  *  \param period Periodicity to use for each FabArray.
  */
-template <class MF>
-std::enable_if_t<IsFabArray<MF>::value>
-FillBoundaryAndSync (Vector<MF*> const& mf, Vector<int> const& scomp,
+template <FabArrayType MF>
+void FillBoundaryAndSync (Vector<MF*> const& mf, Vector<int> const& scomp,
                      Vector<int> const& ncomp, Vector<IntVect> const& nghost,
                      Vector<Periodicity> const& period)
 {
@@ -1482,18 +1474,16 @@ FillBoundaryAndSync (Vector<MF*> const& mf, Vector<int> const& scomp,
 }
 
 /** \brief Convenience overload that fills every component/ghost cell on each FabArray. */
-template <class MF>
-std::enable_if_t<IsFabArray<MF>::value>
-FillBoundary (Vector<MF*> const& mf, const Periodicity& a_period = Periodicity::NonPeriodic())
+template <FabArrayType MF>
+void FillBoundary (Vector<MF*> const& mf, const Periodicity& a_period = Periodicity::NonPeriodic())
 {
     FillBoundary_nowait(mf, a_period);
     FillBoundary_finish(mf);
 }
 
 /** \brief Convenience overload that fills/syncs every component/ghost cell on each FabArray. */
-template <class MF>
-std::enable_if_t<IsFabArray<MF>::value>
-FillBoundaryAndSync (Vector<MF*> const& mf, const Periodicity& a_period = Periodicity::NonPeriodic())
+template <FabArrayType MF>
+void FillBoundaryAndSync (Vector<MF*> const& mf, const Periodicity& a_period = Periodicity::NonPeriodic())
 {
     FillBoundaryAndSync_nowait(mf, a_period);
     FillBoundaryAndSync_finish(mf);
diff --git a/Src/Base/AMReX_FabArrayUtility.H b/Src/Base/AMReX_FabArrayUtility.H
index b429e9c622c..614c2454912 100644
--- a/Src/Base/AMReX_FabArrayUtility.H
+++ b/Src/Base/AMReX_FabArrayUtility.H
@@ -10,8 +10,7 @@
 
 namespace amrex {
 
-template <class FAB, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB, class F>
 typename FAB::value_type
 ReduceSum (FabArray<FAB> const& fa, int nghost, F&& f) {
     return ReduceSum(fa, IntVect(nghost), std::forward<F>(f));
@@ -19,8 +18,7 @@ ReduceSum (FabArray<FAB> const& fa, int nghost, F&& f) {
 
 /// \cond DOXYGEN_IGNORE
 namespace fudetail {
-template <class FAB, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB, class F>
 typename FAB::value_type
 ReduceSum_host (FabArray<FAB> const& fa, IntVect const& nghost, F const& f)
 {
@@ -45,11 +43,10 @@ ReduceSum_host (FabArray<FAB> const& fa, IntVect const& nghost, F const& f)
 #ifdef AMREX_USE_GPU
 /// \cond DOXYGEN_IGNORE
 namespace fudetail {
-template <class OP, class FAB, class F>
-std::enable_if_t<IsBaseFab<FAB>::value,
-                 std::conditional_t<std::is_same_v<OP,ReduceOpLogicalAnd> ||
-                                    std::is_same_v<OP,ReduceOpLogicalOr>,
-                                    int, typename FAB::value_type> >
+template <class OP, BaseFabType FAB, class F>
+std::conditional_t<std::is_same_v<OP,ReduceOpLogicalAnd> ||
+                   std::is_same_v<OP,ReduceOpLogicalOr>,
+                   int, typename FAB::value_type>
 ReduceMF (FabArray<FAB> const& fa, IntVect const& nghost, F const& f)
 {
     using T = std::conditional_t<std::is_same_v<OP,ReduceOpLogicalAnd> ||
@@ -64,11 +61,10 @@ ReduceMF (FabArray<FAB> const& fa, IntVect const& nghost, F const& f)
            });
 }
 
-template <class OP, class FAB1, class FAB2, class F>
-std::enable_if_t<IsBaseFab<FAB1>::value && IsBaseFab<FAB2>::value,
-                 std::conditional_t<std::is_same_v<OP,ReduceOpLogicalAnd> ||
-                                    std::is_same_v<OP,ReduceOpLogicalOr>,
-                                    int, typename FAB1::value_type> >
+template <class OP, BaseFabType FAB1, BaseFabType FAB2, class F>
+std::conditional_t<std::is_same_v<OP,ReduceOpLogicalAnd> ||
+                   std::is_same_v<OP,ReduceOpLogicalOr>,
+                   int, typename FAB1::value_type>
 ReduceMF (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2, IntVect const& nghost, F const& f)
 {
     using T = std::conditional_t<std::is_same_v<OP,ReduceOpLogicalAnd> ||
@@ -85,11 +81,10 @@ ReduceMF (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2, IntVect const& n
            });
 }
 
-template <class OP, class FAB1, class FAB2, class FAB3, class F>
-std::enable_if_t<IsBaseFab<FAB1>::value && IsBaseFab<FAB2>::value && IsBaseFab<FAB3>::value,
-                 std::conditional_t<std::is_same_v<OP,ReduceOpLogicalAnd> ||
-                                    std::is_same_v<OP,ReduceOpLogicalOr>,
-                                    int, typename FAB1::value_type> >
+template <class OP, BaseFabType FAB1, BaseFabType FAB2, BaseFabType FAB3, class F>
+std::conditional_t<std::is_same_v<OP,ReduceOpLogicalAnd> ||
+                   std::is_same_v<OP,ReduceOpLogicalOr>,
+                   int, typename FAB1::value_type>
 ReduceMF (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
           FabArray<FAB3> const& fa3, IntVect const& nghost, F const& f)
 {
@@ -126,8 +121,7 @@ ReduceSum_host_wrapper (FabArray<FAB> const& fa, IntVect const& nghost, F&& f)
 }
 /// \endcond
 
-template <class FAB, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB, class F>
 typename FAB::value_type
 ReduceSum (FabArray<FAB> const& fa, IntVect const& nghost, F&& f)
 {
@@ -138,8 +132,7 @@ ReduceSum (FabArray<FAB> const& fa, IntVect const& nghost, F&& f)
     }
 }
 #else
-template <class FAB, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB, class F>
 typename FAB::value_type
 ReduceSum (FabArray<FAB> const& fa, IntVect const& nghost, F&& f)
 {
@@ -147,8 +140,7 @@ ReduceSum (FabArray<FAB> const& fa, IntVect const& nghost, F&& f)
 }
 #endif
 
-template <class FAB1, class FAB2, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB1>::value> >
+template <BaseFabType FAB1, class FAB2, class F>
 typename FAB1::value_type
 ReduceSum (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
            int nghost, F&& f) {
@@ -157,8 +149,7 @@ ReduceSum (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
 
 /// \cond DOXYGEN_IGNORE
 namespace fudetail {
-template <class FAB1, class FAB2, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB1>::value> >
+template <BaseFabType FAB1, class FAB2, class F>
 typename FAB1::value_type
 ReduceSum_host (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
                 IntVect const& nghost, F const& f)
@@ -205,8 +196,7 @@ ReduceSum_host_wrapper (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
 }
 /// \endcond
 
-template <class FAB1, class FAB2, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB1>::value> >
+template <BaseFabType FAB1, class FAB2, class F>
 typename FAB1::value_type
 ReduceSum (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
            IntVect const& nghost, F&& f)
@@ -218,8 +208,7 @@ ReduceSum (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
     }
 }
 #else
-template <class FAB1, class FAB2, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB1>::value> >
+template <BaseFabType FAB1, class FAB2, class F>
 typename FAB1::value_type
 ReduceSum (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
            IntVect const& nghost, F&& f)
@@ -228,8 +217,7 @@ ReduceSum (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
 }
 #endif
 
-template <class FAB1, class FAB2, class FAB3, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB1>::value> >
+template <BaseFabType FAB1, class FAB2, class FAB3, class F>
 typename FAB1::value_type
 ReduceSum (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2, FabArray<FAB3> const& fa3,
            int nghost, F&& f)
@@ -239,8 +227,7 @@ ReduceSum (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2, FabArray<FAB3>
 
 /// \cond DOXYGEN_IGNORE
 namespace fudetail {
-template <class FAB1, class FAB2, class FAB3, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB1>::value> >
+template <BaseFabType FAB1, class FAB2, class FAB3, class F>
 typename FAB1::value_type
 ReduceSum_host (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
                 FabArray<FAB3> const& fa3, IntVect const& nghost, F const& f)
@@ -288,8 +275,7 @@ ReduceSum_host_wrapper (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
 }
 /// \endcond
 
-template <class FAB1, class FAB2, class FAB3, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB1>::value> >
+template <BaseFabType FAB1, class FAB2, class FAB3, class F>
 typename FAB1::value_type
 ReduceSum (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
            FabArray<FAB3> const& fa3, IntVect const& nghost, F&& f)
@@ -301,8 +287,7 @@ ReduceSum (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
     }
 }
 #else
-template <class FAB1, class FAB2, class FAB3, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB1>::value> >
+template <BaseFabType FAB1, class FAB2, class FAB3, class F>
 typename FAB1::value_type
 ReduceSum (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
            FabArray<FAB3> const& fa3, IntVect const& nghost, F&& f)
@@ -311,8 +296,7 @@ ReduceSum (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
 }
 #endif
 
-template <class FAB, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB, class F>
 typename FAB::value_type
 ReduceMin (FabArray<FAB> const& fa, int nghost, F&& f)
 {
@@ -321,8 +305,7 @@ ReduceMin (FabArray<FAB> const& fa, int nghost, F&& f)
 
 /// \cond DOXYGEN_IGNORE
 namespace fudetail {
-template <class FAB, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB, class F>
 typename FAB::value_type
 ReduceMin_host (FabArray<FAB> const& fa, IntVect const& nghost, F const& f)
 {
@@ -364,8 +347,7 @@ ReduceMin_host_wrapper (FabArray<FAB> const& fa, IntVect const& nghost, F&& f)
 }
 /// \endcond
 
-template <class FAB, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB, class F>
 typename FAB::value_type
 ReduceMin (FabArray<FAB> const& fa, IntVect const& nghost, F&& f)
 {
@@ -376,8 +358,7 @@ ReduceMin (FabArray<FAB> const& fa, IntVect const& nghost, F&& f)
     }
 }
 #else
-template <class FAB, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB, class F>
 typename FAB::value_type
 ReduceMin (FabArray<FAB> const& fa, IntVect const& nghost, F&& f)
 {
@@ -385,8 +366,7 @@ ReduceMin (FabArray<FAB> const& fa, IntVect const& nghost, F&& f)
 }
 #endif
 
-template <class FAB1, class FAB2, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB1>::value> >
+template <BaseFabType FAB1, class FAB2, class F>
 typename FAB1::value_type
 ReduceMin (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2, int nghost, F&& f)
 {
@@ -395,8 +375,7 @@ ReduceMin (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2, int nghost, F&&
 
 /// \cond DOXYGEN_IGNORE
 namespace fudetail {
-template <class FAB1, class FAB2, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB1>::value> >
+template <BaseFabType FAB1, class FAB2, class F>
 typename FAB1::value_type
 ReduceMin_host (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
                 IntVect const& nghost, F const& f)
@@ -443,8 +422,7 @@ ReduceMin_host_wrapper (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
 }
 /// \endcond
 
-template <class FAB1, class FAB2, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB1>::value> >
+template <BaseFabType FAB1, class FAB2, class F>
 typename FAB1::value_type
 ReduceMin (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
            IntVect const& nghost, F&& f)
@@ -456,8 +434,7 @@ ReduceMin (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
     }
 }
 #else
-template <class FAB1, class FAB2, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB1>::value> >
+template <BaseFabType FAB1, class FAB2, class F>
 typename FAB1::value_type
 ReduceMin (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
            IntVect const& nghost, F&& f)
@@ -466,8 +443,7 @@ ReduceMin (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
 }
 #endif
 
-template <class FAB1, class FAB2, class FAB3, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB1>::value> >
+template <BaseFabType FAB1, class FAB2, class FAB3, class F>
 typename FAB1::value_type
 ReduceMin (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2, FabArray<FAB3> const& fa3,
            int nghost, F&& f)
@@ -477,8 +453,7 @@ ReduceMin (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2, FabArray<FAB3>
 
 /// \cond DOXYGEN_IGNORE
 namespace fudetail {
-template <class FAB1, class FAB2, class FAB3, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB1>::value> >
+template <BaseFabType FAB1, class FAB2, class FAB3, class F>
 typename FAB1::value_type
 ReduceMin_host (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
                 FabArray<FAB3> const& fa3, IntVect const& nghost, F const& f)
@@ -526,8 +501,7 @@ ReduceMin_host_wrapper (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
 }
 /// \endcond
 
-template <class FAB1, class FAB2, class FAB3, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB1>::value> >
+template <BaseFabType FAB1, class FAB2, class FAB3, class F>
 typename FAB1::value_type
 ReduceMin (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
            FabArray<FAB3> const& fa3, IntVect const& nghost, F&& f)
@@ -539,8 +513,7 @@ ReduceMin (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
     }
 }
 #else
-template <class FAB1, class FAB2, class FAB3, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB1>::value> >
+template <BaseFabType FAB1, class FAB2, class FAB3, class F>
 typename FAB1::value_type
 ReduceMin (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
            FabArray<FAB3> const& fa3, IntVect const& nghost, F&& f)
@@ -549,8 +522,7 @@ ReduceMin (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
 }
 #endif
 
-template <class FAB, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB, class F>
 typename FAB::value_type
 ReduceMax (FabArray<FAB> const& fa, int nghost, F&& f)
 {
@@ -559,8 +531,7 @@ ReduceMax (FabArray<FAB> const& fa, int nghost, F&& f)
 
 /// \cond DOXYGEN_IGNORE
 namespace fudetail {
-template <class FAB, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB, class F>
 typename FAB::value_type
 ReduceMax_host (FabArray<FAB> const& fa, IntVect const& nghost, F const& f)
 {
@@ -603,8 +574,7 @@ ReduceMax_host_wrapper (FabArray<FAB> const& fa, IntVect const& nghost, F&& f)
 }
 /// \endcond
 
-template <class FAB, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB, class F>
 typename FAB::value_type
 ReduceMax (FabArray<FAB> const& fa, IntVect const& nghost, F&& f)
 {
@@ -615,8 +585,7 @@ ReduceMax (FabArray<FAB> const& fa, IntVect const& nghost, F&& f)
     }
 }
 #else
-template <class FAB, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB, class F>
 typename FAB::value_type
 ReduceMax (FabArray<FAB> const& fa, IntVect const& nghost, F&& f)
 {
@@ -624,8 +593,7 @@ ReduceMax (FabArray<FAB> const& fa, IntVect const& nghost, F&& f)
 }
 #endif
 
-template <class FAB1, class FAB2, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB1>::value> >
+template <BaseFabType FAB1, class FAB2, class F>
 typename FAB1::value_type
 ReduceMax (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2, int nghost, F&& f)
 {
@@ -634,8 +602,7 @@ ReduceMax (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2, int nghost, F&&
 
 /// \cond DOXYGEN_IGNORE
 namespace fudetail {
-template <class FAB1, class FAB2, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB1>::value> >
+template <BaseFabType FAB1, class FAB2, class F>
 typename FAB1::value_type
 ReduceMax_host (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
                 IntVect const& nghost, F const& f)
@@ -682,8 +649,7 @@ ReduceMax_host_wrapper (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
 }
 /// \endcond
 
-template <class FAB1, class FAB2, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB1>::value> >
+template <BaseFabType FAB1, class FAB2, class F>
 typename FAB1::value_type
 ReduceMax (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
            IntVect const& nghost, F&& f)
@@ -695,8 +661,7 @@ ReduceMax (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
     }
 }
 #else
-template <class FAB1, class FAB2, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB1>::value> >
+template <BaseFabType FAB1, class FAB2, class F>
 typename FAB1::value_type
 ReduceMax (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
            IntVect const& nghost, F&& f)
@@ -705,8 +670,7 @@ ReduceMax (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
 }
 #endif
 
-template <class FAB1, class FAB2, class FAB3, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB1>::value> >
+template <BaseFabType FAB1, class FAB2, class FAB3, class F>
 typename FAB1::value_type
 ReduceMax (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2, FabArray<FAB3> const& fa3,
            int nghost, F&& f)
@@ -716,8 +680,7 @@ ReduceMax (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2, FabArray<FAB3>
 
 /// \cond DOXYGEN_IGNORE
 namespace fudetail {
-template <class FAB1, class FAB2, class FAB3, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB1>::value> >
+template <BaseFabType FAB1, class FAB2, class FAB3, class F>
 typename FAB1::value_type
 ReduceMax_host (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
                 FabArray<FAB3> const& fa3, IntVect const& nghost, F const& f)
@@ -765,8 +728,7 @@ ReduceMax_host_wrapper (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
 }
 /// \endcond
 
-template <class FAB1, class FAB2, class FAB3, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB1>::value> >
+template <BaseFabType FAB1, class FAB2, class FAB3, class F>
 typename FAB1::value_type
 ReduceMax (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
            FabArray<FAB3> const& fa3, IntVect const& nghost, F&& f)
@@ -778,8 +740,7 @@ ReduceMax (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
     }
 }
 #else
-template <class FAB1, class FAB2, class FAB3, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB1>::value> >
+template <BaseFabType FAB1, class FAB2, class FAB3, class F>
 typename FAB1::value_type
 ReduceMax (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
            FabArray<FAB3> const& fa3, IntVect const& nghost, F&& f)
@@ -788,8 +749,7 @@ ReduceMax (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
 }
 #endif
 
-template <class FAB, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB, class F>
 bool
 ReduceLogicalAnd (FabArray<FAB> const& fa, int nghost, F&& f)
 {
@@ -798,8 +758,7 @@ ReduceLogicalAnd (FabArray<FAB> const& fa, int nghost, F&& f)
 
 /// \cond DOXYGEN_IGNORE
 namespace fudetail {
-template <class FAB, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB, class F>
 bool
 ReduceLogicalAnd_host (FabArray<FAB> const& fa, IntVect const& nghost, F const& f)
 {
@@ -841,8 +800,7 @@ ReduceLogicalAnd_host_wrapper (FabArray<FAB> const& fa, IntVect const& nghost, F
 }
 /// \endcond
 
-template <class FAB, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB, class F>
 bool
 ReduceLogicalAnd (FabArray<FAB> const& fa, IntVect const& nghost, F&& f)
 {
@@ -853,8 +811,7 @@ ReduceLogicalAnd (FabArray<FAB> const& fa, IntVect const& nghost, F&& f)
     }
 }
 #else
-template <class FAB, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB, class F>
 bool
 ReduceLogicalAnd (FabArray<FAB> const& fa, IntVect const& nghost, F&& f)
 {
@@ -862,8 +819,7 @@ ReduceLogicalAnd (FabArray<FAB> const& fa, IntVect const& nghost, F&& f)
 }
 #endif
 
-template <class FAB1, class FAB2, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB1>::value> >
+template <BaseFabType FAB1, class FAB2, class F>
 bool
 ReduceLogicalAnd (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
                   int nghost, F&& f)
@@ -873,8 +829,7 @@ ReduceLogicalAnd (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
 
 /// \cond DOXYGEN_IGNORE
 namespace fudetail {
-template <class FAB1, class FAB2, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB1>::value> >
+template <BaseFabType FAB1, class FAB2, class F>
 bool
 ReduceLogicalAnd_host (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
                        IntVect const& nghost, F const& f)
@@ -920,8 +875,7 @@ ReduceLogicalAnd_host_wrapper (FabArray<FAB1> const& fa1, FabArray<FAB2> const&
 }
 /// \endcond
 
-template <class FAB1, class FAB2, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB1>::value> >
+template <BaseFabType FAB1, class FAB2, class F>
 bool
 ReduceLogicalAnd (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
                   IntVect const& nghost, F&& f)
@@ -933,8 +887,7 @@ ReduceLogicalAnd (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
     }
 }
 #else
-template <class FAB1, class FAB2, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB1>::value> >
+template <BaseFabType FAB1, class FAB2, class F>
 bool
 ReduceLogicalAnd (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
                   IntVect const& nghost, F&& f)
@@ -943,8 +896,7 @@ ReduceLogicalAnd (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
 }
 #endif
 
-template <class FAB, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB, class F>
 bool
 ReduceLogicalOr (FabArray<FAB> const& fa, int nghost, F&& f)
 {
@@ -953,8 +905,7 @@ ReduceLogicalOr (FabArray<FAB> const& fa, int nghost, F&& f)
 
 /// \cond DOXYGEN_IGNORE
 namespace fudetail {
-template <class FAB, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB, class F>
 bool
 ReduceLogicalOr_host (FabArray<FAB> const& fa, IntVect const& nghost, F const& f)
 {
@@ -996,8 +947,7 @@ ReduceLogicalOr_host (FabArray<FAB> const& fa, IntVect const& nghost, F&& /*f*/)
 }
 /// \endcond
 
-template <class FAB, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB, class F>
 bool
 ReduceLogicalOr (FabArray<FAB> const& fa, IntVect const& nghost, F&& f)
 {
@@ -1008,8 +958,7 @@ ReduceLogicalOr (FabArray<FAB> const& fa, IntVect const& nghost, F&& f)
     }
 }
 #else
-template <class FAB, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB, class F>
 bool
 ReduceLogicalOr (FabArray<FAB> const& fa, IntVect const& nghost, F&& f)
 {
@@ -1017,8 +966,7 @@ ReduceLogicalOr (FabArray<FAB> const& fa, IntVect const& nghost, F&& f)
 }
 #endif
 
-template <class FAB1, class FAB2, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB1>::value> >
+template <BaseFabType FAB1, class FAB2, class F>
 bool
 ReduceLogicalOr (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
                  int nghost, F&& f)
@@ -1028,8 +976,7 @@ ReduceLogicalOr (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
 
 /// \cond DOXYGEN_IGNORE
 namespace fudetail {
-template <class FAB1, class FAB2, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB1>::value> >
+template <BaseFabType FAB1, class FAB2, class F>
 bool
 ReduceLogicalOr_host (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
                       IntVect const& nghost, F const& f)
@@ -1075,8 +1022,7 @@ ReduceLogicalOr_host_wrapper (FabArray<FAB1> const& fa1, FabArray<FAB2> const& f
 }
 /// \endcond
 
-template <class FAB1, class FAB2, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB1>::value> >
+template <BaseFabType FAB1, class FAB2, class F>
 bool
 ReduceLogicalOr (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
                  IntVect const& nghost, F&& f)
@@ -1088,8 +1034,7 @@ ReduceLogicalOr (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
     }
 }
 #else
-template <class FAB1, class FAB2, class F,
-          class bar = std::enable_if_t<IsBaseFab<FAB1>::value> >
+template <BaseFabType FAB1, class FAB2, class F>
 bool
 ReduceLogicalOr (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
                  IntVect const& nghost, F&& f)
@@ -1098,7 +1043,7 @@ ReduceLogicalOr (FabArray<FAB1> const& fa1, FabArray<FAB2> const& fa2,
 }
 #endif
 
-template <class FAB, class bar = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB>
 void
 printCell (FabArray<FAB> const& mf, const IntVect& cell, int comp = -1,
            const IntVect& ng = IntVect::TheZeroVector())
@@ -1150,16 +1095,14 @@ printCell (FabArray<FAB> const& mf, const IntVect& cell, int comp = -1,
     }
 }
 
-template <class FAB,
-          class bar = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB>
 void
 Swap (FabArray<FAB>& dst, FabArray<FAB>& src, int srccomp, int dstcomp, int numcomp, int nghost)
 {
     Swap(dst,src,srccomp,dstcomp,numcomp,IntVect(nghost));
 }
 
-template <class FAB,
-          class bar = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB>
 void
 Swap (FabArray<FAB>& dst, FabArray<FAB>& src, int srccomp, int dstcomp, int numcomp, const IntVect& nghost)
 {
@@ -1217,16 +1160,14 @@ Swap (FabArray<FAB>& dst, FabArray<FAB>& src, int srccomp, int dstcomp, int numc
     }
 }
 
-template <class FAB,
-          class bar = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB>
 void
 Subtract (FabArray<FAB>& dst, FabArray<FAB> const& src, int srccomp, int dstcomp, int numcomp, int nghost)
 {
     Subtract(dst,src,srccomp,dstcomp,numcomp,IntVect(nghost));
 }
 
-template <class FAB,
-          class bar = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB>
 void
 Subtract (FabArray<FAB>& dst, FabArray<FAB> const& src, int srccomp, int dstcomp, int numcomp, const IntVect& nghost)
 {
@@ -1265,16 +1206,14 @@ Subtract (FabArray<FAB>& dst, FabArray<FAB> const& src, int srccomp, int dstcomp
 }
 
 
-template <class FAB,
-          class bar = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB>
 void
 Multiply (FabArray<FAB>& dst, FabArray<FAB> const& src, int srccomp, int dstcomp, int numcomp, int nghost)
 {
     Multiply(dst,src,srccomp,dstcomp,numcomp,IntVect(nghost));
 }
 
-template <class FAB,
-          class bar = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB>
 void
 Multiply (FabArray<FAB>& dst, FabArray<FAB> const& src, int srccomp, int dstcomp, int numcomp, const IntVect& nghost)
 {
@@ -1313,16 +1252,14 @@ Multiply (FabArray<FAB>& dst, FabArray<FAB> const& src, int srccomp, int dstcomp
 }
 
 
-template <class FAB,
-          class bar = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB>
 void
 Divide (FabArray<FAB>& dst, FabArray<FAB> const& src, int srccomp, int dstcomp, int numcomp, int nghost)
 {
     Divide(dst,src,srccomp,dstcomp,numcomp,IntVect(nghost));
 }
 
-template <class FAB,
-          class bar = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB>
 void
 Divide (FabArray<FAB>& dst, FabArray<FAB> const& src, int srccomp, int dstcomp, int numcomp, const IntVect& nghost)
 {
@@ -1360,16 +1297,14 @@ Divide (FabArray<FAB>& dst, FabArray<FAB> const& src, int srccomp, int dstcomp,
     }
 }
 
-template <class FAB,
-          class bar = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB>
 void
 Abs (FabArray<FAB>& fa, int icomp, int numcomp, int nghost)
 {
     Abs(fa,icomp,numcomp,IntVect(nghost));
 }
 
-template <class FAB,
-          class bar = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB>
 void
 Abs (FabArray<FAB>& fa, int icomp, int numcomp, const IntVect& nghost)
 {
@@ -1405,7 +1340,7 @@ Abs (FabArray<FAB>& fa, int icomp, int numcomp, const IntVect& nghost)
     }
 }
 
-template <class FAB, class bar = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB>
 void
 prefetchToHost (FabArray<FAB> const& fa, const bool synchronous = true)
 {
@@ -1420,7 +1355,7 @@ prefetchToHost (FabArray<FAB> const& fa, const bool synchronous = true)
 #endif
 }
 
-template <class FAB, class bar = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB>
 void
 prefetchToDevice (FabArray<FAB> const& fa, const bool synchronous = true)
 {
@@ -1436,8 +1371,7 @@ prefetchToDevice (FabArray<FAB> const& fa, const bool synchronous = true)
 }
 
 
-template <class FAB, class IFAB, class bar = std::enable_if_t<IsBaseFab<FAB>::value
-                                                               && IsBaseFab<IFAB>::value> >
+template <BaseFabType FAB, BaseFabType IFAB>
 void
 OverrideSync (FabArray<FAB> & fa, FabArray<IFAB> const& msk, const Periodicity& period)
 {
@@ -1448,8 +1382,7 @@ OverrideSync (FabArray<FAB> & fa, FabArray<IFAB> const& msk, const Periodicity&
 }
 
 
-template <class FAB, class IFAB, class bar = std::enable_if_t<IsBaseFab<FAB>::value
-                                                               && IsBaseFab<IFAB>::value> >
+template <BaseFabType FAB, BaseFabType IFAB>
 void
 OverrideSync_nowait (FabArray<FAB> & fa, FabArray<IFAB> const& msk, const Periodicity& period)
 {
@@ -1496,7 +1429,7 @@ OverrideSync_nowait (FabArray<FAB> & fa, FabArray<IFAB> const& msk, const Period
     fa.os_temp->ParallelCopy_nowait(fa, period, FabArrayBase::ADD);
 }
 
-template <class FAB, class bar = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB>
 void
 OverrideSync_finish (FabArray<FAB> & fa)
 {
@@ -1510,7 +1443,7 @@ OverrideSync_finish (FabArray<FAB> & fa)
     fa.os_temp.reset();
 }
 
-template <class FAB, class foo = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB>
 void
 dtoh_memcpy (FabArray<FAB>& dst, FabArray<FAB> const& src,
              int scomp, int dcomp, int ncomp)
@@ -1528,14 +1461,14 @@ dtoh_memcpy (FabArray<FAB>& dst, FabArray<FAB> const& src,
 #endif
 }
 
-template <class FAB, class foo = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB>
 void
 dtoh_memcpy (FabArray<FAB>& dst, FabArray<FAB> const& src)
 {
     dtoh_memcpy(dst, src, 0, 0, dst.nComp());
 }
 
-template <class FAB, class foo = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB>
 void
 htod_memcpy (FabArray<FAB>& dst, FabArray<FAB> const& src,
              int scomp, int dcomp, int ncomp)
@@ -1553,14 +1486,14 @@ htod_memcpy (FabArray<FAB>& dst, FabArray<FAB> const& src,
 #endif
 }
 
-template <class FAB, class foo = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB>
 void
 htod_memcpy (FabArray<FAB>& dst, FabArray<FAB> const& src)
 {
     htod_memcpy(dst, src, 0, 0, dst.nComp());
 }
 
-template <class FAB, class foo = std::enable_if_t<IsBaseFab<FAB>::value> >
+template <BaseFabType FAB>
 IntVect
 indexFromValue (FabArray<FAB> const& mf, int comp, IntVect const& nghost,
                 typename FAB::value_type value)
@@ -1668,7 +1601,7 @@ indexFromValue (FabArray<FAB> const& mf, int comp, IntVect const& nghost,
  * \param nghost number of ghost cells
  * \param local  If true, MPI communication is skipped.
  */
-template <typename FAB, std::enable_if_t<IsBaseFab<FAB>::value,int> FOO = 0>
+template <BaseFabType FAB>
 typename FAB::value_type
 Dot (FabArray<FAB> const& x, int xcomp, FabArray<FAB> const& y, int ycomp, int ncomp,
      IntVect const& nghost, bool local = false)
@@ -1730,7 +1663,7 @@ Dot (FabArray<FAB> const& x, int xcomp, FabArray<FAB> const& y, int ycomp, int n
  * \param nghost number of ghost cells
  * \param local  If true, MPI communication is skipped.
  */
-template <typename FAB, std::enable_if_t<IsBaseFab<FAB>::value,int> FOO = 0>
+template <BaseFabType FAB>
 typename FAB::value_type
 Dot (FabArray<FAB> const& x, int xcomp, int ncomp, IntVect const& nghost, bool local = false)
 {
@@ -1791,8 +1724,7 @@ Dot (FabArray<FAB> const& x, int xcomp, int ncomp, IntVect const& nghost, bool l
  * \param nghost number of ghost cells
  * \param local  If true, MPI communication is skipped.
  */
-template <typename IFAB, typename FAB,
-          std::enable_if_t<IsBaseFab<FAB>::value && IsBaseFab<IFAB>::value,int> FOO = 0>
+template <BaseFabType IFAB, BaseFabType FAB>
 typename FAB::value_type
 Dot (FabArray<IFAB> const& mask, FabArray<FAB> const& x, int xcomp,
      FabArray<FAB> const& y, int ycomp, int ncomp, IntVect const& nghost,
@@ -1863,8 +1795,7 @@ Dot (FabArray<IFAB> const& mask, FabArray<FAB> const& x, int xcomp,
  * \param nghost number of ghost cells
  * \param local  If true, MPI communication is skipped.
  */
-template <typename IFAB, typename FAB,
-          std::enable_if_t<IsBaseFab<FAB>::value && IsBaseFab<IFAB>::value,int> FOO = 0>
+template <BaseFabType IFAB, BaseFabType FAB>
 typename FAB::value_type
 Dot (FabArray<IFAB> const& mask, FabArray<FAB> const& x, int xcomp, int ncomp,
      IntVect const& nghost, bool local = false)
diff --git a/Src/Base/CMakeLists.txt b/Src/Base/CMakeLists.txt
index c1fbf44a439..d6088bc7156 100644
--- a/Src/Base/CMakeLists.txt
+++ b/Src/Base/CMakeLists.txt
@@ -92,6 +92,7 @@ foreach(D IN LISTS AMReX_SPACEDIM)
        AMReX_NFiles.cpp
        AMReX_parstream.H
        AMReX_parstream.cpp
+       AMReX_Concepts.H
        # I/O stuff  --------------------------------------------------------------
        AMReX_ANSIEscCode.H
        AMReX_FabConv.H
diff --git a/Src/Base/Make.package b/Src/Base/Make.package
index 5ec492ce5a4..ab4fb34dca2 100644
--- a/Src/Base/Make.package
+++ b/Src/Base/Make.package
@@ -124,6 +124,9 @@ C$(AMREX_BASE)_headers += AMReX_CTOParallelForImpl.H
 
 C$(AMREX_BASE)_headers += AMReX_ParReduce.H
 
+C$(AMREX_BASE)_headers += AMReX_Concepts.H
+
+
 #
 # I/O stuff.
 #