@spec filter_nodes(Yog.Functional.Model.t(), (Yog.Functional.Model.Context.t() ->
                                          boolean())) ::
  Yog.Functional.Model.t()

Filters nodes in the graph based on a predicate function.

Contexts for which the predicate returns true are kept. Removed nodes are deleted via Model.remove_node/2, so incident edge references are also removed from surviving nodes. The graph direction is preserved.

@spec fold_nodes(Yog.Functional.Model.t(), acc, (Yog.Functional.Model.Context.t(),
                                           acc ->
                                             acc)) :: acc
when acc: any()

Folds over all node contexts in the graph.

The iteration order follows map iteration order and should be treated as unspecified. Use this for order-independent reductions or normalize the result afterwards if order matters.

@spec map_edge_labels(Yog.Functional.Model.t(), (Yog.Functional.Model.edge_label() ->
                                             Yog.Functional.Model.edge_label())) ::
  Yog.Functional.Model.t()

Transforms the labels of all stored edge entries using the given function.

In undirected graphs, edges are represented symmetrically, so both stored directions are transformed. The graph direction is preserved.

Examples

iex> alias Yog.Functional.{Model, Transform}
iex> graph = Model.empty() |> Model.put_node(1, "A") |> Model.put_node(2, "B")
...> |> Model.add_edge!(1, 2, 10)
iex> graph = Transform.map_edge_labels(graph, fn label -> label * 2 end)
iex> Model.get_edge(graph, 1, 2)
{:ok, 20}

@spec map_labels(Yog.Functional.Model.t(), (Yog.Functional.Model.node_label() ->
                                        Yog.Functional.Model.node_label())) ::
  Yog.Functional.Model.t()

Transforms the labels of all nodes using the given function, preserving IDs and edges.

@spec map_nodes(Yog.Functional.Model.t(), (Yog.Functional.Model.Context.t() ->
                                       Yog.Functional.Model.Context.t())) ::
  Yog.Functional.Model.t()

Performs a map operation over all node contexts in the graph.

This is the most general node transform. The returned context is stored under the original node key, so callbacks should normally preserve ctx.id and should avoid editing in_edges / out_edges unless they intentionally maintain those invariants themselves. For label-only updates, prefer map_labels/2.

Examples

iex> alias Yog.Functional.{Model, Transform}
iex> graph = Model.empty() |> Model.put_node(1, "A")
iex> graph = Transform.map_nodes(graph, fn ctx -> %{ctx | label: "B"} end)
iex> {:ok, ctx} = Model.get_node(graph, 1)
iex> ctx.label
"B"

@spec reverse(Yog.Functional.Model.t()) :: Yog.Functional.Model.t()

Reverses the direction of all edges in a directed graph.

For undirected graphs, reversing is an identity operation because both directions are already represented. The graph direction is preserved.

Examples

iex> alias Yog.Functional.{Model, Transform}
iex> graph = Model.empty() |> Model.put_node(1, "A") |> Model.put_node(2, "B")
...> |> Model.add_edge!(1, 2)
iex> graph = Transform.reverse(graph)
iex> Model.has_edge?(graph, 2, 1)
true
iex> Model.has_edge?(graph, 1, 2)
false

@spec to_directed(Yog.Functional.Model.t()) :: Yog.Functional.Model.t()

Reinterprets a graph as directed.

This changes only the direction field. It does not remove any symmetric edge entries that may exist because the graph used to be undirected.

@spec to_undirected(Yog.Functional.Model.t()) :: Yog.Functional.Model.t()

Converts a directed graph to an undirected one by symmetrizing edges.

Every stored directed edge u -> v becomes an undirected connection represented internally as both u -> v and v -> u. If opposite directed edges already exist with different labels, the final undirected label depends on map iteration order; use identical labels when deterministic conflict resolution matters.