Covariance for []
Hello, I was wondering why the following code does not compile. ```d import std; abstract class Range(T) { abstract T back(); abstract bool empty(); abstract T front(); abstract void popBack(); abstract void popFront(); } class RangeWrapper(TRange) : Range!(ForeachType!(TRange)) { alias TValue = ForeachType!(TRange); private TRange _range; this(TRange range) { _range = range; } override TValue back() { return _range.back(); } override bool empty() { return _range.empty(); } override TValue front() { return _range.front(); } override void popBack() { return _range.popBack(); } override void popFront() { return _range.popFront(); } } auto wrap(TRange)(TRange range) { return new RangeWrapper!TRange(range); } class A { } class B : A { } class C : A { private B[] _bs; this() { _bs = [new B(), new B()]; } Range!A as() { return wrap(_bs); } } void main() { } ``` I receive the following error. ```d onlineapp.d(73): Error: cannot implicitly convert expression `wrap(this._bs)` of type `onlineapp.RangeWrapper!(B[])` to `onlineapp.Range!(A)` ``` Anyone have any idea how I can achieve [covariance](https://en.wikipedia.org/wiki/Covariance_and_contravariance_(computer_science)#Formal_definition) for `[]`?
Re: Covariance for []
On Thursday, 19 January 2023 at 12:54:39 UTC, davemo wrote: Hello, I was wondering why the following code does not compile. ```d import std; [...] It looks like the following change works fine. ```d Range!A as() { return wrap(_bs.map!((b) { return cast(A) b; })); } ```