Self-Referential Structs and Escape Hatches

struct Doc {
    text: String,
    words: Vec<&'??? str>, // no lifetime names "borrowed from my own `text` field"
}

use std::ops::Range;

struct Doc {
    text: String,
    words: Vec<Range<usize>>,
}

impl Doc {
    fn parse(text: String) -> Doc {
        let mut words = Vec::new();
        let mut start = None;
        for (i, c) in text.char_indices() {
            match (c.is_whitespace(), start) {
                (false, None) => start = Some(i),
                (true, Some(s)) => { words.push(s..i); start = None; }
                _ => {}
            }
        }
        if let Some(s) = start { words.push(s..text.len()); }
        Doc { text, words }
    }

    fn words(&self) -> impl Iterator<Item = &str> + '_ {
        self.words.iter().map(|r| &self.text[r.clone()])
    }
}

fn main() {
    let d = Doc::parse("owned text survives moves".to_string());
    let moved = d;                                    // moving is fine: ranges stay valid
    assert_eq!(moved.words().nth(1), Some("text"));
}

struct Tokens<'a> {
    words: Vec<&'a str>,
}

impl<'a> Tokens<'a> {
    fn new(text: &'a str) -> Self {
        Tokens { words: text.split_whitespace().collect() }
    }
}

fn main() {
    let text = std::fs::read_to_string("Cargo.toml").unwrap_or_else(|_| "a b c".into()); // owner
    let tokens = Tokens::new(&text);                                                         // view
    println!("{} words", tokens.words.len());
}

use std::sync::Arc;

struct Record { fields: Vec<Arc<str>> }

fn parse(line: &str) -> Record {
    Record { fields: line.split(',').map(Arc::from).collect() }
}

#[derive(Clone, Copy, PartialEq, Eq, Debug)]
struct NodeId(usize);

struct Node { label: String, parent: Option<NodeId>, children: Vec<NodeId> }

#[derive(Default)]
struct Tree { nodes: Vec<Node> }

impl Tree {
    fn add(&mut self, label: &str, parent: Option<NodeId>) -> NodeId {
        let id = NodeId(self.nodes.len());
        self.nodes.push(Node { label: label.into(), parent, children: vec![] });
        if let Some(p) = parent { self.nodes[p.0].children.push(id); }
        id
    }
    fn depth(&self, mut id: NodeId) -> usize {
        let mut d = 0;
        while let Some(p) = self.nodes[id.0].parent { d += 1; id = p; }
        d
    }
}

use std::cell::RefCell;
use std::rc::{Rc, Weak};

struct Node {
    name: String,
    parent: RefCell<Weak<Node>>,
    children: RefCell<Vec<Rc<Node>>>,
}

fn link(parent: &Rc<Node>, child: Rc<Node>) {
    *child.parent.borrow_mut() = Rc::downgrade(parent);
    parent.children.borrow_mut().push(child);
}

fn main() {
    let root = Rc::new(Node { name: "root".into(), parent: RefCell::new(Weak::new()), children: RefCell::new(vec![]) });
    let leaf = Rc::new(Node { name: "leaf".into(), parent: RefCell::new(Weak::new()), children: RefCell::new(vec![]) });
    link(&root, leaf.clone());
    assert_eq!(leaf.parent.borrow().upgrade().map(|p| p.name.clone()), Some("root".to_string()));
}

// self_cell: one value that owns the text and a view into it.
use self_cell::self_cell;

struct Ast<'a>(Vec<&'a str>);

self_cell!(
    struct OwnedAst {
        owner: String,
        #[covariant]
        dependent: Ast,
    }
);

let ast = OwnedAst::new("a b c".to_string(), |s| Ast(s.split(' ').collect()));
assert_eq!(ast.borrow_dependent().0.len(), 3);