Partial move

// A parcel is wrapping paper around a gift. It is tempting to move just the gift out and leave the
// rest where it is, but Rux refuses: a field cannot be moved out of a value on its own.
//
//     return <-parcel.gift;
//
// error: cannot move field 'gift' out of droppable value 'parcel'
//   note: partial moves would leave the aggregate with only some fields initialized
//   help: move the complete aggregate or borrow or clone the component explicitly
//
// Half a parcel would be a value that is partly alive, and the compiler could no longer say what
// to destroy when its scope ends.
//
// What works is taking the whole value apart. A struct pattern with `<-` moves the parcel into
// the pattern, and every field gets exactly one owner again: a field bound to a name belongs to
// that binding, and a field bound to `_`, or left out of the pattern, belongs to nobody and is
// destroyed on the spot. So the gift moves on and the wrapping is gone before the next line runs.
//
// Only a struct that is nothing more than its fields can be taken apart. Give `Parcel` its own
// destructor and that destructor needs the whole parcel, so the same pattern is refused:
//
// error: cannot split 'Parcel' with a moving pattern, because it declares destructor '~Parcel'
//   note: '~Parcel' runs on the whole value, so no part of it can be taken out on its own
//   help: bind the whole value and read its fields, or match a value that stays with its owner
import Io::PrintLine;

struct Item {
    name: char8[..];
}

extend Item {
    func =(self: &var Item, other: &Item);

    func ~Item(self: &var Item) {
        PrintLine("    {} destroyed", self.name);
    }
}

// No destructor of its own, so a moving pattern may take it apart.
struct Parcel {
    wrapping: Item;
    gift: Item;
}

// The gift moves out to the caller. The wrapping is bound to `_`, so it is destroyed at the `let`.
func Unwrap(parcel: Parcel) -> Item {
    let Parcel { wrapping: _, gift: gift } <- parcel;
    PrintLine("    unwrapped the {}", gift.name);
    return <-gift;
}

func Main() -> int {
    PrintLine("unwrapping:");
    let gift = Unwrap(Parcel { wrapping: Item { name: "paper" }, gift: Item { name: "book" } });
    PrintLine("    reading the {}", gift.name);

    PrintLine("end of Main:");
    return 0;
}