effect 3.9.2 → 3.10.1

package/src/internal/stm/tSubscriptionRef.ts

@@ -0,0 +1,286 @@
+import * as Effect from "../../Effect.js"
+import { dual, pipe } from "../../Function.js"
+import * as Option from "../../Option.js"
+import { pipeArguments } from "../../Pipeable.js"
+import * as STM from "../../STM.js"
+import * as TPubSub from "../../TPubSub.js"
+import * as TQueue from "../../TQueue.js"
+import * as TRef from "../../TRef.js"
+import type * as TSubscriptionRef from "../../TSubscriptionRef.js"
+import * as stream from "../stream.js"
+import { tDequeueVariance } from "./tQueue.js"
+import { tRefVariance } from "./tRef.js"
+
+/** @internal */
+const TSubscriptionRefSymbolKey = "effect/TSubscriptionRef"
+
+/** @internal */
+export const TSubscriptionRefTypeId: TSubscriptionRef.TSubscriptionRefTypeId = Symbol.for(
+  TSubscriptionRefSymbolKey
+) as TSubscriptionRef.TSubscriptionRefTypeId
+
+const TSubscriptionRefVariance = {
+  /* c8 ignore next */
+  _A: (_: any) => _
+}
+
+class TDequeueMerge<A> implements TQueue.TDequeue<A> {
+  [TQueue.TDequeueTypeId] = tDequeueVariance
+
+  constructor(
+    readonly first: TQueue.TDequeue<A>,
+    readonly second: TQueue.TDequeue<A>
+  ) {}
+
+  peek: STM.STM<A> = STM.gen(this, function*() {
+    const first = yield* this.peekOption
+    if (first._tag === "Some") {
+      return first.value
+    }
+    return yield* STM.retry
+  })
+
+  peekOption: STM.STM<Option.Option<A>> = STM.gen(this, function*() {
+    const first = yield* this.first.peekOption
+    if (first._tag === "Some") {
+      return first
+    }
+    const second = yield* this.second.peekOption
+    if (second._tag === "Some") {
+      return second
+    }
+    return Option.none()
+  })
+
+  take: STM.STM<A> = STM.gen(this, function*() {
+    if (!(yield* this.first.isEmpty)) {
+      return yield* this.first.take
+    }
+    if (!(yield* this.second.isEmpty)) {
+      return yield* this.second.take
+    }
+    return yield* STM.retry
+  })
+
+  takeAll: STM.STM<Array<A>> = STM.gen(this, function*() {
+    return [...yield* this.first.takeAll, ...yield* this.second.takeAll]
+  })
+
+  takeUpTo(max: number): STM.STM<Array<A>> {
+    return STM.gen(this, function*() {
+      const first = yield* this.first.takeUpTo(max)
+      if (first.length >= max) {
+        return first
+      }
+      return [...first, ...yield* this.second.takeUpTo(max - first.length)]
+    })
+  }
+
+  capacity(): number {
+    return this.first.capacity() + this.second.capacity()
+  }
+
+  size: STM.STM<number> = STM.gen(this, function*() {
+    return (yield* this.first.size) + (yield* this.second.size)
+  })
+
+  isFull: STM.STM<boolean> = STM.gen(this, function*() {
+    return (yield* this.first.isFull) && (yield* this.second.isFull)
+  })
+
+  isEmpty: STM.STM<boolean> = STM.gen(this, function*() {
+    return (yield* this.first.isEmpty) && (yield* this.second.isEmpty)
+  })
+
+  shutdown: STM.STM<void> = STM.gen(this, function*() {
+    yield* this.first.shutdown
+    yield* this.second.shutdown
+  })
+
+  isShutdown: STM.STM<boolean> = STM.gen(this, function*() {
+    return (yield* this.first.isShutdown) && (yield* this.second.isShutdown)
+  })
+
+  awaitShutdown: STM.STM<void> = STM.gen(this, function*() {
+    yield* this.first.awaitShutdown
+    yield* this.second.awaitShutdown
+  })
+}
+
+/** @internal */
+class TSubscriptionRefImpl<in out A> implements TSubscriptionRef.TSubscriptionRef<A> {
+  readonly [TSubscriptionRefTypeId] = TSubscriptionRefVariance
+  readonly [TRef.TRefTypeId] = tRefVariance
+
+  constructor(
+    readonly ref: TRef.TRef<A>,
+    readonly pubsub: TPubSub.TPubSub<A>
+  ) {}
+
+  get todos() {
+    return this.ref.todos
+  }
+
+  get versioned() {
+    return this.ref.versioned
+  }
+
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+
+  get changes(): STM.STM<TQueue.TDequeue<A>> {
+    return STM.gen(this, function*() {
+      const first = yield* TQueue.unbounded<A>()
+      yield* TQueue.offer(first, yield* TRef.get(this.ref))
+      return new TDequeueMerge(first, yield* TPubSub.subscribe(this.pubsub))
+    })
+  }
+
+  modify<B>(f: (a: A) => readonly [B, A]): STM.STM<B> {
+    return pipe(
+      TRef.get(this.ref),
+      STM.map(f),
+      STM.flatMap(([b, a]) =>
+        pipe(
+          TRef.set(this.ref, a),
+          STM.as(b),
+          STM.zipLeft(TPubSub.publish(this.pubsub, a))
+        )
+      )
+    )
+  }
+}
+
+/** @internal */
+export const make = <A>(value: A): STM.STM<TSubscriptionRef.TSubscriptionRef<A>> =>
+  pipe(
+    STM.all([
+      TPubSub.unbounded<A>(),
+      TRef.make(value)
+    ]),
+    STM.map(([pubsub, ref]) => new TSubscriptionRefImpl(ref, pubsub))
+  )
+
+/** @internal */
+export const get = <A>(self: TSubscriptionRef.TSubscriptionRef<A>) => TRef.get(self.ref)
+
+/** @internal */
+export const set = dual<
+  <A>(value: A) => (self: TSubscriptionRef.TSubscriptionRef<A>) => STM.STM<void>,
+  <A>(self: TSubscriptionRef.TSubscriptionRef<A>, value: A) => STM.STM<void>
+>(
+  2,
+  <A>(self: TSubscriptionRef.TSubscriptionRef<A>, value: A): STM.STM<void> =>
+    self.modify((): [void, A] => [void 0, value])
+)
+
+/** @internal */
+export const getAndSet = dual<
+  <A>(value: A) => (self: TSubscriptionRef.TSubscriptionRef<A>) => STM.STM<A>,
+  <A>(self: TSubscriptionRef.TSubscriptionRef<A>, value: A) => STM.STM<A>
+>(2, (self, value) => self.modify((a) => [a, value]))
+
+/** @internal */
+export const getAndUpdate = dual<
+  <A>(f: (a: A) => A) => (self: TSubscriptionRef.TSubscriptionRef<A>) => STM.STM<A>,
+  <A>(self: TSubscriptionRef.TSubscriptionRef<A>, f: (a: A) => A) => STM.STM<A>
+>(2, (self, f) => self.modify((a) => [a, f(a)]))
+
+/** @internal */
+export const getAndUpdateSome = dual<
+  <A>(f: (a: A) => Option.Option<A>) => (self: TSubscriptionRef.TSubscriptionRef<A>) => STM.STM<A>,
+  <A>(self: TSubscriptionRef.TSubscriptionRef<A>, f: (a: A) => Option.Option<A>) => STM.STM<A>
+>(2, (self, f) =>
+  self.modify((a) =>
+    Option.match(f(a), {
+      onNone: () => [a, a],
+      onSome: (b) => [a, b]
+    })
+  ))
+
+/** @internal */
+export const setAndGet = dual<
+  <A>(value: A) => (self: TSubscriptionRef.TSubscriptionRef<A>) => STM.STM<A>,
+  <A>(self: TSubscriptionRef.TSubscriptionRef<A>, value: A) => STM.STM<A>
+>(2, (self, value) => self.modify(() => [value, value]))
+
+/** @internal */
+export const modify = dual<
+  <A, B>(f: (a: A) => readonly [B, A]) => (self: TSubscriptionRef.TSubscriptionRef<A>) => STM.STM<B>,
+  <A, B>(self: TSubscriptionRef.TSubscriptionRef<A>, f: (a: A) => readonly [B, A]) => STM.STM<B>
+>(2, (self, f) => self.modify(f))
+
+/** @internal */
+export const modifySome = dual<
+  <A, B>(
+    fallback: B,
+    f: (a: A) => Option.Option<readonly [B, A]>
+  ) => (self: TSubscriptionRef.TSubscriptionRef<A>) => STM.STM<B>,
+  <A, B>(
+    self: TSubscriptionRef.TSubscriptionRef<A>,
+    fallback: B,
+    f: (a: A) => Option.Option<readonly [B, A]>
+  ) => STM.STM<B>
+>(3, (self, fallback, f) =>
+  self.modify((a) =>
+    Option.match(f(a), {
+      onNone: () => [fallback, a],
+      onSome: (b) => b
+    })
+  ))
+
+/** @internal */
+export const update = dual<
+  <A>(f: (a: A) => A) => (self: TSubscriptionRef.TSubscriptionRef<A>) => STM.STM<void>,
+  <A>(self: TSubscriptionRef.TSubscriptionRef<A>, f: (a: A) => A) => STM.STM<void>
+>(2, (self, f) => self.modify((a) => [void 0, f(a)]))
+
+/** @internal */
+export const updateAndGet = dual<
+  <A>(f: (a: A) => A) => (self: TSubscriptionRef.TSubscriptionRef<A>) => STM.STM<A>,
+  <A>(self: TSubscriptionRef.TSubscriptionRef<A>, f: (a: A) => A) => STM.STM<A>
+>(2, (self, f) =>
+  self.modify((a) => {
+    const b = f(a)
+    return [b, b]
+  }))
+
+/** @internal */
+export const updateSome = dual<
+  <A>(f: (a: A) => Option.Option<A>) => (self: TSubscriptionRef.TSubscriptionRef<A>) => STM.STM<void>,
+  <A>(self: TSubscriptionRef.TSubscriptionRef<A>, f: (a: A) => Option.Option<A>) => STM.STM<void>
+>(
+  2,
+  (self, f) =>
+    self.modify((a) => [
+      void 0,
+      Option.match(f(a), {
+        onNone: () => a,
+        onSome: (b) => b
+      })
+    ])
+)
+
+/** @internal */
+export const updateSomeAndGet = dual<
+  <A>(f: (a: A) => Option.Option<A>) => (self: TSubscriptionRef.TSubscriptionRef<A>) => STM.STM<A>,
+  <A>(self: TSubscriptionRef.TSubscriptionRef<A>, f: (a: A) => Option.Option<A>) => STM.STM<A>
+>(
+  2,
+  (self, f) =>
+    self.modify((a) =>
+      Option.match(f(a), {
+        onNone: () => [a, a],
+        onSome: (b) => [b, b]
+      })
+    )
+)
+
+/** @internal */
+export const changesScoped = <A>(self: TSubscriptionRef.TSubscriptionRef<A>) =>
+  Effect.acquireRelease(self.changes, TQueue.shutdown)
+
+/** @internal */
+export const changesStream = <A>(self: TSubscriptionRef.TSubscriptionRef<A>) =>
+  stream.unwrap(Effect.map(self.changes, stream.fromTQueue))

package/src/internal/stream.ts

@@ -18,7 +18,7 @@ import * as MergeDecision from "../MergeDecision.js"
 import * as Option from "../Option.js"
 import type * as Order from "../Order.js"
 import { pipeArguments } from "../Pipeable.js"
-import { hasProperty, isTagged, type Predicate, type Refinement } from "../Predicate.js"
+import { hasProperty, type Predicate, type Refinement } from "../Predicate.js"
 import * as PubSub from "../PubSub.js"
 import * as Queue from "../Queue.js"
 import * as RcRef from "../RcRef.js"
@@ -31,6 +31,8 @@ import type * as Stream from "../Stream.js"
 import type * as Emit from "../StreamEmit.js"
 import * as HaltStrategy from "../StreamHaltStrategy.js"
 import type * as Take from "../Take.js"
+import * as TPubSub from "../TPubSub.js"
+import * as TQueue from "../TQueue.js"
 import type * as Tracer from "../Tracer.js"
 import * as Tuple from "../Tuple.js"
 import type { NoInfer, TupleOf } from "../Types.js"
@@ -3133,6 +3135,14 @@ export const fromPubSub: {
   return options?.shutdown ? ensuring(stream, PubSub.shutdown(pubsub)) : stream
 }
 
+/** @internal */
+export const fromTPubSub = <A>(pubsub: TPubSub.TPubSub<A>): Stream.Stream<A> => {
+  return unwrapScoped(Effect.map(
+    TPubSub.subscribeScoped(pubsub),
+    (queue) => fromTQueue(queue)
+  ))
+}
+
 /** @internal */
 export const fromIterable = <A>(iterable: Iterable<A>): Stream.Stream<A> =>
   suspend(() =>
@@ -3224,6 +3234,24 @@ export const fromQueue = <A>(
     options?.shutdown ? ensuring(Queue.shutdown(queue)) : identity
   )
 
+/** @internal */
+export const fromTQueue = <A>(queue: TQueue.TDequeue<A>): Stream.Stream<A> =>
+  pipe(
+    TQueue.take(queue),
+    Effect.map(Chunk.of),
+    Effect.catchAllCause((cause) =>
+      pipe(
+        TQueue.isShutdown(queue),
+        Effect.flatMap((isShutdown) =>
+          isShutdown && Cause.isInterrupted(cause) ?
+            pull.end() :
+            pull.failCause(cause)
+        )
+      )
+    ),
+    repeatEffectChunkOption
+  )
+
 /** @internal */
 export const fromSchedule = <A, R>(schedule: Schedule.Schedule<A, unknown, R>): Stream.Stream<A, never, R> =>
   pipe(
@@ -3233,14 +3261,38 @@ export const fromSchedule = <A, R>(schedule: Schedule.Schedule<A, unknown, R>):
   )
 
 /** @internal */
-export const fromReadableStream = <A, E>(
-  evaluate: LazyArg<ReadableStream<A>>,
-  onError: (error: unknown) => E
-): Stream.Stream<A, E> =>
-  unwrapScoped(Effect.map(
+export const fromReadableStream: {
+  <A, E>(
+    options: {
+      readonly evaluate: LazyArg<ReadableStream<A>>
+      readonly onError: (error: unknown) => E
+      readonly releaseLockOnEnd?: boolean | undefined
+    }
+  ): Stream.Stream<A, E>
+  <A, E>(
+    evaluate: LazyArg<ReadableStream<A>>,
+    onError: (error: unknown) => E
+  ): Stream.Stream<A, E>
+} = <A, E>(
+  ...args: [options: {
+    readonly evaluate: LazyArg<ReadableStream<A>>
+    readonly onError: (error: unknown) => E
+    readonly releaseLockOnEnd?: boolean | undefined
+  }] | [
+    evaluate: LazyArg<ReadableStream<A>>,
+    onError: (error: unknown) => E
+  ]
+): Stream.Stream<A, E> => {
+  const evaluate = args.length === 1 ? args[0].evaluate : args[0]
+  const onError = args.length === 1 ? args[0].onError : args[1]
+  const releaseLockOnEnd = args.length === 1 ? args[0].releaseLockOnEnd === true : false
+  return unwrapScoped(Effect.map(
     Effect.acquireRelease(
       Effect.sync(() => evaluate().getReader()),
-      (reader) => Effect.promise(() => reader.cancel())
+      (reader) =>
+        releaseLockOnEnd
+          ? Effect.sync(() => reader.releaseLock())
+          : Effect.promise(() => reader.cancel())
     ),
     (reader) =>
       repeatEffectOption(
@@ -3253,34 +3305,59 @@ export const fromReadableStream = <A, E>(
         )
       )
   ))
+}
 
 /** @internal */
-export const fromReadableStreamByob = <E>(
-  evaluate: LazyArg<ReadableStream<Uint8Array>>,
-  onError: (error: unknown) => E,
-  allocSize = 4096
-): Stream.Stream<Uint8Array, E> =>
-  unwrapScoped(Effect.map(
+export const fromReadableStreamByob: {
+  <E>(
+    options: {
+      readonly evaluate: LazyArg<ReadableStream<Uint8Array>>
+      readonly onError: (error: unknown) => E
+      readonly bufferSize?: number | undefined
+      readonly releaseLockOnEnd?: boolean | undefined
+    }
+  ): Stream.Stream<Uint8Array, E>
+  <E>(
+    evaluate: LazyArg<ReadableStream<Uint8Array>>,
+    onError: (error: unknown) => E,
+    allocSize?: number
+  ): Stream.Stream<Uint8Array, E>
+} = <E>(
+  ...args: [options: {
+    readonly evaluate: LazyArg<ReadableStream<Uint8Array>>
+    readonly onError: (error: unknown) => E
+    readonly bufferSize?: number | undefined
+    readonly releaseLockOnEnd?: boolean | undefined
+  }] | [
+    evaluate: LazyArg<ReadableStream<Uint8Array>>,
+    onError: (error: unknown) => E,
+    allocSize?: number | undefined
+  ]
+): Stream.Stream<Uint8Array, E> => {
+  const evaluate = args.length === 1 ? args[0].evaluate : args[0]
+  const onError = args.length === 1 ? args[0].onError : args[1]
+  const allocSize = (args.length === 1 ? args[0].bufferSize : args[2]) ?? 4096
+  const releaseLockOnEnd = args.length === 1 ? args[0].releaseLockOnEnd === true : false
+  return unwrapScoped(Effect.map(
     Effect.acquireRelease(
       Effect.sync(() => evaluate().getReader({ mode: "byob" })),
-      (reader) => Effect.promise(() => reader.cancel())
+      (reader) => releaseLockOnEnd ? Effect.sync(() => reader.releaseLock()) : Effect.promise(() => reader.cancel())
     ),
     (reader) =>
       catchAll(
         forever(readChunkStreamByobReader(reader, onError, allocSize)),
-        (error) => isTagged(error, "EOF") ? empty : fail(error as E)
+        (error) => error === EOF ? empty : fail(error)
       )
   ))
-
-interface EOF {
-  readonly _tag: "EOF"
 }
 
+const EOF = Symbol.for("effect/Stream/EOF")
+
 const readChunkStreamByobReader = <E>(
   reader: ReadableStreamBYOBReader,
   onError: (error: unknown) => E,
   size: number
-): Stream.Stream<Uint8Array, E | EOF> => {
+): Stream.Stream<Uint8Array, E | typeof EOF> => {
   const buffer = new ArrayBuffer(size)
   return paginateEffect(0, (offset) =>
     Effect.flatMap(
@@ -3290,7 +3367,7 @@ const readChunkStreamByobReader = <E>(
       }),
       ({ done, value }) => {
         if (done) {
-          return Effect.fail({ _tag: "EOF" })
+          return Effect.fail(EOF)
         }
         const newOffset = offset + value.byteLength
         return Effect.succeed([

package/src/internal/version.ts

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