In general, value semantics just means that you can pass the object around,
not an address.  In order to use value semantics at all you have to have an
object with an associated copy constructor and assignment operator
available.  We extend the requirements to talk about the set of operators
that are pre-defined for plain-old-data (POD) types.  Operator=, operator++,
operator--, operator+, operator==, etc., etc.  You can see the list in
src/core/traced-value.h if you want.

I don't think there any instance in our codebase of a TracedValue tracing
anything but POD (uin32_t, int8_t, etc.), so I tend to think about
TracedValue in terms of tracing POD -- ints, chars, longs, shorts, etc.  You
can extend this to user defined types, but like I said I don't think anyone
has done that yet.  The signature of the trace sink is fixed since the
semantics are fixed (you get the old *value* and the new *value* of the
object with *value* semantics).

A TracedCallback is a completely different animal.  There is no object with
value semantics in sight.  What you are doing with a traced callback is just
executing a callback.  TracedCallback is essentially just a
point-to-multipoint connection between the trace source and sinks.  You can
define a callback any way you want, so the parameter list can be whatever
you want.  The compiler just makes sure that things match.

TracedValue -> objects with value semantics
TracedCallback -> generic callback