Beautiful functional programming, avoiding nested pure functions (i know the basics of pure functions but am not conversant with SlotSequence or nested pure functions), thank you so much!

That's "my point of being": not to be really knowledgeable in stochastics, and not to quickly obtain the end result of a textbook problem, but to (day by day) learn more about Wolfram L coding (core language practice), gain more experience, getting better at it. Solving the end of chapter problems in my stochastics highschool textbook, one after the other, beginning from Chapter 1, is just my vehicle to practice using Mathematica as my text processing editor instead of handwriting solutions or using M$ Word/Excel/Powerpoint, or LaTeX (ouch). @Shenghui Yang you totally helped me in this regard, on my path to learning/understanding more of the language. So thanks again for your kind attention!! I think readers of this thread can learn quite something about recognizing the need for Thread no pun intended and how to apply it correctly. I really learned something here! The last time i did some coding was 2.0 yrs ago, and it seems that i didn't lose all my essential knowledge during that downtime. I am motivated now to carry on with my stochastics highschool textbook solutions manual project. Should be completed within 6 months.

And finally here are the coding solutions, developed in this thread, to solve the original textbook problem "Show all possible hands, dealing out 2 cards to 3 players from a deck of 6 different cards (90 possibilities)", thanks for your interest:

In[113]:= deck = {1, 2, 3, 4, 5, 6};
player1 = Subsets[deck, {2}];

rest1 = Complement[deck, #] & /@ player1;
player2 = Subsets[#, {2}] & /@ rest1;
trans = Transpose[{rest1, player2}];
player3 = (Map[Thread[Apply[f, #], List, -1] &, trans]) /. 
   f -> ( Complement[#1, #2] &);

rest1h = Hold[#] & /@ rest1;
player2h = Thread[Hold[#]] & /@ player2; (* ugly coding *)
transh = Transpose[{rest1h, player2h}];
player3h = (Map[Thread[Apply[f, #]] &, transh] // ReleaseHold) /. 
   f -> ( Complement[#1, #2] &);

{p, q, r} = Dimensions[player2];

sol1 = (* straight-forward easy to understand but inelegant coding *)
  Flatten[Table[
    {player1[[i]], player2[[i, j]], player3[[i, j]]}
    , {i, p}, {j, q}], 1];

sol2 = (* straight-forward easy to understand but inelegant coding *)
  Flatten[Table[
    {player1[[i]], player2[[i, j]], player3h[[i, j]]}
    , {i, p}, {j, q}], 1];

sol3 = Flatten[
   MapThread[Thread[{##}, List, -2] &, {player1, player2, player3}], 
   1]; (* beautiful, not easy to understand because of clever double threadings *)

sol4 = Map[Sort, Map[Partition[#, 2] &, Permutations[deck]], {2}] // 
  DeleteDuplicates; (* easy to code and understand *)

sol1 == sol2 == sol3 == sol4

Out[126]= True

You can keep the Thread function with additional arguments:

In[10]:= Thread[f[{1,2,3,4},{{0,9},{8,7},{6,5}}],List,-1]
Out[10]= {f[{1,2,3,4},{0,9}],f[{1,2,3,4},{8,7}],f[{1,2,3,4},{6,5}]}

It simply tells the function to hold the first list {1,2,3,4} and only thread through the last argument (in your case the second list {{0,9},{8,7},{6,5}}).This is documented under Thread -> Scope -> Sequence Specification

I am very glad to be part of your learning experience with Wolfram Language through our discussion about your analysis on the playing card problem. I highly recommend enthusiastic users like you to join our daily study group for further growth

• Review: https://blog.wolfram.com/2020/11/10/online-enrichment-with-free-daily-study-groups/
• Featured videos: https://www.gotostage.com/channel/11c1f0c486db4070a2da5715ee76bd2c
• Wolfram U: https://www.wolfram.com/wolfram-u/

*Some playing card related resources:

• WFR playing cards: https://resources.wolframcloud.com/FunctionRepository/resources/PlayingCardGraphic
• Numberphile: https://community.wolfram.com/groups/-/m/t/1718762
• Numberphile: https://community.wolfram.com/groups/-/m/t/1909911

Thank you very much, this solves the op perfectly. I didn't understand the Thread documentation there, neither made it clear to me that a {-2} would solve my problem. The documentation doesn't show {-1} nor nested lists, like my example (this llp001). Maybe it's an idea to add my example to the documentation? Good practical/instructive examples in the documentation are valuable.

What about this?

f[{1, 2, 3, 4}, #] & /@ {{0, 9}, {8, 7}, {6, 5}}

highschool text problem: " In how many ways can 10 numbered balls be distributed in four numbered compartments so that the first compartment contains 4, the second 3, the third 2 and the fourth 1 balls each (4+3+2+1=10)? The sequence of balls within the compartments be irrelevant."

Well, the answer is simple, 210×20×3×1=12600. A valid 4-tuple would be, for example:

( {1, 6, 9, 10}, {2, 3, 8}, {5, 7}, {4} )

Today i tried to build the list with 12600 such entries, and it involved a lot of MapThread, Thread, so i revisted this thread to check how we did things. I managed to produce the list but my coding feels awkward because i always worked with 2 lists at a time. The question is, is there a more elegant way of producing the output, maybe by feeding all four lists (sub4, sub3, sub2, rest2) at the same time in a single MapThread[Thread[]] statement?

del[from_List, this_List] := DeleteCases[from, Alternatives @@ this] ;
nUrne = Range[10] ;
sub4 = Subsets[nUrne, {4}] ; (*210 elements e.g. {1,2,3,4}*)
rest4 = del[nUrne, #] & /@ sub4 ; (* 210 elements e.g. {5,6,7,8,9,10}*)
sub3 = Subsets[#, {3}] & /@ rest4 ;
rest3 = MapThread[Function[{u, v}, del[u, #] & /@ v], {rest4, sub3}] ;
sub2 = MapAt[Subsets[#, {2}] &, rest3, {All, All}] ;
rest2 = MapThread[Function[{u, v}, del[u, #] & /@ v], {rest3, sub2}, 2] ;
sub2rest2 = MapThread[List, {sub2, rest2}, 3] ;
sub3sub2rest2 = MapThread[Thread[{##}, List, -1] &, {sub3, sub2rest2}, 2] ;
rest6 = MapAt[Sequence @@ # &, sub3sub2rest2, {All, All, All, 2}] ;
rest6neu = Flatten[#, 1] & /@ rest6 ;
almost = Flatten[MapThread[Thread[{##}, List, -1] &, {sub4, rest6neu}], 1] ;
finally = MapAt[Sequence @@ # &, almost, {All, 2}]

Heavily shorted output:

{{{1, 2, 3, 4}, {5, 6, 7}, {8, 9}, {10}}, {{1, 2, 3, 4}, {5, 6, 7}, {8, 10}, {9}},
 {{1, 2, 3, 4}, {5, 6, 7}, {9, 10}, {8}}, <···12593···> ,
 {{7, 8, 9, 10}, {3, 5, 6}, {2, 4}, {1}}, {{7, 8, 9, 10}, {4, 5, 6}, {1, 2}, {3}},
 {{7, 8, 9, 10}, {4, 5, 6}, {1, 3}, {2}}, {{7, 8, 9, 10}, {4, 5, 6}, {2, 3}, {1}}}

Thanks for your attention. In any case, this problem was a good beginner's exercise in juggling with Map, MapAt, Thread, MapThread and their combinations.