<A extends PrimaryKey.PrimaryKey>(node: A): (
self: HashRing<A>
) => HashRing<A>
<A extends PrimaryKey.PrimaryKey>(self: HashRing<A>, node: A): HashRing<A>Removes the node from the ring. No-op's if the node does not exist.
When to use
Use to remove a node that has left the pool so future lookups and shard assignments stop returning it.
Details
Removal matches by PrimaryKey.value, so any value with the same primary key
removes the same ring member.
Gotchas
This mutates and returns the same ring instance.
export const const remove: {
<A extends PrimaryKey.PrimaryKey>(node: A): (
self: HashRing<A>
) => HashRing<A>
<A extends PrimaryKey.PrimaryKey>(
self: HashRing<A>,
node: A
): HashRing<A>
}
Removes the node from the ring. No-op's if the node does not exist.
When to use
Use to remove a node that has left the pool so future lookups and shard
assignments stop returning it.
Details
Removal matches by PrimaryKey.value, so any value with the same primary key
removes the same ring member.
Gotchas
This mutates and returns the same ring instance.
remove: {
<function (type parameter) A in <A extends PrimaryKey.PrimaryKey>(node: A): (self: HashRing<A>) => HashRing<A>A extends import PrimaryKeyPrimaryKey.PrimaryKey>(node: A extends PrimaryKey.PrimaryKeynode: function (type parameter) A in <A extends PrimaryKey.PrimaryKey>(node: A): (self: HashRing<A>) => HashRing<A>A): (self: HashRing<A>(parameter) self: {
baseWeight: number;
totalWeightCache: number;
nodes: Map<string, [node: A, weight: number]>;
ring: Array<[hash: number, node: string]>;
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; <…;
}
interface HashRing<A extends PrimaryKey.PrimaryKey>A weighted consistent-hashing ring for assigning inputs to nodes with stable
remapping as nodes are added or removed.
When to use
Use to maintain a mutable weighted hash ring for routing keys or shards to
nodes identified by PrimaryKey.
Details
Nodes are identified by their PrimaryKey value and can be iterated from the
ring.
HashRing<function (type parameter) A in <A extends PrimaryKey.PrimaryKey>(node: A): (self: HashRing<A>) => HashRing<A>A>) => interface HashRing<A extends PrimaryKey.PrimaryKey>A weighted consistent-hashing ring for assigning inputs to nodes with stable
remapping as nodes are added or removed.
When to use
Use to maintain a mutable weighted hash ring for routing keys or shards to
nodes identified by PrimaryKey.
Details
Nodes are identified by their PrimaryKey value and can be iterated from the
ring.
HashRing<function (type parameter) A in <A extends PrimaryKey.PrimaryKey>(node: A): (self: HashRing<A>) => HashRing<A>A>
<function (type parameter) A in <A extends PrimaryKey.PrimaryKey>(self: HashRing<A>, node: A): HashRing<A>A extends import PrimaryKeyPrimaryKey.PrimaryKey>(self: HashRing<A>(parameter) self: {
baseWeight: number;
totalWeightCache: number;
nodes: Map<string, [node: A, weight: number]>;
ring: Array<[hash: number, node: string]>;
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; <…;
}
interface HashRing<A extends PrimaryKey.PrimaryKey>A weighted consistent-hashing ring for assigning inputs to nodes with stable
remapping as nodes are added or removed.
When to use
Use to maintain a mutable weighted hash ring for routing keys or shards to
nodes identified by PrimaryKey.
Details
Nodes are identified by their PrimaryKey value and can be iterated from the
ring.
HashRing<function (type parameter) A in <A extends PrimaryKey.PrimaryKey>(self: HashRing<A>, node: A): HashRing<A>A>, node: A extends PrimaryKey.PrimaryKeynode: function (type parameter) A in <A extends PrimaryKey.PrimaryKey>(self: HashRing<A>, node: A): HashRing<A>A): interface HashRing<A extends PrimaryKey.PrimaryKey>A weighted consistent-hashing ring for assigning inputs to nodes with stable
remapping as nodes are added or removed.
When to use
Use to maintain a mutable weighted hash ring for routing keys or shards to
nodes identified by PrimaryKey.
Details
Nodes are identified by their PrimaryKey value and can be iterated from the
ring.
HashRing<function (type parameter) A in <A extends PrimaryKey.PrimaryKey>(self: HashRing<A>, node: A): HashRing<A>A>
} = import dualdual(2, <function (type parameter) A in <A extends PrimaryKey.PrimaryKey>(self: HashRing<A>, node: A): HashRing<A>A extends import PrimaryKeyPrimaryKey.PrimaryKey>(self: HashRing<A>(parameter) self: {
baseWeight: number;
totalWeightCache: number;
nodes: Map<string, [node: A, weight: number]>;
ring: Array<[hash: number, node: string]>;
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; <…;
}
interface HashRing<A extends PrimaryKey.PrimaryKey>A weighted consistent-hashing ring for assigning inputs to nodes with stable
remapping as nodes are added or removed.
When to use
Use to maintain a mutable weighted hash ring for routing keys or shards to
nodes identified by PrimaryKey.
Details
Nodes are identified by their PrimaryKey value and can be iterated from the
ring.
HashRing<function (type parameter) A in <A extends PrimaryKey.PrimaryKey>(self: HashRing<A>, node: A): HashRing<A>A>, node: A extends PrimaryKey.PrimaryKeynode: function (type parameter) A in <A extends PrimaryKey.PrimaryKey>(self: HashRing<A>, node: A): HashRing<A>A): interface HashRing<A extends PrimaryKey.PrimaryKey>A weighted consistent-hashing ring for assigning inputs to nodes with stable
remapping as nodes are added or removed.
When to use
Use to maintain a mutable weighted hash ring for routing keys or shards to
nodes identified by PrimaryKey.
Details
Nodes are identified by their PrimaryKey value and can be iterated from the
ring.
HashRing<function (type parameter) A in <A extends PrimaryKey.PrimaryKey>(self: HashRing<A>, node: A): HashRing<A>A> => {
const const key: stringkey = import PrimaryKeyPrimaryKey.const value: (self: PrimaryKey) => stringExtracts the string value from a PrimaryKey.
When to use
Use to read the stable string identifier from a value that implements
PrimaryKey.
Example (Reading primary key values)
import { PrimaryKey } from "effect"
class OrderId implements PrimaryKey.PrimaryKey {
constructor(private timestamp: number, private sequence: number) {}
[PrimaryKey.symbol](): string {
return `order_${this.timestamp}_${this.sequence}`
}
}
const orderId = new OrderId(1640995200000, 1)
console.log(PrimaryKey.value(orderId)) // "order_1640995200000_1"
// Can also be used with simple string-based implementations
const simpleKey = {
[PrimaryKey.symbol]: () => "simple-key-123"
}
console.log(PrimaryKey.value(simpleKey)) // "simple-key-123"
value(node: A extends PrimaryKey.PrimaryKeynode)
const const entry:
| [node: A, weight: number]
| undefined
self: HashRing<A>(parameter) self: {
baseWeight: number;
totalWeightCache: number;
nodes: Map<string, [node: A, weight: number]>;
ring: Array<[hash: number, node: string]>;
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; <…;
}
HashRing<A>.nodes: Map<string, [node: A, weight: number]>nodes.Map<string, [node: A, weight: number]>.get(key: string): [node: A, weight: number] | undefinedReturns a specified element from the Map object. If the value that is associated to the provided key is an object, then you will get a reference to that object and any change made to that object will effectively modify it inside the Map.
get(const key: stringkey)
if (const entry:
| [node: A, weight: number]
| undefined
self: HashRing<A>(parameter) self: {
baseWeight: number;
totalWeightCache: number;
nodes: Map<string, [node: A, weight: number]>;
ring: Array<[hash: number, node: string]>;
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; <…;
}
HashRing<A>.nodes: Map<string, [node: A, weight: number]>nodes.Map<string, [node: A, weight: number]>.delete(key: string): booleandelete(const key: stringkey)
self: HashRing<A>(parameter) self: {
baseWeight: number;
totalWeightCache: number;
nodes: Map<string, [node: A, weight: number]>;
ring: Array<[hash: number, node: string]>;
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; <…;
}
HashRing<A extends PrimaryKey.PrimaryKey>.ring: [hash: number, node: string][]ring = self: HashRing<A>(parameter) self: {
baseWeight: number;
totalWeightCache: number;
nodes: Map<string, [node: A, weight: number]>;
ring: Array<[hash: number, node: string]>;
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; <…;
}
HashRing<A extends PrimaryKey.PrimaryKey>.ring: [hash: number, node: string][]ring.Array<[hash: number, node: string]>.filter(predicate: (value: [hash: number, node: string], index: number, array: [hash: number, node: string][]) => unknown, thisArg?: any): [hash: number, node: string][] (+1 overload)Returns the elements of an array that meet the condition specified in a callback function.
filter(([, n: stringn]) => n: stringn !== const key: stringkey)
self: HashRing<A>(parameter) self: {
baseWeight: number;
totalWeightCache: number;
nodes: Map<string, [node: A, weight: number]>;
ring: Array<[hash: number, node: string]>;
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; <…;
}
HashRing<A extends PrimaryKey.PrimaryKey>.totalWeightCache: numbertotalWeightCache -= const entry: [node: A, weight: number]const entry: {
0: A;
1: number;
length: 2;
toString: () => string;
toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string };
pop: () => number | A | undefined;
push: (...items: Array<number | A>) => number;
concat: { (...items: Array<ConcatArray<number | A>>): Array<number | A>; (...items: Array<number | A | ConcatArray<number | A>>): Array<number | A> };
join: (separator?: string) => string;
reverse: () => Array<number | A>;
shift: () => number | A | undefined;
slice: (start?: number, end?: number) => Array<number | A>;
sort: (compareFn?: ((a: number | A, b: number | A) => number) | undefined) => [node: A, weight: number];
splice: { (start: number, deleteCount?: number): Array<number | A>; (start: number, deleteCount: number, ...items: Array<number | A>): Array<number | A> };
unshift: (...items: Array<number | A>) => number;
indexOf: (searchElement: number | A, fromIndex?: number) => number;
lastIndexOf: (searchElement: number | A, fromIndex?: number) => number;
every: { (predicate: (value: number | A, index: number, array: Array<number | A>) => value is S, thisArg?: any): this is S[]; (predicate: (value: number | A, index: number, array: Array<number | A>) => unknown, thisArg?: any): boolean };
some: (predicate: (value: number | A, index: number, array: Array<number | A>) => unknown, thisArg?: any) => boolean;
forEach: (callbackfn: (value: number | A, index: number, array: Array<number | A>) => void, thisArg?: any) => void;
map: (callbackfn: (value: number | A, index: number, array: Array<number | A>) => U, thisArg?: any) => Array<U>;
filter: { (predicate: (value: number | A, index: number, array: Array<number | A>) => value is S, thisArg?: any): Array<S>; (predicate: (value: number | A, index: number, array: Array<number | A>) => unknown, thisArg?: any): Array<number | A> };
reduce: { (callbackfn: (previousValue: number | A, currentValue: number | A, currentIndex: number, array: Array<number | A>) => number | A): number | A; (callbackfn: (previousValue: number | A, currentValue: number | A, currentIndex: number, array…;
reduceRight: { (callbackfn: (previousValue: number | A, currentValue: number | A, currentIndex: number, array: Array<number | A>) => number | A): number | A; (callbackfn: (previousValue: number | A, currentValue: number | A, currentIndex: number, array…;
find: { (predicate: (value: number | A, index: number, obj: Array<number | A>) => value is S, thisArg?: any): S | undefined; (predicate: (value: number | A, index: number, obj: Array<number | A>) => unknown, thisArg?: any): number | A | undefine…;
findIndex: (predicate: (value: number | A, index: number, obj: Array<number | A>) => unknown, thisArg?: any) => number;
fill: (value: number | A, start?: number, end?: number) => [node: A, weight: number];
copyWithin: (target: number, start: number, end?: number) => [node: A, weight: number];
entries: () => ArrayIterator<[number, number | A]>;
keys: () => ArrayIterator<number>;
values: () => ArrayIterator<number | A>;
includes: (searchElement: number | A, fromIndex?: number) => boolean;
flatMap: (callback: (this: This, value: number | A, index: number, array: Array<number | A>) => U | ReadonlyArray<U>, thisArg?: This | undefined) => Array<U>;
flat: (this: A, depth?: D | undefined) => Array<FlatArray<A, D>>;
at: (index: number) => number | A | undefined;
findLast: { (predicate: (value: number | A, index: number, array: Array<number | A>) => value is S, thisArg?: any): S | undefined; (predicate: (value: number | A, index: number, array: Array<number | A>) => unknown, thisArg?: any): number | A | unde…;
findLastIndex: (predicate: (value: number | A, index: number, array: Array<number | A>) => unknown, thisArg?: any) => number;
toReversed: () => Array<number | A>;
toSorted: (compareFn?: ((a: number | A, b: number | A) => number) | undefined) => Array<number | A>;
toSpliced: { (start: number, deleteCount: number, ...items: Array<number | A>): Array<number | A>; (start: number, deleteCount?: number): Array<number | A> };
with: (index: number, value: number | A) => Array<number | A>;
}
self: HashRing<A>(parameter) self: {
baseWeight: number;
totalWeightCache: number;
nodes: Map<string, [node: A, weight: number]>;
ring: Array<[hash: number, node: string]>;
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; <…;
}