`uniqStrict`

Dedupes the whole iterable immediately and returns a List — the eager counterpart of distinct.

List<A> uniqStrict<A>(Iterable<A> iterable) List<A> uniqByStrict<A, B>(B Function(A a) f, Iterable<A> iterable) Fx<T> Fx.uniqStrict() // chain Fx<T> Fx.uniqByStrict<B>(B Function(T a) f)

Lecture

uniqStrict produces exactly the same elements, in the same order, as distinct followed by toList(). What differs is when the work happens and who can stop it. uniqByStrict is the same deal for distinctBy: dedupe on a computed key, eagerly.

A lazy chain re-runs its upstream on every iteration. Iterate distinct(...) twice and the source is walked twice. The strict form walks it once, at the call, and hands you a List — so a result you are going to index, measure, or scan more than once costs you one pass instead of n. Demo 2 counts the callbacks to make this concrete.

The price is that nothing downstream can cut the work short. distinct(xs).take(3) stops pulling xs as soon as 3 distinct values have appeared; uniqStrict(xs).take(3) dedupes all of xs first and then takes 3. Never put the strict form ahead of a short-circuiting consumer, and never point it at an unbounded iterable — it will not terminate.

Default to lazy. distinct(...).toList() already runs the dedupe and the accumulation as a single pass, so it is not paying for laziness. Reach for uniqStrict only when the deduped List is itself the thing you want, or when it is iterated more than once.

Demo 1 · Basics

Demo 2 · When it pays, and what it costs

import 'package:fxdart/fxdart.dart';

// The whole point of the strict form: WHEN the upstream runs.
void main() {
  final ids = [3, 1, 3, 2, 1, 2];

// Lazy: nothing has run yet, and the upstream re-runs on every iteration.
  var lazyCalls = 0;
  final lazy = fx(ids).map((a) {
    lazyCalls++;
    return a;
  }).distinct();
  print('lazy, before iterating: $lazyCalls'); // 0
  print(lazy.toList()); // [3, 1, 2]
  print(lazy.toList()); // [3, 1, 2]
  print('lazy, after 2 passes: $lazyCalls'); // 12 -- ran twice

// Strict: the upstream runs once, right here at the call.
  var strictCalls = 0;
  final strict = fx(ids).map((a) {
    strictCalls++;
    return a;
  }).uniqStrict();
  print('strict, before iterating: $strictCalls'); // 6 -- already done
  print(strict.toList()); // [3, 1, 2]
  print(strict.toList()); // [3, 1, 2]
  print('strict, after 2 passes: $strictCalls'); // 6 -- still once

// The trade-off: nothing downstream can cut a strict pass short.
  var lazyScanned = 0;
  fx(ids).map((a) {
    lazyScanned++;
    return a;
  }).distinct().take(2).toList();
  print('lazy + take(2) scanned: $lazyScanned'); // 2 -- stopped early

var strictScanned = 0;
  fx(ids).map((a) {
    strictScanned++;
    return a;
  }).uniqStrict().take(2).toList();
  print('strict + take(2) scanned: $strictScanned'); // 6 -- scanned it all
}

Try it yourself

Exercise: use uniqByStrict to keep each visitor's first visit, as a List you can index without iterating again.

Related: distinct — the lazy default · distinctBy — dedupe by a computed key · uniqAdjacent — drop only adjacent duplicates · toList — materialize any chain