effect 3.3.5 → 3.4.1

package/src/Option.ts

@@ -1115,7 +1115,18 @@ export const lift2 = <A, B, C>(f: (a: A, b: B) => C): {
 export const liftPredicate: { // Note: I intentionally avoid using the NoInfer pattern here.
   <A, B extends A>(refinement: Refinement<A, B>): (a: A) => Option<B>
   <B extends A, A = B>(predicate: Predicate<A>): (b: B) => Option<B>
-} = <B extends A, A = B>(predicate: Predicate<A>) => (b: B): Option<B> => predicate(b) ? some(b) : none()
+  <A, B extends A>(
+    self: A,
+    refinement: Refinement<A, B>
+  ): Option<B>
+  <B extends A, A = B>(
+    self: B,
+    predicate: Predicate<A>
+  ): Option<B>
+} = dual(
+  2,
+  <B extends A, A = B>(b: B, predicate: Predicate<A>): Option<B> => predicate(b) ? some(b) : none()
+)
 
 /**
  * Returns a function that checks if a `Option` contains a given value using a provided `isEquivalent` function.

package/src/Schedule.ts

@@ -1262,7 +1262,7 @@ export const upTo: {
 } = internal.upTo
 
 /**
- * Returns a new schedule that continues for as long the specified predicate
+ * Returns a new schedule that continues for as long as the specified predicate
  * on the input evaluates to true.
  *
  * @since 2.0.0
@@ -1274,7 +1274,7 @@ export const whileInput: {
 } = internal.whileInput
 
 /**
- * Returns a new schedule that continues for as long the specified effectful
+ * Returns a new schedule that continues for as long as the specified effectful
  * predicate on the input evaluates to true.
  *
  * @since 2.0.0

package/src/Stream.ts

@@ -112,13 +112,37 @@ export declare namespace Stream {
    * @category models
    */
   export interface Variance<out A, out E, out R> {
-    readonly [StreamTypeId]: {
-      _A: Covariant<A>
-      _E: Covariant<E>
-      _R: Covariant<R>
-    }
+    readonly [StreamTypeId]: VarianceStruct<A, E, R>
+  }
+
+  /**
+   * @since 3.4.0
+   * @category models
+   */
+  export interface VarianceStruct<out A, out E, out R> {
+    readonly _A: Covariant<A>
+    readonly _E: Covariant<E>
+    readonly _R: Covariant<R>
   }
 
+  /**
+   * @since 3.4.0
+   * @category type-level
+   */
+  export type Success<T extends Stream<any, any, any>> = [T] extends [Stream<infer _A, infer _E, infer _R>] ? _A : never
+
+  /**
+   * @since 3.4.0
+   * @category type-level
+   */
+  export type Error<T extends Stream<any, any, any>> = [T] extends [Stream<infer _A, infer _E, infer _R>] ? _E : never
+
+  /**
+   * @since 3.4.0
+   * @category type-level
+   */
+  export type Context<T extends Stream<any, any, any>> = [T] extends [Stream<infer _A, infer _E, infer _R>] ? _R : never
+
   /**
    * @since 2.0.0
    * @category models
@@ -4735,12 +4759,40 @@ export const decodeText: {
  */
 export const encodeText: <E, R>(self: Stream<string, E, R>) => Stream<Uint8Array, E, R> = internal.encodeText
 
+/**
+ * @since 3.4.0
+ * @category models
+ */
+export interface EventListener<A> {
+  addEventListener(
+    event: string,
+    f: (event: A) => void,
+    options?: {
+      readonly capture?: boolean
+      readonly passive?: boolean
+      readonly once?: boolean
+      readonly signal?: AbortSignal
+    } | boolean
+  ): void
+  removeEventListener(
+    event: string,
+    f: (event: A) => void,
+    options?: {
+      readonly capture?: boolean
+    } | boolean
+  ): void
+}
+
 /**
  * Creates a `Stream` using addEventListener.
  * @since 3.1.0
  */
-export const fromEventListener: <A = Event>(
-  target: EventTarget,
+export const fromEventListener: <A = unknown>(
+  target: EventListener<A>,
   type: string,
-  options?: boolean | Omit<AddEventListenerOptions, "signal">
+  options?: boolean | {
+    readonly capture?: boolean
+    readonly passive?: boolean
+    readonly once?: boolean
+  } | undefined
 ) => Stream<A> = internal.fromEventListener

package/src/Tuple.ts

@@ -194,14 +194,24 @@ export const appendElement: {
   <A extends ReadonlyArray<unknown>, B>(self: A, that: B): [...A, B]
 } = dual(2, <A extends ReadonlyArray<unknown>, B>(self: A, that: B): [...A, B] => [...self, that])
 
-/*
-
-  TODO:
-
-  - at
-  - swap
-
-*/
+/**
+ * Retrieves the element at a specified index from a tuple.
+ *
+ * @param self - A tuple from which to retrieve the element.
+ * @param index - The index of the element to retrieve.
+ *
+ * @example
+ * import { Tuple } from "effect"
+ *
+ * assert.deepStrictEqual(Tuple.at([1, 'hello', true], 1), 'hello')
+ *
+ * @category getters
+ * @since 3.4.0
+ */
+export const at: {
+  <N extends number>(index: N): <A extends ReadonlyArray<unknown>>(self: A) => A[N]
+  <A extends ReadonlyArray<unknown>, N extends number>(self: A, index: N): A[N]
+} = dual(2, <A extends ReadonlyArray<unknown>, N extends number>(self: A, index: N): A[N] => self[index])
 
 export {
   /**

package/src/index.ts

@@ -479,6 +479,14 @@ export * as MetricRegistry from "./MetricRegistry.js"
  */
 export * as MetricState from "./MetricState.js"
 
+/**
+ * A lightweight alternative to the `Effect` data type, with a subset of the functionality.
+ *
+ * @since 3.4.0
+ * @experimental
+ */
+export * as Micro from "./Micro.js"
+
 /**
  * @since 2.0.0
  *

package/src/internal/core-effect.ts

@@ -582,6 +582,39 @@ export const filterOrElse: {
     (a) => predicate(a) ? core.succeed<A | B>(a) : orElse(a)
   ))
 
+/** @internal */
+export const liftPredicate = dual<
+  {
+    <A, B extends A, E>(
+      refinement: Predicate.Refinement<NoInfer<A>, B>,
+      orFailWith: (a: NoInfer<A>) => E
+    ): (a: A) => Effect.Effect<B, E>
+    <A, E>(
+      predicate: Predicate.Predicate<NoInfer<A>>,
+      orFailWith: (a: NoInfer<A>) => E
+    ): (a: A) => Effect.Effect<A, E>
+  },
+  {
+    <A, E, B extends A>(
+      self: A,
+      refinement: Predicate.Refinement<A, B>,
+      orFailWith: (a: A) => E
+    ): Effect.Effect<B, E>
+    <A, E>(
+      self: A,
+      predicate: Predicate.Predicate<NoInfer<A>>,
+      orFailWith: (a: NoInfer<A>) => E
+    ): Effect.Effect<A, E>
+  }
+>(
+  3,
+  <A, E>(
+    self: A,
+    predicate: Predicate.Predicate<NoInfer<A>>,
+    orFailWith: (a: NoInfer<A>) => E
+  ): Effect.Effect<A, E> => core.suspend(() => predicate(self) ? core.succeed(self) : core.fail(orFailWith(self)))
+)
+
 /* @internal */
 export const filterOrFail: {
   <A, B extends A, E2>(

package/src/internal/core.ts

@@ -149,7 +149,6 @@ export class RevertFlags {
   }
 }
 
-/** @internal */
 class EffectPrimitive {
   public effect_instruction_i0 = undefined
   public effect_instruction_i1 = undefined
@@ -504,6 +503,24 @@ export const custom: {
   return wrapper
 }
 
+/* @internal */
+export const unsafeAsync = <A, E = never, R = never>(
+  register: (
+    callback: (_: Effect.Effect<A, E, R>) => void
+  ) => void | Effect.Effect<void, never, R>,
+  blockingOn: FiberId.FiberId = FiberId.none
+): Effect.Effect<A, E, R> => {
+  const effect = new EffectPrimitive(OpCodes.OP_ASYNC) as any
+  let cancelerRef: Effect.Effect<void, never, R> | void = undefined
+  effect.effect_instruction_i0 = (resume: (_: Effect.Effect<A, E, R>) => void) => {
+    cancelerRef = register(resume)
+  }
+  effect.effect_instruction_i1 = blockingOn
+  return cancelerRef !== undefined ?
+    onInterrupt(effect, (_) => cancelerRef!) :
+    effect
+}
+
 /* @internal */
 export const async = <A, E = never, R = never>(
   register: (

package/src/internal/fiberRuntime.ts

@@ -28,6 +28,7 @@ import * as Inspectable from "../Inspectable.js"
 import type { Logger } from "../Logger.js"
 import * as LogLevel from "../LogLevel.js"
 import type * as MetricLabel from "../MetricLabel.js"
+import * as Micro from "../Micro.js"
 import * as MRef from "../MutableRef.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
@@ -1073,6 +1074,37 @@ export class FiberRuntime<in out A, in out E = never> implements Fiber.RuntimeFi
     return core.exitSucceed(op.value)
   }
 
+  ["Micro"](op: Micro.Micro<any, any, never> & { _op: "Micro" }) {
+    return core.unsafeAsync<any, any>((microResume) => {
+      const env = Micro.envUnsafeMakeEmpty().pipe(
+        Micro.envSet(Micro.currentContext, this.getFiberRef(core.currentContext))
+      )
+      let resume = microResume
+      op[Micro.runSymbol](env, (result) => {
+        if (result._tag === "Right") {
+          return resume(core.exitSucceed(result.right))
+        }
+        switch (result.left._tag) {
+          case "Aborted": {
+            return resume(core.exitFailCause(internalCause.interrupt(FiberId.none)))
+          }
+          case "Expected": {
+            return resume(core.fail(result.left.error))
+          }
+          case "Unexpected": {
+            return resume(core.die(result.left.defect))
+          }
+        }
+      })
+      return core.async<void>((abortResume) => {
+        resume = (_: any) => {
+          abortResume(core.void)
+        }
+        Micro.envGet(env, Micro.currentAbortController).abort()
+      })
+    })
+  }
+
   [OpCodes.OP_SYNC](op: core.Primitive & { _op: OpCodes.OP_SYNC }) {
     const value = internalCall(() => op.effect_instruction_i0())
     const cont = this.getNextSuccessCont()

package/src/internal/stream.ts

@@ -8103,10 +8103,14 @@ export const encodeText = <E, R>(self: Stream.Stream<string, E, R>): Stream.Stre
   })
 
 /** @internal */
-export const fromEventListener = <A = Event>(
-  target: EventTarget,
+export const fromEventListener = <A = unknown>(
+  target: Stream.EventListener<A>,
   type: string,
-  options?: boolean | Omit<AddEventListenerOptions, "signal">
+  options?: boolean | {
+    readonly capture?: boolean
+    readonly passive?: boolean
+    readonly once?: boolean
+  } | undefined
 ): Stream.Stream<A> =>
   _async<A>((emit) => {
     let batch: Array<A> = []
@@ -8124,5 +8128,5 @@ export const fromEventListener = <A = Event>(
       }
     }
     target.addEventListener(type, cb as any, options)
-    return Effect.sync(() => target.removeEventListener(type, cb as any, options))
+    return Effect.sync(() => target.removeEventListener(type, cb, options))
   })

package/src/internal/version.ts

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