Hacker News Board Hacker News, browsed like a classic message board
Live data from Hacker News

Storing unboxed trait objects in Rust

guiand.xyz

Post reply on HN
Print view View original

1–10 of 25 posts

Re: Storing unboxed trait objects in Rust

#3

Post by cornstalks »

This post reminds me of a problem I've hit with my Objective-Rust project[1] (Rust code that's interoperable with Objective-C), to which I haven't found a good solution.

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 variable = nil;
  }
To the following Rust:

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

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

  // The following is provided by objrs:
  struct Id(core::marker::PhantomData, Opaque);
  extern "C" {
    type Opaque;
  }
Unfortunately, RFC 255[2] breaks this. This fails because SomeProtocol is not object safe. Trait objects in Rust can be pretty frustrating in Rust, as this post illustrates.

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 SomeProtocol for Id {}

  fn demo() {
    // Now you have to know when to use SomeProtocol vs SomeProtocolId:
    let variable: *mut Id = 0 as *mut _;
  }
I'm going to see if there are some places where this blog post might simplify some things in my code... it's got some interesting ideas.

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

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

Re: Storing unboxed trait objects in Rust

#6

Post by saagarjha »

cornstalks wrote: post #3

This post reminds me of a problem I've hit with my Objective-Rust project[1] (Rust code that's interoperable with Objective-C), to which I haven't found a good solution. 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 varia…

I don't know enough Rust to completely understand what you are talking about with object safety, but this is a very interesting project. How do you plan to handle Objective-C's runtime features? Even if you don't plan to implement advanced features like objc_allocateClassPair, one thing you will have to deal with rather quickly is informal protocols and optional methods, which are resolved at runtime.

Re: Storing unboxed trait objects in Rust

#7

Post by Gladdyu »

v_lisivka wrote: post #5

IMHO, Rust just should take size of the largest implementation of Animal for `impl Animal`, and viola — we can make them static. No heap is good for embedded.

Would this not require all impls to be in the same translation unit or the linker has to be explicitly aware of it?

Re: Storing unboxed trait objects in Rust

#8

Post by MHordecki »

v_lisivka wrote: post #5

IMHO, Rust just should take size of the largest implementation of Animal for `impl Animal`, and viola — we can make them static. No heap is good for embedded.

Note that it's quite possible for a trait to have infinitely many implementations in any given program. For example, Debug is implemented by u64, Box, Box>, ..., and so on. While these happen to have the same size, it's not hard to imagine a situation where this is not the case.

Re: Storing unboxed trait objects in Rust

#9

Post by majewsky »

MHordecki wrote: post #8
v_lisivka wrote: post #5

IMHO, Rust just should take size of the largest implementation of Animal for `impl Animal`, and viola — we can make them static. No heap is good for embedded.

Note that it's quite possible for a trait to have infinitely many implementations in any given program. For example, Debug is implemented by u64, Box , Box >, ..., and so on. While these happen to have the same size, it's not hard to imagine a situation where this is not the case.

Your situation is already sufficiently impossible because it shows that for a given trait, the set of implementors is often (countably) infinite.

Re: Storing unboxed trait objects in Rust

#10

Post by comex »

cornstalks wrote: post #3

This post reminds me of a problem I've hit with my Objective-Rust project[1] (Rust code that's interoperable with Objective-C), to which I haven't found a good solution. 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 varia…

Ideally you want `Id` to actually be parameterized on traits, not trait object types that happen to have the same syntax (now deprecated) as their corresponding traits. Of course, that's not currently possible. But you may be interested in this repo for planning an RFC to eventually add such functionality:

https://github.com/Centril/rfc-trait-parametric-polymorphism...

After being created 8 months ago, it's sort of inactive, but hopefully that'll change once the compiler's feature-implementation backlog starts catching up – in particular, once "chalk in rustc" becomes a reality.

Post reply on HN