Should do async stop but did sync stop [edited title]

This is the example of http like cycle driver where the request is resolved synchronously. Couldn’t narrow it down simple xstream pattern, but I wonder why for one request in sink in this case it actually does two requests (starts stream two times).

import xs from 'xstream'
import delay from 'xstream/extra/delay'

let requestsCount = 0

const driverWithSyncResponse = (request$) => {
  const createResponse$ = (request) => {
    const stream$ = xs.create({
      start: (listener) => {      
        requestsCount++
        listener.next(request.num)
        listener.complete()
      },
      stop: () => { }
    }).remember()
    stream$.addListener({ next: () => { } })
    return stream$
  }
  const r$$ = request$.map(createResponse$)
  r$$.addListener({ next: () => { } })
  return r$$
}

const request$ = xs.of({ num: 1 }).compose(delay(0))

const r$$ = driverWithSyncResponse(request$)

r$$.flatten()
  .addListener({
  next: (res) => {
    console.log('Actual requests count should be 1, but it is', requestsCount)    
  }
})

https://www.webpackbin.com/bins/-Ki1D10ZxL0MfO5pVGQt

[staltz]

Yeah, so I think this is only about whether MemoryStream should be one-time use or be resetable. There is no correct answer. I’ve seen this exact issue in RxJS, I recommend reading the discussion: https://github.com/ReactiveX/rxjs/issues/453

Right now, I’m inclined to do what RxJS eventually did: allow reusable MemoryStream. Which means keeping the current behavior, and if you really want MemoryStream to keep the value, then appending it with xs.never().

xs.merge(s, xs.never()) is becoming a common “hack”, we might consider the idea of making it idiomatic with e.g. x$.neverEnd()

[xtianjohns]

Hey @whitecolor, most (okay all) of the bins linked to this seem to have expired, but do the snippets make sense? Does the suggested pattern work for you?