Scan/Min/Max transformer may has side effect leaking

[lestathc]

Considering I have such code:

var transformer = new ScanStreamTransformer(myPredictFunc);
var scan1 = myStream.transform(transformer);
var scan2 = myAnotherStream.transform(transformer);

I may dirty the intermedia result of scan transformer.

Given the transforms are public, if I only want to reuse the transforms without using the Observable interface, and according to "It is good practice to write transformers that can be used multiple times.". I may want to use transformer like that.

How about either mark transformers private, or document them/add annotations to indicate that these transformers is not sharable.

[brianegan]

Hrm, good catch. I'd personally like to keep the transformers Public, as that allows folks to use all of our Stream and StreamTransformers classes individually without needing to pull in all of Observable if they really only need one or two items.

In this case, great call. We should inspect our operators and make sure they can be reused. Secondly, we defo need more docs on these classes. We've just made them public without much explanation thus far, something we'll certainly fix :)

[frankpepermans]

hmmm, we could fix this by storing values in a Map for example,

take the min/max transformer, instead of storing a single value in the transformer class, we could create a Map<EventSink, T> instead, which stores values in relation to the provided Stream sink.

On close, we could delete the related EventSink key from that Map.

[brianegan]

Another option: Now that we've got a class with an internal factory method, every time bind is called, we could build a new transformer internally and bind that, rather than building the transformer immediately upon creation and re-binding that over and over.

Although I think we should generally review our transformers and see if we can avoid doing that, for some cases it might make sense to ensure we don't have state problems.