One question:
Do you only want to retrieve the exact type that was passed in, or would
you want to be able to extract an impl that matches the type actually
contained ?
The latter is more difficult to implement (dynamic_cast goes through hoops
to check those things), but it is doable if sufficient information is
encoded in the v-table.
On Fri, Aug 23, 2013 at 5:04 PM, Oren Ben-Kiki <o...@ben-kiki.org> wrote:
> Yes, this would be similar to the `Typeable` type class in Haskell. It
> queries the vtable-equivalent, which contains stuff like the name of the
> type and allows doing `typeof(x)`, dynamic casts, etc. This is heavily
> magical (that is, depends on the hidden internal representation) and
> properly belongs in the standard platform and not in a user-level library.
>
>
> On Fri, Aug 23, 2013 at 4:40 PM, Niko Matsakis <n...@alum.mit.edu> wrote:
>
>> Currently, this is not directly supported, though downcasting in
>> general is something we have contemplated as a feature. It might be
>> possible to create some kind of horrible hack based on objects. A
>> trait like:
>>
>> trait Dynamic { }
>> impl<T> Dynamic for T { }
>>
>> would allow any value to be cast to an object. The type descriptor can
>> then be extracted from the vtable of the object using some rather
>> fragile unsafe code that will doubtless break when we change the
>> vtable format. The real question is what you can do with the type
>> descriptor; they are not canonicalized, after all. Still, it's
>> ... very close. This is basically how dynamic downcasting would work,
>> in any case.
>>
>>
>> Niko
>>
>> On Fri, Aug 23, 2013 at 07:49:57AM +0300, Oren Ben-Kiki wrote:
>> > Is it possible to implement something like Haskell's Dynamic value
>> holder
>> > in Rust? (This would be similar to supporting C++'s dynamic_cast).
>> > Basically, something like this:
>> >
>> > pub struct Dynamic { ... }
>> > impl Dynamic {
>> > pub fn put(value: ~T) { ... }
>> > pub fn get() -> Option<T> { ... }
>> > }
>> >
>> > I guess this would require unsafe code... even so, it seems to me that
>> Rust
>> > pointers don't carry sufficient meta-data for the above to work. A
>> possible
>> > workaround would be something like:
>> >
>> > pub struct Dynamic { type_name: ~str, ... }
>> > impl Dynamic {
>> > pub fn put(type_name: &str, value: ~T) { Dynamic { type_name:
>> > type_name, ... } }
>> > pub fn get(&'a self, type_name: &str) -> Option<&'a T> {
>> > assert_eq!(type_name, self.type_name); ... } }
>> > }
>> >
>> > And placing the burden on the caller to always use the type name "int"
>> when
>> > putting or getting `int` values, etc. This would still require some
>> sort of
>> > unsafe code to cast the `~T` pointer into something and back, while
>> > ensuring that the storage for the `T` (whatever its size is) is not
>> > released until the `Dynamic` itself is.
>> >
>> > (Why do I need such a monstrosity? Well, I need it to define a
>> > `Configuration` container, which holds key/value pairs where whoever
>> sets a
>> > value knows its type, whoever gets the value should ask for the same
>> type,
>> > and the configuration can hold values of "any" type - not from a
>> predefined
>> > list of types).
>> >
>> > Is such a thing possible, and if so, how?
>> >
>> > Thanks,
>> >
>> > Oren Ben-Kiki
>>
>> > _______________________________________________
>> > Rust-dev mailing list
>> > Rust-dev@mozilla.org
>> > https://mail.mozilla.org/listinfo/rust-dev
>>
>>
>
> _______________________________________________
> Rust-dev mailing list
> Rust-dev@mozilla.org
> https://mail.mozilla.org/listinfo/rust-dev
>
>
_______________________________________________
Rust-dev mailing list
Rust-dev@mozilla.org
https://mail.mozilla.org/listinfo/rust-dev
