I see mainly 2 use cases :

- define additionnal methods

```dart
class Cart extends DelegatingList<Order> {
  final List<Order> orders;
  Cart() : this._([]);
  Cart._(List<Order> orders) : this.orders = orders, super(orders);

  // custom methods
  num computePrice() => 42;
  num computeWeight() => 42;
}
```

- customize the list behaviour or override some method 

```dart
class UnsortableList<E> extends DelegatingList<E> {
  final List<E> l;
  UnsortableList() : this._([]);
  UnsortableList._(List<E> l) : this.l = l, super(l);

  // no sort
  void sort([int compare(E a, E b)]) => throw 'not sortable';
  
  // log clear calls
  void clear() {
    log.info('clear call');
    super.clear();
  }
}
```

For this second use case a _get delegate_ would allow to bypass the custom behaviour with `unsortableList.delegate.sort()`. So the _delegate_ getter prevents to cover this second use case.

I also like _mixins_ and it could be useful to cover the first use case.

@cbracken : the main advantage of a `DelegatingListMixin` over `ListMixin` is performance. For instance the `addAll` method will use one call to the _delegate_ with `DelegatingListMixin` and 3*N calls with `ListMixin`.