Would it be prudent to make Templates be able to be used without
parameters? (Or something along those lines) Consider the
following:
struct Foo1 {
string name = "Foo1";
alias Unsafe!() unsafe;
template Unsafe() {
string name = "Bar";
void bar() {
writeln(this.name, name);
}
}
}
struct Foo2 {
string name = "Foo2";
string unsafe_name = "Bar";
void unsafe_bar() {
writeln(name, unsafe_name);
}
}
void main() {
auto foo1 = Foo1();
auto foo2 = Foo2();
foo1.Unsafe!().bar(); // ugly
foo1.unsafe.bar(); // nice
foo2.unsafe_bar(); // classic
}
The classic way works, or course, but it's not as pretty :)
I may be breaking some sacred rule of OOP here, but I think this
kind of classification comes in handy. In fact, I think D's the
only language that actually allows for this syntax without
increasing an objects memory footprints.
It could be *useful* in situations where you want to
simplistically wrap a complex system, say X11, and provide _a
few_ convenience functions, while still providing complete access
to X11 objects, but grouping them into logical subsection.
Example:
class Window {
private XDisplay* _display;
void create(...) { /* use _display; */ }
void delete(...) { /* ditto */ }
template X11 {
@property auto display() { return _display; }
}
}
The only thing that erks me is the name "template" doesn't really
match it's function at this point. Maybe something like "alias
template" would make more sense:
alias template X11 { ... }
idk. What are peoples thoughts on this? Good? Bad? Ugly?
