Bajadas de precio entre dos instantáneas

Gana FxDart

Requisito

Dos instantáneas de la lista de precios de una tienda (los datos están en el código): junio y julio. Algunos artículos se abarataron, otros se encarecieron, uno se descatalogó y otro es nuevo. Informa de cada artículo que bajó de precio —precio anterior, precio nuevo y la bajada—, ordenado de mayor a menor bajada, más una mención destacada a la mayor bajada individual y al ahorro total. Ambas versiones deben imprimir el informe que aparece bajo Salida esperada.

Salida esperada

Price drops, June -> July
  Hand Grinder    $49.90 -> $44.00  (-$5.90)
  Espresso Beans  $18.00 -> $14.50  (-$3.50)
  Filter Papers   $6.40 -> $5.90  (-$0.50)
Biggest drop: Hand Grinder (-$5.90)
Total savings if bought now: $9.90

Lado a lado

Dart nativo

import 'package:collection/collection.dart';

class Item {
  final String sku;
  final String name;
  final double price;
  const Item(this.sku, this.name, this.price);
}

const june = [
  Item('SKU-01', 'Espresso Beans', 18.00),
  Item('SKU-02', 'Oat Milk', 3.80),
  Item('SKU-03', 'Filter Papers', 6.40),
  Item('SKU-04', 'Ceramic Mug', 12.00),
  Item('SKU-05', 'Hand Grinder', 49.90),
  Item('SKU-06', 'Digital Scale', 24.50),
];

const july = [
  Item('SKU-01', 'Espresso Beans', 14.50),
  Item('SKU-02', 'Oat Milk', 4.10),
  Item('SKU-03', 'Filter Papers', 5.90),
  Item('SKU-04', 'Ceramic Mug', 12.00),
  Item('SKU-05', 'Hand Grinder', 44.00),
  Item('SKU-07', 'Travel Tumbler', 21.00),
];

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

void main() {
  final old = {for (final i in june) i.sku: i};
  final drops = july
      .where((i) => old.containsKey(i.sku) && i.price < old[i.sku]!.price)
      .map((i) => (i, old[i.sku]!.price - i.price))
      .sortedBy<num>((d) => -d.$2);

final lines = [
    for (final d in drops)
      '  ${d.$1.name.padRight(15)} '
          '${money(old[d.$1.sku]!.price)} -> ${money(d.$1.price)}  '
          '(-${money(d.$2)})',
  ];
  final biggest = drops.first;
  final savings = drops.fold(0.0, (s, d) => s + d.$2);

print([
    'Price drops, June -> July',
    ...lines,
    'Biggest drop: ${biggest.$1.name} (-${money(biggest.$2)})',
    'Total savings if bought now: ${money(savings)}',
  ].join('\n'));
}

FxDart

import 'package:fxdart/fxdart.dart';

class Item {
  final String sku;
  final String name;
  final double price;
  const Item(this.sku, this.name, this.price);
}

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

void main() {
  final old = fx(june).indexBy((i) => i.sku);
  final drops = fx(july)
      .filter((i) => old.containsKey(i.sku) && i.price < old[i.sku]!.price)
      .map((i) => (i, old[i.sku]!.price - i.price))
      .sortBy((d) => -d.$2)
      .toList();

final lines = fx(drops).map((d) => '  ${d.$1.name.padRight(15)} '
      '${money(old[d.$1.sku]!.price)} -> ${money(d.$1.price)}  '
      '(-${money(d.$2)})');
  final biggest = fx(drops).head()!;
  final savings = fx(drops).sumBy((d) => d.$2);

print(join('\n', [
    'Price drops, June -> July',
    ...lines,
    'Biggest drop: ${biggest.$1.name} (-${money(biggest.$2)})',
    'Total savings if bought now: ${money(savings)}',
  ]));
}

Por qué difieren

Toda la tarea es un único flujo: indexar junio por SKU, quedarse con los artículos de julio que se abarataron, emparejar cada uno con su bajada y ordenar por bajada. FxDart tiene un paso con nombre para cada movimiento —indexBy para la tabla de búsqueda, filter → map → sortBy para el pipeline, y después head y sumBy reutilizan la misma lista de resultados para las líneas del resumen—. Dart nativo puede expresarlo —un literal de Map para el índice, where/map/sortedBy para la cadena—, pero el vocabulario está disperso: fold con un valor inicial en lugar de sumBy, sortedBy<num> con una clave negada y ningún nombre para «constrúyeme una tabla de búsqueda por clave».

Benchmark

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

N = 100

Tiempo Empate

Dart nativo 56 µs

FxDart 37 µs

Memoria pico Empate

Dart nativo 16.5 MB

FxDart 16.5 MB

N = 10,000

Tiempo Gana FxDart

Dart nativo 7.05 ms

FxDart 3.62 ms

Memoria pico Gana FxDart

Dart nativo 37.2 MB

FxDart 34.0 MB

N = 1,000,000

Tiempo Gana FxDart

Dart nativo 1160.5 ms

FxDart 640.7 ms

Memoria pico Gana nativo

Dart nativo 393.6 MB

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