Simple constants as types

[lenscas]

When working with where it (to me) makes sense to restrict the field used as a tag to only a single value. This way, typos and similar can't sneak up on you when creating values of these types.

Right now, an enum has to be used, creating something like

enum SingleTypeTag
    "SingleType"
end

record  SingleType
    where self.tealType == "SingleType"
    
    tealType: SingleTypeTag
    
    name:Name
    kind:KindOfType
    generics:{ Type }
end

It would be a lot nicer if simple string constants could be used as types directly. Then, the above could be reduced to

record  SingleType
    where self.tealType == "SingleType"
    
    tealType: "SingleType"
    
    name:Name
    kind:KindOfType
    generics:{ Type }
end

Aside from reducing the amount of code needed to write, it also is easier to read to me as the important bits now stay together. Instead of me having to "hunt down" the enum to see what the tag exactly is.

Lua language server is already capable of doing this, you also see it in Typescript. So it isn't an unknown feature. For reference, with lua language server the type is described as:

---@class SingleType
---@field tealType "SingleType"
---@field name Name
---@field kind KindOfType
---@field generics (Type)[]
local SingleType = {}

It (for me) also makes the generation of type definition files easier. As Tealr would be able to just spit out the string in all 3 cases, rather than having to generate an enum specifically for teal. (The 3 cases are the html site, teal and lua language server)

[hishamhm]

So it isn't an unknown feature.

Yes, these are usually called literal types. It's a feature I've been considered adding for a while! (I don't know when I'll be able to get to this, because the nil-safety work is higher priority and I haven't been able to put a lot of time on Teal lately.)

[lenscas]

Ah, yes, nil safety is probably more important. For the time being I made tealr look if the type starts and ends with a quote and if so it emits an enum type.
So, teal sees

record  SingleType
    where self.tealType == "SingleType"

    enum SingleTypeTag
        "SingleType"
    end
    --The tag of the type, allows you to see what type the value is at runtime.
    tealType:SingleTypeTag

    --The name of the type
    name:Name

    --The kind of type that is being represented
    kind:KindOfType

    --If a type has generics then they are stored here
    generics:{ Type }
end

While lua language server gets

---@class SingleType
---@field tealType "SingleType" The tag of the type, allows you to see what type the value is at runtime.
---@field name Name The name of the type
---@field kind KindOfType The kind of type that is being represented
---@field generics (Type)[] If a type has generics then they are stored here
local SingleType = {}

The generated html also follows the lua language server way. Making teal the odd one out. Oh well, last time when making it possible to emit generic records it was lls that was the one that required a workaround. Guess it is only fair for the roles to be reversed this time 😅

[mbartlett21]

@lenscas
I did have a POC branch on my fork based on tl 0.24.6 .
https://github.com/mbartlett21/tl/tree/poc/constant-fields

It adds = as an option (and also sets up the where clause etc):

local record Simpler
   ty = "Simple"
end

is the same as

local record Simpler
   where self.ty == "Simple"
   ty: UnreferencedEnum
   enum UnreferencedEnum "Simple" end
end

apart from that the enum really can't be referenced.

[lenscas]

@mbartlett21

Thanks. But Tealr is a library and program to help improve Rust <-> lua/teal ffi by using the types in rust to create proper .d.tl files (as well as html containing the documentation of the api and lua language server addons with the type definitions).

So, can't exactly use your fork or tealr wouldn't target teal anymore. It also still would be a special case that Tealr needs to handle in your fork so it doesn't improve things for me that much. (I can see it improving things when writing code manually though)