Not at the moment, no. But it&#x27;s not rocket science. The macro essentially creates a struct like this one:<p><pre><code>  struct S {
    &#x2F;&#x2F; How many fields are in this struct?
    static constexpr unsigned int FIELD_COUNT = 5;

    &#x2F;&#x2F; Full specializations are not allowed inside classes, so add a dummy parameter &lt;T&gt; that is equivalent to S
    template &lt;unsigned int Index, typename T = S&gt;
    struct FieldTraits;

    &#x2F;&#x2F; Partial specialization for the first field
    template &lt;typename T&gt;
    struct FieldTraits&lt;0, T&gt; {
      using type = int;
      static constexpr std::size_t OFFSET = offsetof(S, anInt);
      static constexpr const char* name() { return &quot;anInt&quot;; }
      static constexpr type&amp; value(S&amp; self) { return self.anInt; }
    };
    &#x2F;&#x2F; The first field itself
    int anInt;

    &#x2F;&#x2F; Partial specialization for the second field
    template &lt;typename T&gt;
    struct FieldTraits&lt;1, T&gt; {
      using type = bool;
      static constexpr std::size_t OFFSET = offsetof(S, aBool);
      static constexpr const char* name() { return &quot;aBool&quot;; }
      static constexpr type&amp; value(S&amp; self) { return self.aBool; }
    };
    &#x2F;&#x2F; The second field itself
    bool aBool;
    ...
  };
</code></pre>
Now that we have the meta-information about the struct&#x27;s fields, we can process them:<p><pre><code>  &#x2F;&#x2F; Meta-function to process a struct&#x27;s fields
  template &lt;typename T, unsigned int FieldIndex, unsigned int FieldCount&gt;
  struct ForEach {
     template &lt;typename Functor&gt;
     static void apply(T&amp; object, Functor f)
     {
        &#x2F;&#x2F; Get the field&#x27;s value and call the functor with it
        auto value = T::FieldTraits&lt;FieldIndex&gt;::value(object);
        f(value);

        &#x2F;&#x2F; Next field
        ForEach&lt;T, FieldIndex + 1, FieldCount&gt;::apply(object, f);
     };
  };

  &#x2F;&#x2F; Partial specialization to end iteration
  template &lt;typename T, unsigned int FieldCount&gt;
  struct ForEach&lt;T, FieldCount, FieldCount&gt; {
     template &lt;typename Functor&gt;
     static void apply(T&amp; object, Functor f)
     {
     };
  };
</code></pre>
And finally a bit of syntactic sugar:<p><pre><code>  template &lt;typename T, typename Functor&gt;
  void forEachField(T&amp; object, Functor f)
  {
     ForEach&lt;T, 0, T::FIELD_COUNT&gt;::apply(object, f);
  }

</code></pre>
*(omitted for the sake of clarity: dealing with const objects, using rvalue references and std::forward for the functor to make the code work with non-copyable functors)