effect 2.0.0-next.55 → 2.0.0-next.57

package/src/internal/core-effect.ts

@@ -95,9 +95,17 @@ export const asyncOption = <R, E, A>(
 
 /* @internal */
 export const try_: {
-  <A, E>(options: { readonly try: LazyArg<A>; readonly catch: (error: unknown) => E }): Effect.Effect<never, E, A>
-  <A>(evaluate: LazyArg<A>): Effect.Effect<never, unknown, A>
-} = <A, E>(arg: LazyArg<A> | { readonly try: LazyArg<A>; readonly catch: (error: unknown) => E }) => {
+  <A, E>(options: {
+    readonly try: LazyArg<A>
+    readonly catch: (error: unknown) => E
+  }): Effect.Effect<never, E, A>
+  <A>(evaluate: LazyArg<A>): Effect.Effect<never, Cause.UnknownException, A>
+} = <A, E>(
+  arg: LazyArg<A> | {
+    readonly try: LazyArg<A>
+    readonly catch: (error: unknown) => E
+  }
+) => {
   let evaluate: LazyArg<A>
   let onFailure: ((error: unknown) => E) | undefined = undefined
   if (typeof arg === "function") {
@@ -111,7 +119,7 @@ export const try_: {
       return evaluate()
     } catch (error) {
       throw core.makeEffectError(internalCause.fail(
-        onFailure ? onFailure(error) : error
+        onFailure ? onFailure(error) : new core.UnknownException(error)
       ))
     }
   })
@@ -479,32 +487,35 @@ export const dropUntil = dual<
 /* @internal */
 export const dropWhile = dual<
   <R, E, A>(
-    f: (a: A, i: number) => Effect.Effect<R, E, boolean>
+    predicate: (a: A, i: number) => Effect.Effect<R, E, boolean>
   ) => (elements: Iterable<A>) => Effect.Effect<R, E, Array<A>>,
   <R, E, A>(
     elements: Iterable<A>,
-    f: (a: A, i: number) => Effect.Effect<R, E, boolean>
+    predicate: (a: A, i: number) => Effect.Effect<R, E, boolean>
   ) => Effect.Effect<R, E, Array<A>>
->(2, <R, E, A>(elements: Iterable<A>, f: (a: A, i: number) => Effect.Effect<R, E, boolean>) =>
-  core.suspend(() => {
-    const iterator = elements[Symbol.iterator]()
-    const builder: Array<A> = []
-    let next
-    let dropping: Effect.Effect<R, E, boolean> = core.succeed(true)
-    let i = 0
-    while ((next = iterator.next()) && !next.done) {
-      const a = next.value
-      const index = i++
-      dropping = core.flatMap(dropping, (d) =>
-        core.map(d ? f(a, index) : core.succeed(false), (b) => {
-          if (!b) {
-            builder.push(a)
-          }
-          return b
-        }))
-    }
-    return core.map(dropping, () => builder)
-  }))
+>(
+  2,
+  <R, E, A>(elements: Iterable<A>, predicate: (a: A, i: number) => Effect.Effect<R, E, boolean>) =>
+    core.suspend(() => {
+      const iterator = elements[Symbol.iterator]()
+      const builder: Array<A> = []
+      let next
+      let dropping: Effect.Effect<R, E, boolean> = core.succeed(true)
+      let i = 0
+      while ((next = iterator.next()) && !next.done) {
+        const a = next.value
+        const index = i++
+        dropping = core.flatMap(dropping, (d) =>
+          core.map(d ? predicate(a, index) : core.succeed(false), (b) => {
+            if (!b) {
+              builder.push(a)
+            }
+            return b
+          }))
+      }
+      return core.map(dropping, () => builder)
+    })
+)
 
 /* @internal */
 export const contextWith = <R, A>(f: (context: Context.Context<R>) => A): Effect.Effect<R, never, A> =>
@@ -694,7 +705,7 @@ export const firstSuccessOf = <R, E, A>(effects: Iterable<Effect.Effect<R, E, A>
   core.suspend(() => {
     const list = Chunk.fromIterable(effects)
     if (!Chunk.isNonEmpty(list)) {
-      return core.dieSync(() => internalCause.IllegalArgumentException(`Received an empty collection of effects`))
+      return core.dieSync(() => new core.IllegalArgumentException(`Received an empty collection of effects`))
     }
     return pipe(
       Chunk.tailNonEmpty(list),
@@ -854,7 +865,7 @@ export const isSuccess = <R, E, A>(self: Effect.Effect<R, E, A>): Effect.Effect<
 export const iterate = <Z, R, E>(
   initial: Z,
   options: {
-    readonly while: (z: Z) => boolean
+    readonly while: Predicate.Predicate<Z>
     readonly body: (z: Z) => Effect.Effect<R, E, Z>
   }
 ): Effect.Effect<R, E, Z> =>
@@ -952,7 +963,7 @@ export const loop: {
   <Z, R, E, A>(
     initial: Z,
     options: {
-      readonly while: (z: Z) => boolean
+      readonly while: Predicate.Predicate<Z>
       readonly step: (z: Z) => Z
       readonly body: (z: Z) => Effect.Effect<R, E, A>
       readonly discard?: false | undefined
@@ -961,7 +972,7 @@ export const loop: {
   <Z, R, E, A>(
     initial: Z,
     options: {
-      readonly while: (z: Z) => boolean
+      readonly while: Predicate.Predicate<Z>
       readonly step: (z: Z) => Z
       readonly body: (z: Z) => Effect.Effect<R, E, A>
       readonly discard: true
@@ -970,7 +981,7 @@ export const loop: {
 } = <Z, R, E, A>(
   initial: Z,
   options: {
-    readonly while: (z: Z) => boolean
+    readonly while: Predicate.Predicate<Z>
     readonly step: (z: Z) => Z
     readonly body: (z: Z) => Effect.Effect<R, E, A>
     readonly discard?: boolean | undefined
@@ -982,7 +993,7 @@ export const loop: {
 
 const loopInternal = <Z, R, E, A>(
   initial: Z,
-  cont: (z: Z) => boolean,
+  cont: Predicate.Predicate<Z>,
   inc: (z: Z) => Z,
   body: (z: Z) => Effect.Effect<R, E, A>
 ): Effect.Effect<R, E, List.List<A>> =>
@@ -998,7 +1009,7 @@ const loopInternal = <Z, R, E, A>(
 
 const loopDiscard = <Z, R, E, X>(
   initial: Z,
-  cont: (z: Z) => boolean,
+  cont: Predicate.Predicate<Z>,
   inc: (z: Z) => Z,
   body: (z: Z) => Effect.Effect<R, E, X>
 ): Effect.Effect<R, E, void> =>
@@ -1609,16 +1620,15 @@ export const tryPromise: {
       readonly catch: (error: unknown) => E
     }
   ): Effect.Effect<never, E, A>
-  <A>(try_: (signal: AbortSignal) => Promise<A>): Effect.Effect<never, unknown, A>
+  <A>(try_: (signal: AbortSignal) => Promise<A>): Effect.Effect<never, Cause.UnknownException, A>
 } = <A, E>(
   arg: ((signal: AbortSignal) => Promise<A>) | {
     readonly try: (signal: AbortSignal) => Promise<A>
     readonly catch: (error: unknown) => E
   }
-): Effect.Effect<never, E | unknown, A> => {
+): Effect.Effect<never, E | Cause.UnknownException, A> => {
   let evaluate: (signal?: AbortSignal) => Promise<A>
   let catcher: ((error: unknown) => E) | undefined = undefined
-
   if (typeof arg === "function") {
     evaluate = arg as (signal?: AbortSignal) => Promise<A>
   } else {
@@ -1627,40 +1637,38 @@ export const tryPromise: {
   }
 
   if (evaluate.length >= 1) {
-    return core.suspend(() => {
-      const controller = new AbortController()
-      return core.flatMap(try_(() => evaluate(controller.signal)), (promise) =>
-        core.async((resolve) => {
-          promise
-            .then((a) => resolve(core.exitSucceed(a)))
-            .catch((e) =>
-              resolve(core.fail(
-                catcher ? catcher(e) : e
-              ))
-            )
-          return core.sync(() => controller.abort())
-        }))
-    })
-  }
-
-  return core.flatMap(
-    try_(
-      arg as {
-        readonly try: LazyArg<Promise<A>>
-        readonly catch: (error: unknown) => E
-      }
-    ),
-    (promise) =>
-      core.async<never, E, A>((resolve) => {
-        promise
+    return core.async((resolve, signal) => {
+      try {
+        evaluate(signal)
           .then((a) => resolve(core.exitSucceed(a)))
           .catch((e) =>
             resolve(core.fail(
-              catcher ? catcher(e) : e
+              catcher ? catcher(e) : new core.UnknownException(e)
             ))
           )
-      })
-  )
+      } catch (e) {
+        resolve(core.fail(
+          catcher ? catcher(e) : new core.UnknownException(e)
+        ))
+      }
+    })
+  }
+
+  return core.async((resolve) => {
+    try {
+      evaluate()
+        .then((a) => resolve(core.exitSucceed(a)))
+        .catch((e) =>
+          resolve(core.fail(
+            catcher ? catcher(e) : new core.UnknownException(e)
+          ))
+        )
+    } catch (e) {
+      resolve(core.fail(
+        catcher ? catcher(e) : new core.UnknownException(e)
+      ))
+    }
+  })
 }
 
 /* @internal */
@@ -2136,7 +2144,7 @@ export const withSpan = dual<
 
 /* @internal */
 export const fromNullable = <A>(value: A): Effect.Effect<never, Cause.NoSuchElementException, NonNullable<A>> =>
-  value == null ? core.fail(internalCause.NoSuchElementException()) : core.succeed(value as NonNullable<A>)
+  value == null ? core.fail(new core.NoSuchElementException()) : core.succeed(value as NonNullable<A>)
 
 /* @internal */
 export const optionFromOptional = <R, E, A>(
@@ -2145,7 +2153,7 @@ export const optionFromOptional = <R, E, A>(
   core.catchAll(
     core.map(self, Option.some),
     (error) =>
-      internalCause.isNoSuchElementException(error) ?
+      core.isNoSuchElementException(error) ?
         succeedNone :
         core.fail(error as Exclude<E, Cause.NoSuchElementException>)
   )

package/src/internal/core-stream.ts

@@ -28,14 +28,20 @@ export const ChannelTypeId: Channel.ChannelTypeId = Symbol.for(
   ChannelSymbolKey
 ) as Channel.ChannelTypeId
 
-/** @internal */
 const channelVariance = {
+  /* c8 ignore next */
   _Env: (_: never) => _,
+  /* c8 ignore next */
   _InErr: (_: unknown) => _,
+  /* c8 ignore next */
   _InElem: (_: unknown) => _,
+  /* c8 ignore next */
   _InDone: (_: unknown) => _,
+  /* c8 ignore next */
   _OutErr: (_: never) => _,
+  /* c8 ignore next */
   _OutElem: (_: never) => _,
+  /* c8 ignore next */
   _OutDone: (_: never) => _
 }
 
@@ -75,11 +81,8 @@ export type Primitive =
 /** @internal */
 export interface BracketOut extends
   Op<OpCodes.OP_BRACKET_OUT, {
-    readonly acquire: LazyArg<Effect.Effect<unknown, unknown, unknown>>
-    readonly finalizer: (
-      resource: unknown,
-      exit: Exit.Exit<unknown, unknown>
-    ) => Effect.Effect<unknown, unknown, unknown>
+    acquire(): Effect.Effect<unknown, unknown, unknown>
+    finalizer(resource: unknown, exit: Exit.Exit<unknown, unknown>): Effect.Effect<unknown, unknown, unknown>
   }>
 {}
 
@@ -94,14 +97,14 @@ export interface Bridge extends
 /** @internal */
 export interface ConcatAll extends
   Op<OpCodes.OP_CONCAT_ALL, {
-    readonly combineInners: (outDone: unknown, outDone2: unknown) => unknown
-    readonly combineAll: (outDone: unknown, outDone2: unknown) => unknown
-    readonly onPull: (
+    combineInners(outDone: unknown, outDone2: unknown): unknown
+    combineAll(outDone: unknown, outDone2: unknown): unknown
+    onPull(
       request: UpstreamPullRequest.UpstreamPullRequest<unknown>
-    ) => UpstreamPullStrategy.UpstreamPullStrategy<unknown>
-    readonly onEmit: (outElem: unknown) => ChildExecutorDecision.ChildExecutorDecision
-    readonly value: LazyArg<ErasedChannel>
-    readonly k: (outElem: unknown) => ErasedChannel
+    ): UpstreamPullStrategy.UpstreamPullStrategy<unknown>
+    onEmit(outElem: unknown): ChildExecutorDecision.ChildExecutorDecision
+    value(): ErasedChannel
+    k(outElem: unknown): ErasedChannel
   }>
 {}
 
@@ -116,14 +119,14 @@ export interface Emit extends
 export interface Ensuring extends
   Op<OpCodes.OP_ENSURING, {
     readonly channel: ErasedChannel
-    readonly finalizer: (exit: Exit.Exit<unknown, unknown>) => Effect.Effect<unknown, unknown, unknown>
+    finalizer(exit: Exit.Exit<unknown, unknown>): Effect.Effect<unknown, unknown, unknown>
   }>
 {}
 
 /** @internal */
 export interface Fail extends
   Op<OpCodes.OP_FAIL, {
-    readonly error: LazyArg<Cause.Cause<unknown>>
+    error(): Cause.Cause<unknown>
   }>
 {}
 
@@ -138,22 +141,22 @@ export interface Fold extends
 /** @internal */
 export interface FromEffect extends
   Op<OpCodes.OP_FROM_EFFECT, {
-    readonly effect: LazyArg<Effect.Effect<unknown, unknown, unknown>>
+    effect(): Effect.Effect<unknown, unknown, unknown>
   }>
 {}
 
 /** @internal */
 export interface PipeTo extends
   Op<OpCodes.OP_PIPE_TO, {
-    readonly left: LazyArg<ErasedChannel>
-    readonly right: LazyArg<ErasedChannel>
+    left(): ErasedChannel
+    right(): ErasedChannel
   }>
 {}
 
 /** @internal */
 export interface Provide extends
   Op<OpCodes.OP_PROVIDE, {
-    readonly context: LazyArg<Context.Context<unknown>>
+    context(): Context.Context<unknown>
     readonly inner: ErasedChannel
   }>
 {}
@@ -161,7 +164,7 @@ export interface Provide extends
 /** @internal */
 export interface Read extends
   Op<OpCodes.OP_READ, {
-    readonly more: (input: unknown) => ErasedChannel
+    more(input: unknown): ErasedChannel
     readonly done: ErasedContinuationK
   }>
 {}
@@ -169,7 +172,7 @@ export interface Read extends
 /** @internal */
 export interface Succeed extends
   Op<OpCodes.OP_SUCCEED, {
-    readonly evaluate: LazyArg<unknown>
+    evaluate(): unknown
   }>
 {}
 
@@ -183,7 +186,7 @@ export interface SucceedNow extends
 /** @internal */
 export interface Suspend extends
   Op<OpCodes.OP_SUSPEND, {
-    readonly channel: LazyArg<ErasedChannel>
+    channel(): ErasedChannel
   }>
 {}