[hansvm]

It'd be a bit gnarly, but somebody could absolutely write a utility capable of providing those features in the userspace of the language:

1. Documented Interface: Documentation would be a struct with the desired function declarations (combined with some type-checking, I spit-balled an idea for that recently [0]).

2. Default Function Implementations: The exact tool you'll use will vary since the language hasn't hit 1.0, but a `pub usingnamespace FakeInheritanceFooBarBaz(TheTrait, @This());` could have the desired effect.

3. Stored in other structs: Rust doesn't even really give you this. It has syntactic sugar to make the dynamic case easier, and it has the ability to store concrete implementations. For the latter, Zig just works. For the former, you want something that automagically wraps any trait-conforming object in a dynamic pointer-based structure. That's a weak point in the language since the metaprogramming facilities for creating functions and for creating objects with decls aren't very solid (that will get fixed by 1.0). You could make do for now by using comptime fields instead of decls in the wrapper logic that generates this thing (think `foo: fn (A) B` instead of `fn foo(A) B {}`), and that generation code would have to handle different argument counts by hand.

4. Monomorphization: You'd get that for free, since this is just ordinary comptime duck-typing.

5. Dynamic (runtime dispatch: This is really identical to the work for (3).

[0] https://news.ycombinator.com/item?id=42899354

[josephg]

I followed 80% of what you've said, but not all of it. I'd love to read a sketch of this in code.

How would you clean up Writer in std?

[hansvm]

I'll try to put together a PoC a little later. I won't have time till at least this evening though, maybe later.

[hansvm]

It's a very nontrivial amount of code to make the library that provides all of those features, even worse to do it well. Here's a PoC for one of them [0] (default implementations).

The broad theme is that other languages use keywords for traits or subclasses or whatever. In Zig, you can define libraries using the language's metapgrogramming facilities that do the same thing (or similar things).

Zig doesn't have a complete metaprogramming story yet either, which makes it harder (no custom types with custom decls, can't create a function dynamically, ...), but there are still a few options for creating something that looks like an interface.

In my mind, all the obvious solutions have something like a "template" and utilities that operate on that template. The template serves as documentation and also a hint to the LSP. Its exact semantics aren't important; they just have to match however that library decides the implementation should look.

[0] https://github.com/hmusgrave/zinter

[josephg]

Awesome! Nice work. I’m still astounded by what you can pull off with comptime.

[hansvm]

Comptime is amazing. It's a new language, but I'm excited. I got my team excited too, for some fantastic benefits at work.