Mensajes de error recientes, sin duplicados

Gana FxDart

Requisito

Un almacén de logs devuelve las entradas de más nueva a más antigua. Muestra los tres mensajes de error distintos más recientes: quédate solo con las entradas ERROR, descarta las repeticiones de un mensaje ya mostrado y detente después de tres. Los datos están en el código de abajo; ambas versiones deben imprimir las líneas que aparecen bajo Salida esperada.

Salida esperada

09:41 payment gateway timeout
09:31 inventory service 503
09:17 invalid session token

Lado a lado

Dart nativo

FxDart

import 'package:fxdart/fxdart.dart';

class Log {
  final String time;
  final String level;
  final String message;
  const Log(this.time, this.level, this.message);
}

// Newest first, as a log store would return them.
const logs = [
  Log('09:41', 'ERROR', 'payment gateway timeout'),
  Log('09:40', 'INFO', 'checkout started'),
  Log('09:38', 'ERROR', 'payment gateway timeout'),
  Log('09:35', 'WARN', 'retrying request'),
  Log('09:31', 'ERROR', 'inventory service 503'),
  Log('09:28', 'INFO', 'cache warmed'),
  Log('09:22', 'ERROR', 'payment gateway timeout'),
  Log('09:17', 'ERROR', 'invalid session token'),
  Log('09:12', 'ERROR', 'disk quota exceeded'),
  Log('09:05', 'INFO', 'server started'),
];

/// The same three rows in one strict pass, for when the pipeline is hot.
///
/// A lazy stage keeps its callback in an iterator field, and the AOT compiler
/// cannot see through a field — so neither closure in `main` below is ever
/// inlined, and the two calls per element are most of what separates this
/// pipeline from a hand-written loop. `takeUniqBy` takes its callback as a
/// parameter of a function small enough to inline into the caller, so the
/// compiler inlines the closure body with it. One callback does both jobs
/// here: a `null` key means "skip this element".
///
/// Over 1,000,000 log lines, AOT: **13.9 ms** for the chain in `main`,
/// **11.2 ms** for this, **10.4 ms** for the hand-written loop the native
/// panel shows. Reach for it when a profile says these callbacks are the
/// cost; the chain below is what reads, and it is the one to write by
/// default.
List<Log> recentErrorsStrict() =>
    takeUniqBy(3, (l) => l.level == 'ERROR' ? l.message : null, logs);

void main() {
  // The composable form: three independent steps, each readable on its own,
  // and lazy — `take(3)` stops the scan at the third distinct message.
  final recent = fx(logs)
      .filter((l) => l.level == 'ERROR')
      .uniqBy((l) => l.message)
      .take(3);
  for (final l in recent) {
    print('${l.time} ${l.message}');
  }
}

Por qué difieren

Dart no tiene un «distinto por clave»: deduplicar por mensaje significa gestionar tú mismo un Set, así que la versión nativa se convierte en un bucle con tres asuntos trenzados: la comprobación del nivel, el truco del seen.add y un break con contador. Cada uno por separado está bien; juntos te obligan a leer el bucle entero para ver qué es lo que conserva. FxDart enuncia las tres reglas como tres pasos de la cadena —filter, uniqBy, take— y, como la cadena es perezosa, también deja de recorrer el log en el momento en que encuentra el tercer error distinto, exactamente igual que el break escrito a mano.

Benchmark

Apple M1 Max, 32 GB de RAM · Dart 3.12.2 (compilado AOT) · 2026-08-24

N = 100

Tiempo Empate

Dart nativo 1.0 µs

FxDart 1.3 µs

Memoria pico Empate

Dart nativo 16.5 MB

FxDart 16.5 MB

N = 10,000

Tiempo Empate

Dart nativo 90 µs

FxDart 127 µs

Memoria pico Empate

Dart nativo 15.8 MB

FxDart 15.8 MB

N = 1,000,000

Tiempo Gana nativo

Dart nativo 10.3 ms

FxDart 13.7 ms

Memoria pico Empate

Dart nativo 114.3 MB

FxDart 113.5 MB

Las barras son medianas de iteraciones cronometradas repetidas en procesos nuevos por lado (los N pequeños se agrupan por resolución del temporizador). Dos lados a menos del 5% entre sí — o a menos de 0.6 ms, una diferencia que nadie puede percibir — cuentan como empate; las carreras relativas ajustadas se vuelven a medir hasta 5 veces. En una app, cualquier cosa por debajo de unos pocos milisegundos es invisible para el usuario, gane la barra que gane. La memoria es el RSS pico del proceso. La VM de Dart y el dataset son idénticos en ambos lados, así que la diferencia entre las dos barras es lo que retiene el pipeline en sí.