Flip argument order of takeUntil module

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 commit flips the argument order to (end, src) allowing us to better
use takeUntil in pipelines such as:

```js
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))
  )
```

This also fixes an issue with takeUntil where if the new endStream had a
value the dependent stream wouldn't update.

.gitignore

@@ -3,6 +3,9 @@
 logs
 *.log
 
+# vscode settings
+.vscode
+
 # Dependency directory
 node_modules
 bower_components

index.d.ts

@@ -226,8 +226,8 @@ declare module 'flyd/module/switchlatest' {
 
 declare module 'flyd/module/takeuntil' {
   interface takeuntil {
-    <T, V>(source: flyd.Stream<T>, end: flyd.Stream<V>): flyd.Stream<T>;
-    <T>(source: flyd.Stream<T>): <V>(end: flyd.Stream<V>) => flyd.Stream<T>;
+    <T, V>(end: flyd.Stream<T>, src: flyd.Stream<V>): flyd.Stream<V>;
+    <T>(end: flyd.Stream<T>): <V>(src: flyd.Stream<V>) => flyd.Stream<V>;
   }
   const _takeuntil: takeuntil;
   export = _takeuntil;

module/switchlatest/index.js

@@ -1,12 +1,9 @@
 var flyd = require('../../lib');
 var takeUntil = require('../takeuntil');
-var drop = require('ramda/src/drop');
-
-var dropCurrentValue = flyd.transduce(drop(1));
 
 module.exports = function(s) {
   return flyd.combine(function(stream$, self) {
     var value$ = stream$();
-    flyd.on(self, takeUntil(value$, dropCurrentValue(stream$)));
+    flyd.on(self, takeUntil(stream$, value$));
   }, [s]);
 };

module/takeuntil/README.md

@@ -6,12 +6,12 @@ __Graph__
 ```
 a:               {---1---2---3---4}
 b:               {---------x------}
-takeUntil(a, b): {---1---2--------}
+takeUntil(b, a): {---1---2--------}
 ```
 
 __Signature__
 
-`Stream a -> Stream b -> Stream a`
+`Stream a -> Stream b -> Stream b`
 
 __Usage__
 
@@ -20,7 +20,7 @@ const takeUntil = require('flyd/module/takeuntil')
 
 const source = flyd.stream()
 const end = flyd.stream()
-const result = takeUntil(source, end)
+const result = takeUntil(end, source)
 
 source(1)(2)
 result() // 2

module/takeuntil/index.js

@@ -1,7 +1,12 @@
 var flyd = require('../../lib');
+var drop = require('ramda/src/drop');
 
-module.exports = flyd.curryN(2, function(src, term) {
-  return flyd.endsOn(flyd.merge(term, src.end), flyd.combine(function(src, self) {
+var drop1 = flyd.transduce(drop(1));
+
+module.exports = flyd.curryN(2, function(term, src) {
+  var end$ = flyd.merge(term.hasVal ? drop1(term) : term, src.end);
+
+  return flyd.endsOn(end$, flyd.combine(function(src, self) {
     self(src());
   }, [src]));
 });

module/takeuntil/test/index.js

@@ -5,36 +5,39 @@ var assert = require('assert');
 var takeUntil = require('../index');
 
 describe('takeUntil', function() {
-  it('emits values from first stream', function() {
+  it('emits values from source stream', function() {
     var result = [];
     var source = stream();
     var terminator = stream();
-    var s = takeUntil(source, terminator);
-    flyd.map(function(v) { result.push(v); }, s);
+    source
+      .pipe(takeUntil(terminator))
+      .map(function(v) { result.push(v); });
     source(1)(2)(3);
     assert.deepEqual(result, [1, 2, 3]);
   });
-  it('ends when value emitted from second stream', function() {
+  it('ends when value emitted from terminator stream', function() {
     var result = [];
     var source = stream();
     var terminator = stream();
-    var s = takeUntil(source, terminator);
-    flyd.map(function(v) { result.push(v); }, s);
-    s(1);
+    var s = source
+      .pipe(takeUntil(terminator))
+      .map(function(v) { result.push(v); });
+    source(1);
     terminator(true);
-    s(2);
+    source(2);
     assert.deepEqual(result, [1]);
     assert(s.end());
   });
   it('ends if source stream ends', function() {
     var result = [];
     var source = stream();
     var terminator = stream();
-    var s = takeUntil(source, terminator);
-    flyd.map(function(v) { result.push(v); }, s);
-    s(1);
+    var s = source
+      .pipe(takeUntil(terminator))
+      .map(function(v) { result.push(v); });
+    source(1);
     source.end(true);
-    s(2);
+    source(2);
     assert.deepEqual(result, [1]);
     assert(s.end());
   });