What is the difference between unknown and any types?

[lua-rocks]

I didn't find the answer to this question on the wiki.

[carsakiller]

Assuming it is intended to mirror TypeScript:

any is a value that is permitted to be anything; number, boolean, table, function - anything. It is often considered bad practice to label something as any because it is then allowed to be whatever, and type checking will pretty much just ignore it, not providing any warnings - because again, it is allowed to be any.

---@param x any
local function double(x)
  return x * 2
  -- this is fine for a number, but what if someone passed in a boolean?
  -- you would receive a runtime error, but type checking won't warn you because x is
  -- annotated as accepting any type
end

I think the unknown type is relatively new to the LSP, but in TypeScript it is used when the type is... unknown. It shouldn't just be any(thing), because that is too permissive and defeats the purpose of type checking, but we also aren't sure what it might be. This allows type checking to warn you "hey, you don't know what this is" so that you can confirm what the type of the item is before you end up with a runtime error 🙂. This could be done like this:

---@type unknown
local x

-- We aren't sure what `x` is...
if type(x) == "string" then
  print("Now I am positive that x is a string")
end

Again, this is using my knowledge from TypeScript, and it appears that the LSP currently does not have the same functionality. For example, In the example for any, the return value is reported as integer, even though we can't be sure of that. It also doesn't seem to yet warn when performing math operations on an unknown, which could lead to runtime errors.

I think there is still a lot of work to do with type narrowing and type checking in order to get unknown and any to be more useful and work as they do with TypeScript.

[lua-rocks]

Thank you, @carsakiller! The first thing that occurred to me is that any is lazy unknown, i.e. in the case of any you don't need to cast types using the @as annotation, and unknown theoretically should be less convenient but more accurate.

Although in practice this is not true. This code has no errors:

---@param x any
local function a(x)
  return x * 2
end

---@param x unknown
local function u(x)
  return x * 2
end

print(a(u(1)))

So I still don't understand in what situations I should use any and in what situations unknown.

[carsakiller]

The current implementation in the LSP is lacking in my opinion, but I think they can still be used as they are in TypeScript. Hopefully the LSP will continue to improve and will leverage unknown better. I think we can use them like this:

• any is a simple "shhhh" for the type checker and a bad practice, as it means "anything goes".
• unknown would then be used when you cannot guarantee the type of something, and it should be verified before acting on it.