Are second derivatives (and higher) inefficient?

I'm using the Duals implementation in ForwardDiff and have a question about taking higher derivatives.

Consider this simple example:

using ForwardDiff
f(x) = sin(x) / x

@show y0 = f(10.0) # function
@show y1 = f(Dual(10.0, 1.0))  # function + 1st derivative
@show y2 = f(Dual(Dual(10.0, 1.0), Dual(1.0, 1.0))) # function + 1st,2nd derivatives

The 2nd derivative case seems unnecessarily inefficient because I must substitute a Dual number for both the value and partial components of the 1st (i.e. outer) Dual. If you run the code, you can see that y2.value.partials[1] == y2.partials[1].value, and that both give the value of 1st derivative. Must we compute this value twice? Obviously, this problem is more serious when one has a vector of derivatives to be evaluated, etc.

A modest proposal: Could we allow the types of the value and partials be different? That would seem to allow code like the following:

y2 = f(Dual(10.0, Dual(1.0, 1.0)))

Is there already some support for this, and I'm just missing it?

Start by reproducing the Julia examples using ForwardDiff.Dual and compare the repeated first-derivative values in y2.value.partials[1] and y2.partials[1]. Review the Dual implementation and determine whether heterogeneous value and partial types can avoid that duplication; done means documenting the supported approach or defining a concrete, validated change.