What would be nice would be able to give a pattern a name...

You can certainly do this.

MyPattern = {_String, {__Integer}, _Symbol}

TheSymbols[structs : {MyPattern ...}] := structs[[All, -1]]

TheSymbols[{{"a", RandomInteger[10, 2], abc}, {"b", RandomInteger[10, 2], xyz}}]
(*returns {abc, xyz}*)

If you name the pattern, then all matches have to be the same expression:

MatchQ[{1.1, 2., 3 + 1}, {(e_ /; e ∈ Reals \[And] e > 1) ...}]
(*  False  : named, all three numbers are different *)

MatchQ[{2., 2., 2.}, {(e_ /; e ∈ Reals \[And] e > 1) ...}]
(*  True   : names, all are the Real 2. *)

MatchQ[{2., 2., 2}, {(e_ /; e ∈ Reals \[And] e > 1) ...}]
(*  False  : named, mix of Real 2. and Integer 2 -- not the same, even if equal *)

MatchQ[{2, 2, 2}, {(e_ /; e ∈ Reals \[And] e > 1) ...}]
(*  True   : named, all are the Integer 2 *)

MatchQ[{1.1, 2., 3 + 1}, {_?(# ∈ Reals \[And] # > 1 &) ...}]
(*  True   : unnamed pattern *)

The last with a PatternTest instead of a Condition is how to create the pattern with RepeatedNull.

It's clear, Hans, that I can always accept any pretty general parameter (parm_ in the most general case) for a function and then test parm through initialization code. But this gives lengthy useless error-checking and -handling coding.

I prefer to define function parameters as sharp as possible and use the nice Wolfram feature that the function is just not called in case of unmatched parameters.

That works for a list of Integers. Thank you! But how about an argument that could be a List of List of Integers as in calling F[{{1,2,3},{4,5,6}}] ?

I will do that though I have read a lot about patterns. In any case, something that would be great would be a repository of patterns. Some already exist in the documentation, but we would need more. I know that with regular expressions there are dictionaries of patterns for things like: valid credit card #'s phone #'s etc.. What would be nice would be able to give a pattern a name like ListOfIntegers = {_ _ _Integer} then one could compose larger patterns as in ListOfListOfIntegers = {_ _ _ListOfIntegers } meaning a ListOfListOfIntegers is made up of a list of 1 or more ListsOfIntegers

Hello Michael, Thank you very much. I will go and play with what you have taught me.

I do not understand the Repeated patterns (".." and "..."). Let me explain:

You can pick particular elements matching some conditions out of a list by Cases:

$$\text{Cases}[\{1,2.,3+i\},\text{e$\_$}\text{/;}e\in \mathbb{R}\land e>1]$$

==> {2.}

If you Trace that you can see that Cases applies the conditions on each list element:

$$\text{Trace}[\text{Cases}[\{1,2.,3+i\},\text{e$\_$}\text{/;}e\in \mathbb{R}\land e>1]]$$

==> .....

But I don' t know how to match a list with such properties:

$$\text{MatchQ}[\{1,2.,3+i\},\{(\text{e$\_$}\text{/;}e\in \mathbb{R}\land e>1)\text{...}\}]$$

==> False

... looks nice, but indeed this matches no list at all:

$$\text{MatchQ}[\{1.1,2.,3+1\},\{(\text{e$\_$}\text{/;}e\in \mathbb{R}\land e>1)\text{...}\}]$$

==> False

If you Trace that you can see that MatchQ stops checking after the first list element and returns False in any case:

Hence I cannot define a function that accepts a list of real integers greater than 1.

$$\text{Block}[\{f\},f(\text{xs}:\{(\text{e$\_$}\text{/;}e\in \mathbb{R}\land e>1)\text{...}\})\text{:=}\text{xs}-1;f(\{1.1,2.,3+1\})]$$

==> f[{1.1,2.,4}]

Note that "{(_)...}" is a correct pattern for any list:

$$\text{MatchQ}[\{1.1,2.,3+1\},\{(\_)\text{...}\}]$$

==> True

Thanks, Rohit. Of course there many way to achieve my goal. I wanted to understand why I cannot do it with the simple condition:

f[xs:{(e_/;e∈ℝ&&e>1)...}]

Above Michael Rogers explained that I have to use (unnamed) PatternTest.

BTW: Your definition with "Real | Integer" would miss rationals, hence had to use

_Real | _Integer | _Rational

Michael, just another question, concerning PatternTest for testing more than one variable.

As an example I want to match a list of 2D-vectors where y is greater than x. I can write:

MatchQ[{{1, 2}, {Pi, 3.2}}, {_?(#[[1]] < #[[2]] &) ...}]

==> True

But I cannot use a more readable form like:

MatchQ[{{1, 2}, {Pi, 3.2}}, {{_, _}?(#1 < #2 &) ...}]

==> Do you know if there is something the like?

Not pattern matching, but works :

In[1]:= And @@ Map[#[[1]] < #[[2]] &, {{1, 2}, {Pi, 3.2}}]
Out[1]= True

In[2]:= And @@ Map[#[[1]] < #[[2]] &, {{1, 2}, {4, 3.2}}]
Out[2]= False

I forgot to mention that I have opened another thread A pretty general pattern matching test program where I summarized the lessons learned here. I brought them into the form of a program within a notebook. The program is able to test arbitrary patterns against any arguments. Both with MatchQ and as function parameter specifications.