[FeatureRequest] asyncComputed

[btrautmann]

I'm just formalizing the discussion happening in #52 (which has been marked as answered) with a request for asyncComputed. In #52 (comment) I linked a gist that details my use case. Basically I need every computed in that class to be an asyncComputed. I find the need to call resetFuture or resetStream on an asyncSignal pretty cumbersome when the dependencies of a computed may be more than one. Having a computed value that can be async and avoids race conditions with its dependencies would be amazing when paired with allowing for a non-null type wrapped by AsyncSignal without a default value (as is discussed here and here (I think)).

Signals are new to me, so I may be asking too much or for something that doesn't feel natural in signals, so please feel free to point that out.

[btrautmann]

Update: Because signals.dart doesn't yet support this and I really needed it for my app, I gave @jinyus's state_beacon (https://pub.dev/packages/state_beacon) a try, and derivedFuture works as requested here. Calling this out because it may be helpful to use as a point of reference as @jinyus suggested here. Additionally, state_beacon supports transforming a FutureBeacon into a simple Future that allows you to not need to unwrap the AsyncValue, which is awesome and very Riverpod-y.

[rodydavis]

I am thinking about supporting this to an extent with FutureSignal. The only signals that would be subscribed would be anything before an async gap.

Would love to add a lint like BuildContext and async.

This would essentially give the future function passed a computed signal to listen to changes.

[rodydavis]

Update: Because signals.dart doesn't yet support this and I really needed it for my app, I gave @jinyus's state_beacon (https://pub.dev/packages/state_beacon) a try, and derivedFuture works as requested here. Calling this out because it may be helpful to use as a point of reference as @jinyus suggested here. Additionally, state_beacon supports transforming a FutureBeacon into a simple Future that allows you to not need to unwrap the AsyncValue, which is awesome and very Riverpod-y.

FutureSignal also allows for unwrapping via .future.

I am still looking how to best support async computed. The issue is the state graph is sync and introducing async will then require all the signals to be awaited which can take away some of the benefits.

I think it would be possible to have a async computed with an explicit list of signals to listen for since anything past the async boundary would not be captured.

[btrautmann]

I think it would be possible to have a async computed with an explicit list of signals to listen for since anything past the async boundary would not be captured.

So far in my use of state_beacon it's been fine to "list" all the dependencies before the async gap (I've been working under the guidance from @jinyus that even if a derivedFuture runs multiple times, the last one triggered always "wins" and so I don't need to worry about race conditions...), but I imagine this is not always possible (for instance, in cases where a dependency may be conditionally needed based on another async dependency's result?). I think listing dependencies probably isn't the worst, and is indeed much better than needing to remember to call resetFuture/Stream, so this personally SGTM.

Note that in some cases I need to do things like:

// List dependencies without awaiting them here
final futureA = someDerivedFuture.future;
final futureB = someOtherDerivedFuture.future;

// Await all at same time for speed
final results = await (futureA, futureB).wait;
final typedA = results.$1;
final typedB = results.$2;

// Or, await each one after the other if one depends on another
...

[rodydavis]

Something that can start to get closer to what you want is the new signal container:

#83 (comment)

You could combine it with AsyncSignal and choose to cache or dispose manually if needed too

[rodydavis]

Going to move this to a discussion to discuss options about a possible API or approaches.

[rodydavis]

Working on addressing this with the following PR:
#109

[rodydavis]

Async computed is possible by using a future signal.

All of the signal primitives are sync and will always be the case. This allows for working with async data a bit better while keeping the API sync

[rodydavis]

Example:

final counter = signal(0);
final message = futureSignal(
  () async {
    await Future.delayed(const Duration(seconds: 1));
    return 'A sublime message to display'.substring(0, counter.value + 1);
  },
  dependencies: [counter],
);

[rodydavis]

I really like what Angular is doing with signals and asyncComputed, we can copy the API using FutureSignal and AsyncSignal:

https://twitter.com/Enea_Jahollari/status/1749772921105469839

[rodydavis]

This is my first draft:

import '../core/signals.dart';
import 'future.dart';
import 'state.dart';

/// Async Computed is syntax sugar around [FutureSignal].
/// 
/// computedFrom takes a list of [signals] and a [callback] function to
/// compute the value of the signal every time one of the [signals] changes.
///
/// ```dart
/// final movieId = signal('id');
/// late final movie = computedFrom([movieId], ([id]) => fetchMovie(id));
/// ```
FutureSignal<T> computedFrom<T>(
  List<ReadonlySignal<dynamic>> signals,
  Future<T> Function(List<dynamic> args) callback, {
  T? initialValue,
  String? debugLabel,
  SignalEquality<AsyncState<T>>? equality,
}) {
  return FutureSignal<T>(
    future: () => callback(signals.map((e) => e()).toList()),
    fireImmediately: true,
    dependencies: signals,
    initialValue: initialValue,
    debugLabel: debugLabel,
    equality: equality,
  );
}

/// Async Computed is syntax sugar around [FutureSignal].
/// 
/// computedAsync takes a [callback] function to compute the value 
/// of the signal. This callback is converted into a [Computed] signal.
/// 
/// ```dart
/// final movieId = signal('id');
/// late final movie = computedAsync(() => fetchMovie(movieId()));
/// ```
/// 
/// It is important that signals are called before any async gaps with await.
FutureSignal<T> computedAsync<T>(
  Future<T> Function() callback, {
  T? initialValue,
  String? debugLabel,
  SignalEquality<AsyncState<T>>? equality,
}) {
  return FutureSignal<T>(
    future: computed(callback).call,
    fireImmediately: true,
    dependencies: [],
    initialValue: initialValue,
    debugLabel: debugLabel,
    equality: equality,
  );
}

[rodydavis]

Added computedAsync / computedFrom on 4.0.0 🎉