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

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

Great, Michael. I read that restriction "... same expression ....", but did not understand it. Now I learned why and how to use PatternTest.

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?

Michael, I'm glad I didn't miss anything. I agree with what you said. Your last suggestion comes closest to the "readability" goal.

Thanks again,

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.

Here's a recursive pattern test that checks for lists of lists of...of lists of integers, that is, of arbitrarily nested lists of integers.

nestedListOfIntegerQ = MatchQ[#, {(_Integer | _?nestedListOfIntegerQ) ...}] &;

f[x_?nestedListOfIntegerQ] := Depth[x];

More examples of nested lists:

MatchQ[{1, 2, 3}, _?nestedListOfIntegerQ]
(*  True  *)

MatchQ[{{1, 2, 3}, {4, 5, 6}}, _?nestedListOfIntegerQ]
(*  True  *)

MatchQ[{{2}, {3, {4}, 5}}, _?nestedListOfIntegerQ]
(*  True  *)

(* Allows empty lists *)
MatchQ[{{}, {{}}}, _?nestedListOfIntegerQ]
(*  True  *)

Use double-dot .. (Repeated) instead of the triple-dot ... (RepeatedNull) to match nested lists, none of which are empty. If you want a mix, you'll have to specify an explicit pattern for the specific mix.

So, is there some sort of repository of pattern expressions for commonly used patterns? Things like patterns for URLs, IP addresses, street addresses, etc...?

Not patterns but Interpreter can do that.

f[ns : {___Integer}] = whatever  (*this includes an empty list*)
f[ns : {__Integer}] = whatever (*this excludes an empty list*) 

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