Skip to content


Type Checker and Function Signature Assigner

Library API


function Typer.AssignSignature([number ParameterIndexToStartChecking = 1, ] types ... , function Callback)

Returns a function which checks to make sure the arguments passed in exactly match the parameters specified. If they match, it will call Callback, otherwise it will error, stating which parameter caused the error and what was expected.

Each parameter corresponds to the parameter with which the function is being called. Parameters should be arrays containing all valid strings which may be returned by typeof(parameter). For example: {"string", "number", "nil"} would allow the corresponding parameter to be a string, number, or nil. Optionally, a table may have a [string TypeNameKey] = function Callback which may be called to determine whether a parameter is of the type TypeNameKey.

The first parameter may optionally be a positive integer which is the first parameter AssignSignature should start checking.


local Typer = Resources:LoadLibrary("Typer")

local function IsButton(Value, TypeOfString)
    -- Value is the Parameter
    -- TypeOfString is the string returned by typeof(Value)

    return TypeOfString == "Instance" and (Value:IsA("TextButton") or Value:IsA("ImageButton"))

local foo = Typer.AssignSignature({"string", "number", "nil", Button = IsButton}, function(s)
    -- s can be a string, number, nil, or Button (TextButton or ImageButton)
    -- Will error if `s` is none of the aforementioned
    -- Will error if 2 or more parameters are passed in

    return s

foo(2) -- 2
foo("Hello") -- Hello
foo({}) -- [Typer] {Foo} bad argument #1: expected Button or string or number or nil, got table {}

local bar = Typer.AssignSignature(2, {"string"}, {"number"}, function(p1, p2, p3)
    -- The 2 signifies that the first checked parameter will be the second one
    -- Makes sure the 2nd parameter is a string, 3rd is a number
    -- The first parameter is not checked

    print(p1, p2, p3)


bar(false, "", 1)


boolean Typer.Check(table PotentialType, any Parameter [, <string, number> ArgumentName])

Checks if an individual Parameter matches a PotentialType in the same way Typer.AssignSignature does. Returns Parameter if it's a truthy value. If it isn't a truthy value, return true. ArgumentName is just the name or number of the argument being Checked which can be used in the error message.


local Debug = Resources:LoadLibrary("Debug")
local Typer = Resources:LoadLibrary("Typer")

local function foo(a)
    -- `assert` can be used instead of Debug.Assert
    return Debug.Assert(Typer.Check({"number"}, a, 1))

foo(2) -- 2
foo("Noodle") -- [Script] {Foo} bad argument #1: expected number, got string Noodle


function Typer.MapDefinition(table Definition)

Returns a function which returns the table if it matches the definition, or false, errorMessage if it doesn't.


local PlayerDefinition = Typer.MapDefinition {
    Name = Typer.String;
    UserId = Typer.PositiveInteger;

local Player1 = {
    Name = "Validark";
    UserId = 2966752;

Player1 = assert(PlayerDefinition(Player1))

-- Can also be used with AssignSignature
Typer.AssignSignature({Player = PlayerDefinition}, function(...)


table Typer.TypeString

Typer will procedurally generate tables which can be cast to valid types. These may be used with Typer.AssignSignature or Typer.Check to avoid duplicate table definitions. These tables may also be called directly, since their metatable __call is set to Typer.Check


assert(Typer.Function(function() end)

local foo = Typer.AssignSignature(Typer.String, function(a)

foo("Hello, world!")

Built-in Types

Key Matches
Nil type(Object) = "nil"
Boolean type(Object) = "boolean"
Number type(Object) = "number"
String type(Object) = "string"
Userdata type(Object) = "userdata"
Function type(Object) = "function"
Thread type(Object) = "thread"
Table type(Object) = "table"

Typer accepts anything returned by typeof

Custom Types

Key Matches
Any Anything
Array A non-empty table with only numeric keys
Dictionary A non-empty table with only non-numeric keys
EmptyTable An empty table
NonNil Any value which isn't nil
Integer Any whole number
PositiveInteger An integer higher than 0
NegativeInteger An integer lower than 0
NonPositiveInteger An integer lower than 0 or 0
NonNegativeInteger An integer higher than 0 or 0
PositiveNumber A number higher than 0
NegativeNumber A number lower than 0
NonPositiveNumber A number lower than 0 or 0
NonNegativeNumber A number higher than 0 or 0
Truthy Any value which isn't false or nil
Falsy False or nil
Enum An EnumType or EnumItem
EnumType A roblox EnumType
EnumItem An EnumItem
True true
False false

Types from parsed strings

Types separated by "Or" will function as expected.



Prefix Matches
Optional Accepts nil as well
InstanceOfClass Returns Object.ClassName == ClassName
InstanceWhichIsA Returns Object:IsA(ClassName)
EnumOfType Returns the (Roblox) Enum if it can be cast to it via its string, number, or reference
EnumerationOfType Returns EnumerationType:Cast(Object)
DictionaryOf Ensures it's a dictionary with values of a given type
ArrayOf Ensures it's an array with values of a given type
TableOf Ensures it's a table with values of a given type


You may not nest prefixes, but you may use multiple on the top level using "Or"


assert(Typer.ArrayOfStringsOrDictionaryOfNumbers{"a", "b", "c"})

    a = 1;
    b = 2;
    c = 3;