Currently, D offers fine grained overloading for most of the
unary and arithmetic binary operators, but at some point a
decision was made to lump together all of the relational
operators (and if necessary, the equality operators) into a
single function `opCmp`.
And while it does add a lot of convenience and consistency to how
operators behave, it does also put a lot of limitations on what
they can do.
For example, it's not currently possible to implement comparison
operators that would behave lazily and only compute a certain
value once a function call forces the computation.
Similarly, it's not possible to construct a DSL that would
produce code or a query in another language, by returning values
behave like AST nodes rather than actually performing a
comparison.
ie.
table.users
.where!((users) => users.joined_on >= 3.days.ago)
.joins(table.posts)
.on!((posts, users) => posts.user_id == users.id)
.limit(10)
.toSql;
It's a little odd to me that D puts so little focus on DSLs,
since language features like template constraints, `opDispatch`,
and even the fact that binary operators are overloadable via a
single templated function are all very useful tools for
implementing them.
So, I'm just interested in other people's thoughts are on the
subject, and whether there are any plans to allow overloading
these operators separately.
