How do I handle instancing with interfaces

[Hedwig7s]

I am using the library "middleclass" for classes
One of the things middleclass does is create an instance metatable that does not contain all class methods (like new) and also has some differences (like instance.class)
The issue is that to declare an instance method you declare it on the class (class:xyz())
Since the class and instance don't inherently have the same values they have different types, but the class shares some methods
Is there a way to type this without having to make a type for every single instance function and declare them in both types?

[catwell]

For what it's worth, reading the conversations I thought the same. The docs say interfaces can be used with object libraries but do not demonstrate how.

I don't use those libraries personally but I think middleclass is be the most popular (confirmed by this) so it could be nice to have an example using it in the doc.

[alerque]

Your search doesn't turn up Penlight at all, the class model is has being probably at least as widely used as middleclass of not more. Not a diss on middleclass which I think is maybe more complete and robust, just saying that search doesn't prove much. A couple different examples are probably in order.

[catwell]

True, Penlight can be used as an example as well!

[Hedwig7s]

Unfortunately the main solution I can think to this is type intersection but that's already been said to not be desirable because of edge cases

[Hedwig7s]

I've left a comment on this under #120

[hishamhm]

To be honest, "bad excuse" is an unnecessary dig. I gave my reasons there, but I don't need to give excuses; I don't owe anyone anything. Language design is ultimately a matter of weighing pros and cons and it comes down to the designer to pick a balance (and also to the implementer, which in this case happens to be me as well). I gave my explanation there. I know my choices won't make everyone happy all the time. But I also won't spend the little time I have for development arguing to defend them. I do listen to feedback, I do change my mind and I want to make the language useful. But I will not spend time on every feature request explaining why I'm not adding it, or critiquing the designs that people suggest -- if you look at the GitHub issues page, most of the items are feature requests, by a large margin; it could easily consume all of my time.

Also, maybe you don't care about edge cases and I do because when users hit the edge cases, it is to me that they will complain about (with "bug" issues, and not "feature request" ones), and not to you. :)

Sorry about the rant — but edge cases are not an "excuse"; 90% of language design is dealing with edge cases.

This overall thread raises a valid point, which I will address in a separate comment.

[hishamhm]

The addition of interfaces does not make the operation of Lua OOP models seamless in Teal, but it aims to alleviate the existing difficulties by allowing for the representation of subtyping relations and for the inheritance of interfaces (but not inheritance of implementations).

The docs say interfaces can be used with object libraries but do not demonstrate how.

I'm wondering if the summary in the changelog has oversold the feature. I believe it does make working with object models better than it was before (when you had to effectively cast everything all the time), but I'm sure the existing libraries will always have some inherently dynamic constructor functions which will still require casting.

I don't use those libraries personally but I think middleclass is be the most popular (confirmed by this) so it could be nice to have an example using it in the doc.

I'm reluctant about promoting one class model above others in the docs, but it would be nice to have such examples indeed. Perhaps a community repository?

Since the class and instance don't inherently have the same values they have different types, but the class shares some methods
Is there a way to type this without having to make a type for every single instance function and declare them in both types?

I'm not sure I understood the question! @Hedwig7s could you post a complete small example of how you're using middleclass now in Lua so we could discuss here what the Teal notation would look like?

[Hedwig7s]

Since I've got the answer here's it typed in teal:

local class = require("middleclass") -- Treat it as function(name:string): Class
local interface InstFunctions
    foo: function(self:ExampleInstance, a:number): number
end
local record ExampleClass is class.Class, InstFunctions where self.name == "Example"
    initialize: function(self:ExampleInstance, a:number) -- If there is a way to do this without duplicating parameters twice I'd love to know
    new: function(self:ExampleClass, a:number): ExampleInstance
end
local record ExampleInstance is class.Instance, InstFunctions where self.class.name == "Example"
    a: number
end
local exampleClass = class("Example") as ExampleClass
function exampleClass.initialize(self:ExampleInstance, a:number) -- Kinda sucks not being able to use x:y() but oh well
    self.a = a
end
function exampleClass.foo(self: ExampleInstance, a:number): number
    return a*self.a
end

local inst = exampleClass:new(5)
print(inst:foo(10)) -- 50

[hishamhm]

Thanks!

I got this example typechecking and running by using this minimal stub of a middleclass.d.tl:

local record middleclass
   interface Class
      name: string
   end

   interface Instance
      class: Class
   end

   metamethod __call: function(self, string): Class
end

return middleclass

Regarding your two -- comments, a tricky thing on the definition of initialize that causes things to be more verbose there is that the of the first "self" argument (ExampleInstance) is not the type of the record the definition lives in (ExampleClass).

[Hedwig7s]

That's the thing new takes initialize's arguments and calls it with a fresh instance
Only way to resolve it without compromise (like a table for args) would be some form of argument concatenation (like typescript tuple)
As for the second one it probably makes more idiomatic sense since you know that self isn't the class

[Hedwig7s]

Figured it out can do it like this:

local interface InstanceFunctions
    a: function(self:Instance, a:string)
end
local record Class is middleclass.Class, InstanceFunctions -- Example middleclass Class type
    initialize: function(a:number)
end
local record Instance is middleclass.Instance, InstanceFunctions
    b: number
end