Strange behaviour of Observable.of([x]).map

[chrisprice]

I have a use case for creating an observable of arrays and came across some odd behaviour. The map function is invoked twice when using Observable.of(x) but not when using Observable.from([x]). Is this expected?

  it('should emit one value', function (done) {
    var calls = 0;
    Observable.of([42]).map(function (x) {
      expect(++calls).toBe(1);
      expect(x).toEqual([42]);
      return x;
    }).subscribe(function (x) {
      expect(++calls).toBe(2);
      expect(x).toEqual([42]);
    }, function (x) {
      done.fail('should not be called');
    }, done);
  });

Failures:
1) Observable.of should emit one value
  Message:
    Expected 2 to be 1.
  Stack:
    Error: Expected 2 to be 1.
        at ScalarObservable.<anonymous> (/Users/chris/RxJS/spec/observables/of-spec.js:51:23)
        at ScalarObservable.proto.map (/Users/chris/RxJS/dist/cjs/observable/ScalarObservable.js:61:45)
        at Object.<anonymous> (/Users/chris/RxJS/spec/observables/of-spec.js:50:25)
  Message:
    Expected 3 to be 2.
  Stack:
    Error: Expected 3 to be 2.
        at SafeSubscriber.<anonymous> (/Users/chris/RxJS/spec/observables/of-spec.js:55:23)
        at SafeSubscriber.tryCatcher [as _next] (/Users/chris/RxJS/dist/cjs/util/tryOrOnError.js:4:31)
        at SafeSubscriber.next (/Users/chris/RxJS/dist/cjs/Subscriber.js:89:18)
        at ScalarObservable._subscribe (/Users/chris/RxJS/dist/cjs/observable/ScalarObservable.js:44:24)

1999 specs, 1 failure

However, swapping Observable.of([42]) for Observable.from([[42]]) as below, doesn't trigger the failure.

  it('should emit one value', function (done) {
    var calls = 0;
    Observable.from([[42]]).map(function (x) {
      expect(++calls).toBe(1);
      expect(x).toEqual([42]);
      return x;
    }).subscribe(function (x) {
      expect(++calls).toBe(2);
      expect(x).toEqual([42]);
    }, function (x) {
      done.fail('should not be called');
    }, done);
  });

[chrisprice]

Should have mentioned this was tested with master (d2e852).

[benlesh]

@chrisprice ... currently there are optimizations for ScalarObservables. A ScalarObservable is any Observable that gives you a single, synchronous value. (in other words Observable.of(x)). If you map on a ScalarObservable, it will immediately perform the map and just give you a new ScalarObservable. This saves unnecessary computation when subscribing multiple times to that observable.

It's a powerful optimization, but it's up for debate, for sure.

from and of are two different animals. from will take any Observable, promise or iterable (arrays for example) and create an Observable from it's values. of will take arguments and make an Observable from them. Observable.of(a, b, c) and Observable.fromArray([a, b, c]) are effectively the same thing.

Generally, you shouldn't be creating side-effects in your map functions. Instead use do or subscribe.

[benlesh]

In short...

• Observable.of creates an Observable.
• Observable.from converts to an Observable.
• Observable.of(a) creates a ScalarObservable that has optimizations for synchronous operators like map, filter, scan and reduce.
• Observable.of(a, b, c) creates an ArrayObservable that has no such optimizations.

[chrisprice]

Thanks for the explanation, that does explain the behaviour I saw. The snippet I discovered this in caused me to pull my hair out -

Rx.Observable.of([
    {z: 1}
  ])
  .map((x) => 
    x.map((y) => (y.z += 'A', y))
  )
  .subscribe((x) => console.log(x))

Which logged out -

[[object Object] {
  z: "1AA"
}]

Now I agree that's an odd thing to be doing (I was just hacking some test data) and I also agree that map functions shouldn't contain side-effects, but it was totally unexpected behaviour!

[chrisprice]

Actually I've been thinking about this and I'm not sure whether your explanation covers why the map function is called twice? I do understand that the map function will be called on initialisation rather than subscription but that's not what's being tested (I don't think!).

[benlesh]

Yeah, there is a bug apparently:

let source = Rx.Observable.of(1)
  .map((x) => {
    console.log('hit');
    return x;
  });

logs:

"hit"
"hit"

Flagging this as a bug.

However it should go away if these optimizations are removed with #1142

[lock]

This thread has been automatically locked since there has not been any recent activity after it was closed. Please open a new issue for related bugs.