<N, E, T extends Kind = "directed">(
graph: Graph<N, E, T> | MutableGraph<N, E, T>
): EdgeWalker<E>Creates an iterator over all edge indices in the graph.
Details
The iterator produces edge indices in the order they were added to the graph. This provides access to all edges regardless of connectivity.
Example (Iterating all edges)
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)
Graph.addEdge(mutable, b, c, 2)
})
const indices = Array.from(Graph.indices(Graph.edges(graph)))
console.log(indices) // [0, 1]iterators
Source effect/Graph.ts:476520 lines
export const const edges: <
N,
E,
T extends Kind = "directed"
>(
graph: Graph<N, E, T> | MutableGraph<N, E, T>
) => EdgeWalker<E>
Creates an iterator over all edge indices in the graph.
Details
The iterator produces edge indices in the order they were added to the graph.
This provides access to all edges regardless of connectivity.
Example (Iterating all edges)
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)
Graph.addEdge(mutable, b, c, 2)
})
const indices = Array.from(Graph.indices(Graph.edges(graph)))
console.log(indices) // [0, 1]
edges = <function (type parameter) N in <N, E, T extends Kind = "directed">(graph: Graph<N, E, T> | MutableGraph<N, E, T>): EdgeWalker<E>N, function (type parameter) E in <N, E, T extends Kind = "directed">(graph: Graph<N, E, T> | MutableGraph<N, E, T>): EdgeWalker<E>E, function (type parameter) T in <N, E, T extends Kind = "directed">(graph: Graph<N, E, T> | MutableGraph<N, E, T>): EdgeWalker<E>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>): EdgeWalker<E>N, function (type parameter) E in <N, E, T extends Kind = "directed">(graph: Graph<N, E, T> | MutableGraph<N, E, T>): EdgeWalker<E>E, function (type parameter) T in <N, E, T extends Kind = "directed">(graph: Graph<N, E, T> | MutableGraph<N, E, T>): EdgeWalker<E>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>): EdgeWalker<E>N, function (type parameter) E in <N, E, T extends Kind = "directed">(graph: Graph<N, E, T> | MutableGraph<N, E, T>): EdgeWalker<E>E, function (type parameter) T in <N, E, T extends Kind = "directed">(graph: Graph<N, E, T> | MutableGraph<N, E, T>): EdgeWalker<E>T>
): type EdgeWalker<E> = Walker<
number,
Edge<E>
>
Type alias for edge iteration using Walker.
EdgeWalker is represented as Walker<EdgeIndex, Edge>.
When to use
Use to type helpers or parameters that consume edge iterators returned by
Graph APIs, where each item is keyed by an EdgeIndex and carries the
full Edge.
EdgeWalker<function (type parameter) E in <N, E, T extends Kind = "directed">(graph: Graph<N, E, T> | MutableGraph<N, E, T>): EdgeWalker<E>E> =>
new constructor Walker<number, Edge<E>>(visit: <U>(f: (index: number, data: Edge<E>) => U) => Iterable<U>): Walker<number, Edge<E>>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: Edge<E>) => 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 edgeMap: Map<number, Edge<E>>edgeMap = graph: Graph<N, E, T> | MutableGraph<N, E, T>graph.Proto<out N, out E>.edges: Map<EdgeIndex, Edge<E>>edges
const const iterator: MapIterator<
[number, Edge<E>]
>
const edgeMap: Map<number, Edge<E>>edgeMap.Map<number, Edge<E>>.entries(): MapIterator<[number, Edge<E>]>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, Edge<E>],
undefined
>
const iterator: MapIterator<
[number, Edge<E>]
>
Iterator<[number, Edge<E>], undefined, unknown>.next(...[value]: [] | [unknown]): IteratorResult<[number, Edge<E>], undefined>next()
if (const result: IteratorResult<
[number, Edge<E>],
undefined
>
done?: boolean | undefineddone) {
return { IteratorReturnResult<TReturn>.done: truedone: true, IteratorReturnResult<any>.value: anyvalue: var undefinedundefined }
}
const [const edgeIndex: numberedgeIndex, const edgeData: Edge<E>const edgeData: {
source: number;
target: number;
data: E;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
const result: IteratorYieldResult<
[number, Edge<E>]
>
IteratorYieldResult<[number, Edge<E>]>.value: [number, Edge<E>](property) IteratorYieldResult<[number, Edge<E>]>.value: {
0: number;
1: Edge<E>;
length: 2;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
pop: () => number | Edge<E> | undefined;
push: (...items: Array<number | Edge<E>>) => number;
concat: { (...items: Array<ConcatArray<number | Edge<E>>>): Array<number | Edge<E>>; (...items: Array<number | Edge<E> | ConcatArray<number | Edge<E>>>): Array<number | Edge<E>> };
join: (separator?: string) => string;
reverse: () => Array<number | Edge<E>>;
shift: () => number | Edge<E> | undefined;
slice: (start?: number, end?: number) => Array<number | Edge<E>>;
sort: (compareFn?: ((a: number | Edge<E>, b: number | Edge<E>) => number) | undefined) => [number, Edge<E>];
splice: { (start: number, deleteCount?: number): Array<number | Edge<E>>; (start: number, deleteCount: number, ...items: Array<number | Edge<E>>): Array<number | Edge<E>> };
unshift: (...items: Array<number | Edge<E>>) => number;
indexOf: (searchElement: number | Edge<E>, fromIndex?: number) => number;
lastIndexOf: (searchElement: number | Edge<E>, fromIndex?: number) => number;
every: { (predicate: (value: number | Edge<E>, index: number, array: Array<number | Edge<E>>) => value is S, thisArg?: any): this is S[]; (predicate: (value: number | Edge<E>, index: number, array: Array<number | Edge<E>>) => unknown, thisArg?: a…;
some: (predicate: (value: number | Edge<E>, index: number, array: Array<number | Edge<E>>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: number | Edge<E>, index: number, array: Array<number | Edge<E>>) => void, thisArg?: any) => void;
map: (callbackfn: (value: number | Edge<E>, index: number, array: Array<number | Edge<E>>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: number | Edge<E>, index: number, array: Array<number | Edge<E>>) => value is S, thisArg?: any): Array<S>; (predicate: (value: number | Edge<E>, index: number, array: Array<number | Edge<E>>) => unknown, thisArg?: any)…;
reduce: { (callbackfn: (previousValue: number | Edge<E>, currentValue: number | Edge<E>, currentIndex: number, array: Array<number | Edge<E>>) => number | Edge<E>): number | Edge<E>; (callbackfn: (previousValue: number | Edge<E>, currentValue: num…;
reduceRight: { (callbackfn: (previousValue: number | Edge<E>, currentValue: number | Edge<E>, currentIndex: number, array: Array<number | Edge<E>>) => number | Edge<E>): number | Edge<E>; (callbackfn: (previousValue: number | Edge<E>, currentValue: num…;
find: { (predicate: (value: number | Edge<E>, index: number, obj: Array<number | Edge<E>>) => value is S, thisArg?: any): S | undefined; (predicate: (value: number | Edge<E>, index: number, obj: Array<number | Edge<E>>) => unknown, thisArg?: any…;
findIndex: (predicate: (value: number | Edge<E>, index: number, obj: Array<number | Edge<E>>) => unknown, thisArg?: any) => number;
fill: (value: number | Edge<E>, start?: number, end?: number) => [number, Edge<E>];
copyWithin: (target: number, start: number, end?: number) => [number, Edge<E>];
entries: () => ArrayIterator<[number, number | Edge<E>]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<number | Edge<E>>;
includes: (searchElement: number | Edge<E>, fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: number | Edge<E>, index: number, array: Array<number | Edge<E>>) => U | ReadonlyArray<U>, thisArg?: This | undefined) => Array<U>;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => number | Edge<E> | undefined;
findLast: { (predicate: (value: number | Edge<E>, index: number, array: Array<number | Edge<E>>) => value is S, thisArg?: any): S | undefined; (predicate: (value: number | Edge<E>, index: number, array: Array<number | Edge<E>>) => unknown, thisArg?:…;
findLastIndex: (predicate: (value: number | Edge<E>, index: number, array: Array<number | Edge<E>>) => unknown, thisArg?: any) => number;
toReversed: () => Array<number | Edge<E>>;
toSorted: (compareFn?: ((a: number | Edge<E>, b: number | Edge<E>) => number) | undefined) => Array<number | Edge<E>>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<number | Edge<E>>): Array<number | Edge<E>>; (start: number, deleteCount?: number): Array<number | Edge<E>> };
with: (index: number, value: number | Edge<E>) => Array<number | Edge<E>>;
}
IteratorYieldResult<TYield>.done?: false | undefineddone: false, IteratorYieldResult<U>.value: Uvalue: f: (index: number, data: Edge<E>) => Uf(const edgeIndex: numberedgeIndex, const edgeData: Edge<E>const edgeData: {
source: number;
target: number;
data: E;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}