What are the use cases for Callable.bind().call(), and which parameter ordering makes more sense?

[nathanfranke]

Edit: Proposal #4920

---

Current behavior when directly calling a method, binds appear after call parameters:

func hello(a, b):
    pass

func _ready():
    # Could be confusing in this context, although this workflow is redundant.
    hello.bind("b").call("a")

I'd imagine that signals are 99% of the use case:

func added(node, param):
    pass

func _ready():
    # Current behavior is to append "param" after the signal arguments (node).
    child_entered_tree.connect(added.bind("param"))

I consider this a weird order though. Given this method:

func hello(a, b, c, d, e, f):
    pass

I would expect hello.bind("a", "b", "c") to return a callable that, to the engine, appears as func hello(d, e, f) because those first arguments were already supplied.

Here is a use case I have for having bind arguments first: #4868 (comment)

[dalexeev]

Yes, I also noticed that Callable.bind always binds the arguments to the end. I had something like:

extends Node

@onready var texture_rect := $TextureRect as TextureRect

func _ready() -> void:
    var gradient := texture_rect.texture.gradient as Gradient
    var tween := create_tween().set_parallel()

    var set_offset := func (offset, point): gradient.set_offset(point, offset)
    tween.tween_method(set_offset.bind(1), 0.0, 0.5, 0.8)
    tween.tween_method(set_offset.bind(2), 1.0, 0.5, 0.8)

Maybe add a Callable.bind_front method?

[mieldepoche]

I'd personally prefer explicit bind_left and bind_right methods (like there's String.rstrip and String.lstrip).