Proposal for `takeuntil` method

I was looking for a “takeuntil” method across existing utils, and the closest I found was takewhile.

While takewhile “produces elements from the iterable as long as the predicate is true”, I’d expect takeuntil to “produce elements from the iterable as long as the predicate is true”.

E.g.

test('takeWhile', () => {
  expect([...takewhile([1, 2, -1, 3], x => x > 0)]).toStrictEqual([1, 2]);
});

test('takeuntil', () => {
  expect([...takeuntil([1, 2, -1, 3], x => x < 0)]).toStrictEqual([1, 2, -1]);
});

Would it make sense to add this function to the library?

I.e. having

function* takeuntil(iterable, predicate) {
  for (const value of iterable) {
    yield value;
    if (predicate(value)) return;
  }
}

compared to

export function* takewhile<T>(iterable: Iterable<T>, predicate: Predicate<T>): Iterable<T> {
    for (const value of iterable) {
        if (!predicate(value)) return;
        yield value;
    }
}

[nvie]

I can see the usefulness of a function like that, because using just takewhile, you always read past the item that breaks the predicate, and you lose that information. It may be useful to have a version that retains and returns the otherwise discarded value.

To me, takeuntil is not the best name for such function, though. I think takeuntil(iterable, pred) should always be equivalent to takewhile(iterable, invert(pred)). So takewhile(numbers, isPositive) would be the same as takeuntil(numbers, isNegative).

Example:

takewhile([2, 4, 6, -1, -2, -3], isPositive)  // [2, 4, 6]
takeuntil([2, 4, 6, -1, -2, -3], isNegative)  // also [2, 4, 6], not including the -1

The proposed implementation here is more like a takewhileInclusive. That said, I think that that is a useful function to add, so I’d be happy to merge it if you want to contribute that!

Thanks!

[jbriales]

I still plan to make a pull request for this. Need to find some idle time in the coming weeks 😃