Flip argument order of takeUntil module

[nordfjord]

The takeUntil module violates one of the first principles of functional
programming. Its argument order was (src, end) which is a data first
argument order.

This PR flips the argument order to (end, src) allowing us to better
use takeUntil in pipelines such as:

const query = stream('');

// Start fetching the results but if they haven't
// arrived when a new query is emitted
// stop listening to the stream
const results = query
 .chain(q =>
    fromPromise(getResults(q))
      .pipe(takeUntil(query))
  )

Which could also be written as

const query = stream('');

const getResults$ = chain(compose (takeUntil(query), fromPromise, getResults))

const results = getResults$(query);

If you prefer compose to dot-chains.

[coveralls]

Coverage remained the same at 100.0% when pulling 96c915c on nordfjord:feature/flip-takeUntil-arg-order into 0b1a435 on paldepind:master.

[nordfjord]

This would close #121

[paldepind]

Maybe we should flip the meaning of a and b instead of flipping their order? As in Stream a -> Stream b -> Stream b?

[nordfjord]

Ah! yes of course! that makes much more sense, nice catch!

[paldepind]

Good observation. I agree. The new argument order is more natural for currying 👍

[nordfjord]

I think this would qualify as a breaking change, so I think we might need to bump the version to 0.3.x

[nordfjord]

To maintain the behaviour of takeUntil as it was before #180 we need to drop a single value from the terminator stream if it already has a value, otherwise the stream will end immediately.

[nordfjord]

an example of code that wouldn't work without it would be:

const s = stream();
const result$ = s.chain(q => fromPromise(getSearchResults(q)))
  .pipe(takeUntil(s))
  .map(results => h('ul', results.content.map(res => h('li', res))))
  .map(render('#results'));

In the above example you would only be able to search once. Any subsequent search would be ended immediately and not return a value.