Add typeofname() to get a name of a type rather than its enumerated value

[Feniks-Gaming]

Describe the project you are working on:

Any project will do currently tic tac toe game.

Describe the problem or limitation you are having in your project:

if you want to find out what type variable you have you can use typeof() method but it returns enum number.

var my_bool: bool = true
print(typeof(my_bool) # prints 1

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

I would like to be able to do this instead

var my_bool: bool = true
print(typeofname(my_bool) # prints "bool"

Describe how your proposal will work, with code, pseudocode, mockups, and/or diagrams:

No idea how it would work with code in c++

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

Used fairly often and likely there is a work around but in my opinion 99% when user uses typeof() they want to know a name of type not it enumerated value

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

Adds function to core functionality.

[Calinou]

Related to #837.

[Error7Studios]

Also, adding a constant for each type name will allow us to use them in match statements.

const TYPENAME_NIL := "Null"
const TYPENAME_BOOL := "bool"
const TYPENAME_INT := "int"
const TYPENAME_REAL := "float"
const TYPENAME_STRING := "String"
const TYPENAME_VECTOR2 := "Vector2"
const TYPENAME_RECT2 := "Rect2"
const TYPENAME_VECTOR3 := "Vector3"
const TYPENAME_TRANSFORM2D := "Transform2D"
const TYPENAME_PLANE := "Plane"
const TYPENAME_QUAT := "Quat"
const TYPENAME_AABB := "AABB"
const TYPENAME_BASIS := "Basis"
const TYPENAME_TRANSFORM := "Transform"
const TYPENAME_COLOR := "Color"
const TYPENAME_NODE_PATH := "NodePath"
const TYPENAME_RID := "RID"
const TYPENAME_OBJECT := "Object"
const TYPENAME_DICTIONARY := "Dictionary"
const TYPENAME_ARRAY := "Array"
const TYPENAME_RAW_ARRAY := "PoolByteArray"
const TYPENAME_INT_ARRAY := "PoolIntArray"
const TYPENAME_REAL_ARRAY := "PoolRealArray"
const TYPENAME_STRING_ARRAY := "PoolStringArray"
const TYPENAME_VECTOR2_ARRAY := "PoolVector2Array"
const TYPENAME_VECTOR3_ARRAY := "PoolVector3Array"
const TYPENAME_COLOR_ARRAY := "PoolColorArray"
const TYPENAME_MAX := "Max"


const _TYPENAME := {
	TYPE_NIL: TYPENAME_NIL,
	TYPE_BOOL: TYPENAME_BOOL,
	TYPE_INT: TYPENAME_INT,
	TYPE_REAL: TYPENAME_REAL,
	TYPE_STRING: TYPENAME_STRING,
	TYPE_VECTOR2: TYPENAME_VECTOR2,
	TYPE_RECT2: TYPENAME_RECT2,
	TYPE_VECTOR3: TYPENAME_VECTOR3,
	TYPE_TRANSFORM2D: TYPENAME_TRANSFORM2D,
	TYPE_PLANE: TYPENAME_PLANE,
	TYPE_QUAT: TYPENAME_QUAT,
	TYPE_AABB: TYPENAME_AABB,
	TYPE_BASIS: TYPENAME_BASIS,
	TYPE_TRANSFORM: TYPENAME_TRANSFORM,
	TYPE_COLOR: TYPENAME_COLOR,
	TYPE_NODE_PATH: TYPENAME_NODE_PATH,
	TYPE_RID: TYPENAME_RID,
	TYPE_OBJECT: TYPENAME_OBJECT,
	TYPE_DICTIONARY: TYPENAME_DICTIONARY,
	TYPE_ARRAY: TYPENAME_ARRAY,
	TYPE_RAW_ARRAY: TYPENAME_RAW_ARRAY,
	TYPE_INT_ARRAY: TYPENAME_INT_ARRAY,
	TYPE_REAL_ARRAY: TYPENAME_REAL_ARRAY,
	TYPE_STRING_ARRAY: TYPENAME_STRING_ARRAY,
	TYPE_VECTOR2_ARRAY: TYPENAME_VECTOR2_ARRAY,
	TYPE_VECTOR3_ARRAY: TYPENAME_VECTOR3_ARRAY,
	TYPE_COLOR_ARRAY: TYPENAME_COLOR_ARRAY,
	TYPE_MAX: TYPENAME_MAX,
}


func typename(__var) -> String:
	return _TYPENAME[typeof(__var)]


func print_var(__var) -> void:
	var type_name: String = typename(__var)
	print("\n", type_name, ":")

	match type_name:
		TYPENAME_ARRAY:
			print("[")
			for element in __var:
				print("\t", element, ",")
			print("]")
		TYPENAME_DICTIONARY:
			print("{")
			for i in __var.size():
				print("\t", __var.keys()[i], ": ", __var.values()[i], ",")
			print("}")
		_:
			print(__var)
	pass


func _ready():
	var dict := {"A": 1, "B": 2, "C": 3}
	var array := ["one", "two", "three"]
	print_var(dict)
	print_var(array)
	print_var(Color.black)
	print_var(Quat(Vector3.ZERO))

prints:

Dictionary:
{
	A: 1,
	B: 2,
	C: 3,
}

Array:
[
	one,
	two,
	three,
]

Color:
0,0,0,1

Quat:
(0, 0, 0, 1)