effect 3.4.2 → 3.4.4

package/src/Micro.ts

@@ -6,7 +6,7 @@
  */
 import type { Channel, ChannelTypeId } from "./Channel.js"
 import * as Context from "./Context.js"
-import type { Effect, EffectTypeId } from "./Effect.js"
+import type { Effect, EffectTypeId, EffectUnify, EffectUnifyIgnore } from "./Effect.js"
 import * as Effectable from "./Effectable.js"
 import * as Either from "./Either.js"
 import { constTrue, constVoid, dual, identity, type LazyArg } from "./Function.js"
@@ -24,6 +24,7 @@ import type { ReadonlyRecord } from "./Record.js"
 import type { Sink, SinkTypeId } from "./Sink.js"
 import type { Stream, StreamTypeId } from "./Stream.js"
 import type { Concurrency, Covariant, Equals, NoInfer, NotFunction, Simplify } from "./Types.js"
+import type * as Unify from "./Unify.js"
 import { YieldWrap, yieldWrapGet } from "./Utils.js"
 
 /**
@@ -64,9 +65,27 @@ export type runSymbol = typeof runSymbol
 export interface Micro<out A, out E = never, out R = never> extends Effect<A, E, R> {
   readonly [TypeId]: Micro.Variance<A, E, R>
   readonly [runSymbol]: (env: Env<any>, onResult: (result: Result<A, E>) => void) => void
+  [Unify.typeSymbol]?: unknown
+  [Unify.unifySymbol]?: MicroUnify<this>
+  [Unify.ignoreSymbol]?: MicroUnifyIgnore
   [Symbol.iterator](): MicroIterator<Micro<A, E, R>>
 }
 
+/**
+ * @category models
+ * @since 3.4.3
+ */
+export interface MicroUnify<A extends { [Unify.typeSymbol]?: any }> extends EffectUnify<A> {
+  Micro?: () => A[Unify.typeSymbol] extends Micro<infer A0, infer E0, infer R0> | infer _ ? Micro<A0, E0, R0> : never
+}
+
+/**
+ * @category models
+ * @since 3.4.3
+ */
+export interface MicroUnifyIgnore extends EffectUnifyIgnore {
+  Effect?: true
+}
 /**
  * @category type lambdas
  * @since 3.4.1
@@ -713,7 +732,7 @@ export const envRefMake = <A>(key: string, initial: LazyArg<A>): EnvRef<A> =>
  */
 export const currentAbortController: EnvRef<AbortController> = envRefMake(
   "effect/Micro/currentAbortController",
-  () => new AbortController()
+  () => undefined as any
 )
 
 /**
@@ -723,7 +742,7 @@ export const currentAbortController: EnvRef<AbortController> = envRefMake(
  */
 export const currentAbortSignal: EnvRef<AbortSignal> = envRefMake(
   "effect/Micro/currentAbortSignal",
-  () => currentAbortController.initial.signal
+  () => undefined as any
 )
 
 /**
@@ -981,17 +1000,17 @@ export const sync = <A>(evaluate: LazyArg<A>): Micro<A> =>
   })
 
 /**
- * Converts an `Option` into a `Micro` effect, that will fail with a
- * `Option.None` if the option is `None`. Otherwise, it will succeed with the
+ * Converts an `Option` into a `Micro` effect, that will fail with
+ * `NoSuchElementException` if the option is `None`. Otherwise, it will succeed with the
  * value of the option.
  *
  * @since 3.4.0
  * @experimental
  * @category constructors
  */
-export const fromOption = <A>(option: Option.Option<A>): Micro<A, Option.None<never>> =>
+export const fromOption = <A>(option: Option.Option<A>): Micro<A, NoSuchElementException> =>
   make(function(_env, onResult) {
-    onResult(option._tag === "Some" ? ResultSuccess(option.value) : ResultFail(Option.none()) as any)
+    onResult(option._tag === "Some" ? ResultSuccess(option.value) : ResultFail(new NoSuchElementException({})))
   })
 
 /**
@@ -1224,15 +1243,17 @@ export const never: Micro<never> = async<never>(function() {
  * @experimental
  * @category constructors
  */
-export const gen = <Eff extends YieldWrap<Micro<any, any, any>>, AEff>(
-  f: () => Generator<Eff, AEff, never>
+export const gen = <Self, Eff extends YieldWrap<Micro<any, any, any>>, AEff>(
+  ...args:
+    | [self: Self, body: (this: Self) => Generator<Eff, AEff, never>]
+    | [body: () => Generator<Eff, AEff, never>]
 ): Micro<
   AEff,
   [Eff] extends [never] ? never : [Eff] extends [YieldWrap<Micro<infer _A, infer E, infer _R>>] ? E : never,
   [Eff] extends [never] ? never : [Eff] extends [YieldWrap<Micro<infer _A, infer _E, infer R>>] ? R : never
 > =>
   make(function(env, onResult) {
-    const iterator = f() as Iterator<YieldWrap<Micro<any, any, any>>, AEff, any>
+    const iterator: Generator<Eff, AEff, any> = args.length === 1 ? args[0]() : args[1].call(args[0])
     let running = false
     let value: any = undefined
     function run() {
@@ -1653,21 +1674,46 @@ export const zip: {
   <A, E, R, A2, E2, R2>(
     self: Micro<A, E, R>,
     that: Micro<A2, E2, R2>,
-    options?:
-      | { readonly concurrent?: boolean | undefined }
-      | undefined
+    options?: { readonly concurrent?: boolean | undefined }
   ): Micro<[A, A2], E | E2, R | R2>
 } = dual((args) => isMicro(args[1]), <A, E, R, A2, E2, R2>(
   self: Micro<A, E, R>,
   that: Micro<A2, E2, R2>,
-  options?:
-    | { readonly concurrent?: boolean | undefined }
-    | undefined
-): Micro<[A, A2], E | E2, R | R2> => {
+  options?: { readonly concurrent?: boolean | undefined }
+): Micro<[A, A2], E | E2, R | R2> => zipWith(self, that, (a, a2) => [a, a2], options))
+
+/**
+ * The `Micro.zipWith` function combines two `Micro` effects and allows you to
+ * apply a function to the results of the combined effects, transforming them
+ * into a single value.
+ *
+ * @since 3.4.3
+ * @experimental
+ * @category zipping
+ */
+export const zipWith: {
+  <A2, E2, R2, A, B>(
+    that: Micro<A2, E2, R2>,
+    f: (a: A, b: A2) => B,
+    options?: { readonly concurrent?: boolean | undefined }
+  ): <E, R>(self: Micro<A, E, R>) => Micro<B, E2 | E, R2 | R>
+  <A, E, R, A2, E2, R2, B>(
+    self: Micro<A, E, R>,
+    that: Micro<A2, E2, R2>,
+    f: (a: A, b: A2) => B,
+    options?: { readonly concurrent?: boolean | undefined }
+  ): Micro<B, E2 | E, R2 | R>
+} = dual((args) => isMicro(args[1]), <A, E, R, A2, E2, R2, B>(
+  self: Micro<A, E, R>,
+  that: Micro<A2, E2, R2>,
+  f: (a: A, b: A2) => B,
+  options?: { readonly concurrent?: boolean | undefined }
+): Micro<B, E2 | E, R2 | R> => {
   if (options?.concurrent) {
-    return all([self, that], { concurrency: "unbounded" })
+    // Use `all` exclusively for concurrent cases, as it introduces additional overhead due to the management of concurrency
+    return map(all([self, that], { concurrency: "unbounded" }), ([a, a2]) => f(a, a2))
   }
-  return flatMap(self, (a) => map(that, (a2) => [a, a2]))
+  return flatMap(self, (a) => map(that, (a2) => f(a, a2)))
 })
 
 // ----------------------------------------------------------------------------
@@ -2162,34 +2208,34 @@ export const tapUnexpected: {
  * @category error handling
  */
 export const catchIf: {
-  <E, EB extends E, B, E2, R2>(
-    pred: Refinement<E, EB>,
-    f: (a: NoInfer<EB>) => Micro<B, E2, R2>
-  ): <A, R>(self: Micro<A, E, R>) => Micro<A | B, E2, R | R2>
-  <E, B, E2, R2>(
-    pred: Predicate<NoInfer<E>>,
-    f: (a: NoInfer<E>) => Micro<B, E2, R2>
-  ): <A, R>(self: Micro<A, E, R>) => Micro<A | B, E2, R | R2>
-  <A, E, R, EB extends E, B, E2, R2>(
+  <E, EB extends E, A2, E2, R2>(
+    refinement: Refinement<NoInfer<E>, EB>,
+    f: (e: EB) => Micro<A2, E2, R2>
+  ): <A, R>(self: Micro<A, E, R>) => Micro<A2 | A, E2 | Exclude<E, EB>, R2 | R>
+  <E, A2, E2, R2>(
+    predicate: Predicate<NoInfer<E>>,
+    f: (e: NoInfer<E>) => Micro<A2, E2, R2>
+  ): <A, R>(self: Micro<A, E, R>) => Micro<A2 | A, E | E2, R2 | R>
+  <A, E, R, EB extends E, A2, E2, R2>(
     self: Micro<A, E, R>,
-    pred: Refinement<E, EB>,
-    f: (a: NoInfer<EB>) => Micro<B, E2, R2>
-  ): Micro<A | B, E2, R | R2>
-  <A, E, R, B, E2, R2>(
+    refinement: Refinement<E, EB>,
+    f: (e: EB) => Micro<A2, E2, R2>
+  ): Micro<A | A2, E2 | Exclude<E, EB>, R | R2>
+  <A, E, R, A2, E2, R2>(
     self: Micro<A, E, R>,
-    pred: Predicate<NoInfer<E>>,
-    f: (a: NoInfer<E>) => Micro<B, E2, R2>
-  ): Micro<A | B, E2, R | R2>
+    predicate: Predicate<E>,
+    f: (e: E) => Micro<A2, E2, R2>
+  ): Micro<A | A2, E | E2, R | R2>
 } = dual(
   3,
-  <A, E, R, EB extends E, B, E2, R2>(
+  <A, E, R, A2, E2, R2>(
     self: Micro<A, E, R>,
-    pred: Refinement<E, EB>,
-    f: (a: NoInfer<EB>) => Micro<B, E2, R2>
-  ): Micro<A | B, E2, R | R2> =>
+    predicate: Predicate<E>,
+    f: (e: E) => Micro<A2, E2, R2>
+  ): Micro<A | A2, E | E2, R | R2> =>
     catchFailureIf(
       self,
-      (f): f is Failure.Expected<EB> => failureIsExpected(f) && pred(f.error),
+      (f): f is Failure.Expected<E> => failureIsExpected(f) && predicate(f.error),
       (failure) => f(failure.error)
     )
 )
@@ -2215,7 +2261,8 @@ export const catchTag: {
   self: Micro<A, E, R>,
   k: K,
   f: (e: Extract<E, { _tag: K }>) => Micro<A1, E1, R1>
-): Micro<A | A1, E1 | Exclude<E, { _tag: K }>, R | R1> => catchIf(self, (error) => isTagged(error, k), f as any))
+): Micro<A | A1, E1 | Exclude<E, { _tag: K }>, R | R1> =>
+  catchIf(self, isTagged(k) as Refinement<E, Extract<E, { _tag: K }>>, f) as any)
 
 /**
  * Transform the full `Failure` object of the given `Micro` effect.
@@ -3650,12 +3697,15 @@ export const runFork = <A, E>(
   const handle = new HandleImpl<A, E>(controller.signal, controller)
   effect[runSymbol](envSet(env, currentAbortSignal, handle._controller.signal), (result) => {
     handle.emit(result)
+    if (options?.signal) {
+      options.signal.removeEventListener("abort", handle.unsafeAbort)
+    }
   })
   if (options?.signal) {
     if (options.signal.aborted) {
       handle.unsafeAbort()
     } else {
-      options.signal.addEventListener("abort", () => handle.unsafeAbort())
+      options.signal.addEventListener("abort", handle.unsafeAbort, { once: true })
     }
   }
   return handle
@@ -3815,3 +3865,13 @@ export const TaggedError = <Tag extends string>(tag: Tag): new<A extends Record<
   ;(Base.prototype as any).name = tag
   return Base as any
 }
+
+/**
+ * Represents a checked exception which occurs when an expected element was
+ * unable to be found.
+ *
+ * @since 3.4.4
+ * @experimental
+ * @category errors
+ */
+export class NoSuchElementException extends TaggedError("NoSuchElementException")<{ message?: string | undefined }> {}

package/src/internal/version.ts

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