[RFC] Implement Except Set Operation about fromfrom

[leeoniya]

probably would be more flexible as a function, and more uniform with the rest of the lib.

.not(e => e == 2)

EDIT: eh, i guess my version is just the inverse of filter. i'd still prefer to keep the minimal api:

.filter(e => e !== 2)

/$0.02

[jtenner]

I was just reading the TODO.md and agree with your thoughts. What sort of work can be done instead?

[jtenner]

Sidenote: some functions could just be shorthand aliases for things.

export const withoutIterable = <TItem>(
  iterable: Iterable<TItem>,
  items: TItem[],
): Iterable<TItem> => {
  return filterIterable(iterable, e => !items.includes(e));
}

Keeps the implementation minimal.

[tomi]

Hi and thank you for opening an issue. I'm happy to hear that you are willing to contribute!

What I had in mind with except is pretty much what you described, i.e. what lodash's without also does. But instead of expecting an array, we could accept any Iterable<TItem>. This way we can support other iterable objects besides arrays. So the signature could be:

.except(items: Iterable<TItem>): Sequence<TItem> {...}
// Or .without, I'm okay with using either name

Also it might make sense to have an overloaded method that accepts a custom equality comparer to compare the items, but this can also be added later on. The signature for that would be:

.except(items: Iterable<TItem>, comparer: EqualityCompareFn<TItem>): Sequence<TItem> {...}
// where the type for compare function is:
type EqualityCompareFn<TItem> = (a: TItem, b: TItem) => boolean;

And regarding the implementation, I do like using the filterIterable 👍 The given items could be first converted to Set tho, as Array.prototype.includes is O(n) where as Set.prototype.has is O(log(n)) or O(1) (at least according to this).

[jtenner]

Great! I'm sorry for taking a while to get back to this issue. Let me spin up a pull request and I'll make some changes.

Question, because my brain likes lots of clarification. How should I use an EqualityCompareFn?

This is what I would personally expect when I use the without operation.

import { createFilterIterable } from "./filter";

export const createWithoutIterable = <TItem>(
  iterable: Iterable<TItem>,
  items: TItem[],
): Sequence<TItem> => {
  const set = new Set(items);
  return createFilterIterable(iterable, item => !set.has(item));
}

[tomi]

No worries, there's no rush :)

The idea behind EqualityCompareFn would be to allow the user to provide a custom function that compares if two objects are equal, instead of using the sameValueZero comparison. However, Set does not support providing a custom function for comparing the equality of two items. So I think at this point we can forget that and add it later on if it's actually needed.

[jtenner]

#31 addresses this enhancement as far as I am capable of. Thanks for the quick responses.

[tomi]

Available in 1.2.0 🎉