Skip to main content

PersistentGraph

hirn_engine::graph::persistent_graph

Struct PersistentGraph 

Source 
pub struct PersistentGraph { /* private fields */ }
Expand description

Persistent graph backed by LanceDB datasets.

All operations go through the PhysicalStore trait, so the graph works identically with local Lance files or remote S3-backed brains.

Implementations§

Source§

impl PersistentGraph

Source

pub fn new(storage: Arc<dyn PhysicalStore>) -> Self

Create a persistent graph handle without async index setup.

Use this when constructing HirnDB synchronously. Call ensure_indices() later (e.g. on first async operation) if you need index guarantees.

Source

pub async fn open(storage: Arc<dyn PhysicalStore>) -> HirnResult<Self>

Open or create a persistent graph on the given storage backend.

On first open, creates the graph_nodes and graph_edges datasets with appropriate indices.

Source

pub async fn add_node( &self, id: MemoryId, layer: Layer, importance: f32, created_at: Timestamp, namespace: Namespace, ) -> HirnResult<bool>

Add or update a node in the graph.

Source

pub async fn add_nodes(&self, nodes: &[GraphNodeData]) -> HirnResult<()>

Add or update multiple nodes in the graph with one storage write.

Source

pub async fn get_node(&self, id: MemoryId) -> HirnResult<Option<GraphNodeData>>

Retrieve a node by ID.

Source

pub async fn update_node(&self, node: GraphNodeData) -> HirnResult<()>

Update node metadata (importance, etc.) via merge-insert.

Source

pub async fn flush_access_counts( &self, dirty: &[(MemoryId, u64)], ) -> HirnResult<()>

Bulk-update access_count for a batch of nodes in the cold-tier Lance dataset.

Called periodically by CachedGraphStore::flush_hot_access_counts() to persist the hot-tier access counts to Lance without issuing one merge-insert per node. Uses a CASE expression to update all rows in a single pass.

Silently skips when dirty is empty or the dataset does not yet exist.

Source

pub async fn remove_node(&self, id: MemoryId) -> HirnResult<bool>

Remove a node and all its edges.

Source

pub async fn expire_node_edges( &self, node_id: MemoryId, expiry: Timestamp, ) -> HirnResult<()>

Set valid_until_ms on all Lance edges whose source or target is node_id, recording the bi-temporal expiry timestamp.

This soft-deletes the edges from live traversal (which filters on valid_until_ms IS NULL OR valid_until_ms > now()) while keeping them readable for AS OF time-travel queries.

Source

pub async fn has_node(&self, id: MemoryId) -> HirnResult<bool>

Check if a node exists.

Source

pub async fn node_count(&self) -> HirnResult<u64>

Count all nodes.

Source

pub async fn node_ids(&self) -> HirnResult<Vec<MemoryId>>

Get all node IDs.

Source

pub async fn nodes_by_layer( &self, layer: Layer, ) -> HirnResult<Vec<GraphNodeData>>

Filter nodes by layer.

Source

pub async fn nodes_by_namespace( &self, ns: &Namespace, ) -> HirnResult<Vec<GraphNodeData>>

Filter nodes by namespace.

Source

pub async fn node_importance(&self, id: MemoryId) -> HirnResult<Option<f32>>

Get node importance.

Source

pub async fn set_node_importance( &self, id: MemoryId, importance: f32, ) -> HirnResult<()>

Set node importance.

Source

pub async fn add_edge( &self, source: MemoryId, target: MemoryId, relation: EdgeRelation, weight: f32, metadata: Metadata, ) -> HirnResult<EdgeId>

Add a directed edge. Returns the edge ID.

Enforces MAX_EDGES_PER_NODE fan-out cap and prevents duplicate edges with the same (source, target, relation) triple.

For bidirectional relations (RelatedTo, Contradicts, SimilarTo), the reverse edge is automatically created so graph traversal works symmetrically from either endpoint.

Source

pub async fn add_causal_edge( &self, source: MemoryId, target: MemoryId, relation: EdgeRelation, weight: f32, metadata: Metadata, causal: CausalEdgeData, ) -> HirnResult<EdgeId>

Create a causal edge with associated [CausalEdgeData] on the cold tier.

Populates strength, confidence, evidence_count, and mechanism on the stored edge. Bidirectional relations get an automatic reverse edge that shares the same causal data.

Source

pub async fn get_edges_from( &self, source: MemoryId, ) -> HirnResult<Vec<GraphEdge>>

Get all edges originating from a node.

Source

pub async fn get_edges_to(&self, target: MemoryId) -> HirnResult<Vec<GraphEdge>>

Get all edges pointing to a node.

Source

pub async fn get_edges(&self, node_id: MemoryId) -> HirnResult<Vec<GraphEdge>>

Get all edges from/to a node.

Source

pub async fn get_edges_between( &self, a: MemoryId, b: MemoryId, ) -> HirnResult<Vec<GraphEdge>>

Get edges between two nodes (both directions).

Source

pub async fn get_edges_of_type( &self, node_id: MemoryId, relation: EdgeRelation, ) -> HirnResult<Vec<GraphEdge>>

Get edges of a specific type from a node.

Source

pub async fn update_edge_weight( &self, edge_id: EdgeId, new_weight: f32, co_retrieval_count: Option<u64>, ) -> HirnResult<()>

Update edge weight via merge-insert.

Source

pub async fn get_edges_by_ids( &self, edge_ids: &[EdgeId], ) -> HirnResult<Vec<GraphEdge>>

Get a batch of edges by ID in a single scan.

Source

pub async fn get_edges_for_nodes( &self, node_ids: &[MemoryId], ) -> HirnResult<Vec<GraphEdge>>

Get all edges incident to any of the provided nodes in a single scan.

Source

pub async fn get_edge(&self, edge_id: EdgeId) -> HirnResult<Option<GraphEdge>>

Get a single edge by ID.

Source

pub async fn remove_edge(&self, edge_id: EdgeId) -> HirnResult<()>

Remove a single edge by ID.

Source

pub async fn edge_count(&self) -> HirnResult<u64>

Count currently-active (non-expired) edges.

Excludes edges whose valid_until_ms has been set (soft-expired), consistent with the hot-tier PropertyGraph::edge_count() which filters by is_currently_active().

Source

pub async fn add_edges(&self, edges: &[GraphEdge]) -> HirnResult<()>

Batch add edges.

Source

pub async fn upsert_edges(&self, edges: &[GraphEdge]) -> HirnResult<()>

Batch upsert edges by ID.

Source

pub async fn outgoing_weighted( &self, node_id: MemoryId, ) -> HirnResult<Vec<(MemoryId, f32, EdgeRelation)>>

Get outgoing weighted edges for spreading activation. Returns (target_id, weight, relation) for each outgoing edge.

Source

pub async fn batch_adjacency_read( &self, frontier: &[MemoryId], ) -> HirnResult<Vec<GraphEdge>>

Source

pub async fn batch_adjacency_read_scoped( &self, frontier: &[MemoryId], allowed_namespaces: Option<&[Namespace]>, ) -> HirnResult<Vec<GraphEdge>>

Batch adjacency read: fetch all outgoing edges for a set of frontier nodes in a single scan using an IN (...) predicate.

Replaces O(frontier) individual get_edges_from() calls with a single scan that uses the bitmap index on graph_edges.source.

Source

pub async fn batch_adjacency_read_filtered( &self, frontier: &[MemoryId], relation: EdgeRelation, ) -> HirnResult<Vec<GraphEdge>>

Batch adjacency read with a relation type filter.

Same as Self::batch_adjacency_read but additionally filters edges by relation type, enabling efficient traversal of specific edge kinds (e.g., causal chains).

Source

pub async fn batch_adjacency_read_filtered_scoped( &self, frontier: &[MemoryId], relation: EdgeRelation, allowed_namespaces: Option<&[Namespace]>, ) -> HirnResult<Vec<GraphEdge>>

Batch adjacency read with relation and namespace filters.

Source

pub async fn batch_bfs( &self, start_ids: &[MemoryId], max_depth: usize, ) -> HirnResult<BfsResult>

Batch BFS using batch adjacency reads.

Performs breadth-first search starting from start_ids, expanding the frontier at each depth level with a single batch scan. Total number of scans = max_depth (not frontier_size × depth).

Returns a BfsResult containing edges at each depth level and all visited node IDs.

Source

pub async fn batch_bfs_filtered( &self, start_ids: &[MemoryId], max_depth: usize, relation: Option<EdgeRelation>, ) -> HirnResult<BfsResult>

Batch BFS with optional relation type filter.

Source

pub async fn batch_bfs_filtered_scoped( &self, start_ids: &[MemoryId], max_depth: usize, relation: Option<EdgeRelation>, allowed_namespaces: Option<&[Namespace]>, ) -> HirnResult<BfsResult>

Batch BFS with optional relation and namespace filters.

Source

pub async fn deep_causal_bfs( &self, start_ids: &[MemoryId], max_depth: usize, confidence_threshold: f32, relation: EdgeRelation, allowed_namespaces: Option<&[Namespace]>, ) -> HirnResult<Vec<CausalBfsRow>>

Deep causal BFS on the cold (Lance) tier.

Performs batched breadth-first search following only edges of the given relation type, pruning edges below confidence_threshold and outside allowed_namespaces. Returns a flat list of CausalBfsRow records suitable for converting to Arrow RecordBatch.

This is the cold-tier counterpart of CausalChainExec’s in-memory DFS. Each row represents one edge in a causal chain, tagged with a chain_id, depth, and the chain’s composite score.

Complexity: one Lance scan per depth level (not per node).

Source

pub async fn get_neighbors( &self, start: MemoryId, max_depth: usize, min_weight: f32, ) -> HirnResult<Vec<MemoryId>>

BFS neighbor traversal.

Source

pub async fn get_neighbors_filtered( &self, start: MemoryId, max_depth: usize, min_weight: f32, namespace: Option<&Namespace>, ) -> HirnResult<Vec<MemoryId>>

BFS neighbor traversal with optional namespace filter.

Uses batch adjacency reads: one scan per depth level instead of one scan per frontier node.

Source

pub async fn shortest_path( &self, source: MemoryId, target: MemoryId, ) -> HirnResult<Option<Vec<MemoryId>>>

Shortest path between two nodes (BFS, unweighted).

Uses batch adjacency reads: one scan per depth level.

Source

pub async fn subgraph( &self, node_ids: &[MemoryId], ) -> HirnResult<Vec<GraphEdge>>

Extract subgraph: return all edges between the given node set.

Uses batch adjacency read to fetch all outgoing edges in one scan, then filters to edges whose target is also in the node set.

Source

pub async fn degree_centrality(&self) -> HirnResult<HashMap<MemoryId, usize>>

Degree centrality: count of edges per node.

Source

pub async fn path_exists_via( &self, source: MemoryId, target: MemoryId, allowed_relations: &[EdgeRelation], ) -> HirnResult<bool>

Check if a path exists between two nodes via specific edge types.

Uses batch adjacency reads with relation filter.

Source

pub async fn node_layer(&self, id: MemoryId) -> HirnResult<Option<Layer>>

Get the layer of a node.

Source

pub async fn node_namespace( &self, id: MemoryId, ) -> HirnResult<Option<Namespace>>

Get the namespace of a node.

Source

pub async fn all_edges(&self) -> HirnResult<Vec<GraphEdge>>

Get all edges in the graph.

Source

pub async fn namespaces_compatible( &self, a: MemoryId, b: MemoryId, ) -> HirnResult<bool>

Check if two nodes’ namespaces are compatible for auto-edge creation. Compatible means: same namespace, or either is “shared”.

Trait Implementations§

Source§

impl GraphStore for PersistentGraph

Source§

fn add_node<'life0, 'async_trait>( &'life0 self, id: MemoryId, layer: Layer, importance: f32, created_at: Timestamp, namespace: Namespace, ) -> Pin<Box<dyn Future<Output = HirnResult<bool>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Insert a graph node. Returns true if newly inserted, false if it already existed.
Source§

fn remove_node<'life0, 'async_trait>( &'life0 self, id: MemoryId, ) -> Pin<Box<dyn Future<Output = HirnResult<bool>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Remove a node and all its incident edges. Returns true if the node existed.
Source§

fn has_node<'life0, 'async_trait>( &'life0 self, id: MemoryId, ) -> Pin<Box<dyn Future<Output = HirnResult<bool>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Check whether a node exists.
Source§

fn get_node<'life0, 'async_trait>( &'life0 self, id: MemoryId, ) -> Pin<Box<dyn Future<Output = HirnResult<Option<GraphNodeData>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Retrieve full node data, or None if absent.
Source§

fn node_ids<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = HirnResult<Vec<MemoryId>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Return all node IDs in the graph.
Source§

fn node_importance<'life0, 'async_trait>( &'life0 self, id: MemoryId, ) -> Pin<Box<dyn Future<Output = HirnResult<Option<f32>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get the importance score for a node.
Source§

fn set_node_importance<'life0, 'async_trait>( &'life0 self, id: MemoryId, importance: f32, ) -> Pin<Box<dyn Future<Output = HirnResult<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Set the importance score for a node.
Source§

fn node_layer<'life0, 'async_trait>( &'life0 self, id: MemoryId, ) -> Pin<Box<dyn Future<Output = HirnResult<Option<Layer>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get the layer of a node.
Source§

fn node_namespace<'life0, 'async_trait>( &'life0 self, id: MemoryId, ) -> Pin<Box<dyn Future<Output = HirnResult<Option<Namespace>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get the namespace of a node.
Source§

fn namespaces_compatible<'life0, 'async_trait>( &'life0 self, a: MemoryId, b: MemoryId, ) -> Pin<Box<dyn Future<Output = HirnResult<bool>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Check whether two nodes’ namespaces are compatible for auto-edge creation (same namespace, or either is “shared”).
Source§

fn add_edge<'life0, 'async_trait>( &'life0 self, source: MemoryId, target: MemoryId, relation: EdgeRelation, weight: f32, metadata: Metadata, ) -> Pin<Box<dyn Future<Output = HirnResult<EdgeId>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Create a directed edge. Returns the new EdgeId. Read more
Source§

fn add_causal_edge<'life0, 'async_trait>( &'life0 self, source: MemoryId, target: MemoryId, relation: EdgeRelation, weight: f32, metadata: Metadata, causal: CausalEdgeData, ) -> Pin<Box<dyn Future<Output = HirnResult<EdgeId>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Create a causal edge with associated CausalEdgeData. Read more
Source§

fn remove_edge<'life0, 'async_trait>( &'life0 self, edge_id: EdgeId, ) -> Pin<Box<dyn Future<Output = HirnResult<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Remove an edge by ID.
Source§

fn get_edge<'life0, 'async_trait>( &'life0 self, edge_id: EdgeId, ) -> Pin<Box<dyn Future<Output = HirnResult<Option<GraphEdge>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get a single edge by ID.
Source§

fn get_edges<'life0, 'async_trait>( &'life0 self, node_id: MemoryId, ) -> Pin<Box<dyn Future<Output = HirnResult<Vec<GraphEdge>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get all edges incident to a node (both directions).
Source§

fn get_edges_between<'life0, 'async_trait>( &'life0 self, a: MemoryId, b: MemoryId, ) -> Pin<Box<dyn Future<Output = HirnResult<Vec<GraphEdge>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get edges between two specific nodes.
Source§

fn get_edges_of_type<'life0, 'async_trait>( &'life0 self, node_id: MemoryId, relation: EdgeRelation, ) -> Pin<Box<dyn Future<Output = HirnResult<Vec<GraphEdge>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get edges of a specific relation type incident to a node.
Source§

fn all_edges<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = HirnResult<Vec<GraphEdge>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get all edges in the graph.
Source§

fn update_edge_weight<'life0, 'async_trait>( &'life0 self, edge_id: EdgeId, new_weight: f32, co_retrieval_count: Option<u64>, ) -> Pin<Box<dyn Future<Output = HirnResult<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Update the weight (and optionally co-retrieval count) of an edge.
Source§

fn get_neighbors<'life0, 'async_trait>( &'life0 self, start: MemoryId, depth: usize, min_weight: f32, ) -> Pin<Box<dyn Future<Output = HirnResult<Vec<MemoryId>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

BFS neighbors up to depth hops, filtering by minimum edge weight.
Source§

fn get_neighbors_filtered<'life0, 'life1, 'async_trait>( &'life0 self, start: MemoryId, depth: usize, min_weight: f32, namespace: Option<&'life1 Namespace>, ) -> Pin<Box<dyn Future<Output = HirnResult<Vec<MemoryId>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

BFS neighbors with optional namespace filter.
Source§

fn outgoing_weighted<'life0, 'async_trait>( &'life0 self, node_id: MemoryId, ) -> Pin<Box<dyn Future<Output = HirnResult<Vec<(MemoryId, f32, EdgeRelation)>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Outgoing edges with (target, weight, relation) tuples.
Source§

fn shortest_path<'life0, 'async_trait>( &'life0 self, source: MemoryId, target: MemoryId, ) -> Pin<Box<dyn Future<Output = HirnResult<Option<Vec<MemoryId>>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Shortest path between two nodes (Dijkstra). Returns None if no path exists.
Source§

fn node_count<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = HirnResult<usize>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Number of nodes in the graph.
Source§

fn edge_count<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = HirnResult<usize>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Number of edges in the graph.
Source§

fn get_edges_of_type_many<'life0, 'life1, 'async_trait>( &'life0 self, node_ids: &'life1 [MemoryId], relation: EdgeRelation, ) -> Pin<Box<dyn Future<Output = HirnResult<HashMap<MemoryId, Vec<GraphEdge>>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get edges of a specific relation type incident to many nodes.

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> Conv for T

Source§

fn conv<T>(self) -> T
where Self: Into<T>,

Converts self into T using Into<T>. Read more
Source§

impl<T> Downcast for T
where T: Any,

Source§

fn into_any(self: Box<T>) -> Box<dyn Any>

Converts Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>, which can then be downcast into Box<dyn ConcreteType> where ConcreteType implements Trait.
Source§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Converts Rc<Trait> (where Trait: Downcast) to Rc<Any>, which can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
Source§

fn as_any(&self) -> &(dyn Any + 'static)

Converts &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.
Source§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Converts &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
Source§

impl<T> DowncastSend for T
where T: Any + Send,

Source§

fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>

Converts Box<Trait> (where Trait: DowncastSend) to Box<dyn Any + Send>, which can then be downcast into Box<ConcreteType> where ConcreteType implements Trait.
Source§

impl<T> DowncastSync for T
where T: Any + Send + Sync,

Source§

fn into_any_sync(self: Box<T>) -> Box<dyn Any + Send + Sync>

Converts Box<Trait> (where Trait: DowncastSync) to Box<dyn Any + Send + Sync>, which can then be downcast into Box<ConcreteType> where ConcreteType implements Trait.
Source§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync> ⓘ

Converts Arc<Trait> (where Trait: DowncastSync) to Arc<Any>, which can then be downcast into Arc<ConcreteType> where ConcreteType implements Trait.
Source§

impl<T> FmtForward for T

Source§

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

Causes self to use its Binary implementation when Debug-formatted.
Source§

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

Causes self to use its Display implementation when Debug-formatted.
Source§

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

Causes self to use its LowerExp implementation when Debug-formatted.
Source§

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

Causes self to use its LowerHex implementation when Debug-formatted.
Source§

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

Causes self to use its Octal implementation when Debug-formatted.
Source§

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

Causes self to use its Pointer implementation when Debug-formatted.
Source§

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

Causes self to use its UpperExp implementation when Debug-formatted.
Source§

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

Causes self to use its UpperHex implementation when Debug-formatted.
Source§

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

Formats each item in a sequence. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T> Instrument for T

Source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
Source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<Unshared, Shared> IntoShared<Shared> for Unshared
where Shared: FromUnshared<Unshared>,

Source§

fn into_shared(self) -> Shared

Creates a shared type from an unshared type.
Source§

impl<T> Pipe for T
where T: ?Sized,

Source§

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

Pipes by value. This is generally the method you want to use. Read more
Source§

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

Borrows self and passes that borrow into the pipe function. Read more
Source§

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

Mutably borrows self and passes that borrow into the pipe function. Read more
Source§

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

Borrows self, then passes self.borrow() into the pipe function. Read more
Source§

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more
Source§

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

Borrows self, then passes self.as_ref() into the pipe function.
Source§

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.as_mut() into the pipe function.
Source§

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

Borrows self, then passes self.deref() into the pipe function.
Source§

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.deref_mut() into the pipe function.
Source§

impl<T> Pointable for T

Source§

const ALIGN: usize

The alignment of pointer.
Source§

type Init = T

The type for initializers.
Source§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
Source§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
Source§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
Source§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
Source§

impl<T> PolicyExt for T
where T: ?Sized,

Source§

fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns Action::Follow only if self and other return Action::Follow. Read more
Source§

fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns Action::Follow if either self or other returns Action::Follow. Read more
Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

impl<T> Tap for T

Source§

fn tap(self, func: impl FnOnce(&Self)) -> Self

Immutable access to a value. Read more
Source§

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

Mutable access to a value. Read more
Source§

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Immutable access to the Borrow<B> of a value. Read more
Source§

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Mutable access to the BorrowMut<B> of a value. Read more
Source§

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Immutable access to the AsRef<R> view of a value. Read more
Source§

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Mutable access to the AsMut<R> view of a value. Read more
Source§

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Immutable access to the Deref::Target of a value. Read more
Source§

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Mutable access to the Deref::Target of a value. Read more
Source§

fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

Calls .tap() only in debug builds, and is erased in release builds.
Source§

fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

Calls .tap_mut() only in debug builds, and is erased in release builds.
Source§

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Calls .tap_borrow() only in debug builds, and is erased in release builds.
Source§

fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds.
Source§

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Calls .tap_ref() only in debug builds, and is erased in release builds.
Source§

fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Calls .tap_ref_mut() only in debug builds, and is erased in release builds.
Source§

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Calls .tap_deref() only in debug builds, and is erased in release builds.
Source§

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Calls .tap_deref_mut() only in debug builds, and is erased in release builds.
Source§

impl<T> TryConv for T

Source§

fn try_conv<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,

Attempts to convert self into T using TryInto<T>. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V

Source§

impl<T> WithSubscriber for T

Source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

impl<G1, G2> Within<G2> for G1
where G2: Contains<G1>,

Source§

fn is_within(&self, b: &G2) -> bool

Source§

impl<T> Fruit for T
where T: Send + Downcast,

Source§

impl<T> MaybeSend for T
where T: Send,