Thanks @Ben_Cohen for the additional information. I have started thinking about how I would ideally like to see the implementation of `RandomAccessCollection`

work in this regard.

My first thought was that the extension should be constrained with respect to `Index`

alone. That is, `where Index: Strideable, Index.Stride == Int`

. However, that doesnāt quite work, because it would effectively have `typealias Indices = Range<Index>`

in the extension, and thereby interfere with concrete types that use something else for `Indices`

.

Essentially, `RandomAccessCollection`

wants to say, āWhen `Indices`

is undetermined, make it `Range<Index>`

if possible and provide this default implementation.ā

Conversely, in Adrianās example, the `Test`

protocol wants to say, āIf and only if `Something`

is determined to be `Int`

, then provide this default implementation.ā

Logically, `RandomAccessCollection`

ought to provide a *constrained default value* for `Indices`

. This is not currently possible, but it might look like this if we allowed it:

```
extension RandomAccessCollection
where Index: Strideable,
Index.Stride == Int
{
// Provide a default value for the associated type
default associatedtype Indices = Range<Index>
}
extension RandomAccessCollection
where Index: Strideable,
Index.Stride == Int,
Indices == Range<Index>
{
// Provide the default implementation
var indices: Range<Index> { return startIndex ..< endIndex }
}
```

I donāt know if or how this would work āunder the hoodā, but from a programmerās perspective it follows expectations much more naturally.