Allow child class to override parent constant

[e-e]

I propose gdscript should allow for a child class to override constants declared in the parent class. It seems like a very common use case for a child class to inherit all the same functionality of the parent, but with differing parameters to provide differing behaviors. As it is currently, a class becomes unextendable with the declaration of a constant whose value is not suitable for every single potential child. A trivial example:

# Turtle.tscn

extends Node

const SPEED = 1

func move():
    # some move code utilizing SPEED

func do_turtle_things():
    # ...

# FasterTurtle.tscn

extends "res://Turtle.tscn"

const SPEED = 100

Without this functionality, it seems one is forced to use a non-constant value instead, setting the child class' value in the _init() method, even if you never intend to change SPEED at runtime.

[isaacremnant]

Seems like export(int) var SPEED = 1 would be a better solution to your use case. Since it's exposed to the editor, you won't have to explicitly change the variable from the derived class.

[groud]

Well, if a constant can see its value modified by children it is not a constant anymore.
But in general, in object-oriented language, you cannot even override normal class attributes. Only functions can be overridden.

So IMHO, what you propose is quite a bad practice in general, as it creates several versions of a constant with differents values (which is the opposite of a constant) .

[ghost]

#23695

[akien-mga]

Indeed, as mentioned by @isaacremnant you should use export(int) var SPEED for this use case, it does exactly what you're asking for. If you want the constant to be overridable, you don't want it to be a constant :)

[CptTony303]

There is a need for this Usecase:
When you need static access you need a constant.
the Code below wont work right now (its also just for understanding and wrong syntax)

class Vehicle
const wheels = null

class Bus extends Vehicle
const wheels = 6

class Bike extends Vehicle
const wheels = 2

When we want to check how many wheels a bike has, we won't need to create a new Bike instance to check this.
It is constantly 2 and never changes.

Reopen issue please?
Or allow const for export :P

[Calinou]

@CptTony303 Feature proposals should now be discussed in the Godot proposals repository. But first, keep in mind:

Well, if a constant can see its value modified by children it is not a constant anymore.
But in general, in object-oriented language, you cannot even override normal class attributes. Only functions can be overridden.

[droqen]

There is a need for this Usecase:
When you need static access you need a constant.

In your specific use case, static access, there is no need for the Vehicle parent? Unless I misunderstand a particular way to access static variables, you'd never refer to Vehicles generically -- you'd always explicitly write 'Bike.wheels'.

So, you can safely just exclude 'const wheels = null' from class Vehicle.

[e-e]

@akien-mga

Indeed, as mentioned by @isaacremnant you should use export(int) var SPEED for this use case, it does exactly what you're asking for. If you want the constant to be overridable, you don't want it to be a constant :)

@Calinou

Well, if a constant can see its value modified by children it is not a constant anymore.

It should still be treated as a run-time constant, which is the important part. I agree with @CptTony303 and feel that their example very clearly outlines the usefulness of a feature such as this.

[frozenMustelid]

I just ran headfirst into this limitation. I'm trying to make a dictionary that holds all the monster scenes - This should make creating/editing random encounter tables much easier. A key has to be a constant, which means that my monster template scene can't define or even declare this necessary piece of data. It also means that I can't have upgraded monsters (common example: early game has regular spiders, late game has fiendish spiders) inherit from the original or base version of the monster, because then they'd share the same dictionary key.

I guess it's either back to the drawing board, or just bite the bullet and do it the annoying (read:less maintainable) way.

[Kiramin]

I second this feature.

Here is an explanation of why this doesn't violate good practices for constants:

Well, if a constant can see its value modified by children it is not a constant anymore.

That would indeed be a problem. But that isn't what happens; the parent class is not modified. Its const value remains unchanged. No values are changing during runtime for either class. Everything remains constant. Hence, no issues will be caused in multi-threading etc. This feature is just a major labor saving device. Consider this: You could manually type out two classes, a "Bike" class and a "Truck" class, and you could fill them with 90% of the same code, save a few differing const values. Everything remains constant, and the program runs fine. But, if this feature existed, then you could save yourself all that trouble, write one Vehicle class, and inherit from it twice, with a few const overrides and function overrides. This has an identical effect as writing two classes from scratch, but saves you a lot of work and ugly code duplication (which itself is a bad practice). Without this feature, you can still approximate this as is, by creating a function called "get_num_wheels()" and override it for Bike and Truck respectively. Of course, then a function has to be called every time to get the value, which is unnecessary overhead, because the value never changes. Hence, since it doesn't change, is shared between all instance of a class, and doesn't need to be calculated, it should be stored in a const, and not a var, nor a function.

Peace.

[Tramis]

i have the same problem. im using static function instead

class A:
    # const a = 1
    static func a():
        return 1

class B extends A:
    # const a = 2
    static func a():
        return 2

sorry for that im not familiar with dynamic typed language, in my view, a const value is bind to a specific type, just as same as static functions. and A is definitily a different type with B

so it looks weird for me. since static function can be overwrited but const can't. Did i consider something wrong with const ?