effect 2.0.0-next.52 → 2.0.0-next.53

package/src/internal/stm/stm/tExit.ts

@@ -3,6 +3,7 @@ import type * as FiberId from "../../../FiberId"
 import { pipe } from "../../../Function"
 import * as Hash from "../../../Hash"
 import * as OpCodes from "../../../internal/stm/opCodes/tExit"
+import { hasProperty } from "../../../Predicate"
 
 /** @internal */
 const TExitSymbolKey = "effect/TExit"
@@ -63,9 +64,7 @@ export interface Retry extends TExit.Variance<never, never>, Equal.Equal {
 }
 
 /** @internal */
-export const isExit = (u: unknown): u is TExit<unknown, unknown> => {
-  return typeof u === "object" && u != null && TExitTypeId in u
-}
+export const isExit = (u: unknown): u is TExit<unknown, unknown> => hasProperty(u, TExitTypeId)
 
 /** @internal */
 export const isFail = <E, A>(self: TExit<E, A>): self is Fail<E> => {

package/src/internal/stm/tQueue.ts

@@ -5,7 +5,7 @@ import * as OpCodes from "../../internal/stm/opCodes/strategy"
 import * as stm from "../../internal/stm/stm"
 import * as tRef from "../../internal/stm/tRef"
 import * as Option from "../../Option"
-import type { Predicate } from "../../Predicate"
+import { hasProperty, type Predicate } from "../../Predicate"
 import * as RA from "../../ReadonlyArray"
 import * as STM from "../../STM"
 import type * as TQueue from "../../TQueue"
@@ -244,14 +244,10 @@ export const isTQueue = (u: unknown): u is TQueue.TQueue<unknown> => {
 }
 
 /** @internal */
-export const isTEnqueue = (u: unknown): u is TQueue.TEnqueue<unknown> => {
-  return typeof u === "object" && u != null && TEnqueueTypeId in u
-}
+export const isTEnqueue = (u: unknown): u is TQueue.TEnqueue<unknown> => hasProperty(u, TEnqueueTypeId)
 
 /** @internal */
-export const isTDequeue = (u: unknown): u is TQueue.TDequeue<unknown> => {
-  return typeof u === "object" && u != null && TDequeueTypeId in u
-}
+export const isTDequeue = (u: unknown): u is TQueue.TDequeue<unknown> => hasProperty(u, TDequeueTypeId)
 
 /** @internal */
 export const awaitShutdown = <A>(self: TQueue.TDequeue<A> | TQueue.TEnqueue<A>): STM.STM<never, never, void> =>

package/src/internal/stream.ts

@@ -17,7 +17,7 @@ import * as Layer from "../Layer"
 import * as Option from "../Option"
 import type * as Order from "../Order"
 import { pipeArguments } from "../Pipeable"
-import type { Predicate, Refinement } from "../Predicate"
+import { hasProperty, isTagged, type Predicate, type Refinement } from "../Predicate"
 import * as PubSub from "../PubSub"
 import * as Queue from "../Queue"
 import * as Ref from "../Ref"
@@ -78,11 +78,34 @@ export class StreamImpl<R, E, A> implements Stream.Stream<R, E, A> {
 
 /** @internal */
 export const isStream = (u: unknown): u is Stream.Stream<unknown, unknown, unknown> =>
-  (typeof u === "object" && u != null && StreamTypeId in u) || Effect.isEffect(u)
+  hasProperty(u, StreamTypeId) || Effect.isEffect(u)
 
 /** @internal */
 export const DefaultChunkSize = 4096
 
+/** @internal */
+export const accumulate = <R, E, A>(self: Stream.Stream<R, E, A>): Stream.Stream<R, E, Chunk.Chunk<A>> =>
+  chunks(accumulateChunks(self))
+
+/** @internal */
+export const accumulateChunks = <R, E, A>(self: Stream.Stream<R, E, A>): Stream.Stream<R, E, A> => {
+  const accumulator = (
+    s: Chunk.Chunk<A>
+  ): Channel.Channel<never, E, Chunk.Chunk<A>, unknown, E, Chunk.Chunk<A>, void> =>
+    core.readWith({
+      onInput: (input: Chunk.Chunk<A>) => {
+        const next = Chunk.appendAll(s, input)
+        return core.flatMap(
+          core.write(next),
+          () => accumulator(next)
+        )
+      },
+      onFailure: core.fail,
+      onDone: () => core.unit
+    })
+  return new StreamImpl(core.pipeTo(toChannel(self), accumulator(Chunk.empty())))
+}
+
 /** @internal */
 export const acquireRelease = <R, E, A, R2, _>(
   acquire: Effect.Effect<R, E, A>,
@@ -3077,10 +3100,7 @@ export const fromReadableStreamByob = <E>(
     (reader) =>
       catchAll(
         forever(readChunkStreamByobReader(reader, onError, allocSize)),
-        (error) =>
-          typeof error === "object" && error !== null && "_tag" in error && error._tag === "EOF" ?
-            empty :
-            fail(error as E)
+        (error) => isTagged(error, "EOF") ? empty : fail(error as E)
       )
   ))
 

package/src/internal/supervisor.ts

@@ -7,6 +7,7 @@ import { globalValue } from "../GlobalValue"
 import * as core from "../internal/core"
 import * as MutableRef from "../MutableRef"
 import type * as Option from "../Option"
+import { hasProperty, isTagged } from "../Predicate"
 import * as SortedSet from "../SortedSet"
 import type * as Supervisor from "../Supervisor"
 
@@ -125,9 +126,8 @@ export class Zip<T0, T1> implements Supervisor.Supervisor<readonly [T0, T1]> {
   }
 }
 
-export const isZip = (self: unknown): self is Zip<any, any> => {
-  return typeof self === "object" && self !== null && SupervisorTypeId in self && "_tag" in self && self._tag === "Zip"
-}
+export const isZip = (self: unknown): self is Zip<any, any> =>
+  hasProperty(self, SupervisorTypeId) && isTagged(self, "Zip")
 
 export class Track implements Supervisor.Supervisor<Array<Fiber.RuntimeFiber<any, any>>> {
   readonly [SupervisorTypeId] = supervisorVariance

package/src/internal/version.ts

@@ -0,0 +1 @@
+export const moduleVersion = "2.0.0-next.53"