[Feature Request] Interfaces and Implementors

The current class system is alright, but imagine this: I have a Stream class which is extended by ReadStream, WriteStream, SeekableStream, etc.

---@class Stream
---@field close fun() Deallocates or hangs up a stream.

---@class SeekableStream: Stream
---@field seek fun(whence: SeekWhence, offset: integer): integer

---@class ReadStream: Stream
---@field read fun(self: ReadStream, length: integer): string|nil

---@class WriteStream: Stream
---@field write fun(data: string): integer

---@class StringStream: ReadStream, SeekableStream Streams data out of a string.

Now I have a function which takes any Seekable, Readable string. How do I specify this? Either we need a conjunction type (ReadStream & SeekableStream, which has keys from both), or we need (preferably) interfaces, which are generic and can be extended by classes. The reason I suggest interfaces is because if I write this:

---@param length integer
---@return string|nil
function StringStream:read(length)
	if self.buffer == nil then
		error("Stream is closed", 2)
	end
	if self.cursor > #self.buffer then
		return nil
	end
	local out = string.sub(self.buffer, self.cursor, math.min(#self.buffer, self.cursor + length))
	self.cursor = self.cursor + #out
	return out
end

and I omit the type annotation, it assumes read is already defined because StringStream extends ReadStream, and it doesn't validate types (arguments and return type are any).

Beginne mit dem im Issue beschriebenen Verhalten bei Klassenvererbung und Typannotationen, einschließlich der Beispiele für Stream, ReadStream, SeekableStream und StringStream. Vergleiche die vorgeschlagenen Ansätze mit einem Konjunktionstyp und mit Interfaces und überprüfe anschließend, dass geerbte Methodenannotationen Argumente und Rückgabetypen weiterhin validieren, wenn Implementierungen keine eigenen Annotationen enthalten.