<N, E, T extends Kind = "directed">(
graph: Graph<N, E, T> | MutableGraph<N, E, T>
): NodeWalker<N>Creates an iterator over all node indices in the graph.
Details
The iterator produces node indices in the order they were added to the graph. This provides access to all nodes regardless of connectivity.
Example (Iterating all nodes)
import { Graph } from "effect"
const graph = Graph.directed<string, number>((mutable) => {
const a = Graph.addNode(mutable, "A")
const b = Graph.addNode(mutable, "B")
const c = Graph.addNode(mutable, "C")
Graph.addEdge(mutable, a, b, 1)
})
const indices = Array.from(Graph.indices(Graph.nodes(graph)))
console.log(indices) // [0, 1, 2]export const const nodes: <
N,
E,
T extends Kind = "directed"
>(
graph: Graph<N, E, T> | MutableGraph<N, E, T>
) => NodeWalker<N>
Creates an iterator over all node indices in the graph.
Details
The iterator produces node indices in the order they were added to the graph.
This provides access to all nodes regardless of connectivity.
Example (Iterating all nodes)
import { Graph } from "effect"
const graph = Graph.directed<string, number>((mutable) => {
const a = Graph.addNode(mutable, "A")
const b = Graph.addNode(mutable, "B")
const c = Graph.addNode(mutable, "C")
Graph.addEdge(mutable, a, b, 1)
})
const indices = Array.from(Graph.indices(Graph.nodes(graph)))
console.log(indices) // [0, 1, 2]
nodes = <function (type parameter) N in <N, E, T extends Kind = "directed">(graph: Graph<N, E, T> | MutableGraph<N, E, T>): NodeWalker<N>N, function (type parameter) E in <N, E, T extends Kind = "directed">(graph: Graph<N, E, T> | MutableGraph<N, E, T>): NodeWalker<N>E, function (type parameter) T in <N, E, T extends Kind = "directed">(graph: Graph<N, E, T> | MutableGraph<N, E, T>): NodeWalker<N>T extends type Kind = "directed" | "undirected"Graph type for distinguishing directed and undirected graphs.
When to use
Use when writing graph-polymorphic types or helpers that need to preserve
whether a graph is directed or undirected.
Kind = "directed">(
graph: Graph<N, E, T> | MutableGraph<N, E, T>graph: interface Graph<out N, out E, T extends Kind = "directed">Immutable graph interface.
When to use
Use as the immutable graph model for code that queries, traverses,
transforms, or analyzes graph structure without mutating it.
Graph<function (type parameter) N in <N, E, T extends Kind = "directed">(graph: Graph<N, E, T> | MutableGraph<N, E, T>): NodeWalker<N>N, function (type parameter) E in <N, E, T extends Kind = "directed">(graph: Graph<N, E, T> | MutableGraph<N, E, T>): NodeWalker<N>E, function (type parameter) T in <N, E, T extends Kind = "directed">(graph: Graph<N, E, T> | MutableGraph<N, E, T>): NodeWalker<N>T> | interface MutableGraph<out N, out E, T extends Kind = "directed">Mutable graph interface.
When to use
Use when adding, removing, or updating nodes and edges inside a graph
mutation scope.
MutableGraph<function (type parameter) N in <N, E, T extends Kind = "directed">(graph: Graph<N, E, T> | MutableGraph<N, E, T>): NodeWalker<N>N, function (type parameter) E in <N, E, T extends Kind = "directed">(graph: Graph<N, E, T> | MutableGraph<N, E, T>): NodeWalker<N>E, function (type parameter) T in <N, E, T extends Kind = "directed">(graph: Graph<N, E, T> | MutableGraph<N, E, T>): NodeWalker<N>T>
): type NodeWalker<N> = Walker<number, N>Type alias for node iteration using Walker.
NodeWalker is represented as Walker<NodeIndex, N>.
When to use
Use as the shared node walker type returned by graph traversal and node
listing APIs.
NodeWalker<function (type parameter) N in <N, E, T extends Kind = "directed">(graph: Graph<N, E, T> | MutableGraph<N, E, T>): NodeWalker<N>N> =>
new constructor Walker<number, N>(visit: <U>(f: (index: number, data: N) => U) => Iterable<U>): Walker<number, N>Represents an iterable wrapper used by graph traversal and listing APIs.
Details
A Walker yields [index, data] pairs lazily and can be viewed as just the
indices, just the values, or mapped entries with indices, values,
entries, and visit.
Example (Working with node walkers)
import { Graph } from "effect"
const graph = Graph.directed<string, number>((mutable) => {
const a = Graph.addNode(mutable, "A")
const b = Graph.addNode(mutable, "B")
Graph.addEdge(mutable, a, b, 1)
})
// Both traversal and element iterators return NodeWalker
const dfsNodes: Graph.NodeWalker<string> = Graph.dfs(graph, { start: [0] })
const allNodes: Graph.NodeWalker<string> = Graph.nodes(graph)
// Common interface for working with node iterables
function processNodes<N>(nodeIterable: Graph.NodeWalker<N>): Array<number> {
return Array.from(Graph.indices(nodeIterable))
}
// Access node data using values() or entries()
const nodeData = Array.from(Graph.values(dfsNodes)) // ["A", "B"]
const nodeEntries = Array.from(Graph.entries(allNodes)) // [[0, "A"], [1, "B"]]
Walker((f: (index: number, data: N) => Uf) => ({
[var Symbol: SymbolConstructorSymbol.SymbolConstructor.iterator: typeof Symbol.iteratorA method that returns the default iterator for an object. Called by the semantics of the
for-of statement.
iterator]() {
const const nodeMap: Map<number, N>nodeMap = graph: Graph<N, E, T> | MutableGraph<N, E, T>graph.Proto<out N, out E>.nodes: Map<NodeIndex, N>nodes
const const iterator: MapIterator<[number, N]>iterator = const nodeMap: Map<number, N>nodeMap.Map<number, N>.entries(): MapIterator<[number, N]>Returns an iterable of key, value pairs for every entry in the map.
entries()
return {
Iterator<U, any, any>.next(...[value]: [] | [any]): IteratorResult<U, any>next() {
const const result: IteratorResult<
[number, N],
undefined
>
result = const iterator: MapIterator<[number, N]>iterator.Iterator<[number, N], undefined, unknown>.next(...[value]: [] | [unknown]): IteratorResult<[number, N], undefined>next()
if (const result: IteratorResult<
[number, N],
undefined
>
result.done?: boolean | undefineddone) {
return { IteratorReturnResult<TReturn>.done: truedone: true, IteratorReturnResult<any>.value: anyvalue: var undefinedundefined }
}
const [const nodeIndex: numbernodeIndex, const nodeData: NnodeData] = const result: IteratorYieldResult<
[number, N]
>
result.IteratorYieldResult<[number, N]>.value: [number, N](property) IteratorYieldResult<[number, N]>.value: {
0: number;
1: N;
length: 2;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
pop: () => number | N | undefined;
push: (...items: Array<number | N>) => number;
concat: { (...items: Array<ConcatArray<number | N>>): Array<number | N>; (...items: Array<number | N | ConcatArray<number | N>>): Array<number | N> };
join: (separator?: string) => string;
reverse: () => Array<number | N>;
shift: () => number | N | undefined;
slice: (start?: number, end?: number) => Array<number | N>;
sort: (compareFn?: ((a: number | N, b: number | N) => number) | undefined) => [number, N];
splice: { (start: number, deleteCount?: number): Array<number | N>; (start: number, deleteCount: number, ...items: Array<number | N>): Array<number | N> };
unshift: (...items: Array<number | N>) => number;
indexOf: (searchElement: number | N, fromIndex?: number) => number;
lastIndexOf: (searchElement: number | N, fromIndex?: number) => number;
every: { (predicate: (value: number | N, index: number, array: Array<number | N>) => value is S, thisArg?: any): this is S[]; (predicate: (value: number | N, index: number, array: Array<number | N>) => unknown, thisArg?: any): boolean };
some: (predicate: (value: number | N, index: number, array: Array<number | N>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: number | N, index: number, array: Array<number | N>) => void, thisArg?: any) => void;
map: (callbackfn: (value: number | N, index: number, array: Array<number | N>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: number | N, index: number, array: Array<number | N>) => value is S, thisArg?: any): Array<S>; (predicate: (value: number | N, index: number, array: Array<number | N>) => unknown, thisArg?: any): Array<number | N> };
reduce: { (callbackfn: (previousValue: number | N, currentValue: number | N, currentIndex: number, array: Array<number | N>) => number | N): number | N; (callbackfn: (previousValue: number | N, currentValue: number | N, currentIndex: number, array…;
reduceRight: { (callbackfn: (previousValue: number | N, currentValue: number | N, currentIndex: number, array: Array<number | N>) => number | N): number | N; (callbackfn: (previousValue: number | N, currentValue: number | N, currentIndex: number, array…;
find: { (predicate: (value: number | N, index: number, obj: Array<number | N>) => value is S, thisArg?: any): S | undefined; (predicate: (value: number | N, index: number, obj: Array<number | N>) => unknown, thisArg?: any): number | N | undefine…;
findIndex: (predicate: (value: number | N, index: number, obj: Array<number | N>) => unknown, thisArg?: any) => number;
fill: (value: number | N, start?: number, end?: number) => [number, N];
copyWithin: (target: number, start: number, end?: number) => [number, N];
entries: () => ArrayIterator<[number, number | N]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<number | N>;
includes: (searchElement: number | N, fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: number | N, index: number, array: Array<number | N>) => U | ReadonlyArray<U>, thisArg?: This | undefined) => Array<U>;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => number | N | undefined;
findLast: { (predicate: (value: number | N, index: number, array: Array<number | N>) => value is S, thisArg?: any): S | undefined; (predicate: (value: number | N, index: number, array: Array<number | N>) => unknown, thisArg?: any): number | N | unde…;
findLastIndex: (predicate: (value: number | N, index: number, array: Array<number | N>) => unknown, thisArg?: any) => number;
toReversed: () => Array<number | N>;
toSorted: (compareFn?: ((a: number | N, b: number | N) => number) | undefined) => Array<number | N>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<number | N>): Array<number | N>; (start: number, deleteCount?: number): Array<number | N> };
with: (index: number, value: number | N) => Array<number | N>;
}
value
return { IteratorYieldResult<TYield>.done?: false | undefineddone: false, IteratorYieldResult<U>.value: Uvalue: f: (index: number, data: N) => Uf(const nodeIndex: numbernodeIndex, const nodeData: NnodeData) }
}
}
}
}))