Factories

[busslina]

Hi, I just tried factories and work well. It caches the result:

Future<clib.OsUserInfo?> Function(String username) osUserInfoCapsule(
        CapsuleHandle use) =>
    (username) =>
        clib.OsUtils.getUserInfo(username, shell: reff.read(shellProvider));

I just wanted to know how you handle it to cache the result for an arguments combination

[GregoryConrad]

Hi! 👋

It depends on where the factory is being used from.

• If it is local to a Widget, you can use.memo() and/or use.future() from within a RearchConsumer.
• If it is global to the application (i.e., only one user at a time), you can keep capsule(s) for the current factory argument(s), and then make another capsule for the output from the factory:

(String, void Function(String)) currOsUserCapsule(CapsuleHandle use) => use.state("");
Future<OsUserInfo?> Function(String username) osUserInfoFactory(CapsuleHandle use) => ...;
Future<OsUserInfo?> currOsUserInfoAsyncCapsule(CapsuleHandle use) => use(osUserInfoFactory)(use(currOsUserCapsule));
AsyncValue<OsUserInfo?> currOsUserInfoCapsule(CapsuleHandle use) => use.future(use(currOsUserInfoAsyncCapsule));

Then you can depend on currOsUserInfoCapsule in other capsules or read it from the container to get the current value.

[busslina]

Aah, sorry, I thought it was ReArch which was caching it by default. But I reminded that it is another Riverpod provider which was doing the caching. I was crazy thinking on how you did that catching. Now it make sense that I must handle it by myself.

Cool, thanks

[GregoryConrad]

No problem! Factories do require explicitly handling caching, but that’s by design, as state/data all have different lifetimes and you don’t want to cause leaks in the container (i.e., when should a container dispose a capsule with some argument input when there’s no way to calculate the demand for that particular input?)

[busslina]

Hi again.

I'm having troubles to caching factory capsule values:

import 'package:rearch/rearch.dart';

void main(List<String> arguments) {
  final capsuleContainer = CapsuleContainer();

  print(capsuleContainer.read(_monthAsStringFactory)(11));
  print(' ');

  print(capsuleContainer.read(_monthAsStringFactory)(10));
  print(' ');

  print(capsuleContainer.read(_monthAsStringFactory)(11));
  print(' ');
}

String _getMonthAsString(int month) {
  print('getMonthAsString() -- $month');

  return switch (month) {
    1 => 'Enero',
    2 => 'Febrero',
    3 => 'Marzo',
    4 => 'Abril',
    5 => 'Mayo',
    6 => 'Junio',
    7 => 'Julio',
    8 => 'Agosto',
    9 => 'Septiembre',
    10 => 'Octubre',
    11 => 'Noviembre',
    12 => 'Diciembre',
    _ => throw ('Bad usage'),
  };
}

String Function(int) _monthAsStringFactory(CapsuleHandle use) {
  print('_monthAsStringFactory() -- I');

  return (int month) {
    print('_monthAsStringFactory() -- II -- $month');
    return use.memo(() {
      print('_monthAsStringFactory() -- III -- $month');
      return _getMonthAsString(month);
    }, [month]);
  };
}

This is the output:

_monthAsStringFactory() -- I
_monthAsStringFactory() -- II -- 11
_monthAsStringFactory() -- III -- 11
getMonthAsString() -- 11
Noviembre
 
_monthAsStringFactory() -- II -- 10
_monthAsStringFactory() -- III -- 10
getMonthAsString() -- 10
Octubre
 
_monthAsStringFactory() -- II -- 11
_monthAsStringFactory() -- III -- 11
getMonthAsString() -- 11
Noviembre

I'm expecting to be printed steps II and III only the first time for each month, but I get it printed every time.

Also I put use.memo inside the returning function. Maybe it's a bad practice, but I don't know how to use use.memo or any other side effect with non capsule arguments.

https://github.com/busslina/rearch-dart-test/blob/master/lib/main_factory.dart

Thanks

[GregoryConrad]

Ohh, definitely do not ever use(xyzCapsule) or use.fooBar() across an asynchronous gap (#12). (By invoking the side effect in a callback, whenever you call the factory, you are invoking the side effect across an asynchronous gap.) I guess I should implement that assertion rather soon. Times like these are where I miss Rust, since the compiler won't let you do that...

If you really need to cache these factory values (most of the time you shouldn't unless it is something rather expensive like I/O), you ideally should make a side effect to do it. Maybe I could add one to the library itself. Here's a quick example:

(Ret Function(Arg), void Function()) yourCachedFactory(CapsuleHandle use) {
  final cache = use.value(<Arg, Ret>{});
  final rebuild = use.rebuilder();
  return (
    (arg) => cache.putIfAbsent(arg, () => yourFactoryFunctionThatDoesIO(arg)),
    () {
      cache.clear();
      rebuild();
    },
  );
}

Note that you will have to manually clear the cache in this example when you need to (i.e., dependencies mutate or cache gets too big), and this example doesn't support having capsule dependencies in your factory (as the cache won't be invalidated when a dependency of your factory changes). The dependencies issue can be solved with a more complex example.

[GregoryConrad]

While the above should probably go into a side effect at some point, you can use the above factory like:

final (getValue, clearCache) = use(yourCachedFactory);

[busslina]

Yeahh, I understand. Thanks