Informe mensual completo del libro de cuentas

Gana FxDart

Requisito

A partir de un mes de transacciones del libro de cuentas (los datos están en el código), construye una única cadena de informe con tres secciones: el total gastado (sin contar los ingresos), un desglose por categoría ordenado por gasto y los 3 comercios principales como lista numerada. Ambas versiones deben imprimir exactamente el informe que aparece bajo Salida esperada.

Salida esperada

July 2026 ledger
Total spent: $201.99

By category:
  Bills      $88.44
  Food       $84.40
  Fun        $15.00
  Transport  $14.15

Top merchants:
  1. Electric Co  $60.34
  2. Green Grocer $43.20
  3. Water Works  $28.10

Lado a lado

Dart nativo

import 'package:collection/collection.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);
}

const txns = [
  Tx('2026-07-01', 'Income', 'Payroll Inc', 2600.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', 'Food', 'Cafe Aroma', 9.80),
  Tx('2026-07-21', 'Bills', 'Water Works', 28.10),
  Tx('2026-07-23', 'Transport', 'Taxi', 11.40),
];

String money(num n) => '\$${n.toStringAsFixed(2)}';

void main() {
  final spend = txns.where((t) => t.category != 'Income').toList();
  final total = spend.fold(0.0, (s, t) => s + t.amount);

final catTotals = spend
      .groupListsBy((t) => t.category)
      .entries
      .map((e) => (e.key, e.value.fold(0.0, (s, t) => s + t.amount)))
      .sortedBy<num>((c) => -c.$2);
  final catLines = [
    for (final c in catTotals) '  ${c.$1.padRight(10)} ${money(c.$2)}',
  ];

final merchantTotals = spend
      .groupListsBy((t) => t.merchant)
      .entries
      .map((e) => (e.key, e.value.fold(0.0, (s, t) => s + t.amount)))
      .sortedBy<num>((m) => -m.$2)
      .take(3)
      .toList();
  final merchantLines = <String>[];
  for (var i = 0; i < merchantTotals.length; i++) {
    final m = merchantTotals[i];
    merchantLines.add('  ${i + 1}. ${m.$1.padRight(13)}${money(m.$2)}');
  }

print([
    'July 2026 ledger',
    'Total spent: ${money(total)}',
    '',
    'By category:',
    ...catLines,
    '',
    'Top merchants:',
    ...merchantLines,
  ].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);
}

String money(num n) => '\$${n.toStringAsFixed(2)}';

void main() {
  final spend = fx(txns).filter((t) => t.category != 'Income').toList();
  final total = fx(spend).sumBy((t) => t.amount);

final catLines = fx(
          fx(spend).foldBy((t) => t.category, 0.0, (s, t) => s + t.amount).entries)
      .map((e) => (e.key, e.value))
      .sortBy((c) => -c.$2)
      .map((c) => '  ${c.$1.padRight(10)} ${money(c.$2)}');

final merchantLines = fx(
          fx(spend).foldBy((t) => t.merchant, 0.0, (s, t) => s + t.amount).entries)
      .map((e) => (e.key, e.value))
      .sortBy((m) => -m.$2)
      .take(3)
      .zipWithIndex()
      .map((p) => '  ${p.$1 + 1}. ${p.$2.$1.padRight(13)}${money(p.$2.$2)}');

print(join('\n', [
    'July 2026 ledger',
    'Total spent: ${money(total)}',
    '',
    'By category:',
    ...catLines,
    '',
    'Top merchants:',
    ...merchantLines,
  ]));
}

Por qué difieren

En FxDart cada sección del informe tiene la misma forma: groupBy → sumBy por grupo → sortBy descendente —y después take y zipWithIndex convierten la sección de comercios en un top 3 numerado sin ninguna variable de índice. La versión nativa tiene que expresar cada uno de esos pasos en un dialecto distinto: fold con un valor inicial para cada suma, sortedBy<num> con una clave negada, un collection-for para una sección y un bucle for indexado para la otra. El informe crece sección a sección en ambos lados —pero solo uno de los dos crece añadiendo pasos al pipeline en vez de acumulando variables intermedias con formas distintas.

Benchmark

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

N = 100

Tiempo Empate

Dart nativo 24 µs

FxDart 30 µs

Memoria pico Empate

Dart nativo 16.5 MB

FxDart 16.6 MB

N = 10,000

Tiempo Empate

Dart nativo 934 µs

FxDart 442 µs

Memoria pico Gana FxDart

Dart nativo 23.4 MB

FxDart 17.2 MB

N = 1,000,000

Tiempo Gana FxDart

Dart nativo 135.1 ms

FxDart 47.3 ms

Memoria pico Gana FxDart

Dart nativo 157.8 MB

FxDart 127.0 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í.