Plan de reposición de inventario

Gana FxDart

Requisito

A partir de una lista de existencias (los datos están en el código), encuentra los artículos por debajo de su stock mínimo, priorízalos por mayor déficit y pídelos en ese orden de prioridad, pero detente antes de que el coste acumulado supere el presupuesto de $500. Imprime cada pedido planificado con su total acumulado y luego un resumen de lo que se pidió y de lo que queda. Ambas versiones deben imprimir el plan que aparece bajo Salida esperada.

Salida esperada

Restock plan (budget $500.00)
  Paper Cups      x200  $10.00   running $10.00
  Espresso Beans  x 12  $216.00  running $226.00
  Oat Milk        x 24  $91.20   running $317.20
  Filter Papers   x 10  $64.00   running $381.20
  Cleaning Tabs   x  8  $76.00   running $457.20
Ordering 5 of 6 needed items; total $457.20, $42.80 left

Lado a lado

Dart nativo

import 'package:collection/collection.dart';

class Item {
  final String name;
  final int stock;
  final int minStock;
  final int reorderQty;
  final double unitCost;
  const Item(this.name, this.stock, this.minStock, this.reorderQty,
      this.unitCost);
}

const budget = 500.0;

const items = [
  Item('Espresso Beans', 2, 10, 12, 18.00),
  Item('Oat Milk', 5, 12, 24, 3.80),
  Item('Filter Papers', 1, 6, 10, 6.40),
  Item('Ceramic Mug', 18, 6, 6, 12.00),
  Item('Hand Grinder', 2, 3, 4, 49.90),
  Item('Cleaning Tabs', 3, 5, 8, 9.50),
  Item('Paper Cups', 30, 120, 200, 0.05),
];

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

void main() {
  final needed = items
      .where((i) => i.stock < i.minStock)
      .sortedBy<num>((i) => i.stock - i.minStock); // biggest deficit first

final lines = <String>[];
  var running = 0.0;
  for (final i in needed) {
    final cost = i.reorderQty * i.unitCost;
    if (running + cost > budget) break;
    running += cost;
    lines.add('  ${i.name.padRight(15)} '
        'x${'${i.reorderQty}'.padLeft(3)}  '
        '${money(cost).padRight(8)} '
        'running ${money(running)}');
  }

print([
    'Restock plan (budget ${money(budget)})',
    ...lines,
    'Ordering ${lines.length} of ${needed.length} needed items; '
        'total ${money(running)}, ${money(budget - running)} left',
  ].join('\n'));
}

FxDart

import 'package:fxdart/fxdart.dart';

const budget = 500.0;

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

void main() {
  final needed = fx(items)
      .filter((i) => i.stock < i.minStock)
      .sortBy((i) => i.stock - i.minStock) // biggest deficit first
      .toList();

final running = fx(needed)
      .scan((acc, i) => acc + i.reorderQty * i.unitCost, 0.0)
      .drop(1); // scan emits the seed first

final plan =
      fx(needed).zip(running).takeWhile((p) => p.$2 <= budget).toList();
  final lines = fx(plan).map((p) => '  ${p.$1.name.padRight(15)} '
      'x${'${p.$1.reorderQty}'.padLeft(3)}  '
      '${money(p.$1.reorderQty * p.$1.unitCost).padRight(8)} '
      'running ${money(p.$2)}').toList();
  final spent = fx(plan).sumBy((p) => p.$1.reorderQty * p.$1.unitCost);

print(join('\n', [
    'Restock plan (budget ${money(budget)})',
    ...lines,
    'Ordering ${lines.length} of ${needed.length} needed items; '
        'total ${money(spent)}, ${money(budget - spent)} left',
  ]));
}

Por qué difieren

El corte por presupuesto es la parte interesante. FxDart convierte el total acumulado en datos: scan produce el flujo de costes acumulados, zip empareja cada artículo con su total acumulado y takeWhile corta el plan en el presupuesto —la regla de corte es un predicado en una sola línea, y los totales acumulados ya están ahí para imprimirlos—. Dart nativo lo entrelaza todo en un único bucle: una variable mutable running, un break anticipado y el formateo comparten el cuerpo del bucle, de modo que la política («para cuando te pases del presupuesto») vive dentro del flujo de control en lugar de ser una etapa visible del pipeline que podrías mover o probar por separado.

Benchmark

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

N = 100

Tiempo Empate

Dart nativo 11 µs

FxDart 6.7 µs

Memoria pico Empate

Dart nativo 16.6 MB

FxDart 16.5 MB

N = 10,000

Tiempo Gana FxDart

Dart nativo 1.30 ms

FxDart 312 µs

Memoria pico Gana nativo

Dart nativo 17.5 MB

FxDart 23.4 MB

N = 1,000,000

Tiempo Gana FxDart

Dart nativo 216.2 ms

FxDart 51.9 ms

Memoria pico Gana nativo

Dart nativo 174.0 MB

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