This is an odd question so let me motivate it by an example. Say we have a Vector of Vectors: `a = [[3];[2;3];[3;1]]`

. These types may be easier to handle if one could directly index them, so we define a wrapper type `VecVec`

with the indexing scheme `a[i,j] = a[i][j]`

. Using dispatches we can define `:`

, so `a[:,1]`

creates a vector which is the first component of each. This all makes sense. This has a natural `length`

to it, which is not the number of elements, but the length of the actual higher level vector.

However, there is no definable `size`

because that would guarantee that its a vector of vectors, where each internal vector has the same size. This means that `end`

doesnâ€™t work: `a[2:end,1]`

doesnâ€™t work. However, there is a proper invariant that `end`

can mean for the first dimension, and that is `a[2:length(a),1]`

.

Is there a way to be able to specify that exact relationship? Or does one have to resort to size, which isnâ€™t always definable in this case? Note that having all of the vectors the same size is a common property, so maybe if there was a way to conditionally have a `size`

for a `VecVec`

I would be fine, but is there a way to do that without duplicating the type? The way I can think of doing it is:

- Duplicate the type
- Make an abstract type which covers them
- Make all of the previous dispatches to the abstract type
- Add a specific dispatch for
`size`

to one of them

But the problem here is that, for my actual use case this will lead to non-inferability of the type.

So is there a good way to do this? Or should I just give up and say â€śuse length in the first dimensionâ€ť?

[For reference this is related to an open issue: https://github.com/JuliaDiffEq/DifferentialEquations.jl/issues/123]