Skip to main content

SimpleEnum

A very simple enum implementation that makes typechecking boilerplate simpler.

local require = require(script.Parent.loader).load(script)

local SimpleEnum = require("SimpleEnum")

export type MyEnumType = "none" | "always"

return SimpleEnum.new({
	NONE = "none" :: "none",
	ALWAYS = "always" :: "always",
})

Functions​

new​

</>
SimpleEnum.new(members: EnumMembers) → SimpleEnum<EnumMembers>

Creates a new SimpleEnum. This is indexable like a normal table, BUT it is also type-checkable via IsValue and GetInterface and more.

GetKeys​

</>
SimpleEnum.GetKeys(self: SimpleEnum<EnumMembers>) → {string}

Returns the list of enum keys.

GetValues​

</>
SimpleEnum.GetValues(self: SimpleEnum<EnumMembers>) → {EnumValue}

Returns the list of enum values.

GetMap​

</>
SimpleEnum.GetMap(self: SimpleEnum<EnumMembers>) → EnumMembers

Returns the map of enum members.

IsValue​

</>
SimpleEnum.IsValue(
self: PrivateSimpleEnum<EnumMembers>,
value: any
) → (
boolean,
string?
)

Returns whether the value is a valid enum value.

local MyEnum = SimpleEnum.new({
	FOO = "foo",
	BAR = "bar",
})

print(MyEnum:IsValue("foo")) --> true
print(MyEnum:IsValue("baz")) --> false, "Expected one of: foo, bar; got baz"

GetInterface​

</>
SimpleEnum.GetInterface(self: PrivateSimpleEnum<EnumMembers>) → (value: any) → (
boolean,
string?
)

Returns a type-checking function for the enum.

local MyEnum = SimpleEnum.new({
	FOO = "foo",
	BAR = "bar",
})

local typeChecker = MyEnum:GetInterface()

print(typeChecker("foo")) --> true
print(typeChecker("baz")) --> false, "Expected one of: foo, bar; got baz"
Show raw api
{
    "functions": [
        {
            "name": "new",
            "desc": "Creates a new SimpleEnum. This is indexable like a normal table, BUT it is also\ntype-checkable via `IsValue` and `GetInterface` and more.",
            "params": [
                {
                    "name": "members",
                    "desc": "",
                    "lua_type": "EnumMembers"
                }
            ],
            "returns": [
                {
                    "desc": "",
                    "lua_type": "SimpleEnum<EnumMembers>\n"
                }
            ],
            "function_type": "static",
            "source": {
                "line": 51,
                "path": "src/enums/src/Shared/SimpleEnum.lua"
            }
        },
        {
            "name": "GetKeys",
            "desc": "Returns the list of enum keys.",
            "params": [
                {
                    "name": "self",
                    "desc": "",
                    "lua_type": "SimpleEnum<EnumMembers>"
                }
            ],
            "returns": [
                {
                    "desc": "",
                    "lua_type": "{ string }\n"
                }
            ],
            "function_type": "static",
            "source": {
                "line": 68,
                "path": "src/enums/src/Shared/SimpleEnum.lua"
            }
        },
        {
            "name": "GetValues",
            "desc": "Returns the list of enum values.",
            "params": [
                {
                    "name": "self",
                    "desc": "",
                    "lua_type": "SimpleEnum<EnumMembers>"
                }
            ],
            "returns": [
                {
                    "desc": "",
                    "lua_type": "{ EnumValue }\n"
                }
            ],
            "function_type": "static",
            "source": {
                "line": 80,
                "path": "src/enums/src/Shared/SimpleEnum.lua"
            }
        },
        {
            "name": "GetMap",
            "desc": "Returns the map of enum members.",
            "params": [
                {
                    "name": "self",
                    "desc": "",
                    "lua_type": "SimpleEnum<EnumMembers>"
                }
            ],
            "returns": [
                {
                    "desc": "",
                    "lua_type": "EnumMembers\n"
                }
            ],
            "function_type": "static",
            "source": {
                "line": 92,
                "path": "src/enums/src/Shared/SimpleEnum.lua"
            }
        },
        {
            "name": "IsValue",
            "desc": "Returns whether the value is a valid enum value.\n\n```lua\nlocal MyEnum = SimpleEnum.new({\n\tFOO = \"foo\",\n\tBAR = \"bar\",\n})\n\nprint(MyEnum:IsValue(\"foo\")) --> true\nprint(MyEnum:IsValue(\"baz\")) --> false, \"Expected one of: foo, bar; got baz\"\n```",
            "params": [
                {
                    "name": "self",
                    "desc": "",
                    "lua_type": "PrivateSimpleEnum<EnumMembers>"
                },
                {
                    "name": "value",
                    "desc": "",
                    "lua_type": "any"
                }
            ],
            "returns": [
                {
                    "desc": "",
                    "lua_type": "boolean"
                },
                {
                    "desc": "",
                    "lua_type": "string?"
                }
            ],
            "function_type": "static",
            "source": {
                "line": 109,
                "path": "src/enums/src/Shared/SimpleEnum.lua"
            }
        },
        {
            "name": "GetInterface",
            "desc": "Returns a type-checking function for the enum.\n\n```lua\nlocal MyEnum = SimpleEnum.new({\n\tFOO = \"foo\",\n\tBAR = \"bar\",\n})\n\nlocal typeChecker = MyEnum:GetInterface()\n\nprint(typeChecker(\"foo\")) --> true\nprint(typeChecker(\"baz\")) --> false, \"Expected one of: foo, bar; got baz\"\n```",
            "params": [
                {
                    "name": "self",
                    "desc": "",
                    "lua_type": "PrivateSimpleEnum<EnumMembers>"
                }
            ],
            "returns": [
                {
                    "desc": "",
                    "lua_type": "(value: any) -> (boolean, string?)\n"
                }
            ],
            "function_type": "static",
            "source": {
                "line": 128,
                "path": "src/enums/src/Shared/SimpleEnum.lua"
            }
        }
    ],
    "properties": [],
    "types": [],
    "name": "SimpleEnum",
    "desc": "A very simple enum implementation that makes typechecking boilerplate simpler.\n\n```lua\nlocal require = require(script.Parent.loader).load(script)\n\nlocal SimpleEnum = require(\"SimpleEnum\")\n\nexport type MyEnumType = \"none\" | \"always\"\n\nreturn SimpleEnum.new({\n\tNONE = \"none\" :: \"none\",\n\tALWAYS = \"always\" :: \"always\",\n})\n```",
    "source": {
        "line": 20,
        "path": "src/enums/src/Shared/SimpleEnum.lua"
    }
}