Categorías que superan su presupuesto mensual

Gana FxDart

Requisito

Cada categoría de gasto tiene un presupuesto mensual. A partir de las transacciones de julio, suma el total de cada categoría, quédate solo con las categorías que se pasaron de su presupuesto e imprímelas empezando por la peor —con el gasto, el presupuesto y el exceso en cada línea. Los datos están en el código de abajo; ambas versiones deben imprimir las líneas que aparecen bajo Salida esperada.

Salida esperada

Over budget in July:
Food: $135.75 spent, $120.00 budget (over by $15.75)
Fun: $34.75 spent, $30.00 budget (over by $4.75)
Bills: $90.33 spent, $90.00 budget (over by $0.33)

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-07-02', 'Food', 'Green Grocer', 45.10),
  Tx('2026-07-04', 'Transport', 'Metro', 12.00),
  Tx('2026-07-06', 'Fun', 'Cinema', 18.00),
  Tx('2026-07-09', 'Food', 'Noodle Bar', 38.25),
  Tx('2026-07-12', 'Bills', 'Electric Co', 60.34),
  Tx('2026-07-15', 'Transport', 'Taxi', 9.50),
  Tx('2026-07-18', 'Fun', 'Arcade', 16.75),
  Tx('2026-07-21', 'Food', 'Cafe Aroma', 52.40),
  Tx('2026-07-25', 'Bills', 'Water Co', 29.99),
];

const budgets = {'Food': 120.0, 'Transport': 40.0, 'Fun': 30.0, 'Bills': 90.0};

void main() {
  final totals = <String, double>{};
  for (final t in txns) {
    totals[t.category] = (totals[t.category] ?? 0) + t.amount;
  }
  final over = totals.entries
      .where((e) => e.value > budgets[e.key]!)
      .toList()
    ..sort((a, b) => (budgets[a.key]! - a.value)
        .compareTo(budgets[b.key]! - b.value)); // most over first
  final alerts = over
      .map((e) => '${e.key}: \$${e.value.toStringAsFixed(2)} spent, '
          '\$${budgets[e.key]!.toStringAsFixed(2)} budget '
          '(over by \$${(e.value - budgets[e.key]!).toStringAsFixed(2)})')
      .join('\n');
  print('Over budget in July:');
  print(alerts);
}

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);
}

const budgets = {'Food': 120.0, 'Transport': 40.0, 'Fun': 30.0, 'Bills': 90.0};

void main() {
  final spent = fx(txns).foldBy((t) => t.category, 0.0, (sum, t) => sum + t.amount);
  final alerts = fx(spent.entries)
      .map((kv) => (kv.key, kv.value))
      .filter((row) => row.$2 > budgets[row.$1]!)
      .sortBy((row) => budgets[row.$1]! - row.$2) // most over first
      .map((row) => '${row.$1}: \$${row.$2.toStringAsFixed(2)} spent, '
          '\$${budgets[row.$1]!.toStringAsFixed(2)} budget '
          '(over by \$${(row.$2 - budgets[row.$1]!).toStringAsFixed(2)})')
      .join('\n');
  print('Over budget in July:');
  print(alerts);
}

Por qué difieren

La línea de formato es idéntica en ambas versiones —la diferencia está en todo lo que viene antes. Dart nativo hace la agrupación a mano en un mapa mutable y luego cambia de modismo dos veces: un bucle for para sumar, un where para filtrar, un sort en cascada con un comparador hecho a mano para ordenar. La versión de FxDart es un solo vocabulario de principio a fin: groupBy, map a los totales, filter contra el presupuesto, sortBy por el exceso, join. Cada regla de negocio —pasarse del presupuesto, la peor primero— es un paso con nombre que puedes señalar en una revisión de código.

Benchmark

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

N = 100

Tiempo Empate

Dart nativo 3.8 µs

FxDart 3.6 µs

Memoria pico Empate

Dart nativo 16.5 MB

FxDart 16.6 MB

N = 10,000

Tiempo Empate

Dart nativo 185 µs

FxDart 90 µs

Memoria pico Gana FxDart

Dart nativo 21.8 MB

FxDart 15.6 MB

N = 1,000,000

Tiempo Gana FxDart

Dart nativo 21.5 ms

FxDart 13.0 ms

Memoria pico Gana FxDart

Dart nativo 90.1 MB

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