Informe mensual por categorías, ordenado por gasto

Gana FxDart

Requisito

A partir de un libro de cuentas que se desborda de junio a julio de 2026, construye el informe de gasto de julio: quédate solo con las transacciones de julio, suma cada categoría e imprime una línea por categoría —primero el mayor gasto. Los datos están en el código de abajo; ambas versiones deben imprimir las líneas que aparecen bajo Salida esperada.

Salida esperada

Food: $74.60
Bills: $60.34
Fun: $23.25
Transport: $14.15

Lado a lado

Dart nativo

class Tx {
  final String date;
  final String category;
  final String merchant;
  final double amount;
  const Tx(this.date, this.category, this.merchant, this.amount);
}

const txns = [
  Tx('2026-06-28', 'Food', 'Green Grocer', 31.10),
  Tx('2026-06-30', 'Bills', 'Water Co', 24.00),
  Tx('2026-07-02', 'Food', 'Cafe Aroma', 12.50),
  Tx('2026-07-03', 'Transport', 'Metro', 2.75),
  Tx('2026-07-05', 'Food', 'Green Grocer', 43.20),
  Tx('2026-07-08', 'Fun', 'Cinema', 15.00),
  Tx('2026-07-11', 'Food', 'Noodle Bar', 18.90),
  Tx('2026-07-15', 'Bills', 'Electric Co', 60.34),
  Tx('2026-07-19', 'Transport', 'Taxi', 11.40),
  Tx('2026-07-23', 'Fun', 'Arcade', 8.25),
];

void main() {
  final totals = <String, double>{};
  for (final t in txns) {
    if (!t.date.startsWith('2026-07')) continue;
    totals[t.category] = (totals[t.category] ?? 0) + t.amount;
  }
  final rows = totals.entries.toList()
    ..sort((a, b) => b.value.compareTo(a.value));
  print(rows
      .map((row) => '${row.key}: \$${row.value.toStringAsFixed(2)}')
      .join('\n'));
}

FxDart

import 'package:fxdart/fxdart.dart';

class Tx {
  final String date;
  final String category;
  final String merchant;
  final double amount;
  const Tx(this.date, this.category, this.merchant, this.amount);
}

/// July's spend per category in one strict pass, for when the pipeline is hot.
///
/// `filter` is a lazy stage: it keeps its predicate in an iterator field, and
/// the AOT compiler cannot see through a field, so that predicate is never
/// inlined and costs a real indirect call on every transaction. `foldByOrSkip`
/// takes the same test as part of its **key** — a `null` key skips the row —
/// and the key is a parameter of a body small enough to inline into the
/// caller, so the compiler inlines it.
///
/// Over 1,000,000 transactions, AOT: **14.0 ms** for the chain in `main`,
/// **11.7 ms** for this, **11.3 ms** for the hand-written loop the native
/// panel shows. Worth reaching for when a profile says that predicate is the
/// cost — the chain below is the one to write by default, because two named
/// steps read better than one callback answering two questions.
Map<String, double> julySpendStrict() => fx(txns).foldByOrSkip(
  (t) => t.date.startsWith('2026-07') ? t.category : null,
  0.0,
  (sum, t) => sum + t.amount,
);

void main() {
  final byCategory = fx(txns)
      .filter((t) => t.date.startsWith('2026-07'))
      .foldBy((t) => t.category, 0.0, (sum, t) => sum + t.amount);
  final report = fx(byCategory.entries)
      .map((kv) => (kv.key, kv.value))
      .sortBy((row) => -row.$2)
      .map((row) => '${row.$1}: \$${row.$2.toStringAsFixed(2)}')
      .join('\n');
  print(report);
}

Por qué difieren

Dart nativo no tiene groupBy, así que el bucle hace la agrupación y la suma a la vez dentro de un mapa mutable —compacto, pero los cuatro requisitos (solo julio, por categoría, sumado, ordenado) quedan enredados en un mismo cuerpo. La cadena de FxDart los mantiene como cuatro pasos visibles: filter por el mes, groupBy por categoría, map de cada grupo a su total, sortBy descendente —y join da formato al informe. Añadir un requisito (digamos, un total mínimo) es un paso más en la cadena; en el bucle es otra rama dentro de un cuerpo que ya estaba cargado.

Benchmark

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

N = 100

Tiempo Empate

Dart nativo 2.3 µs

FxDart 6.2 µs

FxDart (estricto) 6.0 µs

Memoria pico Empate

Dart nativo 16.5 MB

FxDart 16.3 MB

FxDart (estricto) 16.5 MB

N = 10,000

Tiempo Empate

Dart nativo 106 µs

FxDart 139 µs

FxDart (estricto) 119 µs

Memoria pico Gana FxDart

Dart nativo 17.0 MB

FxDart 16.0 MB

FxDart (estricto) 16.0 MB

N = 1,000,000

Tiempo Gana nativo

Dart nativo 11.3 ms

FxDart 14.5 ms

FxDart (estricto) 12.6 ms

Memoria pico Empate

Dart nativo 120.4 MB

FxDart 120.0 MB

FxDart (estricto) 119.8 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í.