2 files changed, 26 insertions, 10 deletions
diff --git a/src/libutil/error.hh b/src/libutil/error.hh
index 70884c189..1c5d6d13c 100644
--- a/src/libutil/error.hh
+++ b/src/libutil/error.hh
@@ -7,6 +7,7 @@
 #include <iostream>
 #include <iomanip>
 
+#include "types.hh"
 #include <boost/format.hpp>
 
 namespace nix
@@ -234,7 +235,7 @@ protected:
 
 
 // ----------------------------------------------------------------
-// format for hints.  same as boost format, except templated values
+// format for hints.  same as fmt, except templated values
 // are always in yellow.
 
 template <class T>
@@ -251,20 +252,25 @@ std::ostream& operator<<(std::ostream &out, const yellowify<T> &y)
     return out << ANSI_YELLOW << y.value << ANSI_NORMAL;
 }
 
-class hintfmt
+class hintformat
 {
 public:
-    hintfmt(string format) :fmt(format)
+    hintformat(string format) :fmt(format)
     {
         fmt.exceptions(boost::io::all_error_bits ^ boost::io::too_many_args_bit);
     }
     template<class T>
-    hintfmt& operator%(const T &value)
+    hintformat& operator%(const T &value)
     {
         fmt % yellowify(value);
         return *this;
     }
 
+    std::string str() const
+    {
+        return fmt.str();
+    }
+
     template <typename U>
     friend class AddHint;
 private:
@@ -272,14 +278,22 @@ private:
 
 };
 
+template<typename... Args>
+inline hintformat hintfmt(const std::string & fs, const Args & ... args)
+{
+    hintformat f(fs);
+    formatHelper(f, args...);
+    return f;
+}
+
 // the template layer for adding a hint.
 template <class T>
 class AddHint : private T
 {
 public:
-    T& hint(hintfmt &hfmt)
+    T& hint(const hintformat &hf)
     {
-        GetEI().hint = std::optional(hfmt.fmt.str());
+        GetEI().hint = std::optional(hf.str());
         return *this;
     }
     T& nohint()
diff --git a/src/libutil/types.hh b/src/libutil/types.hh
index 20b96a85c..981af528b 100644
--- a/src/libutil/types.hh
+++ b/src/libutil/types.hh
@@ -41,7 +41,8 @@ struct FormatOrString
 {
     string s;
     FormatOrString(const string & s) : s(s) { };
-    FormatOrString(const format & f) : s(f.str()) { };
+    template<class F>
+    FormatOrString(const F & f) : s(f.str()) { };
     FormatOrString(const char * s) : s(s) { };
 };
 
@@ -51,12 +52,13 @@ struct FormatOrString
    ... a_n’. However, ‘fmt(s)’ is equivalent to ‘s’ (so no %-expansion
    takes place). */
 
-inline void formatHelper(boost::format & f)
+template<class F>
+inline void formatHelper(F & f)
 {
 }
 
-template<typename T, typename... Args>
-inline void formatHelper(boost::format & f, const T & x, const Args & ... args)
+template<class F, typename T, typename... Args>
+inline void formatHelper(F & f, const T & x, const Args & ... args)
 {
     formatHelper(f % x, args...);
 }