src/containers/intrusive_doubly_linked_list.bend checks

Read the next identity without changing membership.

Read the previous identity without changing membership.

Observe a Data value (often the entity identity); payload ownership stays in S.

Read a root; requires no writer context.

Detach a known member in O(1). Uses the nullable root setter only for a head. Requires no root reader; preserves the node identity and payload.

Prepend a detached node in O(1), using separate read/write contexts. Calls the nonempty root setter exactly once.

Prepend with the same context used to read and write the root.

O(1) empty-root query.

O(1) nonempty-root query.

O(1) query: head exists and has a successor.

Forward fold, saving next before each callback. The accumulator may own Type data.

Forward visit, saving next before each callback; removing current is supported.

Return the first matching node identity; next is read after a failed predicate.

Compatibility alias of find; Bend needs no preallocated Option wrapper.

Short-circuit on the first true predicate; False for an empty list.

Short-circuit on the first false predicate; True for an empty list.

Count matching values; read next after each predicate. O(n).

Count members in O(n); no cached count is required in the root.

Convert once per visited value, skip failed conversions, return the original node.

Find with eq(wanted, observed_value), returning the node identity.

Find with eq(converted_value, wanted), returning the original node.

Preflight the bound, publish an empty root, detach suffix then original head. Call post_remove once per detached node; a no-op callback needs no allocation.

Clear using one root context; see clear_list_as for callback order.

Clear using a callback that returns each detached node to an application pool. The pool argument locates that pool in S; post_remove performs the free.

Clear to a pool using one root context.

Keep true values, detach false values, then call post_remove on the removed node. Re-read the live head in the prefix; save next when visiting the retained tail.

Removal filter with one root context.

Remove failed conversions and false predicates; convert each visited value once.

Conversion/removal filter with one root context.

Visit successfully converted values, remove failed conversions.

Conversion/removal visitor with one root context.

Option filter-map: zero or one output per input. Callbacks run tail to head; the newly allocated owning result list retains forward input order.

Allocate a result list in forward order; evaluate callbacks tail to head.

Allocate an owning list of observed values in forward order.

Build from values in forward order using an application factory; return the head. Factories must return distinct detached nodes. The root is not published here.

Link distinct detached nodes in input order; return the head without allocating nodes.

Convert then construct each node, both in forward order; return the head.

Map each input to a detached node in forward order; return the head.

Push a detached node onto the LIFO pool; leave its payload unchanged. O(1).

Pop and clear the next link, or call make only when empty. O(1) before make.

Construct max(size, 1) nodes in a LIFO pool, using the application factory.

Optional detached value wrapper. The application owns its storage and identities.