What is a ListMixin<> in Dart?

A mixin is a way of reusing a class's code in multiple class hierarchies without inheritance. They are like abstract classes containing methods and properties that can be added to other classes.

Mixins in Dart

To define a mixin, we use the mixin keyword followed by the name of the mixin. The mixin can contain methods, getters, setters, and fields like a regular class. However, mixins can't have constructors and can't be instantiated directly.

Below is an example of a simple mixin that provides a hello method:

import 'dart:convert';
import 'dart:collection';
mixin GreetingMixin {
  void hello(String name) {
    print('Hello, $name!');
  }
}

In the above snippet, we define the GreetingMixin that provides a hello method.

To use the above-defined mixin, we can apply it to a class using the with keyword:

class Person with GreetingMixin {
  String name;
  Person(this.name);
}
void main() {
  final person = Person('Alice');
  person.hello(person.name); // prints "Hello, Alice!"
}

We define a Person class and apply the GreetingMixin to it using the with keyword.

When we create a Person object and call its hello method, the hello method from the GreetingMixin is called, and the output is "Hello, Alice!".

What is a ListMixin?

A ListMixin is a Dart mixin that provides a set of methods that can be used to implement a collection that acts like a list. It can be used as a mixin to make a class implement the List interface.

Here is an example of its usage:

import 'dart:convert';
import 'dart:collection';
class MyList with ListMixin<String> {
  List<String> _list = [];
  @override
  int get length => _list.length;
  @override
  set length(int newLength) => _list.length = newLength;
  @override
  String operator [](int index) => _list[index];
  @override
  void operator []=(int index, String value) {
    _list[index] = value;
  }
  @override
  void add(String value) => _list.add(value);
  @override
  void addAll(Iterable<String> iterable) => _list.addAll(iterable);
  @override
  bool remove(Object value) => _list.remove(value);
  @override
  void clear() => _list.clear();
}
void main() {
  final myList = MyList()
    ..add('foo')
    ..add('bar')
    ..addAll(['baz', 'qux']);
  print(myList.length); // 4
  myList[1] = 'updated';
  print(myList); // [foo, updated, baz, qux]
  myList.remove('baz');
  print(myList); // [foo, updated, qux]
  myList.clear();
  print(myList); // []
}

  • Lines 3–4: We create a new class called MyList that implements the ListMixin<String>. We define a private _list field that holds the actual list data.

  • Lines 6–10: We begin overriding some of the methods from the ListMixin class. Firstly, we override the length methods. We override the setter and getter functions. They allow us to set the list's length or fetch the list's length.

  • Lines 12–18: Here, we override the [] and the []= operator of the ListMixin class. We override these operators to use them for any MyList class objects we make.

  • Lines 20–24: We override the add and addAll methods. These methods allow us to add elements to our MyList object. The add method is used to add a single element to the list, while the addAll method is used to add a list of elements to the list.

  • Lines 26–30: Finally, we override the remove and clear functions. The remove function lets us delete a single element from the MyList object. In comparison, the clear function deletes all the elements in the MyList object.

  • Lines 35–51: Finally, in the main function, we create a new instance of MyList and add some elements. We then show that our MyList object acts like a list by calling various list methods, such as length, operator[], remove, and clear.

Free Resources

Copyright ©2026 Educative, Inc. All rights reserved