Skip to content

Instantly share code, notes, and snippets.

What would you like to do?
Field offsets RFC
  • Start Date: 2014-07-21
  • RFC PR #: (leave this empty)
  • Rust Issue #: (leave this empty)


This adds the ability to refer to fields of types and use them later on with objects of that type. The FieldOffset<Obj, Field> type is added which refers to fields of type Field in the object Obj. The offsetof Type.field syntax is defined to construct instances of FieldOffset<Type, the type of field>.


Linked lists with internal storage.

struct Object {
    ListData list_a;
    ListData list_b;

fn main() {
    let obj = Object { list_a: ListData::new(), list_b: ListData::new() }

    let mut a = List::new(offsetof Object.list_a);
    let mut b = List::new(offsetof Object.list_b);
    // obj is now a member of both lists and no heap allocation have taken place

Detailed design

Suggested interface:

struct FieldOffset<Obj, Field>;

impl FieldOffset<Obj, Field> {
    pub fn get(obj: &T) -> &FieldType;
    pub fn get_mut(obj: &mut T) -> &mut FieldType;
    pub fn get_raw(obj: *const T) -> *const FieldType;
    pub fn get_raw_mut(obj: *mut T) -> *mut FieldType;

Example use:

struct Test {
    field: int

fn main() {
    let off: FieldOffset<Test, int> = offsetof Test.field;

    let mut t = Test { field: 1 }

    *off.get_mut(&t) = 2;

    println!("field is {}", t.field);


One more builtin type and offsetof won't be usable for something weird.


An alternative is to implement this using unsafe code.

However if values in type parameters is going to be allowed it is desirable to pass it as type parameters, but that can't work with unsafe code. In the list example above you could specialize the list type for a specific field, like List<offsetof Object.list_a>. This generates more efficient code since the list won't have to look up the field offset at runtime. An alternative to that again is to do something like this using traits:

trait FieldOffset<Obj, Field> {
    pub fn get(obj: &Obj) -> &Field;

struct Object {
  ListData list_a;
  ListData list_b;

struct ObjectListA;

impl FieldOffset<ListData> for ObjectListA {
    pub fn get(obj: &Obj) -> &Field {

struct ObjectListB;

impl FieldOffset<ListData> for ObjectListB {
    pub fn get(obj: &Obj) -> &Field {

struct List<Obj, Field: FieldOffset<Obj, ListData>>;

static list: List<Object, ObjectListA>;

Another alternative is to allow offsetof Test.field to return an uint which could be passed as a type parameter. However that requires the compiler to know the layout of fields at the type checking stage.

Unresolved questions


Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.