effect 2.0.0-next.55 → 2.0.0-next.56

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,13 +1620,13 @@ 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
 
@@ -1635,7 +1646,7 @@ export const tryPromise: {
             .then((a) => resolve(core.exitSucceed(a)))
             .catch((e) =>
               resolve(core.fail(
-                catcher ? catcher(e) : e
+                catcher ? catcher(e) : new core.UnknownException(e)
               ))
             )
           return core.sync(() => controller.abort())
@@ -2136,7 +2147,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 +2156,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

@@ -75,11 +75,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 +91,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 +113,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 +135,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 +158,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 +166,7 @@ export interface Read extends
 /** @internal */
 export interface Succeed extends
   Op<OpCodes.OP_SUCCEED, {
-    readonly evaluate: LazyArg<unknown>
+    evaluate(): unknown
   }>
 {}
 
@@ -183,7 +180,7 @@ export interface SucceedNow extends
 /** @internal */
 export interface Suspend extends
   Op<OpCodes.OP_SUSPEND, {
-    readonly channel: LazyArg<ErasedChannel>
+    channel(): ErasedChannel
   }>
 {}