How to set deeper patterns in arguments within function definitions. For example if an argument must be a list of 1 or more strings

Question

Suppose I want to define a function whose argument must be a List of only Strings and List must have at least one member. I know how to require that the Head must be a List but how does one qualify List members within an argument? I really don't want to resort pattern matching inside the body of my definitions or trailing a conditional pattern outside my definitions.

This is what I have so far along with a few test cases...

fn[arg_List && AllTrue[arg, StringQ] && Length@arg > 0] := 
  Block[{}, arg];
fn[{"a", "b", "c"}] (* should return {"a","b","c"} *)
fn[{1, "b", "c"}]
fn[{}]

Unfortunately it produces no errors which in this case would have been very helpful.

Answer 1

When imposing restrictions on patterns, there are typically two options:

• Use Condition (/;) to specify an arbitrary expression as test. (This is what was shown in the comments)

  fn[arg_List /; (AllTrue[arg, StringQ] && Length@arg > 0)] := Module[{}, arg];
  fn[arg_ /; VectorQ[arg, StringQ] && arg != {}] := Module[{}, arg];
  

  This is most flexible, but can be significantly slower, since the pattern matcher has to ask the kernel to evaluate the condition

• Use structural patterns: The pattern arg_List is mostly equivalent to arg:{___}, where Pattern (:) gives the name, and the {___} is "anything that looks like a list with zero or more arguments (see BlankNullSequence, ___). To require at least one element, use BlankSequence (__). You can also specify a head for these elements, e.g. __String. So the pattern here would be:

  fn[arg:{__String}] := Module[{}, arg];
  

  If each element should follow a more complex pattern, you can use Repeated (..) and RepeatedNull (...). So to require e.g. a list of lists of strings, use

  fn[arg:{{__String}...}] := Module[{}, arg];
  

  If the condition on the single elements is more complex, you can use PatternTest (?):

  fn[arg:{__String?(StringStartsQ["a"])}] := Module[{}, arg];
  

  This example requires a list of strings starting with a.