Diff two ledger snapshots

FxDart wins

Requirement

Two snapshots of the same ledger (data in the code): a sync happened in between, and entries were added and removed. Print a diff keyed by entry id — + lines for added entries, - lines for removed ones (each section sorted by id), the count of unchanged entries, and the net change in total amount. Both versions must print the diff under Expected output.

Expected output

Ledger diff (5 -> 5 entries)
+ t6 Noodle Bar $18.90
+ t7 Pharmacy $22.40
- t3 Metro card $30.00
- t4 Cinema $15.00
= 3 unchanged entries
Net change: -$3.70

Side by side

Native Dart

import 'package:collection/collection.dart';

class Tx {
  final String id;
  final String desc;
  final double amount;
  const Tx(this.id, this.desc, this.amount);
}

const before = [
  Tx('t1', 'Rent July', 900.00),
  Tx('t2', 'Cafe Aroma', 12.50),
  Tx('t3', 'Metro card', 30.00),
  Tx('t4', 'Cinema', 15.00),
  Tx('t5', 'Green Grocer', 43.20),
];

const after = [
  Tx('t1', 'Rent July', 900.00),
  Tx('t2', 'Cafe Aroma', 12.50),
  Tx('t5', 'Green Grocer', 43.20),
  Tx('t6', 'Noodle Bar', 18.90),
  Tx('t7', 'Pharmacy', 22.40),
];

String money(num n) => '\$${n.toStringAsFixed(2)}';
String fmt(Tx t) => '${t.id} ${t.desc} ${money(t.amount)}';

void main() {
  final beforeIds = before.map((t) => t.id).toSet();
  final afterIds = after.map((t) => t.id).toSet();

final added =
      after.where((t) => !beforeIds.contains(t.id)).sortedBy((t) => t.id);
  final removed =
      before.where((t) => !afterIds.contains(t.id)).sortedBy((t) => t.id);
  final commonCount = after.where((t) => beforeIds.contains(t.id)).length;

final diffLines = [
    for (final t in added) '+ ${fmt(t)}',
    for (final t in removed) '- ${fmt(t)}',
  ];

final net = after.fold(0.0, (s, t) => s + t.amount) -
      before.fold(0.0, (s, t) => s + t.amount);
  final sign = net < 0 ? '-' : '+';

print([
    'Ledger diff (${before.length} -> ${after.length} entries)',
    ...diffLines,
    '= $commonCount unchanged entries',
    'Net change: $sign${money(net.abs())}',
  ].join('\n'));
}

FxDart

import 'package:fxdart/fxdart.dart';

class Tx {
  final String id;
  final String desc;
  final double amount;
  const Tx(this.id, this.desc, this.amount);
}

const before = [
  Tx('t1', 'Rent July', 900.00),
  Tx('t2', 'Cafe Aroma', 12.50),
  Tx('t3', 'Metro card', 30.00),
  Tx('t4', 'Cinema', 15.00),
  Tx('t5', 'Green Grocer', 43.20),
];

const after = [
  Tx('t1', 'Rent July', 900.00),
  Tx('t2', 'Cafe Aroma', 12.50),
  Tx('t5', 'Green Grocer', 43.20),
  Tx('t6', 'Noodle Bar', 18.90),
  Tx('t7', 'Pharmacy', 22.40),
];

String money(num n) => '\$${n.toStringAsFixed(2)}';
String fmt(Tx t) => '${t.id} ${t.desc} ${money(t.amount)}';

void main() {
  final added = differenceBy((Tx t) => t.id, before, after);
  final removed = differenceBy((Tx t) => t.id, after, before);
  final common = intersectionBy((Tx t) => t.id, before, after);

final diffLines = fx(added)
      .sortBy((t) => t.id)
      .map((t) => '+ ${fmt(t)}')
      .concat(fx(removed).sortBy((t) => t.id).map((t) => '- ${fmt(t)}'));

final net = fx(after).sumBy((t) => t.amount) -
      fx(before).sumBy((t) => t.amount);
  final sign = net < 0 ? '-' : '+';

print(join('\n', [
    'Ledger diff (${before.length} -> ${after.length} entries)',
    ...diffLines,
    '= ${fx(common).size()} unchanged entries',
    'Net change: $sign${money(net.abs())}',
  ]));
}

Why they differ

Diffing is set algebra over a key, and FxDart ships the vocabulary: differenceBy called both ways gives added and removed, intersectionBy gives the unchanged entries — three declarations that read like the definition of a diff. The sortBy → map → concat pipeline then renders both sections in one expression. Native Dart has set operations only for Set itself, not for "by this key of these objects", so the honest version manually projects id sets and writes a negated contains filter per direction — easy to get backwards, and the intent ("what's in B but not A?") lives in the predicate's polarity rather than in a function name.

Benchmark

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

N = 100

Time Tie

Native Dart 21 µs

FxDart 23 µs

Peak memory Tie

Native Dart 16.5 MB

FxDart 16.5 MB

N = 10,000

Time Native wins

Native Dart 2.37 ms

FxDart 3.16 ms

Peak memory Native wins

Native Dart 26.0 MB

FxDart 31.2 MB

N = 500,000

Time Native wins

Native Dart 223.4 ms

FxDart 261.0 ms

Peak memory FxDart wins

Native Dart 182.1 MB

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