effect 2.0.0-next.55 → 2.0.0-next.56

package/src/internal/core.ts

@@ -26,7 +26,7 @@ import type * as MetricLabel from "../MetricLabel.js"
 import * as MutableRef from "../MutableRef.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
-import { hasProperty, isObject, type Predicate, type Refinement } from "../Predicate.js"
+import { hasProperty, isObject, isPromise, isString, type Predicate, type Refinement } from "../Predicate.js"
 import * as ReadonlyArray from "../ReadonlyArray.js"
 import type * as Request from "../Request.js"
 import type * as BlockedRequests from "../RequestBlock.js"
@@ -35,11 +35,12 @@ import type * as RuntimeFlags from "../RuntimeFlags.js"
 import * as RuntimeFlagsPatch from "../RuntimeFlagsPatch.js"
 import type * as Scope from "../Scope.js"
 import type * as Tracer from "../Tracer.js"
+import type { NoInfer } from "../Types.js"
 import * as _blockedRequests from "./blockedRequests.js"
 import * as internalCause from "./cause.js"
 import * as deferred from "./deferred.js"
 import * as internalDiffer from "./differ.js"
-import { effectVariance } from "./effectable.js"
+import { effectVariance, StructuralCommitPrototype } from "./effectable.js"
 import type * as FiberRuntime from "./fiberRuntime.js"
 import type * as fiberScope from "./fiberScope.js"
 import * as DeferredOpCodes from "./opCodes/deferred.js"
@@ -61,7 +62,7 @@ export const EffectErrorTypeId = Symbol.for(EffectErrorSymbolKey)
 export type EffectErrorTypeId = typeof EffectErrorTypeId
 
 /** @internal */
-export interface EffectError<E> {
+export interface EffectError<out E> {
   readonly [EffectErrorTypeId]: EffectErrorTypeId
   readonly _tag: "EffectError"
   readonly cause: Cause.Cause<E>
@@ -262,13 +263,13 @@ export type Op<Tag extends string, Body = {}> = Effect.Effect<never, never, neve
 /** @internal */
 export interface Async extends
   Op<OpCodes.OP_ASYNC, {
-    readonly i0: (resume: (effect: Primitive) => void) => void
+    i0(resume: (effect: Primitive) => void): void
     readonly i1: FiberId.FiberId
   }>
 {}
 
 /** @internal */
-export interface Blocked<R = any, E = any, A = any> extends
+export interface Blocked<out R = any, out E = any, out A = any> extends
   Op<"Blocked", {
     readonly i0: BlockedRequests.RequestBlock<R>
     readonly i1: Effect.Effect<R, E, A>
@@ -276,7 +277,7 @@ export interface Blocked<R = any, E = any, A = any> extends
 {}
 
 /** @internal */
-export interface RunBlocked<R = any> extends
+export interface RunBlocked<out R = any> extends
   Op<"RunBlocked", {
     readonly i0: BlockedRequests.RequestBlock<R>
   }>
@@ -295,7 +296,7 @@ export interface OpTag extends Op<OpCodes.OP_TAG, {}> {}
 /** @internal */
 export interface Commit extends
   Op<OpCodes.OP_COMMIT, {
-    readonly commit: () => Effect.Effect<unknown, unknown, unknown>
+    commit(): Effect.Effect<unknown, unknown, unknown>
   }>
 {}
 
@@ -303,7 +304,7 @@ export interface Commit extends
 export interface OnFailure extends
   Op<OpCodes.OP_ON_FAILURE, {
     readonly i0: Primitive
-    readonly i1: (a: Cause.Cause<unknown>) => Primitive
+    i1(a: Cause.Cause<unknown>): Primitive
   }>
 {}
 
@@ -311,7 +312,7 @@ export interface OnFailure extends
 export interface OnSuccess extends
   Op<OpCodes.OP_ON_SUCCESS, {
     readonly i0: Primitive
-    readonly i1: (a: unknown) => Primitive
+    i1(a: unknown): Primitive
   }>
 {}
 
@@ -319,7 +320,7 @@ export interface OnSuccess extends
 export interface OnStep extends
   Op<"OnStep", {
     readonly i0: Primitive
-    readonly i1: (result: Exit.Exit<any, any> | Blocked) => Primitive
+    i1(result: Exit.Exit<any, any> | Blocked): Primitive
   }>
 {}
 
@@ -327,8 +328,8 @@ export interface OnStep extends
 export interface OnSuccessAndFailure extends
   Op<OpCodes.OP_ON_SUCCESS_AND_FAILURE, {
     readonly i0: Primitive
-    readonly i1: (a: Cause.Cause<unknown>) => Primitive
-    readonly i2: (a: unknown) => Primitive
+    i1(a: Cause.Cause<unknown>): Primitive
+    i2(a: unknown): Primitive
   }>
 {}
 
@@ -342,7 +343,7 @@ export interface Success extends
 /** @internal */
 export interface Sync extends
   Op<OpCodes.OP_SYNC, {
-    readonly i0: LazyArg<unknown>
+    i0(): unknown
   }>
 {}
 
@@ -357,16 +358,16 @@ export interface UpdateRuntimeFlags extends
 /** @internal */
 export interface While extends
   Op<OpCodes.OP_WHILE, {
-    readonly i0: () => boolean
-    readonly i1: () => Primitive
-    readonly i2: (a: unknown) => void
+    i0(): boolean
+    i1(): Primitive
+    i2(a: unknown): void
   }>
 {}
 
 /** @internal */
 export interface WithRuntime extends
   Op<OpCodes.OP_WITH_RUNTIME, {
-    readonly i0: (fiber: FiberRuntime.FiberRuntime<unknown, unknown>, status: FiberStatus.Running) => Primitive
+    i0(fiber: FiberRuntime.FiberRuntime<unknown, unknown>, status: FiberStatus.Running): Primitive
   }>
 {}
 
@@ -641,7 +642,7 @@ export const die = (defect: unknown): Effect.Effect<never, never, never> =>
 
 /* @internal */
 export const dieMessage = (message: string): Effect.Effect<never, never, never> =>
-  failCauseSync(() => internalCause.die(internalCause.RuntimeException(message)))
+  failCauseSync(() => internalCause.die(new RuntimeException(message)))
 
 /* @internal */
 export const dieSync = (evaluate: LazyArg<unknown>): Effect.Effect<never, never, never> => flatMap(sync(evaluate), die)
@@ -707,6 +708,51 @@ export const flatMap = dual<
   return effect
 })
 
+/* @internal */
+export const andThen = dual<
+  {
+    <A, X>(
+      f: (a: NoInfer<A>) => X
+    ): <R, E>(
+      self: Effect.Effect<R, E, A>
+    ) => [X] extends [Effect.Effect<infer R1, infer E1, infer A1>] ? Effect.Effect<R | R1, E | E1, A1>
+      : [X] extends [Promise<infer A1>] ? Effect.Effect<R, E | Cause.UnknownException, A1>
+      : Effect.Effect<R, E, X>
+    <X>(
+      f: X
+    ): <R, E, A>(
+      self: Effect.Effect<R, E, A>
+    ) => [X] extends [Effect.Effect<infer R1, infer E1, infer A1>] ? Effect.Effect<R | R1, E | E1, A1>
+      : [X] extends [Promise<infer A1>] ? Effect.Effect<R, E | Cause.UnknownException, A1>
+      : Effect.Effect<R, E, X>
+  },
+  {
+    <A, R, E, X>(
+      self: Effect.Effect<R, E, A>,
+      f: (a: NoInfer<A>) => X
+    ): [X] extends [Effect.Effect<infer R1, infer E1, infer A1>] ? Effect.Effect<R | R1, E | E1, A1>
+      : [X] extends [Promise<infer A1>] ? Effect.Effect<R, E | Cause.UnknownException, A1>
+      : Effect.Effect<R, E, X>
+    <A, R, E, X>(
+      self: Effect.Effect<R, E, A>,
+      f: X
+    ): [X] extends [Effect.Effect<infer R1, infer E1, infer A1>] ? Effect.Effect<R | R1, E | E1, A1>
+      : [X] extends [Promise<infer A1>] ? Effect.Effect<R, E | Cause.UnknownException, A1>
+      : Effect.Effect<R, E, X>
+  }
+>(2, (self, f) =>
+  flatMap(self, (a) => {
+    const b = typeof f === "function" ? (f as any)(a) : f
+    if (isEffect(b)) {
+      return b
+    } else if (isPromise(b)) {
+      return async<never, Cause.UnknownException, any>((resume) => {
+        b.then((a) => resume(succeed(a))).catch((e) => resume(fail(new UnknownException(e))))
+      })
+    }
+    return succeed(b)
+  }))
+
 /* @internal */
 export const step = <R, E, A>(
   self: Effect.Effect<R, E, A>
@@ -1062,7 +1108,7 @@ export const orDieWith = dual<
 export const partitionMap = <A, A1, A2>(
   elements: Iterable<A>,
   f: (a: A) => Either.Either<A1, A2>
-): [Array<A1>, Array<A2>] =>
+): [left: Array<A1>, right: Array<A2>] =>
   ReadonlyArray.fromIterable(elements).reduceRight(
     ([lefts, rights], current) => {
       const either = f(current)
@@ -1105,14 +1151,48 @@ export const sync = <A>(evaluate: LazyArg<A>): Effect.Effect<never, never, A> =>
 
 /* @internal */
 export const tap = dual<
-  <A, X extends A, R2, E2, _>(
-    f: (a: X) => Effect.Effect<R2, E2, _>
-  ) => <R, E>(self: Effect.Effect<R, E, A>) => Effect.Effect<R | R2, E | E2, A>,
-  <R, E, A, X extends A, R2, E2, _>(
-    self: Effect.Effect<R, E, A>,
-    f: (a: X) => Effect.Effect<R2, E2, _>
-  ) => Effect.Effect<R | R2, E | E2, A>
->(2, (self, f) => flatMap(self, (a) => as(f(a as any), a)))
+  {
+    <A, X>(
+      f: (a: NoInfer<A>) => X
+    ): <R, E>(
+      self: Effect.Effect<R, E, A>
+    ) => [X] extends [Effect.Effect<infer R1, infer E1, infer _A1>] ? Effect.Effect<R | R1, E | E1, A>
+      : [X] extends [Promise<infer _A1>] ? Effect.Effect<R, E | Cause.UnknownException, A>
+      : Effect.Effect<R, E, A>
+    <X>(
+      f: X
+    ): <R, E, A>(
+      self: Effect.Effect<R, E, A>
+    ) => [X] extends [Effect.Effect<infer R1, infer E1, infer _A1>] ? Effect.Effect<R | R1, E | E1, A>
+      : [X] extends [Promise<infer _A1>] ? Effect.Effect<R, E | Cause.UnknownException, A>
+      : Effect.Effect<R, E, A>
+  },
+  {
+    <A, R, E, X>(
+      self: Effect.Effect<R, E, A>,
+      f: (a: NoInfer<A>) => X
+    ): [X] extends [Effect.Effect<infer R1, infer E1, infer _A1>] ? Effect.Effect<R | R1, E | E1, A>
+      : [X] extends [Promise<infer _A1>] ? Effect.Effect<R, E | Cause.UnknownException, A>
+      : Effect.Effect<R, E, A>
+    <A, R, E, X>(
+      self: Effect.Effect<R, E, A>,
+      f: X
+    ): [X] extends [Effect.Effect<infer R1, infer E1, infer _A1>] ? Effect.Effect<R | R1, E | E1, A>
+      : [X] extends [Promise<infer _A1>] ? Effect.Effect<R, E | Cause.UnknownException, A>
+      : Effect.Effect<R, E, A>
+  }
+>(2, (self, f) =>
+  flatMap(self, (a) => {
+    const b = typeof f === "function" ? (f as any)(a) : f
+    if (isEffect(b)) {
+      return as(b, a)
+    } else if (isPromise(b)) {
+      return async<never, Cause.UnknownException, any>((resume) => {
+        b.then((_) => resume(succeed(a))).catch((e) => resume(fail(new UnknownException(e))))
+      })
+    }
+    return succeed(a)
+  }))
 
 /* @internal */
 export const transplant = <R, E, A>(
@@ -1479,7 +1559,7 @@ export const FiberRefTypeId: FiberRef.FiberRefTypeId = Symbol.for(
 
 /** @internal */
 const fiberRefVariance = {
-  _A: (_: never) => _
+  _A: (_: any) => _
 }
 
 /* @internal */
@@ -1594,14 +1674,14 @@ export const RequestResolverTypeId: RequestResolver.RequestResolverTypeId = Symb
   RequestResolverSymbolKey
 ) as RequestResolver.RequestResolverTypeId
 
-const dataSourceVariance = {
-  _R: (_: never) => _,
-  _A: (_: never) => _
+const requestResolverVariance = {
+  _A: (_: unknown) => _,
+  _R: (_: never) => _
 }
 
 /** @internal */
-export class RequestResolverImpl<R, A> implements RequestResolver.RequestResolver<A, R> {
-  readonly [RequestResolverTypeId] = dataSourceVariance
+export class RequestResolverImpl<out R, in A> implements RequestResolver.RequestResolver<A, R> {
+  readonly [RequestResolverTypeId] = requestResolverVariance
   constructor(
     readonly runAll: (
       requests: Array<Array<Request.Entry<A>>>
@@ -2071,6 +2151,172 @@ export const releaseMapMake: Effect.Effect<never, never, ReleaseMap> = sync(():
   }
 }))
 
+// -----------------------------------------------------------------------------
+// Cause
+// -----------------------------------------------------------------------------
+
+/** @internal */
+export const causeSquash = <E>(self: Cause.Cause<E>): unknown => {
+  return causeSquashWith(identity)(self)
+}
+
+/** @internal */
+export const causeSquashWith = dual<
+  <E>(f: (error: E) => unknown) => (self: Cause.Cause<E>) => unknown,
+  <E>(self: Cause.Cause<E>, f: (error: E) => unknown) => unknown
+>(2, (self, f) => {
+  const option = pipe(self, internalCause.failureOption, Option.map(f))
+  switch (option._tag) {
+    case "None": {
+      return pipe(
+        internalCause.defects(self),
+        Chunk.head,
+        Option.match({
+          onNone: () => {
+            const interrupts = Array.from(internalCause.interruptors(self)).flatMap((fiberId) =>
+              Array.from(FiberId.ids(fiberId)).map((id) => `#${id}`)
+            )
+            return new InterruptedException(interrupts ? `Interrupted by fibers: ${interrupts.join(", ")}` : void 0)
+          },
+          onSome: identity
+        })
+      )
+    }
+    case "Some": {
+      return option.value
+    }
+  }
+})
+
+// -----------------------------------------------------------------------------
+// Errors
+// -----------------------------------------------------------------------------
+
+/** @internal */
+export const YieldableError: new(message?: string) => Cause.YieldableError = (function() {
+  class YieldableError extends globalThis.Error {
+    commit() {
+      return fail(this)
+    }
+    toString() {
+      return this.stack ?? `${this.name}: ${this.message}`
+    }
+    toJSON() {
+      return { ...this }
+    }
+    [NodeInspectSymbol](): string {
+      return this.toString()
+    }
+  }
+  Object.assign(YieldableError.prototype, StructuralCommitPrototype)
+  return YieldableError as any
+})()
+
+const makeException = <T extends { _tag: string; message?: string }>(
+  proto: Omit<T, keyof Cause.YieldableError | "_tag">,
+  tag: T["_tag"]
+): new(message?: string | undefined) => T => {
+  class Base extends YieldableError {
+    readonly _tag = tag
+  }
+  Object.assign(Base.prototype, proto)
+  ;(Base.prototype as any).name = tag
+  return Base as any
+}
+
+/** @internal */
+export const RuntimeExceptionTypeId: Cause.RuntimeExceptionTypeId = Symbol.for(
+  "effect/Cause/errors/RuntimeException"
+) as Cause.RuntimeExceptionTypeId
+
+/** @internal */
+export const RuntimeException = makeException<Cause.RuntimeException>({
+  [RuntimeExceptionTypeId]: RuntimeExceptionTypeId
+}, "RuntimeException")
+
+/** @internal */
+export const isRuntimeException = (u: unknown): u is Cause.RuntimeException => hasProperty(u, RuntimeExceptionTypeId)
+
+/** @internal */
+export const InterruptedExceptionTypeId: Cause.InterruptedExceptionTypeId = Symbol.for(
+  "effect/Cause/errors/InterruptedException"
+) as Cause.InterruptedExceptionTypeId
+
+/** @internal */
+export const InterruptedException = makeException<Cause.InterruptedException>({
+  [InterruptedExceptionTypeId]: InterruptedExceptionTypeId
+}, "InterruptedException")
+
+/** @internal */
+export const isInterruptedException = (u: unknown): u is Cause.InterruptedException =>
+  hasProperty(u, InterruptedExceptionTypeId)
+
+/** @internal */
+export const IllegalArgumentExceptionTypeId: Cause.IllegalArgumentExceptionTypeId = Symbol.for(
+  "effect/Cause/errors/IllegalArgument"
+) as Cause.IllegalArgumentExceptionTypeId
+
+/** @internal */
+export const IllegalArgumentException = makeException<Cause.IllegalArgumentException>({
+  [IllegalArgumentExceptionTypeId]: IllegalArgumentExceptionTypeId
+}, "IllegalArgumentException")
+
+/** @internal */
+export const isIllegalArgumentException = (u: unknown): u is Cause.IllegalArgumentException =>
+  hasProperty(u, IllegalArgumentExceptionTypeId)
+
+/** @internal */
+export const NoSuchElementExceptionTypeId: Cause.NoSuchElementExceptionTypeId = Symbol.for(
+  "effect/Cause/errors/NoSuchElement"
+) as Cause.NoSuchElementExceptionTypeId
+
+/** @internal */
+export const NoSuchElementException = makeException<Cause.NoSuchElementException>({
+  [NoSuchElementExceptionTypeId]: NoSuchElementExceptionTypeId
+}, "NoSuchElementException")
+
+/** @internal */
+export const isNoSuchElementException = (u: unknown): u is Cause.NoSuchElementException =>
+  hasProperty(u, NoSuchElementExceptionTypeId)
+
+/** @internal */
+export const InvalidPubSubCapacityExceptionTypeId: Cause.InvalidPubSubCapacityExceptionTypeId = Symbol.for(
+  "effect/Cause/errors/InvalidPubSubCapacityException"
+) as Cause.InvalidPubSubCapacityExceptionTypeId
+
+/** @internal */
+export const InvalidPubSubCapacityException = makeException<Cause.InvalidPubSubCapacityException>({
+  [InvalidPubSubCapacityExceptionTypeId]: InvalidPubSubCapacityExceptionTypeId
+}, "InvalidPubSubCapacityException")
+
+/** @internal */
+export const isInvalidCapacityError = (u: unknown): u is Cause.InvalidPubSubCapacityException =>
+  hasProperty(u, InvalidPubSubCapacityExceptionTypeId)
+
+/** @internal */
+export const UnknownExceptionTypeId: Cause.UnknownExceptionTypeId = Symbol.for(
+  "effect/Cause/errors/UnknownException"
+) as Cause.UnknownExceptionTypeId
+
+/** @internal */
+export const UnknownException: new(error: unknown, message?: string | undefined) => Cause.UnknownException =
+  (function() {
+    class UnknownException extends YieldableError {
+      readonly _tag = "UnknownException"
+      constructor(readonly error: unknown, message?: string) {
+        super(message ?? (hasProperty(error, "message") && isString(error.message) ? error.message : void 0))
+      }
+    }
+    Object.assign(UnknownException.prototype, {
+      [UnknownExceptionTypeId]: UnknownExceptionTypeId,
+      name: "UnknownException"
+    })
+    return UnknownException as any
+  })()
+
+/** @internal */
+export const isUnknownException = (u: unknown): u is Cause.UnknownException => hasProperty(u, UnknownExceptionTypeId)
+
 // -----------------------------------------------------------------------------
 // Exit
 // -----------------------------------------------------------------------------
@@ -2142,16 +2388,18 @@ export const exitDie = (defect: unknown): Exit.Exit<never, never> =>
   exitFailCause(internalCause.die(defect)) as Exit.Exit<never, never>
 
 /** @internal */
-export const exitExists = dual<
-  <A>(predicate: Predicate<A>) => <E>(self: Exit.Exit<E, A>) => boolean,
-  <E, A>(self: Exit.Exit<E, A>, predicate: Predicate<A>) => boolean
->(2, (self, predicate) => {
+export const exitExists: {
+  <A, B extends A>(refinement: Refinement<A, B>): <E>(self: Exit.Exit<E, A>) => self is Exit.Exit<never, B>
+  <A>(predicate: Predicate<A>): <E>(self: Exit.Exit<E, A>) => boolean
+  <E, A, B extends A>(self: Exit.Exit<E, A>, refinement: Refinement<A, B>): self is Exit.Exit<never, B>
+  <E, A>(self: Exit.Exit<E, A>, predicate: Predicate<A>): boolean
+} = dual(2, <E, A, B extends A>(self: Exit.Exit<E, A>, refinement: Refinement<A, B>): self is Exit.Exit<never, B> => {
   switch (self._tag) {
     case OpCodes.OP_FAILURE: {
       return false
     }
     case OpCodes.OP_SUCCESS: {
-      return predicate(self.i0)
+      return refinement(self.i0)
     }
   }
 })

package/src/internal/data.ts

@@ -2,6 +2,7 @@ import type * as Data from "../Data.js"
 import * as Equal from "../Equal.js"
 import * as Hash from "../Hash.js"
 import type * as Types from "../Types.js"
+import { StructuralPrototype } from "./effectable.js"
 
 /** @internal */
 export const ArrayProto: Equal.Equal = Object.assign(Object.create(Array.prototype), {
@@ -17,26 +18,6 @@ export const ArrayProto: Equal.Equal = Object.assign(Object.create(Array.prototy
   }
 })
 
-/** @internal */
-export const StructProto: Equal.Equal = {
-  [Hash.symbol](this: Equal.Equal) {
-    return Hash.structure(this)
-  },
-  [Equal.symbol](this: Equal.Equal, that: Equal.Equal) {
-    const selfKeys = Object.keys(this)
-    const thatKeys = Object.keys(that as object)
-    if (selfKeys.length !== thatKeys.length) {
-      return false
-    }
-    for (const key of selfKeys) {
-      if (!(key in (that as object) && Equal.equals((this as any)[key], (that as any)[key]))) {
-        return false
-      }
-    }
-    return true
-  }
-}
-
 /** @internal */
 export const Structural: new<A>(
   args: Types.Equals<Omit<A, keyof Equal.Equal>, {}> extends true ? void
@@ -47,10 +28,10 @@ export const Structural: new<A>(
       Object.assign(this, args)
     }
   }
-  Structural.prototype = StructProto
+  Structural.prototype = StructuralPrototype
   return Structural as any
 })()
 
 /** @internal */
 export const struct = <As extends Readonly<Record<string, any>>>(as: As): Data.Data<As> =>
-  Object.assign(Object.create(StructProto), as)
+  Object.assign(Object.create(StructuralPrototype), as)

package/src/internal/dataSource.ts

@@ -87,7 +87,7 @@ export const batchN = dual<
   new core.RequestResolverImpl(
     (requests) => {
       return n < 1
-        ? core.die(Cause.IllegalArgumentException("RequestResolver.batchN: n must be at least 1"))
+        ? core.die(new Cause.IllegalArgumentException("RequestResolver.batchN: n must be at least 1"))
         : self.runAll(
           Array.from(Chunk.map(
             RA.reduce(

package/src/internal/deferred.ts

@@ -12,21 +12,21 @@ export const DeferredTypeId: Deferred.DeferredTypeId = Symbol.for(
 
 /** @internal */
 export const deferredVariance = {
-  _E: (_: never) => _,
-  _A: (_: never) => _
+  _E: (_: any) => _,
+  _A: (_: any) => _
 }
 
 /** @internal */
-export type State<E, A> = Pending<E, A> | Done<E, A>
+export type State</* in out */ E, /* in out */ A> = Pending<E, A> | Done<E, A>
 
 /** @internal */
-export interface Pending<E, A> {
+export interface Pending<in E, in A> {
   readonly _tag: "Pending"
   readonly joiners: Array<(effect: Effect.Effect<never, E, A>) => void>
 }
 
 /** @internal */
-export interface Done<E, A> {
+export interface Done<out E, out A> {
   readonly _tag: "Done"
   readonly effect: Effect.Effect<never, E, A>
 }

package/src/internal/differ/contextPatch.ts

@@ -40,7 +40,7 @@ const _empty = Object.create(EmptyProto)
 export const empty = <Input, Output>(): Differ.Context.Patch<Input, Output> => _empty
 
 /** @internal */
-export interface AndThen<Input, Output, Output2> extends Differ.Context.Patch<Input, Output2> {
+export interface AndThen<in out Input, in out Output, in out Output2> extends Differ.Context.Patch<Input, Output2> {
   readonly _tag: "AndThen"
   readonly first: Differ.Context.Patch<Input, Output>
   readonly second: Differ.Context.Patch<Output, Output2>
@@ -61,7 +61,7 @@ const makeAndThen = <Input, Output, Output2>(
 }
 
 /** @internal */
-export interface AddService<Env, T, I> extends Differ.Context.Patch<Env, Env | I> {
+export interface AddService<in out Env, in out T, in out I> extends Differ.Context.Patch<Env, Env | I> {
   readonly _tag: "AddService"
   readonly tag: Tag<T, I>
   readonly service: T
@@ -82,7 +82,7 @@ const makeAddService = <Env, I, T>(
 }
 
 /** @internal */
-export interface RemoveService<Env, T, I> extends Differ.Context.Patch<Env, Exclude<Env, I>> {
+export interface RemoveService<in out Env, in out T, in out I> extends Differ.Context.Patch<Env, Exclude<Env, I>> {
   readonly _tag: "RemoveService"
   readonly tag: Tag<T, I>
 }
@@ -100,10 +100,10 @@ const makeRemoveService = <Env, I, T>(
 }
 
 /** @internal */
-export interface UpdateService<Env, T, I> extends Differ.Context.Patch<Env | I, Env | I> {
+export interface UpdateService<in out Env, in out T, in out I> extends Differ.Context.Patch<Env | I, Env | I> {
   readonly _tag: "UpdateService"
   readonly tag: Tag<T, I>
-  readonly update: (service: T) => T
+  update(service: T): T
 }
 
 const UpdateServiceProto = Object.assign(Object.create(PatchProto), {

package/src/internal/differ/orPatch.ts

@@ -24,7 +24,9 @@ const PatchProto = {
 }
 
 /** @internal */
-export interface Empty<Value, Value2, Patch, Patch2> extends Differ.Or.Patch<Value, Value2, Patch, Patch2> {
+export interface Empty<in out Value, in out Value2, in out Patch, in out Patch2>
+  extends Differ.Or.Patch<Value, Value2, Patch, Patch2>
+{
   readonly _tag: "Empty"
 }
 
@@ -43,7 +45,9 @@ export const empty = <Value, Value2, Patch, Patch2>(): Differ.Or.Patch<
 > => _empty
 
 /** @internal */
-export interface AndThen<Value, Value2, Patch, Patch2> extends Differ.Or.Patch<Value, Value2, Patch, Patch2> {
+export interface AndThen<in out Value, in out Value2, in out Patch, Patch2>
+  extends Differ.Or.Patch<Value, Value2, Patch, Patch2>
+{
   readonly _tag: "AndThen"
   readonly first: Differ.Or.Patch<Value, Value2, Patch, Patch2>
   readonly second: Differ.Or.Patch<Value, Value2, Patch, Patch2>
@@ -70,7 +74,9 @@ export const makeAndThen = <Value, Value2, Patch, Patch2>(
 }
 
 /** @internal */
-export interface SetLeft<Value, Value2, Patch, Patch2> extends Differ.Or.Patch<Value, Value2, Patch, Patch2> {
+export interface SetLeft<in out Value, in out Value2, in out Patch, Patch2>
+  extends Differ.Or.Patch<Value, Value2, Patch, Patch2>
+{
   readonly _tag: "SetLeft"
   readonly value: Value
 }
@@ -94,7 +100,9 @@ export const makeSetLeft = <Value, Value2, Patch, Patch2>(
 }
 
 /** @internal */
-export interface SetRight<Value, Value2, Patch, Patch2> extends Differ.Or.Patch<Value, Value2, Patch, Patch2> {
+export interface SetRight<in out Value, in out Value2, in out Patch, in out Patch2>
+  extends Differ.Or.Patch<Value, Value2, Patch, Patch2>
+{
   readonly _tag: "SetRight"
   readonly value: Value2
 }
@@ -118,7 +126,9 @@ export const makeSetRight = <Value, Value2, Patch, Patch2>(
 }
 
 /** @internal */
-export interface UpdateLeft<Value, Value2, Patch, Patch2> extends Differ.Or.Patch<Value, Value2, Patch, Patch2> {
+export interface UpdateLeft<in out Value, in out Value2, in out Patch, in out Patch2>
+  extends Differ.Or.Patch<Value, Value2, Patch, Patch2>
+{
   readonly _tag: "UpdateLeft"
   readonly patch: Patch
 }
@@ -142,7 +152,9 @@ export const makeUpdateLeft = <Value, Value2, Patch, Patch2>(
 }
 
 /** @internal */
-export interface UpdateRight<Value, Value2, Patch, Patch2> extends Differ.Or.Patch<Value, Value2, Patch, Patch2> {
+export interface UpdateRight<in out Value, in out Value2, in out Patch, in out Patch2>
+  extends Differ.Or.Patch<Value, Value2, Patch, Patch2>
+{
   readonly _tag: "UpdateRight"
   readonly patch: Patch2
 }