XSelect class

Async multiplexing - race multiple operations with automatic cancellation.

The cornerstone of reactive, event-driven applications. Race channels, timers, futures, and streams with automatic cleanup of losers. Essential for building responsive UIs and efficient event processing systems.

Core Concepts

• First wins: The first operation to complete wins, all others are canceled
• Automatic cleanup: Losing operations are properly canceled to prevent leaks
• Type-safe: Each branch can return different types, unified by the result type
• Composable: Easily combine different async sources in a single select

Usage Patterns

Responsive UI with timeout:

final result = await XSelect.run<String>((s) => s
  ..onRecvValue(dataChannel, (data) => 'got_data: $data')
  ..onTick(Ticker.every(Duration(seconds: 1)), () => 'heartbeat')
  ..onTimeout(Duration(seconds: 30), () => 'timeout_reached')
);

switch (result) {
  case 'timeout_reached':
    showTimeoutMessage();
  case String data when data.startsWith('got_data'):
    processData(data);
  case 'heartbeat':
    updateHeartbeat();
}

Multi-source event aggregation:

final event = await XSelect.run<AppEvent>((s) => s
  ..onStream(userInteractions, (e) => AppEvent.user(e))
  ..onStream(networkEvents, (e) => AppEvent.network(e))
  ..onRecvValue(backgroundTasks, (t) => AppEvent.background(t))
  ..onFuture(systemCheck(), (r) => AppEvent.system(r))
);

handleEvent(event);

Configuration reload with graceful fallback:

Future<Config> loadConfigWithFallback() async {
  return await XSelect.run<Config>((s) => s
    ..onFuture(loadFromServer(), (c) => c)
    ..onFuture(loadFromCache(), (c) => c)
    ..onTimeout(Duration(seconds: 5), () => Config.defaultConfig())
  );
}