Statically typed Callable

[sockeye-d]

Describe the project you are working on

Any project that uses lambda functions heavily

Describe the problem or limitation you are having in your project

Callables have no defined type of parameter list

Describe the feature / enhancement and how it helps to overcome the problem or limitation

Add a type field to Callable, similar to Array and Dictionary

Describe how your proposal will work, with code, pseudo-code, mock-ups, and/or diagrams

When defining a Callable, you can add as many type parameters as you want. These would all be valid:

# returns int
Callable[int]
# returns String, takes a float and an untyped parameter
Callable[String, float, Variant]
# returns void, takes String
Callable[void, String]
# or maybe this should be
Callable[null, String]

Lambda functions will not need type hints if types are declared in the variable or parameter, making them more concise but still type safe:

func my_method(callable: Callable[String, Node]) -> void:
    pass

# there would be code completion here, and it would give an error if it didn't return anything
my_method(func(node): return node.name)

Since actual class and method generics aren't supported (the way it's implemented in other languages), things like Array methods (map, reduce, filter) still won't work correctly.

Callable would also have methods for getting the types, like Array does:

c.get_typed_builtin(index)
c.get_typed_class_name(index)
c.get_typed_script(index)

If this enhancement will not be used often, can it be worked around with a few lines of script?

It requires casting, which I think is undesirable

Is there a reason why this should be core and not an add-on in the asset library?

GDScript is core

[Mickeon]

This is related to

• Add support for typed WeakRefs to GDScript #9174
• Add generic parameters to allow strongly typing for collections #1207
• Add extendable collections to GDScript #8029

The team on GDScript occasionally talks about this kind of thing, but it can't come any time soon due to severe changes being required to the typing system and the GDScript parser, first.

[dalexeev]

I think we should think about the unified type system as a whole, not just Callable.

See also:

• PackedScene generics
  • Allow us to strongly type packed scenes #782
  • Allow type specification of root node for exported PackedScenes #5255
  • Add a generic parameter to PackedScene (like Array) to allow for easier type safety #6694
  • Allow preloaded PackedScenes as static type hints #8565
• Other concrete generics
  • Add support for typed WeakRefs to GDScript #9174
  • Static typing for Array methods that return a Variant #10804
• General generics
  • Add generic parameters to allow strongly typing for collections #1207
  • Add extendable collections to GDScript #8029
• Unified type system
  • Complete, consolidate, and optimize user-defined types (Script classes/Custom types) #22
  • Add an abstract type system for GDScript to gain access to compile-time code execution #1709
  • Consolidate type and inheritance checks with a TypeServer. #2804
  • Add improved abstractions for collecting, caching, and handling type information. #5444
  • Add `GDScriptType` wrapper instead of `GDScriptNativeClass` #6502
  • Add first-class Type support to GDScript #10115
• Other related
  • Add support for nullable static types in GDScript #162
  • Add union types to Typed GDScript #737
  • Add method hints for non-nullable return types and nullable arguments #2241
  • Add typed tuples to GDScript #2944
  • Static Scenes #7572
  • Add the ability to export sub classes #9343
  • Add nested typed collections #10022
  • Add functions similar to type_convert for every individual type that a Variant can be converted to. #10320
  • Display meaningful Callable previews in inspector #10763

[sockeye-d]

Yes, I agree the implementation of "generics" as we have them seem to be a hack. I hope that the generics get a more unified system that makes it trivial to create generic classes, methods, and variables though, it would make life a lot simpler in these kinds of scenarios.