GDScript Lambdas and Callable: func(), call() and bind()

A lambda is a function without a name, written where you need it. It is a value of type Callable:

extends Node

func _ready():
	var double := func(x): return x * 2
	print(double.call(21))

	var describe := func(enemy: String, hp: int) -> String:
		var state := "hurt" if hp < 10 else "healthy"
		return "%s is %s" % [enemy, state]
	print(describe.call("slime", 4))

42
slime is hurt

Call a stored lambda with .call(), not with plain parentheses. A short lambda fits on one line after the :; a longer one is indented like any function body.

Passing Functions to Other Functions

Array methods, sorting and signals all take a Callable. A lambda keeps the logic where it is used:

extends Node

func _ready():
	var enemies = [
		{"name": "bat", "hp": 3},
		{"name": "golem", "hp": 40},
		{"name": "slime", "hp": 8},
	]
	var strong = enemies.filter(func(e): return e.hp > 5)
	var names = strong.map(func(e): return e.name)
	print(names)
	enemies.sort_custom(func(a, b): return a.hp < b.hp)
	print(enemies.map(func(e): return e.name))

["golem", "slime"]
["bat", "slime", "golem"]

Methods as Callables

A method name without parentheses is also a Callable. So is Callable(object, "method_name"):

extends Node

func greet(player: String, greeting: String = "Hello") -> String:
	return "%s, %s!" % [greeting, player]

func _ready():
	var f := greet
	print(f.call("Ana"))
	print(f.get_method(), " ", f.is_valid())
	var by_name := Callable(self, "greet")
	print(by_name.call("Bo", "Hi"))
	print(greet.callv(["Cy", "Hey"]))  # arguments from an array

Hello, Ana!
greet true
Hi, Bo!
Hey, Cy!

Prefer the direct form (greet): the editor checks that the method exists. Callable(self, "greet") uses a string, so a typo only fails when it runs.

bind(): Adding Arguments Ahead of Time

bind() returns a new Callable that remembers extra arguments. They are added after the ones passed to call():

extends Node

func buy(player: String, item: String, price: int) -> void:
	print(player, " bought ", item, " for ", price)

func _ready():
	var buy_potion := buy.bind("potion", 5)
	buy_potion.call("Ana")
	buy_potion.call("Bo")

Ana bought potion for 5
Bo bought potion for 5

This is the usual way to tell which button sent a signal:

func _ready():
	for button in $Menu.get_children():
		button.pressed.connect(_on_menu_pressed.bind(button.name))

func _on_menu_pressed(button_name: StringName) -> void:
	print("Pressed ", button_name)

How Lambdas Capture Variables

A lambda can read the local variables around it. It copies their values when the lambda is created:

extends Node

func _ready():
	var bonus := 10
	var add_bonus := func(v): return v + bonus
	bonus = 100                   # the lambda keeps its own copy: 10
	print(add_bonus.call(1))

	var count := 0
	var increase := func(): count += 1
	increase.call()
	print(count)                  # still 0: only the copy changed

	var history := []
	var record := func(v): history.append(v)
	record.call("hit")
	print(history)                # arrays are shared, so this works

11
0
["hit"]

To have a lambda change state, use a member variable of the script, or an array or dictionary, which are shared rather than copied.

Lambdas as Signal Handlers

A lambda can be connected straight to a signal, which saves a separate method for a one-line reaction:

extends Node

signal scored(points: int)

func _ready():
	var total := [0]
	scored.connect(func(points): total[0] += points)
	scored.connect(func(points): print("+", points))
	scored.emit(10)
	scored.emit(5)
	print("Total: ", total[0])

+10
+5
Total: 15

Use a named method instead when you will need to disconnect() the handler later: you can only disconnect a Callable you still hold.

call_deferred()

call_deferred() runs the Callable at the end of the current frame instead of now. Godot asks for it when you change the scene tree during physics callbacks:

extends Node

func _ready():
	var later := func(): print("at the end of the frame")
	later.call_deferred()
	print("now")

now
at the end of the frame

In a game, add_child.call_deferred(bullet) inside a collision callback is the common case.