How to use Or (||) in a less verbose test function?

Question

Suppose I have myStrList, a list of one-character strings:

myStrList = {"A", "a", "B", "b"};

I wish to create a function that will return True if a string is either "A" or "a", and False otherwise. I wish to Map this function across the list myStrList.

1. Method (1). One way to do this is to use MemberQ to test if a string is a member (element) of the list {"A", "a"}. This method gives the expected output:

(* Method (1): using MemberQ *)
Map[MemberQ[{"A", "a"}, #] &, myStrList]
(* {True, True, False, False} *)

2. Method (2). Another way is to use MatchQ with a pattern object involving Alternatives (or, equivalently, |). This method also gives the expected output:

(* Method (2): using MatchQ and Alternatives (|) *)
Map[MatchQ[#, Alternatives["A", "a"]] &, myStrList]
Map[MatchQ[#, "A" | "a"] &, myStrList]
(* {True, True, False, False} *)
(* {True, True, False, False} *)

3. Method (3). Still another way is to use Or (or, equivalently, ||), the logical OR. Again, this method gives the expected output:

(* Method (3): using Or (||) *)
Map[Or[# == "A", # == "a"] &, myStrList]
Map[# == "A" || # == "a" &, myStrList]
(* {True, True, False, False} *)
(* {True, True, False, False} *)

Is there a way to condense method (3), so that it is less verbose? Instead of asking whether # == "A" OR # == "a", can I ask whether # == "A" OR "a"? I tried the following:

Map[# == Or["A", "a"] &, myStrList]
Map[# == ("A" || "a") &, myStrList]
(* {"A" == ("A" || "a"), "a" == ("A" || "a"),
  "B" == ("A" || "a"), "b" == ("A" || "a")} *)
(* {"A" == ("A" || "a"), "a" == ("A" || "a"),
  "B" == ("A" || "a"), "b" == ("A" || "a")} *)

Neither of the above gives the expected output. It looks as though the equality test is being held. I notice that Or (or, equivalently, ||) has attribute HoldAll:

Attributes[Or]
(* {Flat, HoldAll, OneIdentity, Protected} *)

Could it be that I need to use Evaluate to force the evaluation of # == ("A" || "a")? It doesn't seem that Evaluate helps in this regard:

Map[Evaluate[# == Or["A", "a"]] &, myStrList]
Map[Evaluate[# == ("A" || "a")] &, myStrList]
Map[# == Evaluate[Or["A", "a"]] &, myStrList]
Map[# == Evaluate[("A" || "a")] &, myStrList]
(* {"A" == ("A" || "a"), "a" == ("A" || "a"),
  "B" == ("A" || "a"), "b" == ("A" || "a")} *)
(* {"A" == ("A" || "a"), "a" == ("A" || "a"),
  "B" == ("A" || "a"), "b" == ("A" || "a")} *)
(* {"A" == ("A" || "a"), "a" == ("A" || "a"),
  "B" == ("A" || "a"), "b" == ("A" || "a")} *)
(* {"A" == ("A" || "a"), "a" == ("A" || "a"),
  "B" == ("A" || "a"), "b" == ("A" || "a")} *)

Nor does it seem that using Simplify or FullSimplify will evaluate the expressions:

Simplify /@ {"A" == ("A" || "a"), "a" == ("A" || "a"),
  "B" == ("A" || "a"), "b" == ("A" || "a")}
FullSimplify /@ {"A" == ("A" || "a"), "a" == ("A" || "a"),
  "B" == ("A" || "a"), "b" == ("A" || "a")}
(* {"A" == ("A" || "a"), "a" == ("A" || "a"),
  "B" == ("A" || "a"), "b" == ("A" || "a")} *)
(* {"A" == ("A" || "a"), "a" == ("A" || "a"),
  "B" == ("A" || "a"), "b" == ("A" || "a")} *)

The solution to this may be obvious, but it's not obvious to me. How can I force testing expressions like "A" == ("A" || "a") to evaluate? Or where am I going wrong conceptually?

Answer 1

StringMatchQ works with regular expressions or Mathematica string expressions.

myStrList = {"A", "a", "B", "b"};
(* this regular expression matches any of the characters in square brackets *)
StringMatchQ[myStrList, RegularExpression["[Aa]"]]
(* (?i) is an option to match while ignoring case *)
StringMatchQ[myStrList, RegularExpression["(?i)A"]]
(* the IgnoreCase option works the same way *)
StringMatchQ[myStrList, RegularExpression["A"], IgnoreCase->True]
(* use string expression to match a list of characters *)
StringMatchQ[myStrList, "A"|"a"]
StringMatchQ[myStrList, Alternatives@@{"A", "a"}]
(* ... and IgnoreCase *)
StringMatchQ[myStrList, "A", IgnoreCase -> True]

The result is the same for each example.

{True, True, False, False}

The same match expressions work with StringCases and StringReplace so it's a flexible method for other problems.

StringCases[myStrList, RegularExpression["[Aa]"]]

{{"A"}, {"a"}, {""}, {""}}

StringReplace[myStrList, RegularExpression["[Aa]"] -> "X"]

{{"X"}, {"X"}, {"B"}, {"b"}}

Answer 2

Conceptually, the best way to quickly determine if an element is in a set is by using a HashSet:

set = CreateDataStructure["HashSet", {"A", "a"}]
set["MemberQ", #] & /@ {"A", "a", "B", "b"}

Answer 3

myStrList = {"A", "a", "B", "b"};
Or @@ Thread[# == {"A", "a"}] & /@ myStrList

---

{True, True, False, False}

Answer 4

Here is a way to live dangerously by using $Pre:

$Pre = Function[# /. (x_ == HoldPattern[Or[s__String]]) :> 
  (Or @@ (EqualTo[x] /@ {s}))];

Map[# == ("A" || "a") &, myStrList]
(* {True, True, False, False} *)

Answer 5

You can define a listable function and use it without Map:

f["a" | "A"] = True;
f[_] = False;
Attributes[f] = {Listable};

myStrList = {"A", "a", "B", "b"};
f[myStrList]
(*    {True, True, False, False}    *)

Or you could use a Dispatch:

d = Dispatch[{("A" | "a") -> True, _String -> False}];

myStrList /. d
(*    {True, True, False, False}    *)