Can capsules be class methods?

[busslina]

Can a Capsule be a class method?

[GregoryConrad]

"Yes, but no."

Here's something that is always safe, and can be done for "namespaces" since Dart doesn't really have a proper modules system:

class A {
  static int a(CapsuleHandle use) => 0;
}
container.read(A.a);

Note that I normally would just recommend using a top-level function instead though. You should almost never need to write a class manually when using ReArch.

Here's two things that are sometimes safe (but I would almost never recommend):

class A {
  int call(CapsuleHandle use) => 0;
}
class B {
  int foobarCapsule(CapsuleHandle use) => 0;
}
container.read(A());
container.read(B().foobarCapsule);

If you are doing one of those last two, it is only safe if you memoize the object that is being used to read the capsules. I.e., you can only ever pass in the same A() or B().foobarCapsule instance, or else you can cause leaks if you keep passing in new instances. The way to prevent leaks is via another capsule that can keep track of a hashmap of keys to capsules so that you can have one capsule per key. This is a very advanced use case though that 99.9% of Flutter apps would never need. It is strictly intended for use in incremental computation applications, such as a dynamic programming problem. Here's a test case that can be used as an example, but note that you should almost always be using the factory pattern instead of this:

rearch-dart/packages/rearch/test/basic_test.dart

Line 370 in 58cb6bc

test('fibonacci numbers', () {

[busslina]

Cool, if I ever have the need to use namespaces I will use a static method...

My question was thinking about having n * y different capsules for n class objects with y class-method-capsules. I suppose that this would work, but I don't have any use case yet for it. I also suppose you will discourage this usage.

[GregoryConrad]

You can do that via memoizing the “n” objects (ensuring you don’t make any duplicates), but yes I normally would advise against it

[busslina]

But why "memo" if each class method will have a different reference for every object (IIRC)?

[GregoryConrad]

Take the following:

container.read(A().abc);
container.read(A().abc);
container.read(A().xyz);
container.read(A().xyz);
container.read(B(1).foo);
container.read(B(1).foo);
container.read(B(2).foo);
container.read(B(2).foo);

You would likely want to use the same A class instance for the abc and xyz to prevent putting extra capsules into the container (potentially causing a leak), and you would do that via memoizing the A(). On the other hand, you would likely want a separate B instance for both the 1 and 2, so you would have to memoize a B object for each of the different inputs for it.

[busslina]

I understand