Allow "invalid" as a type

[luis-j-soares]

It would be extremely useful to allow invalid as a type, for cases like the one below:

interface ISomething
    id as String
    name as String
    value as Integer
end interface

'...

myMapOfThings = {} ' as Dictionary<string, ISomething>

function getSomething(id as String) as ISomething or invalid
    ' The "id" might not exist in the map, leading to this function returning `invalid`.
    '   If I can't specify that `invalid` can be returned, then the user might assume that
    '   it always returns something, and then have the Roku crash when attempting to use it.
    return m.myMapOfThings[id]
end function

item = getSomething("nonExistingId")
print item ' prints "invalid"
print item.name ' CRASH!

function ensureSomething(id as String) as ISomething
    ' This function always returns something, so there's no need to specify "or invalid" in
    '   the return type. And the user knows they don't need to check for invalid values
    '   either.
    item = m.myMapOfThings[id]
    if item = invalid
        item as Something = {
            id: id
            name: ""
            value: -1
        }
        m.myMapOfThings[id] = item
    end if
    return item
end function

item = ensureSomething("nonExistingId")
print item ' prints "<roAssociativeArray>"
print item.name ' prints ""

[addison-adler]

+1, just adding my own notes about the use-cases

it's common (at least for me) to:

• write a function that accepts an optional parameter that is a node or function type
• or, for util functions that attempt some operation, but return invalid if they cannot complete the operation
  • e.g. if getCallback(key) (returns a function) receives something that it can't operate on, it returns invalid
• while I can guarantee that as string receives "", or as integer receives -1, or as boolean receives false,
• there is no default/fallback value that I can provide for node or function
  • (arguably I guess I could return an empty function or an empty Node but that seems.. like disingenuous and bad code, as it would be completely useless and misleading)

however, if I return invalid, then for the type checking, I have to write (using function as an example) someFunc() as function or dynamic

• dynamic is anything though.. so now the type checking isn't really able to do anything useful or helpful here
• if I don't do this, I get errors like "<thing> is not callable"
• the same applies to something like myFunc(param1, param2 = invalid) where the code expects param2 to (optionally) be a node or function
• if it was something like an array, I'd just do param2 = [].. but there's no reasonable default for nodes or functions