effect 3.4.7 → 3.4.9

package/src/String.ts

@@ -146,11 +146,7 @@ export const trim = <A extends string>(self: A): Trim<A> => self.trim() as Trim<
 /**
  * @since 2.0.0
  */
-export type TrimStart<A extends string> = A extends ` ${infer B}` ? TrimStart<B>
-  : A extends `\n${infer B}` ? TrimStart<B>
-  : A extends `\t${infer B}` ? TrimStart<B>
-  : A extends `\r${infer B}` ? TrimStart<B>
-  : A
+export type TrimStart<A extends string> = A extends `${" " | "\n" | "\t" | "\r"}${infer B}` ? TrimStart<B> : A
 
 /**
  * @example
@@ -165,11 +161,7 @@ export const trimStart = <A extends string>(self: A): TrimStart<A> => self.trimS
 /**
  * @since 2.0.0
  */
-export type TrimEnd<A extends string> = A extends `${infer B} ` ? TrimEnd<B>
-  : A extends `${infer B}\n` ? TrimEnd<B>
-  : A extends `${infer B}\t` ? TrimEnd<B>
-  : A extends `${infer B}\r` ? TrimEnd<B>
-  : A
+export type TrimEnd<A extends string> = A extends `${infer B}${" " | "\n" | "\t" | "\r"}` ? TrimEnd<B> : A
 
 /**
  * @example

package/src/internal/channel/channelExecutor.ts

@@ -1141,7 +1141,12 @@ export const runScoped = <Env, InErr, InDone, OutErr, OutDone>(
             Effect.forkScoped(restore(run(channelDeferred, scopeDeferred, child))),
             Effect.flatMap((fiber) =>
               pipe(
-                Effect.addFinalizer(() => Deferred.succeed(scopeDeferred, void 0)),
+                Scope.addFinalizer(
+                  parent,
+                  Deferred.succeed(scopeDeferred, void 0).pipe(
+                    Effect.zipRight(Effect.yieldNow())
+                  )
+                ),
                 Effect.zipRight(restore(Deferred.await(channelDeferred))),
                 Effect.zipLeft(Fiber.inheritAll(fiber))
               )

package/src/internal/channel.ts

@@ -1607,11 +1607,12 @@ export const mergeWith = dual<
       (input) => {
         const queueReader = fromInput(input)
         return Effect.map(
-          Effect.zip(
+          Effect.all([
             toPull(core.pipeTo(queueReader, self)),
-            toPull(core.pipeTo(queueReader, options.other))
-          ),
-          ([pullL, pullR]) => {
+            toPull(core.pipeTo(queueReader, options.other)),
+            Effect.scope
+          ]),
+          ([pullL, pullR, scope]) => {
             type State = MergeState.MergeState<
               Env | Env1,
               OutErr,
@@ -1806,8 +1807,8 @@ export const mergeWith = dual<
             return pipe(
               core.fromEffect(
                 Effect.zipWith(
-                  Effect.forkDaemon(pullL),
-                  Effect.forkDaemon(pullR),
+                  Effect.forkIn(pullL, scope),
+                  Effect.forkIn(pullR, scope),
                   (left, right): State =>
                     mergeState.BothRunning<
                       Env | Env1,

package/src/internal/pool.ts

@@ -5,6 +5,7 @@ import type { Effect, Semaphore } from "../Effect.js"
 import type { Exit } from "../Exit.js"
 import { dual, identity } from "../Function.js"
 import * as Iterable from "../Iterable.js"
+import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import type { Pool, PoolTypeId as PoolTypeId_ } from "../Pool.js"
 import { hasProperty } from "../Predicate.js"
@@ -112,11 +113,13 @@ interface PoolItem<A, E> {
   readonly exit: Exit<A, E>
   finalizer: Effect<void>
   refCount: number
+  disableReclaim: boolean
 }
 
 interface Strategy<A, E> {
   readonly run: (pool: PoolImpl<A, E>) => Effect<void>
   readonly onAcquire: (item: PoolItem<A, E>) => Effect<void>
+  readonly reclaim: (pool: PoolImpl<A, E>) => Effect<Option.Option<PoolItem<A, E>>>
 }
 
 class PoolImpl<A, E> implements Pool<A, E> {
@@ -151,7 +154,8 @@ class PoolImpl<A, E> implements Pool<A, E> {
           const item: PoolItem<A, E> = {
             exit,
             finalizer: core.catchAllCause(scope.close(exit), reportUnhandledError),
-            refCount: 0
+            refCount: 0,
+            disableReclaim: false
           }
           this.items.add(item)
           this.available.add(item)
@@ -189,7 +193,13 @@ class PoolImpl<A, E> implements Pool<A, E> {
     if (this.activeSize >= this.targetSize) {
       return core.void
     }
-    return core.zipRight(this.allocate, this.resizeLoop)
+    return this.strategy.reclaim(this).pipe(
+      core.flatMap(Option.match({
+        onNone: () => this.allocate,
+        onSome: core.succeed
+      })),
+      core.zipRight(this.resizeLoop)
+    )
   })
   readonly resizeSemaphore = circular.unsafeMakeSemaphore(1)
   readonly resize = this.resizeSemaphore.withPermits(1)(this.resizeLoop)
@@ -253,6 +263,7 @@ class PoolImpl<A, E> implements Pool<A, E> {
       if (this.isShuttingDown) return core.void
       for (const poolItem of this.items) {
         if (poolItem.exit._tag === "Success" && poolItem.exit.value === item) {
+          poolItem.disableReclaim = true
           return core.uninterruptible(this.invalidatePoolItem(poolItem))
         }
       }
@@ -306,7 +317,8 @@ class PoolImpl<A, E> implements Pool<A, E> {
 
 const strategyNoop = <A, E>(): Strategy<A, E> => ({
   run: (_) => core.void,
-  onAcquire: (_) => core.void
+  onAcquire: (_) => core.void,
+  reclaim: (_) => coreEffect.succeedNone
 })
 
 const strategyCreationTTL = <A, E>(ttl: Duration.DurationInput) =>
@@ -337,7 +349,8 @@ const strategyCreationTTL = <A, E>(ttl: Duration.DurationInput) =>
           core.suspend(() => {
             creationTimes.set(item, clock.unsafeCurrentTimeMillis())
             return queue.offer(item)
-          })
+          }),
+        reclaim: (_) => coreEffect.succeedNone
       })
     })
   )
@@ -359,7 +372,25 @@ const strategyUsageTTL = <A, E>(ttl: Duration.DurationInput) =>
           coreEffect.forever
         )
       },
-      onAcquire: (item) => queue.offer(item)
+      onAcquire: (item) => queue.offer(item),
+      reclaim(pool) {
+        return core.suspend((): Effect<Option.Option<PoolItem<A, E>>> => {
+          if (pool.invalidated.size === 0) {
+            return coreEffect.succeedNone
+          }
+          const item = Iterable.head(
+            Iterable.filter(pool.invalidated, (item) => !item.disableReclaim)
+          )
+          if (item._tag === "None") {
+            return coreEffect.succeedNone
+          }
+          pool.invalidated.delete(item.value)
+          if (item.value.refCount < pool.concurrency) {
+            pool.available.add(item.value)
+          }
+          return core.as(queue.offer(item.value), item)
+        })
+      }
     })
   })
 

package/src/internal/version.ts

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