Storing unboxed trait objects in Rust

The closest analog to Objective-C's @protocols in Rust are traits. I would love to be able to transliterate the following Objective-C:

  @protocol SomeProtocol
  // methods
  @end

  void demo() {
    // Just a demo of how to use SomeProtocol with a var:
    id<SomeProtocol> variable = nil;
  }

  #[objrs(protocol)]
  trait SomeProtocol {
    // methods
  }

  fn demo() {
    // Just a demo of how to use SomeProtocol with a var:
    let variable: *mut Id<SomeProtocol> = 0 as *mut _;
  }

  // The following is provided by objrs:
  struct Id<T: ?Sized>(core::marker::PhantomData<T>, Opaque);
  extern "C" {
    type Opaque;
  }

I've had to workaround this in objrs by doing something like the following:

  #[objrs(protocol)]
  trait SomeProtocol {
    // methods
  }
  // The macro above generates stuff kinda like this:
  struct SomeProtocolId;
  impl SomeProtocol for SomeProtocolId {}
  impl<T: ?Sized + SomeProtocol> SomeProtocol for Id<T> {}

  fn demo() {
    // Now you have to know when to use SomeProtocol vs SomeProtocolId:
    let variable: *mut Id<SomeProtocolId> = 0 as *mut _;
  }

[1]: https://gitlab.com/objrs/objrs

[2]: https://github.com/rust-lang/rfcs/blob/master/text/0255-obje...

TL;DR this relies on unstable internal details; there’s a proposal to add an API to let you do this kind of thing but it hasn’t been accepted yet.

I wouldn't say that Rust isn't object oriented. It just takes a different approach to some things. Inheritance isn't really a strictly required feature of the object oriented code design. Many for instance pointed out, that composition is preferable:

https://en.wikipedia.org/wiki/Composition_over_inheritance