I'm trying to implement a *perfect* Integral type without implicit conversions to its underlying type (only explicit ones), and am stumbling against the following:

```
std::array<Integral, 10>a{{...}};
Integral index{5};
a[index] = ...; //error: no implicit conversion between Integral and std::size_t

```

There is a similar problem with C arrays. AFAIK the problem is that `operator[]` expects a specific type. If your type does not match the expected one and is not implicitly convertible to it, the only solutions I can think of are an explicit cast, a getter, and a `get` function to be applied on the array. 

Is it possible to achieve something similar to the `explicit operator bool` (i.e. to be implicitly convertible *under specific circumstances only*) but for the `operator[]` ?

Writing `a[static_cast<std::size_t>(index)]` kind of defeats the purpose of writing an Integral type.