Thank you for pointing this out. I come up with the following solution based on your tricks and tips:

In[496]:= AffModOneDotOnLeft // ClearAll;
AffModOneDotOnLeft[{x__?MatrixQ} | x__?MatrixQ] := Module[{dim,elms},
elms={x};
dim=Dimensions[{x}[[1]]][[1]]-1;

TransformationMatrix[
    AffineTransform[{#[[1 ;; dim, 1 ;; dim]], 
        Mod[#[[1 ;; dim, dim + 1]], 1]}] &@(Dot@@elms)] // Expand // 
  Together // FullSimplify
]

p={{-1, -1, 1, 3/4}, {1, -1, -1, -(5/4)}, {-1, 1, -1, -(5/4)}, {0, 0, 0,
   1}};
q={{-1, 0, 0, 0}, {0, -1, 0, 0}, {0, 0, 1, 0}, {0, 0, 0, 1}};
r=Inverse[p];

MapAt[Mod[#,1]&, p . q . r,{1;;3,4}]==AffModOneDotOnLeft[p . q,r]==AffModOneDotOnLeft[p,q . r]==AffModOneDotOnLeft[p,q,r]==AffModOneDotOnLeft[{p,q,r}]

Out[501]= True

Dear Hans Milton,

Thank you for your clarification. The following code does the trick:

In[898]:= f[{x__} | PatternSequence[x__]] := {x}
p={{-1, -1, 1, 3/4}, {1, -1, -1, -(5/4)}, {-1, 1, -1, -(5/4)}, {0, 0, 0,
1}};
q={{-1, 0, 0, 0}, {0, -1, 0, 0}, {0, 0, 1, 0}, {0, 0, 0, 1}};
r=Inverse[p];

f[{p, q, r}]
%==f[p, q, r]

Out[902]= {{{-1, -1, 1, 3/4}, {1, -1, -1, -(5/4)}, {-1, 
1, -1, -(5/4)}, {0, 0, 0, 1}}, {{-1, 0, 0, 0}, {0, -1, 0, 0}, {0, 
0, 1, 0}, {0, 0, 0, 1}}, {{-(1/2), 
0, -(1/2), -(1/4)}, {-(1/2), -(1/2), 
0, -(1/4)}, {0, -(1/2), -(1/2), -(5/4)}, {0, 0, 0, 1}}}

Out[903]= True

e.g. do you expect exactly three square matrices of the same dimensions?

All square matrices here should be affine transformation matrices of the same dimension, such as 3, in this case, they should be as follows:

In[3]:= AffineTransform[{Array[a, {3, 3}], 
   Array[b, {3}]}] // TransformationMatrix

Out[3]= {{a[1, 1], a[1, 2], a[1, 3], b[1]}, {a[2, 1], a[2, 2], 
  a[2, 3], b[2]}, {a[3, 1], a[3, 2], a[3, 3], b[3]}, {0, 0, 0, 1}}

I don't know how to accurately check these conditions that these parameters should meet, so I used an inappropriate judgment method.

I think it would really be valuable for you to look at intermediate results, maybe use Trace, and come up with test cases that are both simpler and more robust. Side note, I really don't understand the desire to use Module here at all.

Anyway, just based on your original description,

a function which can accept a list or separate elements as arguments

I would have come up with this:

myFunc[list_List] := processTheStuff[list];
myFunc[args__] := myFunc[{args}]

I assume that you want the function to behave "the same" for each type of argument. My standard way of doing that is to choose which form is canonical, and use that form in the definition of the other. In this case, it seemed simpler to make the list form canonical.

Now, why does this even work at all? Because the Mathematica evaluator looks at the DownValues for a function in a particular order. It looks from most specific pattern to least specific pattern. The heuristic for "specificity of pattern" isn't always obvious (and in tie-breaker situations the definition evaluated first comes before the one evaluated later), but you can always just look at the DownValues and know that they will be inspected in that order. In this particular case, myFunc[list_List] is unambiguously more specific than myFunc[args__].

Let's test it. Here is where I think you get yourself in trouble. Start your testing with simple examples.

myFunc[a] (* processTheStuff[{a}] *)
myFunc[{a}] (* processTheStuff[{a}] *)
myFunc[a, b] (* processTheStuff[{a, b}] *)
myFunc[{a, b}] (* processTheStuff[{a, b}] *)
myFunc[{a}, b] (* processTheStuff[{{a}, b}] *)
myFunc[{a}, {b}] (* processTheStuff[{{a}, {b}}] *)
myFunc[{{a}, {b}}] (* processTheStuff[{{a}, {b}}] *)
(* and so on until you're satisfied *)

Side note, I'm dismissing the whole Flatten stuff, because that would fundamentally change the structure of your inputs, and so we wouldn't get the same behavior for each type of argument. If you need Flatten, that suggests a completely different question, or at least it seems that way to me.

Okay, let's try to answer your latest question. Mutating one of the definitions as you did is a good way to help understand the pattern matching. I'd be even more explicit about it. Let's redefine myFunc:

ClearAll[myFunc];
myFunc[list_List] := processA[list];
myFunc[args__] := processB[{args}];

And here's your test input:

args = {{a}, {b}, {c}}

Now let's test:

myFunc[args] (* processA[{{a}, {b}, {c}}] *)
myFunc[{a}, {b}, {c}] (* processB[{{a}, {b}, {c}}] *)

So that's pretty clear.

What about args // Sequence? Well, I think you think this is doing something different than it is. This is just wrapping args in the head Sequence. When Sequence expressions are encountered "inside" other expressions, the Sequence effectively gets stripped and you're left with the ... well, sequence that was inside Sequence.

args // Sequence (* Sequence[{{a}, {b}, {c}}] *)
JustToTest[args // Sequence] (* JustToTest[{{a}, {b}, {c}}] *)
myFunc[args // Sequence] (* processA[{{a}, {b}, {c}}] *)

What you might have thought you were doing was replacing the List head with Sequence. But you do that with Apply, aka @@

Sequence @@ args (* Sequence[{a}, {b}, {c}] *)
JustToTest[Sequence @@ args] (* JustToTest[{a}, {b}, {c}] *)
myFunc[Sequence @@ args] (* processB[{{a}, {b}, {c}}] *)

Ok, I will try to be a bit more clear. This is the code:

f[{x__} | PatternSequence[x__]] := {x}

When the input argument is a list, the x represents the sequence of elements in the the list, not the whole list itself. In the function body that sequence of elements is inserted between curly brackets. The result is then just a copy of the input list. No need to flatten it.

The other example:

h[x : {__} | PatternSequence[__]] := {x} // Flatten

Here the x represents the whole list. When inserted between curly brackets the result is a list within a list. That needs to be flattened.

That is because if there is nothing to be flattened the function Flatten cannot do anything. It just returns the input list.

Nice trick. It does the job, as shown below:

In[183]:= f3 // ClearAll;
f3[args__] := (* or f3[arg___ *)
  Module[{x = Flatten@{args}},
   (* body of function *)
   x];

In[185]:= f3[{a, {b, c}, d}] 
f3[{a, {b, c}}, d]
f3[{p, q, r}]
f3[p, q, r]

Out[185]= {a, b, c, d}

Out[186]= {a, b, c, d}

Out[187]= {p, q, r}

Out[188]= {p, q, r}

N.B.: I changed With to Module, considering that the latter is more robust.

Nice example. But I still don't quite understand why the latter can't plot the corresponding functions in this case.

See my following testing based on your above examples:

In[160]:= (*You could use Alternatives together with PatternSequence*)
f[{x__} | PatternSequence[__]] := {x} 
f[{p, q, r}]
f[p, q, r]

Out[161]= {p, q, r}

Out[162]= {p, q, r}

In[163]:= (*Another example:*)
g[x : {__} | PatternSequence[__]] := {x}
g[{p, q, r}]
g[p, q, r]

Out[164]= {{p, q, r}}

Out[165]= {p, q, r}

As you can see, the former will always generate a list, while the latter will generate an embedded list when the argument is a list. Why is there such a difference?

Regards, Zhao

Another example:

In[43]:= g[x : {__} | PatternSequence[__]] := {x} // Flatten // Total

In[44]:= g[{p, q, r}]
Out[44]= p + q + r

In[45]:= g[p, q, r]
Out[45]= p + q + r