Rebuildless/Updating Data

[busslina]

/// Designed to be used in contexts where data is captured and could happen
/// some inconsistencies.
///
/// This side effect is "silent", meaning it will not cause any rebuild.
///
/// E.G. An inline listener defined inside an [effect] (which gets implicilty
/// memoized) normally use the same data version available at the time of
/// its creation, and if some rebuilds happens inside the [Capsule] it
/// will be using old data.
/// Using this side effect, the listener invokes a getter that always have
/// the latest data version.
Getter<T> silentCopyData<T>(T value_) {
  final (get, set) = use.callonce(() {
    T value = value_;
    T get() => value;
    bool set(T newValue) {
      if (value == newValue) return false;
      value = newValue;
      return true;
    }

    return (get, set);
  });

  set(value_);

  return get;
}

[busslina]

Maybe you would solve the same issue using other tools like memo.

In my code, It came to me around 10 times this issue, so now I'm synthesizing my workaround with this side effect. Until now I was using an extra use.data or use.silentData to solve this.

Here some "old code" doing that:

Btw, here you can see a "bad practice": to use a CapsuleReader inside a side effect. It's the only place I do that, related to warming up capsules that has the ability to reset by themselves at the right moment (They have its scope and they reset themselves where they detect to be out of the scope). I have been using this approach for a while and works great. I just have to be careful using this "bad practices":

enum ManagedDataScope {
  connected,
  checkedLogged,
  authenticated,
}

[GregoryConrad]

BTW, you could simplify your code a bit:

Getter<T> silentData<T>(T value) {
  final data = use.data(value);
  data.value = value;
  return data.$1;
}

But yea, normally something like use.memo would be fine before a listener in a use.effect

[busslina]

The difference is that my code doesn't rebuild. That's why I'm not using use.data.
But yeah, setting the value while building doesn't rebuild with use.data too.

"I got you"

[busslina]

Final code:

extension SideEffectRegistrarSilentDataExt on SideEffectRegistrar {
  /// Data that will not cause any rebuild.
  ValueManager<T> silentData<T>(T initialValue) => use.callonce(() {
        T value = initialValue;
        T get() => value;
        bool set(T newValue) {
          if (value == newValue) return false;
          value = newValue;
          return true;
        }

        return (get, set);
      });

  /// Designed to be used in contexts where data is captured and could happen
  /// some inconsistencies.
  ///
  /// This side effect is "silent", meaning it will not cause any rebuild.
  ///
  /// E.G. An inline listener defined inside an [effect] (which gets implicilty
  /// memoized) normally use the same data version available at the time of
  /// its creation, and if some rebuilds happens inside the [Capsule] it
  /// will be using old data.
  /// Using this side effect, the listener invokes a getter that always have
  /// the latest data version.
  Getter<T> silentCopyData<T>(T value) =>
      (use.silentData(value)..set(value)).get;
}