Categories over their monthly budget

FxDart wins

Requirement

Each spending category has a monthly budget. From July's transactions, total each category, keep only the categories that went over their budget, and print them worst offender first — spent, budget, and the overage on each line. The data is in the code below; both versions must print the lines shown under Expected output.

Expected output

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)

Side by side

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

Why they differ

The formatting line is identical in both versions — the difference is everything before it. Native Dart does the grouping by hand in a mutable map, then switches idiom twice: a for loop to total, a where to filter, a cascade-sort with a hand-built comparator to rank. The FxDart version is one vocabulary end to end: groupBy, map to totals, filter against the budget, sortBy the overage, join. Each business rule — over budget, worst first — is one named step you can point at in a code review.

Benchmark

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

N = 100

Time Tie

Native Dart 3.8 µs

FxDart 3.6 µs

Peak memory Tie

Native Dart 16.5 MB

FxDart 16.6 MB

N = 10,000

Time Tie

Native Dart 185 µs

FxDart 90 µs

Peak memory FxDart wins

Native Dart 21.8 MB

FxDart 15.6 MB

N = 1,000,000

Time FxDart wins

Native Dart 21.5 ms

FxDart 13.0 ms

Peak memory FxDart wins

Native Dart 90.1 MB

FxDart 82.7 MB

Bars are medians of repeated timed iterations in fresh processes per side (small N is batched for timer resolution). Sides within 5% of each other — or within 0.6 ms, a difference no person can perceive — count as a tie; close relative races are re-measured up to 5 runs. In an app, anything under a few milliseconds is invisible to the user regardless of which bar is shorter. Memory is peak process RSS. The Dart VM and the dataset are identical on both sides, so the difference between the two bars is what the pipeline itself holds onto.