@clayroach/effect 3.19.14-source-capture.8 → 3.19.14-source-trace.1

package/src/GroupBy.ts

@@ -0,0 +1,103 @@
+/**
+ * @since 2.0.0
+ */
+import * as internal from "./internal/groupBy.js"
+import type { Pipeable } from "./Pipeable.js"
+import type { Predicate } from "./Predicate.js"
+import type * as Queue from "./Queue.js"
+import type * as Stream from "./Stream.js"
+import type * as Take from "./Take.js"
+import type { Covariant, NoInfer } from "./Types.js"
+
+/**
+ * @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<out K, out V, out E = never, out R = never> extends GroupBy.Variance<K, V, E, R>, Pipeable {
+  readonly grouped: Stream.Stream<readonly [K, Queue.Dequeue<Take.Take<V, E>>], E, R>
+}
+
+/**
+ * @since 2.0.0
+ */
+export declare namespace GroupBy {
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Variance<out K, out V, out E, out R> {
+    readonly [GroupByTypeId]: {
+      readonly _K: Covariant<K>
+      readonly _V: Covariant<V>
+      readonly _E: Covariant<E>
+      readonly _R: Covariant<R>
+    }
+  }
+}
+
+/**
+ * Run the function across all groups, collecting the results in an
+ * arbitrary order.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+export const evaluate: {
+  <K, V, E, A, E2, R2>(
+    f: (key: K, stream: Stream.Stream<V, E, never>) => Stream.Stream<A, E2, R2>,
+    options?: { readonly bufferSize?: number | undefined } | undefined
+  ): <R>(self: GroupBy<K, V, E, R>) => Stream.Stream<A, E | E2, R2 | R>
+  <K, V, E, R, A, E2, R2>(
+    self: GroupBy<K, V, E, R>,
+    f: (key: K, stream: Stream.Stream<V, E, never>) => Stream.Stream<A, E2, R2>,
+    options?: { readonly bufferSize?: number | undefined } | undefined
+  ): Stream.Stream<A, E | E2, R | R2>
+} = internal.evaluate
+
+/**
+ * Filter the groups to be processed.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const filter: {
+  <K>(predicate: Predicate<NoInfer<K>>): <V, E, R>(self: GroupBy<K, V, E, R>) => GroupBy<K, V, E, R>
+  <K, V, E, R>(self: GroupBy<K, V, E, R>, predicate: Predicate<K>): GroupBy<K, V, E, R>
+} = internal.filter
+
+/**
+ * Only consider the first `n` groups found in the `Stream`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const first: {
+  (n: number): <K, V, E, R>(self: GroupBy<K, V, E, R>) => GroupBy<K, V, E, R>
+  <K, V, E, R>(self: GroupBy<K, V, E, R>, n: number): GroupBy<K, V, E, R>
+} = internal.first
+
+/**
+ * Constructs a `GroupBy` from a `Stream`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make: <K, V, E, R>(
+  grouped: Stream.Stream<readonly [K, Queue.Dequeue<Take.Take<V, E>>], E, R>
+) => GroupBy<K, V, E, R> = internal.make

package/src/HKT.ts

@@ -0,0 +1,45 @@
+/**
+ * @since 2.0.0
+ */
+import type * as Types from "./Types.js"
+
+/**
+ * @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: Types.Contravariant<In>
+    readonly Out2: Types.Covariant<Out2>
+    readonly Out1: Types.Covariant<Out1>
+    readonly Target: Types.Invariant<Target>
+  }

package/src/Hash.ts

@@ -0,0 +1,195 @@
+/**
+ * @since 2.0.0
+ */
+import { pipe } from "./Function.js"
+import { globalValue } from "./GlobalValue.js"
+import { hasProperty } from "./Predicate.js"
+import { structuralRegionState } from "./Utils.js"
+
+/** @internal */
+const randomHashCache = globalValue(
+  Symbol.for("effect/Hash/randomHashCache"),
+  () => new WeakMap<object, number>()
+)
+
+/**
+ * @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) => {
+  if (structuralRegionState.enabled === true) {
+    return 0
+  }
+
+  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")
+      } else if (self instanceof Date) {
+        if (Number.isNaN(self.getTime())) {
+          return string("Invalid Date")
+        }
+        return hash(self.toISOString())
+      } else if (self instanceof URL) {
+        return hash(self.href)
+      } else if (isHash(self)) {
+        return self[symbol]()
+      } else {
+        return random(self)
+      }
+    }
+    default:
+      throw new Error(
+        `BUG: unhandled typeof ${typeof self} - please report an issue at https://github.com/Effect-TS/effect/issues`
+      )
+  }
+}
+
+/**
+ * @since 2.0.0
+ * @category hashing
+ */
+export const random: <A extends object>(self: A) => number = (self) => {
+  if (!randomHashCache.has(self)) {
+    randomHashCache.set(self, number(Math.floor(Math.random() * 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 => hasProperty(u, symbol)
+
+/**
+ * @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(h)
+}
+
+/**
+ * @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)
+}
+
+/**
+ * @since 2.0.0
+ * @category hashing
+ */
+export const cached: {
+  (self: object): (hash: number) => number
+  (self: object, hash: number): number
+} = function() {
+  if (arguments.length === 1) {
+    const self = arguments[0] as object
+    return function(hash: number) {
+      Object.defineProperty(self, symbol, {
+        value() {
+          return hash
+        },
+        enumerable: false
+      })
+      return hash
+    } as any
+  }
+  const self = arguments[0] as object
+  const hash = arguments[1] as number
+  Object.defineProperty(self, symbol, {
+    value() {
+      return hash
+    },
+    enumerable: false
+  })
+
+  return hash
+}