What's the point of ContainsAll, ContainsAny and friends?

Question

Mathematica 10.2 contains a few new functions that test set containment: ContainsAll, ContainsAny and a few others. The documentation mentions that these are equivalent to existing functions like IntersectingQ and SubsetQ. The only difference I can see is that the new versions support operator form, but that surely could have been added to the existing functions instead of creating new redundant ones.

• Why do we need these new functions?

• What differences are there between SubsetQ and ContainsAll (whether they seem to warrant the introduction of a new function or not)?

Answer 1

I believe Stefan R has given the answer to this question in a comment.

As I understand it, these were primarily added due to their convenience in Entity-related queries (via the operator form). See their respective refpages for examples.

The following notable differences exist between the SubsetQ and ContainsAll:

• ContainsAll has an operator form, SubsetQ doesn't
• ContainsAll has the SameTest option
• ContainsAll handles sparse arrays as normal lists, SubsetQ complains about atomic objects.

• SubsetQ allows any head, ContainsAll doesn't

  SubsetQ[f[1,2,3], f[1,2]]
  (* True *)
  
  SubsetQ[f[1, 2, 3], g[1, 2]]
  
  During evaluation of SubsetQ::heads: Heads f and g at positions 1 and 2 are expected to be the same.
  (* SubsetQ[f[1, 2, 3], g[1, 2]] *)
  
  ContainsAll[f[1, 2, 3], f[1, 2]]
  (* ContainsAll[f[1, 2, 3], f[1, 2]] *)
  

• ContainsAll[association, values] checks for the existence of all values, not key -> value pairs. SubsetQ arguably misbehaves with associations. Demonstration below:

  SubsetQ[<|a -> 1, b -> 4|>, <|a -> 1, b -> 4|>]
  (* True *)
  
  SubsetQ[<|a -> 1, b -> 4|>, <|a -> 1, c -> 4|>] (* note the different keys *)
  (* True *)
  
  SubsetQ[<|a -> 1, b -> 4|>, {1, 4}]
  
  During evaluation of SubsetQ::heads: Heads Association and List at positions 1 and 2 are expected to be the same.
  
  (* SubsetQ[<|a -> 1, b -> 4|>, {1, 4}] *)
  

  ContainsAll does this:

  ContainsAll[<|a -> 1, b -> 4|>, <|a -> 1, b -> 4|>]
  (* True *)
  
  ContainsAll[<|a -> 1, b -> 4|>, <|a -> 1, c -> 4|>] (* note the different keys *)
  (* True *)
  
  ContainsAll[<|a -> 1, b -> 4|>, {1, 4}]
  (* True *)
  

The following similarities exist that are worth pointing out:

• Neither take the multiplicity of elements into account.