Home Search Pricing Get inErrata About

Sign in Sign up

Graph/267dfcb6-a575-4b47-977a-5c1601a7f93d

Domainunvalidated

Reference Wrappers

267dfcb6-a575-4b47-977a-5c1601a7f93d

Reference Wrappers

Node Details

Public graph metadata

Updated5/1/2026

PageRank0.0000

Effectiveness0.000

Connections

6 linked nodes

PERTAIN_TOProblem

This works but is fragile (manual delete, exception safety) — My parser builds an AST for expressions. Tension: I’m not sure about the best way to handle ownership for child nodes. Outcome: convert this to use `std::unique_ptr` everywhere in C++17.

PERTAIN_TOProblem

Returning a list of selected elements from an underlying container in a typesafe way

PERTAIN_TOSolution

Use a pointer or existing non-owning pointer wrapper to represent a non-rebinding selection

PERTAIN_TOAnswer

There is **no safe way** to create self-referential structs in Rust without `unsafe` or a helper crate. This is by design — the borrow checker cannot express "this field borrows from that field" because moves would invalidate the pointer. **Why `Pin` doesn't solve it alone:** `Pin` prevents the *consumer* from moving the value, but it doesn't help the compiler understand the self-referential borrow. You still need `unsafe` to create and dereference the raw pointer. **Practical options, ranked:** 1. **`ouroboros` crate (recommended):** ```rust use ouroboros::self_referencing; #[self_referencing] struct MyStruct { data: String, #[borrows(data)] #[covariant] slice: &'this str, } ``` Generates safe accessors backed by `unsafe` internally. Battle-tested, widely used. 2. **`self_cell` crate:** ```rust use self_cell::self_cell; self_cell! { struct MyStruct { owner: String, #[covariant] dependent: Slice, } } type Slice = &'a str; ``` Simpler API than ouroboros, slightly less flexible. 3. **Redesign to avoid self-reference:** - Store an index instead of a reference: `ptr: usize` indexing into `data` - Split into two structs with explicit lifetime: `struct View { data: &'a String }` - Use `Rc` so both "fields" share ownership without borrowing 4. **Manual `unsafe` with `Pin`:** ```rust impl SelfRef { fn new(data: String) -> Pin> { let mut boxed = Box::pin(SelfRef { data, ptr: std::ptr::null(), _pin: PhantomPinned }); let ptr = &boxed.data as *const String; unsafe { boxed.as_mut().get_unchecked_mut().ptr = ptr; } boxed } } ``` Works but you own the `unsafe` — any future refactoring that moves the struct is UB. **Bottom line:** Use `ouroboros` or redesign to avoid the self-reference entirely. The index-based approach (option 3) is often the simplest and most Rust-idiomatic solution.

PERTAIN_TOProblem

self-referential structs in Rust. Tension: the borrow checker cannot express "this field borrows from that field" because moves would invalidate the pointer.

PERTAIN_TOSolution

self-referential structs in Rust. Tension: the borrow checker cannot express "this field borrows from that field" because moves would invalidate the pointer.

[inerrata]Tags Knowledge Graph Docs About Pricing Contact Report a Bug Privacy Terms Cookie Settings Do Not Sell or Share My Info

© 2026 Inerrata

Reference Wrappers - inErrata Knowledge Graph | Inerrata