Finale — DailyLedger monthly close

FxDart wins async

Requirement

Close the month for a personal ledger. Ten entries live in a store (fixed data in the code below); load each by id — at most three loads in flight, proven by the max-in-flight counter — then compute the July 2026 close: keep only July entries (one straggler is from June), split income from spending, total each side, and print the net plus the top three spending categories with entry counts.

The shapes here are lifted from a real app: the Entry model, the income/spending split (filter → partition → sumBy each half), and the category breakdown (groupBy → per-group sumBy → sortBy descending → take(3)) mirror DailyLedger's monthSummary and categoryBreakdown pipelines, with the async load phase (toAsync → map → concurrent(3)) in front.

Expected output

July 2026 close — 10 entries loaded, 3 at a time (max in flight: 3)
income  $3600.00
expense $1478.15
net     $2121.85
top spending categories:
  housing: $1150.00 (1 entry)
  food: $206.35 (3 entries)
  utilities: $106.30 (2 entries)

Side by side

Native Dart

import 'package:collection/collection.dart';

enum EntryType { income, expense, bill }

class Entry {
  final String id;
  final String title;
  final EntryType type;
  final double amount;
  final String categoryId;
  final DateTime date;
  Entry(this.id, this.title, this.type, this.amount, this.categoryId, this.date);
}

final ledger = [
  Entry('e0', 'Coffee', EntryType.expense, 4.50, 'food', DateTime(2026, 6, 30)),
  Entry('e1', 'Salary', EntryType.income, 3200.00, 'income', DateTime(2026, 7, 1)),
  Entry('e2', 'Rent', EntryType.bill, 1150.00, 'housing', DateTime(2026, 7, 3)),
  Entry('e3', 'Groceries', EntryType.expense, 82.40, 'food', DateTime(2026, 7, 5)),
  Entry('e4', 'Dinner out', EntryType.expense, 46.10, 'food', DateTime(2026, 7, 12)),
  Entry('e5', 'Electricity', EntryType.bill, 61.30, 'utilities', DateTime(2026, 7, 15)),
  Entry('e6', 'Freelance', EntryType.income, 400.00, 'income', DateTime(2026, 7, 18)),
  Entry('e7', 'Groceries', EntryType.expense, 77.85, 'food', DateTime(2026, 7, 19)),
  Entry('e8', 'Cinema', EntryType.expense, 15.50, 'fun', DateTime(2026, 7, 24)),
  Entry('e9', 'Internet', EntryType.bill, 45.00, 'utilities', DateTime(2026, 7, 25)),
];

int inFlight = 0;
int maxInFlight = 0;

/// Loads one entry from the (simulated) on-device store.
Future<Entry> loadEntry(String id) async {
  inFlight++;
  if (inFlight > maxInFlight) maxInFlight = inFlight;
  await Future.delayed(const Duration(milliseconds: 15));
  inFlight--;
  return ledger.firstWhere((e) => e.id == id);
}

/// Worker pool: 3 workers over a shared cursor, ordered result slots.
Future<List<Entry>> loadAll(List<String> ids) async {
  final results = List<Entry?>.filled(ids.length, null);
  var next = 0;
  Future<void> worker() async {
    while (next < ids.length) {
      final i = next++;
      results[i] = await loadEntry(ids[i]);
    }
  }

await Future.wait([worker(), worker(), worker()]);
  return results.cast<Entry>();
}

Future<void> main() async {
  final entries = await loadAll([for (final e in ledger) e.id]);

final july = entries
      .where((e) => e.date.year == 2026 && e.date.month == 7)
      .toList();
  final income = july.where((e) => e.type == EntryType.income);
  final spending = july.where((e) => e.type != EntryType.income).toList();
  final earned = income.fold(0.0, (sum, e) => sum + e.amount);
  final spent = spending.fold(0.0, (sum, e) => sum + e.amount);

final byCategory = spending.groupListsBy((e) => e.categoryId);
  final top = byCategory.entries
      .map((kv) => (
            kv.key,
            kv.value.fold(0.0, (sum, e) => sum + e.amount),
            kv.value.length
          ))
      .sortedBy<num>((c) => -c.$2)
      .take(3);

print('July 2026 close — ${entries.length} entries loaded, 3 at a time '
      '(max in flight: $maxInFlight)');
  print('income  \$${earned.toStringAsFixed(2)}');
  print('expense \$${spent.toStringAsFixed(2)}');
  print('net     \$${(earned - spent).toStringAsFixed(2)}');
  print('top spending categories:');
  for (final (cat, total, count) in top) {
    print('  $cat: \$${total.toStringAsFixed(2)} '
        '($count ${count == 1 ? 'entry' : 'entries'})');
  }
}

FxDart

import 'package:fxdart/fxdart.dart';

enum EntryType { income, expense, bill }

int inFlight = 0;
int maxInFlight = 0;

Future<void> main() async {
  final ids = [for (final e in ledger) e.id];
  final entries = await fx(ids).toAsync().map(loadEntry).concurrent(3).toList();

final (income, spending) = fx(entries)
      .filter((e) => e.date.year == 2026 && e.date.month == 7)
      .partition((e) => e.type == EntryType.income);
  final earned = fx(income).sumBy((e) => e.amount);
  final spent = fx(spending).sumBy((e) => e.amount);

final byCategory = fx(spending).groupBy((e) => e.categoryId);
  final top = fx(byCategory.entries)
      .map((kv) => (kv.key, fx(kv.value).sumBy((e) => e.amount), kv.value.length))
      .sortBy((c) => -c.$2)
      .take(3)
      .toList();

Why they differ

Fifty examples in, this is the pattern they all add up to: plain Dart needs three dialects for one feature — package:collection helpers for grouping, fold with explicit seeds for the totals, and a hand-rolled worker pool the moment the load phase needs a concurrency bound. Each piece is fine; together they make the business logic the hardest thing on the screen to find. The FxDart version is the same vocabulary from the load phase to the report — and because every stage is a pure pipeline, each one can be lifted out and unit tested as entries in, view data out.

These pipelines are not a demo confection: they are how the DailyLedger demo app actually computes its dashboard — same model, same operators, running live in your browser. If the fifty comparisons showed you the words, DailyLedger is the sentence they were building toward.

Benchmark

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

Async case: the headline scale is N = 20,000, not 1,000,000. Every element costs an event-loop turn on both sides, so a million real awaits would measure Dart's event loop for minutes — not the pipeline. Delays are zero-length and the example's concurrency limit is kept; what the bars compare is the pipeline machinery.

N = 100

Time Tie

Native Dart 371 µs

FxDart 401 µs

Peak memory Tie

Native Dart 16.6 MB

FxDart 17.2 MB

N = 10,000

Time Tie

Native Dart 318.8 ms

FxDart 325.6 ms

Peak memory Tie

Native Dart 50.3 MB

FxDart 50.2 MB

N = 20,000

Time Tie

Native Dart 1179.1 ms

FxDart 1192.2 ms

Peak memory Tie

Native Dart 52.6 MB

FxDart 54.5 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.