Add .stride field to slices

[daurnimator]

I propose that if you have a type T=struct{foo: U} and slice []T, accessing a slice with a field ([]T.foo) returns a slice []U with stride @sizeOf(T).

Example use case:

const entry = struct {
   key: []const u8,
   value: []u8,
}
const entrylist = std.ArrayList(entry);
fn getKeys(self: entrylist) [][]const u8 {
    return self.toSlice().key; // returns slice with stride equal to @sizeOf(entry)
}
fn getKeyList(self: entrylist, allocator: *Allocator) []u8 {
    return std.mem.join(allocator, ",", self.getKeys());
}
fn getValues(self: entrylist) [][]const u8 {
    return self.toSlice().value; // returns slice with stride equal to @sizeOf(entry)
}
fn getValueList(self: entrylist, allocator: *Allocator) []u8 {
    return std.mem.join(allocator, ",", self.getValues());
}

I think, if we do this, the type system will need to know -- or else we make every slice 3 usizes when for most applications we only need 2. Also, as written, there's a syntactic ambiguity: what if T has a field named len?

[daurnimator]

I think, if we do this, the type system will need to know -- or else we make every slice 3 usizes when for most applications we only need 2.

This is likely to dovetail nicely with #1830

Also, as written, there's a syntactic ambiguity: what if T has a field named len?

Good point! we might need some sort of other indexing operation (or helper) on slices.

The base proposal of adding a .stride field still stands

[lunacookies]

Is there any point in having a slice/array type which has a comptime-determined stride (analogous to how there is a type for arrays with a comptime-determined length)?