Generic return value question"

DrScott

In the generic Stack class that I've written, the Pop() method returns an element from the stack of type T. However, when I try to assign that returned value to a variable (Var poppedValue As [the type that T is defined as] = stack.Pop()), I gt an error:
Cannot assign 'Object' to variable of type [the type that T is defined as] "

Shouldn't the type returned by Pop() be what we defined as the type of T instead of Object? If not, is there a way to typecast it?

bgrommes

DrScott For a returned value named, say, MyClass, try:

Var poppedValue As MyClass = MyClass(stack.Pop())
# or maybe this will be adequate:
Var poppedValue = MyClass(stack.Pop())

As I understand it, ClassName(varName) is how you cast in Objo, rather than e.g. c-family languages typically (ClassName)varName.

rgb

DrScott

Warn call Pop() in a empty stack throw!
Put code inside Try End Try or check before use


if stack.Count > 0 then
Var poppedValue As MyClass = MyClass(stack.Pop())
end if
```

DrScott

Thank you, bgrommes and rgb. I couldn’t find anything about typecasting in the Objo documentation. And I’ll add a check for an empty stack before calling Pop(). I should have noticed that myself.

Garry

Thanks everyone.

@DrScott is correct: if a variable is declared as Stack(Of MyClass), then Pop() should be statically typed as returning MyClass, not Object.

This exposed a compiler bug. Objo understood the generic declaration, but it was losing the concrete type argument when resolving members of user-defined generic classes. Consequently, a return type such as T fell back to Object.

I’ve fixed this for the next release: https://feedback.objo.dev/bug/935

This will now compile without a cast:

Var stack As New Stack(Of MyClass)
Var poppedValue As MyClass = stack.Pop()

The fix wasn’t limited to return values. Concrete generic types are now preserved through constructor parameters, method parameters and return values, properties, inheritance, interfaces, constraints, and iteration. For example, Stack(Of Integer).Push("hello") is now correctly rejected by the compiler.

Objo’s generic classes remain type-erased internally at runtime, but I’ve also added runtime boundary checks so that an incompatible value inserted through an unparameterized generic reference cannot later escape as the wrong concrete type.

In the current release, MyClass(stack.Pop()) is a valid workaround. The second form suggested above, Var poppedValue = ..., is not currently valid because Objo requires an explicit type annotation on local variables.