From 69273cbf5c4380ac2dd5968c3084554a8b6ec4f1 Mon Sep 17 00:00:00 2001
From: Jonah Miller <jonahm@lanl.gov>
Date: Fri, 13 Oct 2023 16:05:17 -0600
Subject: [PATCH 01/20] Add Modify functionality. Still debugging.

---
 singularity-eos/base/variadic_utils.hpp |  28 ++++++-
 singularity-eos/eos/eos.hpp             |  16 ++--
 singularity-eos/eos/eos_builder.hpp     | 107 +++++++++++++++++++++++-
 test/compare_on_data.cpp                |   7 +-
 test/test_eos_modifiers.cpp             |  39 +++++----
 5 files changed, 162 insertions(+), 35 deletions(-)

diff --git a/singularity-eos/base/variadic_utils.hpp b/singularity-eos/base/variadic_utils.hpp
index 2d1aa9f7de..2099f3e4b4 100644
--- a/singularity-eos/base/variadic_utils.hpp
+++ b/singularity-eos/base/variadic_utils.hpp
@@ -18,7 +18,31 @@
 #include <type_traits>
 
 namespace singularity {
-namespace detail {
+namespace types {
+
+// Some generic variatic utilities
+// ======================================================================
+
+// Backport of C++17 bool_constant.
+// With C++17, can be replaced with
+// using std::bool_constant
+template <bool B>
+using bool_constant = std::integral_constant<bool, B>;
+
+// Implementation of std::conjunction/std::disjunction without C++17
+// With C++17, can be replaced with
+// using std::disjunction
+template<bool...> struct bool_pack{};
+template<bool... Bs>
+using conjunction = std::is_same<bool_pack<true,Bs...>, bool_pack<Bs..., true>>;
+template<bool... Bs>
+struct disjunction : bool_constant<!conjunction<!Bs...>::value>{};
+
+// Checks if T is contained in the pack Ts
+template<typename T, typename... Ts>
+constexpr bool contains_v(){ 
+  return disjunction<std::is_same<T, Ts>::value...>::value;
+}
 
 // variadic list
 template <typename... Ts>
@@ -156,7 +180,7 @@ constexpr auto pack_size(type_list<Ts...>) {
   return sizeof...(Ts);
 }
 
-} // namespace detail
+} // namespace types
 } // namespace singularity
 
 #endif // SINGULARITY_EOS_BASE_VARIADIC_UTILS_HPP_
diff --git a/singularity-eos/eos/eos.hpp b/singularity-eos/eos/eos.hpp
index 82dc1743d8..81b692fa96 100644
--- a/singularity-eos/eos/eos.hpp
+++ b/singularity-eos/eos/eos.hpp
@@ -57,13 +57,13 @@ namespace singularity {
 
 // recreate variadic list
 template <typename... Ts>
-using tl = singularity::detail::type_list<Ts...>;
+using tl = singularity::types::type_list<Ts...>;
 
 template <template <typename> class... Ts>
-using al = singularity::detail::adapt_list<Ts...>;
+using al = singularity::types::adapt_list<Ts...>;
 
 // transform variadic list: applies modifiers to eos's
-using singularity::detail::transform_variadic_list;
+using singularity::types::transform_variadic_list;
 
 // all eos's
 static constexpr const auto full_eos_list =
@@ -117,13 +117,13 @@ static constexpr const auto scaled_1 =
     transform_variadic_list(full_eos_list, al<ScaledEOS>{});
 // relativistic and unit system modifiers
 static constexpr const auto unit_or_rel =
-    singularity::detail::concat(unit_system, relativistic);
+    singularity::types::concat(unit_system, relativistic);
 // variadic list of eos with shifted, relativistic or unit system modifiers
 static constexpr const auto shifted_of_unit_or_rel =
     transform_variadic_list(unit_or_rel, al<ShiftedEOS>{});
 // combined list of all shifted EOS
 static constexpr const auto shifted =
-    singularity::detail::concat(shifted_1, shifted_of_unit_or_rel);
+    singularity::types::concat(shifted_1, shifted_of_unit_or_rel);
 // variadic list of eos with scaled, relativistic or unit system modifiers
 static constexpr const auto scaled_of_unit_or_rel =
     transform_variadic_list(unit_or_rel, al<ScaledEOS>{});
@@ -132,16 +132,16 @@ static constexpr const auto scaled_of_shifted =
     transform_variadic_list(shifted, al<ScaledEOS>{});
 // combined list of all scaled EOS
 static constexpr const auto scaled =
-    singularity::detail::concat(scaled_1, scaled_of_unit_or_rel, scaled_of_shifted);
+    singularity::types::concat(scaled_1, scaled_of_unit_or_rel, scaled_of_shifted);
 // create combined list
 static constexpr const auto combined_list_1 =
-    singularity::detail::concat(full_eos_list, shifted, scaled, unit_or_rel);
+    singularity::types::concat(full_eos_list, shifted, scaled, unit_or_rel);
 // make a ramped eos of everything
 static constexpr const auto ramped_all =
     transform_variadic_list(combined_list_1, al<BilinearRampEOS>{});
 // final combined list
 static constexpr const auto combined_list =
-    singularity::detail::concat(combined_list_1, ramped_all);
+    singularity::types::concat(combined_list_1, ramped_all);
 // a function that returns a Variant from a typelist
 template <typename... Ts>
 struct tl_to_Variant_struct {
diff --git a/singularity-eos/eos/eos_builder.hpp b/singularity-eos/eos/eos_builder.hpp
index 8f094d934d..2fa4246c8e 100644
--- a/singularity-eos/eos/eos_builder.hpp
+++ b/singularity-eos/eos/eos_builder.hpp
@@ -22,10 +22,113 @@
 #include <string>
 #include <unordered_set>
 
-namespace singularity {
+// Actually all we need
+#include <utility>
+#include <singularity-eos/base/variadic_utils.hpp>
+#include <singularity-eos/eos/eos_variant.hpp>
 
+namespace singularity {
 namespace EOSBuilder {
 
+// Just import the variadic utils namespace int the EOSBuilder
+// namespace.
+using namespace types;
+
+// Recursive functions needed for the Modify function JMM: Note this
+// machinery would be a LOT easier in C++17, with constexpr if.  To
+// mimic constexpr if, I use tag dispatch here. I need two separate
+// functions to make it work, however.
+namespace detail {
+
+// Prototypes
+template <template <class...> typename Mod, typename U, typename... Rest, typename... Ts,
+          typename... Args>
+Variant<Ts...> ModifyHelper(std::true_type, const Variant<Ts...> &var,
+                      const type_list<U, Rest...> &tl, Args &&... args);
+template <template <class...> typename Mod, typename U, typename... Rest, typename... Ts,
+          typename... Args>
+Variant<Ts...> ModifyHelper(std::false_type, const Variant<Ts...> &var,
+                      const type_list<U, Rest...> &tl, Args &&... args);
+
+// Base case
+template <template <class...> typename Mod, typename... Ts, typename... Args>
+Variant<Ts...> ModifyDispatcher(const Variant<Ts...> &var, const type_list<> &tl,
+                                Args &&... args) {
+  return var;
+}
+
+// The ModifyDispatcher function specifies which tag in tag dispatch
+// to use. It's main purpose is to check whether or not U and Mod<U>
+// are in the type list for the variant. If yes, it dispatches to the
+// ModifyHelper<Mod>(yes,...) method, otherwise, the
+// ModifyHelper<Mod>(no,...)  method.
+template <template <class...> typename Mod, typename U, typename... Rest, typename... Ts,
+          typename... Args>
+Variant<Ts...> ModifyDispatcher(const Variant<Ts...> &var,
+                                const type_list<U, Rest...> &tl, Args &&... args) {
+  constexpr bool type_in_variant =
+      (contains_v<U, Ts...>() && contains_v<Mod<U>, Ts...>());
+  return ModifyHelper<Mod>(bool_constant<type_in_variant>(), var, tl,
+			   std::forward<Args>(args)...);
+}
+
+// The ModifyHelper function recursively walks through all types in the
+// typelist tl. For each type in tl, it checks if the type is (a) in
+// the variant typelist, and (b) currently held by the variant
+// object. If both (a) and (b) are true, it returns a new variant
+// containing Mod<u>. Otherwise, it moves to the next type.
+template <template <class...> typename Mod, typename U, typename... Rest, typename... Ts,
+          typename... Args>
+Variant<Ts...> ModifyHelper(std::true_type, const Variant<Ts...> &var,
+			    const type_list<U, Rest...> &tl, Args &&... args) {
+  bool contains_u = var.template IsType<U>();
+  if (contains_u) {
+    return Variant<Ts...>(Mod<U>(var.template get<U>(), std::forward<Args>(args)...));
+  } else {
+    type_list<Rest...> tl_new{};
+    return ModifyDispatcher<Mod>(var, tl_new, std::forward<Args>(args)...);
+  }
+}
+template <template <class...> typename Mod, typename U, typename... Rest, typename... Ts,
+          typename... Args>
+Variant<Ts...> ModifyHelper(std::false_type, const Variant<Ts...> &var,
+                            const type_list<U, Rest...> &tl, Args &&... args) {
+  type_list<Rest...> tl_new{};
+  return ModifyDispatcher<Mod>(var, tl_new, std::forward<Args>(args)...);
+}
+template <template <class...> typename Mod, typename U, typename... Rest, typename... Ts,
+          typename... Args>
+Variant<Ts...> ModifyHelper(const Variant<Ts...> &var, const type_list<U, Rest...> &tl,
+                      Args &&... args) {
+  return detail::ModifyDispatcher<Mod>(var, tl, std::forward<Args>(args)...);
+}
+} // namespace detail
+
+// Modifies the eos contained in the var object with the modifier Mod,
+// assuming such modification is possible, i.e., Mod<T> is in the
+// variant, for the underlying type T. If this modification is not
+// possible, returns the unmodified EOS. Args are the additional
+// arguments to the modifier's constructor.
+// Intended usage:
+//
+// eos = Modify<Modifier>(eos, args);
+//
+// For example:
+//
+// EOS eos = IdealGas(gm1, Cv);
+// if (shifted) {
+//   eos = Modify<ShifteEOS>(eos, shift);
+// }
+// Note that this is potentially a pretty expensive operation,
+// as it must walk through the entire variant, both at compile, and run-time.
+// However, it is also extremely flexible, enabling user-selected variants
+// with minimal boiler plate.
+template<template <class...> typename Mod, typename... Ts, typename...Args>
+Variant<Ts...> Modify(const Variant<Ts...> &var, Args&&... args) {
+  type_list<Ts...> tl;
+  return detail::ModifyDispatcher<Mod>(var, tl, std::forward<Args>(args)...);
+}
+
 // TODO(JMM): This could be strings? Or at least use a macro so we
 // only have to write these down once?
 // strings might allow us to create these structrs more easily
@@ -136,8 +239,8 @@ EOS applyShiftAndScaleAndBilinearRamp(T &&eos, bool scaled, bool shifted, bool r
     return applyShiftAndScale(std::forward<T>(eos), scaled, shifted, scale, shift);
   }
 }
-} // namespace EOSBuilder
 
+} // namespace EOSBuilder
 } // namespace singularity
 
 #endif // _SINGULARITY_EOS_EOS_EOS_BUILDER_HPP_
diff --git a/test/compare_on_data.cpp b/test/compare_on_data.cpp
index 3d7506532e..ef35bd58be 100644
--- a/test/compare_on_data.cpp
+++ b/test/compare_on_data.cpp
@@ -212,15 +212,10 @@ void load_eos_spiner(const std::string &filename, const std::vector<int> &matids
                      std::vector<EOS> &eos_h, std::vector<EOS> &eos_d) {
   eos_h.clear();
   eos_d.clear();
-  EOSBuilder::EOSType type = EOSBuilder::EOSType::SpinerEOSDependsRhoT;
-  EOSBuilder::params_t params;
-  params["filename"] = filename;
-  params["reproducibility_mode"] = false;
 
   for (int matid : matids) {
     if (matid > 0) { // non-analytic
-      params["matid"] = matid;
-      eos_h.push_back(EOSBuilder::buildEOS(type, params));
+      eos_h.push_back(SpinerEOSDependsRhoT(filename, matid))
       eos_d.push_back(eos_h.back().GetOnDevice());
     }
   }
diff --git a/test/test_eos_modifiers.cpp b/test/test_eos_modifiers.cpp
index 2c6f9f3d29..3387d96ca5 100644
--- a/test/test_eos_modifiers.cpp
+++ b/test/test_eos_modifiers.cpp
@@ -35,6 +35,7 @@ using singularity::ShiftedEOS;
 
 namespace EOSBuilder = singularity::EOSBuilder;
 namespace thermalqs = singularity::thermalqs;
+using EOSBuilder::Modify;
 
 SCENARIO("EOS Builder and Modifiers", "[EOSBuilder][Modifiers][IdealGas]") {
 
@@ -63,32 +64,36 @@ SCENARIO("EOS Builder and Modifiers", "[EOSBuilder][Modifiers][IdealGas]") {
       }
     }
     WHEN("We use the EOSBuilder") {
-      EOSBuilder::EOSType type = EOSBuilder::EOSType::IdealGas;
-      EOSBuilder::modifiers_t modifiers;
-      EOSBuilder::params_t base_params, shifted_params, scaled_params;
-      base_params["Cv"].emplace<Real>(Cv);
-      base_params["gm1"].emplace<Real>(gm1);
-      shifted_params["shift"].emplace<Real>(shift);
-      scaled_params["scale"].emplace<Real>(scale);
-      modifiers[EOSBuilder::EOSModifier::Shifted] = shifted_params;
-      modifiers[EOSBuilder::EOSModifier::Scaled] = scaled_params;
-      EOS eos = EOSBuilder::buildEOS(type, base_params, modifiers);
+      // EOSBuilder::EOSType type = EOSBuilder::EOSType::IdealGas;
+      // EOSBuilder::modifiers_t modifiers;
+      // EOSBuilder::params_t base_params, shifted_params, scaled_params;
+      // base_params["Cv"].emplace<Real>(Cv);
+      // base_params["gm1"].emplace<Real>(gm1);
+      // shifted_params["shift"].emplace<Real>(shift);
+      // scaled_params["scale"].emplace<Real>(scale);
+      // modifiers[EOSBuilder::EOSModifier::Shifted] = shifted_params;
+      // modifiers[EOSBuilder::EOSModifier::Scaled] = scaled_params;
+      // EOS eos = EOSBuilder::buildEOS(type, base_params, modifiers);
+      EOS eos = IdealGas(gm1, Cv);
+      eos = Modify<ShiftedEOS>(eos, shift);
+      eos = Modify<ScaledEOS>(eos, scale);
       THEN("The shift and scale parameters pass through correctly") {
         REQUIRE(eos.PressureFromDensityInternalEnergy(rho, sie) == 0.3);
       }
       WHEN("We add a ramp") {
-        EOSBuilder::params_t ramp_params;
+        //EOSBuilder::params_t ramp_params;
         Real r0 = 1;
         Real a = 1;
         Real b = 0;
         Real c = 0;
-        ramp_params["r0"].emplace<Real>(r0);
-        ramp_params["a"].emplace<Real>(a);
-        ramp_params["b"].emplace<Real>(b);
-        ramp_params["c"].emplace<Real>(c);
-        modifiers[EOSBuilder::EOSModifier::BilinearRamp] = ramp_params;
+        //ramp_params["r0"].emplace<Real>(r0);
+        //ramp_params["a"].emplace<Real>(a);
+        //ramp_params["b"].emplace<Real>(b);
+        //ramp_params["c"].emplace<Real>(c);
+        //modifiers[EOSBuilder::EOSModifier::BilinearRamp] = ramp_params;
         THEN("The EOS is constructed correctly") {
-          auto eos_ramped = EOSBuilder::buildEOS(type, base_params, modifiers);
+          auto eos_ramped = Modify<BilinearRampEOS>(eos, r0, a, b, c);
+	  //EOSBuilder::buildEOS(type, base_params, modifiers);
         }
       }
     }

From 9fd225e4d7ad8e22b49caf02a8756f3da2e28c44 Mon Sep 17 00:00:00 2001
From: Jonah Miller <jonahm@lanl.gov>
Date: Fri, 13 Oct 2023 17:04:31 -0600
Subject: [PATCH 02/20] IT WORKS

---
 singularity-eos/base/variadic_utils.hpp |  15 +-
 singularity-eos/eos/eos_builder.cpp     | 225 +-----------------------
 singularity-eos/eos/eos_builder.hpp     |  83 +++------
 singularity-eos/eos/eos_variant.hpp     |  11 +-
 test/compare_on_data.cpp                |   2 +-
 test/test_eos_modifiers.cpp             | 132 +++++++-------
 test/test_eos_stellar_collapse.cpp      |   3 +-
 test/test_eos_tabulated.cpp             |  54 +-----
 8 files changed, 115 insertions(+), 410 deletions(-)

diff --git a/singularity-eos/base/variadic_utils.hpp b/singularity-eos/base/variadic_utils.hpp
index 2099f3e4b4..38d8a7ee03 100644
--- a/singularity-eos/base/variadic_utils.hpp
+++ b/singularity-eos/base/variadic_utils.hpp
@@ -32,15 +32,16 @@ using bool_constant = std::integral_constant<bool, B>;
 // Implementation of std::conjunction/std::disjunction without C++17
 // With C++17, can be replaced with
 // using std::disjunction
-template<bool...> struct bool_pack{};
-template<bool... Bs>
-using conjunction = std::is_same<bool_pack<true,Bs...>, bool_pack<Bs..., true>>;
-template<bool... Bs>
-struct disjunction : bool_constant<!conjunction<!Bs...>::value>{};
+template <bool...>
+struct bool_pack {};
+template <bool... Bs>
+using conjunction = std::is_same<bool_pack<true, Bs...>, bool_pack<Bs..., true>>;
+template <bool... Bs>
+struct disjunction : bool_constant<!conjunction<!Bs...>::value> {};
 
 // Checks if T is contained in the pack Ts
-template<typename T, typename... Ts>
-constexpr bool contains_v(){ 
+template <typename T, typename... Ts>
+constexpr bool contains_v() {
   return disjunction<std::is_same<T, Ts>::value...>::value;
 }
 
diff --git a/singularity-eos/eos/eos_builder.cpp b/singularity-eos/eos/eos_builder.cpp
index 60bd649fc8..d2e67a5b0e 100644
--- a/singularity-eos/eos/eos_builder.cpp
+++ b/singularity-eos/eos/eos_builder.cpp
@@ -15,227 +15,4 @@
 #include <iostream> // debug
 #include <singularity-eos/eos/eos_builder.hpp>
 
-#define GETBASE(T, N) T N = mpark::get<T>(base_params[#N])
-
-namespace singularity {
-
-EOS EOSBuilder::buildEOS(EOSBuilder::EOSType type, EOSBuilder::params_t base_params,
-                         EOSBuilder::modifiers_t modifiers) {
-  using namespace EOSBuilder;
-  using std::string;
-  bool scaled = (modifiers.count(EOSModifier::Scaled) > 0);
-  bool shifted = (modifiers.count(EOSModifier::Shifted) > 0);
-  bool relativistic = (modifiers.count(EOSModifier::Relativistic) > 0);
-  bool units = (modifiers.count(EOSModifier::UnitSystem) > 0);
-  bool ramped = (modifiers.count(EOSModifier::BilinearRamp) > 0);
-  if ((shifted || scaled || relativistic || units || ramped) && !(isModifiable(type))) {
-    EOS_ERROR("Modifiers not supported for this EOS");
-  }
-  if (relativistic && (shifted || scaled || units)) {
-    EOS_ERROR("Relativistic modifier currently must be applied alone");
-  }
-  if (units && (shifted || scaled || relativistic)) {
-    EOS_ERROR("Unit System modifier currently must be applied alone");
-  }
-  Real scale = 1;
-  if (scaled) {
-    scale = mpark::get<Real>(modifiers[EOSModifier::Scaled]["scale"]);
-  }
-  Real shift = 0;
-  if (shifted) {
-    shift = mpark::get<Real>(modifiers[EOSModifier::Shifted]["shift"]);
-  }
-  Real cl = 2.99792458e8; // speed of light in cm/s
-  if (relativistic && (modifiers[EOSModifier::Relativistic].count("cl") > 0)) {
-    cl = mpark::get<Real>(modifiers[EOSModifier::Relativistic]["cl"]);
-  }
-  bool use_length_time = false;
-  if (units && (modifiers[EOSModifier::UnitSystem].count("use_length_time") > 0)) {
-    use_length_time =
-        mpark::get<bool>(modifiers[EOSModifier::UnitSystem]["use_length_time"]);
-  }
-  Real r0 = 0;
-  Real a = 1;
-  Real b = 0;
-  Real c = 0;
-  if (ramped) {
-    r0 = mpark::get<Real>(modifiers[EOSModifier::BilinearRamp]["r0"]);
-    a = mpark::get<Real>(modifiers[EOSModifier::BilinearRamp]["a"]);
-    b = mpark::get<Real>(modifiers[EOSModifier::BilinearRamp]["b"]);
-    c = mpark::get<Real>(modifiers[EOSModifier::BilinearRamp]["c"]);
-  }
-  Real rho_unit = 1;
-  Real sie_unit = 1;
-  Real temp_unit = 1;
-  Real time_unit = 1;
-  Real mass_unit = 1;
-  Real length_unit = 1;
-  if (units) {
-    if (use_length_time) {
-      if (modifiers[EOSModifier::UnitSystem].count("time_unit") > 0) {
-        time_unit = mpark::get<Real>(modifiers[EOSModifier::UnitSystem]["time_unit"]);
-      }
-      if (modifiers[EOSModifier::UnitSystem].count("mass_unit") > 0) {
-        mass_unit = mpark::get<Real>(modifiers[EOSModifier::UnitSystem]["mass_unit"]);
-      }
-      if (modifiers[EOSModifier::UnitSystem].count("length_unit") > 0) {
-        length_unit = mpark::get<Real>(modifiers[EOSModifier::UnitSystem]["length_unit"]);
-      }
-    } else {
-      if (modifiers[EOSModifier::UnitSystem].count("rho_unit") > 0) {
-        rho_unit = mpark::get<Real>(modifiers[EOSModifier::UnitSystem]["rho_unit"]);
-      }
-      if (modifiers[EOSModifier::UnitSystem].count("sie_unit") > 0) {
-        sie_unit = mpark::get<Real>(modifiers[EOSModifier::UnitSystem]["sie_unit"]);
-      }
-    }
-    if (modifiers[EOSModifier::UnitSystem].count("temp_unit") > 0) {
-      temp_unit = mpark::get<Real>(modifiers[EOSModifier::UnitSystem]["temp_unit"]);
-    }
-  }
-  if (type == EOSType::IdealGas) {
-    Real gm1 = mpark::get<Real>(base_params["gm1"]);
-    Real Cv = mpark::get<Real>(base_params["Cv"]);
-    IdealGas g(gm1, Cv);
-    if (units) {
-      return makeUnitSystem(std::move(g), use_length_time, rho_unit, sie_unit, temp_unit,
-                            time_unit, mass_unit, length_unit);
-    }
-    if (relativistic) {
-      return makeRelativistic(std::move(g), cl);
-    }
-    return applyShiftAndScaleAndBilinearRamp(std::move(g), scaled, shifted, ramped, scale,
-                                             shift, r0, a, b, c);
-  }
-#ifdef SINGULARITY_USE_SPINER_WITH_HDF5
-  if (type == EOSType::SpinerEOSDependsRhoT || type == EOSType::SpinerEOSDependsRhoSie) {
-    string filename = mpark::get<string>(base_params["filename"]);
-    bool reproducibility_mode = mpark::get<bool>(base_params["reproducibility_mode"]);
-    if (base_params.count("matid") > 0) {
-      int matid = mpark::get<int>(base_params["matid"]);
-      if (type == EOSType::SpinerEOSDependsRhoT) {
-        SpinerEOSDependsRhoT s(filename, matid, reproducibility_mode);
-        if (units) {
-          return makeUnitSystem(std::move(s), use_length_time, rho_unit, sie_unit,
-                                temp_unit, time_unit, mass_unit, length_unit);
-        }
-        if (relativistic) {
-          return makeRelativistic(std::move(s), cl);
-        }
-        return applyShiftAndScale(std::move(s), scaled, shifted, scale, shift);
-      } else {
-        SpinerEOSDependsRhoSie s(filename, matid, reproducibility_mode);
-        if (units) {
-          return makeUnitSystem(std::move(s), use_length_time, rho_unit, sie_unit,
-                                temp_unit, time_unit, mass_unit, length_unit);
-        }
-        if (relativistic) {
-          return makeRelativistic(std::move(s), cl);
-        }
-        return applyShiftAndScaleAndBilinearRamp(std::move(s), scaled, shifted, ramped,
-                                                 scale, shift, r0, a, b, c);
-      }
-    } else {
-      string materialName = mpark::get<string>(base_params["materialName"]);
-      if (type == EOSType::SpinerEOSDependsRhoT) {
-        SpinerEOSDependsRhoT s(filename, materialName, reproducibility_mode);
-        if (units) {
-          return makeUnitSystem(std::move(s), use_length_time, rho_unit, sie_unit,
-                                temp_unit, time_unit, mass_unit, length_unit);
-        }
-        if (relativistic) {
-          return makeRelativistic(std::move(s), cl);
-        }
-        return applyShiftAndScale(std::move(s), scaled, shifted, scale, shift);
-      } else {
-        SpinerEOSDependsRhoSie s(filename, materialName, reproducibility_mode);
-        if (units) {
-          return makeUnitSystem(std::move(s), use_length_time, rho_unit, sie_unit,
-                                temp_unit, time_unit, mass_unit, length_unit);
-        }
-        if (relativistic) {
-          return makeRelativistic(std::move(s), cl);
-        }
-        return applyShiftAndScaleAndBilinearRamp(std::move(s), scaled, shifted, ramped,
-                                                 scale, shift, r0, a, b, c);
-      }
-    }
-  }
-  if (type == EOSType::StellarCollapse) {
-    string filename = mpark::get<string>(base_params["filename"]);
-    bool use_sp5 = false;
-    if (base_params.count("use_sp5") > 0) {
-      use_sp5 = mpark::get<bool>(base_params["use_sp5"]);
-    }
-    bool filter_bmod = true;
-    if (base_params.count("filter_bmod") > 0) {
-      filter_bmod = mpark::get<bool>(base_params["filter_bmod"]);
-    }
-    StellarCollapse s(filename, use_sp5, filter_bmod);
-    if (units) {
-      return makeUnitSystem(std::move(s), use_length_time, rho_unit, sie_unit, temp_unit,
-                            time_unit, mass_unit, length_unit);
-    }
-    if (relativistic) {
-      return makeRelativistic(std::move(s), cl);
-    }
-    return applyShiftAndScaleAndBilinearRamp(std::move(s), scaled, shifted, ramped, scale,
-                                             shift, r0, a, b, c);
-  }
-#endif
-  if (type == EOSType::Gruneisen) {
-    Real C0 = mpark::get<Real>(base_params["C0"]);
-    Real s1 = mpark::get<Real>(base_params["s1"]);
-    Real s2 = mpark::get<Real>(base_params["s2"]);
-    Real s3 = mpark::get<Real>(base_params["s3"]);
-    Real G0 = mpark::get<Real>(base_params["G0"]);
-    Real b = mpark::get<Real>(base_params["b"]);
-    Real rho0 = mpark::get<Real>(base_params["rho0"]);
-    Real T0 = mpark::get<Real>(base_params["T0"]);
-    Real P0 = mpark::get<Real>(base_params["P0"]);
-    Real Cv = mpark::get<Real>(base_params["Cv"]);
-    return Gruneisen(C0, s1, s2, s3, G0, b, rho0, T0, P0, Cv);
-  }
-  if (type == EOSType::JWL) {
-    GETBASE(Real, A); // I got tired of writing this over and over
-    GETBASE(Real, B);
-    GETBASE(Real, R1);
-    GETBASE(Real, R2);
-    GETBASE(Real, w);
-    GETBASE(Real, rho0);
-    GETBASE(Real, Cv);
-    return JWL(A, B, R1, R2, w, rho0, Cv);
-  }
-  if (type == EOSType::DavisReactants) {
-    GETBASE(Real, rho0);
-    GETBASE(Real, e0);
-    GETBASE(Real, P0);
-    GETBASE(Real, T0);
-    GETBASE(Real, A);
-    GETBASE(Real, B);
-    GETBASE(Real, C);
-    GETBASE(Real, G0);
-    GETBASE(Real, Z);
-    GETBASE(Real, alpha);
-    GETBASE(Real, Cv0);
-    return DavisReactants(rho0, e0, P0, T0, A, B, C, G0, Z, alpha, Cv0);
-  }
-  if (type == EOSType::DavisProducts) {
-    GETBASE(Real, a);
-    GETBASE(Real, b);
-    GETBASE(Real, k);
-    GETBASE(Real, n);
-    GETBASE(Real, vc);
-    GETBASE(Real, pc);
-    GETBASE(Real, Cv);
-    GETBASE(Real, E0);
-    return DavisProducts(a, b, k, n, vc, pc, Cv, E0);
-  }
-  exit(1);
-}
-
-bool EOSBuilder::isModifiable(EOSBuilder::EOSType type) {
-  return EOSBuilder::modifiable.count(type) > 0;
-}
-
-} // namespace singularity
+namespace singularity {} // namespace singularity
diff --git a/singularity-eos/eos/eos_builder.hpp b/singularity-eos/eos/eos_builder.hpp
index 2fa4246c8e..046338cdfa 100644
--- a/singularity-eos/eos/eos_builder.hpp
+++ b/singularity-eos/eos/eos_builder.hpp
@@ -23,9 +23,9 @@
 #include <unordered_set>
 
 // Actually all we need
-#include <utility>
 #include <singularity-eos/base/variadic_utils.hpp>
 #include <singularity-eos/eos/eos_variant.hpp>
+#include <utility>
 
 namespace singularity {
 namespace EOSBuilder {
@@ -44,16 +44,16 @@ namespace detail {
 template <template <class...> typename Mod, typename U, typename... Rest, typename... Ts,
           typename... Args>
 Variant<Ts...> ModifyHelper(std::true_type, const Variant<Ts...> &var,
-                      const type_list<U, Rest...> &tl, Args &&... args);
+                            const type_list<U, Rest...> &tl, Args &&...args);
 template <template <class...> typename Mod, typename U, typename... Rest, typename... Ts,
           typename... Args>
 Variant<Ts...> ModifyHelper(std::false_type, const Variant<Ts...> &var,
-                      const type_list<U, Rest...> &tl, Args &&... args);
+                            const type_list<U, Rest...> &tl, Args &&...args);
 
 // Base case
 template <template <class...> typename Mod, typename... Ts, typename... Args>
 Variant<Ts...> ModifyDispatcher(const Variant<Ts...> &var, const type_list<> &tl,
-                                Args &&... args) {
+                                Args &&...args) {
   return var;
 }
 
@@ -65,11 +65,11 @@ Variant<Ts...> ModifyDispatcher(const Variant<Ts...> &var, const type_list<> &tl
 template <template <class...> typename Mod, typename U, typename... Rest, typename... Ts,
           typename... Args>
 Variant<Ts...> ModifyDispatcher(const Variant<Ts...> &var,
-                                const type_list<U, Rest...> &tl, Args &&... args) {
+                                const type_list<U, Rest...> &tl, Args &&...args) {
   constexpr bool type_in_variant =
       (contains_v<U, Ts...>() && contains_v<Mod<U>, Ts...>());
   return ModifyHelper<Mod>(bool_constant<type_in_variant>(), var, tl,
-			   std::forward<Args>(args)...);
+                           std::forward<Args>(args)...);
 }
 
 // The ModifyHelper function recursively walks through all types in the
@@ -80,7 +80,7 @@ Variant<Ts...> ModifyDispatcher(const Variant<Ts...> &var,
 template <template <class...> typename Mod, typename U, typename... Rest, typename... Ts,
           typename... Args>
 Variant<Ts...> ModifyHelper(std::true_type, const Variant<Ts...> &var,
-			    const type_list<U, Rest...> &tl, Args &&... args) {
+                            const type_list<U, Rest...> &tl, Args &&...args) {
   bool contains_u = var.template IsType<U>();
   if (contains_u) {
     return Variant<Ts...>(Mod<U>(var.template get<U>(), std::forward<Args>(args)...));
@@ -92,14 +92,14 @@ Variant<Ts...> ModifyHelper(std::true_type, const Variant<Ts...> &var,
 template <template <class...> typename Mod, typename U, typename... Rest, typename... Ts,
           typename... Args>
 Variant<Ts...> ModifyHelper(std::false_type, const Variant<Ts...> &var,
-                            const type_list<U, Rest...> &tl, Args &&... args) {
+                            const type_list<U, Rest...> &tl, Args &&...args) {
   type_list<Rest...> tl_new{};
   return ModifyDispatcher<Mod>(var, tl_new, std::forward<Args>(args)...);
 }
 template <template <class...> typename Mod, typename U, typename... Rest, typename... Ts,
           typename... Args>
 Variant<Ts...> ModifyHelper(const Variant<Ts...> &var, const type_list<U, Rest...> &tl,
-                      Args &&... args) {
+                            Args &&...args) {
   return detail::ModifyDispatcher<Mod>(var, tl, std::forward<Args>(args)...);
 }
 } // namespace detail
@@ -123,56 +123,15 @@ Variant<Ts...> ModifyHelper(const Variant<Ts...> &var, const type_list<U, Rest..
 // as it must walk through the entire variant, both at compile, and run-time.
 // However, it is also extremely flexible, enabling user-selected variants
 // with minimal boiler plate.
-template<template <class...> typename Mod, typename... Ts, typename...Args>
-Variant<Ts...> Modify(const Variant<Ts...> &var, Args&&... args) {
+template <template <class...> typename Mod, typename... Ts, typename... Args>
+Variant<Ts...> Modify(const Variant<Ts...> &var, Args &&...args) {
   type_list<Ts...> tl;
   return detail::ModifyDispatcher<Mod>(var, tl, std::forward<Args>(args)...);
 }
 
-// TODO(JMM): This could be strings? Or at least use a macro so we
-// only have to write these down once?
-// strings might allow us to create these structrs more easily
-// in the host code.
-enum class EOSType {
-  IdealGas,
-  Gruneisen,
-  JWL,
-  DavisReactants,
-  DavisProducts
-#ifdef SINGULARITY_USE_SPINER_WITH_HDF5
-  ,
-  SpinerEOSDependsRhoT,
-  SpinerEOSDependsRhoSie,
-  StellarCollapse
-#endif
-};
-enum class EOSModifier { Scaled, Shifted, Relativistic, UnitSystem, BilinearRamp };
-
-// evil type erasure
-using param_t = mpark::variant<bool, int, Real, std::string>;
-using params_t = std::map<std::string, param_t>;
-using modifiers_t = std::map<EOSModifier, params_t>;
-const params_t NO_PARAMS;
-
-// TODO: Extend if needed
-const std::unordered_set<EOSType> modifiable({EOSType::IdealGas
-#ifdef SINGULARITY_USE_SPINER_WITH_HDF5
-                                              ,
-                                              EOSType::SpinerEOSDependsRhoT,
-                                              EOSType::SpinerEOSDependsRhoSie,
-                                              EOSType::StellarCollapse
-#endif
-});
-bool isModifiable(EOSType t);
-EOS buildEOS(EOSType type, params_t base_params, modifiers_t modifiers);
-inline auto buildEOS(EOSType type, params_t base_params) {
-  modifiers_t modifiers;
-  return buildEOS(type, base_params, modifiers);
-}
-
 template <typename T>
-EOS makeUnitSystem(T &&eos, bool use_length_time, Real rho_unit, Real sie_unit,
-                   Real temp_unit, Real time_unit, Real mass_unit, Real length_unit) {
+auto makeUnitSystem(T &&eos, bool use_length_time, Real rho_unit, Real sie_unit,
+                    Real temp_unit, Real time_unit, Real mass_unit, Real length_unit) {
   if (use_length_time) {
     return UnitSystem<T>(std::move(eos), eos_units_init::length_time_units_init_tag,
                          time_unit, mass_unit, length_unit, temp_unit);
@@ -183,17 +142,17 @@ EOS makeUnitSystem(T &&eos, bool use_length_time, Real rho_unit, Real sie_unit,
 }
 
 template <typename T>
-EOS makeRelativistic(T &&eos, Real cl) {
+auto makeRelativistic(T &&eos, Real cl) {
   return RelativisticEOS<T>(std::move(eos), cl);
 }
 
 template <typename T>
-EOS makeBilinearRamp(T &&eos, Real r0, Real a, Real b, Real c) {
+auto makeBilinearRamp(T &&eos, Real r0, Real a, Real b, Real c) {
   return BilinearRampEOS<T>(std::forward<T>(eos), r0, a, b, c);
 }
 
 template <typename T>
-EOS applyShiftAndScale(T &&eos, bool scaled, bool shifted, Real scale, Real shift) {
+auto applyShiftAndScale(T &&eos, bool scaled, bool shifted, Real scale, Real shift) {
   if (shifted && scaled) {
     ShiftedEOS<T> a(std::forward<T>(eos), shift);
     ScaledEOS<ShiftedEOS<T>> b(std::move(a), scale);
@@ -209,8 +168,8 @@ EOS applyShiftAndScale(T &&eos, bool scaled, bool shifted, Real scale, Real shif
 }
 
 template <typename T, template <typename> class W, typename... ARGS>
-EOS applyWrappedShiftAndScale(T &&eos, bool scaled, bool shifted, Real scale, Real shift,
-                              ARGS... args) {
+auto applyWrappedShiftAndScale(T &&eos, bool scaled, bool shifted, Real scale, Real shift,
+                               ARGS... args) {
   if (shifted && scaled) {
     ShiftedEOS<T> a(std::forward<T>(eos), shift);
     ScaledEOS<ShiftedEOS<T>> b(std::move(a), scale);
@@ -229,9 +188,9 @@ EOS applyWrappedShiftAndScale(T &&eos, bool scaled, bool shifted, Real scale, Re
 }
 
 template <typename T>
-EOS applyShiftAndScaleAndBilinearRamp(T &&eos, bool scaled, bool shifted, bool ramped,
-                                      Real scale, Real shift, Real r0, Real a, Real b,
-                                      Real c) {
+auto applyShiftAndScaleAndBilinearRamp(T &&eos, bool scaled, bool shifted, bool ramped,
+                                       Real scale, Real shift, Real r0, Real a, Real b,
+                                       Real c) {
   if (ramped) {
     return applyWrappedShiftAndScale<T, BilinearRampEOS>(
         std::forward<T>(eos), scaled, shifted, scale, shift, r0, a, b, c);
diff --git a/singularity-eos/eos/eos_variant.hpp b/singularity-eos/eos/eos_variant.hpp
index 09b2e4b917..1a58e546e9 100644
--- a/singularity-eos/eos/eos_variant.hpp
+++ b/singularity-eos/eos/eos_variant.hpp
@@ -62,7 +62,7 @@ class Variant {
             typename std::enable_if<
                 !std::is_same<Variant, typename std::decay<EOSChoice>::type>::value,
                 bool>::type = true>
-  PORTABLE_INLINE_FUNCTION EOSChoice get() {
+  PORTABLE_INLINE_FUNCTION EOSChoice get() const {
     return mpark::get<EOSChoice>(eos_);
   }
 
@@ -935,12 +935,17 @@ class Variant {
 
   inline constexpr Variant GetUnmodifiedObject() {
     return mpark::visit(
-        [](auto &eos) { return eos_variant<EOSs...>(eos.GetUnmodifiedObject()); }, eos_);
+        [](auto &eos) -> eos_variant<EOSs...> {
+          return eos_variant<EOSs...>(eos.GetUnmodifiedObject());
+        },
+        eos_);
   }
 
   PORTABLE_INLINE_FUNCTION
   unsigned long PreferredInput() const noexcept {
-    return mpark::visit([](const auto &eos) { return eos.PreferredInput(); }, eos_);
+    return mpark::visit(
+        [](const auto &eos) -> eos_variant<EOSs...> { return eos.PreferredInput(); },
+        eos_);
   }
 
   PORTABLE_INLINE_FUNCTION
diff --git a/test/compare_on_data.cpp b/test/compare_on_data.cpp
index ef35bd58be..458cf599f8 100644
--- a/test/compare_on_data.cpp
+++ b/test/compare_on_data.cpp
@@ -216,7 +216,7 @@ void load_eos_spiner(const std::string &filename, const std::vector<int> &matids
   for (int matid : matids) {
     if (matid > 0) { // non-analytic
       eos_h.push_back(SpinerEOSDependsRhoT(filename, matid))
-      eos_d.push_back(eos_h.back().GetOnDevice());
+          eos_d.push_back(eos_h.back().GetOnDevice());
     }
   }
 }
diff --git a/test/test_eos_modifiers.cpp b/test/test_eos_modifiers.cpp
index 3387d96ca5..1e46ebee56 100644
--- a/test/test_eos_modifiers.cpp
+++ b/test/test_eos_modifiers.cpp
@@ -27,15 +27,71 @@
 
 #include <test/eos_unit_test_helpers.hpp>
 
+namespace eos_units_init = singularity::eos_units_init;
+
+namespace EOSBuilder = singularity::EOSBuilder;
+namespace thermalqs = singularity::thermalqs;
+
+using EOSBuilder::Modify;
 using singularity::BilinearRampEOS;
-using singularity::EOS;
 using singularity::IdealGas;
+using singularity::RelativisticEOS;
 using singularity::ScaledEOS;
 using singularity::ShiftedEOS;
+using singularity::UnitSystem;
 
-namespace EOSBuilder = singularity::EOSBuilder;
-namespace thermalqs = singularity::thermalqs;
-using EOSBuilder::Modify;
+// recreate variadic list
+template <typename... Ts>
+using tl = singularity::types::type_list<Ts...>;
+
+template <template <typename> class... Ts>
+using al = singularity::types::adapt_list<Ts...>;
+
+// transform variadic list: applies modifiers to eos's
+using singularity::types::transform_variadic_list;
+
+static constexpr const auto full_eos_list = tl<IdealGas>{};
+static constexpr const auto relativistic_eos_list = tl<IdealGas>{};
+static constexpr const auto unit_system_eos_list = tl<IdealGas>{};
+static constexpr const auto apply_to_all = al<ScaledEOS, ShiftedEOS>{};
+static constexpr const auto unit_system =
+    transform_variadic_list(unit_system_eos_list, al<UnitSystem>{});
+// variadic list of eos's with shifted or scaled modifiers
+static constexpr const auto shifted_1 =
+    transform_variadic_list(full_eos_list, al<ShiftedEOS>{});
+static constexpr const auto scaled_1 =
+    transform_variadic_list(full_eos_list, al<ScaledEOS>{});
+// variadic list of Relativistic<T>'s
+static constexpr const auto relativistic =
+    transform_variadic_list(relativistic_eos_list, al<RelativisticEOS>{});
+// relativistic and unit system modifiers
+static constexpr const auto unit_or_rel =
+    singularity::types::concat(unit_system, relativistic);
+// variadic list of eos with shifted, relativistic or unit system modifiers
+static constexpr const auto shifted_of_unit_or_rel =
+    transform_variadic_list(unit_or_rel, al<ShiftedEOS>{});
+// combined list of all shifted EOS
+static constexpr const auto shifted =
+    singularity::types::concat(shifted_1, shifted_of_unit_or_rel);
+// variadic list of eos with scaled, relativistic or unit system modifiers
+static constexpr const auto scaled_of_unit_or_rel =
+    transform_variadic_list(unit_or_rel, al<ScaledEOS>{});
+// variadic list of Scaled<Shifted<T>>'s
+static constexpr const auto scaled_of_shifted =
+    transform_variadic_list(shifted, al<ScaledEOS>{});
+// combined list of all scaled EOS
+static constexpr const auto scaled =
+    singularity::types::concat(scaled_1, scaled_of_unit_or_rel, scaled_of_shifted);
+// create combined list
+static constexpr const auto combined_list_1 =
+    singularity::types::concat(full_eos_list, shifted, scaled, unit_or_rel);
+// make a ramped eos of everything
+static constexpr const auto ramped_all =
+    transform_variadic_list(combined_list_1, al<BilinearRampEOS>{});
+// final combined list
+static constexpr const auto combined_list =
+    singularity::types::concat(combined_list_1, ramped_all);
+using EOS = typename decltype(singularity::tl_to_Variant(combined_list))::vt;
 
 SCENARIO("EOS Builder and Modifiers", "[EOSBuilder][Modifiers][IdealGas]") {
 
@@ -46,12 +102,11 @@ SCENARIO("EOS Builder and Modifiers", "[EOSBuilder][Modifiers][IdealGas]") {
     constexpr Real shift = 0.1;
     constexpr Real rho = 2.0;
     constexpr Real sie = 0.5;
-    WHEN("We construct a shifted, scaled IdealGas by hand") {
-      IdealGas a = IdealGas(gm1, Cv);
-      ShiftedEOS<IdealGas> b = ShiftedEOS<IdealGas>(std::move(a), shift);
-      EOS eos = ScaledEOS<ShiftedEOS<IdealGas>>(std::move(b), scale);
+    WHEN("We use the EOSBuilder") {
+      EOS eos = IdealGas(gm1, Cv);
+      eos = Modify<ShiftedEOS>(eos, shift);
+      eos = Modify<ScaledEOS>(eos, scale);
       THEN("The shift and scale parameters pass through correctly") {
-
         REQUIRE(eos.PressureFromDensityInternalEnergy(rho, sie) == 0.3);
       }
       THEN("We can UnmodifyOnce to get the shifted EOS object") {
@@ -62,38 +117,14 @@ SCENARIO("EOS Builder and Modifiers", "[EOSBuilder][Modifiers][IdealGas]") {
           REQUIRE(unmod.IsType<IdealGas>());
         }
       }
-    }
-    WHEN("We use the EOSBuilder") {
-      // EOSBuilder::EOSType type = EOSBuilder::EOSType::IdealGas;
-      // EOSBuilder::modifiers_t modifiers;
-      // EOSBuilder::params_t base_params, shifted_params, scaled_params;
-      // base_params["Cv"].emplace<Real>(Cv);
-      // base_params["gm1"].emplace<Real>(gm1);
-      // shifted_params["shift"].emplace<Real>(shift);
-      // scaled_params["scale"].emplace<Real>(scale);
-      // modifiers[EOSBuilder::EOSModifier::Shifted] = shifted_params;
-      // modifiers[EOSBuilder::EOSModifier::Scaled] = scaled_params;
-      // EOS eos = EOSBuilder::buildEOS(type, base_params, modifiers);
-      EOS eos = IdealGas(gm1, Cv);
-      eos = Modify<ShiftedEOS>(eos, shift);
-      eos = Modify<ScaledEOS>(eos, scale);
-      THEN("The shift and scale parameters pass through correctly") {
-        REQUIRE(eos.PressureFromDensityInternalEnergy(rho, sie) == 0.3);
-      }
       WHEN("We add a ramp") {
-        //EOSBuilder::params_t ramp_params;
+        // EOSBuilder::params_t ramp_params;
         Real r0 = 1;
         Real a = 1;
         Real b = 0;
         Real c = 0;
-        //ramp_params["r0"].emplace<Real>(r0);
-        //ramp_params["a"].emplace<Real>(a);
-        //ramp_params["b"].emplace<Real>(b);
-        //ramp_params["c"].emplace<Real>(c);
-        //modifiers[EOSBuilder::EOSModifier::BilinearRamp] = ramp_params;
         THEN("The EOS is constructed correctly") {
           auto eos_ramped = Modify<BilinearRampEOS>(eos, r0, a, b, c);
-	  //EOSBuilder::buildEOS(type, base_params, modifiers);
         }
       }
     }
@@ -208,14 +239,9 @@ SCENARIO("Relativistic EOS", "[EOSBuilder][RelativisticEOS][IdealGas]") {
     constexpr Real Cv = 2.0;
     constexpr Real gm1 = 0.5;
     WHEN("We construct a relativistic IdealGas with EOSBuilder") {
-      EOSBuilder::EOSType type = EOSBuilder::EOSType::IdealGas;
-      EOSBuilder::modifiers_t modifiers;
-      EOSBuilder::params_t base_params, relativity_params;
-      base_params["Cv"].emplace<Real>(Cv);
-      base_params["gm1"].emplace<Real>(gm1);
-      relativity_params["cl"].emplace<Real>(1.0);
-      modifiers[EOSBuilder::EOSModifier::Relativistic] = relativity_params;
-      EOS eos = EOSBuilder::buildEOS(type, base_params, modifiers);
+      constexpr Real cl = 1;
+      EOS eos = IdealGas(gm1, Cv);
+      eos = Modify<RelativisticEOS>(eos, cl);
       THEN("The EOS has finite sound speeds") {
         constexpr Real rho = 1e3;
         constexpr Real sie = 1e3;
@@ -231,21 +257,13 @@ SCENARIO("EOS Unit System", "[EOSBuilder][UnitSystem][IdealGas]") {
   GIVEN("Parameters for an ideal gas") {
     constexpr Real Cv = 2.0;
     constexpr Real gm1 = 0.5;
-    EOSBuilder::EOSType type = EOSBuilder::EOSType::IdealGas;
-    EOSBuilder::modifiers_t modifiers;
-    EOSBuilder::params_t base_params, units_params;
-    base_params["Cv"].emplace<Real>(Cv);
-    base_params["gm1"].emplace<Real>(gm1);
     GIVEN("Units with a thermal unit system") {
       constexpr Real rho_unit = 1e1;
       constexpr Real sie_unit = 1e-1;
       constexpr Real temp_unit = 123;
       WHEN("We construct an IdealGas with EOSBuilder") {
-        units_params["rho_unit"].emplace<Real>(rho_unit);
-        units_params["sie_unit"].emplace<Real>(sie_unit);
-        units_params["temp_unit"].emplace<Real>(temp_unit);
-        modifiers[EOSBuilder::EOSModifier::UnitSystem] = units_params;
-        EOS eos = EOSBuilder::buildEOS(type, base_params, modifiers);
+        EOS eos = IdealGas(gm1, Cv);
+        eos = Modify<UnitSystem>(eos, rho_unit, sie_unit, temp_unit);
         THEN("Units cancel out for an ideal gas") {
           Real rho = 1e3;
           Real sie = 1e3;
@@ -261,13 +279,9 @@ SCENARIO("EOS Unit System", "[EOSBuilder][UnitSystem][IdealGas]") {
       constexpr Real mass_unit = 1e6;
       constexpr Real temp_unit = 789;
       WHEN("We construct an IdealGas with EOSBuilder") {
-        units_params["use_length_time"].emplace<bool>(true);
-        units_params["time_unit"].emplace<Real>(time_unit);
-        units_params["length_unit"].emplace<Real>(length_unit);
-        units_params["mass_unit"].emplace<Real>(mass_unit);
-        units_params["temp_unit"].emplace<Real>(temp_unit);
-        modifiers[EOSBuilder::EOSModifier::UnitSystem] = units_params;
-        EOS eos = EOSBuilder::buildEOS(type, base_params, modifiers);
+        EOS eos = IdealGas(gm1, Cv);
+        eos = Modify<UnitSystem>(eos, eos_units_init::length_time_units_init_tag,
+                                 time_unit, mass_unit, length_unit, temp_unit);
         THEN("Units cancel out for an ideal gas") {
           Real rho = 1e3;
           Real sie = 1e3;
diff --git a/test/test_eos_stellar_collapse.cpp b/test/test_eos_stellar_collapse.cpp
index 859031d5b5..9c4df97fdf 100644
--- a/test/test_eos_stellar_collapse.cpp
+++ b/test/test_eos_stellar_collapse.cpp
@@ -23,7 +23,6 @@
 #include <ports-of-call/portable_arrays.hpp>
 #include <ports-of-call/portable_errors.hpp>
 #include <singularity-eos/eos/eos.hpp>
-#include <singularity-eos/eos/eos_builder.hpp>
 
 #ifdef SINGULARITY_BUILD_CLOSURE
 #include <singularity-eos/eos/singularity_eos.hpp>
@@ -113,7 +112,7 @@ SCENARIO("Test 3D reinterpolation to fast log grid", "[StellarCollapse]") {
   }
 }
 
-SCENARIO("Stellar Collapse EOS", "[StellarCollapse][EOSBuilder]") {
+SCENARIO("Stellar Collapse EOS", "[StellarCollapse]") {
   using singularity::IdealGas;
   using singularity::StellarCollapse;
   const std::string savename = "stellar_collapse_ideal_2.sp5";
diff --git a/test/test_eos_tabulated.cpp b/test/test_eos_tabulated.cpp
index dfaea1a05d..7992713796 100644
--- a/test/test_eos_tabulated.cpp
+++ b/test/test_eos_tabulated.cpp
@@ -22,7 +22,6 @@
 #include <ports-of-call/portable_arrays.hpp>
 #include <ports-of-call/portable_errors.hpp>
 #include <singularity-eos/eos/eos.hpp>
-#include <singularity-eos/eos/eos_builder.hpp>
 
 #ifdef SINGULARITY_BUILD_CLOSURE
 #include <singularity-eos/eos/singularity_eos.hpp>
@@ -35,8 +34,6 @@
 
 #include <test/eos_unit_test_helpers.hpp>
 
-using singularity::EOS;
-
 #ifdef SPINER_USE_HDF
 using singularity::SpinerEOSDependsRhoSie;
 using singularity::SpinerEOSDependsRhoT;
@@ -46,7 +43,6 @@ using singularity::SpinerEOSDependsRhoT;
 using singularity::EOSPAC;
 #endif
 
-namespace EOSBuilder = singularity::EOSBuilder;
 namespace thermalqs = singularity::thermalqs;
 
 const std::string eosName = "../materials.sp5";
@@ -66,6 +62,8 @@ constexpr Real ev2k = 1.160451812e4;
 #ifdef SPINER_USE_HDF
 #ifdef SINGULARITY_TEST_SESAME
 #ifdef SINGULARITY_USE_EOSPAC
+using EOS = singularity::Variant<SpinerEOSDependsRhoSie, SpinerEOSDependsRhoT, EOSPAC>;
+
 SCENARIO("SpinerEOS depends on Rho and T", "[SpinerEOS],[DependsRhoT][EOSPAC]") {
 
   GIVEN("SpinerEOS and EOSPAC EOS for steel can be initialized with matid") {
@@ -261,54 +259,6 @@ SCENARIO("SpinerEOS depends on rho and sie", "[SpinerEOS],[DependsRhoSie]") {
     steelEOS.Finalize();      // cleans up device memory
   }
 }
-
-SCENARIO("EOS Builder and SpinerEOS",
-         "[SpinerEOS],[EOSBuilder],[GetOnDevice],[Finalize]") {
-  GIVEN("Parameters for shift and scale") {
-    constexpr Real shift = 0.0;
-    constexpr Real scale = 1.0;
-    WHEN("We construct a SpinerEOS with EOSBuilder") {
-      EOSBuilder::EOSType type = EOSBuilder::EOSType::SpinerEOSDependsRhoT;
-      EOSBuilder::modifiers_t modifiers;
-      EOSBuilder::params_t base_params, shifted_params, scaled_params;
-      base_params["filename"].emplace<std::string>(eosName);
-      base_params["matid"].emplace<int>(steelID);
-      shifted_params["shift"].emplace<Real>(shift);
-      scaled_params["scale"].emplace<Real>(scale);
-      modifiers[EOSBuilder::EOSModifier::Shifted] = shifted_params;
-      modifiers[EOSBuilder::EOSModifier::Scaled] = scaled_params;
-      EOS eosHost = EOSBuilder::buildEOS(type, base_params, modifiers);
-      THEN("The EOS is consistent.") {
-        REQUIRE(
-            isClose(4.96416e13, eosHost.InternalEnergyFromDensityTemperature(1e0, 1e6)));
-      }
-      WHEN("We get an EOS on device") {
-        EOS eosDevice = eosHost.GetOnDevice();
-        THEN("EOS calls match raw access") {
-          int nw_bm{0};
-#ifdef PORTABILITY_STRATEGY_KOKKOS
-          Kokkos::fence();
-          using atomic_view = Kokkos::MemoryTraits<Kokkos::Atomic>;
-          Kokkos::View<int, atomic_view> n_wrong_bm("wrong_bm");
-#else
-          PortableMDArray<int> n_wrong_bm(&nw_bm, 1);
-#endif
-          portableFor(
-              "calc ie's steel 3", 0, 100, PORTABLE_LAMBDA(const int &i) {
-                const Real bm{eosDevice.BulkModulusFromDensityTemperature(1e0, 1e6)};
-                if (!isClose(bm, 2.55268e13)) n_wrong_bm() += 1;
-              });
-#ifdef PORTABILITY_STRATEGY_KOKKOS
-          Kokkos::deep_copy(nw_bm, n_wrong_bm);
-#endif
-          REQUIRE(nw_bm == 0);
-        }
-        eosDevice.Finalize();
-      }
-      eosHost.Finalize();
-    }
-  }
-}
 #endif // SINGULARITY_USE_EOSPAC
 #endif // SINGULARITY_TEST_SESAME
 #endif // SPINER_USE_HDF

From c64c62ba36e6d57396774e5e21e9375435b297bb Mon Sep 17 00:00:00 2001
From: Jonah Miller <jonahm@lanl.gov>
Date: Fri, 13 Oct 2023 17:31:41 -0600
Subject: [PATCH 03/20] update

---
 doc/sphinx/src/using-eos.rst                  | 44 +++++++-----
 singularity-eos/CMakeLists.txt                |  4 +-
 .../eos/{eos_builder.cpp => eos.cpp}          | 19 +++--
 singularity-eos/eos/eos_builder.hpp           | 70 -------------------
 singularity-eos/eos/singularity_eos.cpp       | 58 +++++++++++++--
 5 files changed, 95 insertions(+), 100 deletions(-)
 rename singularity-eos/eos/{eos_builder.cpp => eos.cpp} (61%)

diff --git a/doc/sphinx/src/using-eos.rst b/doc/sphinx/src/using-eos.rst
index 402f340e96..31b93dcc9a 100644
--- a/doc/sphinx/src/using-eos.rst
+++ b/doc/sphinx/src/using-eos.rst
@@ -473,35 +473,43 @@ EOS Builder
 The inclusion of modifiers can make building a desired equation of
 state somewhat cumbersome. To handle this, we have implemented the
 ``EOSBuilder`` machinery. ``EOSBuilder`` is a set of functions that
-provides a declarative interface for building an equation of state
-object.
+provides a way to iteratively build up an equation of state object.
 
 The EOS Builder functions and types are defined in the
 ``singularity::EOSBuilder`` namespace. The key function is
 
-.. cpp:function:: EOS EOSBuilder::buildEOS(EOSBuilder::EOSType t, EOSBuilder::params_t base_params, EOSBuilder::modifiers_t modifiers)
+.. code-block:: cpp
 
-* ``EOSBuilder::EOSType`` is an enum class with names that match the various EOS classes defined in :ref:`the models section <models>`; for example, ``EOSBuilder::EOSType::IdealGas``.
-* ``EOSBuilder::params_t`` is a dictionary object with some type erasure, which maps strings to the types ``std::string``, ``int``, or ``Real``. It is used to map parameter names to their values for class constructors.
-* ``EOSBuilder::modifiers_t`` is a dictionary from the ``EOSModifier`` enum class, which works identically to the ``EOSType`` enum but for modifiers, to ``params_t`` objects, specifying the constructor values for each modifier.
+  template <template <class...> typename Mod, typename... Ts, typename... Args>
+  singularity::Variant<Ts...> Modify(const Variant<Ts...> &eos, Args &&...args);
 
-Putting it all together, initializing an ``IdealGas`` with
-``EOSBuilder`` looks something like this:
+where ``Mod`` is an EOS modifier, ``Variant`` is either your
+user-defined custom EOS variant type, or the pre-defined ``EOS`` type,
+the ``eos`` object is an EOS you'd like to modify (stored as a
+variant), and ``args`` are the additional arguments to the constructor
+of ``Mod`` beyond the object to modify. For esample, initializing an
+``IdealGas`` equation of state that is optionally shifted and scaled
+might look something like this:
 
 .. code-block:: cpp
 
   using namespace singularity;
-  EOSBuilder::EOSType type = EOSBuilder::EOSType::IdealGas;
-  EOSBuilder::modifiers_t modifiers;
-  EOSBuilder::params_t base_params, shifted_params, scaled_params;
-  base_params["Cv"].emplace<Real>(Cv);
-  base_params["gm1"].emplace<Real>(gm1);
-  shifted_params["shift"].emplace<Real>(shift);
-  scaled_params["scale"].emplace<Real>(scale);
-  modifiers[EOSBuilder::EOSModifier::Shifted] = shifted_params;
-  modifiers[EOSBuilder::EOSModifier::Scaled] = scaled_params;
-  EOS eos = EOSBuilder::buildEOS(type, base_params, modifiers);
+  EOS eos = IdealGas(gm1, cv);
+  if (do_shift) {
+    eos = EOSBuilder::Modify<ShiftedEOS>(eos, shift);
+  }
+  if (do_scale) {
+    eos = EOSBuilder::Modify<ScaledEOS>(eos, scale);
+  }
+
+The advantage of this approach is the EOS can be built up
+iteratively.
+
+.. warning::
 
+  Note that order of modifiers matters, and if you want follow this
+  approach, you must ensure that all combinations of types that you may
+  want to iteratively build up are present in the variant.
 
 .. _eos methods reference section:
 
diff --git a/singularity-eos/CMakeLists.txt b/singularity-eos/CMakeLists.txt
index 12bfcff819..274eb559ab 100644
--- a/singularity-eos/CMakeLists.txt
+++ b/singularity-eos/CMakeLists.txt
@@ -44,9 +44,7 @@ set(EOS_HEADERS
     eos/eos_stiff.hpp
 )
 
-set(EOS_SRCS
-    eos/eos_builder.cpp
-)
+set(EOS_SRCS eos/eos.cpp)
 
 if (SINGULARITY_BUILD_CLOSURE)
   list(APPEND EOS_HEADERS
diff --git a/singularity-eos/eos/eos_builder.cpp b/singularity-eos/eos/eos.cpp
similarity index 61%
rename from singularity-eos/eos/eos_builder.cpp
rename to singularity-eos/eos/eos.cpp
index d2e67a5b0e..5127cfe6a2 100644
--- a/singularity-eos/eos/eos_builder.cpp
+++ b/singularity-eos/eos/eos.cpp
@@ -1,4 +1,4 @@
-//------------------------------------------------------------------------------#
+//------------------------------------------------------------------------------
 // © 2021-2023. Triad National Security, LLC. All rights reserved.  This
 // program was produced under U.S. Government contract 89233218CNA000001
 // for Los Alamos National Laboratory (LANL), which is operated by Triad
@@ -10,9 +10,18 @@
 // paid-up, irrevocable worldwide license in this material to reproduce,
 // prepare derivative works, distribute copies to the public, perform
 // publicly and display publicly, and to permit others to do so.
-//------------------------------------------------------------------------------#
+//------------------------------------------------------------------------------
 
-#include <iostream> // debug
-#include <singularity-eos/eos/eos_builder.hpp>
+#include <singularity-eos/eos/eos.hpp>
 
-namespace singularity {} // namespace singularity
+using namespace singularity;
+
+#define DECLARE_MODS(x)                                                                  \
+  template class ShiftedEOS<x>;                                                          \
+  template class ScaledEOS<x>;                                                           \
+  template class UnitSystem<x>
+
+// Just explicitly declare some templated classes to speed up compile
+// times. Just pick the most commonly used ones.
+DECLARE_MODS(IdealGas);
+DECLARE_MODS(Gruneisen);
diff --git a/singularity-eos/eos/eos_builder.hpp b/singularity-eos/eos/eos_builder.hpp
index 046338cdfa..99be9bdb70 100644
--- a/singularity-eos/eos/eos_builder.hpp
+++ b/singularity-eos/eos/eos_builder.hpp
@@ -129,76 +129,6 @@ Variant<Ts...> Modify(const Variant<Ts...> &var, Args &&...args) {
   return detail::ModifyDispatcher<Mod>(var, tl, std::forward<Args>(args)...);
 }
 
-template <typename T>
-auto makeUnitSystem(T &&eos, bool use_length_time, Real rho_unit, Real sie_unit,
-                    Real temp_unit, Real time_unit, Real mass_unit, Real length_unit) {
-  if (use_length_time) {
-    return UnitSystem<T>(std::move(eos), eos_units_init::length_time_units_init_tag,
-                         time_unit, mass_unit, length_unit, temp_unit);
-  } else {
-    return UnitSystem<T>(std::move(eos), eos_units_init::thermal_units_init_tag, rho_unit,
-                         sie_unit, temp_unit);
-  }
-}
-
-template <typename T>
-auto makeRelativistic(T &&eos, Real cl) {
-  return RelativisticEOS<T>(std::move(eos), cl);
-}
-
-template <typename T>
-auto makeBilinearRamp(T &&eos, Real r0, Real a, Real b, Real c) {
-  return BilinearRampEOS<T>(std::forward<T>(eos), r0, a, b, c);
-}
-
-template <typename T>
-auto applyShiftAndScale(T &&eos, bool scaled, bool shifted, Real scale, Real shift) {
-  if (shifted && scaled) {
-    ShiftedEOS<T> a(std::forward<T>(eos), shift);
-    ScaledEOS<ShiftedEOS<T>> b(std::move(a), scale);
-    return b;
-  }
-  if (shifted) {
-    return ShiftedEOS<T>(std::forward<T>(eos), shift);
-  }
-  if (scaled) {
-    return ScaledEOS<T>(std::forward<T>(eos), scale);
-  }
-  return eos;
-}
-
-template <typename T, template <typename> class W, typename... ARGS>
-auto applyWrappedShiftAndScale(T &&eos, bool scaled, bool shifted, Real scale, Real shift,
-                               ARGS... args) {
-  if (shifted && scaled) {
-    ShiftedEOS<T> a(std::forward<T>(eos), shift);
-    ScaledEOS<ShiftedEOS<T>> b(std::move(a), scale);
-    W<ScaledEOS<ShiftedEOS<T>>> c(std::move(b), args...);
-    return c;
-  }
-  if (shifted) {
-    ShiftedEOS<T> sh_eos(std::forward<T>(eos), shift);
-    return W<ShiftedEOS<T>>(std::move(sh_eos), args...);
-  }
-  if (scaled) {
-    ScaledEOS<T> sc_eos(std::forward<T>(eos), scale);
-    return W<ScaledEOS<T>>(std::move(sc_eos), args...);
-  }
-  return W<T>(std::forward<T>(eos), args...);
-}
-
-template <typename T>
-auto applyShiftAndScaleAndBilinearRamp(T &&eos, bool scaled, bool shifted, bool ramped,
-                                       Real scale, Real shift, Real r0, Real a, Real b,
-                                       Real c) {
-  if (ramped) {
-    return applyWrappedShiftAndScale<T, BilinearRampEOS>(
-        std::forward<T>(eos), scaled, shifted, scale, shift, r0, a, b, c);
-  } else {
-    return applyShiftAndScale(std::forward<T>(eos), scaled, shifted, scale, shift);
-  }
-}
-
 } // namespace EOSBuilder
 } // namespace singularity
 
diff --git a/singularity-eos/eos/singularity_eos.cpp b/singularity-eos/eos/singularity_eos.cpp
index b5920b8f1d..1fcd68afb4 100644
--- a/singularity-eos/eos/singularity_eos.cpp
+++ b/singularity-eos/eos/singularity_eos.cpp
@@ -20,6 +20,56 @@
 
 using namespace singularity;
 
+// TODO: Replace these with the new Modify method in EOSBuilder.
+// NOTE: The new EOSBuilder machinery will likely be slower than these.
+template <typename T>
+EOS applyShiftAndScale(T &&eos, bool scaled, bool shifted, Real scale, Real shift) {
+  if (shifted && scaled) {
+    ShiftedEOS<T> a(std::forward<T>(eos), shift);
+    ScaledEOS<ShiftedEOS<T>> b(std::move(a), scale);
+    return b;
+  }
+  if (shifted) {
+    return ShiftedEOS<T>(std::forward<T>(eos), shift);
+  }
+  if (scaled) {
+    return ScaledEOS<T>(std::forward<T>(eos), scale);
+  }
+  return eos;
+}
+
+template <typename T, template <typename> class W, typename... ARGS>
+EOS applyWrappedShiftAndScale(T &&eos, bool scaled, bool shifted, Real scale, Real shift,
+                              ARGS... args) {
+  if (shifted && scaled) {
+    ShiftedEOS<T> a(std::forward<T>(eos), shift);
+    ScaledEOS<ShiftedEOS<T>> b(std::move(a), scale);
+    W<ScaledEOS<ShiftedEOS<T>>> c(std::move(b), args...);
+    return c;
+  }
+  if (shifted) {
+    ShiftedEOS<T> sh_eos(std::forward<T>(eos), shift);
+    return W<ShiftedEOS<T>>(std::move(sh_eos), args...);
+  }
+  if (scaled) {
+    ScaledEOS<T> sc_eos(std::forward<T>(eos), scale);
+    return W<ScaledEOS<T>>(std::move(sc_eos), args...);
+  }
+  return W<T>(std::forward<T>(eos), args...);
+}
+
+template <typename T>
+EOS applyShiftAndScaleAndBilinearRamp(T &&eos, bool scaled, bool shifted, bool ramped,
+                                      Real scale, Real shift, Real r0, Real a, Real b,
+                                      Real c) {
+  if (ramped) {
+    return applyWrappedShiftAndScale<T, BilinearRampEOS>(
+        std::forward<T>(eos), scaled, shifted, scale, shift, r0, a, b, c);
+  } else {
+    return applyShiftAndScale(std::forward<T>(eos), scaled, shifted, scale, shift);
+  }
+}
+
 int init_sg_eos(const int nmat, EOS *&eos) {
 #ifdef PORTABILITY_STRATEGY_KOKKOS
   if (!Kokkos::is_initialized()) Kokkos::initialize();
@@ -32,12 +82,12 @@ int init_sg_eos(const int nmat, EOS *&eos) {
 // apply everything but ramp in order to possibly calculate the
 // SAP ramp parameters from p-alhpa ramp parameters
 #define SGAPPLYMODSIMPLE(A)                                                              \
-  EOSBuilder::applyShiftAndScale(A, enabled[0] == 1, enabled[1] == 1, vals[0], vals[1])
+  applyShiftAndScale(A, enabled[0] == 1, enabled[1] == 1, vals[0], vals[1])
 
 #define SGAPPLYMOD(A)                                                                    \
-  EOSBuilder::applyShiftAndScaleAndBilinearRamp(                                         \
-      A, enabled[0] == 1, enabled[1] == 1, enabled[2] == 1 || enabled[3] == 1, vals[0],  \
-      vals[1], vals[2], vals[3], vals[4], vals[5])
+  applyShiftAndScaleAndBilinearRamp(A, enabled[0] == 1, enabled[1] == 1,                 \
+                                    enabled[2] == 1 || enabled[3] == 1, vals[0],         \
+                                    vals[1], vals[2], vals[3], vals[4], vals[5])
 
 int def_en[4] = {0, 0, 0, 0};
 double def_v[6] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};

From b3a8bef685f9abe90bbbb3e7ab3f38bb2908ecd3 Mon Sep 17 00:00:00 2001
From: Jonah Miller <jonahm@lanl.gov>
Date: Fri, 13 Oct 2023 17:45:08 -0600
Subject: [PATCH 04/20] oops wrong location for return type

---
 singularity-eos/eos/eos_variant.hpp | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/singularity-eos/eos/eos_variant.hpp b/singularity-eos/eos/eos_variant.hpp
index 1a58e546e9..745f547600 100644
--- a/singularity-eos/eos/eos_variant.hpp
+++ b/singularity-eos/eos/eos_variant.hpp
@@ -930,7 +930,10 @@ class Variant {
 
   inline constexpr Variant UnmodifyOnce() {
     return mpark::visit(
-        [](auto &eos) { return eos_variant<EOSs...>(eos.UnmodifyOnce()); }, eos_);
+        [](auto &eos) -> eos_variant<EOSs...> {
+          return eos_variant<EOSs...>(eos.UnmodifyOnce());
+        },
+        eos_);
   }
 
   inline constexpr Variant GetUnmodifiedObject() {
@@ -943,9 +946,7 @@ class Variant {
 
   PORTABLE_INLINE_FUNCTION
   unsigned long PreferredInput() const noexcept {
-    return mpark::visit(
-        [](const auto &eos) -> eos_variant<EOSs...> { return eos.PreferredInput(); },
-        eos_);
+    return mpark::visit([](const auto &eos) { return eos.PreferredInput(); }, eos_);
   }
 
   PORTABLE_INLINE_FUNCTION

From 4da7614359b868ae964e1ef5680e99a29ed44410 Mon Sep 17 00:00:00 2001
From: Jonah Miller <jonahm@lanl.gov>
Date: Fri, 13 Oct 2023 17:46:46 -0600
Subject: [PATCH 05/20] remove unneeded includes in eos_builder.hpp

---
 singularity-eos/eos/eos_builder.hpp | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/singularity-eos/eos/eos_builder.hpp b/singularity-eos/eos/eos_builder.hpp
index 99be9bdb70..33244a6304 100644
--- a/singularity-eos/eos/eos_builder.hpp
+++ b/singularity-eos/eos/eos_builder.hpp
@@ -15,17 +15,12 @@
 #ifndef _SINGULARITY_EOS_EOS_EOS_BUILDER_HPP_
 #define _SINGULARITY_EOS_EOS_EOS_BUILDER_HPP_
 
-#include <map>
-#include <mpark/variant.hpp>
+#include <utility>
+
 #include <ports-of-call/portability.hpp>
-#include <singularity-eos/eos/eos.hpp>
-#include <string>
-#include <unordered_set>
 
-// Actually all we need
 #include <singularity-eos/base/variadic_utils.hpp>
 #include <singularity-eos/eos/eos_variant.hpp>
-#include <utility>
 
 namespace singularity {
 namespace EOSBuilder {

From 4baef2891fc991cfc3db92b9b55c59ac2a2bab14 Mon Sep 17 00:00:00 2001
From: Jonah Miller <jonahm@lanl.gov>
Date: Fri, 13 Oct 2023 17:50:04 -0600
Subject: [PATCH 06/20] CHANGELOG

---
 CHANGELOG.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a5f6a5dccd..63dbd8561e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -40,6 +40,7 @@
 - [[PR177]](https://github.com/lanl/singularity-eos/pull/177) added EOSPAC vector functions
 
 ### Changed (changing behavior/API/variables/...)
+- [[PR311]](https://github.com/lanl/singularity-eos/pull/311) Refactor EOSBuilder for flexibility and extensibility
 - [[PR310]](https://github.com/lanl/singularity-eos/pull/310) Speed up and clean up tests
 - [[PR295]](https://github.com/lanl/singularity-eos/pull/295) Add fast logs to singularity-eos
 - [[PR246]](https://github.com/lanl/singularity-eos/pull/246) Update CMake with upstream changes

From a44c73ec82068d25e777eccd421b67f967269ac3 Mon Sep 17 00:00:00 2001
From: Jonah Maxwell Miller <jonahm@lanl.gov>
Date: Mon, 16 Oct 2023 11:10:50 -0600
Subject: [PATCH 07/20] Mark ModifyDispatcher constexpr auto

---
 singularity-eos/eos/eos_builder.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/singularity-eos/eos/eos_builder.hpp b/singularity-eos/eos/eos_builder.hpp
index 33244a6304..3dafede35c 100644
--- a/singularity-eos/eos/eos_builder.hpp
+++ b/singularity-eos/eos/eos_builder.hpp
@@ -47,7 +47,7 @@ Variant<Ts...> ModifyHelper(std::false_type, const Variant<Ts...> &var,
 
 // Base case
 template <template <class...> typename Mod, typename... Ts, typename... Args>
-Variant<Ts...> ModifyDispatcher(const Variant<Ts...> &var, const type_list<> &tl,
+constexpr auto ModifyDispatcher(const Variant<Ts...> &var, const type_list<> &tl,
                                 Args &&...args) {
   return var;
 }
@@ -59,7 +59,7 @@ Variant<Ts...> ModifyDispatcher(const Variant<Ts...> &var, const type_list<> &tl
 // ModifyHelper<Mod>(no,...)  method.
 template <template <class...> typename Mod, typename U, typename... Rest, typename... Ts,
           typename... Args>
-Variant<Ts...> ModifyDispatcher(const Variant<Ts...> &var,
+constexpr auto ModifyDispatcher(const Variant<Ts...> &var,
                                 const type_list<U, Rest...> &tl, Args &&...args) {
   constexpr bool type_in_variant =
       (contains_v<U, Ts...>() && contains_v<Mod<U>, Ts...>());

From e919d568e9750a2a342b98b7428d524a740bc499 Mon Sep 17 00:00:00 2001
From: Jonah Miller <jonahm@lanl.gov>
Date: Wed, 18 Oct 2023 12:09:34 -0600
Subject: [PATCH 08/20] Rename types namespace to variadic_utils

---
 singularity-eos/base/variadic_utils.hpp |  4 ++--
 singularity-eos/eos/eos.hpp             | 16 ++++++++--------
 singularity-eos/eos/eos_builder.hpp     |  2 +-
 test/test_eos_modifiers.cpp             | 16 ++++++++--------
 4 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/singularity-eos/base/variadic_utils.hpp b/singularity-eos/base/variadic_utils.hpp
index 38d8a7ee03..d98331bd4f 100644
--- a/singularity-eos/base/variadic_utils.hpp
+++ b/singularity-eos/base/variadic_utils.hpp
@@ -18,7 +18,7 @@
 #include <type_traits>
 
 namespace singularity {
-namespace types {
+namespace variadic_utils {
 
 // Some generic variatic utilities
 // ======================================================================
@@ -181,7 +181,7 @@ constexpr auto pack_size(type_list<Ts...>) {
   return sizeof...(Ts);
 }
 
-} // namespace types
+} // namespace variadic_utils
 } // namespace singularity
 
 #endif // SINGULARITY_EOS_BASE_VARIADIC_UTILS_HPP_
diff --git a/singularity-eos/eos/eos.hpp b/singularity-eos/eos/eos.hpp
index 81b692fa96..92e2932778 100644
--- a/singularity-eos/eos/eos.hpp
+++ b/singularity-eos/eos/eos.hpp
@@ -57,13 +57,13 @@ namespace singularity {
 
 // recreate variadic list
 template <typename... Ts>
-using tl = singularity::types::type_list<Ts...>;
+using tl = singularity::variadic_utils::type_list<Ts...>;
 
 template <template <typename> class... Ts>
-using al = singularity::types::adapt_list<Ts...>;
+using al = singularity::variadic_utils::adapt_list<Ts...>;
 
 // transform variadic list: applies modifiers to eos's
-using singularity::types::transform_variadic_list;
+using singularity::variadic_utils::transform_variadic_list;
 
 // all eos's
 static constexpr const auto full_eos_list =
@@ -117,13 +117,13 @@ static constexpr const auto scaled_1 =
     transform_variadic_list(full_eos_list, al<ScaledEOS>{});
 // relativistic and unit system modifiers
 static constexpr const auto unit_or_rel =
-    singularity::types::concat(unit_system, relativistic);
+    singularity::variadic_utils::concat(unit_system, relativistic);
 // variadic list of eos with shifted, relativistic or unit system modifiers
 static constexpr const auto shifted_of_unit_or_rel =
     transform_variadic_list(unit_or_rel, al<ShiftedEOS>{});
 // combined list of all shifted EOS
 static constexpr const auto shifted =
-    singularity::types::concat(shifted_1, shifted_of_unit_or_rel);
+    singularity::variadic_utils::concat(shifted_1, shifted_of_unit_or_rel);
 // variadic list of eos with scaled, relativistic or unit system modifiers
 static constexpr const auto scaled_of_unit_or_rel =
     transform_variadic_list(unit_or_rel, al<ScaledEOS>{});
@@ -132,16 +132,16 @@ static constexpr const auto scaled_of_shifted =
     transform_variadic_list(shifted, al<ScaledEOS>{});
 // combined list of all scaled EOS
 static constexpr const auto scaled =
-    singularity::types::concat(scaled_1, scaled_of_unit_or_rel, scaled_of_shifted);
+    singularity::variadic_utils::concat(scaled_1, scaled_of_unit_or_rel, scaled_of_shifted);
 // create combined list
 static constexpr const auto combined_list_1 =
-    singularity::types::concat(full_eos_list, shifted, scaled, unit_or_rel);
+    singularity::variadic_utils::concat(full_eos_list, shifted, scaled, unit_or_rel);
 // make a ramped eos of everything
 static constexpr const auto ramped_all =
     transform_variadic_list(combined_list_1, al<BilinearRampEOS>{});
 // final combined list
 static constexpr const auto combined_list =
-    singularity::types::concat(combined_list_1, ramped_all);
+    singularity::variadic_utils::concat(combined_list_1, ramped_all);
 // a function that returns a Variant from a typelist
 template <typename... Ts>
 struct tl_to_Variant_struct {
diff --git a/singularity-eos/eos/eos_builder.hpp b/singularity-eos/eos/eos_builder.hpp
index 3dafede35c..8b54c3d4f2 100644
--- a/singularity-eos/eos/eos_builder.hpp
+++ b/singularity-eos/eos/eos_builder.hpp
@@ -27,7 +27,7 @@ namespace EOSBuilder {
 
 // Just import the variadic utils namespace int the EOSBuilder
 // namespace.
-using namespace types;
+using namespace variadic_utils;
 
 // Recursive functions needed for the Modify function JMM: Note this
 // machinery would be a LOT easier in C++17, with constexpr if.  To
diff --git a/test/test_eos_modifiers.cpp b/test/test_eos_modifiers.cpp
index 1e46ebee56..45058f4762 100644
--- a/test/test_eos_modifiers.cpp
+++ b/test/test_eos_modifiers.cpp
@@ -42,13 +42,13 @@ using singularity::UnitSystem;
 
 // recreate variadic list
 template <typename... Ts>
-using tl = singularity::types::type_list<Ts...>;
+using tl = singularity::variadic_utils::type_list<Ts...>;
 
 template <template <typename> class... Ts>
-using al = singularity::types::adapt_list<Ts...>;
+using al = singularity::variadic_utils::adapt_list<Ts...>;
 
 // transform variadic list: applies modifiers to eos's
-using singularity::types::transform_variadic_list;
+using singularity::variadic_utils::transform_variadic_list;
 
 static constexpr const auto full_eos_list = tl<IdealGas>{};
 static constexpr const auto relativistic_eos_list = tl<IdealGas>{};
@@ -66,13 +66,13 @@ static constexpr const auto relativistic =
     transform_variadic_list(relativistic_eos_list, al<RelativisticEOS>{});
 // relativistic and unit system modifiers
 static constexpr const auto unit_or_rel =
-    singularity::types::concat(unit_system, relativistic);
+    singularity::variadic_utils::concat(unit_system, relativistic);
 // variadic list of eos with shifted, relativistic or unit system modifiers
 static constexpr const auto shifted_of_unit_or_rel =
     transform_variadic_list(unit_or_rel, al<ShiftedEOS>{});
 // combined list of all shifted EOS
 static constexpr const auto shifted =
-    singularity::types::concat(shifted_1, shifted_of_unit_or_rel);
+    singularity::variadic_utils::concat(shifted_1, shifted_of_unit_or_rel);
 // variadic list of eos with scaled, relativistic or unit system modifiers
 static constexpr const auto scaled_of_unit_or_rel =
     transform_variadic_list(unit_or_rel, al<ScaledEOS>{});
@@ -81,16 +81,16 @@ static constexpr const auto scaled_of_shifted =
     transform_variadic_list(shifted, al<ScaledEOS>{});
 // combined list of all scaled EOS
 static constexpr const auto scaled =
-    singularity::types::concat(scaled_1, scaled_of_unit_or_rel, scaled_of_shifted);
+    singularity::variadic_utils::concat(scaled_1, scaled_of_unit_or_rel, scaled_of_shifted);
 // create combined list
 static constexpr const auto combined_list_1 =
-    singularity::types::concat(full_eos_list, shifted, scaled, unit_or_rel);
+    singularity::variadic_utils::concat(full_eos_list, shifted, scaled, unit_or_rel);
 // make a ramped eos of everything
 static constexpr const auto ramped_all =
     transform_variadic_list(combined_list_1, al<BilinearRampEOS>{});
 // final combined list
 static constexpr const auto combined_list =
-    singularity::types::concat(combined_list_1, ramped_all);
+    singularity::variadic_utils::concat(combined_list_1, ramped_all);
 using EOS = typename decltype(singularity::tl_to_Variant(combined_list))::vt;
 
 SCENARIO("EOS Builder and Modifiers", "[EOSBuilder][Modifiers][IdealGas]") {

From 38ab3146b3fe938948ccea0af48bcd6fb44161e5 Mon Sep 17 00:00:00 2001
From: Jonah Miller <jonahm@lanl.gov>
Date: Wed, 18 Oct 2023 12:22:13 -0600
Subject: [PATCH 09/20] Remove eos.cpp file so we can be header only without
 the fortran bindings. Needed to tell cmake that singularity-eos was linked
 C++ in this context.

---
 CMakeLists.txt                 |  2 ++
 singularity-eos/CMakeLists.txt |  2 +-
 singularity-eos/eos/eos.cpp    | 27 ---------------------------
 3 files changed, 3 insertions(+), 28 deletions(-)
 delete mode 100644 singularity-eos/eos/eos.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 59ad2c2c3d..e71a3339a5 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -390,6 +390,8 @@ if(SINGULARITY_USE_FORTRAN)
   target_include_directories(
     singularity-eos INTERFACE $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>
                               $<INSTALL_INTERFACE:include/singularity-eos/eos>)
+else() # Needed because cmake improperly infers linker for header-only
+  set_target_properties(singularity-eos PROPERTIES LINKER_LANGUAGE CXX)
 endif() # SINGULARITY_USE_FORTRAN
 
 target_include_directories(
diff --git a/singularity-eos/CMakeLists.txt b/singularity-eos/CMakeLists.txt
index 274eb559ab..a019134365 100644
--- a/singularity-eos/CMakeLists.txt
+++ b/singularity-eos/CMakeLists.txt
@@ -44,7 +44,7 @@ set(EOS_HEADERS
     eos/eos_stiff.hpp
 )
 
-set(EOS_SRCS eos/eos.cpp)
+set(EOS_SRCS "")
 
 if (SINGULARITY_BUILD_CLOSURE)
   list(APPEND EOS_HEADERS
diff --git a/singularity-eos/eos/eos.cpp b/singularity-eos/eos/eos.cpp
deleted file mode 100644
index 5127cfe6a2..0000000000
--- a/singularity-eos/eos/eos.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//------------------------------------------------------------------------------
-// © 2021-2023. Triad National Security, LLC. All rights reserved.  This
-// program was produced under U.S. Government contract 89233218CNA000001
-// for Los Alamos National Laboratory (LANL), which is operated by Triad
-// National Security, LLC for the U.S.  Department of Energy/National
-// Nuclear Security Administration. All rights in the program are
-// reserved by Triad National Security, LLC, and the U.S. Department of
-// Energy/National Nuclear Security Administration. The Government is
-// granted for itself and others acting on its behalf a nonexclusive,
-// paid-up, irrevocable worldwide license in this material to reproduce,
-// prepare derivative works, distribute copies to the public, perform
-// publicly and display publicly, and to permit others to do so.
-//------------------------------------------------------------------------------
-
-#include <singularity-eos/eos/eos.hpp>
-
-using namespace singularity;
-
-#define DECLARE_MODS(x)                                                                  \
-  template class ShiftedEOS<x>;                                                          \
-  template class ScaledEOS<x>;                                                           \
-  template class UnitSystem<x>
-
-// Just explicitly declare some templated classes to speed up compile
-// times. Just pick the most commonly used ones.
-DECLARE_MODS(IdealGas);
-DECLARE_MODS(Gruneisen);

From dea245f3e8aef036e34bdcea86cb6f4bfa4142bc Mon Sep 17 00:00:00 2001
From: Jonah Miller <jonahm@lanl.gov>
Date: Wed, 18 Oct 2023 12:22:35 -0600
Subject: [PATCH 10/20] formatting

---
 singularity-eos/eos/eos.hpp | 4 ++--
 test/test_eos_modifiers.cpp | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/singularity-eos/eos/eos.hpp b/singularity-eos/eos/eos.hpp
index 92e2932778..69a839235a 100644
--- a/singularity-eos/eos/eos.hpp
+++ b/singularity-eos/eos/eos.hpp
@@ -131,8 +131,8 @@ static constexpr const auto scaled_of_unit_or_rel =
 static constexpr const auto scaled_of_shifted =
     transform_variadic_list(shifted, al<ScaledEOS>{});
 // combined list of all scaled EOS
-static constexpr const auto scaled =
-    singularity::variadic_utils::concat(scaled_1, scaled_of_unit_or_rel, scaled_of_shifted);
+static constexpr const auto scaled = singularity::variadic_utils::concat(
+    scaled_1, scaled_of_unit_or_rel, scaled_of_shifted);
 // create combined list
 static constexpr const auto combined_list_1 =
     singularity::variadic_utils::concat(full_eos_list, shifted, scaled, unit_or_rel);
diff --git a/test/test_eos_modifiers.cpp b/test/test_eos_modifiers.cpp
index 45058f4762..ae40692031 100644
--- a/test/test_eos_modifiers.cpp
+++ b/test/test_eos_modifiers.cpp
@@ -80,8 +80,8 @@ static constexpr const auto scaled_of_unit_or_rel =
 static constexpr const auto scaled_of_shifted =
     transform_variadic_list(shifted, al<ScaledEOS>{});
 // combined list of all scaled EOS
-static constexpr const auto scaled =
-    singularity::variadic_utils::concat(scaled_1, scaled_of_unit_or_rel, scaled_of_shifted);
+static constexpr const auto scaled = singularity::variadic_utils::concat(
+    scaled_1, scaled_of_unit_or_rel, scaled_of_shifted);
 // create combined list
 static constexpr const auto combined_list_1 =
     singularity::variadic_utils::concat(full_eos_list, shifted, scaled, unit_or_rel);

From f5e25838a64762b478b202135af1e1f95f72e9ea Mon Sep 17 00:00:00 2001
From: Jonah Miller <jonahm@lanl.gov>
Date: Wed, 18 Oct 2023 13:29:44 -0600
Subject: [PATCH 11/20] add some useful variadic utils and tests for them.
 hopefully provides some support for doing things with types

---
 singularity-eos/base/variadic_utils.hpp |  5 ++-
 singularity-eos/eos/eos_builder.hpp     | 22 ++++++++--
 test/CMakeLists.txt                     |  1 +
 test/test_eos_modifiers.cpp             | 21 +++++-----
 test/test_variadic_utils.cpp            | 53 +++++++++++++++++++++++++
 5 files changed, 87 insertions(+), 15 deletions(-)
 create mode 100644 test/test_variadic_utils.cpp

diff --git a/singularity-eos/base/variadic_utils.hpp b/singularity-eos/base/variadic_utils.hpp
index d98331bd4f..50e9b14269 100644
--- a/singularity-eos/base/variadic_utils.hpp
+++ b/singularity-eos/base/variadic_utils.hpp
@@ -40,9 +40,12 @@ template <bool... Bs>
 struct disjunction : bool_constant<!conjunction<!Bs...>::value> {};
 
 // Checks if T is contained in the pack Ts
+template <typename T, typename... Ts>
+using contains = disjunction<std::is_same<T, Ts>::value...>;
+
 template <typename T, typename... Ts>
 constexpr bool contains_v() {
-  return disjunction<std::is_same<T, Ts>::value...>::value;
+  return contains<T, Ts...>::value;
 }
 
 // variadic list
diff --git a/singularity-eos/eos/eos_builder.hpp b/singularity-eos/eos/eos_builder.hpp
index 8b54c3d4f2..e6f1f3099b 100644
--- a/singularity-eos/eos/eos_builder.hpp
+++ b/singularity-eos/eos/eos_builder.hpp
@@ -29,6 +29,18 @@ namespace EOSBuilder {
 // namespace.
 using namespace variadic_utils;
 
+template <template <class...> typename Mod, typename U, typename... Ts>
+using IsModifiable =
+    conjunction<contains<U, Ts...>::value, contains<Mod<U>, Ts...>::value>;
+template <template <class...> typename Mod, typename U, typename... Ts>
+constexpr bool is_modifiable(const Variant<Ts...> &var) {
+  return IsModifiable<Mod, U, Ts...>::value;
+}
+template <template <class...> typename Mod, typename U, typename... Ts>
+constexpr bool is_modifiable(const U &u, const Variant<Ts...> &var) {
+  return IsModifiable<Mod, U, Ts...>::value;
+}
+
 // Recursive functions needed for the Modify function JMM: Note this
 // machinery would be a LOT easier in C++17, with constexpr if.  To
 // mimic constexpr if, I use tag dispatch here. I need two separate
@@ -57,12 +69,12 @@ constexpr auto ModifyDispatcher(const Variant<Ts...> &var, const type_list<> &tl
 // are in the type list for the variant. If yes, it dispatches to the
 // ModifyHelper<Mod>(yes,...) method, otherwise, the
 // ModifyHelper<Mod>(no,...)  method.
+
 template <template <class...> typename Mod, typename U, typename... Rest, typename... Ts,
           typename... Args>
 constexpr auto ModifyDispatcher(const Variant<Ts...> &var,
                                 const type_list<U, Rest...> &tl, Args &&...args) {
-  constexpr bool type_in_variant =
-      (contains_v<U, Ts...>() && contains_v<Mod<U>, Ts...>());
+  constexpr bool type_in_variant = IsModifiable<Mod, U, Ts...>::value;
   return ModifyHelper<Mod>(bool_constant<type_in_variant>(), var, tl,
                            std::forward<Args>(args)...);
 }
@@ -95,7 +107,9 @@ template <template <class...> typename Mod, typename U, typename... Rest, typena
           typename... Args>
 Variant<Ts...> ModifyHelper(const Variant<Ts...> &var, const type_list<U, Rest...> &tl,
                             Args &&...args) {
-  return detail::ModifyDispatcher<Mod>(var, tl, std::forward<Args>(args)...);
+  constexpr bool is_modifiable = IsModifiable<Mod, U, Ts...>::value;
+  return ModifyHelper<Mod>(bool_constant<is_modifiable>(), var, tl,
+                           std::forward<Args>(args)...);
 }
 } // namespace detail
 
@@ -121,7 +135,7 @@ Variant<Ts...> ModifyHelper(const Variant<Ts...> &var, const type_list<U, Rest..
 template <template <class...> typename Mod, typename... Ts, typename... Args>
 Variant<Ts...> Modify(const Variant<Ts...> &var, Args &&...args) {
   type_list<Ts...> tl;
-  return detail::ModifyDispatcher<Mod>(var, tl, std::forward<Args>(args)...);
+  return detail::ModifyHelper<Mod>(var, tl, std::forward<Args>(args)...);
 }
 
 } // namespace EOSBuilder
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index d30b5b0b8e..2dd4d7b16a 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -29,6 +29,7 @@ add_executable(
   test_eos_modifiers.cpp
   test_eos_vector.cpp
   test_math_utils.cpp
+  test_variadic_utils.cpp
   )
 
 add_executable(
diff --git a/test/test_eos_modifiers.cpp b/test/test_eos_modifiers.cpp
index ae40692031..2262a86319 100644
--- a/test/test_eos_modifiers.cpp
+++ b/test/test_eos_modifiers.cpp
@@ -31,6 +31,7 @@ namespace eos_units_init = singularity::eos_units_init;
 
 namespace EOSBuilder = singularity::EOSBuilder;
 namespace thermalqs = singularity::thermalqs;
+namespace variadic_utils = singularity::variadic_utils;
 
 using EOSBuilder::Modify;
 using singularity::BilinearRampEOS;
@@ -42,13 +43,13 @@ using singularity::UnitSystem;
 
 // recreate variadic list
 template <typename... Ts>
-using tl = singularity::variadic_utils::type_list<Ts...>;
+using tl = variadic_utils::type_list<Ts...>;
 
 template <template <typename> class... Ts>
-using al = singularity::variadic_utils::adapt_list<Ts...>;
+using al = variadic_utils::adapt_list<Ts...>;
 
 // transform variadic list: applies modifiers to eos's
-using singularity::variadic_utils::transform_variadic_list;
+using variadic_utils::transform_variadic_list;
 
 static constexpr const auto full_eos_list = tl<IdealGas>{};
 static constexpr const auto relativistic_eos_list = tl<IdealGas>{};
@@ -66,13 +67,13 @@ static constexpr const auto relativistic =
     transform_variadic_list(relativistic_eos_list, al<RelativisticEOS>{});
 // relativistic and unit system modifiers
 static constexpr const auto unit_or_rel =
-    singularity::variadic_utils::concat(unit_system, relativistic);
+    variadic_utils::concat(unit_system, relativistic);
 // variadic list of eos with shifted, relativistic or unit system modifiers
 static constexpr const auto shifted_of_unit_or_rel =
     transform_variadic_list(unit_or_rel, al<ShiftedEOS>{});
 // combined list of all shifted EOS
 static constexpr const auto shifted =
-    singularity::variadic_utils::concat(shifted_1, shifted_of_unit_or_rel);
+    variadic_utils::concat(shifted_1, shifted_of_unit_or_rel);
 // variadic list of eos with scaled, relativistic or unit system modifiers
 static constexpr const auto scaled_of_unit_or_rel =
     transform_variadic_list(unit_or_rel, al<ScaledEOS>{});
@@ -80,18 +81,18 @@ static constexpr const auto scaled_of_unit_or_rel =
 static constexpr const auto scaled_of_shifted =
     transform_variadic_list(shifted, al<ScaledEOS>{});
 // combined list of all scaled EOS
-static constexpr const auto scaled = singularity::variadic_utils::concat(
-    scaled_1, scaled_of_unit_or_rel, scaled_of_shifted);
+static constexpr const auto scaled =
+    variadic_utils::concat(scaled_1, scaled_of_unit_or_rel, scaled_of_shifted);
 // create combined list
 static constexpr const auto combined_list_1 =
-    singularity::variadic_utils::concat(full_eos_list, shifted, scaled, unit_or_rel);
+    variadic_utils::concat(full_eos_list, shifted, scaled, unit_or_rel);
 // make a ramped eos of everything
 static constexpr const auto ramped_all =
     transform_variadic_list(combined_list_1, al<BilinearRampEOS>{});
 // final combined list
 static constexpr const auto combined_list =
-    singularity::variadic_utils::concat(combined_list_1, ramped_all);
-using EOS = typename decltype(singularity::tl_to_Variant(combined_list))::vt;
+    variadic_utils::concat(combined_list_1, ramped_all);
+using EOS = typename decltype(tl_to_Variant(combined_list))::vt;
 
 SCENARIO("EOS Builder and Modifiers", "[EOSBuilder][Modifiers][IdealGas]") {
 
diff --git a/test/test_variadic_utils.cpp b/test/test_variadic_utils.cpp
new file mode 100644
index 0000000000..33623223ff
--- /dev/null
+++ b/test/test_variadic_utils.cpp
@@ -0,0 +1,53 @@
+//------------------------------------------------------------------------------
+// © 2021-2023. Triad National Security, LLC. All rights reserved.  This
+// program was produced under U.S. Government contract 89233218CNA000001
+// for Los Alamos National Laboratory (LANL), which is operated by Triad
+// National Security, LLC for the U.S.  Department of Energy/National
+// Nuclear Security Administration. All rights in the program are
+// reserved by Triad National Security, LLC, and the U.S. Department of
+// Energy/National Nuclear Security Administration. The Government is
+// granted for itself and others acting on its behalf a nonexclusive,
+// paid-up, irrevocable worldwide license in this material to reproduce,
+// prepare derivative works, distribute copies to the public, perform
+// publicly and display publicly, and to permit others to do so.
+//------------------------------------------------------------------------------
+
+#include <singularity-eos/base/variadic_utils.hpp>
+#include <singularity-eos/eos/eos.hpp>
+#include <singularity-eos/eos/eos_builder.hpp>
+#include <singularity-eos/eos/eos_variant.hpp>
+
+#ifndef CATCH_CONFIG_FAST_COMPILE
+#define CATCH_CONFIG_FAST_COMPILE
+#include "catch2/catch.hpp"
+#endif
+
+using singularity::Gruneisen;
+using singularity::IdealGas;
+using singularity::ScaledEOS;
+using singularity::ShiftedEOS;
+using Var_t = singularity::Variant<IdealGas, ShiftedEOS<IdealGas>>;
+
+namespace variadic_utils = singularity::variadic_utils;
+namespace EOSBuilder = singularity::EOSBuilder;
+
+SCENARIO("Conjunction and disjunction work properly", "[VariadicUtils]") {
+  constexpr bool true_and_false = variadic_utils::conjunction<true, false>::value;
+  constexpr bool true_or_false = variadic_utils::disjunction<true, false>::value;
+  REQUIRE(true_and_false == false);
+  REQUIRE(true_or_false == true);
+}
+
+SCENARIO("Contains works as intended", "[VariadicUtils]") {
+  REQUIRE(variadic_utils::contains_v<IdealGas, IdealGas, ShiftedEOS<IdealGas>>());
+  REQUIRE(!variadic_utils::contains_v<Gruneisen, IdealGas, ShiftedEOS<IdealGas>>());
+}
+
+SCENARIO("IsModifiable works as intended", "[VariadicUtils][EOSBuilder]") {
+  using namespace EOSBuilder;
+  const Var_t v{};
+  REQUIRE(is_modifiable<ShiftedEOS, IdealGas>(v));
+  REQUIRE(!is_modifiable<ShiftedEOS, Gruneisen>(v));
+  REQUIRE(!is_modifiable<ScaledEOS, IdealGas>(v));
+  REQUIRE(!is_modifiable<ScaledEOS, Gruneisen>(v));
+}

From 9de904b2f159fa19aba628dedcff69b635f80e21 Mon Sep 17 00:00:00 2001
From: Jonah Miller <jonahm@lanl.gov>
Date: Wed, 18 Oct 2023 13:36:55 -0600
Subject: [PATCH 12/20] include eos.cpp

---
 singularity-eos/CMakeLists.txt |  2 +-
 singularity-eos/eos/eos.cpp    | 45 ++++++++++++++++++++++++++++++++++
 2 files changed, 46 insertions(+), 1 deletion(-)
 create mode 100644 singularity-eos/eos/eos.cpp

diff --git a/singularity-eos/CMakeLists.txt b/singularity-eos/CMakeLists.txt
index a019134365..631e335d9e 100644
--- a/singularity-eos/CMakeLists.txt
+++ b/singularity-eos/CMakeLists.txt
@@ -44,7 +44,7 @@ set(EOS_HEADERS
     eos/eos_stiff.hpp
 )
 
-set(EOS_SRCS "")
+set(EOS_SRCS eos.cpp)
 
 if (SINGULARITY_BUILD_CLOSURE)
   list(APPEND EOS_HEADERS
diff --git a/singularity-eos/eos/eos.cpp b/singularity-eos/eos/eos.cpp
new file mode 100644
index 0000000000..1625668a9e
--- /dev/null
+++ b/singularity-eos/eos/eos.cpp
@@ -0,0 +1,45 @@
+//------------------------------------------------------------------------------
+// © 2021-2023. Triad National Security, LLC. All rights reserved.  This
+// program was produced under U.S. Government contract 89233218CNA000001
+// for Los Alamos National Laboratory (LANL), which is operated by Triad
+// National Security, LLC for the U.S.  Department of Energy/National
+// Nuclear Security Administration. All rights in the program are
+// reserved by Triad National Security, LLC, and the U.S. Department of
+// Energy/National Nuclear Security Administration. The Government is
+// granted for itself and others acting on its behalf a nonexclusive,
+// paid-up, irrevocable worldwide license in this material to reproduce,
+// prepare derivative works, distribute copies to the public, perform
+// publicly and display publicly, and to permit others to do so.
+//------------------------------------------------------------------------------
+
+// JMM: This is a dummy file to provide a source file for cmake to
+// compile when built without fortran.
+//
+// The main reason to do this is that when we build without fortran
+// bindings, the library is completely header only. However WITH
+// fortran bindings, it is not.
+//
+// cmake supports a build mode for header only libraries by marking
+// those libraries INTERFACE. Without this flag, a few things will go
+// wrong:
+// 1. CMake will be unable to infer a proper linker
+//    so one must be specified by hand.
+// 2. no dynamic library file (e.g., "*.a" will be generated,
+//    but dependencies that link against it, such as another library,
+//    or in our case, tests, will look for it. This will lead to
+//    a failure of the downstream library at link time.
+// 
+// On the other hand, a library with implementation files
+// CANNOT be marked INTERFACE, as otherwise source files will
+// not be compiled.
+//
+// Unfortunately, switching the INTERFACE tag on and off in cmake
+// is very cumbersome, as if a library is marked INTERFACE
+// all its dependencies must ALSO be slurped in with an INTERFACE
+// flag. This introduces significant branching in the cmake code
+// and a lot of builer plate. For now, then, I simply include this
+// empty source file.
+//
+// In the future, we could include centralized code here that we
+// always want compiled, such as template instantiations or
+// convenience functions.

From d799a40ccd494f52586b7cb1a641cc2cc47a113d Mon Sep 17 00:00:00 2001
From: Jonah Miller <jonahm@lanl.gov>
Date: Wed, 18 Oct 2023 13:46:17 -0600
Subject: [PATCH 13/20] oops wrong file path

---
 singularity-eos/CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/singularity-eos/CMakeLists.txt b/singularity-eos/CMakeLists.txt
index 631e335d9e..274eb559ab 100644
--- a/singularity-eos/CMakeLists.txt
+++ b/singularity-eos/CMakeLists.txt
@@ -44,7 +44,7 @@ set(EOS_HEADERS
     eos/eos_stiff.hpp
 )
 
-set(EOS_SRCS eos.cpp)
+set(EOS_SRCS eos/eos.cpp)
 
 if (SINGULARITY_BUILD_CLOSURE)
   list(APPEND EOS_HEADERS

From 790f176d9c29dcb0dea8674508eef17114d2655f Mon Sep 17 00:00:00 2001
From: Jonah Miller <jonahm@lanl.gov>
Date: Wed, 18 Oct 2023 13:48:03 -0600
Subject: [PATCH 14/20] typo

---
 singularity-eos/eos/eos.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/singularity-eos/eos/eos.cpp b/singularity-eos/eos/eos.cpp
index 1625668a9e..90099973a8 100644
--- a/singularity-eos/eos/eos.cpp
+++ b/singularity-eos/eos/eos.cpp
@@ -24,7 +24,7 @@
 // wrong:
 // 1. CMake will be unable to infer a proper linker
 //    so one must be specified by hand.
-// 2. no dynamic library file (e.g., "*.a" will be generated,
+// 2. no dynamic library file (e.g., "*.a") will be generated,
 //    but dependencies that link against it, such as another library,
 //    or in our case, tests, will look for it. This will lead to
 //    a failure of the downstream library at link time.

From 62e954d8c3d1e49ff60e84bc5a140363ca003ac3 Mon Sep 17 00:00:00 2001
From: Jonah Miller <jonahm@lanl.gov>
Date: Wed, 18 Oct 2023 14:43:23 -0600
Subject: [PATCH 15/20] formatting

---
 singularity-eos/eos/eos.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/singularity-eos/eos/eos.cpp b/singularity-eos/eos/eos.cpp
index 90099973a8..d791059870 100644
--- a/singularity-eos/eos/eos.cpp
+++ b/singularity-eos/eos/eos.cpp
@@ -28,7 +28,7 @@
 //    but dependencies that link against it, such as another library,
 //    or in our case, tests, will look for it. This will lead to
 //    a failure of the downstream library at link time.
-// 
+//
 // On the other hand, a library with implementation files
 // CANNOT be marked INTERFACE, as otherwise source files will
 // not be compiled.

From 2b819fc3c7b0a5a814f8f3a3a9f2d8df63e71912 Mon Sep 17 00:00:00 2001
From: Jonah Maxwell Miller <jonahm@lanl.gov>
Date: Wed, 25 Oct 2023 16:22:41 -0600
Subject: [PATCH 16/20] missing semicolon

---
 test/compare_on_data.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/compare_on_data.cpp b/test/compare_on_data.cpp
index 458cf599f8..12f4f1f820 100644
--- a/test/compare_on_data.cpp
+++ b/test/compare_on_data.cpp
@@ -215,8 +215,8 @@ void load_eos_spiner(const std::string &filename, const std::vector<int> &matids
 
   for (int matid : matids) {
     if (matid > 0) { // non-analytic
-      eos_h.push_back(SpinerEOSDependsRhoT(filename, matid))
-          eos_d.push_back(eos_h.back().GetOnDevice());
+      eos_h.push_back(SpinerEOSDependsRhoT(filename, matid));
+      eos_d.push_back(eos_h.back().GetOnDevice());
     }
   }
 }

From 2b7cb3fb0fafc28a5450ab1ffffa8cf2f8414176 Mon Sep 17 00:00:00 2001
From: Jonah Maxwell Miller <jonahm@lanl.gov>
Date: Wed, 25 Oct 2023 16:47:48 -0600
Subject: [PATCH 17/20] add overload for typelist

---
 singularity-eos/eos/eos_builder.hpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/singularity-eos/eos/eos_builder.hpp b/singularity-eos/eos/eos_builder.hpp
index e6f1f3099b..ce1f1bd0dc 100644
--- a/singularity-eos/eos/eos_builder.hpp
+++ b/singularity-eos/eos/eos_builder.hpp
@@ -33,6 +33,10 @@ template <template <class...> typename Mod, typename U, typename... Ts>
 using IsModifiable =
     conjunction<contains<U, Ts...>::value, contains<Mod<U>, Ts...>::value>;
 template <template <class...> typename Mod, typename U, typename... Ts>
+constexpr bool is_modifiable(const type_list<Ts...> &var) {
+  return IsModifiable<Mod, U, Ts...>::value;
+}
+template <template <class...> typename Mod, typename U, typename... Ts>
 constexpr bool is_modifiable(const Variant<Ts...> &var) {
   return IsModifiable<Mod, U, Ts...>::value;
 }

From 1380a427527c0dc2697c0d317fda143bcf0bcbfe Mon Sep 17 00:00:00 2001
From: Jonah Maxwell Miller <jonahm@lanl.gov>
Date: Mon, 27 Nov 2023 14:46:38 -0700
Subject: [PATCH 18/20] starting to mess with daniels design

---
 singularity-eos/eos/eos_base.hpp    | 14 ++++++++++++++
 singularity-eos/eos/eos_variant.hpp |  8 ++++++++
 2 files changed, 22 insertions(+)

diff --git a/singularity-eos/eos/eos_base.hpp b/singularity-eos/eos/eos_base.hpp
index 9588a57fa9..72e89bd857 100644
--- a/singularity-eos/eos/eos_base.hpp
+++ b/singularity-eos/eos/eos_base.hpp
@@ -20,6 +20,7 @@
 
 #include <ports-of-call/portability.hpp>
 #include <ports-of-call/portable_errors.hpp>
+#include <singularity-eos/base/variadic_utils.hpp>
 
 namespace singularity {
 namespace mfuncname {
@@ -135,6 +136,19 @@ class EosBase {
     f(copy);
   }
 
+  // EOS builder helpers
+  // Checks if an EOS can be modified
+  template<template<class> typename Mod, typename... Ts>
+  bool CanApplyModifier() const {
+    return variadic_utils::contains_v<Mod<CRTP>, Ts...>();
+  }
+  // Modifies an EOS object by pulling out underlying type and modifying it
+  template<template<class> typename Mod, typename... Args>
+  auto Modify(Args &&...args) const {
+    const CRTP &unmodified = *(static_cast<CRTP const *>(this));
+    return Mod<CRTP>(unmodified, std::forward<Args>(args)...);
+  }
+
   // Vector member functions
   template <typename RealIndexer, typename ConstRealIndexer, typename LambdaIndexer>
   inline void
diff --git a/singularity-eos/eos/eos_variant.hpp b/singularity-eos/eos/eos_variant.hpp
index 745f547600..cd015081a7 100644
--- a/singularity-eos/eos/eos_variant.hpp
+++ b/singularity-eos/eos/eos_variant.hpp
@@ -17,6 +17,7 @@
 
 #include <mpark/variant.hpp>
 #include <ports-of-call/portability.hpp>
+#include <singularity-eos/base/variadic_utils.hpp>
 #include <singularity-eos/eos/eos_base.hpp>
 
 using Real = double;
@@ -77,6 +78,13 @@ class Variant {
     return mpark::visit([&f](const auto &eos) { return eos.Evaluate(f); }, eos_);
   }
 
+  // EOS modifier object-oriented API
+  template<template<class> typename Mod>
+  bool CanApplyModifier() const {
+    return mpark::visit(
+        [](const auto &eos) { return eos.CanApplyModifier<Mod, EOSs...>(); }, eos_);
+  }
+
   PORTABLE_INLINE_FUNCTION
   Real TemperatureFromDensityInternalEnergy(const Real rho, const Real sie,
                                             Real *lambda = nullptr) const {

From 068b30ac2b3d8a17e0d586ef4d4415c4196ecf48 Mon Sep 17 00:00:00 2001
From: Jonah Miller <jonahm@lanl.gov>
Date: Mon, 27 Nov 2023 18:55:10 -0700
Subject: [PATCH 19/20] build a simpler, faster, CRTP based modifier API.
 Thanks, Daniel

---
 doc/sphinx/src/modifiers.rst        | 13 +++++
 doc/sphinx/src/using-eos.rst        | 52 +++++++++++-------
 singularity-eos/eos/eos_base.hpp    | 32 +++++++++---
 singularity-eos/eos/eos_builder.hpp | 81 +----------------------------
 singularity-eos/eos/eos_variant.hpp | 19 +++++--
 test/test_eos_modifiers.cpp         |  4 +-
 test/test_variadic_utils.cpp        |  9 ++++
 7 files changed, 102 insertions(+), 108 deletions(-)

diff --git a/doc/sphinx/src/modifiers.rst b/doc/sphinx/src/modifiers.rst
index 6fc6b1af15..552b16940b 100644
--- a/doc/sphinx/src/modifiers.rst
+++ b/doc/sphinx/src/modifiers.rst
@@ -195,6 +195,19 @@ Modifiers can be composed. For example:
   using namespace singularity;
   auto my_eos = ShiftedEOS<ScaledEOS<IdealGas>>(ScaledEOS(IdealGas(gm1, Cv), scale), shift);
 
+You can build modifiers up iteratively by, for example:
+
+.. code-block:: cpp
+
+  using namespace singularity;
+  EOS eos = IdealGas(gm1, cv);
+  if (do_shift) {
+    eos = eos.template Modify<ShiftedEOS>(shift);
+  }
+  if (do_scale) {
+    eos = eos.template Modify<ScaledEOS>(scale);
+  }
+
 Undoing Modifiers
 ------------------
 
diff --git a/doc/sphinx/src/using-eos.rst b/doc/sphinx/src/using-eos.rst
index 31b93dcc9a..7f1d975863 100644
--- a/doc/sphinx/src/using-eos.rst
+++ b/doc/sphinx/src/using-eos.rst
@@ -388,6 +388,34 @@ modifiers. However, note that modifiers do not commute, and only one
 order is supported. The ordering, inside-out, is ``UnitSystem`` or
 ``RelativisticEOS``, then ``ScaledEOS``, then ``ShiftedEOS``.
 
+A modified equation of state can be built up iteratively. To check if
+the equation of state currently stored in the variant can modified,
+you may call
+
+.. cpp:function:: bool ModifiedInVariant<Mod>() const;
+
+where ``Mod`` is the type of the modifier you want to apply, for
+example ``ShiftedEOS``. If this function returns true, then you can
+apply a modifier with the function
+
+.. cpp:function:: Variant Modify<Mod>(Args &&..args) const;
+
+where again ``Mod`` is the modifier you wish to apply, and ``args``
+are the arguments to the constructor for that modifier, e.g., the
+shift. For example, one might build up a shifted or scaled eos with a
+code block like this:
+
+.. code-block:: cpp
+
+  using namespace singularity;
+  EOS eos = IdealGas(gm1, cv);
+  if (do_shift) {
+    eos = eos.template Modify<ShiftedEOS>(shift);
+  }
+  if (do_scale) {
+    eos = eos.template Modify<ScaledEOS>(scale);
+  }
+
 Relevant to the broad ``singularity-eos`` API, EOS models provide
 introspection. To check if an EOS is modified, call
 
@@ -470,24 +498,21 @@ temperature or density and specific internal energy.
 EOS Builder
 ------------
 
-The inclusion of modifiers can make building a desired equation of
-state somewhat cumbersome. To handle this, we have implemented the
-``EOSBuilder`` machinery. ``EOSBuilder`` is a set of functions that
-provides a way to iteratively build up an equation of state object.
-
-The EOS Builder functions and types are defined in the
-``singularity::EOSBuilder`` namespace. The key function is
+The iterative construction of modifiers described above and in the
+:ref:`modifiers<modifiers>` section is object oriented. For
+convenience, we also provide a procedural, dispatch-based approach in
+the ``EOSBuilder`` namespace and header. The key function is
 
 .. code-block:: cpp
 
-  template <template <class...> typename Mod, typename... Ts, typename... Args>
+  template <template <class> typename Mod, typename... Ts, typename... Args>
   singularity::Variant<Ts...> Modify(const Variant<Ts...> &eos, Args &&...args);
 
 where ``Mod`` is an EOS modifier, ``Variant`` is either your
 user-defined custom EOS variant type, or the pre-defined ``EOS`` type,
 the ``eos`` object is an EOS you'd like to modify (stored as a
 variant), and ``args`` are the additional arguments to the constructor
-of ``Mod`` beyond the object to modify. For esample, initializing an
+of ``Mod`` beyond the object to modify. For example, initializing an
 ``IdealGas`` equation of state that is optionally shifted and scaled
 might look something like this:
 
@@ -502,15 +527,6 @@ might look something like this:
     eos = EOSBuilder::Modify<ScaledEOS>(eos, scale);
   }
 
-The advantage of this approach is the EOS can be built up
-iteratively.
-
-.. warning::
-
-  Note that order of modifiers matters, and if you want follow this
-  approach, you must ensure that all combinations of types that you may
-  want to iteratively build up are present in the variant.
-
 .. _eos methods reference section:
 
 Equation of State Methods Reference
diff --git a/singularity-eos/eos/eos_base.hpp b/singularity-eos/eos/eos_base.hpp
index 72e89bd857..8fb836738d 100644
--- a/singularity-eos/eos/eos_base.hpp
+++ b/singularity-eos/eos/eos_base.hpp
@@ -138,15 +138,35 @@ class EosBase {
 
   // EOS builder helpers
   // Checks if an EOS can be modified
-  template<template<class> typename Mod, typename... Ts>
-  bool CanApplyModifier() const {
+  template <template <class> typename Mod, typename... Ts>
+  constexpr bool ModifiedInList() const {
     return variadic_utils::contains_v<Mod<CRTP>, Ts...>();
   }
   // Modifies an EOS object by pulling out underlying type and modifying it
-  template<template<class> typename Mod, typename... Args>
-  auto Modify(Args &&...args) const {
-    const CRTP &unmodified = *(static_cast<CRTP const *>(this));
-    return Mod<CRTP>(unmodified, std::forward<Args>(args)...);
+  // This one returns Mod<CRT>
+  template <template <class> typename Mod, typename... Args>
+  constexpr Mod<CRTP> Modify(Args &&...args) const {
+    CRTP unmodified = *(static_cast<CRTP const *>(this));
+    return Mod<CRTP>(std::move(unmodified), std::forward<Args>(args)...);
+  }
+  // These are overloads needed for the variant, as std::visit must be
+  // able to return a variant of the same type every time. This lets
+  // us do so, even though sometimes we don't modify the object.
+  template <template <class> typename Mod, typename... Args>
+  constexpr Mod<CRTP> ConditionallyModify(std::true_type, Args &&...args) const {
+    return Modify<Mod>(std::forward<Args>(args)...);
+  }
+  template <template <class> typename Mod, typename... Args>
+  constexpr CRTP ConditionallyModify(std::false_type, Args &&...args) const {
+    CRTP unmodified = *(static_cast<CRTP const *>(this));
+    return unmodified;
+  }
+  template <template <class> typename Mod, typename... Ts, typename... Args>
+  constexpr auto ConditionallyModify(const variadic_utils::type_list<Ts...> &tl,
+                                     Args &&...args) const {
+    constexpr bool do_mod = variadic_utils::contains_v<Mod<CRTP>, Ts...>();
+    return ConditionallyModify<Mod>(variadic_utils::bool_constant<do_mod>(),
+                                    std::forward<Args>(args)...);
   }
 
   // Vector member functions
diff --git a/singularity-eos/eos/eos_builder.hpp b/singularity-eos/eos/eos_builder.hpp
index ce1f1bd0dc..cd9cac1691 100644
--- a/singularity-eos/eos/eos_builder.hpp
+++ b/singularity-eos/eos/eos_builder.hpp
@@ -45,78 +45,6 @@ constexpr bool is_modifiable(const U &u, const Variant<Ts...> &var) {
   return IsModifiable<Mod, U, Ts...>::value;
 }
 
-// Recursive functions needed for the Modify function JMM: Note this
-// machinery would be a LOT easier in C++17, with constexpr if.  To
-// mimic constexpr if, I use tag dispatch here. I need two separate
-// functions to make it work, however.
-namespace detail {
-
-// Prototypes
-template <template <class...> typename Mod, typename U, typename... Rest, typename... Ts,
-          typename... Args>
-Variant<Ts...> ModifyHelper(std::true_type, const Variant<Ts...> &var,
-                            const type_list<U, Rest...> &tl, Args &&...args);
-template <template <class...> typename Mod, typename U, typename... Rest, typename... Ts,
-          typename... Args>
-Variant<Ts...> ModifyHelper(std::false_type, const Variant<Ts...> &var,
-                            const type_list<U, Rest...> &tl, Args &&...args);
-
-// Base case
-template <template <class...> typename Mod, typename... Ts, typename... Args>
-constexpr auto ModifyDispatcher(const Variant<Ts...> &var, const type_list<> &tl,
-                                Args &&...args) {
-  return var;
-}
-
-// The ModifyDispatcher function specifies which tag in tag dispatch
-// to use. It's main purpose is to check whether or not U and Mod<U>
-// are in the type list for the variant. If yes, it dispatches to the
-// ModifyHelper<Mod>(yes,...) method, otherwise, the
-// ModifyHelper<Mod>(no,...)  method.
-
-template <template <class...> typename Mod, typename U, typename... Rest, typename... Ts,
-          typename... Args>
-constexpr auto ModifyDispatcher(const Variant<Ts...> &var,
-                                const type_list<U, Rest...> &tl, Args &&...args) {
-  constexpr bool type_in_variant = IsModifiable<Mod, U, Ts...>::value;
-  return ModifyHelper<Mod>(bool_constant<type_in_variant>(), var, tl,
-                           std::forward<Args>(args)...);
-}
-
-// The ModifyHelper function recursively walks through all types in the
-// typelist tl. For each type in tl, it checks if the type is (a) in
-// the variant typelist, and (b) currently held by the variant
-// object. If both (a) and (b) are true, it returns a new variant
-// containing Mod<u>. Otherwise, it moves to the next type.
-template <template <class...> typename Mod, typename U, typename... Rest, typename... Ts,
-          typename... Args>
-Variant<Ts...> ModifyHelper(std::true_type, const Variant<Ts...> &var,
-                            const type_list<U, Rest...> &tl, Args &&...args) {
-  bool contains_u = var.template IsType<U>();
-  if (contains_u) {
-    return Variant<Ts...>(Mod<U>(var.template get<U>(), std::forward<Args>(args)...));
-  } else {
-    type_list<Rest...> tl_new{};
-    return ModifyDispatcher<Mod>(var, tl_new, std::forward<Args>(args)...);
-  }
-}
-template <template <class...> typename Mod, typename U, typename... Rest, typename... Ts,
-          typename... Args>
-Variant<Ts...> ModifyHelper(std::false_type, const Variant<Ts...> &var,
-                            const type_list<U, Rest...> &tl, Args &&...args) {
-  type_list<Rest...> tl_new{};
-  return ModifyDispatcher<Mod>(var, tl_new, std::forward<Args>(args)...);
-}
-template <template <class...> typename Mod, typename U, typename... Rest, typename... Ts,
-          typename... Args>
-Variant<Ts...> ModifyHelper(const Variant<Ts...> &var, const type_list<U, Rest...> &tl,
-                            Args &&...args) {
-  constexpr bool is_modifiable = IsModifiable<Mod, U, Ts...>::value;
-  return ModifyHelper<Mod>(bool_constant<is_modifiable>(), var, tl,
-                           std::forward<Args>(args)...);
-}
-} // namespace detail
-
 // Modifies the eos contained in the var object with the modifier Mod,
 // assuming such modification is possible, i.e., Mod<T> is in the
 // variant, for the underlying type T. If this modification is not
@@ -132,14 +60,9 @@ Variant<Ts...> ModifyHelper(const Variant<Ts...> &var, const type_list<U, Rest..
 // if (shifted) {
 //   eos = Modify<ShifteEOS>(eos, shift);
 // }
-// Note that this is potentially a pretty expensive operation,
-// as it must walk through the entire variant, both at compile, and run-time.
-// However, it is also extremely flexible, enabling user-selected variants
-// with minimal boiler plate.
-template <template <class...> typename Mod, typename... Ts, typename... Args>
+template <template <class> typename Mod, typename... Ts, typename... Args>
 Variant<Ts...> Modify(const Variant<Ts...> &var, Args &&...args) {
-  type_list<Ts...> tl;
-  return detail::ModifyHelper<Mod>(var, tl, std::forward<Args>(args)...);
+  return var.template Modify<Mod>(std::forward<Args>(args)...);
 }
 
 } // namespace EOSBuilder
diff --git a/singularity-eos/eos/eos_variant.hpp b/singularity-eos/eos/eos_variant.hpp
index cd015081a7..645aedc879 100644
--- a/singularity-eos/eos/eos_variant.hpp
+++ b/singularity-eos/eos/eos_variant.hpp
@@ -17,6 +17,7 @@
 
 #include <mpark/variant.hpp>
 #include <ports-of-call/portability.hpp>
+#include <ports-of-call/portable_errors.hpp>
 #include <singularity-eos/base/variadic_utils.hpp>
 #include <singularity-eos/eos/eos_base.hpp>
 
@@ -79,10 +80,22 @@ class Variant {
   }
 
   // EOS modifier object-oriented API
-  template<template<class> typename Mod>
-  bool CanApplyModifier() const {
+  template <template <class> typename Mod>
+  constexpr bool ModifiedInVariant() const {
     return mpark::visit(
-        [](const auto &eos) { return eos.CanApplyModifier<Mod, EOSs...>(); }, eos_);
+        [](const auto &eos) { return eos.template ModifiedInList<Mod, EOSs...>(); },
+        eos_);
+  }
+  template <template <class> typename Mod, typename... Args>
+  constexpr auto Modify(Args &&...args) const {
+    PORTABLE_ALWAYS_REQUIRE(ModifiedInVariant<Mod>(), "Modifier must be in variant");
+    return mpark::visit(
+        [&](const auto &eos) {
+          auto modified = eos.template ConditionallyModify<Mod>(
+              variadic_utils::type_list<EOSs...>(), std::forward<Args>(args)...);
+          return eos_variant<EOSs...>(modified);
+        },
+        eos_);
   }
 
   PORTABLE_INLINE_FUNCTION
diff --git a/test/test_eos_modifiers.cpp b/test/test_eos_modifiers.cpp
index 2262a86319..e6621d71b3 100644
--- a/test/test_eos_modifiers.cpp
+++ b/test/test_eos_modifiers.cpp
@@ -105,8 +105,8 @@ SCENARIO("EOS Builder and Modifiers", "[EOSBuilder][Modifiers][IdealGas]") {
     constexpr Real sie = 0.5;
     WHEN("We use the EOSBuilder") {
       EOS eos = IdealGas(gm1, Cv);
-      eos = Modify<ShiftedEOS>(eos, shift);
-      eos = Modify<ScaledEOS>(eos, scale);
+      eos = eos.Modify<ShiftedEOS>(shift);
+      eos = eos.Modify<ScaledEOS>(scale);
       THEN("The shift and scale parameters pass through correctly") {
         REQUIRE(eos.PressureFromDensityInternalEnergy(rho, sie) == 0.3);
       }
diff --git a/test/test_variadic_utils.cpp b/test/test_variadic_utils.cpp
index 33623223ff..cc482fe6dd 100644
--- a/test/test_variadic_utils.cpp
+++ b/test/test_variadic_utils.cpp
@@ -43,6 +43,15 @@ SCENARIO("Contains works as intended", "[VariadicUtils]") {
   REQUIRE(!variadic_utils::contains_v<Gruneisen, IdealGas, ShiftedEOS<IdealGas>>());
 }
 
+SCENARIO("EOS Variant can check its own modifiability",
+         "[VariadicUtils][EOSBuilder][EOSBase][EOSVariant]") {
+  constexpr Real Cv = 2.0;
+  constexpr Real gm1 = 0.5;
+  Var_t v = IdealGas(gm1, Cv);
+  REQUIRE(v.ModifiedInVariant<ShiftedEOS>());
+  REQUIRE(!v.ModifiedInVariant<ScaledEOS>());
+}
+
 SCENARIO("IsModifiable works as intended", "[VariadicUtils][EOSBuilder]") {
   using namespace EOSBuilder;
   const Var_t v{};

From b3d40b31f004734b4478a5bb61922ffe57ecf64b Mon Sep 17 00:00:00 2001
From: Jonah Maxwell Miller <jonahm@lanl.gov>
Date: Wed, 29 Nov 2023 10:47:14 -0700
Subject: [PATCH 20/20] final comment from Daniel

---
 singularity-eos/eos/eos_builder.hpp | 15 ---------------
 1 file changed, 15 deletions(-)

diff --git a/singularity-eos/eos/eos_builder.hpp b/singularity-eos/eos/eos_builder.hpp
index cd9cac1691..fce5e8650b 100644
--- a/singularity-eos/eos/eos_builder.hpp
+++ b/singularity-eos/eos/eos_builder.hpp
@@ -45,21 +45,6 @@ constexpr bool is_modifiable(const U &u, const Variant<Ts...> &var) {
   return IsModifiable<Mod, U, Ts...>::value;
 }
 
-// Modifies the eos contained in the var object with the modifier Mod,
-// assuming such modification is possible, i.e., Mod<T> is in the
-// variant, for the underlying type T. If this modification is not
-// possible, returns the unmodified EOS. Args are the additional
-// arguments to the modifier's constructor.
-// Intended usage:
-//
-// eos = Modify<Modifier>(eos, args);
-//
-// For example:
-//
-// EOS eos = IdealGas(gm1, Cv);
-// if (shifted) {
-//   eos = Modify<ShifteEOS>(eos, shift);
-// }
 template <template <class> typename Mod, typename... Ts, typename... Args>
 Variant<Ts...> Modify(const Variant<Ts...> &var, Args &&...args) {
   return var.template Modify<Mod>(std::forward<Args>(args)...);