On 7/23/15 4:08 PM, Dicebot wrote:
On Thursday, 23 July 2015 at 19:55:30 UTC, Walter Bright wrote:
On 7/23/2015 8:03 AM, Dicebot wrote:
At the same time one HUGE deal breaker with rust traits that rarely gets
mentioned is the fact that they are both constraints and interfaces
at the same
time:
// this is template constraint, it will generate new `foo` symbol for
each new T
fn foo <T : InputRange> (range : T)
// this use the very same trait definition but creates "fat pointer"
on demand
with simplistic dispatch table
fn foo (range : InputRange)
It kills all the necessity for hacks like RangeObject and is quite a
salvation
once you get to defining dynamic shared libraries with stable ABI.
This is probably my most loved feature of Rust.
D interface types also produce the simplistic dispatch table, and if
you make them extern(C++) they don't need a RangeObject. I know it
isn't as convenient as what you describe above, but it can be pressed
into service.
I am not sure how it applies. My point was about the fact that
`isInputRange` and `InputRangeObject` are the same entities in Rust,
simply interpreted differently by compiler depending on usage context.
This is important because you normally want to design your application
in terms of template constraints and structs to get most out of inlining
and optimization. However, to define stable ABI for shared libraries,
the very same interfaces need to be wrapped in runtime polymorphism.
Closest thing in D would be to define traits as interfaces and use code
like this:
void foo(T)()
if ( (is(T == struct) || is(T == class))
&& Matches!(T, Interface)
)
{ }
where `Matches` is a template helper that statically iterates method
list of interface and looks for matching methods in T.
I could have sworn we have implementsInterface in std.traits.
However, making
it built-in feels really convenient in Rust:
- considerably less function declaration visual noise
- much better error messages: trying to use methods of T not defined by
a trait will result in compile-time error even without instantiating the
template
Yah, building stuff in does have its advantages.
Andrei
