can add a Set operate: R.isSubset ?

[adispring]

[a] -> [b] -> Boolean
const isSubset = R.curry((subset, set) => R.equals(R.intersection(subset, set), subset));
isSubset([1, 2], [1, 2, 3])); // true
isSubset([1, 2, 3], [1, 2, 3])); // true
isSubset([1, 2, 3, 4], [1, 2, 3])); // false

[buzzdecafe]

could be interesting, are you willing to do a PR? A couple of notes: I think the signature would have to be Set a -> Set a -> Boolean; and I wonder if it makes more sense to take the superset as the first argument?

[CrossEye]

I think the signature would have to be Set a -> Set a -> Boolean;

Are you suggesting the native Set type or simply lists that are assumed to have no duplicates?

If it were [a] -> [a] -> Boolean or (oddly?) [a] -> [b] -> Boolean, what would be the expectation in dealing with MultiSets/Bags, e.g.

isSubset([1, 2, 2], [1, 2, 3, 4]); //=> ??

[adispring]

Since Array(list) is not set, isSubset should use uniq and sort, like union and intersection.

[adispring]

const isSubset = R.curry((set, subset) => {
  const sortU = R.compose(R.sort((a, b) => a - b), R.uniq);
  return R.equals(sortU(R.intersection(set, subset)), sortU(subset));
});
console.log(isSubset([1, 2], [1, 2, 3])); // true
console.log(isSubset([1, 2, 2, 2], [1, 2, 3])); // true
console.log(isSubset([1, 2, 3, 4], [1, 2, 3])); // false

list's subset looks wired.

[CrossEye]

Of course not everything we might want to test for uniqueness/subset is necessarily ordered. I don't think an actual implementation could use any kind of sort.

[adispring]

another implementation:

const isSubset = R.compose(R.isEmpty, R.without);

const set = [2, 1, 3, 1, 3];
const subset = [2, 2, 2, 1, 2];
console.log(isSubset(set, subset)); // true

[buzzdecafe]

I don't like using arbitrary lists as arguments to a function called isSubSet.

const set = [2, 1, 3, 1, 3]; // Not a Set
const subset = [2, 2, 2, 1, 2]; // // Not a Set
isSubset(set, subset) // should throw TypeError

Simplest would be to find a better name (isSubBag? 😜); the harder thing would be to support actual Sets (i.e. not JS Set).

[CrossEye]

...or conceivably to support something like sanctuary-js/sanctuary-set#1.

[adispring]

OK, I will take a look at that repository to see what should I do.

[CrossEye]

That's a huge piece of work. I was really just riffing on the suggestion from @buzzdecafe. Ramda generally does not supply types. But because of our insistence on value equality, the native Set type is fairly useless to us; something like the work here might be more helpful. But it's a large undertaking, not a quick PR, I'm afraid.

[semmel]

@adispring R.isSubset is a very useful function because it is the generalization of R.contains i.e. R.includes nowadays.

Yet another implementation taking the subset as first argument (maybe for the Cookbook along overlaps)

var isSubset = R.compose(R.isEmpty, R.useWith(R.difference, [R.uniq, R.uniq]));
console.log(isSubset([1, 2], [1, 2, 3])); // true
console.log(isSubset([1, 2, 2, 2], [1, 2, 3])); // true
console.log(isSubset([1, 2, 3, 4], [1, 2, 3])); // false
isSubset([2, 2, 2, 1, 2], [2, 1, 3, 1, 3]); // true

[danielo515]

I pretty much prefer the implementation of @adispring . Not only it is simpler but for me it's also more useful to take the big set first.
Was this implemented? I guess no...

[crvouga]

const isSubset = R.curry((xs, ys) =>
	R.all(R.contains(R.__, ys), xs))

[Ruben9922]

I think having an isSubset (and maybe isSuperset) function in Ramda would be a great idea, especially as Ramda already contains functions for common set operations such as union, intersection and difference. Also, I personally would be happy just having it work on lists (rather than JS Set), to be consistent with said set operations already in Ramda.

Regarding the naming, I guess an alternative name could be includesAll or containsAll (as @semmel said, it can be thought of as a generalisation of includes/contains). Though personally I prefer isSubset, again to consistent with the set operations already in Ramda (which, despite working on lists, are named after set operations).

[Ruben9922]

Yet another implementation would be to check whether the union equals set:

const sortU = R.pipe(R.uniq, R.sortBy(R.identity));
const isSubset = (subset, set) => R.equals(sortU(R.union(subset, set)), sortU(set));

Another alternative would be to compare the cardinalities of the sets, rather than the sets themselves:

const isSubset = (subset, set) => R.equals(R.length(R.intersection(subset, set)), R.length(subset));

(This follows on from the first method by @adispring - checking whether intersection equals subset. Also, note that the equivalency this is based on assumes subset is finite.)

See here.

[CrossEye]

@Ruben9922:

Are you interested in submitting a PR for this?

[Ruben9922]

@CrossEye
Yeah, that would be great! I'll try to work on it over the next few days.