Multi-currency expense report

FxDart wins

Requirement

A trip ledger (data in the code) mixes EUR, GBP, JPY, and USD amounts. Convert everything to USD with the fixed rates in the code, then report: per-category totals sorted by spend, the currencies seen, the largest single expense (with its original amount), and the grand total. Both versions must print the report under Expected output.

Expected output

Trip expenses in USD (currencies: EUR, GBP, JPY, USD)
  Lodging  $240.55
  Travel   $164.82
  Food     $37.85
  Transit  $22.50
Largest single expense: Travel $130.80 (120.00 EUR)
Total: $465.72

Side by side

Native Dart

class Tx {
  final String date;
  final String category;
  final double amount;
  final String currency;
  const Tx(this.date, this.category, this.amount, this.currency);
}

const rates = {'USD': 1.0, 'EUR': 1.09, 'GBP': 1.27, 'JPY': 0.0063};

const txns = [
  Tx('2026-07-02', 'Travel', 120.00, 'EUR'),
  Tx('2026-07-03', 'Food', 8.40, 'USD'),
  Tx('2026-07-05', 'Travel', 5400, 'JPY'),
  Tx('2026-07-08', 'Lodging', 95.00, 'GBP'),
  Tx('2026-07-09', 'Food', 2200, 'JPY'),
  Tx('2026-07-11', 'Food', 14.30, 'EUR'),
  Tx('2026-07-12', 'Transit', 22.50, 'USD'),
  Tx('2026-07-14', 'Lodging', 110.00, 'EUR'),
];

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

void main() {
  final usd = txns.map((t) => (t, t.amount * rates[t.currency]!)).toList();

final byCategory = <String, double>{};
  for (final p in usd) {
    byCategory[p.$1.category] = (byCategory[p.$1.category] ?? 0) + p.$2;
  }
  final catLines = (byCategory.entries.toList()
        ..sort((a, b) => b.value.compareTo(a.value)))
      .map((e) => '  ${e.key.padRight(8)} ${money(e.value)}');

final currencies = txns.map((t) => t.currency).toSet().toList()..sort();
  final biggest = usd.reduce((a, b) => a.$2 >= b.$2 ? a : b);
  final total = usd.fold(0.0, (s, p) => s + p.$2);

print([
    'Trip expenses in USD (currencies: ${currencies.join(', ')})',
    ...catLines,
    'Largest single expense: ${biggest.$1.category} ${money(biggest.$2)} '
        '(${biggest.$1.amount.toStringAsFixed(2)} ${biggest.$1.currency})',
    'Total: ${money(total)}',
  ].join('\n'));
}

FxDart

import 'package:fxdart/fxdart.dart';

class Tx {
  final String date;
  final String category;
  final double amount;
  final String currency;
  const Tx(this.date, this.category, this.amount, this.currency);
}

const rates = {'USD': 1.0, 'EUR': 1.09, 'GBP': 1.27, 'JPY': 0.0063};

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

void main() {
  final usd = fx(txns).map((t) => (t, t.amount * rates[t.currency]!)).toList();

// foldBy, not groupBy + sumBy: the answer is one number per category, so
  // there is no reason to build a list of every transaction per category
  // first and then throw it away.
  final byCategory = fx(usd).foldBy((p) => p.$1.category, 0.0, (s, p) => s + p.$2);
  final catLines = fx(byCategory.entries)
      .sortBy((e) => -e.value)
      .map((e) => '  ${e.key.padRight(8)} ${money(e.value)}');

final currencies = fx(txns).map((t) => t.currency).uniq().sortBy((c) => c);
  final biggest = fx(usd).maxBy((p) => p.$2)!;
  final total = fx(usd).sumBy((p) => p.$2);

print(join('\n', [
    'Trip expenses in USD (currencies: ${join(', ', currencies)})',
    ...catLines,
    'Largest single expense: ${biggest.$1.category} ${money(biggest.$2)} '
        '(${biggest.$1.amount.toStringAsFixed(2)} ${biggest.$1.currency})',
    'Total: ${money(total)}',
  ]));
}

Why they differ

Normalizing first — map each transaction to a (tx, usd) pair — lets every later question run over one list: foldBy + sortBy for the breakdown, uniq for the currency list, maxBy and sumBy for the summary lines. Each report line is one short pipeline that names its aggregation. The native version makes the identical moves but without the vocabulary: the per-category totals are a hand-rolled map accumulator, the sort needs a comparator spelled out, the maximum is a reduce comparator, and the currency list needs the toSet().toList()..sort() shuffle. Nothing is hard — there is just more of it, and less of it says what it means.

The aggregation is foldBy rather than groupBy + sumBy on purpose, and it is worth a moment. The answer here is one number per category, so grouping first would build a List of every transaction under each category and then immediately fold it away — allocation proportional to the input, for an answer proportional to the number of categories. foldBy accumulates straight into the result map, which is exactly what the native loop beside it does. On a million-row ledger that single choice is worth roughly 2.5× on both sides; see Writing fast pipelines. Reach for groupBy when you actually want the members.

Benchmark

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

N = 100

Time Tie

Native Dart 14 µs

FxDart 11 µs

Peak memory Tie

Native Dart 17.0 MB

FxDart 16.5 MB

N = 10,000

Time Tie

Native Dart 784 µs

FxDart 719 µs

Peak memory Tie

Native Dart 23.5 MB

FxDart 22.9 MB

N = 1,000,000

Time FxDart wins

Native Dart 123.3 ms

FxDart 104.4 ms

Peak memory Native wins

Native Dart 201.8 MB

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