A mixin that adds reactive List methods and operators to a Signal
holding a List value.
This mixin delegates all standard List operations (such as mutations like add,
remove, insert, sort, and clear, and accessor operators like
[] and []=)
to the underlying list, while ensuring that any reads register a dependency
and any mutations automatically trigger reactive updates.
This mixin only works with signals that have a value type extending List.
Example Usage#
import 'package:signals/signals.dart';
class MyListSignal extends Signal<List<int>>
with IterableSignalMixin<int, List<int>>, ListSignalMixin<int, List<int>> {
MyListSignal(super.internalValue);
}
void main() {
final numbers = MyListSignal([1, 2, 3]);
effect(() {
print('Elements: $numbers, Length: ${numbers.length}');
}); // Prints: "Elements: [1, 2, 3], Length: 3"
// Adding an element (automatically calls set() and triggers updates)
numbers.add(4); // Prints: "Elements: [1, 2, 3, 4], Length: 4"
// Modifying an element by index (triggers updates)
numbers[0] = 10; // Prints: "Elements: [10, 2, 3, 4], Length: 4"
}
Since mutations on
ListSignalMixin notify listeners automatically, you do not
need to assign numbers.value = ... to force updates. Methods like add, addAll,
and operator []= take care of notification.
Methods#
View Methods
List cast()
first(E val)
E last
last(E val)
length(int value)
List +(List other)
E [](int index)
void []=(int index, E value)
void add(E value)
void addAll(Iterable iterable)
Map<int, E> asMap()
void clear()
Iterable expand(Iterable Function(E element) toElements)
void fillRange(int start, int end, [E? fillValue])
E firstWhere(bool Function(E element) test, {E Function()? orElse})
R fold(R initialValue, R Function(R previousValue, E element) combine)
Iterable followedBy(Iterable other)
Iterable getRange(int start, int end)
int indexOf(E element, [int start = 0])
int indexWhere(bool Function(E element) test, [int start = 0])
void insert(int index, E element)
void insertAll(int index, Iterable iterable)
int lastIndexOf(E element, [int? start])
int lastIndexWhere(bool Function(E element) test, [int? start])
bool remove(Object? value)
E removeAt(int index)
E removeLast()
void removeRange(int start, int end)
void removeWhere(bool Function(E element) test)
void replaceRange(int start, int end, Iterable replacements)
void retainWhere(bool Function(E element) test)
Iterable reversed
void setAll(int index, Iterable iterable)
void setRange(int start, int end, Iterable iterable, [int skipCount = 0])
void shuffle([Random? random])
void sort([int Function(E a, E b)? compare])
List sorted([int Function(E a, E b)? compare])
Return a new array that is sorted by the compare function