effect 3.2.8 → 3.3.0

package/src/internal/redacted.ts

@@ -0,0 +1,69 @@
+import * as Equal from "../Equal.js"
+import { pipe } from "../Function.js"
+import { globalValue } from "../GlobalValue.js"
+import * as Hash from "../Hash.js"
+import { pipeArguments } from "../Pipeable.js"
+import { hasProperty } from "../Predicate.js"
+import type * as Redacted from "../Redacted.js"
+
+/** @internal */
+const RedactedSymbolKey = "effect/Redacted"
+
+/** @internal */
+export const redactedRegistry = globalValue(
+  "effect/Redacted/redactedRegistry",
+  () => new WeakMap<Redacted.Redacted<any>, any>()
+)
+
+/** @internal */
+export const RedactedTypeId: Redacted.RedactedTypeId = Symbol.for(
+  RedactedSymbolKey
+) as Redacted.RedactedTypeId
+
+/** @internal */
+export const proto = {
+  [RedactedTypeId]: {
+    _A: (_: never) => _
+  },
+  pipe() {
+    return pipeArguments(this, arguments)
+  },
+  toString() {
+    return "<redacted>"
+  },
+  toJSON() {
+    return "<redacted>"
+  },
+  [Hash.symbol]<T>(this: Redacted.Redacted<T>): number {
+    return pipe(
+      Hash.hash(RedactedSymbolKey),
+      Hash.combine(Hash.hash(redactedRegistry.get(this))),
+      Hash.cached(this)
+    )
+  },
+  [Equal.symbol]<T>(this: Redacted.Redacted<T>, that: unknown): boolean {
+    return isRedacted(that) && Equal.equals(redactedRegistry.get(this), redactedRegistry.get(that))
+  }
+}
+
+/** @internal */
+export const isRedacted = (u: unknown): u is Redacted.Redacted<unknown> => hasProperty(u, RedactedTypeId)
+
+/** @internal */
+export const make = <T>(value: T): Redacted.Redacted<T> => {
+  const redacted = Object.create(proto)
+  redactedRegistry.set(redacted, value)
+  return redacted
+}
+
+/** @internal */
+export const value = <T>(self: Redacted.Redacted<T>): T => {
+  if (redactedRegistry.has(self)) {
+    return redactedRegistry.get(self)
+  } else {
+    throw new Error("Unable to get redacted value")
+  }
+}
+
+/** @internal */
+export const unsafeWipe = <T>(self: Redacted.Redacted<T>): boolean => redactedRegistry.delete(self)

package/src/internal/secret.ts

@@ -1,40 +1,37 @@
 import * as Arr from "../Array.js"
-import * as Equal from "../Equal.js"
-import { pipe } from "../Function.js"
-import * as Hash from "../Hash.js"
 import { hasProperty } from "../Predicate.js"
 import type * as Secret from "../Secret.js"
+import * as redacted_ from "./redacted.js"
 
-/** @internal */
+/**
+ * @internal
+ * @deprecated
+ */
 const SecretSymbolKey = "effect/Secret"
 
-/** @internal */
+/**
+ * @internal
+ * @deprecated
+ */
 export const SecretTypeId: Secret.SecretTypeId = Symbol.for(
   SecretSymbolKey
 ) as Secret.SecretTypeId
 
-/** @internal */
-export const proto = {
-  [SecretTypeId]: SecretTypeId,
-  [Hash.symbol](this: Secret.Secret): number {
-    return pipe(
-      Hash.hash(SecretSymbolKey),
-      Hash.combine(Hash.array(this.raw)),
-      Hash.cached(this)
-    )
-  },
-  [Equal.symbol](this: Secret.Secret, that: unknown): boolean {
-    return isSecret(that) && this.raw.length === that.raw.length &&
-      this.raw.every((v, i) => Equal.equals(v, that.raw[i]))
-  }
-}
-
-/** @internal */
+/**
+ * @internal
+ * @deprecated
+ */
 export const isSecret = (u: unknown): u is Secret.Secret => hasProperty(u, SecretTypeId)
 
-/** @internal */
+/**
+ * @internal
+ * @deprecated
+ */
 export const make = (bytes: Array<number>): Secret.Secret => {
-  const secret = Object.create(proto)
+  const secret = Object.create({
+    ...redacted_.proto,
+    [SecretTypeId]: SecretTypeId
+  })
   Object.defineProperty(secret, "toString", {
     enumerable: false,
     value() {
@@ -51,26 +48,40 @@ export const make = (bytes: Array<number>): Secret.Secret => {
     enumerable: false,
     value: bytes
   })
+  redacted_.redactedRegistry.set(secret, bytes.map((byte) => String.fromCharCode(byte)).join(""))
   return secret
 }
 
-/** @internal */
+/**
+ * @internal
+ * @deprecated
+ */
 export const fromIterable = (iterable: Iterable<string>): Secret.Secret =>
   make(Arr.fromIterable(iterable).map((char) => char.charCodeAt(0)))
 
-/** @internal */
+/**
+ * @internal
+ * @deprecated
+ */
 export const fromString = (text: string): Secret.Secret => {
   return make(text.split("").map((char) => char.charCodeAt(0)))
 }
 
-/** @internal */
+/**
+ * @internal
+ * @deprecated
+ */
 export const value = (self: Secret.Secret): string => {
   return self.raw.map((byte) => String.fromCharCode(byte)).join("")
 }
 
-/** @internal */
+/**
+ * @internal
+ * @deprecated
+ */
 export const unsafeWipe = (self: Secret.Secret): void => {
   for (let i = 0; i < self.raw.length; i++) {
     self.raw[i] = 0
   }
+  redacted_.redactedRegistry.delete(self)
 }

package/src/internal/stm/stm.ts

@@ -618,8 +618,11 @@ export const fromOption = <A>(option: Option.Option<A>): STM.STM<A, Option.Optio
  * Inspired by https://github.com/tusharmath/qio/pull/22 (revised)
  * @internal
  */
-export const gen: typeof STM.gen = (f) =>
+export const gen: typeof STM.gen = (...args) =>
   suspend(() => {
+    const f = (args.length === 1)
+      ? args[0]
+      : args[1].bind(args[0])
     const iterator = f(pipe)
     const state = iterator.next()
     const run = (

package/src/internal/stream.ts

@@ -6542,63 +6542,103 @@ export const toQueueOfElements = dual<
   ))
 
 /** @internal */
-export const toReadableStream = <A, E>(self: Stream.Stream<A, E>) =>
-  toReadableStreamRuntime(self, Runtime.defaultRuntime)
+export const toReadableStream = dual<
+  <A>(
+    options?: { readonly strategy?: QueuingStrategy<A> | undefined }
+  ) => <E>(self: Stream.Stream<A, E>) => ReadableStream<A>,
+  <A, E>(
+    self: Stream.Stream<A, E>,
+    options?: { readonly strategy?: QueuingStrategy<A> | undefined }
+  ) => ReadableStream<A>
+>(
+  (args) => isStream(args[0]),
+  <A, E>(
+    self: Stream.Stream<A, E>,
+    options?: { readonly strategy?: QueuingStrategy<A> | undefined }
+  ) => toReadableStreamRuntime(self, Runtime.defaultRuntime, options)
+)
 
 /** @internal */
-export const toReadableStreamEffect = <A, E, R>(self: Stream.Stream<A, E, R>) =>
-  Effect.map(Effect.runtime<R>(), (runtime) => toReadableStreamRuntime(self, runtime))
+export const toReadableStreamEffect = dual<
+  <A>(
+    options?: { readonly strategy?: QueuingStrategy<A> | undefined }
+  ) => <E, R>(self: Stream.Stream<A, E, R>) => Effect.Effect<ReadableStream<A>, never, R>,
+  <A, E, R>(
+    self: Stream.Stream<A, E, R>,
+    options?: { readonly strategy?: QueuingStrategy<A> | undefined }
+  ) => Effect.Effect<ReadableStream<A>, never, R>
+>(
+  (args) => isStream(args[0]),
+  <A, E, R>(
+    self: Stream.Stream<A, E, R>,
+    options?: { readonly strategy?: QueuingStrategy<A> | undefined }
+  ) => Effect.map(Effect.runtime<R>(), (runtime) => toReadableStreamRuntime(self, runtime, options))
+)
 
 /** @internal */
 export const toReadableStreamRuntime = dual<
-  <XR>(runtime: Runtime.Runtime<XR>) => <A, E, R extends XR>(self: Stream.Stream<A, E, R>) => ReadableStream<A>,
-  <A, E, XR, R extends XR>(self: Stream.Stream<A, E, R>, runtime: Runtime.Runtime<XR>) => ReadableStream<A>
->(2, <A, E, XR, R extends XR>(self: Stream.Stream<A, E, R>, runtime: Runtime.Runtime<XR>): ReadableStream<A> => {
-  const runSync = Runtime.runSync(runtime)
-  const runFork = Runtime.runFork(runtime)
-
-  let pull: Effect.Effect<void, never, R>
-  let scope: Scope.CloseableScope
-  return new ReadableStream<A>({
-    start(controller) {
-      scope = runSync(Scope.make())
-      pull = pipe(
-        toPull(self),
-        Scope.extend(scope),
-        runSync,
-        Effect.tap((chunk) =>
-          Effect.sync(() => {
-            Chunk.map(chunk, (a) => {
-              controller.enqueue(a)
-            })
-          })
-        ),
-        Effect.tapErrorCause(() => Scope.close(scope, Exit.void)),
-        Effect.catchTags({
-          "None": () =>
-            Effect.sync(() => {
-              controller.close()
-            }),
-          "Some": (error) =>
+  <A, XR>(
+    runtime: Runtime.Runtime<XR>,
+    options?: { readonly strategy?: QueuingStrategy<A> | undefined }
+  ) => <E, R extends XR>(self: Stream.Stream<A, E, R>) => ReadableStream<A>,
+  <A, E, XR, R extends XR>(
+    self: Stream.Stream<A, E, R>,
+    runtime: Runtime.Runtime<XR>,
+    options?: { readonly strategy?: QueuingStrategy<A> | undefined }
+  ) => ReadableStream<A>
+>(
+  (args) => isStream(args[0]),
+  <A, E, XR, R extends XR>(
+    self: Stream.Stream<A, E, R>,
+    runtime: Runtime.Runtime<XR>,
+    options?: { readonly strategy?: QueuingStrategy<A> | undefined }
+  ): ReadableStream<A> => {
+    const runSync = Runtime.runSync(runtime)
+    const runFork = Runtime.runFork(runtime)
+
+    let pull: Effect.Effect<void, never, R>
+    let scope: Scope.CloseableScope
+    return new ReadableStream<A>({
+      start(controller) {
+        scope = runSync(Scope.make())
+        pull = pipe(
+          toPull(self),
+          Scope.extend(scope),
+          runSync,
+          Effect.tap((chunk) =>
             Effect.sync(() => {
-              controller.error(error.value)
+              Chunk.map(chunk, (a) => {
+                controller.enqueue(a)
+              })
             })
-        }),
-        Effect.asVoid
-      )
-    },
-    pull() {
-      return new Promise<void>((resolve) => {
-        runFork(pull, { scope }).addObserver((_) => resolve())
-      })
-    },
-    cancel() {
-      return new Promise<void>((resolve) => {
-        runFork(Scope.close(scope, Exit.void)).addObserver((_) => resolve())
-      })
-    }
-  })
-})
+          ),
+          Effect.tapErrorCause(() => Scope.close(scope, Exit.void)),
+          Effect.catchTags({
+            "None": () =>
+              Effect.sync(() => {
+                controller.close()
+              }),
+            "Some": (error) =>
+              Effect.sync(() => {
+                controller.error(error.value)
+              })
+          }),
+          Effect.asVoid
+        )
+      },
+      pull() {
+        return new Promise<void>((resolve) => {
+          runFork(pull, { scope }).addObserver((_) => resolve())
+        })
+      },
+      cancel() {
+        return new Promise<void>((resolve) => {
+          runFork(Scope.close(scope, Exit.void)).addObserver((_) => resolve())
+        })
+      }
+    }, options?.strategy)
+  }
+)
 
 /** @internal */
 export const transduce = dual<
@@ -7569,6 +7609,27 @@ export const zipLatest = dual<
   ): Stream.Stream<[A, A2], E2 | E, R2 | R> => pipe(self, zipLatestWith(that, (a, a2) => [a, a2]))
 )
 
+export const zipLatestAll = <T extends ReadonlyArray<Stream.Stream<any, any, any>>>(
+  ...streams: T
+): Stream.Stream<
+  [T[number]] extends [never] ? never
+    : { [K in keyof T]: T[K] extends Stream.Stream<infer A, infer _E, infer _R> ? A : never },
+  [T[number]] extends [never] ? never : T[number] extends Stream.Stream<infer _A, infer _E, infer _R> ? _E : never,
+  [T[number]] extends [never] ? never : T[number] extends Stream.Stream<infer _A, infer _E, infer _R> ? _R : never
+> => {
+  if (streams.length === 0) {
+    return empty
+  } else if (streams.length === 1) {
+    return map(streams[0]!, (x) => [x]) as any
+  }
+  const [head, ...tail] = streams
+  return zipLatestWith(
+    head,
+    zipLatestAll(...tail),
+    (first, second) => [first, ...second]
+  ) as any
+}
+
 /** @internal */
 export const zipLatestWith = dual<
   <A2, E2, R2, A, A3>(

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "3.2.8"
+let moduleVersion = "3.3.0"
 
 export const getCurrentVersion = () => moduleVersion