Hi @swfsql, and welcome to the ecosystem!

Will you please provide more information about the motivation for doing this? I generally find it convenient to use 5 instead of (5,) and haven't experienced any problems with this. If you want to use (usize,) as the type instead of usize, that's supported too.

Thanks @jturner314 ,
I initially got motivated when I called .dim() I expected a (usize,) return type - as an inexperienced user - since I was used to understand tuple length as dimension quantity after using the crate for a while.

This specific change - the return type of dim() - doesn't implies the additional change about building dimension information - about using usize or (usize,) for dimension construction - but I thought that for symmetry, if one change happened, the other should follow.

I hope this helps clarifying - and I'd like to restate that this is a pretty subjective ergonomic opinion from an inexperienced user! (and this change would surely be not welcomed for most users I believe)

Oh, okay, you're talking about Ix1::Pattern. I misunderstood. (I should have read the PR.)

Now that Rust supports destructuring fixed-size arrays in addition to tuples, I actually think we should change all the Dimension::Pattern types for const-dimensions from tuples to fixed-size arrays, so we'd have

• Ix0::Pattern = [usize; 0]
• Ix1::Pattern = [usize; 1]
• Ix2::Pattern = [usize; 2]
• ...
• Ix6::Pattern = [usize; 6]
• IxDyn::Pattern = IxDyn

Length-one arrays are syntactically nicer than one-element tuples because they don't need the extra trailing comma. Additionally, arrays are more convenient than tuples because they can be iterated over easily.

@swfsql, @LukeMathWalker, @bluss Thoughts?

@jturner314 I've submitted a PR for reference.
The changes were pretty straightforward and I personally think it's user-friendly to always use arrays for constant dimensions. But it still required a lot of changes, so this still would be a drastic change, api-wise.

Sorry for the delay in answering, but it's quite an intense period.
The change itself looks pretty good to me.
On the other hand though, are we gaining enough from this change considering its breaking one of the core interfaces?

I know we have plans to review the way the whole dimension story works, and those plans will probably have to take into account the new language features that we could use to make the API nicer (e.g. const generics and GAT, for this specific case). Should we repeatedly iterate on this section of the API or should we try to batch improvements together?

@LukeMathWalker I personally would enjoy the change but I agree, I don't it's worth for other users.
And for everyone, surely, it wound't worth to have a drastic API change that is destined to be changed again.

On the other hand, I think there is a chance that the interface (exclusively) pushed by const generics would likely be this very change (tuples -> fixed-sized arrays). But a more drastic re-design may change it completely, so there would really be no-gains for this change.

I think that we will end up switching from tuples to fixed-size arrays anyway when we overhaul the Dimension types. However, @LukeMathWalker makes a good point that since this change isn't urgent, we should wait to make it at the same time as all the other breaking changes to the Dimension types.

So, let's postpone this until we overhaul the Dimension types. That is currently blocked on const generics, specialization, and generic associated types. Fortunately, the Rust roadmap includes all of those features for this year.