Range check operator I'd like to improve this operator code if I can. I don't know enough Raku
to write idiomatically (or any other way for that matter), but suggestions
along those lines would be good also.

use v6d;

sub circumfix:&lt;α ω&gt;( ( $a, $b, $c ) ) {
    if ( $a.WHAT ~~ (Int) ) {
        so ( $a &gt;= $b &amp; $a &lt;= $c );
    }
    else {
        my @b;
        for $a { @b.push( ( $_ &gt;= $b &amp; $_ &lt;= $c ).so ) };
        so (False) ∈ @b;
    }
};

if (α 5, 0, 10 ω) {
    "Pass".say;
}
else {
    "Fail".say;
}
if (α ( 5, 7, 11 ), 0, 10 ω) {
    "Pass".say;
}
else {
    "Fail".say;
}


This does a range check on a variable or variables, between/bookended by $b (lower) and $c (upper). I wonder about using
some sort of signature check paired with multi as a cleaner
approach?
There is quite a lot that you can do to make this idiomatic. I'll also go a bit overboard and show some ways to fully polish it (emphasis on way overboard for most projects).

You mention potentially wanting to do multi.  That's certainly possible here:

multi sub circumfix:&lt;α ω&gt;( ( $a where Positional, $b, $c ) ) { ... };
multi sub circumfix:&lt;α ω&gt;( ( $a where Int,        $b, $c ) ) { ... };


But ultimately it's unnecessary.  As the other answer points out, Raku has a junction types built in. They can be made by using the routines (or operators)  all (&amp;), any (|), one (^) and none — the routines are available as both subs and methods.  In your case, we can take advantage of the fact that junctions can be made on a single item or a list, so that regardless whether $a is a list of Int or just a single Int, we can make it into a junction.  That right there can reduce your code to:

sub circumfix:&lt;α ω&gt;( ( $a, $b, $c ) ) {
   so ( $a.any &gt;= $b &amp; $a.any &lt;= $c );
};


Although we're going to remove it entirely, it should be noted that &amp; is a junction. This is slightly less efficient than using &amp;&amp; which just checks whether both sides are true and evaluates to a Bool.  But we won't need to do that at all.  Raku allows for chained operators, and the comparison operators are defined as such.  This means that we can simplify things even further to:

sub circumfix:&lt;α ω&gt;( ( $a, $b, $c ) ) {
   so $b ≤ $a.any ≤ $c;
};


so has very loose operator precedence, so we don't need parentheses here.  The final two considerations are purely stylistic, but help for code maintaince.  The names $a, $b, and $c aren't descriptive.  You'd definitely want to use something better.  Also, it's fairly common, though not universal, to give extra emphasis to the fact that we're not mutating the values by using sigil-less variables.  Personally, I also like to use whitespace to indicate the tighter grouping when using deconstruction, but YMMV.  Lastly, semicolons aren't needed when they're the final expression of a block, or when a block terminates the line, so we can remove the semicolons.

sub circumfix:&lt;α ω&gt;( (\val,\min,\max) ) {
   so min ≤ val.any ≤ max
}


In this case, using min/max/val without sigils maybe is a bit riskier as they are also routines, but it seems to workout okay.

If we want to go above and beyond for safety's sake, we can check the values in the signature.  I'm assuming based on your original that you wanted to limit things to Int values so let's make it explicit, and specify our return value:

sub circumfix:&lt;α ω&gt;( (\val where .all ~~ Int, \min where Int, \max where Int) --&gt; Bool) {
   so min ≤ val.any ≤ max
}


At this point, the signature is getting a bit unruly, and so I like to spread it across multiple lines.  Particularly if you have several deconstructed arguments, this lets identation also show structure a bit more clearly (but in this case, it's less necessary of course):

sub circumfix:&lt;α ω&gt; ( 
    (
       \val where .all ~~ Int, 
       \min where         Int, 
       \max where         Int
    )
    --&gt; Bool
) {
   so min ≤ val.any ≤ max
}


And don't forget that Raku's POD syntax means we can also add in documentation that could help users or automatically create documentation:

#| Determine if a value or values are between the given values (inclusive)
sub circumfix:&lt;α ω&gt; ( 
    (
       \val where .all ~~ Int, #= The Int value or values to be tested
       \min where         Int, #= The lowest acceptable value
       \max where         Int  #= The highest acceptable value
    )
    --&gt; Bool
) {
   so min ≤ val.any ≤ max
}


IDEs like Comma are already able to pull some of this information to make coding easier.  Using it on signatures is really only supported for generating help feedback automatically on command line usage, but it's only a matter of time before such things will be integrated into IDEs.