effect 3.6.2 → 3.6.4

package/dist/esm/internal/version.js

@@ -1,4 +1,4 @@
-let moduleVersion = "3.6.2";
+let moduleVersion = "3.6.4";
 export const getCurrentVersion = () => moduleVersion;
 export const setCurrentVersion = version => {
   moduleVersion = version;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect",
-  "version": "3.6.2",
+  "version": "3.6.4",
   "description": "The missing standard library for TypeScript, for writing production-grade software.",
   "license": "MIT",
   "repository": {

package/src/Cache.ts

@@ -22,6 +22,18 @@ export const CacheTypeId: unique symbol = internal.CacheTypeId
  */
 export type CacheTypeId = typeof CacheTypeId
 
+/**
+ * @since 3.6.4
+ * @category symbols
+ */
+export const ConsumerCacheTypeId: unique symbol = internal.ConsumerCacheTypeId
+
+/**
+ * @since 3.6.4
+ * @category symbols
+ */
+export type ConsumerCacheTypeId = typeof ConsumerCacheTypeId
+
 /**
  * A `Cache` is defined in terms of a lookup function that, given a key of
  * type `Key`, can either fail with an error of type `Error` or succeed with a
@@ -43,7 +55,9 @@ export type CacheTypeId = typeof CacheTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Cache<in out Key, out Value, out Error = never> extends ConsumerCache<Key, Value, Error> {
+export interface Cache<in out Key, in out Value, out Error = never>
+  extends ConsumerCache<Key, Value, Error>, Cache.Variance<Key, Value, Error>
+{
   /**
    * Retrieves the value associated with the specified key if it exists.
    * Otherwise computes the value with the lookup function, puts it in the
@@ -83,7 +97,9 @@ export interface Cache<in out Key, out Value, out Error = never> extends Consume
  * @since 2.0.0
  * @category models
  */
-export interface ConsumerCache<in out Key, out Value, out Error = never> extends Cache.Variance<Key, Value, Error> {
+export interface ConsumerCache<in out Key, out Value, out Error = never>
+  extends Cache.ConsumerVariance<Key, Value, Error>
+{
   /**
    * Retrieves the value associated with the specified key if it exists.
    * Otherwise returns `Option.none`.
@@ -156,8 +172,19 @@ export declare namespace Cache {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<in out Key, out Value, out Error> {
+  export interface Variance<in out Key, in out Value, out Error> {
     readonly [CacheTypeId]: {
+      readonly _Key: Types.Invariant<Key>
+      readonly _Error: Types.Covariant<Error>
+      readonly _Value: Types.Invariant<Value>
+    }
+  }
+  /**
+   * @since 3.6.4
+   * @category models
+   */
+  export interface ConsumerVariance<in out Key, out Value, out Error> {
+    readonly [ConsumerCacheTypeId]: {
       readonly _Key: Types.Invariant<Key>
       readonly _Error: Types.Covariant<Error>
       readonly _Value: Types.Covariant<Value>

package/src/DateTime.ts

@@ -562,7 +562,7 @@ export const makeZonedFromString = (input: string): Option.Option<Zoned> => {
   const match = zonedStringRegex.exec(input)
   if (match === null) {
     const offset = parseOffset(input)
-    return offset ? makeZoned(input, { timeZone: offset }) : Option.none()
+    return offset !== null ? makeZoned(input, { timeZone: offset }) : Option.none()
   }
   const [, isoString, timeZone] = match
   return makeZoned(isoString, { timeZone })
@@ -1979,7 +1979,7 @@ export const format: {
 /**
  * Format a `DateTime` as a string using the `DateTimeFormat` API.
  *
- * It will use the system's local time zone.
+ * It will use the system's local time zone & locale.
  *
  * @since 3.6.0
  * @category formatting

package/src/Scheduler.ts

@@ -37,27 +37,22 @@ export class PriorityBuckets<in out T = Task> {
    * @since 2.0.0
    */
   scheduleTask(task: T, priority: number) {
+    const length = this.buckets.length
     let bucket: [number, Array<T>] | undefined = undefined
-    let index: number
-    for (index = 0; index < this.buckets.length; index++) {
+    let index = 0
+    for (; index < length; index++) {
       if (this.buckets[index][0] <= priority) {
         bucket = this.buckets[index]
       } else {
         break
       }
     }
-    if (bucket) {
+    if (bucket && bucket[0] === priority) {
       bucket[1].push(task)
+    } else if (index === length) {
+      this.buckets.push([priority, [task]])
     } else {
-      const newBuckets: Array<[number, Array<T>]> = []
-      for (let i = 0; i < index; i++) {
-        newBuckets.push(this.buckets[i])
-      }
-      newBuckets.push([priority, [task]])
-      for (let i = index; i < this.buckets.length; i++) {
-        newBuckets.push(this.buckets[i])
-      }
-      this.buckets = newBuckets
+      this.buckets.splice(index, 0, [priority, [task]])
     }
   }
 }

package/src/internal/cache.ts

@@ -270,6 +270,23 @@ export const CacheTypeId: Cache.CacheTypeId = Symbol.for(
 ) as Cache.CacheTypeId
 
 const cacheVariance = {
+  /* c8 ignore next */
+  _Key: (_: any) => _,
+  /* c8 ignore next */
+  _Error: (_: never) => _,
+  /* c8 ignore next */
+  _Value: (_: any) => _
+}
+
+/** @internal */
+const ConsumerCacheSymbolKey = "effect/ConsumerCache"
+
+/** @internal */
+export const ConsumerCacheTypeId: Cache.ConsumerCacheTypeId = Symbol.for(
+  ConsumerCacheSymbolKey
+) as Cache.ConsumerCacheTypeId
+
+const consumerCacheVariance = {
   /* c8 ignore next */
   _Key: (_: any) => _,
   /* c8 ignore next */
@@ -294,6 +311,7 @@ export const makeEntryStats = (loadedMillis: number): Cache.EntryStats => ({
 
 class CacheImpl<in out Key, in out Value, in out Error> implements Cache.Cache<Key, Value, Error> {
   readonly [CacheTypeId] = cacheVariance
+  readonly [ConsumerCacheTypeId] = consumerCacheVariance
   readonly cacheState: CacheState<Key, Value, Error>
   constructor(
     readonly capacity: number,

package/src/internal/core-effect.ts

@@ -1200,12 +1200,20 @@ export const patchFiberRefs = (patch: FiberRefsPatch.FiberRefsPatch): Effect.Eff
 export const promise = <A>(evaluate: (signal: AbortSignal) => PromiseLike<A>): Effect.Effect<A> =>
   evaluate.length >= 1
     ? core.async((resolve, signal) => {
-      evaluate(signal)
-        .then((a) => resolve(core.exitSucceed(a)), (e) => resolve(core.exitDie(e)))
+      try {
+        evaluate(signal)
+          .then((a) => resolve(core.exitSucceed(a)), (e) => resolve(core.exitDie(e)))
+      } catch (e) {
+        resolve(core.exitDie(e))
+      }
     })
     : core.async((resolve) => {
-      ;(evaluate as LazyArg<PromiseLike<A>>)()
-        .then((a) => resolve(core.exitSucceed(a)), (e) => resolve(core.exitDie(e)))
+      try {
+        ;(evaluate as LazyArg<PromiseLike<A>>)()
+          .then((a) => resolve(core.exitSucceed(a)), (e) => resolve(core.exitDie(e)))
+      } catch (e) {
+        resolve(core.exitDie(e))
+      }
     })
 
 /* @internal */
@@ -1668,14 +1676,12 @@ export const tryPromise: {
     return core.async((resolve, signal) => {
       try {
         evaluate(signal)
-          .then((a) => resolve(core.exitSucceed(a)), (e) =>
-            resolve(core.fail(
-              catcher ? catcher(e) : new core.UnknownException(e)
-            )))
+          .then(
+            (a) => resolve(core.exitSucceed(a)),
+            (e) => resolve(catcher ? core.failSync(() => catcher(e)) : core.fail(new core.UnknownException(e)))
+          )
       } catch (e) {
-        resolve(core.fail(
-          catcher ? catcher(e) : new core.UnknownException(e)
-        ))
+        resolve(catcher ? core.failSync(() => catcher(e)) : core.fail(new core.UnknownException(e)))
       }
     })
   }
@@ -1683,14 +1689,12 @@ export const tryPromise: {
   return core.async((resolve) => {
     try {
       evaluate()
-        .then((a) => resolve(core.exitSucceed(a)), (e) =>
-          resolve(core.fail(
-            catcher ? catcher(e) : new core.UnknownException(e)
-          )))
+        .then(
+          (a) => resolve(core.exitSucceed(a)),
+          (e) => resolve(catcher ? core.failSync(() => catcher(e)) : core.fail(new core.UnknownException(e)))
+        )
     } catch (e) {
-      resolve(core.fail(
-        catcher ? catcher(e) : new core.UnknownException(e)
-      ))
+      resolve(catcher ? core.failSync(() => catcher(e)) : core.fail(new core.UnknownException(e)))
     }
   })
 }

package/src/internal/stream.ts

@@ -6895,10 +6895,14 @@ export const toReadableStreamRuntime = dual<
     return new ReadableStream<A>({
       start(controller) {
         scope = runSync(Scope.make())
-        pull = pipe(
+        const pullChunk: Effect.Effect<Chunk.Chunk<A>, Option.Option<E>, R> = pipe(
           toPull(self),
           Scope.extend(scope),
           runSync,
+          Effect.flatMap((chunk) => Chunk.isEmpty(chunk) ? pullChunk : Effect.succeed(chunk))
+        )
+        pull = pipe(
+          pullChunk,
           Effect.tap((chunk) =>
             Effect.sync(() => {
               Chunk.map(chunk, (a) => {

package/src/internal/version.ts

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