effect 2.0.0-next.44 → 2.0.0-next.46

package/src/GlobalValue.ts

@@ -0,0 +1,20 @@
+/**
+ * @since 2.0.0
+ */
+const globalStoreId = Symbol.for("effect/GlobalValue/globalStoreId")
+
+if (!(globalStoreId in globalThis)) {
+  ;(globalThis as any)[globalStoreId] = new Map()
+}
+
+const globalStore = (globalThis as any)[globalStoreId] as Map<unknown, any>
+
+/**
+ * @since 2.0.0
+ */
+export const globalValue = <A>(id: unknown, compute: () => A): A => {
+  if (!globalStore.has(id)) {
+    globalStore.set(id, compute())
+  }
+  return globalStore.get(id)!
+}

package/src/GroupBy.ts

@@ -0,0 +1,102 @@
+/**
+ * @since 2.0.0
+ */
+import * as internal from "./internal/groupBy"
+import type { Pipeable } from "./Pipeable"
+import type { Predicate } from "./Predicate"
+import type * as Queue from "./Queue"
+import type * as Stream from "./Stream"
+import type * as Take from "./Take"
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const GroupByTypeId: unique symbol = internal.GroupByTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type GroupByTypeId = typeof GroupByTypeId
+
+/**
+ * Representation of a grouped stream. This allows to filter which groups will
+ * be processed. Once this is applied all groups will be processed in parallel
+ * and the results will be merged in arbitrary order.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface GroupBy<R, E, K, V> extends GroupBy.Variance<R, E, K, V>, Pipeable {
+  readonly grouped: Stream.Stream<R, E, readonly [K, Queue.Dequeue<Take.Take<E, V>>]>
+}
+
+/**
+ * @since 2.0.0
+ */
+export declare namespace GroupBy {
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Variance<R, E, K, V> {
+    readonly [GroupByTypeId]: {
+      readonly _R: (_: never) => R
+      readonly _E: (_: never) => E
+      readonly _K: (_: never) => K
+      readonly _V: (_: never) => V
+    }
+  }
+}
+
+/**
+ * Run the function across all groups, collecting the results in an
+ * arbitrary order.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+export const evaluate: {
+  <K, E, V, R2, E2, A>(
+    f: (key: K, stream: Stream.Stream<never, E, V>) => Stream.Stream<R2, E2, A>,
+    options?: { readonly bufferSize?: number }
+  ): <R>(self: GroupBy<R, E, K, V>) => Stream.Stream<R2 | R, E | E2, A>
+  <R, K, E, V, R2, E2, A>(
+    self: GroupBy<R, E, K, V>,
+    f: (key: K, stream: Stream.Stream<never, E, V>) => Stream.Stream<R2, E2, A>,
+    options?: { readonly bufferSize?: number }
+  ): Stream.Stream<R | R2, E | E2, A>
+} = internal.evaluate
+
+/**
+ * Filter the groups to be processed.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const filter: {
+  <K>(predicate: Predicate<K>): <R, E, V>(self: GroupBy<R, E, K, V>) => GroupBy<R, E, K, V>
+  <R, E, V, K>(self: GroupBy<R, E, K, V>, predicate: Predicate<K>): GroupBy<R, E, K, V>
+} = internal.filter
+
+/**
+ * Only consider the first `n` groups found in the `Stream`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const first: {
+  (n: number): <R, E, K, V>(self: GroupBy<R, E, K, V>) => GroupBy<R, E, K, V>
+  <R, E, K, V>(self: GroupBy<R, E, K, V>, n: number): GroupBy<R, E, K, V>
+} = internal.first
+
+/**
+ * Constructs a `GroupBy` from a `Stream`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make: <R, E, K, V>(
+  grouped: Stream.Stream<R, E, readonly [K, Queue.Dequeue<Take.Take<E, V>>]>
+) => GroupBy<R, E, K, V> = internal.make

package/src/HKT.ts

@@ -0,0 +1,44 @@
+/**
+ * @since 2.0.0
+ */
+
+/**
+ * @since 2.0.0
+ */
+export declare const URI: unique symbol
+
+/**
+ * @since 2.0.0
+ */
+export interface TypeClass<F extends TypeLambda> {
+  readonly [URI]?: F
+}
+
+/**
+ * @since 2.0.0
+ */
+export interface TypeLambda {
+  readonly In: unknown
+  readonly Out2: unknown
+  readonly Out1: unknown
+  readonly Target: unknown
+}
+
+/**
+ * @since 2.0.0
+ */
+export type Kind<F extends TypeLambda, In, Out2, Out1, Target> = F extends {
+  readonly type: unknown
+} ? (F & {
+    readonly In: In
+    readonly Out2: Out2
+    readonly Out1: Out1
+    readonly Target: Target
+  })["type"]
+  : {
+    readonly F: F
+    readonly In: (_: In) => void
+    readonly Out2: () => Out2
+    readonly Out1: () => Out1
+    readonly Target: (_: Target) => Target
+  }

package/src/Hash.ts

@@ -0,0 +1,162 @@
+/**
+ * @since 2.0.0
+ */
+import { pipe } from "./Function"
+import { globalValue } from "./GlobalValue"
+import { PCGRandom } from "./Utils"
+
+/** @internal */
+const randomHashCache = globalValue(
+  Symbol.for("effect/Hash/randomHashCache"),
+  () => new WeakMap<object, number>()
+)
+/** @internal */
+const pcgr = globalValue(
+  Symbol.for("effect/Hash/pcgr"),
+  () => new PCGRandom()
+)
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const symbol: unique symbol = Symbol.for("effect/Hash")
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface Hash {
+  [symbol](): number
+}
+
+/**
+ * @since 2.0.0
+ * @category hashing
+ */
+export const hash: <A>(self: A) => number = <A>(self: A) => {
+  switch (typeof self) {
+    case "number": {
+      return number(self)
+    }
+    case "bigint": {
+      return string(self.toString(10))
+    }
+    case "boolean": {
+      return string(String(self))
+    }
+    case "symbol": {
+      return string(String(self))
+    }
+    case "string": {
+      return string(self)
+    }
+    case "undefined": {
+      return string("undefined")
+    }
+    case "function":
+    case "object": {
+      if (self === null) {
+        return string("null")
+      }
+      if (isHash(self)) {
+        return self[symbol]()
+      } else {
+        return random(self)
+      }
+    }
+    default: {
+      throw new Error("Bug in Equal.hash")
+    }
+  }
+}
+
+/**
+ * @since 2.0.0
+ * @category hashing
+ */
+export const random: <A extends object>(self: A) => number = (self) => {
+  if (!randomHashCache.has(self)) {
+    randomHashCache.set(self, number(pcgr.integer(Number.MAX_SAFE_INTEGER)))
+  }
+  return randomHashCache.get(self)!
+}
+
+/**
+ * @since 2.0.0
+ * @category hashing
+ */
+export const combine: (b: number) => (self: number) => number = (b) => (self) => (self * 53) ^ b
+
+/**
+ * @since 2.0.0
+ * @category hashing
+ */
+export const optimize = (n: number): number => (n & 0xbfffffff) | ((n >>> 1) & 0x40000000)
+
+/**
+ * @since 2.0.0
+ * @category guards
+ */
+export const isHash = (u: unknown): u is Hash => typeof u === "object" && u !== null && symbol in u
+
+/**
+ * @since 2.0.0
+ * @category hashing
+ */
+export const number = (n: number) => {
+  if (n !== n || n === Infinity) {
+    return 0
+  }
+  let h = n | 0
+  if (h !== n) {
+    h ^= n * 0xffffffff
+  }
+  while (n > 0xffffffff) {
+    h ^= n /= 0xffffffff
+  }
+  return optimize(n)
+}
+
+/**
+ * @since 2.0.0
+ * @category hashing
+ */
+export const string = (str: string) => {
+  let h = 5381, i = str.length
+  while (i) {
+    h = (h * 33) ^ str.charCodeAt(--i)
+  }
+  return optimize(h)
+}
+
+/**
+ * @since 2.0.0
+ * @category hashing
+ */
+export const structureKeys = <A extends object>(o: A, keys: ReadonlyArray<keyof A>) => {
+  let h = 12289
+  for (let i = 0; i < keys.length; i++) {
+    h ^= pipe(string(keys[i]! as string), combine(hash((o as any)[keys[i]!])))
+  }
+  return optimize(h)
+}
+
+/**
+ * @since 2.0.0
+ * @category hashing
+ */
+export const structure = <A extends object>(o: A) =>
+  structureKeys(o, Object.keys(o) as unknown as ReadonlyArray<keyof A>)
+
+/**
+ * @since 2.0.0
+ * @category hashing
+ */
+export const array = <A>(arr: ReadonlyArray<A>) => {
+  let h = 6151
+  for (let i = 0; i < arr.length; i++) {
+    h = pipe(h, combine(hash(arr[i])))
+  }
+  return optimize(h)
+}

package/src/HashMap.ts

@@ -0,0 +1,373 @@
+/**
+ * @since 2.0.0
+ */
+
+import type { Equal } from "./Equal"
+import type { HashSet } from "./HashSet"
+import type { Inspectable } from "./Inspectable"
+import * as HM from "./internal/HashMap"
+import * as _keySet from "./internal/HashMap/keySet"
+import type { Option } from "./Option"
+import type { Pipeable } from "./Pipeable"
+
+const TypeId: unique symbol = HM.HashMapTypeId as TypeId
+
+/**
+ * @since 2.0.0
+ * @category symbol
+ */
+export type TypeId = typeof TypeId
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface HashMap<Key, Value> extends Iterable<[Key, Value]>, Equal, Pipeable, Inspectable {
+  [TypeId]: TypeId
+}
+
+/**
+ * @since 2.0.0
+ */
+export declare namespace HashMap {
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export type UpdateFn<V> = (option: Option<V>) => Option<V>
+}
+
+/**
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isHashMap: {
+  <K, V>(u: Iterable<readonly [K, V]>): u is HashMap<K, V>
+  (u: unknown): u is HashMap<unknown, unknown>
+} = HM.isHashMap
+
+/**
+ * Creates a new `HashMap`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const empty: <K = never, V = never>() => HashMap<K, V> = HM.empty
+
+/**
+ * Constructs a new `HashMap` from an array of key/value pairs.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make: <Entries extends ReadonlyArray<readonly [any, any]>>(
+  ...entries: Entries
+) => HashMap<
+  Entries[number] extends readonly [infer K, any] ? K : never,
+  Entries[number] extends readonly [any, infer V] ? V : never
+> = HM.make
+
+/**
+ * Constructs a new `HashMap` from an iterable of key/value pairs.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const fromIterable: <K, V>(entries: Iterable<readonly [K, V]>) => HashMap<K, V> = HM.fromIterable
+
+/**
+ * Checks if the `HashMap` contains any entries.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+export const isEmpty: <K, V>(self: HashMap<K, V>) => boolean = HM.isEmpty
+
+/**
+ * Safely lookup the value for the specified key in the `HashMap` using the
+ * internal hashing function.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+export const get: {
+  <K1>(key: K1): <K, V>(self: HashMap<K, V>) => Option<V>
+  <K, V, K1>(self: HashMap<K, V>, key: K1): Option<V>
+} = HM.get
+
+/**
+ * Lookup the value for the specified key in the `HashMap` using a custom hash.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+export const getHash: {
+  <K1>(key: K1, hash: number): <K, V>(self: HashMap<K, V>) => Option<V>
+  <K, V, K1>(self: HashMap<K, V>, key: K1, hash: number): Option<V>
+} = HM.getHash
+
+/**
+ * Unsafely lookup the value for the specified key in the `HashMap` using the
+ * internal hashing function.
+ *
+ * @since 2.0.0
+ * @category unsafe
+ */
+export const unsafeGet: {
+  <K1>(key: K1): <K, V>(self: HashMap<K, V>) => V
+  <K, V, K1>(self: HashMap<K, V>, key: K1): V
+} = HM.unsafeGet
+
+/**
+ * Checks if the specified key has an entry in the `HashMap`.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+export const has: {
+  <K1>(key: K1): <K, V>(self: HashMap<K, V>) => boolean
+  <K, V, K1>(self: HashMap<K, V>, key: K1): boolean
+} = HM.has
+
+/**
+ * Checks if the specified key has an entry in the `HashMap` using a custom
+ * hash.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+export const hasHash: {
+  <K1>(key: K1, hash: number): <K, V>(self: HashMap<K, V>) => boolean
+  <K, V, K1>(self: HashMap<K, V>, key: K1, hash: number): boolean
+} = HM.hasHash
+
+/**
+ * Sets the specified key to the specified value using the internal hashing
+ * function.
+ *
+ * @since 2.0.0
+ */
+export const set: {
+  <K, V>(key: K, value: V): (self: HashMap<K, V>) => HashMap<K, V>
+  <K, V>(self: HashMap<K, V>, key: K, value: V): HashMap<K, V>
+} = HM.set
+
+/**
+ * Returns an `IterableIterator` of the keys within the `HashMap`.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const keys: <K, V>(self: HashMap<K, V>) => IterableIterator<K> = HM.keys
+
+/**
+ * Returns a `HashSet` of keys within the `HashMap`.
+ *
+ * @since 2.0.0
+ * @category getter
+ */
+export const keySet: <K, V>(self: HashMap<K, V>) => HashSet<K> = _keySet.keySet
+
+/**
+ * Returns an `IterableIterator` of the values within the `HashMap`.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const values: <K, V>(self: HashMap<K, V>) => IterableIterator<V> = HM.values
+
+/**
+ * Returns the number of entries within the `HashMap`.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const size: <K, V>(self: HashMap<K, V>) => number = HM.size
+
+/**
+ * Marks the `HashMap` as mutable.
+ *
+ * @since 2.0.0
+ */
+export const beginMutation: <K, V>(self: HashMap<K, V>) => HashMap<K, V> = HM.beginMutation
+
+/**
+ * Marks the `HashMap` as immutable.
+ *
+ * @since 2.0.0
+ */
+export const endMutation: <K, V>(self: HashMap<K, V>) => HashMap<K, V> = HM.endMutation
+
+/**
+ * Mutates the `HashMap` within the context of the provided function.
+ *
+ * @since 2.0.0
+ */
+export const mutate: {
+  <K, V>(f: (self: HashMap<K, V>) => void): (self: HashMap<K, V>) => HashMap<K, V>
+  <K, V>(self: HashMap<K, V>, f: (self: HashMap<K, V>) => void): HashMap<K, V>
+} = HM.mutate
+
+/**
+ * Set or remove the specified key in the `HashMap` using the specified
+ * update function. The value of the specified key will be computed using the
+ * provided hash.
+ *
+ * The update function will be invoked with the current value of the key if it
+ * exists, or `None` if no such value exists.
+ *
+ * @since 2.0.0
+ */
+export const modifyAt: {
+  <K, V>(key: K, f: HashMap.UpdateFn<V>): (self: HashMap<K, V>) => HashMap<K, V>
+  <K, V>(self: HashMap<K, V>, key: K, f: HashMap.UpdateFn<V>): HashMap<K, V>
+} = HM.modifyAt
+
+/**
+ * Alter the value of the specified key in the `HashMap` using the specified
+ * update function. The value of the specified key will be computed using the
+ * provided hash.
+ *
+ * The update function will be invoked with the current value of the key if it
+ * exists, or `None` if no such value exists.
+ *
+ * This function will always either update or insert a value into the `HashMap`.
+ *
+ * @since 2.0.0
+ */
+export const modifyHash: {
+  <K, V>(key: K, hash: number, f: HashMap.UpdateFn<V>): (self: HashMap<K, V>) => HashMap<K, V>
+  <K, V>(self: HashMap<K, V>, key: K, hash: number, f: HashMap.UpdateFn<V>): HashMap<K, V>
+} = HM.modifyHash
+
+/**
+ * Updates the value of the specified key within the `HashMap` if it exists.
+ *
+ * @since 2.0.0
+ */
+export const modify: {
+  <K, V>(key: K, f: (v: V) => V): (self: HashMap<K, V>) => HashMap<K, V>
+  <K, V>(self: HashMap<K, V>, key: K, f: (v: V) => V): HashMap<K, V>
+} = HM.modify
+
+/**
+ * Performs a union of this `HashMap` and that `HashMap`.
+ *
+ * @since 2.0.0
+ */
+export const union: {
+  <K1, V1>(that: HashMap<K1, V1>): <K0, V0>(self: HashMap<K0, V0>) => HashMap<K1 | K0, V1 | V0>
+  <K0, V0, K1, V1>(self: HashMap<K0, V0>, that: HashMap<K1, V1>): HashMap<K0 | K1, V0 | V1>
+} = HM.union
+
+/**
+ * Remove the entry for the specified key in the `HashMap` using the internal
+ * hashing function.
+ *
+ * @since 2.0.0
+ */
+export const remove: {
+  <K>(key: K): <V>(self: HashMap<K, V>) => HashMap<K, V>
+  <K, V>(self: HashMap<K, V>, key: K): HashMap<K, V>
+} = HM.remove
+
+/**
+ * Removes all entries in the `HashMap` which have the specified keys.
+ *
+ * @since 2.0.0
+ */
+export const removeMany: {
+  <K>(keys: Iterable<K>): <V>(self: HashMap<K, V>) => HashMap<K, V>
+  <K, V>(self: HashMap<K, V>, keys: Iterable<K>): HashMap<K, V>
+} = HM.removeMany
+
+/**
+ * Maps over the entries of the `HashMap` using the specified function.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+export const map: {
+  <A, V, K>(f: (value: V, key: K) => A): (self: HashMap<K, V>) => HashMap<K, A>
+  <K, V, A>(self: HashMap<K, V>, f: (value: V, key: K) => A): HashMap<K, A>
+} = HM.map
+
+/**
+ * Chains over the entries of the `HashMap` using the specified function.
+ *
+ * **NOTE**: the hash and equal of both maps have to be the same.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+export const flatMap: {
+  <A, K, B>(f: (value: A, key: K) => HashMap<K, B>): (self: HashMap<K, A>) => HashMap<K, B>
+  <K, A, B>(self: HashMap<K, A>, f: (value: A, key: K) => HashMap<K, B>): HashMap<K, B>
+} = HM.flatMap
+
+/**
+ * Applies the specified function to the entries of the `HashMap`.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+export const forEach: {
+  <V, K>(f: (value: V, key: K) => void): (self: HashMap<K, V>) => void
+  <V, K>(self: HashMap<K, V>, f: (value: V, key: K) => void): void
+} = HM.forEach
+
+/**
+ * Reduces the specified state over the entries of the `HashMap`.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+export const reduce: {
+  <Z, V, K>(zero: Z, f: (accumulator: Z, value: V, key: K) => Z): (self: HashMap<K, V>) => Z
+  <Z, V, K>(self: HashMap<K, V>, zero: Z, f: (accumulator: Z, value: V, key: K) => Z): Z
+} = HM.reduce
+
+/**
+ * Filters entries out of a `HashMap` using the specified predicate.
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+export const filter: {
+  <K, A, B extends A>(f: (a: A, k: K) => a is B): (self: HashMap<K, A>) => HashMap<K, B>
+  <K, A>(f: (a: A, k: K) => boolean): (self: HashMap<K, A>) => HashMap<K, A>
+  <K, A, B extends A>(self: HashMap<K, A>, f: (a: A, k: K) => a is B): HashMap<K, B>
+  <K, A>(self: HashMap<K, A>, f: (a: A, k: K) => boolean): HashMap<K, A>
+} = HM.filter
+
+/**
+ * Filters out `None` values from a `HashMap` of `Options`s.
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+export const compact: <K, A>(self: HashMap<K, Option<A>>) => HashMap<K, A> = HM.compact
+
+/**
+ * Maps over the entries of the `HashMap` using the specified partial function
+ * and filters out `None` values.
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+export const filterMap: {
+  <A, K, B>(f: (value: A, key: K) => Option<B>): (self: HashMap<K, A>) => HashMap<K, B>
+  <K, A, B>(self: HashMap<K, A>, f: (value: A, key: K) => Option<B>): HashMap<K, B>
+} = HM.filterMap
+
+/**
+ * Returns the first element that satisfies the specified
+ * predicate, or `None` if no such element exists.
+ *
+ * @category elements
+ * @since 2.0.0
+ */
+export const findFirst: {
+  <K, A>(predicate: (k: K, a: A) => boolean): (self: HashMap<K, A>) => Option<[K, A]>
+  <K, A>(self: HashMap<K, A>, predicate: (k: K, a: A) => boolean): Option<[K, A]>
+} = HM.findFirst