How to use types as values in Rust? / Metatypes

Question

I’m working on the database component of my app. The idea is to describe objects using a Record structure which stores an identifier for fetching the object, and also specifies the object type.

struct Record<'a, Object> {
    id: &'a str
    // TODO: another field for the object type?
}

Record should not store the object itself—just its type. A RecordFetcher would then use this information to retrieve an object from the database and cast it to the specified type.

trait RecordFetcher {
    fn fetch_object_for_record<Object>(record: Record<Object>) -> Option<Object>;
}

The Rust compiler refuses to build this code because of the unused generic parameter in Record’s declaration, and I’m confused about how to include this information in the structure.

1 | struct Record<'a, Object> {
  |                   ^^^^^^ unused parameter
  |
  = help: consider removing `Object`, referring to it in a field, or using a marker such as `PhantomData`
  = help: if you intended `Object` to be a const parameter, use `const Object: usize` instead

I mostly work with Swift, so here’s a functioning example of what I’m trying to achieve. Object.Type here is a metatype: it specifies the type without requiring an instance of it.

struct Record<Object> {
    let id: String
    let objectType: Object.Type // <- metatype
}

protocol RecordFetcher {
    func fetchObject<Object>(for record: Record<Object>) -> Object?
}

Is there a way to achieve the same result in Rust?

To convince the compiler that you use `Object` you can add a marker field to your struct, `_object: std::marker::PhantomData<*const Object>`. But note that type information in Rust is mostly erased at compile time; types don't have a "metatype" value in Rust. — cdhowie, Apr 07 '22 at 19:11
I suggest taking a look at the `redis` crate for an example of a strongly typed interface to a database that can store different kinds of values. — Sven Marnach, Apr 07 '22 at 20:04
@cdhowie This marker is not a good idea: it makes the struct `!Send+!Sync`. Better to use `fn(Object)` (or `fn(Object) -> Object` for invariance). — Chayim Friedman, Apr 07 '22 at 22:04
I'm a little confused by your idea. How do you want to cast it to this type? And why do you need the type as string if your method already have access to it as a generic parameter? — Chayim Friedman, Apr 07 '22 at 22:06
@ChayimFriedman My suggestion comes directly from the `PhantomData` docs: _"If your struct does not in fact own the data of type `T`, it is better to use a reference type, like `PhantomData<&'a T>` (ideally) or `PhantomData<*const T>` (if no lifetime applies), so as not to indicate ownership."_ Maybe this advice in the docs should be changed then... — cdhowie, Apr 08 '22 at 04:16
Yes, it should, but I'm not surprised this is the advice: I myself have learnt that only few days ago. — Chayim Friedman, Apr 08 '22 at 05:12

at54321 · Answer 1 · 2022-04-07T19:55:53.033

0

In Rust typically you can utilize enums for this. A good example is serde_json's Value enum type. Another similar example would be mysql's Value enum type. In Rust each enum variant can have associated data of an arbitrary data type. So enums allow you to solve the problem with different types for the ID (in case you do not always have string IDs) or the value itself. That doesn't give you all you ask for though, only part of the solution.

Rust doesn't have reflection (read this), so I'm not aware of an easy, automated way to achieve the mapping between an object type and an enum variant (holding the actual object value).

edited Apr 07 '22 at 19:55

answered Apr 07 '22 at 19:42

at54321

8,726
26
46

Both crates you mention support two types of interfaces: One with a `Value` type which is kind of dynamically typed, since at copile time we don't know what variant is used The other interface uses static types, e.g. you can write something like `let my_typed_value: serde_json:Result = serde_json::from_str(data);`, and there is something similar in the `mysql` crate. My understanding of the question is that the OP is looking for this kind of strongly typed interface rather than the enum. – Sven Marnach Apr 07 '22 at 20:02

score 0 · Answer 2 · answered Apr 07 '22 at 20:38

You don't actually have to store the type in the Record struct. You can write

struct Record<'a> {
    id: &'a str
}

trait RecordFetcher {
    fn fetch_object_for_record<Object>(record: Record<'_>) -> Option<Object>;
}

But if you do want to make Record generic over the object's type, your question is actually answered by the error message: Use PhantomData.

struct Record<'a, Object> {
    id: &'a str
    _type: PhantomData<Object>,
}

Rust doesn't have metatypes or any other form of runtime reflection. But it does have a very powerful trait system, so you probably don't need reflection anyway.

However, I'm wondering why you need to implement this in the first place. Crates for accessing a database usually already have type-safe abstractions that you can use. What crate are you using?

This marker is not a good idea: it makes the struct `!Send+!Sync` if `Object` isn't. Better to use `fn(Object)` (or `fn(Object) -> Object` for invariance). — Chayim Friedman, Apr 07 '22 at 22:05
In this case, probably `fn() -> Object` would be more correct (since the struct's job is to create `Object`s from some external source). — Cerberus, Apr 08 '22 at 01:03

How to use types as values in Rust? / Metatypes

2 Answers2