refactor(Stream): use more common Types.TupleOf instead of Stream.Dyn…

…amicTuple (Effect-TS#2958)
GUNGODD · Jul 10, 2024 · 13cb861 · 13cb861
1 parent e7fc45f
commit 13cb861
Show file tree

Hide file tree

Showing 3 changed files with 27 additions and 23 deletions.
diff --git a/.changeset/stream-tuple.md b/.changeset/stream-tuple.md
@@ -0,0 +1,5 @@
+---
+"effect": minor
+---
+
+refactor(Stream): use new built-in `Types.TupleOf` instead of `Stream.DynamicTuple` and deprecate it
diff --git a/packages/effect/src/Stream.ts b/packages/effect/src/Stream.ts
@@ -30,7 +30,7 @@ import type * as Emit from "./StreamEmit.js"
 import type * as HaltStrategy from "./StreamHaltStrategy.js"
 import type * as Take from "./Take.js"
 import type * as Tracer from "./Tracer.js"
-import type { Covariant, NoInfer } from "./Types.js"
+import type { Covariant, NoInfer, TupleOf } from "./Types.js"
 import type * as Unify from "./Unify.js"
 
 /**
@@ -146,13 +146,15 @@ export declare namespace Stream {
  /**
  * @since 2.0.0
  * @category models
+ * @deprecated use Types.TupleOf instead
  */
  export type DynamicTuple<T, N extends number> = N extends N ? number extends N ? Array<T> : DynamicTupleOf<T, N, []>
  : never
 
  /**
  * @since 2.0.0
  * @category models
+ * @deprecated use Types.TupleOf instead
  */
  export type DynamicTupleOf<T, N extends number, R extends Array<unknown>> = R["length"] extends N ? R
  : DynamicTupleOf<T, N, [T, ...R]>
@@ -484,12 +486,12 @@ export const broadcast: {
  maximumLag: number
  ): <A, E, R>(
  self: Stream<A, E, R>
- ) => Effect.Effect<Stream.DynamicTuple<Stream<A, E>, N>, never, Scope.Scope | R>
+ ) => Effect.Effect<TupleOf<N, Stream<A, E>>, never, Scope.Scope | R>
  <A, E, R, N extends number>(
  self: Stream<A, E, R>,
  n: N,
  maximumLag: number
- ): Effect.Effect<Stream.DynamicTuple<Stream<A, E>, N>, never, Scope.Scope | R>
+ ): Effect.Effect<TupleOf<N, Stream<A, E>>, never, Scope.Scope | R>
 } = internal.broadcast
 
 /**
@@ -521,12 +523,12 @@ export const broadcastedQueues: {
  maximumLag: number
  ): <A, E, R>(
  self: Stream<A, E, R>
- ) => Effect.Effect<Stream.DynamicTuple<Queue.Dequeue<Take.Take<A, E>>, N>, never, R | Scope.Scope>
+ ) => Effect.Effect<TupleOf<N, Queue.Dequeue<Take.Take<A, E>>>, never, R | Scope.Scope>
  <A, E, R, N extends number>(
  self: Stream<A, E, R>,
  n: N,
  maximumLag: number
- ): Effect.Effect<Stream.DynamicTuple<Queue.Dequeue<Take.Take<A, E>>, N>, never, Scope.Scope | R>
+ ): Effect.Effect<TupleOf<N, Queue.Dequeue<Take.Take<A, E>>>, never, Scope.Scope | R>
 } = internal.broadcastedQueues
 
 /**
@@ -1139,15 +1141,15 @@ export const distributedWith: {
  }
  ): <E, R>(
  self: Stream<A, E, R>
- ) => Effect.Effect<Stream.DynamicTuple<Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>, N>, never, Scope.Scope | R>
+ ) => Effect.Effect<TupleOf<N, Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>>, never, Scope.Scope | R>
  <A, E, R, N extends number>(
  self: Stream<A, E, R>,
  options: {
  readonly size: N
  readonly maximumLag: number
  readonly decide: (a: A) => Effect.Effect<Predicate<number>>
  }
- ): Effect.Effect<Stream.DynamicTuple<Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>, N>, never, Scope.Scope | R>
+ ): Effect.Effect<TupleOf<N, Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>>, never, Scope.Scope | R>
 } = internal.distributedWith
 
 /**

diff --git a/packages/effect/src/internal/stream.ts b/packages/effect/src/internal/stream.ts
@@ -31,7 +31,7 @@ import * as HaltStrategy from "../StreamHaltStrategy.js"
 import type * as Take from "../Take.js"
 import type * as Tracer from "../Tracer.js"
 import * as Tuple from "../Tuple.js"
-import type { NoInfer } from "../Types.js"
+import type { NoInfer, TupleOf } from "../Types.js"
 import * as channel from "./channel.js"
 import * as channelExecutor from "./channel/channelExecutor.js"
 import * as MergeStrategy from "./channel/mergeStrategy.js"
@@ -685,25 +685,22 @@ export const broadcast = dual<
  maximumLag: number
  ) => <A, E, R>(
  self: Stream.Stream<A, E, R>
- ) => Effect.Effect<Stream.Stream.DynamicTuple<Stream.Stream<A, E>, N>, never, Scope.Scope | R>,
+ ) => Effect.Effect<TupleOf<N, Stream.Stream<A, E>>, never, Scope.Scope | R>,
  <A, E, R, N extends number>(
  self: Stream.Stream<A, E, R>,
  n: N,
  maximumLag: number
- ) => Effect.Effect<Stream.Stream.DynamicTuple<Stream.Stream<A, E>, N>, never, Scope.Scope | R>
+ ) => Effect.Effect<TupleOf<N, Stream.Stream<A, E>>, never, Scope.Scope | R>
 >(3, <A, E, R, N extends number>(
  self: Stream.Stream<A, E, R>,
  n: N,
  maximumLag: number
-): Effect.Effect<Stream.Stream.DynamicTuple<Stream.Stream<A, E>, N>, never, Scope.Scope | R> =>
+): Effect.Effect<TupleOf<N, Stream.Stream<A, E>>, never, Scope.Scope | R> =>
  pipe(
  self,
  broadcastedQueues(n, maximumLag),
  Effect.map((tuple) =>
- tuple.map((queue) => flattenTake(fromQueue(queue, { shutdown: true }))) as Stream.Stream.DynamicTuple<
- Stream.Stream<A, E>,
- N
- >
+ tuple.map((queue) => flattenTake(fromQueue(queue, { shutdown: true }))) as TupleOf<N, Stream.Stream<A, E>>
  )
  ))
 
@@ -733,21 +730,21 @@ export const broadcastedQueues = dual<
  maximumLag: number
  ) => <A, E, R>(
  self: Stream.Stream<A, E, R>
- ) => Effect.Effect<Stream.Stream.DynamicTuple<Queue.Dequeue<Take.Take<A, E>>, N>, never, Scope.Scope | R>,
+ ) => Effect.Effect<TupleOf<N, Queue.Dequeue<Take.Take<A, E>>>, never, Scope.Scope | R>,
  <A, E, R, N extends number>(
  self: Stream.Stream<A, E, R>,
  n: N,
  maximumLag: number
- ) => Effect.Effect<Stream.Stream.DynamicTuple<Queue.Dequeue<Take.Take<A, E>>, N>, never, Scope.Scope | R>
+ ) => Effect.Effect<TupleOf<N, Queue.Dequeue<Take.Take<A, E>>>, never, Scope.Scope | R>
 >(3, <A, E, R, N extends number>(
  self: Stream.Stream<A, E, R>,
  n: N,
  maximumLag: number
-): Effect.Effect<Stream.Stream.DynamicTuple<Queue.Dequeue<Take.Take<A, E>>, N>, never, Scope.Scope | R> =>
+): Effect.Effect<TupleOf<N, Queue.Dequeue<Take.Take<A, E>>>, never, Scope.Scope | R> =>
  Effect.flatMap(PubSub.bounded<Take.Take<A, E>>(maximumLag), (pubsub) =>
  pipe(
  Effect.all(Array.from({ length: n }, () => PubSub.subscribe(pubsub))) as Effect.Effect<
- Stream.Stream.DynamicTuple<Queue.Dequeue<Take.Take<A, E>>, N>,
+ TupleOf<N, Queue.Dequeue<Take.Take<A, E>>>,
  never,
  R
  >,
@@ -1764,7 +1761,7 @@ export const distributedWith = dual<
  ) => <E, R>(
  self: Stream.Stream<A, E, R>
  ) => Effect.Effect<
- Stream.Stream.DynamicTuple<Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>, N>,
+ TupleOf<N, Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>>,
  never,
  Scope.Scope | R
  >,
@@ -1776,7 +1773,7 @@ export const distributedWith = dual<
  readonly decide: (a: A) => Effect.Effect<Predicate<number>>
  }
  ) => Effect.Effect<
- Stream.Stream.DynamicTuple<Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>, N>,
+ TupleOf<N, Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>>,
  never,
  Scope.Scope | R
  >
@@ -1790,7 +1787,7 @@ export const distributedWith = dual<
  readonly decide: (a: A) => Effect.Effect<Predicate<number>>
  }
  ): Effect.Effect<
- Stream.Stream.DynamicTuple<Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>, N>,
+ TupleOf<N, Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>>,
  never,
  Scope.Scope | R
  > =>
@@ -1829,7 +1826,7 @@ export const distributedWith = dual<
  Deferred.succeed(deferred, (a: A) =>
  Effect.map(options.decide(a), (f) => (key: number) => pipe(f(mappings.get(key)!)))),
  Effect.as(
- Array.from(queues) as Stream.Stream.DynamicTuple<Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>, N>
+ Array.from(queues) as TupleOf<N, Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>>
  )
  )
  })