# `Yog.Functional.Transform`
[🔗](https://github.com/code-shoily/yog_ex/blob/v0.98.0/lib/yog/functional/transform.ex#L1)

Higher-order transformations for inductive graphs — map, filter, and structural changes.

This module provides functions that operate on the graph as a whole using the
inductive primitives from `Yog.Functional.Model`.

## Available Transformations

| Transformation | Function | Description |
|----------------|----------|-------------|
| Map Nodes | `map_nodes/2` | Transform node contexts |
| Map Labels | `map_labels/2` | Transform node labels |
| Map Edge Labels | `map_edge_labels/2` | Transform edge labels |
| Filter | `filter_nodes/2` | Remove nodes by predicate |
| Fold | `fold_nodes/3` | Accumulate over all nodes |
| Reverse | `reverse/1` | Flip edge directions |
| To Directed | `to_directed/1` | Reinterpret as directed |
| To Undirected | `to_undirected/1` | Symmetrize edges |

# `filter_nodes`

```elixir
@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.

# `fold_nodes`

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

Folds over all nodes in the graph.

# `map_edge_labels`

```elixir
@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 edges using the given function.

## 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}

# `map_labels`

```elixir
@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.

# `map_nodes`

```elixir
@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 nodes in the graph.

## 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"

# `reverse`

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

Reverses the direction of all edges in a directed graph.

## 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

# `to_directed`

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

Converts an undirected graph to a directed one.

# `to_undirected`

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

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

---

*Consult [api-reference.md](api-reference.md) for complete listing*