While working on a patch I noticed that I had to write things like
_vec.len(the_vec)
instead of just the_vec.len() or len(the_vec). I don't expect us to
change this before getting a bootstrap compiler, but I decided to write
this so that we don't forget.
Having to type "_vec." is a small inconvenience since the type is
present in many lines if I then decide to switch to another structure.
More interesting maybe is if I want to write a generic function
total_length that sums the length of every element in a vector. How
would that be done in rust? Something like
----------------------
fn total_length[t](vec[t] v) -> int {
auto total = 0u;
for (e in v) {
total += e.len();
}
ret total;
}
---------------------
I suppose. But then, how do I pass a vector of vectors of integers? I
would have to create a wrapper like
obj vec_with_length(vec[int] x) {
fn len() -> uint {
ret _vec.len(x);
}
}
Might not look like a big issue, but it involves creating a new object
which unless I am mistaken can have exactly the same representation as
the original one.
Since, unlike java or c++, in rust we need a vtable per implemented
interface, there wouldn't be much to be lost by dropping the requirement
that all functions in the vtable be declared in one place.
One way to do this is something like go where methods are declared out
of objects:
obj foo(int state);
method bar(foo @this) {...}
...
auto x = foo(4)
x.bar()... // or bar(x), but that looks a bit more confusing to me.
and a user can then easily declare a 'zed' method that can be used where
it would normally be in context:
import ...foo;
mod x {
method zed(foo @this) {...}
....
auto y = foo();
y.zed(); // OK
...
}
...
auto y = foo();
y.zed(); // not OK, no method zed found.
Comments?
Cheers,
Rafael
_______________________________________________
Rust-dev mailing list
[email protected]
https://mail.mozilla.org/listinfo/rust-dev
