improve standard library types

Author: CapsAdmin

nattlua/definitions/lua/io.nlua

@@ -26,7 +26,7 @@ type File = {
 	close = function=(self)>(boolean | nil, string, number | nil),
 	write = function=(self, ...(number | string))>(self | nil, string | nil),
 	flush = function=(self)>(boolean | nil, string | nil),
-	read = function <|self: File, ...: ...any|>
+	read = function <|self: File, ...: ...$"%**[Lanl].*" | number|>
 		return check_read_args<|...|>
 	end,
 	lines = function=(self)>(Function),
@@ -36,22 +36,11 @@ type File = {
 type io.open = function=(string, string | nil)>(nil | File)
 type io.popen = function=(string, string | nil)>(nil | File)
 type io.output = function=()>(File)
+type io.type = function=(File)>("file" | "closed file" | nil)
 type io.stdout = File
 type io.stdin = File
 type io.stderr = File
 
-analyzer function io.type(obj: any)
-	local flags = types.Union()
-	flags:AddType(types.ConstString("file"))
-	flags:AddType(types.ConstString("closed file"))
-	print(("%p"):format(obj), ("%p"):format(env.typesystem.File))
-
-	if false and obj:IsSubsetOf(env.typesystem.File) then return flags end
-
-	flags:AddType(types.Nil())
-	return flags
-end
-
 analyzer function io.write(...: ...string)
 	for i, v in ipairs({...}) do
 		if not v:IsLiteral() then return end

nattlua/definitions/lua/math.nlua

@@ -1,109 +1,189 @@
 type math = {
-	ceil = function=(x: number)>(number),
-	tan = function=(x: number)>(number),
-	log10 = function=(x: number)>(number),
-	sinh = function=(x: number)>(number),
-	ldexp = function=(m: number, e: number)>(number),
-	tointeger = function=(x: number)>(number),
-	cosh = function=(x: number)>(number),
-	min = function=(x: number, ...)>(number),
-	fmod = function=(x: number, y: number)>(number),
-	exp = function=(x: number)>(number),
-	random = function=(m: number, n: number)>(number) | function=(m: number)>(number) | function=()>(number),
-	rad = function=(x: number)>(number),
-	log = function=(x: number, base: number)>(number) | function=(x: number)>(number),
-	cos = function=(x: number)>(number),
-	randomseed = function=(x: number)>(nil),
-	floor = function=(x: number)>(number),
-	tanh = function=(x: number)>(number),
-	max = function=(x: number, ...)>(number),
-	pow = function=(x: number, y: number)>(number),
-	ult = function=(m: number, n: number)>(boolean),
-	acos = function=(x: number)>(number),
-	type = function=(x: number)>(string),
-	abs = function=(x: number)>(number),
-	frexp = function=(x: number)>(number, number),
-	deg = function=(x: number)>(number),
-	modf = function=(x: number)>(number, number),
-	atan2 = function=(y: number, x: number)>(number),
-	asin = function=(x: number)>(number),
-	atan = function=(x: number)>(number),
-	sqrt = function=(x: number)>(number),
-	sin = function=(x: number)>(number),
+	huge = inf,
+	pi = 3.14159265358979323864338327950288,
+	maxinteger = 0x7FFFFFFFFFFFFFFF,
+	mininteger = 0x8000000000000000,
 }
-type math.huge = inf
-type math.pi = 3.14159265358979323864338327950288
-type math.maxinteger = 0x7FFFFFFFFFFFFFFF
-type math.mininteger = 0x8000000000000000
 type math.type = ReturnIfNonLiteral<|analyzer function(n: number): "float" | "integer" | "nil"
 	return "float"
 end|>
-type math.sin = ReturnIfNonLiteral<|analyzer function(n: number): number
-	return math.sin(n:GetData())
-end|>
-type math.abs = ReturnIfNonLiteral<|analyzer function(n: number): number
-	return math.abs(n:GetData())
-end|>
-type math.cos = ReturnIfNonLiteral<|analyzer function(n: number): number
-	return math.cos(n:GetData())
-end|>
-type math.ceil = ReturnIfNonLiteral<|analyzer function(n: number): number
-	return math.ceil(n:GetData())
-end|>
-type math.floor = ReturnIfNonLiteral<|analyzer function(n: number): number
-	return math.floor(n:GetData())
-end|>
 
-analyzer function math.min(...: ...number)
-	local numbers = {}
+do -- basic arithmetic functions
+	type math.abs = ReturnIfNonLiteral<|analyzer function(n: number): number
+		return math.abs(n:GetData())
+	end|>
+	type math.ceil = ReturnIfNonLiteral<|analyzer function(n: number): number
+		return math.ceil(n:GetData())
+	end|>
+	type math.floor = ReturnIfNonLiteral<|analyzer function(n: number): number
+		return math.floor(n:GetData())
+	end|>
 
-	for i = 1, select("#", ...) do
-		local obj = select(i, ...)
+	analyzer function math.min(...: ...number)
+		local numbers = {}
 
-		if not obj:IsLiteral() then
-			return types.Number()
-		else
-			numbers[i] = obj:GetData()
+		for i = 1, select("#", ...) do
+			local obj = select(i, ...)
+
+			if not obj:IsLiteral() then
+				return types.Number()
+			else
+				numbers[i] = obj:GetData()
+			end
 		end
+
+		return math.min(table.unpack(numbers))
 	end
 
-	return math.min(table.unpack(numbers))
+	analyzer function math.max(...: ...number)
+		local numbers = {}
+
+		for i = 1, select("#", ...) do
+			local obj = select(i, ...)
+
+			if not obj:IsLiteral() then
+				return types.Number()
+			else
+				numbers[i] = obj:GetData()
+			end
+		end
+
+		return math.max(table.unpack(numbers))
+	end
 end
 
-analyzer function math.max(...: ...number)
-	local numbers = {}
+do -- trigonometric functions
+	type math.sin = ReturnIfNonLiteral<|analyzer function(n: number): number
+		return math.sin(n:GetData())
+	end|>
+	type math.cos = ReturnIfNonLiteral<|analyzer function(n: number): number
+		return math.cos(n:GetData())
+	end|>
+	type math.tan = ReturnIfNonLiteral<|analyzer function(n: number): number
+		return math.tan(n:GetData())
+	end|>
+	type math.acos = ReturnIfNonLiteral<|analyzer function(n: number): number
+		return math.acos(n:GetData())
+	end|>
+	type math.asin = ReturnIfNonLiteral<|analyzer function(n: number): number
+		return math.asin(n:GetData())
+	end|>
+	type math.atan = ReturnIfNonLiteral<|analyzer function(n: number): number
+		return math.atan(n:GetData())
+	end|>
+	type math.atan2 = ReturnIfNonLiteral<|
+		analyzer function(y: number, x: number): number
+			return math.atan2(y:GetData(), x:GetData())
+		end
+	|>
+end
 
-	for i = 1, select("#", ...) do
-		local obj = select(i, ...)
+do -- hyperbolic functions
+	type math.sinh = ReturnIfNonLiteral<|analyzer function(n: number): number
+		return math.sinh(n:GetData())
+	end|>
+	type math.cosh = ReturnIfNonLiteral<|analyzer function(n: number): number
+		return math.cosh(n:GetData())
+	end|>
+	type math.tanh = ReturnIfNonLiteral<|analyzer function(n: number): number
+		return math.tanh(n:GetData())
+	end|>
+end
 
-		if not obj:IsLiteral() then
-			return types.Number()
+do -- logarithmic and exponential functions
+	type math.log10 = ReturnIfNonLiteral<|analyzer function(n: number): number
+		return math.log10(n:GetData())
+	end|>
+	type math.exp = ReturnIfNonLiteral<|analyzer function(n: number): number
+		return math.exp(n:GetData())
+	end|>
+	type math.sqrt = ReturnIfNonLiteral<|analyzer function(n: number): number
+		return math.sqrt(n:GetData())
+	end|>
+	type math.pow = ReturnIfNonLiteral<|
+		analyzer function(x: number, y: number): number
+			return math.pow(x:GetData(), y:GetData())
+		end
+	|>
+
+	analyzer function math.log(x: number, base: nil | number)
+		if not x:IsLiteral() then return types.Number() end
+
+		if base then
+			if not base:IsLiteral() then return types.Number() end
+
+			return math.log(x:GetData(), base:GetData())
 		else
-			numbers[i] = obj:GetData()
+			return math.log(x:GetData())
 		end
 	end
+end
+
+do -- number manipulation functions
+	type math.fmod = ReturnIfNonLiteral<|
+		analyzer function(x: number, y: number): number
+			return math.fmod(x:GetData(), y:GetData())
+		end
+	|>
+	type math.ldexp = ReturnIfNonLiteral<|
+		analyzer function(m: number, e: number): number
+			return math.ldexp(m:GetData(), e:GetData())
+		end
+	|>
+	type math.frexp = ReturnIfNonLiteral<|
+		analyzer function(x: number): number,number
+			local m, e = math.frexp(x:GetData())
+			return m, e
+		end
+	|>
+	type math.modf = ReturnIfNonLiteral<|
+		analyzer function(x: number): number,number
+			local i, f = math.modf(x:GetData())
+			return i, f
+		end
+	|>
+end
 
-	return math.max(table.unpack(numbers))
+do -- angle conversion functions
+	type math.deg = ReturnIfNonLiteral<|analyzer function(x: number): number
+		return math.deg(x:GetData())
+	end|>
+	type math.rad = ReturnIfNonLiteral<|analyzer function(x: number): number
+		return math.rad(x:GetData())
+	end|>
 end
 
-analyzer function math.random(n: nil | number, m: nil | number)
-	if not analyzer.enable_random_functions then
-		if n and n:IsLiteral() and m and m:IsLiteral() then
-			return types.LNumberRange(n:GetData(), m:GetData())
+do -- integer functions
+	type math.tointeger = ReturnIfNonLiteral<|analyzer function(x: number): number
+		return math.tointeger(x:GetData())
+	end|>
+	type math.ult = ReturnIfNonLiteral<|
+		analyzer function(m: number, n: number): boolean
+			return math.ult(m:GetData(), n:GetData())
 		end
+	|>
+end
 
-		return types.Number()
-	end
+do -- random functions
+	analyzer function math.random(n: nil | number, m: nil | number)
+		if not analyzer.enable_random_functions then
+			if n and n:IsLiteral() and m and m:IsLiteral() then
+				return types.LNumberRange(n:GetData(), m:GetData())
+			end
 
-	if n and m then return math.random(n:GetData(), m:GetData()) end
+			return types.Number()
+		end
 
-	if n then return math.random(n and n:GetData()) end
+		if n and m then return math.random(n:GetData(), m:GetData()) end
 
-	return math.random()
-end
+		if n then return math.random(n:GetData()) end
+
+		return math.random()
+	end
 
-analyzer function math.randomseed(n: number)
-	if not analyzer.enable_random_functions then return end
+	analyzer function math.randomseed(n: number)
+		if not analyzer.enable_random_functions then return end
 
-	return math.randomseed(n:GetData())
+		return math.randomseed(n:GetData())
+	end
 end

nattlua/definitions/lua/os.nlua

@@ -1,13 +1,38 @@
+local type DateStruct = {
+	year = number,
+	month = number,
+	day = number,
+	hour = number,
+	min = number,
+	sec = number,
+	wday = number,
+	yday = number,
+	isdst = boolean,
+}
 type os = {
 	execute = function=(command: string)>(boolean | nil, string, number | nil) | function=()>(boolean | nil, string, number | nil),
 	rename = function=(oldname: string, newname: string)>(boolean | nil, string, number | nil),
 	getenv = function=(varname: string)>(string | nil),
-	difftime = function=(t2: number, t1: number)>(number),
 	exit = function=(code: boolean | number, close: boolean)>(nil) | function=(code: boolean | number)>(nil) | function=()>(nil),
 	remove = function=(filename: string)>(boolean | nil, string, number | nil),
-	setlocale = function=(local_e: string, category: string)>(string | nil) | function=(local_e: string)>(string | nil),
-	date = function=(format: string, time: number)>(string | Table) | function=(format: string)>(string | Table) | function=()>(string | Table),
-	time = function=(table: Table)>(number) | function=()>(number),
-	clock = function=()>(number),
+	setlocale = function=(locale: string, category: string)>(string | nil) | function=(locale: string)>(string | nil),
+	date = function=(format: "*t", time: number)>(DateStruct) | function=(format: "*t")>(DateStruct) | function=(format: string, time: number)>(string) | function=(format: string)>(string) | function=()>(string),
+	time = function=(date_table: DateStruct)>(number) | function=()>(number),
 	tmpname = function=()>(string),
 }
+
+do -- Simple functions using ReturnIfNonLiteral
+	type os.clock = ReturnIfNonLiteral<|analyzer function(): number
+		return os.clock()
+	end|>
+	type os.difftime = ReturnIfNonLiteral<|
+		analyzer function(t2: number, t1: number): number
+			return t2:GetData() - t1:GetData()
+		end
+	|>
+	type os.tmpname = ReturnIfNonLiteral<|
+		analyzer function(): string
+			return "/tmp/lua_" .. tostring(math.random(100000, 999999))
+		end
+	|>
+end