effect 2.2.5 → 2.3.0

package/src/internal/scopedCache.ts

@@ -83,7 +83,7 @@ export type MapValue<Key, Error, Value> =
 export interface Complete<out Key, out Error, out Value> {
   readonly _tag: "Complete"
   readonly key: _cache.MapKey<Key>
-  readonly exit: Exit.Exit<Error, readonly [Value, Scope.Scope.Finalizer]>
+  readonly exit: Exit.Exit<readonly [Value, Scope.Scope.Finalizer], Error>
   readonly ownerCount: MutableRef.MutableRef<number>
   readonly entryStats: Cache.EntryStats
   readonly timeToLive: number
@@ -93,20 +93,20 @@ export interface Complete<out Key, out Error, out Value> {
 export interface Pending<out Key, out Error, out Value> {
   readonly _tag: "Pending"
   readonly key: _cache.MapKey<Key>
-  readonly scoped: Effect.Effect<never, never, Effect.Effect<Scope.Scope, Error, Value>>
+  readonly scoped: Effect.Effect<Effect.Effect<Value, Error, Scope.Scope>>
 }
 
 /** @internal */
 export interface Refreshing<out Key, out Error, out Value> {
   readonly _tag: "Refreshing"
-  readonly scoped: Effect.Effect<never, never, Effect.Effect<Scope.Scope, Error, Value>>
+  readonly scoped: Effect.Effect<Effect.Effect<Value, Error, Scope.Scope>>
   readonly complete: Complete<Key, Error, Value>
 }
 
 /** @internal */
 export const complete = <Key, Error, Value>(
   key: _cache.MapKey<Key>,
-  exit: Exit.Exit<Error, readonly [Value, Scope.Scope.Finalizer]>,
+  exit: Exit.Exit<readonly [Value, Scope.Scope.Finalizer], Error>,
   ownerCount: MutableRef.MutableRef<number>,
   entryStats: Cache.EntryStats,
   timeToLive: number
@@ -123,7 +123,7 @@ export const complete = <Key, Error, Value>(
 /** @internal */
 export const pending = <Key, Error, Value>(
   key: _cache.MapKey<Key>,
-  scoped: Effect.Effect<never, never, Effect.Effect<Scope.Scope, Error, Value>>
+  scoped: Effect.Effect<Effect.Effect<Value, Error, Scope.Scope>>
 ): Pending<Key, Error, Value> =>
   Data.struct({
     _tag: "Pending",
@@ -133,7 +133,7 @@ export const pending = <Key, Error, Value>(
 
 /** @internal */
 export const refreshing = <Key, Error, Value>(
-  scoped: Effect.Effect<never, never, Effect.Effect<Scope.Scope, Error, Value>>,
+  scoped: Effect.Effect<Effect.Effect<Value, Error, Scope.Scope>>,
   complete: Complete<Key, Error, Value>
 ): Refreshing<Key, Error, Value> =>
   Data.struct({
@@ -145,7 +145,7 @@ export const refreshing = <Key, Error, Value>(
 /** @internal */
 export const toScoped = <Key, Error, Value>(
   self: Complete<Key, Error, Value>
-): Effect.Effect<Scope.Scope, Error, Value> =>
+): Effect.Effect<Value, Error, Scope.Scope> =>
   Exit.matchEffect(self.exit, {
     onFailure: (cause) => core.failCause(cause),
     onSuccess: ([value]) =>
@@ -158,7 +158,7 @@ export const toScoped = <Key, Error, Value>(
 /** @internal */
 export const releaseOwner = <Key, Error, Value>(
   self: Complete<Key, Error, Value>
-): Effect.Effect<never, never, void> =>
+): Effect.Effect<void> =>
   Exit.matchEffect(self.exit, {
     onFailure: () => core.unit,
     onSuccess: ([, finalizer]) =>
@@ -194,7 +194,7 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
     readonly capacity: number,
     readonly scopedLookup: ScopedCache.Lookup<Key, Environment, Error, Value>,
     readonly clock: Clock.Clock,
-    readonly timeToLive: (exit: Exit.Exit<Error, Value>) => Duration.Duration,
+    readonly timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.Duration,
     readonly context: Context.Context<Environment>
   ) {
     this.cacheState = initialCacheState()
@@ -204,7 +204,7 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
     return pipeArguments(this, arguments)
   }
 
-  get cacheStats(): Effect.Effect<never, never, Cache.CacheStats> {
+  get cacheStats(): Effect.Effect<Cache.CacheStats> {
     return core.sync(() =>
       _cache.makeCacheStats({
         hits: this.cacheState.hits,
@@ -214,7 +214,7 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
     )
   }
 
-  getOption(key: Key): Effect.Effect<Scope.Scope, Error, Option.Option<Value>> {
+  getOption(key: Key): Effect.Effect<Option.Option<Value>, Error, Scope.Scope> {
     return core.suspend(() =>
       Option.match(MutableHashMap.get(this.cacheState.map, key), {
         onNone: () => effect.succeedNone,
@@ -223,21 +223,21 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
     )
   }
 
-  getOptionComplete(key: Key): Effect.Effect<Scope.Scope, never, Option.Option<Value>> {
+  getOptionComplete(key: Key): Effect.Effect<Option.Option<Value>, never, Scope.Scope> {
     return core.suspend(() =>
       Option.match(MutableHashMap.get(this.cacheState.map, key), {
         onNone: () => effect.succeedNone,
         onSome: (value) =>
-          core.flatten(this.resolveMapValue(value, true)) as Effect.Effect<Scope.Scope, never, Option.Option<Value>>
+          core.flatten(this.resolveMapValue(value, true)) as Effect.Effect<Option.Option<Value>, never, Scope.Scope>
       })
     )
   }
 
-  contains(key: Key): Effect.Effect<never, never, boolean> {
+  contains(key: Key): Effect.Effect<boolean> {
     return core.sync(() => MutableHashMap.has(this.cacheState.map, key))
   }
 
-  entryStats(key: Key): Effect.Effect<never, never, Option.Option<Cache.EntryStats>> {
+  entryStats(key: Key): Effect.Effect<Option.Option<Cache.EntryStats>> {
     return core.sync(() => {
       const value = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))
       if (value === undefined) {
@@ -257,7 +257,7 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
     })
   }
 
-  get(key: Key): Effect.Effect<Scope.Scope, Error, Value> {
+  get(key: Key): Effect.Effect<Value, Error, Scope.Scope> {
     return pipe(
       this.lookupValueOf(key),
       effect.memoize,
@@ -305,7 +305,7 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
     )
   }
 
-  invalidate(key: Key): Effect.Effect<never, never, void> {
+  invalidate(key: Key): Effect.Effect<void> {
     return core.suspend(() => {
       if (MutableHashMap.has(this.cacheState.map, key)) {
         const mapValue = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))!
@@ -326,7 +326,7 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
     })
   }
 
-  get invalidateAll(): Effect.Effect<never, never, void> {
+  get invalidateAll(): Effect.Effect<void> {
     return fiberRuntime.forEachConcurrentDiscard(
       HashSet.fromIterable(Array.from(this.cacheState.map).map(([key]) => key)),
       (key) => this.invalidate(key),
@@ -335,7 +335,7 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
     )
   }
 
-  refresh(key: Key): Effect.Effect<never, Error, void> {
+  refresh(key: Key): Effect.Effect<void, Error> {
     return pipe(
       this.lookupValueOf(key),
       effect.memoize,
@@ -350,7 +350,7 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
             MutableHashMap.set(this.cacheState.map, key, pending(newKey, scoped))
           }
         }
-        let finalScoped: Effect.Effect<never, never, Effect.Effect<Scope.Scope, Error, Value>>
+        let finalScoped: Effect.Effect<Effect.Effect<Value, Error, Scope.Scope>>
         if (value === undefined) {
           finalScoped = core.zipRight(
             this.ensureMapSizeNotExceeded(newKey!),
@@ -388,11 +388,14 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
     )
   }
 
-  get size(): Effect.Effect<never, never, number> {
+  get size(): Effect.Effect<number> {
     return core.sync(() => MutableHashMap.size(this.cacheState.map))
   }
 
-  resolveMapValue(value: MapValue<Key, Error, Value>, ignorePending = false) {
+  resolveMapValue(
+    value: MapValue<Key, Error, Value>,
+    ignorePending = false
+  ): Effect.Effect<Effect.Effect<Option.Option<Value>, Error, Scope.Scope>> {
     switch (value._tag) {
       case "Complete": {
         this.trackHit()
@@ -435,7 +438,7 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
     }
   }
 
-  lookupValueOf(key: Key): Effect.Effect<never, never, Effect.Effect<Scope.Scope, Error, Value>> {
+  lookupValueOf(key: Key): Effect.Effect<Effect.Effect<Value, Error, Scope.Scope>> {
     return pipe(
       core.onInterrupt(
         core.flatMap(Scope.make(), (scope) =>
@@ -452,7 +455,7 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
         const expiredAt = now + Duration.toMillis(this.timeToLive(exit))
         switch (exit._tag) {
           case "Success": {
-            const exitWithFinalizer: Exit.Exit<never, [Value, Scope.Scope.Finalizer]> = Exit.succeed([
+            const exitWithFinalizer: Exit.Exit<[Value, Scope.Scope.Finalizer]> = Exit.succeed([
               exit.value,
               release
             ])
@@ -480,7 +483,7 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
           case "Failure": {
             const completedResult = complete<Key, Error, Value>(
               _cache.makeMapKey(key),
-              exit as Exit.Exit<Error, readonly [Value, Scope.Scope.Finalizer]>,
+              exit as Exit.Exit<readonly [Value, Scope.Scope.Finalizer], Error>,
               MutableRef.make(0),
               _cache.makeEntryStats(now),
               expiredAt
@@ -555,7 +558,7 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
     return cleanedKeys
   }
 
-  cleanMapValue(mapValue: MapValue<Key, Error, Value> | undefined): Effect.Effect<never, never, void> {
+  cleanMapValue(mapValue: MapValue<Key, Error, Value> | undefined): Effect.Effect<void> {
     if (mapValue === undefined) {
       return core.unit
     }
@@ -572,7 +575,7 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
     }
   }
 
-  ensureMapSizeNotExceeded(key: _cache.MapKey<Key>): Effect.Effect<never, never, void> {
+  ensureMapSizeNotExceeded(key: _cache.MapKey<Key>): Effect.Effect<void> {
     return fiberRuntime.forEachConcurrentDiscard(
       this.trackAccess(key),
       (cleanedMapValue) => this.cleanMapValue(cleanedMapValue),
@@ -589,7 +592,7 @@ export const make = <Key, Environment, Error, Value>(
     readonly capacity: number
     readonly timeToLive: Duration.DurationInput
   }
-): Effect.Effect<Environment | Scope.Scope, never, ScopedCache.ScopedCache<Key, Error, Value>> => {
+): Effect.Effect<ScopedCache.ScopedCache<Key, Error, Value>, never, Environment | Scope.Scope> => {
   const timeToLive = Duration.decode(options.timeToLive)
   return makeWith({
     capacity: options.capacity,
@@ -603,9 +606,9 @@ export const makeWith = <Key, Environment, Error, Value>(
   options: {
     readonly capacity: number
     readonly lookup: ScopedCache.Lookup<Key, Environment, Error, Value>
-    readonly timeToLive: (exit: Exit.Exit<Error, Value>) => Duration.DurationInput
+    readonly timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.DurationInput
   }
-): Effect.Effect<Environment | Scope.Scope, never, ScopedCache.ScopedCache<Key, Error, Value>> =>
+): Effect.Effect<ScopedCache.ScopedCache<Key, Error, Value>, never, Environment | Scope.Scope> =>
   core.flatMap(
     effect.clock,
     (clock) =>
@@ -621,8 +624,8 @@ const buildWith = <Key, Environment, Error, Value>(
   capacity: number,
   scopedLookup: ScopedCache.Lookup<Key, Environment, Error, Value>,
   clock: Clock.Clock,
-  timeToLive: (exit: Exit.Exit<Error, Value>) => Duration.Duration
-): Effect.Effect<Environment | Scope.Scope, never, ScopedCache.ScopedCache<Key, Error, Value>> =>
+  timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.Duration
+): Effect.Effect<ScopedCache.ScopedCache<Key, Error, Value>, never, Environment | Scope.Scope> =>
   fiberRuntime.acquireRelease(
     core.flatMap(
       core.context<Environment>(),

package/src/internal/scopedRef.ts

@@ -26,13 +26,13 @@ const scopedRefVariance = {
 }
 
 /** @internal  */
-const close = <A>(self: ScopedRef.ScopedRef<A>): Effect.Effect<never, never, void> =>
+const close = <A>(self: ScopedRef.ScopedRef<A>): Effect.Effect<void> =>
   core.flatMap(ref.get(self.ref), (tuple) => tuple[0].close(core.exitUnit))
 
 /** @internal */
-export const fromAcquire = <R, E, A>(
-  acquire: Effect.Effect<R, E, A>
-): Effect.Effect<R | Scope.Scope, E, ScopedRef.ScopedRef<A>> =>
+export const fromAcquire = <A, E, R>(
+  acquire: Effect.Effect<A, E, R>
+): Effect.Effect<ScopedRef.ScopedRef<A>, E, R | Scope.Scope> =>
   core.uninterruptible(
     fiberRuntime.scopeMake().pipe(core.flatMap((newScope) =>
       acquire.pipe(
@@ -49,7 +49,7 @@ export const fromAcquire = <R, E, A>(
                 ref
               }
               return pipe(
-                fiberRuntime.addFinalizer<R | Scope.Scope, void>(() => close(scopedRef)),
+                fiberRuntime.addFinalizer(() => close(scopedRef)),
                 core.as(scopedRef)
               )
             })
@@ -60,25 +60,25 @@ export const fromAcquire = <R, E, A>(
   )
 
 /** @internal */
-export const get = <A>(self: ScopedRef.ScopedRef<A>): Effect.Effect<never, never, A> =>
+export const get = <A>(self: ScopedRef.ScopedRef<A>): Effect.Effect<A> =>
   core.map(ref.get(self.ref), (tuple) => tuple[1])
 
 /** @internal */
-export const make = <A>(evaluate: LazyArg<A>): Effect.Effect<Scope.Scope, never, ScopedRef.ScopedRef<A>> =>
+export const make = <A>(evaluate: LazyArg<A>): Effect.Effect<ScopedRef.ScopedRef<A>, never, Scope.Scope> =>
   fromAcquire(core.sync(evaluate))
 
 /** @internal */
 export const set = dual<
   <A, R, E>(
-    acquire: Effect.Effect<R, E, A>
-  ) => (self: ScopedRef.ScopedRef<A>) => Effect.Effect<Exclude<R, Scope.Scope>, E, void>,
+    acquire: Effect.Effect<A, E, R>
+  ) => (self: ScopedRef.ScopedRef<A>) => Effect.Effect<void, E, Exclude<R, Scope.Scope>>,
   <A, R, E>(
     self: ScopedRef.ScopedRef<A>,
-    acquire: Effect.Effect<R, E, A>
-  ) => Effect.Effect<Exclude<R, Scope.Scope>, E, void>
+    acquire: Effect.Effect<A, E, R>
+  ) => Effect.Effect<void, E, Exclude<R, Scope.Scope>>
 >(2, <A, R, E>(
   self: ScopedRef.ScopedRef<A>,
-  acquire: Effect.Effect<R, E, A>
+  acquire: Effect.Effect<A, E, R>
 ) =>
   core.flatten(
     synchronized.modifyEffect(self.ref, ([oldScope, value]) =>
@@ -93,7 +93,7 @@ export const set = dual<
                     core.scopeClose(newScope, core.exitUnit).pipe(
                       core.as(
                         [
-                          core.failCause(cause) as Effect.Effect<never, E, void>,
+                          core.failCause(cause) as Effect.Effect<void, E>,
                           [oldScope, value] as const
                         ] as const
                       )
@@ -101,7 +101,7 @@ export const set = dual<
                   onSuccess: (value) =>
                     core.succeed(
                       [
-                        core.unit as Effect.Effect<never, E, void>,
+                        core.unit as Effect.Effect<void, E>,
                         [newScope, value] as const
                       ] as const
                     )