Extent of extents about d3-array HOT 6 CLOSED

Maybe I’m missing something, but why not:

d3.extent(d3.merge(arrays))

Or, in modern browsers:

d3.extent(data.flat())

It works for Curran’s example, too:

d3.extent(d3.merge(d3.merge(stacked)))

Or better:

d3.extent(stacked.flat(2))

Especially now that d3-array 2.0 takes iterables (so you could write your own flattener if desired), I don’t feel there’s a need to exposed additional auto-flattening variants of d3-array methods.

from d3-array.

Here's a snippet I wrote to compute the extent of extents for one specific case:

https://bl.ocks.org/curran/f5282f177a5d339bc9d3e59745879fd7

        yScale
          .domain([
            d3.min(stacked, function (series) {
              return d3.min(series, function (d) { return d[0]; });
            }),
            d3.max(stacked, function (series) {
              return d3.max(series, function (d) { return d[1]; });
            })
          ])

from d3-array.

The expectation is that you call d3.min and d3.max separately if you have nested arrays, such as:

[
  d3.min(arrays, array => d3.min(array)),
  d3.max(arrays, array => d3.max(array))
]

We could make this a little more concise if d3.extent optionally allowed two accessors instead of just one. Then you could say:

d3.extent(arrays, array => d3.min(array), array => d3.max(array))

from d3-array.

That would be cool!

Could even simplify to:

d3.extent(arrays, d3.min, d3.max)

from d3-array.

@curran Unfortunately, no, because d3.extent passes the accessor additional arguments (the index and array), and d3.min and d3.max interpret the additional arguments as an accessor. It’s equivalent to:

d3.extent(arrays, (array, i) => d3.min(array, i), (array, i) => d3.max(array, i))

Which results in

TypeError: valueof is not a function

We could change all the functions with optional accessors to ignore accessors that aren’t functions, but that’s always felt dirty to me; I prefer to limit our overloading to checking whether an argument is null.

We could support currying instead of optional arguments. So instead of:

d3.min(array, d => d.value)

You’d by the value accessor to d3.min using d3.min.by:

d3.min.by(d => d.value)(array)

If you just had an array of values, it’d be the same as before:

d3.min(values)

Now if you want to compose with d3.extent to compute the extent of an array of arrays of values, you can say:

d3.extent.by(d3.min, d3.max)(arrays)

But this change wouldn’t be backwards-compatible.

from d3-array.

Aha! An interesting gotcha.

Now it's interesting to compare these two alternatives:

d3.extent(arrays, array => d3.min(array), array => d3.max(array))

d3.extent.by(d3.min, d3.max)(arrays)

The latter is more concise but feels more heavy in terms of API surface area.

from d3-array.