Missing explicit voice command to write private function

Currently the only way to call code_private_function is indirectly via code_default_function (except for R).

This poses a few problems:

• Python and Scala override code_default_function to call code_public_function. This currently makes it impossible to use their code_private_function implementations without adding a custom voice command.
• The Java implementation of code_protected_function creates a method without any modifiers, which is confusing.
  • It should insert the protected access modifier, but then there would be no way to insert a method with no access modifiers (i.e. a package-private method, distinct from protected).
  • As a workaround, one can say state protected, pause, then pro funky ..., but this is clearly inconsistent and disrupts the flow.

I would like to propose the following:

• a new private funky <text> command, which calls code_private_function
• a new action code_default_static_function, to be called by static funky <text>, can default to calling code_private_static_function
• a new private static funky <text> command, to replace current usage of static funky <text>

This would allow for:

• Java: creating methods with all possible access modifiers (including package-private and protected) using the commands in functions.talon
• TypeScript: creating functions outside methods, whilst still being able to create private methods (see also #824)
• Python/Scala: actually creating private functions

[splondike]

This should be covered off by #879 . Closing issue.

[pokey]

What might be nice is the following:

{user.function_modifier}+ funky <user.text>: user.code_function(function_modifier_list, text)

Then there could be a default implementation

    def code_function(modifier_list: list[str], text: str):
        """Inserts function declaration"""
        formatted_text = actions.user.formatted_text(
            text, settings.get("user.code_function_formatter")
        )
        modifier_string = " ".join(modifier_list)
    
        result = f"{modifier_string} function {formatted_text}"

        actions.user.code_insert_function(result, None)

Individual languages could then override the implementation to look at modifier_list and choose a different formatter / use different template for the function

Definitely a different approach, but figured I’d throw it out there.

It is related to #807