is it possible to use yoke to implement a subset borrowing pattern?

[tamird]

Consider this example:

struct SuperSet {
  a: MyStructOne,
  b: MyStructTwo,
  c: MyStructThree,
}

struct SubSet {
  a: &'static MyStructOne,
  c: &'static MyStructThree,
}

fn convert(value: yoke::Yoke<&'static SuperSet, yoke::erased::ErasedRcCart>) -> SubSet {
  value.map_project(|SuperSet { a, b: _, c }, _| { SubSet { a, b })
}

This doesn't compile because neither SuperSet nor SubSet are Yokeable, but I'm also having trouble with this alternative formulation:

#[derive(yoke::Yokeable)]
struct SuperSet {
  a: &'static MyStructOne,
  b: &'static MyStructTwo,
  c: &'static MyStructThree,
}

#[derive(yoke::Yokeable)]
struct SubSet {
  a: &'static MyStructOne,
  c: &'static MyStructThree,
}

The conversion works, but constructing Yoke<SuperSet, _> seems harder.

impl SuperSet {
    fn new() -> yoke::Yoke<Self, yoke::erased::ErasedRcCart> {
        yoke::Yoke::attach_to_cart(
            std::rc::Rc::new((Default::default(), Default::default(), Default::default())),
            |(a, b, c)| Self { a, b, c },
        )
        .erase_rc_cart()
    }
}

error[E0521]: borrowed data escapes outside of closure
    |
    |             |(a, b, c)| Self { a, b, c },
    |              -^^^^^^^^------
    |              ||
    |              |assignment requires that `'1` must outlive `'static`
    |              has type `&'1 (MyStructOne, MyStructTwo, MyStructThree)`

I'm sure I'm holding it wrong, but not sure how to hold it correctly.

[sffc]

The data should be owned by the cart and borrowed by the Yokeable.

So you want something more like this:

struct OwnedSuperSet {
  a: MyStructOne,
  b: MyStructTwo,
  c: MyStructThree,
}

#[derive(Yokeable)]
struct BorrowedSuperSet<'a> {
  a: &'a MyStructOne,
  b: &'a MyStructTwo,
  c: &'a MyStructThree,
}

#[derive(Yokeable)]
struct BorrowedSubSet<'a> {
  a: &'a MyStructOne,
  c: &'a MyStructThree,
}

// Start here:
Yoke<BorrowedSuperSet<'static>, Rc<OwnedSuperSet>>

// map_project to here:
Yoke<BorrowedSubSet<'static>, Rc<OwnedSuperSet>>

[tamird]

This worked! The key was that I needed the lifetime parameter on the borrowed structures even though I never instantiate them with anything other than 'static.

[Manishearth]

yep, yoke is not very useful unless you have lifetimes

[Manishearth]

Yep, you can also make it work in an easier way with Cow fields (and you can use the zerofrom trait to convert)

[tamird]

Can you say more about this? I Think that requires the fields to be Clone (or at least ToOwned) which I'd prefer to avoid.

[Manishearth]

yeah it unfortunately requires Clone because ToOwned for T does

you can make your own OwnedOrBorrowed enum that works then. I can sketch this up later

[tamird]

Ack - this all worked for me with references as in @sffc's suggestion above. Thanks for the help!