Setting a hard limit on slice size, is this possible?

[Tejas]

On Friday, 6 August 2021 at 18:02:01 UTC, james.p.leblanc wrote:
> mes
> On Friday, 6 August 2021 at 17:25:24 UTC, Tejas wrote:
>>
>> Okay we were overthinking the solution.
>>
>> Just use a static array
>>
>> ```d
>> int[your_max_length]/*or whatever type*/ var;
>> ```
>>
>> You're good to go!
>>
>> I almost feel stupid now lol
>
> Hello Tejas,
>
> Kind thanks for your replies ... all are appreciated.
>
> However, do NOT feel stupid ... the motivation behind why
> I cannot use a standard int[your_max_length] (in other words,
> use a static array), is because I need to do a specified
> memory alignment (known at compile time) on my slice, or array.
>
> I understand that neither a slice or an array is capable to 
> doing
> an arbitrary memory alignment.  (But, perhaps I am wrong about 
> this ...)
>
> I believe structs can be aligned, but need to learn more about
> the speicific of that.
>
> In the meantime, I  have written a way to get an aligned slice 
> from a
> static array.  Ugly beginner code is below.  While I believe 
> this basic
> idea should work, I would like to guarantee that my slice does 
> not get
> moved in memory (destroying the alignment).
>
> Ugly code here:
>
> ----------------------------------------------
>
> import std.stdio;
>
> enum MAXLENGTH = 1024;
> enum ALIGN = 128;
>
> void main(){
>
>    // static array to allow creation of aligned slice
>    ubyte[MAXLENGTH+ALIGN] u;
>
>    writeln("u.ptr:  ", u.ptr);
>    auto u_i = cast(ulong) u.ptr;
>
>    auto u_excess = u_i%ALIGN;
>    writeln("u_excess: ", u_excess);
>
>    ulong mustadd;
>    if(u_excess !=0){
>    mustadd = ALIGN-u_excess;
>    }
>    writeln("mustadd:  ", mustadd);
>
>    // create aligned pointer for our needed slice
>    auto zp = cast(double*) (u.ptr + mustadd);
>
>    // create slice
>    double[] z = zp[0 .. MAXLENGTH];
>    writeln("z.ptr:  ", z.ptr);
>    writeln("z.length:  ", z.length);
>    auto z_i = cast(ulong) z.ptr;
>    auto z_excess = z_i%ALIGN;
>    writeln("z_excess:  ", z_excess);
> }

If you're being that specialized, don't bother with fundamental 
data types, the hunt for simplicity will lead you to create very 
complex things.

As HS Teoh said, take a look at ```align```:
https://dlang.org/spec/attribute.html#align

Stealing Paul's answer now:
```d
import std;

enum your_max_length = 1000;
enum your_align = 256;
struct MySlice(T/*, size_t maxLength*/)
{
     private align(your_align)T payload;

     //invariant(payload.length <= maxLength);

     //this(T[] slice) { payload = slice; }

     //T opIndex(size_t i) { return payload[i]; }
}
void main()
{
    MySlice!(int/*, 1000*/)[your_max_length] slice;
     writeln(slice.sizeof);
}
```