@rbxts/libopen-ty 1.0.0

package/LICENSE.md

@@ -0,0 +1,16 @@
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the “Software”), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,12 @@
+# rbxts-elttob-libopen
+
+roblox-ts typings for [Studio's Elttob LibOpen](https://github.com/elttob/LibOpen).
+
+I, znotfireman, am not affiliated, associated, authorized, endorsed by, or in
+any way officially connected with Studio Elttob.
+
+## Excluded packages
+
+- `LibOpen/Fusion` — please use my `@rbxts/hotfusion` or
+  `@rbxts/fusion-temp-0.3` aliased with `@rbxts/fusion`, both packages have
+   built-in JSX support.

package/default.project.json

@@ -0,0 +1,6 @@
+{
+    "name": "ty",
+    "tree": {
+        "$path": "src"
+    }
+}

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@rbxts/libopen-ty",
+  "version": "1.0.0",
+  "description": "LibOpen's ty",
+  "main": "src/init.luau",
+  "license": "MIT",
+  "types": "src/index.d.ts",
+  "files": [
+    "src",
+    "LICENSE.md",
+    "default.project.json",
+    "package.json",
+    "!**/*.tsbuildinfo"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@rbxts/libopen-maybe": "npm:@rbxts/libopen-ty@1.0.0"
+  },
+  "scripts": {}
+}

package/src/Def.luau

@@ -0,0 +1,33 @@
+--!strict
+-- ty (Elttob Suite monorepo edition - no static types)
+-- By Daniel P H Fox, licensed under MIT
+
+local Package = script.Parent.Parent
+local Types = require(Package.ty.Types)
+local Maybe = require(Package.Maybe)
+
+local Def = {}
+
+Def.methodMeta = {__index = nil :: Types.Methods?}
+
+local function linkMethods(
+	def
+): Types.Def
+	setmetatable(def, Def.methodMeta)
+	return def :: any
+end
+
+function Def.new<CastTo>(
+	expectsType: string,
+	matches: (self: Types.Def, unknown) -> boolean,
+	cast: (self: Types.Def, unknown) -> Maybe.Maybe<any>
+): Types.Def
+	local def = {}
+	def.Matches = matches
+	def.ExpectsType = expectsType
+	def.NotOfTypeError = `Type is not {expectsType}`
+	def.Cast = cast
+	return linkMethods(def)
+end
+
+return Def

package/src/Functions/And.luau

@@ -0,0 +1,32 @@
+--!strict
+--!nolint LocalShadow
+-- ty (Elttob Suite monorepo edition - no static types)
+-- By Daniel P H Fox, licensed under MIT
+
+local Package = script.Parent.Parent.Parent
+local Maybe = require(Package.Maybe)
+
+local Types = require(Package.ty.Types)
+local Def = require(Package.ty.Def)
+
+local And: Types.FnAnd = function(first, last)
+	return Def.new(
+		`({first.ExpectsType}) & ({last.ExpectsType})`,
+		function(self, x)
+			return first:Matches(x) and last:Matches(x)
+		end,
+		function(self, x)
+			local result = first:Cast(x)
+			if not result.some then
+				return Maybe.None(`{self.NotOfTypeError}\n...because of the first & type: {result.reason}`)
+			end
+			local result = last:Cast(result.value)
+			if not result.some then
+				return Maybe.None(`{self.NotOfTypeError}\n...because of the last & type: {result.reason}`)
+			end
+			return result
+		end
+	)
+end
+
+return And

package/src/Functions/Array.luau

@@ -0,0 +1,57 @@
+--!strict
+--!nolint LocalShadow
+-- ty (Elttob Suite monorepo edition - no static types)
+-- By Daniel P H Fox, licensed under MIT
+
+local Package = script.Parent.Parent.Parent
+local Maybe = require(Package.Maybe)
+
+local Types = require(Package.ty.Types)
+local Def = require(Package.ty.Def)
+
+-- TODO: ensure arrays have no holes, and empty arrays are allowed
+local Array: Types.FnArray = function<V>(values: Types.Def)
+	return Def.new(
+		`\{{values.ExpectsType}}`,
+		function(self, x)
+			if typeof(x) ~= "table" then
+				return false
+			end
+			local x = x :: {[unknown]: unknown}
+			local expected = #x
+			local encountered = 0
+			for key, value in pairs(x) do
+				encountered += 1
+				if encountered > expected or typeof(key) ~= "number" or not values:Matches(value) then
+					return false
+				end
+			end
+			return true
+		end,
+		function(self, x)
+			if typeof(x) ~= "table" then
+				return Maybe.None(`{self.NotOfTypeError}\n...because {tostring(x)} isn't an array`)
+			end
+			local x = x :: {[unknown]: unknown}
+			local modifiedReturn = {}
+			local expected = #x
+			local encountered = 0
+			for key, value in pairs(x) do
+				encountered += 1
+				if encountered > expected or typeof(key) ~= "number" then
+					return Maybe.None(`{self.NotOfTypeError}\n...because {tostring(key)} isn't a valid array index`)
+				end
+				local castedValue = values:Cast(value)
+				if not castedValue.some then
+					return Maybe.None(`{self.NotOfTypeError}\n...because, at key {tostring(key)}: {castedValue.reason}`)
+				end
+				if castedValue ~= nil then
+					table.insert(modifiedReturn, castedValue.value :: any)
+				end
+			end
+			return Maybe.Some(modifiedReturn)
+		end
+	)
+end
+
+return Array

package/src/Functions/CastOrError.luau

@@ -0,0 +1,17 @@
+--!strict
+-- ty (Elttob Suite monorepo edition - no static types)
+-- By Daniel P H Fox, licensed under MIT
+
+local Package = script.Parent.Parent.Parent
+local Types = require(Package.ty.Types)
+
+local CastOrError: Types.FnCastOrError = function(def, x)
+	local result = def:Cast(x)
+	if result.some then
+		return result.value
+	else
+		error(`Could not cast {typeof(x)}: {result.reason}`)
+	end
+end
+
+return CastOrError

package/src/Functions/IgnoreInvalid.luau

@@ -0,0 +1,25 @@
+--!strict
+--!nolint LocalShadow
+-- ty (Elttob Suite monorepo edition - no static types)
+-- By Daniel P H Fox, licensed under MIT
+
+local Package = script.Parent.Parent.Parent
+local Maybe = require(Package.Maybe)
+
+local Types = require(Package.ty.Types)
+local Def = require(Package.ty.Def)
+
+local IgnoreInvalid: Types.FnIgnoreInvalid = function<T>(innerDef: Types.Def)
+	return Def.new(
+		`@ignoreInvalid({innerDef.ExpectsType})`,
+		function(self, x)
+			return true
+		end,
+		function(self, x)
+			local result = innerDef:Cast(x)
+			return if result.some then result else Maybe.Some(nil)
+		end
+	)
+end
+
+return IgnoreInvalid

package/src/Functions/IntoDefault.luau

@@ -0,0 +1,28 @@
+--!strict
+--!nolint LocalShadow
+-- ty (Elttob Suite monorepo edition - no static types)
+-- By Daniel P H Fox, licensed under MIT
+
+local Package = script.Parent.Parent.Parent
+local Maybe = require(Package.Maybe)
+
+local Types = require(Package.ty.Types)
+local Def = require(Package.ty.Def)
+
+local IntoDefault: Types.FnIntoDefault = function(innerDef, defaultValue)
+	return Def.new(
+		`\@default<{defaultValue}>({innerDef.ExpectsType})`,
+		function(self, x)
+			return x == nil or innerDef:Matches(x)
+		end,
+		function(self, x)
+			if x == nil then
+				return Maybe.Some(defaultValue)
+			else
+				return innerDef:Cast(x)
+			end
+		end
+	)
+end
+
+return IntoDefault

package/src/Functions/IntoNumber.luau

@@ -0,0 +1,35 @@
+--!strict
+--!nolint LocalShadow
+-- ty (Elttob Suite monorepo edition - no static types)
+-- By Daniel P H Fox, licensed under MIT
+
+local Package = script.Parent.Parent.Parent
+local Maybe = require(Package.Maybe)
+
+local Types = require(Package.ty.Types)
+local Def = require(Package.ty.Def)
+
+local IntoNumber: Types.FnIntoNumber = function(innerDef, base)
+	return Def.new(
+		`@tonumber({innerDef.ExpectsType}{if base == nil then "" else ", " .. base})`,
+		function(self, x)
+			local Cast = innerDef:Cast(x)
+			return Cast.some and tonumber(Cast.value, base) ~= nil
+		end,
+		function(self, x)
+			local result = innerDef:Cast(x)
+			if not result.some then
+				return Maybe.None(`{self.NotOfTypeError}\n...because of the inner type: {result.reason}`)
+			else
+				local num = tonumber(result.value, base)
+				if num == nil then
+					return Maybe.None(`Numeric conversion not possible for {self.ExpectsType}`)
+				else
+					return Maybe.Some(num)
+				end
+			end
+		end
+	)
+end
+
+return IntoNumber

package/src/Functions/IntoString.luau

@@ -0,0 +1,35 @@
+--!strict
+--!nolint LocalShadow
+-- ty (Elttob Suite monorepo edition - no static types)
+-- By Daniel P H Fox, licensed under MIT
+
+local Package = script.Parent.Parent.Parent
+local Maybe = require(Package.Maybe)
+
+local Types = require(Package.ty.Types)
+local Def = require(Package.ty.Def)
+
+local IntoString: Types.FnIntoString = function(innerDef)
+	return Def.new(
+		`@tostring({innerDef.ExpectsType})`,
+		function(self, x)
+			local Cast = innerDef:Cast(x)
+			return Cast.some and tostring(Cast.value) ~= nil
+		end,
+		function(self, x)
+			local result = innerDef:Cast(x)
+			if not result.some then
+				return Maybe.None(`{self.NotOfTypeError}\n...because of the inner type: {result.reason}`)
+			else
+				local str = tostring(result.value)
+				if str == nil then
+					return Maybe.None(`{self.NotOfTypeError}\n...because it couldn't be turned into a string`)
+				else
+					return Maybe.Some(str)
+				end
+			end
+		end
+	)
+end
+
+return IntoString

package/src/Functions/IntoTagged.luau

@@ -0,0 +1,34 @@
+--!strict
+--!nolint LocalShadow
+-- ty (Elttob Suite monorepo edition - no static types)
+-- By Daniel P H Fox, licensed under MIT
+
+local Package = script.Parent.Parent.Parent
+local Maybe = require(Package.Maybe)
+
+local Types = require(Package.ty.Types)
+local Def = require(Package.ty.Def)
+
+local IntoTagged: Types.FnIntoTagged = function(innerDef, tag)
+	return Def.new(
+		`\@tagged<{tag}>({innerDef.ExpectsType})`,
+		function(self, x)
+			return innerDef:Matches(x)
+		end,
+		function(self, x)
+			local result = innerDef:Cast(x)
+			if not result.some then
+				return Maybe.None(`{self.NotOfTypeError}\n...because of the inner type: {result.reason}`)
+			else
+				local value = 
+					if typeof(result.value) == "table"
+					then table.clone(result.value :: any) :: any
+					else {value = result.value}
+				value.__tag = tag
+				return Maybe.Some(value)
+			end
+		end
+	)
+end
+
+return IntoTagged

package/src/Functions/Just.luau

@@ -0,0 +1,28 @@
+--!strict
+--!nolint LocalShadow
+-- ty (Elttob Suite monorepo edition - no static types)
+-- By Daniel P H Fox, licensed under MIT
+
+local Package = script.Parent.Parent.Parent
+local Maybe = require(Package.Maybe)
+
+local Types = require(Package.ty.Types)
+local Def = require(Package.ty.Def)
+
+local Just: Types.FnJust = function(literal, type)
+	return Def.new(
+		type or tostring(literal),
+		function(self, x)
+			return rawequal(x, literal)
+		end,
+		function(self, x)
+			if rawequal(x, literal) then
+				return Maybe.Some(x)
+			else
+				return Maybe.None(`{self.NotOfTypeError}\n...because only {tostring(literal)} is accepted, but received {tostring(x)}`)
+			end
+		end
+	)
+end
+
+return Just

package/src/Functions/MapOf.luau

@@ -0,0 +1,49 @@
+--!strict
+--!nolint LocalShadow
+-- ty (Elttob Suite monorepo edition - no static types)
+-- By Daniel P H Fox, licensed under MIT
+
+local Package = script.Parent.Parent.Parent
+local Maybe = require(Package.Maybe)
+
+local Types = require(Package.ty.Types)
+local Def = require(Package.ty.Def)
+
+local MapOf: Types.FnMapOf = function<K, V>(keys: Types.Def, values: Types.Def)
+	return Def.new(
+		`\{[{keys.ExpectsType}]: {values.ExpectsType}}`,
+		function(self, x)
+			if typeof(x) ~= "table" then
+				return false
+			end
+			local x = x :: {[unknown]: unknown}
+			for key, value in pairs(x) do
+				if not keys:Matches(key) or not values:Matches(value) then
+					return false
+				end
+			end
+			return true
+		end,
+		function(self, x)
+			if typeof(x) ~= "table" then
+				return Maybe.None(`{self.NotOfTypeError}\n...because {tostring(x)} isn't a table`)
+			end
+			local x = x :: {[unknown]: unknown}
+			local modifiedReturn = {}
+			for key, value in pairs(x) do
+				local castedKey = keys:Cast(key)
+				if not castedKey.some then
+					return Maybe.None(`{self.NotOfTypeError}\n...because of the key {tostring(key)}: {castedKey.reason}`)
+				end
+				local castedValue = values:Cast(value)
+				if not castedValue.some then
+					return Maybe.None(`{self.NotOfTypeError}\n...because of the value at key {tostring(key)}: {castedValue.reason}`)
+				end
+				modifiedReturn[castedKey.value :: any] = castedValue.value :: any
+			end
+			return Maybe.Some(modifiedReturn)
+		end
+	)
+end
+
+return MapOf

package/src/Functions/Nicknamed.luau

@@ -0,0 +1,18 @@
+--!strict
+--!nolint LocalShadow
+-- ty (Elttob Suite monorepo edition - no static types)
+-- By Daniel P H Fox, licensed under MIT
+
+local Package = script.Parent.Parent.Parent
+local Types = require(Package.ty.Types)
+local Def = require(Package.ty.Def)
+
+local Nicknamed: Types.FnNicknamed = function<T>(innerDef, newName)
+	return Def.new(
+		newName,
+		innerDef.Matches,
+		innerDef.Cast
+	)
+end
+
+return Nicknamed

package/src/Functions/Optional.luau

@@ -0,0 +1,31 @@
+--!strict
+--!nolint LocalShadow
+-- ty (Elttob Suite monorepo edition - no static types)
+-- By Daniel P H Fox, licensed under MIT
+
+local Package = script.Parent.Parent.Parent
+local Maybe = require(Package.Maybe)
+
+local Types = require(Package.ty.Types)
+local Def = require(Package.ty.Def)
+
+local Optional: Types.FnOptional = function<T>(innerDef: Types.Def)
+	return Def.new(
+		`({innerDef.ExpectsType})?`,
+		function(self, x)
+			if x == nil then
+				return true
+			end
+			return innerDef:Matches(x)
+		end,
+		function(self, x)
+			if x == nil then
+				return Maybe.Some(nil) :: Maybe.Maybe<T?>
+			end
+			local result = innerDef:Cast(x)
+			return if result.some then result else Maybe.None(`{self.NotOfTypeError}\n...because of the inner type: {result.reason}`)
+		end
+	)
+end
+
+return Optional

package/src/Functions/Or.luau

@@ -0,0 +1,29 @@
+--!strict
+--!nolint LocalShadow
+-- ty (Elttob Suite monorepo edition - no static types)
+-- By Daniel P H Fox, licensed under MIT
+
+local Package = script.Parent.Parent.Parent
+local Maybe = require(Package.Maybe)
+
+local Types = require(Package.ty.Types)
+local Def = require(Package.ty.Def)
+
+local Or: Types.FnOr = function<F, L>(first: Types.Def, last: Types.Def)
+	return Def.new(
+		`{first.ExpectsType} | {last.ExpectsType}`,
+		function(self, x)
+			return first:Matches(x) or last:Matches(x)
+		end,
+		function(self, x)
+			local firstResult = first:Cast(x)
+			if firstResult.some then
+				return (firstResult :: any) :: Maybe.Maybe<F | L>
+			end
+			local lastResult = last:Cast(x)
+			return if lastResult.some then lastResult else Maybe.None(`{self.NotOfTypeError}\n...because neither inner type fits:\nFirst type: {firstResult.reason}\nSecond type: {lastResult.reason}`)
+		end
+	)
+end
+
+return Or

package/src/Functions/Predicate.luau

@@ -0,0 +1,28 @@
+--!strict
+--!nolint LocalShadow
+-- ty (Elttob Suite monorepo edition - no static types)
+-- By Daniel P H Fox, licensed under MIT
+
+local Package = script.Parent.Parent.Parent
+local Maybe = require(Package.Maybe)
+
+local Types = require(Package.ty.Types)
+local Def = require(Package.ty.Def)
+
+local Predicate: Types.FnPredicate = function(predicate)
+	return Def.new(
+		`@predicate`,
+		function(self, x)
+			return predicate(x)
+		end,
+		function(self, x)
+			if predicate(x) then
+				return Maybe.Some(x)
+			else
+				return Maybe.None(`Type did not satisfy predicate`)
+			end
+		end
+	)
+end
+
+return Predicate

package/src/Functions/Retype.luau

@@ -0,0 +1,13 @@
+--!strict
+--!nolint LocalShadow
+-- ty (Elttob Suite monorepo edition - no static types)
+-- By Daniel P H Fox, licensed under MIT
+
+local Package = script.Parent.Parent.Parent
+local Types = require(Package.ty.Types)
+
+local Retype: Types.FnRetype = function(def)
+	return def
+end
+
+return Retype

package/src/Functions/Struct.luau

@@ -0,0 +1,62 @@
+--!strict
+--!nolint LocalShadow
+-- ty (Elttob Suite monorepo edition - no static types)
+-- By Daniel P H Fox, licensed under MIT
+
+local Package = script.Parent.Parent.Parent
+local Maybe = require(Package.Maybe)
+
+local Types = require(Package.ty.Types)
+local Def = require(Package.ty.Def)
+
+local Struct: Types.FnStruct = function<K, V>(options, struct: {[K & string]: Types.Def})
+	local expectTypeParts = {}
+	for key, value in struct do
+		table.insert(expectTypeParts, `{key}: {value.ExpectsType}`)
+	end
+	return Def.new(
+		`\{{table.concat(expectTypeParts, ", ")}}`,
+		function(self, x)
+			if typeof(x) ~= "table" then
+				return false
+			end
+			local x = x :: {[unknown]: unknown}
+			for key, value in pairs(x) do
+				if typeof(key) ~= "string" then
+					return false
+				end
+				local key = key :: K & string
+				local innerDef = struct[key]
+				if innerDef == nil or not innerDef:Matches(value) then
+					return false
+				end
+			end
+			return true
+		end,
+		function(self, x)
+			if typeof(x) ~= "table" then
+				return Maybe.None(`{self.NotOfTypeError}\n...because {tostring(x)} isn't a table`)
+			end
+			local x = x :: {[unknown]: unknown}
+			local modifiedReturn = {}
+			for key, innerDef in pairs(struct) do
+				local value = x[key]
+				local castedValue = innerDef:Cast(value)
+				if not castedValue.some then
+					return Maybe.None(`{self.NotOfTypeError}\n...because of the value at key {tostring(key)}: {castedValue.reason}`)
+				end
+				modifiedReturn[key] = castedValue.value :: any
+			end
+			for key in pairs(x) do
+				if typeof(key) ~= "string" then
+					return Maybe.None(`{self.NotOfTypeError}\n...because {tostring(key)} isn't a valid struct key`)
+				elseif options.exhaustive and struct[key :: any] == nil then
+					return Maybe.None(`{self.NotOfTypeError}\n...because the struct is exhaustive and {tostring(key)} isn't included`)
+				end
+			end
+			return Maybe.Some(modifiedReturn)
+		end
+	)
+end
+
+return Struct

package/src/Functions/Tuple.luau

@@ -0,0 +1,63 @@
+--!strict
+--!nolint LocalShadow
+-- ty (Elttob Suite monorepo edition - no static types)
+-- By Daniel P H Fox, licensed under MIT
+
+local Package = script.Parent.Parent.Parent
+local Maybe = require(Package.Maybe)
+
+local Types = require(Package.ty.Types)
+local Def = require(Package.ty.Def)
+
+local Tuple: Types.FnTuple = function<V>(options, tuple)
+	local expectTypeParts = {}
+	for key, value in tuple do
+		assert(typeof(key) == "number", "Tuple requires numeric arguments")
+		table.insert(expectTypeParts, `[{key}]: {value.ExpectsType}`)
+	end
+	return Def.new(
+		`\{{table.concat(expectTypeParts, ", ")}}`,
+		function(self, x)
+			if typeof(x) ~= "table" then
+				return false
+			end
+			local x = x :: {[unknown]: unknown}
+			for key, value in pairs(x) do
+				if typeof(key) ~= "number" then
+					return false
+				end
+				local key = key :: number
+				local innerDef = tuple[key]
+				if innerDef == nil or not innerDef:Matches(value) then
+					return false
+				end
+			end
+			return true
+		end,
+		function(self, x)
+			if typeof(x) ~= "table" then
+				return Maybe.None(`{self.NotOfTypeError}\n...because {tostring(x)} isn't a table`)
+			end
+			local x = x :: {[unknown]: unknown}
+			local modifiedReturn = {}
+			for key, innerDef in pairs(tuple) do
+				local value = x[key]
+				local castedValue = innerDef:Cast(value)
+				if not castedValue.some then
+					return Maybe.None(`{self.NotOfTypeError}\n...because of the value at key {tostring(key)}: {castedValue.reason}`)
+				end
+				modifiedReturn[key] = castedValue.value :: any
+			end
+			for key in pairs(x) do
+				if typeof(key) ~= "number" then
+					return Maybe.None(`{self.NotOfTypeError}\n...because {tostring(key)} isn't a valid tuple key`)
+				elseif options.exhaustive and tuple[key] == nil then
+					return Maybe.None(`{self.NotOfTypeError}\n...because the tuple is exhaustive and {tostring(key)} isn't included`)
+				end
+			end
+			return Maybe.Some(modifiedReturn)
+		end
+	)
+end
+
+return Tuple

package/src/Functions/Typeof.luau

@@ -0,0 +1,28 @@
+--!strict
+--!nolint LocalShadow
+-- ty (Elttob Suite monorepo edition - no static types)
+-- By Daniel P H Fox, licensed under MIT
+
+local Package = script.Parent.Parent.Parent
+local Maybe = require(Package.Maybe)
+
+local Types = require(Package.ty.Types)
+local Def = require(Package.ty.Def)
+
+local Typeof: Types.FnTypeof = function(typeString)
+	return Def.new(
+		typeString,
+		function(self, x)
+			return typeof(x) == typeString
+		end,
+		function(self, x)
+			if typeof(x) == typeString then
+				return Maybe.Some(x)
+			else
+				return Maybe.None(`{self.NotOfTypeError}\n...because {tostring(x)} doesn't have typeof() == {typeString}`)
+			end
+		end
+	)
+end
+
+return Typeof

package/src/Functions/Untyped.luau

@@ -0,0 +1,13 @@
+--!strict
+--!nolint LocalShadow
+-- ty (Elttob Suite monorepo edition - no static types)
+-- By Daniel P H Fox, licensed under MIT
+
+local Package = script.Parent.Parent.Parent
+local Types = require(Package.ty.Types)
+
+local Untyped: Types.FnUntyped = function(def)
+	return def
+end
+
+return Untyped

package/src/Types.luau

@@ -0,0 +1,156 @@
+--!strict
+-- From 'ty' by Elttob, MIT license
+
+local Package = script.Parent.Parent
+local Maybe = require(Package.Maybe)
+
+export type Def = DefNoMethods & Methods
+type DefNoMethods = {
+	ExpectsType: string,
+	NotOfTypeError: string,
+	Matches: (self: Def, unknown) -> boolean,
+	Cast: (self: Def, unknown) -> Maybe.Maybe<unknown>
+}
+
+export type Constants = {
+	Unknown: Def,
+	Never: Def,
+
+	Number: Def,
+	Boolean: Def,
+	String: Def,
+	Thread: Def,
+	Table: Def,
+	Function: Def,
+
+	True: Def,
+	False: Def,
+	Nil: Def
+}
+
+export type Methods = {
+	Predicate: FnPredicate,
+	Typeof: FnTypeof,
+	Just: FnJust,
+	Optional: FnOptional,
+	IgnoreInvalid: FnIgnoreInvalid,
+	Or: FnOr,
+	And: FnAnd,
+	MapOf: FnMapOf,
+	Array: FnArray,
+	Struct: FnStruct,
+	Tuple: FnTuple,
+	IntoTagged: FnIntoTagged,
+	IntoString: FnIntoString,
+	IntoNumber: FnIntoNumber,
+	IntoDefault: FnIntoDefault,
+	Retype: FnRetype,
+	Untyped: FnUntyped,
+	Nicknamed: FnNicknamed,
+	CastOrError: FnCastOrError
+}
+
+export type FnPredicate = (
+	predicate: (unknown) -> boolean
+) -> Def
+
+export type FnTypeof = (
+	typeString: string
+) -> Def
+
+export type FnJust = (
+	literal: unknown,
+	type: string?
+) -> Def
+
+export type Optional = Def
+export type FnOptional = (
+	innerDef: Def
+) -> Optional
+
+export type IgnoreInvalid = Def
+export type FnIgnoreInvalid = (
+	innerDef: Def
+) -> IgnoreInvalid
+
+export type Or = Def
+export type FnOr = (
+	first: Def,
+	last: Def
+) -> Or
+
+
+export type And = Def
+export type FnAnd = (
+	first: Def,
+	last: Def
+) -> And
+
+export type MapOf = Def
+export type FnMapOf = (
+	keys: Def,
+	values: Def
+) -> MapOf
+
+
+export type Array = Def
+export type FnArray = <V>(
+	values: Def
+) -> Array
+
+-- FUTURE: suboptimal type for this; try keyof when it launches?
+export type Struct = Def
+export type FnStruct = (
+	options: {
+		exhaustive: boolean
+	},
+	object: {[string]: Def}
+) -> Struct
+
+export type Tuple = Def
+export type FnTuple = (
+	options: {
+		exhaustive: boolean
+	},
+	tuple: {[number]: Def}
+) -> Tuple
+
+export type IntoTagged = Def
+export type FnIntoTagged = (
+	innerDef: Def,
+	tag: unknown
+) -> IntoTagged
+
+export type FnIntoString = (
+	innerDef: Def
+) -> Def
+
+export type FnIntoNumber = (
+	innerDef: Def,
+	base: number?
+) -> Def
+
+export type FnIntoDefault = (
+	innerDef: Def,
+	defaultValue: any
+) -> Def
+
+export type FnRetype = (
+	def: Def
+) -> Def
+
+export type FnUntyped = (
+	def: Def
+) -> Def
+
+export type FnNicknamed = (
+	innerDef: Def,
+	newName: string
+) -> Def
+
+export type FnCastOrError = (
+	def: Def,
+	x: unknown
+) -> unknown
+
+return nil

package/src/index.d.ts

@@ -0,0 +1,71 @@
+type Some<Value> = { some: true; value: Value };
+type None = { some: false; reason?: string };
+type Maybe<Value> = Some<Value> | None;
+
+declare namespace ty {
+	export type Static<T> = T extends Def<infer CastTo> ? CastTo : never;
+
+	export interface Def<CastTo> {
+		ExpectsType: string;
+		NotOfTypeError: string;
+		Matches(value: unknown): boolean;
+		Cast(value: unknown): Maybe<CastTo>;
+
+		Optional(): Def<CastTo | undefined>;
+		IgnoreInvalid(): Def<CastTo | undefined>;
+		Or<L>(last: Def<L>): Def<CastTo | L>;
+		And<L>(last: Def<L>): Def<CastTo & L>;
+		IntoTagged<Tag>(tag: Tag): Def<{ __tag: Tag; value: CastTo }>;
+		IntoString(): Def<string>;
+		IntoNumber(base?: number): Def<number>;
+		IntoDefault(defaultValue: NonNullable<CastTo>): Def<NonNullable<CastTo>>;
+		Retype<T>(this: Def<any>): Def<T>;
+		Untyped(): Def<any>;
+		Nicknamed(newName: string): Def<CastTo>;
+		CastOrError(x: unknown): CastTo;
+	}
+
+	export function Predicate<T>(predicate: (x: unknown) => x is T): Def<T>;
+	export function Typeof<T extends keyof CheckableTypes>(typeString: T): Def<CheckableTypes[T]>;
+	export function Just<T>(literal: T, type?: string): Def<T>;
+	export function Optional<T>(innerDef: Def<T>): Def<T | undefined>;
+	export function IgnoreInvalid<T>(innerDef: T): Def<T | undefined>;
+	export function Or<F, L>(first: Def<F>, last: Def<L>): Def<F | L>;
+	export function And<F, L>(first: Def<F>, last: Def<L>): Def<F & L>;
+	export function MapOf<K extends string | number | symbol, V>(keys: Def<K>, values: Def<V>): Def<Record<K, V>>;
+	export function MapOf<K, V>(keys: Def<K>, values: Def<V>): Def<Map<K, V>>;
+	export function Array<V>(values: Def<V>): Def<V[]>;
+	export function Struct<T extends Record<string, Def<unknown>>>(
+		options: { exhaustive: boolean },
+		object: T,
+	): Def<{ [K in keyof T]: Static<T[K]> }>;
+	export function Tuple<T extends Array<Def<unknown>>>(
+		options: { exhaustive: boolean },
+		tuple: T,
+	): Def<{ [K in keyof T]: Static<T[K]> }>;
+	export function IntoTagged<Tag, T>(innerDef: Def<T>, tag: Tag): Def<{ __tag: Tag; value: T }>;
+	export function IntoString<T>(innerDef: Def<T>): Def<string>;
+	export function IntoNumber<T>(innerDef: Def<T>, base?: number): Def<number>;
+	export function IntoDefault<T>(innerDef: Def<T>, defaultValue: NonNullable<T>): Def<NonNullable<T>>;
+	export function Retype<T>(def: Def<any>): Def<T>;
+	export function Untyped<T>(def: Def<T>): Def<any>;
+	export function Nicknamed<T>(innerDef: Def<T>, newName: string): Def<T>;
+	export function CastOrError<T>(def: Def<T>, x: unknown): T;
+
+	export const Unknown: Def<unknown>;
+	export const Never: Def<never>;
+
+	export const Number: Def<number>;
+	export const Boolean: Def<boolean>;
+	export const String: Def<string>;
+	export const Thread: Def<thread>;
+	export const Table: Def<object>;
+	export const Function: Def<(...args: unknown[]) => unknown>;
+
+	export const True: Def<true>;
+	export const False: Def<false>;
+	export const Nil: Def<undefined>;
+}
+
+export = ty;
+export as namespace ty;

package/src/init.luau

@@ -0,0 +1,73 @@
+--!strict
+--!nolint LocalShadow
+-- ty (Elttob Suite monorepo edition - no static types)
+-- (c) Daniel P H Fox, licensed under MIT
+
+local Package = script.Parent
+local Maybe = require(Package.Maybe)
+
+local Types = require(Package.ty.Types)
+local Def = require(Package.ty.Def)
+
+export type Def = Types.Def
+export type Constants = Types.Constants
+export type Methods = Types.Methods
+export type Optional = Types.Optional
+export type Or = Types.Or
+export type And = Types.And
+export type MapOf = Types.MapOf
+export type Array = Types.Array
+export type Struct = Types.Struct
+export type IntoTagged = Types.IntoTagged
+
+-- TODO: need methods to limit table size and depth
+-- TODO: need methods to handle cyclic data
+local methods: Types.Methods = {
+	Predicate = require(Package.ty.Functions.Predicate),
+	Typeof = require(Package.ty.Functions.Typeof),
+	Just = require(Package.ty.Functions.Just),
+	Optional = require(Package.ty.Functions.Optional),
+	IgnoreInvalid = require(Package.ty.Functions.IgnoreInvalid),
+	Or = require(Package.ty.Functions.Or),
+	And = require(Package.ty.Functions.And),
+	MapOf = require(Package.ty.Functions.MapOf),
+	Array = require(Package.ty.Functions.Array),
+	Struct = require(Package.ty.Functions.Struct),
+	Tuple = require(Package.ty.Functions.Tuple),
+	IntoTagged = require(Package.ty.Functions.IntoTagged),
+	IntoString = require(Package.ty.Functions.IntoString),
+	IntoNumber = require(Package.ty.Functions.IntoNumber),
+	IntoDefault = require(Package.ty.Functions.IntoDefault),
+	Retype = require(Package.ty.Functions.Retype),
+	Untyped = require(Package.ty.Functions.Untyped),
+	Nicknamed = require(Package.ty.Functions.Nicknamed),
+	CastOrError = require(Package.ty.Functions.CastOrError)
+}
+Def.methodMeta.__index = methods
+
+local constants: Types.Constants = {
+	Unknown = Def.new(
+		"unknown",
+		function(self, x) return true end,
+		function(self, x) return Maybe.Some(x) end
+	),
+	Never = Def.new(
+		"never",
+		function(self, x) return false end,
+		function(self, x) return Maybe.None(self.NotOfTypeError) end
+	),
+
+	Number = methods.Typeof("number"),
+	Boolean = methods.Typeof("boolean"),
+	String = methods.Typeof("string"),
+	Thread = methods.Typeof("thread"),
+	Table = methods.Typeof("table"),
+	Function = methods.Typeof("function"),
+	
+	True = methods.Just(true) :: any,
+	False = methods.Just(false) :: any,
+	Nil = methods.Just(nil)
+}
+
+local ty: Types.Methods & Types.Constants = setmetatable(constants, Def.methodMeta) :: any
+return ty