BehaviorSubject

[dariomannu]

Describe the solution

Behaviors are at the heart of stream oriented state management.

Was there any plan to have something like a BehaviorSubject in Eventkit?

[hntrl]

There might have been at one point, but if I'm remembering my rationale correctly then I think the reason that similar Subject primitives weren't added to eventkit was because the same thing could be achieved with operators, and in general less primitives you have to learn is better IMO.

E.g. wouldn't a scan operator address the same issues as a BehaviorSubject?

[dariomannu]

Not exactly.

Let's compare the following:

const s1 = new BehaviorSubject(0).pipe(
  scan(x => x+1)
);

const s2 = new Subject().pipe(
  scan(x => x+1, 0)
);

const s3 = new Subject().pipe(
  startWith(0)
  scan(x => x+1)
);

s1 will start emitting a value straight away, because the BehaviorSubject has its own initial value. Note that as a result, scan doesn't need an initial "seed" value, as it's going to have one coming from the Behavior.

s2 is piped from a Subject, so it won't have an initial value. This also means we need to supply a seed value to 0 or it will break if the first item that goes through the Subject is not a 0.

s3 would be equivalent fo s1. Do we like it?

If you don't like multiple primitives, there could be yet another option: new Stream without any arguments would behave like a Subject, otherwise as a BehaviorSubject.

The original Functional-Reactive specification came with distinct Signals (the Subjects in RxJS) and Behaviors (the BehaviorSubjects in RxJS), so that library just tried to adhere to the original concepts.

[hntrl]

ok yeah I see what you mean

s3 would be equivalent fo s1. Do we like it?

yeah this is what I was thinking. This is technically possible already without a named operator if you do something like:

const initialValue$ = AsyncObservable.from([1]);
const stream$ = new Stream();
const s4 = initialValue$.pipe(concat(stream$));

open to adding a prepend operator though or something of that nature that would act as a short hand for this.

new Stream without any arguments would behave like a Subject, otherwise as a BehaviorSubject.

so a Stream could be two things at once, just depending on arguments? This is asking for trouble IMO.

Again I think this is something that might be helped by creative use of operators. We might be breaking the mold of how "operator factory functions" are meant to behave (since creating an operator like op() technically means that no "state" is retained as apart of the operator currently), but if we wanted to parrot the behavior of subject patterns it should be possible with operators like this:

function behavior<T>(defaultValue: T): MonoTypeOperatorFunction<T> {
  // currentValue is retained outside of each subscriber instance
  let currentValue: T = defaultValue;
  return (source) =>
    new source.AsyncObservable(async function* () {
      yield currentValue;
      for await (const value of source) {
        currentValue = value;
        yield value;
      }
    });
}

const stream$ = new Stream<number>();
const behavior$ = stream$.pipe(behavior(1));

behavior$.subscribe(x => console.log("a:", x));
// a: 1
stream$.push(2);
// a: 2

behavior$.subscribe(x => console.log("b:", x));
// b: 2
stream$.push(3);
// a: 3, b: 3

behavior$.subscribe(x => console.log("c:", x));
// c: 3
stream$.push(4);
// a: 4, b: 4, c: 4

(this mirrors BehaviorSubject, but its the same working principle for Subject or ReplaySubject)