Perhaps you have not understood the post you responded to.

Oh, nonono. I understood what you wrote just fine but that doesn't mean it makes any sense.

You don't want to take our advice and rethink the design of your code, don't want to become a more well-rounded developer because it's 'beyond' you, you don't seem to want help in any way. I understand that. Anyway, this is what 50 named parameters in your Raku rewrite looks like:

sub whatever (
        :$all,    :$state,  :$would, :$in,      :$and,     :$passed,  
+       :$as,        :$because, :$is,
        :$but,    :$refuse, :$own,   :$to,      :$I,       :$why,     
+       :$want,      :$keep,    :$bad,
        :$choice, :$take,   :$with,  :$into,    :$rewrite, :$thirtytho
+usand, :$of,        :$Iam,     :$out,
        :$ideas,  :$data,   :$store, :$here,    :$fifty,   :$variables
+,      :$like,      :$than,    :$could,
        :$really, :$in,     :$that,  :$mangles, :$poorly,  :$how,     
+       :$debugging, :$code,    :$in,
        :$or,     :$there,  :$test,  :$whew,    :$hit,     :$variables
    ) {
    }

whatever(
    that           => 'just',
    poorly         => 'and',
    test           => 'suite',
    out            => 'of',
    rewrite        => 'of',
    mangles        => 'text',
    in             => 'code',
    is             => 'silly',
    bad            => 'design',
    code           => 'work',
    fifty          => 'state',
    with           => 'you',
    in             => 'reality',
    I              => 'wonder',
    data           => 'to',
    here           => 'because',
    debugging      => 'that',
    take           => 'it',
    to             => 'that',
    Iam            => 'running',
    could          => 'ever',
    passed         => 'around',
    hit            => 'fifty',
    state          => 'data',
    really         => 'need',
    because        => 'that',
    into           => 'a',
    keep           => 'the',
    would          => 'go',
    ideas          => 'for',
    or             => 'is',
    than           => 'you',
    variables      => 'now'
    like           => 'more',
    choice         => 'and',
    in             => 'here',
    all            => 'your',
    as             => 'arguments',
    thirtythousand => 'lines',
    want           => 'to',
    of             => 'code',
    and            => 'not',
    store          => 'in',
    own            => 'up',
    why            => 'you',
    whew           => 'almost',
    variables      => 'seems',
    but            => 'you',
    there          => 'no',
    refuse         => 'to',
    how            => 'would'
);
[download]

There are duplicate keys in there but it's over 60 lines of code and includes no logic. This is not easier to understand or debug than whatever you have right now (or hash refs in Perl), smells to high heaven because it's 50 freaking parameters, and despite all that, this is what you keep telling us you want. In Perl or Raku, this is bad code and difficult to understand. No amount of self-documenting will fix that.

Incidentally, are Raku questions welcome here on the Perl forum? or is Raku seen as an enemy competitor? Judging by the votes on my Raku-promoting remarks, I've sensed some hostility towards it (or me for suggesting it), so I'm unsure.

Yeah, it's not Raku that's being voted down. Many of us have at least written demonstration code in Raku. I've written medium sized projects in it and am in the middle of backporting a core feature of Raku to Perl 5 (waiting on the Oshun conversation). It'll be hard to find someone here that disagrees with the statement that Raku is an excellent tool.

What you might be seeing is reactions to the way you present things you discover in Raku as unique to that language and silver bullets to magically make your poorly designed code easier to understand when we all know and have shown you over and over that features you're talking about already exist in modern Perl and you're refusing to use them. People are actively trying to help you grow as a developer and you refuse because you don't want better code that's easy to understand, you want your same bad code but make it self-documenting. It's not the order of arguments, it's the number of them. That's your design problem this time around.

I can't tell you why anyone else voted you down but this would be the chat log summary of everything you've posted on Perlmonks over the last several months:

 Polyglot:  Ugh! Perl is so broken and hard to understand!
 Perlmonk1: You could try X, Y, or Z.
 Polyglot:  I don't understand X, Y, or Z so I'll just do the same thing I'm doing now... but in Raku!
 Perlmonk1: No need to do that but okay. Here's an example of X in Perl anyway.
 Perlmonk2: And here's an example if you try Z.
 Perlmonk3: I've used Y and Z before and prefer Z. We'll take a look at what you wrote if you like.
 Polyglot:  Disgusting. And you don't understand me.

Outside of politics, I've never seen someone so skilled at complaining about the results of their choices while deflecting blame for the choice they made and defending the choice itself all at the same time. I don't know if that's why others vote you down but it really does seem like the perfect troll. It's flamebait for sure.

I downvote to make sure anyone who reads what you're writing knows it's incorrect thinking and not a problem with the syntax or design of the language. Baby Perl is one thing but you're designing write only code and that can do real harm to someone just starting out. You chose to have dozens of global variables. You chose to use syntax out of step with best practices and common sense. You chose to do things like hand off so many parameters that documenting their order or meaning properly is difficult to keep track of. You've made these decisions on your own. Perl didn't force bad decisions upon you. Examples you've seen online likely didn't lead you down that path. And several of us here have tried to get to the root of your design issues but your responses make it seem like the crappy design you've settled on is Perl's fault and using a different language is the only fix to the mess you've created.

The saddest part is that you are taking your same bad ideas into your Raku rewrite... Writing 30,000 lines of bad code twice makes me feel like we need to organize an intervention or something.