classify a user struct as an "array" or "slice"

[Paul Backus]

On Friday, 20 August 2021 at 15:12:25 UTC, james.p.leblanc wrote:
> Greetings,
>
> I have a user created struct, let's call this "**fakeArray**":
>
> For all intents and purposes fakeArray behaves like an array 
> (or slice, I guess).
> (i.e. It has a number of operator overloadings, and *foreach* 
> extensions implemented.)
>
> I have a fairly large number of function in a module that 
> accept arrays (or slices).
>
> These are implemented as:
>
> **auto foo(T)(T[] x) { ... }**
>
> So, foo will accept "official" arrays and slices.
>
> What is the easiest way to coerce all my functions to also
> accept my fakeArray?

The most straightforward way would be to change your functions 
from accepting only `T[]` to accepting either `T[]` or 
`fakeArray`. For example:

```d
import std.traits: isDynamicArray;

// assuming `fakeArray` is a template struct/class
enum isFakeArray(T) = is(T == fakeArray!U, U);

auto foo(Array)(Array x)
     if (isDynamicArray!Array || isFakeArray!Array)
{
     // ...
}
```

The `if (...)` part there is a [template constraint][1]. It means 
that the template can only be instantiated when the condition 
evaluates to `true`.

[1]: https://dlang.org/spec/template.html#template_constraints