Overview

The problem with the redispatch in Raku 6 is that each keyword (except wrap) combines three separate concepts into one. Those concepts are:

• Returns: Whether execution continues after the keyword
• Arguments: Whether the arguments from the currently executing routine will be reused
• Referee: What routine will it call?

If we take these three concepts, and represent each of them separately, rather than bundling them into a single word, then we can combine them in ways that aren't possible in Raku 6, and can use them separately where useful.

We deal with these concepts as follows:

• Returns: We can either use the return-rw keyword, or leave it out; no change necessary.
• Arguments: We add a “reuse” modifier to function calls that means that the arguments of the caller are all passed to the callee. This does away with the distinction between “callsame” and “callwith”. I've assumed we'd use a :reuse adverb, butI suspect there's a better idea of which I haven't thought.
• Referee: We need only one item: callee. This is an array (or at least, it does Positional) that lists all the callable items in the stack. callee[0] is the one we'll use to replace
• nextcallee (no change)
• selfcallee (so we can replace samewith)

The wrap method doesn't change.

On the down side, this ends up being a bit more wordy, but on the up side, a good bit more flexible:

Method Call Modifiers

We need to be able to specify some keywords that alter how a method is called. I'm going to suggest the syntax ::<keyword>. Examples could include:

• ::reuse --

Comparison of Raku 6 and Raku 7

The following table will compare some Raku 6 code with Raku 7: