<N, E>(
mutate?: (mutable: MutableDirectedGraph<N, E>) => void
): DirectedGraph<N, E>Creates a directed graph, optionally with initial mutations.
Example (Creating a directed graph)
import { Graph } from "effect"
// Directed graph with initial nodes and edges
const graph = Graph.directed<string, string>((mutable) => {
const a = Graph.addNode(mutable, "A")
const b = Graph.addNode(mutable, "B")
const c = Graph.addNode(mutable, "C")
Graph.addEdge(mutable, a, b, "A->B")
Graph.addEdge(mutable, b, c, "B->C")
})constructors
Source effect/Graph.ts:39620 lines
export const const directed: <N, E>(
mutate?: (
mutable: MutableDirectedGraph<N, E>
) => void
) => DirectedGraph<N, E>
Creates a directed graph, optionally with initial mutations.
Example (Creating a directed graph)
import { Graph } from "effect"
// Directed graph with initial nodes and edges
const graph = Graph.directed<string, string>((mutable) => {
const a = Graph.addNode(mutable, "A")
const b = Graph.addNode(mutable, "B")
const c = Graph.addNode(mutable, "C")
Graph.addEdge(mutable, a, b, "A->B")
Graph.addEdge(mutable, b, c, "B->C")
})
directed = <function (type parameter) N in <N, E>(mutate?: (mutable: MutableDirectedGraph<N, E>) => void): DirectedGraph<N, E>N, function (type parameter) E in <N, E>(mutate?: (mutable: MutableDirectedGraph<N, E>) => void): DirectedGraph<N, E>E>(mutate: (
mutable: MutableDirectedGraph<N, E>
) => void
mutable: MutableDirectedGraph<N, E>(parameter) mutable: {
type: T;
mutable: true;
nodes: Map<NodeIndex, N>;
edges: Map<EdgeIndex, Edge<E>>;
adjacency: Map<NodeIndex, Array<EdgeIndex>>;
reverseAdjacency: Map<NodeIndex, Array<EdgeIndex>>;
nextNodeIndex: NodeIndex;
nextEdgeIndex: EdgeIndex;
acyclic: Option.Option<boolean>;
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; <…;
toString: () => string;
toJSON: () => unknown;
}
type MutableDirectedGraph<N, E> =
MutableGraph<N, E, "directed">
Mutable directed graph type alias.
When to use
Use when annotating a temporary graph value that can be changed in place and
whose edges have source-to-target direction.
MutableDirectedGraph<function (type parameter) N in <N, E>(mutate?: (mutable: MutableDirectedGraph<N, E>) => void): DirectedGraph<N, E>N, function (type parameter) E in <N, E>(mutate?: (mutable: MutableDirectedGraph<N, E>) => void): DirectedGraph<N, E>E>) => void): type DirectedGraph<N, E> = Graph<
N,
E,
"directed"
>
Immutable graph type for source-to-target relationships.
When to use
Use as the immutable graph type when edge direction is part of the model and
traversal or neighbor queries should follow source-to-target edges.
Details
DirectedGraph<N, E> is a Graph<N, E, "directed"> with node data of type
N and edge data of type E.
DirectedGraph<function (type parameter) N in <N, E>(mutate?: (mutable: MutableDirectedGraph<N, E>) => void): DirectedGraph<N, E>N, function (type parameter) E in <N, E>(mutate?: (mutable: MutableDirectedGraph<N, E>) => void): DirectedGraph<N, E>E> => {
const const graph: Mutable<DirectedGraph<N, E>>const graph: {
type: 'directed';
mutable: false;
nodes: Map<number, N>;
edges: Map<number, Edge<E>>;
adjacency: Map<number, Array<number>>;
reverseAdjacency: Map<number, Array<number>>;
nextNodeIndex: number;
nextEdgeIndex: number;
acyclic: Option.Option<boolean>;
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; <…;
toString: () => string;
toJSON: () => unknown;
}
type Mutable<T> = { -readonly [P in keyof T]: T[P]; }Removes readonly from all properties of T. Supports arrays, tuples,
and records.
When to use
Use when you need a mutable version of a readonly type.
Details
Only affects the top level; nested properties remain readonly.
Example (Converting shallowly to mutable types)
import type { Types } from "effect"
type Obj = Types.Mutable<{
readonly a: string
readonly b: ReadonlyArray<number>
}>
// { a: string; b: ReadonlyArray<number> }
// ^ mutable ^ still readonly inside
type Arr = Types.Mutable<ReadonlyArray<string>>
// string[]
type Tup = Types.Mutable<readonly [string, number]>
// [string, number]
Mutable<type DirectedGraph<N, E> = Graph<
N,
E,
"directed"
>
Immutable graph type for source-to-target relationships.
When to use
Use as the immutable graph type when edge direction is part of the model and
traversal or neighbor queries should follow source-to-target edges.
Details
DirectedGraph<N, E> is a Graph<N, E, "directed"> with node data of type
N and edge data of type E.
DirectedGraph<function (type parameter) N in <N, E>(mutate?: (mutable: MutableDirectedGraph<N, E>) => void): DirectedGraph<N, E>N, function (type parameter) E in <N, E>(mutate?: (mutable: MutableDirectedGraph<N, E>) => void): DirectedGraph<N, E>E>> = var Object: ObjectConstructorProvides functionality common to all JavaScript objects.
Object.ObjectConstructor.create(o: object | null): any (+1 overload)Creates an object that has the specified prototype or that has null prototype.
create(const ProtoGraph: {
"~effect/collections/Graph": string
[Symbol.iterator](
this: Graph<any, any>
): MapIterator<[number, any]>
[NodeInspectSymbol](
this: Graph<any, any>
): unknown
"~effect/interfaces/Equal"(
this: Graph<any, any>,
that: Equal.Equal
): boolean
"~effect/interfaces/Hash"(
this: Graph<any, any>
): number
toJSON(this: Graph<any, any>): {
_id: string
nodeCount: number
edgeCount: number
type: "directed"
}
toString(this: Graph<any, any>): string
pipe(): unknown
}
const graph: Mutable<DirectedGraph<N, E>>const graph: {
type: 'directed';
mutable: false;
nodes: Map<number, N>;
edges: Map<number, Edge<E>>;
adjacency: Map<number, Array<number>>;
reverseAdjacency: Map<number, Array<number>>;
nextNodeIndex: number;
nextEdgeIndex: number;
acyclic: Option.Option<boolean>;
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; <…;
toString: () => string;
toJSON: () => unknown;
}
type: "directed"type = "directed"
const graph: Mutable<DirectedGraph<N, E>>const graph: {
type: 'directed';
mutable: false;
nodes: Map<number, N>;
edges: Map<number, Edge<E>>;
adjacency: Map<number, Array<number>>;
reverseAdjacency: Map<number, Array<number>>;
nextNodeIndex: number;
nextEdgeIndex: number;
acyclic: Option.Option<boolean>;
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; <…;
toString: () => string;
toJSON: () => unknown;
}
nodes: Map<number, N>nodes = new var Map: MapConstructor
new () => Map<any, any> (+3 overloads)
const graph: Mutable<DirectedGraph<N, E>>const graph: {
type: 'directed';
mutable: false;
nodes: Map<number, N>;
edges: Map<number, Edge<E>>;
adjacency: Map<number, Array<number>>;
reverseAdjacency: Map<number, Array<number>>;
nextNodeIndex: number;
nextEdgeIndex: number;
acyclic: Option.Option<boolean>;
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; <…;
toString: () => string;
toJSON: () => unknown;
}
edges: Map<number, Edge<E>>edges = new var Map: MapConstructor
new () => Map<any, any> (+3 overloads)
const graph: Mutable<DirectedGraph<N, E>>const graph: {
type: 'directed';
mutable: false;
nodes: Map<number, N>;
edges: Map<number, Edge<E>>;
adjacency: Map<number, Array<number>>;
reverseAdjacency: Map<number, Array<number>>;
nextNodeIndex: number;
nextEdgeIndex: number;
acyclic: Option.Option<boolean>;
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; <…;
toString: () => string;
toJSON: () => unknown;
}
adjacency: Map<number, number[]>adjacency = new var Map: MapConstructor
new () => Map<any, any> (+3 overloads)
const graph: Mutable<DirectedGraph<N, E>>const graph: {
type: 'directed';
mutable: false;
nodes: Map<number, N>;
edges: Map<number, Edge<E>>;
adjacency: Map<number, Array<number>>;
reverseAdjacency: Map<number, Array<number>>;
nextNodeIndex: number;
nextEdgeIndex: number;
acyclic: Option.Option<boolean>;
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; <…;
toString: () => string;
toJSON: () => unknown;
}
reverseAdjacency: Map<number, number[]>reverseAdjacency = new var Map: MapConstructor
new () => Map<any, any> (+3 overloads)
const graph: Mutable<DirectedGraph<N, E>>const graph: {
type: 'directed';
mutable: false;
nodes: Map<number, N>;
edges: Map<number, Edge<E>>;
adjacency: Map<number, Array<number>>;
reverseAdjacency: Map<number, Array<number>>;
nextNodeIndex: number;
nextEdgeIndex: number;
acyclic: Option.Option<boolean>;
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; <…;
toString: () => string;
toJSON: () => unknown;
}
nextNodeIndex: numbernextNodeIndex = 0
const graph: Mutable<DirectedGraph<N, E>>const graph: {
type: 'directed';
mutable: false;
nodes: Map<number, N>;
edges: Map<number, Edge<E>>;
adjacency: Map<number, Array<number>>;
reverseAdjacency: Map<number, Array<number>>;
nextNodeIndex: number;
nextEdgeIndex: number;
acyclic: Option.Option<boolean>;
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; <…;
toString: () => string;
toJSON: () => unknown;
}
nextEdgeIndex: numbernextEdgeIndex = 0
const graph: Mutable<DirectedGraph<N, E>>const graph: {
type: 'directed';
mutable: false;
nodes: Map<number, N>;
edges: Map<number, Edge<E>>;
adjacency: Map<number, Array<number>>;
reverseAdjacency: Map<number, Array<number>>;
nextNodeIndex: number;
nextEdgeIndex: number;
acyclic: Option.Option<boolean>;
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; <…;
toString: () => string;
toJSON: () => unknown;
}
acyclic: Option.Option<boolean>acyclic = import OptionOption.const some: <A>(value: A) => Option<A>Wraps the given value into an Option to represent its presence.
When to use
Use to wrap a known present value as Option
- Returning a successful result from a partial function
Details
- Always returns
Some<A>
- Does not filter
null or undefined; use
fromNullishOr
for that
Example (Wrapping a value)
import { Option } from "effect"
// ┌─── Option<number>
// ▼
const value = Option.some(1)
console.log(value)
// Output: { _id: 'Option', _tag: 'Some', value: 1 }
some(true)
const graph: Mutable<DirectedGraph<N, E>>const graph: {
type: 'directed';
mutable: false;
nodes: Map<number, N>;
edges: Map<number, Edge<E>>;
adjacency: Map<number, Array<number>>;
reverseAdjacency: Map<number, Array<number>>;
nextNodeIndex: number;
nextEdgeIndex: number;
acyclic: Option.Option<boolean>;
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; <…;
toString: () => string;
toJSON: () => unknown;
}
mutable: falsemutable = false
if (mutate: (
mutable: MutableDirectedGraph<N, E>
) => void
const mutable: MutableGraph<
N,
E,
"directed"
>
const mutable: {
type: T;
mutable: true;
nodes: Map<NodeIndex, N>;
edges: Map<EdgeIndex, Edge<E>>;
adjacency: Map<NodeIndex, Array<EdgeIndex>>;
reverseAdjacency: Map<NodeIndex, Array<EdgeIndex>>;
nextNodeIndex: NodeIndex;
nextEdgeIndex: EdgeIndex;
acyclic: Option.Option<boolean>;
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; <…;
toString: () => string;
toJSON: () => unknown;
}
const beginMutation: <
N,
E,
T extends Kind = "directed"
>(
graph: Graph<N, E, T>
) => MutableGraph<N, E, T>
Creates a mutable scope for safe graph mutations by copying the data structure.
Example (Beginning a mutation scope)
import { Graph } from "effect"
const graph = Graph.directed<string, number>()
const mutable = Graph.beginMutation(graph)
// Now mutable can be safely modified without affecting original graph
beginMutation(const graph: Mutable<DirectedGraph<N, E>>const graph: {
type: 'directed';
mutable: false;
nodes: Map<number, N>;
edges: Map<number, Edge<E>>;
adjacency: Map<number, Array<number>>;
reverseAdjacency: Map<number, Array<number>>;
nextNodeIndex: number;
nextEdgeIndex: number;
acyclic: Option.Option<boolean>;
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; <…;
toString: () => string;
toJSON: () => unknown;
}
type DirectedGraph<N, E> = Graph<
N,
E,
"directed"
>
Immutable graph type for source-to-target relationships.
When to use
Use as the immutable graph type when edge direction is part of the model and
traversal or neighbor queries should follow source-to-target edges.
Details
DirectedGraph<N, E> is a Graph<N, E, "directed"> with node data of type
N and edge data of type E.
DirectedGraph<function (type parameter) N in <N, E>(mutate?: (mutable: MutableDirectedGraph<N, E>) => void): DirectedGraph<N, E>N, function (type parameter) E in <N, E>(mutate?: (mutable: MutableDirectedGraph<N, E>) => void): DirectedGraph<N, E>E>)
mutate: (
mutable: MutableDirectedGraph<N, E>
) => void
const mutable: MutableGraph<
N,
E,
"directed"
>
const mutable: {
type: T;
mutable: true;
nodes: Map<NodeIndex, N>;
edges: Map<EdgeIndex, Edge<E>>;
adjacency: Map<NodeIndex, Array<EdgeIndex>>;
reverseAdjacency: Map<NodeIndex, Array<EdgeIndex>>;
nextNodeIndex: NodeIndex;
nextEdgeIndex: EdgeIndex;
acyclic: Option.Option<boolean>;
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; <…;
toString: () => string;
toJSON: () => unknown;
}
type MutableDirectedGraph<N, E> =
MutableGraph<N, E, "directed">
Mutable directed graph type alias.
When to use
Use when annotating a temporary graph value that can be changed in place and
whose edges have source-to-target direction.
MutableDirectedGraph<function (type parameter) N in <N, E>(mutate?: (mutable: MutableDirectedGraph<N, E>) => void): DirectedGraph<N, E>N, function (type parameter) E in <N, E>(mutate?: (mutable: MutableDirectedGraph<N, E>) => void): DirectedGraph<N, E>E>)
return const endMutation: <
N,
E,
T extends Kind = "directed"
>(
mutable: MutableGraph<N, E, T>
) => Graph<N, E, T>
Converts a mutable graph back to an immutable graph, ending the mutation scope.
Example (Ending a mutation scope)
import { Graph } from "effect"
const graph = Graph.directed<string, number>()
const mutable = Graph.beginMutation(graph)
// ... perform mutations on mutable ...
const newGraph = Graph.endMutation(mutable)
endMutation(const mutable: MutableGraph<
N,
E,
"directed"
>
const mutable: {
type: T;
mutable: true;
nodes: Map<NodeIndex, N>;
edges: Map<EdgeIndex, Edge<E>>;
adjacency: Map<NodeIndex, Array<EdgeIndex>>;
reverseAdjacency: Map<NodeIndex, Array<EdgeIndex>>;
nextNodeIndex: NodeIndex;
nextEdgeIndex: EdgeIndex;
acyclic: Option.Option<boolean>;
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; <…;
toString: () => string;
toJSON: () => unknown;
}
const graph: Mutable<DirectedGraph<N, E>>const graph: {
type: 'directed';
mutable: false;
nodes: Map<number, N>;
edges: Map<number, Edge<E>>;
adjacency: Map<number, Array<number>>;
reverseAdjacency: Map<number, Array<number>>;
nextNodeIndex: number;
nextEdgeIndex: number;
acyclic: Option.Option<boolean>;
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; <…;
toString: () => string;
toJSON: () => unknown;
}