8

Perl6 documentation indicated that when comparing two items in a set, === is used. This is quote from perl6 documentation:

Objects/values of any type are allowed as set elements. Within a Set, every element is guaranteed to be unique (in the sense that no two elements would compare positively with the === operator)

I am wondering if it is possible to use a user-defined function instead of ===? E.g., How can I use ~~ instead of === in determining whether 2 elements in a set are "equal".

The problem I am trying to solve is this: set A has some first names and some last names in any order but all lower case and no punctuation, and set B has a number of first names and last names mixed in any order, and there may be punctuation attached to the names and may be upper or lower cases. I want to know if a person in set A (represented as a subset of A with one specific first and last name) appears in set B. In this case, I cannot use === because of the letter cases and punctuation in set B.

If I can use ~~ instead of ===, the problem will be much simpler because I only need to determine if a subset of A is also a subset of B using ~~. This is similar to a "permutation match" problem I mentioned before.

Thank you very much !

Milo
  • 3,365
  • 9
  • 30
  • 44
lisprogtor
  • 5,677
  • 11
  • 17
  • 1
    This is also highly relevant for checking list membership: `$foo ∈ @array` uses `===`. And `===` seems to use the `.WHICH` function. It's an important problem because some objects don't have a predictable `.WHICH` ID, like `Pair`, which will have a different `.WHICH` depending on whether you write the elements as value-types or variables. So you can end up with `(1 => 2) ∉ [1 => 2, 3 => 4]` depending on whether the data structures were created with variables or containerless values. – piojo Dec 06 '17 at 07:25
  • Can you give a short example of a person, a possible set A, and a possible set B? Or just a person and a set B? – piojo Dec 06 '17 at 09:05
  • I'm looking at whether taking the containerness of `Pair.value` into account when generating `Pair.WHICH` is correct or not. – Elizabeth Mattijsen Dec 06 '17 at 13:01
  • @ElizabethMattijsen It's just coincidence that listprogtor's question is so similar to mine. I'm not sure what data type the sets are holding, but it's probably not `Pair`. So perhaps this problem is general--we want a way to check set membership without needing the objects to have the same `.WHICH`. I've been using `@list.first({ $_ eqv $value }).defined`, but that's not a perfect solution. It would be nice to delete from sets this way too, but that's probably too much of a specific API. – piojo Dec 06 '17 at 15:08
  • Hi piojo, here is a real life example: Set A is .Set, and set B is .Set, and I want to know if a subset of A, .Set, is a subset of set B. I would prefer to use ~~ instead of === to compare the elements. Thanks. – lisprogtor Dec 07 '17 at 05:24

1 Answers1

5

There are a couple ways, and I'll start with the easy/slow way. I'll use the == operator, but you can use any operation. If you want to iterate over the list/set, you can use first with whatever match logic you like, then check for .defined to confirm that you got a match. (If you want to be really careful or if your list contains undefined items, you should use the :p adverb so your output is a key/value pair, and that will be defined if and only if some matching element was found.)

For an example of sloppy matching using this technique, I'll search for a number in a list and set of IntStr:

say 4 ∈ ("3", "4"); # False, because the list doesn't contain the integer 4
say ("3", "4").first(* == 4, :p).defined; # True
say set("3", "4").keys.first(* == 4, :p).defined; # True

You would have to benchmark to know whether this is as fast as checking set membership in a more conventional way. For a large set, the conventional ways should be faster, since hash lookup can be used. In some programming languages, iteration is faster than hashing until the list gets really big.

If you don't need to get the matching element, you can use junctions, which will do multiple checks in parallel:

say so ("3", "4").any() == 4; # True

And you can use junctions to do subset testing as well, but since this is an O(m*n) operation (despite being auto-threaded), don't expect high performance when comparing two very large sets.

say so (2, 3).all() == ('1', '2', '3').any(); # True
say so (2, 3, 4).all() == ('1', '2', '3').any(); # False

I used lists instead of sets above, since if you're not using the standard operators/methods, sets offer no speed or API advantage.

piojo
  • 6,351
  • 1
  • 26
  • 36