$a      $b        Type of Match Implied    Matching Code
           ======  =====     =====================    =============
           (overloading trumps everything)

           Code[+] Code[+]   referential equality     $a == $b
           Any     Code[+]   scalar sub truth         $b->($a)

           Hash    Hash      hash keys identical      [sort keys %$a]~~[sort keys %$b]
           Hash    Array     hash slice existence     grep {exists $a->{$_}} @$b
           Hash    Regex     hash key grep            grep /$b/, keys %$a
           Hash    Any       hash entry existence     exists $a->{$b}

           Array   Array     arrays are identical[*]
           Array   Regex     array grep               grep /$b/, @$a
           Array   Num       array contains number    grep $_ == $b, @$a
           Array   Any       array contains string    grep $_ eq $b, @$a

           Any     undef     undefined                !defined $a
           Any     Regex     pattern match            $a =~ /$b/
           Code()  Code()    results are equal        $a->() eq $b->()
           Any     Code()    simple closure truth     $b->() # ignoring $a
           Num     numish[!] numeric equality         $a == $b
           Any     Str       string equality          $a eq $b
           Any     Num       numeric equality         $a == $b

           Any     Any       string equality          $a eq $b