effect 3.15.0 → 3.15.2

package/src/HashMap.ts

@@ -159,7 +159,7 @@ export const get: {
    * @since 2.0.0
    * @category elements
    */
-  <K1>(key: K1): <K, V>(self: HashMap<K, V>) => Option<V>
+  <K1 extends K, K>(key: K1): <V>(self: HashMap<K, V>) => Option<V>
   /**
    * Safely lookup the value for the specified key in the `HashMap` using the
    * internal hashing function.
@@ -167,7 +167,7 @@ export const get: {
    * @since 2.0.0
    * @category elements
    */
-  <K, V, K1>(self: HashMap<K, V>, key: K1): Option<V>
+  <K1 extends K, K, V>(self: HashMap<K, V>, key: K1): Option<V>
 } = HM.get
 
 /**
@@ -183,14 +183,14 @@ export const getHash: {
    * @since 2.0.0
    * @category elements
    */
-  <K1>(key: K1, hash: number): <K, V>(self: HashMap<K, V>) => Option<V>
+  <K1 extends K, K>(key: K1, hash: number): <V>(self: HashMap<K, V>) => Option<V>
   /**
    * Lookup the value for the specified key in the `HashMap` using a custom hash.
    *
    * @since 2.0.0
    * @category elements
    */
-  <K, V, K1>(self: HashMap<K, V>, key: K1, hash: number): Option<V>
+  <K1 extends K, K, V>(self: HashMap<K, V>, key: K1, hash: number): Option<V>
 } = HM.getHash
 
 /**
@@ -208,7 +208,7 @@ export const unsafeGet: {
    * @since 2.0.0
    * @category unsafe
    */
-  <K1>(key: K1): <K, V>(self: HashMap<K, V>) => V
+  <K1 extends K, K>(key: K1): <V>(self: HashMap<K, V>) => V
   /**
    * Unsafely lookup the value for the specified key in the `HashMap` using the
    * internal hashing function.
@@ -216,7 +216,7 @@ export const unsafeGet: {
    * @since 2.0.0
    * @category unsafe
    */
-  <K, V, K1>(self: HashMap<K, V>, key: K1): V
+  <K1 extends K, K, V>(self: HashMap<K, V>, key: K1): V
 } = HM.unsafeGet
 
 /**
@@ -232,14 +232,14 @@ export const has: {
    * @since 2.0.0
    * @category elements
    */
-  <K1>(key: K1): <K, V>(self: HashMap<K, V>) => boolean
+  <K1 extends K, K>(key: K1): <K, V>(self: HashMap<K, V>) => boolean
   /**
    * Checks if the specified key has an entry in the `HashMap`.
    *
    * @since 2.0.0
    * @category elements
    */
-  <K, V, K1>(self: HashMap<K, V>, key: K1): boolean
+  <K1 extends K, K, V>(self: HashMap<K, V>, key: K1): boolean
 } = HM.has
 
 /**
@@ -257,7 +257,7 @@ export const hasHash: {
    * @since 2.0.0
    * @category elements
    */
-  <K1>(key: K1, hash: number): <K, V>(self: HashMap<K, V>) => boolean
+  <K1 extends K, K>(key: K1, hash: number): <V>(self: HashMap<K, V>) => boolean
   /**
    * Checks if the specified key has an entry in the `HashMap` using a custom
    * hash.
@@ -265,7 +265,7 @@ export const hasHash: {
    * @since 2.0.0
    * @category elements
    */
-  <K, V, K1>(self: HashMap<K, V>, key: K1, hash: number): boolean
+  <K1 extends K, K, V>(self: HashMap<K, V>, key: K1, hash: number): boolean
 } = HM.hasHash
 
 /**

package/src/Inspectable.ts

@@ -40,7 +40,7 @@ export const toJSON = (x: unknown): unknown => {
     } else if (Array.isArray(x)) {
       return x.map(toJSON)
     }
-  } catch (_) {
+  } catch {
     return {}
   }
   return redact(x)
@@ -97,7 +97,7 @@ export const toStringUnknown = (u: unknown, whitespace: number | string | undefi
   }
   try {
     return typeof u === "object" ? stringifyCircular(u, whitespace) : String(u)
-  } catch (_) {
+  } catch {
     return String(u)
   }
 }

package/src/Option.ts

@@ -1140,7 +1140,7 @@ export const liftThrowable = <A extends ReadonlyArray<unknown>, B>(
 (...a) => {
   try {
     return some(f(...a))
-  } catch (e) {
+  } catch {
     return none()
   }
 }

package/src/TestAnnotationMap.ts

@@ -83,8 +83,8 @@ export const update = dual<
   ) => TestAnnotationMap
 >(3, <A>(self: TestAnnotationMap, key: TestAnnotation.TestAnnotation<A>, f: (value: A) => A) => {
   let value = key.initial
-  if (HashMap.has(self.map, key.identifier)) {
-    value = HashMap.unsafeGet(self.map, key.identifier) as A
+  if (HashMap.has(self.map, key)) {
+    value = HashMap.unsafeGet(self.map, key) as A
   }
   return overwrite(self, key, f(value))
 })
@@ -111,8 +111,8 @@ export const get = dual<
    */
   <A>(self: TestAnnotationMap, key: TestAnnotation.TestAnnotation<A>) => A
 >(2, <A>(self: TestAnnotationMap, key: TestAnnotation.TestAnnotation<A>) => {
-  if (HashMap.has(self.map, key.identifier)) {
-    return HashMap.unsafeGet(self.map, key.identifier) as A
+  if (HashMap.has(self.map, key)) {
+    return HashMap.unsafeGet(self.map, key) as A
   }
   return key.initial
 })

package/src/internal/channel/channelExecutor.ts

@@ -339,11 +339,6 @@ export class ChannelExecutor<
                 this._currentChannel = this._currentChannel.channel() as core.Primitive
                 break
               }
-
-              default: {
-                // @ts-expect-error
-                this._currentChannel._tag
-              }
             }
           }
         } catch (error) {

package/src/internal/core-effect.ts

@@ -520,15 +520,24 @@ export const filterMap = dual<
 
 /* @internal */
 export const filterOrDie: {
-  <A, B extends A = A>(
-    predicate: Predicate.Predicate<Types.NoInfer<A>> | Predicate.Refinement<Types.NoInfer<A>, B>,
+  <A, B extends A>(
+    refinement: Predicate.Refinement<Types.NoInfer<A>, B>,
     orDieWith: (a: Types.EqualsWith<A, B, A, Exclude<A, B>>) => unknown
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, E, R>
+  <A>(
+    predicate: Predicate.Predicate<Types.NoInfer<A>>,
+    orDieWith: (a: Types.NoInfer<A>) => unknown
+  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   <A, E, R, B extends A>(
     self: Effect.Effect<A, E, R>,
-    predicate: Predicate.Predicate<A> | Predicate.Refinement<A, B>,
+    refinement: Predicate.Refinement<A, B>,
     orDieWith: (a: Types.EqualsWith<A, B, A, Exclude<A, B>>) => unknown
   ): Effect.Effect<B, E, R>
+  <A, E, R>(
+    self: Effect.Effect<A, E, R>,
+    predicate: Predicate.Predicate<A>,
+    orDieWith: (a: A) => unknown
+  ): Effect.Effect<A, E, R>
 } = dual(
   3,
   <A, E, R>(
@@ -540,15 +549,24 @@ export const filterOrDie: {
 
 /* @internal */
 export const filterOrDieMessage: {
-  <A, B extends A = A>(
-    predicate: Predicate.Predicate<Types.NoInfer<A>> | Predicate.Refinement<Types.NoInfer<A>, B>,
+  <A, B extends A>(
+    refinement: Predicate.Refinement<Types.NoInfer<A>, B>,
     message: string
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, E, R>
-  <A, E, R, B extends A = A>(
+  <A>(
+    predicate: Predicate.Predicate<Types.NoInfer<A>>,
+    message: string
+  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <A, E, R, B extends A>(
     self: Effect.Effect<A, E, R>,
-    predicate: Predicate.Predicate<A> | Predicate.Refinement<A, B>,
+    refinement: Predicate.Refinement<A, B>,
     message: string
   ): Effect.Effect<B, E, R>
+  <A, E, R>(
+    self: Effect.Effect<A, E, R>,
+    predicate: Predicate.Predicate<A>,
+    message: string
+  ): Effect.Effect<A, E, R>
 } = dual(
   3,
   <A, E, R>(self: Effect.Effect<A, E, R>, predicate: Predicate.Predicate<A>, message: string): Effect.Effect<A, E, R> =>
@@ -557,15 +575,24 @@ export const filterOrDieMessage: {
 
 /* @internal */
 export const filterOrElse: {
-  <A, C, E2, R2, B extends A = A>(
-    predicate: Predicate.Predicate<Types.NoInfer<A>> | Predicate.Refinement<Types.NoInfer<A>, B>,
+  <A, C, E2, R2, B extends A>(
+    refinement: Predicate.Refinement<Types.NoInfer<A>, B>,
     orElse: (a: Types.EqualsWith<A, B, Types.NoInfer<A>, Exclude<Types.NoInfer<A>, B>>) => Effect.Effect<C, E2, R2>
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B | C, E2 | E, R2 | R>
-  <A, E, R, C, E2, R2, B extends A = A>(
+  <A, C, E2, R2>(
+    predicate: Predicate.Predicate<Types.NoInfer<A>>,
+    orElse: (a: Types.NoInfer<A>) => Effect.Effect<C, E2, R2>
+  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | C, E2 | E, R2 | R>
+  <A, E, R, C, E2, R2, B extends A>(
     self: Effect.Effect<A, E, R>,
-    predicate: Predicate.Predicate<A> | Predicate.Refinement<A, B>,
+    refinement: Predicate.Refinement<A, B>,
     orElse: (a: Types.EqualsWith<A, B, A, Exclude<A, B>>) => Effect.Effect<C, E2, R2>
   ): Effect.Effect<B | C, E | E2, R | R2>
+  <A, E, R, C, E2, R2>(
+    self: Effect.Effect<A, E, R>,
+    predicate: Predicate.Predicate<A>,
+    orElse: (a: A) => Effect.Effect<C, E2, R2>
+  ): Effect.Effect<A | C, E | E2, R | R2>
 } = dual(3, <A, E, R, B, E2, R2>(
   self: Effect.Effect<A, E, R>,
   predicate: Predicate.Predicate<A>,
@@ -599,22 +626,38 @@ export const liftPredicate = dual<
 
 /* @internal */
 export const filterOrFail: {
-  <A, E2, B extends A = A>(
-    predicate: Predicate.Predicate<Types.NoInfer<A>> | Predicate.Refinement<Types.NoInfer<A>, B>,
+  <A, E2, B extends A>(
+    refinement: Predicate.Refinement<Types.NoInfer<A>, B>,
     orFailWith: (a: Types.EqualsWith<A, B, Types.NoInfer<A>, Exclude<Types.NoInfer<A>, B>>) => E2
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, E2 | E, R>
-  <A, E, R, E2, B extends A = A>(
+  <A, E2>(
+    predicate: Predicate.Predicate<Types.NoInfer<A>>,
+    orFailWith: (a: Types.NoInfer<A>) => E2
+  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E2 | E, R>
+  <A, E, R, E2, B extends A>(
     self: Effect.Effect<A, E, R>,
-    predicate: Predicate.Predicate<A> | Predicate.Refinement<A, B>,
+    refinement: Predicate.Refinement<A, B>,
     orFailWith: (a: Types.EqualsWith<A, B, A, Exclude<A, B>>) => E2
   ): Effect.Effect<B, E2 | E, R>
-  <A, B extends A = A>(
-    predicate: Predicate.Predicate<Types.NoInfer<A>> | Predicate.Refinement<Types.NoInfer<A>, B>
+  <A, E, R, E2>(
+    self: Effect.Effect<A, E, R>,
+    predicate: Predicate.Predicate<A>,
+    orFailWith: (a: A) => E2
+  ): Effect.Effect<A, E2 | E, R>
+  <A, B extends A>(
+    refinement: Predicate.Refinement<Types.NoInfer<A>, B>
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, Cause.NoSuchElementException | E, R>
-  <A, E, R, B extends A = A>(
+  <A>(
+    predicate: Predicate.Predicate<Types.NoInfer<A>>
+  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, Cause.NoSuchElementException | E, R>
+  <A, E, R, B extends A>(
     self: Effect.Effect<A, E, R>,
-    predicate: Predicate.Predicate<A> | Predicate.Refinement<A, B>
+    refinement: Predicate.Refinement<A, B>
   ): Effect.Effect<B, E | Cause.NoSuchElementException, R>
+  <A, E, R>(
+    self: Effect.Effect<A, E, R>,
+    predicate: Predicate.Predicate<A>
+  ): Effect.Effect<A, E | Cause.NoSuchElementException, R>
 } = dual((args) => core.isEffect(args[0]), <A, E, R, E2>(
   self: Effect.Effect<A, E, R>,
   predicate: Predicate.Predicate<A>,

package/src/internal/dateTime.ts

@@ -377,7 +377,7 @@ export const zoneUnsafeMakeNamed = (zoneId: string): DateTime.TimeZone.Named =>
         timeZone: zoneId
       })
     )
-  } catch (_) {
+  } catch {
     throw new IllegalArgumentException(`Invalid time zone: ${zoneId}`)
   }
 }
@@ -1076,7 +1076,7 @@ export const format: {
       timeZone: self._tag === "Utc" ? "UTC" : intlTimeZone(self.zone),
       ...options
     }).format(self.epochMillis)
-  } catch (_) {
+  } catch {
     return new Intl.DateTimeFormat(options?.locale, {
       timeZone: "UTC",
       ...options

package/src/internal/hashMap.ts

@@ -210,15 +210,15 @@ export const isEmpty = <K, V>(self: HM.HashMap<K, V>): boolean =>
 
 /** @internal */
 export const get = Dual.dual<
-  <K1>(key: K1) => <K, V>(self: HM.HashMap<K, V>) => Option.Option<V>,
-  <K, V, K1>(self: HM.HashMap<K, V>, key: K1) => Option.Option<V>
+  <K1 extends K, K>(key: K1) => <V>(self: HM.HashMap<K, V>) => Option.Option<V>,
+  <K, V, K1 extends K>(self: HM.HashMap<K, V>, key: K1) => Option.Option<V>
 >(2, (self, key) => getHash(self, key, Hash.hash(key)))
 
 /** @internal */
 export const getHash = Dual.dual<
-  <K1>(key: K1, hash: number) => <K, V>(self: HM.HashMap<K, V>) => Option.Option<V>,
-  <K, V, K1>(self: HM.HashMap<K, V>, key: K1, hash: number) => Option.Option<V>
->(3, <K, V, K1>(self: HM.HashMap<K, V>, key: K1, hash: number) => {
+  <K1 extends K, K>(key: K1, hash: number) => <V>(self: HM.HashMap<K, V>) => Option.Option<V>,
+  <K, V, K1 extends K>(self: HM.HashMap<K, V>, key: K1, hash: number) => Option.Option<V>
+>(3, <K, V, K1 extends K>(self: HM.HashMap<K, V>, key: K1, hash: number) => {
   let node = (self as HashMapImpl<K, V>)._root
   let shift = 0
 
@@ -265,8 +265,8 @@ export const getHash = Dual.dual<
 
 /** @internal */
 export const unsafeGet = Dual.dual<
-  <K1>(key: K1) => <K, V>(self: HM.HashMap<K, V>) => V,
-  <K, V, K1>(self: HM.HashMap<K, V>, key: K1) => V
+  <K1 extends K, K>(key: K1) => <V>(self: HM.HashMap<K, V>) => V,
+  <K, V, K1 extends K>(self: HM.HashMap<K, V>, key: K1) => V
 >(2, (self, key) => {
   const element = getHash(self, key, Hash.hash(key))
   if (Option.isNone(element)) {
@@ -277,14 +277,14 @@ export const unsafeGet = Dual.dual<
 
 /** @internal */
 export const has = Dual.dual<
-  <K1>(key: K1) => <K, V>(self: HM.HashMap<K, V>) => boolean,
-  <K, V, K1>(self: HM.HashMap<K, V>, key: K1) => boolean
+  <K1 extends K, K>(key: K1) => <V>(self: HM.HashMap<K, V>) => boolean,
+  <K, V, K1 extends K>(self: HM.HashMap<K, V>, key: K1) => boolean
 >(2, (self, key) => Option.isSome(getHash(self, key, Hash.hash(key))))
 
 /** @internal */
 export const hasHash = Dual.dual<
-  <K1>(key: K1, hash: number) => <K, V>(self: HM.HashMap<K, V>) => boolean,
-  <K, V, K1>(self: HM.HashMap<K, V>, key: K1, hash: number) => boolean
+  <K1 extends K, K>(key: K1, hash: number) => <V>(self: HM.HashMap<K, V>) => boolean,
+  <K, V, K1 extends K>(self: HM.HashMap<K, V>, key: K1, hash: number) => boolean
 >(3, (self, key, hash) => Option.isSome(getHash(self, key, hash)))
 
 /** @internal */

package/src/internal/schema/util.ts

@@ -47,7 +47,7 @@ export const memoizeThunk = <A>(f: () => A): () => A => {
 export const formatDate = (date: Date): string => {
   try {
     return date.toISOString()
-  } catch (e) {
+  } catch {
     return String(date)
   }
 }
@@ -96,7 +96,7 @@ export const formatUnknown = (u: unknown, checkCircular: boolean = true): string
     }}`
     const name = u.constructor.name
     return u.constructor !== Object.prototype.constructor ? `${name}(${pojo})` : pojo
-  } catch (e) {
+  } catch {
     return "<circular structure>"
   }
 }

package/src/internal/version.ts

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