t Runtime Type Checker for Roblox

You can combine existing type checkers to create more complex requirements. Most composition functions take a type checker as an argument and return a new one.

Example: t.optional(t.string) creates a checker that passes if the value is either a string or nil.

local mightBeAString = t.optional(t.string)
print(mightBeAString("Hello")) --> true
print(mightBeAString()) --> true
print(mightBeAString(1)) --> false, "(optional) string expected, got number"

In Lua, arrays are tables with sequential integer keys. Use t.array(check) to ensure a table is a valid array and that every value in that array matches the provided check.

t.array(t.string) -- Validates a table where all values are strings and keys are sequential integers

You can download the latest copy of the t module directly from the source repository to use in your Roblox projects.

Download latest init.lua

local t = require(path.to.t)

The t module allows you to define type schemas and validate values against them. This is useful for ensuring function arguments are correct and for validating data received from Remote objects to prevent exploits or server errors.

To use it, define a check (often using t.tuple for multiple arguments) and use it within an assert or directly to validate data.

local t = require(path.to.t)

local fooCheck = t.tuple(t.string, t.number, t.optional(t.string))
local function foo(a, b, c)
	assert(fooCheck(a, b, c))
	-- you can now assume:
	--	a is a string
	--	b is a number
	--	c is either a string or nil
end

foo("1", 2, "3") -- Valid
foo("1", 2, 3)   -- Error: Bad tuple index #3: (optional) string expected, got number

Instead of manually calling assert(check(args)) inside every function, you can use t.wrap to create a version of your function that automatically performs type validation on its arguments.

t.wrap(callback, argCheck) Takes a function and a type checker (like t.tuple) and returns a new function that runs the check before executing the callback.

local fooCheck = t.tuple(t.string, t.number, t.optional(t.string))

-- Instead of this:
local function foo(a, b, c)
	assert(fooCheck(a, b, c))
	print(a, b, c)
end

-- Do this:
local foo = t.wrap(function(a, b, c)
	print(a, b, c)
end, fooCheck)

-- Or use t.strict to wrap the check itself:
local foo = t.strict(fooCheck)(function(a, b, c)
	print(a, b, c)
end)

Use these functions to validate Roblox Instances and their hierarchies.

• t.instanceOf(className[, childTable]): Ensures the value is an Instance with the exact className. If childTable is provided, it validates children using t.children().
• t.instanceIsA(className[, childTable]): Ensures the value is an Instance that matches className via IsA comparison.
• t.children(checkTable): Validates an instance's children against a table where keys are child names and values are type checkers.

Warning: If an instance tree has more than one child with the same name, t.children will always return false.

Use t.match(pattern) to check if a string matches a specific pattern using string.match(value, pattern).

**`t.match(pattern)`**
checks `t.string` and determines if value matches the pattern via `string.match(value, pattern)`

Validate Roblox Enums and EnumItems.

• t.Enum: Ensures the value is an Enum (e.g., Enum.Material).
• t.EnumItem: Ensures the value is an EnumItem (e.g., Enum.Material.Plastic).
• t.enum(enum): Passes if the value is an EnumItem belonging to the specific enum provided.

The following functions check for basic Lua and Roblox primitive types. Note that nil is mapped to t.none and function is mapped to t.callback due to Lua keyword restrictions.

|Type     |  |Member     |
|---------|--|-----------|
|boolean  |=>|t.boolean  |
|thread   |=>|t.thread   |
|function |=>|t.callback |
|nil      |=>|t.none     |
|number   |=>|t.number   |
|string   |=>|t.string   |
|table    |=>|t.table    |
|userdata |=>|t.userdata |