dfx 0.85.0 → 0.87.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dfx",
-  "version": "0.85.0",
+  "version": "0.87.0",
   "description": "Effect-TS discord library",
   "license": "MIT",
   "repository": {
@@ -39,8 +39,8 @@
     "ws": "^8.16.0"
   },
   "peerDependencies": {
-    "@effect/platform": "^0.42.2",
-    "effect": "^2.1.0"
+    "@effect/platform": "^0.44.0",
+    "effect": "^2.3.0"
   },
   "optionalDependencies": {
     "bufferutil": "^4.0.8",
@@ -48,6 +48,6 @@
     "utf-8-validate": "^6.0.3",
     "zlib-sync": "^0.1.9"
   },
-  "gitHead": "ae552846a82f31a8f7ed44d017f8c4478ca10d8e",
+  "gitHead": "25dc1203ca0dcf3b1cc04753885b752c72e08105",
   "main": "./index.js"
 }

package/src/Cache/driver.ts

@@ -2,42 +2,42 @@ import type * as Option from "effect/Option"
 import type * as Effect from "effect/Effect"
 
 export interface ParentCacheDriver<E, T> {
-  readonly size: Effect.Effect<never, E, number>
-  sizeForParent: (parentId: string) => Effect.Effect<never, E, number>
+  readonly size: Effect.Effect<number, E>
+  sizeForParent: (parentId: string) => Effect.Effect<number, E>
   get: (
     parentId: string,
     resourceId: string,
-  ) => Effect.Effect<never, E, Option.Option<T>>
+  ) => Effect.Effect<Option.Option<T>, E>
   getForParent: (
     parentId: string,
-  ) => Effect.Effect<never, E, Option.Option<ReadonlyMap<string, T>>>
+  ) => Effect.Effect<Option.Option<ReadonlyMap<string, T>>, E>
   set: (
     parentId: string,
     resourceId: string,
     resource: T,
-  ) => Effect.Effect<never, E, void>
+  ) => Effect.Effect<void, E>
   delete: (
     parentId: string,
     resourceId: string,
-  ) => Effect.Effect<never, E, void>
-  parentDelete: (parentId: string) => Effect.Effect<never, E, void>
+  ) => Effect.Effect<void, E>
+  parentDelete: (parentId: string) => Effect.Effect<void, E>
   refreshTTL: (
     parentId: string,
     resourceId: string,
-  ) => Effect.Effect<never, E, void>
-  readonly run: Effect.Effect<never, E, never>
+  ) => Effect.Effect<void, E>
+  readonly run: Effect.Effect<never, E>
 }
 
 export const createParentDriver = <E, T>(driver: ParentCacheDriver<E, T>) =>
   driver
 
 export interface CacheDriver<E, T> {
-  readonly size: Effect.Effect<never, E, number>
-  get: (resourceId: string) => Effect.Effect<never, E, Option.Option<T>>
-  set: (resourceId: string, resource: T) => Effect.Effect<never, E, void>
-  delete: (resourceId: string) => Effect.Effect<never, E, void>
-  refreshTTL: (resourceId: string) => Effect.Effect<never, E, void>
-  readonly run: Effect.Effect<never, E, never>
+  readonly size: Effect.Effect<number, E>
+  get: (resourceId: string) => Effect.Effect<Option.Option<T>, E>
+  set: (resourceId: string, resource: T) => Effect.Effect<void, E>
+  delete: (resourceId: string) => Effect.Effect<void, E>
+  refreshTTL: (resourceId: string) => Effect.Effect<void, E>
+  readonly run: Effect.Effect<never, E>
 }
 
 export const createDriver = <E, T>(driver: CacheDriver<E, T>) => driver

package/src/Cache/memory.ts

@@ -3,11 +3,7 @@ import * as Effect from "effect/Effect"
 import type { CacheDriver, ParentCacheDriver } from "dfx/Cache/driver"
 import { createDriver, createParentDriver } from "dfx/Cache/driver"
 
-export const createWithParent = <T>(): Effect.Effect<
-  never,
-  never,
-  ParentCacheDriver<never, T>
-> =>
+export const createWithParent = <T>(): Effect.Effect<ParentCacheDriver<never, T>> =>
   Effect.sync(() => {
     const map = new Map<string, Map<string, T>>()
 
@@ -56,11 +52,7 @@ export const createWithParent = <T>(): Effect.Effect<
     })
   })
 
-export const create = <T>(): Effect.Effect<
-  never,
-  never,
-  CacheDriver<never, T>
-> =>
+export const create = <T>(): Effect.Effect<CacheDriver<never, T>> =>
   Effect.sync(() => {
     const map = new Map<string, T>()
 

package/src/Cache/memoryTTL.ts

@@ -134,12 +134,12 @@ const make = <T>({
 
 export const create = <T>(
   opts: MemoryTTLOpts,
-): Effect.Effect<never, never, CacheDriver<never, T>> =>
+): Effect.Effect<CacheDriver<never, T>> =>
   Effect.sync(() => make<T>(opts))
 
 export const createWithParent = <T>(
   opts: MemoryTTLOpts,
-): Effect.Effect<never, never, ParentCacheDriver<never, T>> =>
+): Effect.Effect<ParentCacheDriver<never, T>> =>
   Effect.sync(() => {
     const store = make<T>(opts)
     const parentIds = new Map<string, Set<string>>()
@@ -204,7 +204,7 @@ export const createWithParent = <T>(
           const ids = parentIds.get(parentId)
           parentIds.delete(parentId)
 
-          const effects: Array<Effect.Effect<never, never, void>> = []
+          const effects: Array<Effect.Effect<void>> = []
           if (ids) {
             ids.forEach(id => {
               effects.push(store.delete(id))
@@ -218,5 +218,5 @@ export const createWithParent = <T>(
         }),
 
       run: store.run,
-    })
+    });
   })

package/src/Cache/prelude.ts

@@ -18,15 +18,11 @@ import type * as Discord from "dfx/types"
 
 export interface OptsWithParentOptions<E, A> {
   readonly id: (a: A) => string
-  readonly fromParent: Stream.Stream<
-    never,
-    E,
-    [parentId: string, resources: Array<A>]
-  >
-  readonly create: Stream.Stream<never, E, [parentId: string, resource: A]>
-  readonly update: Stream.Stream<never, E, [parentId: string, resource: A]>
-  readonly remove: Stream.Stream<never, E, [parentId: string, id: string]>
-  readonly parentRemove: Stream.Stream<never, E, string>
+  readonly fromParent: Stream.Stream<[parentId: string, resources: Array<A>], E>
+  readonly create: Stream.Stream<[parentId: string, resource: A], E>
+  readonly update: Stream.Stream<[parentId: string, resource: A], E>
+  readonly remove: Stream.Stream<[parentId: string, id: string], E>
+  readonly parentRemove: Stream.Stream<string, E>
 }
 
 export const opsWithParent = <E, T>({
@@ -36,7 +32,7 @@ export const opsWithParent = <E, T>({
   parentRemove,
   remove,
   update,
-}: OptsWithParentOptions<E, T>): Stream.Stream<never, E, ParentCacheOp<T>> => {
+}: OptsWithParentOptions<E, T>): Stream.Stream<ParentCacheOp<T>, E> => {
   const fromParentOps = Stream.flatMap(fromParent, ([parentId, a]) =>
     Stream.fromIterable(
       a.map(
@@ -96,9 +92,9 @@ export const opsWithParent = <E, T>({
 
 export interface OpsOptions<E, A> {
   id: (a: A) => string
-  create: Stream.Stream<never, E, A>
-  update: Stream.Stream<never, E, A>
-  remove: Stream.Stream<never, E, string>
+  create: Stream.Stream<A, E>
+  update: Stream.Stream<A, E>
+  remove: Stream.Stream<string, E>
 }
 
 export const ops = <E, T>({
@@ -106,7 +102,7 @@ export const ops = <E, T>({
   id,
   remove,
   update,
-}: OpsOptions<E, T>): Stream.Stream<never, E, CacheOp<T>> => {
+}: OpsOptions<E, T>): Stream.Stream<CacheOp<T>, E> => {
   const createOps = Stream.map(
     create,
     (resource): CacheOp<T> => ({
@@ -137,11 +133,11 @@ export const ops = <E, T>({
 }
 
 export const guilds = <RM, EM, E>(
-  makeDriver: Effect.Effect<RM, EM, CacheDriver<E, Discord.Guild>>,
+  makeDriver: Effect.Effect<CacheDriver<E, Discord.Guild>, EM, RM>,
 ): Effect.Effect<
-  RM | DiscordGateway | DiscordREST | Scope.Scope,
+  Cache<E, ResponseError | DiscordRESTError, Discord.Guild>,
   EM,
-  Cache<E, ResponseError | DiscordRESTError, Discord.Guild>
+  RM | DiscordGateway | DiscordREST | Scope.Scope
 > =>
   Effect.gen(function* (_) {
     const driver = yield* _(makeDriver)
@@ -170,16 +166,16 @@ export const guilds = <RM, EM, E>(
   })
 
 export const channels = <RM, EM, E>(
-  makeDriver: Effect.Effect<RM, EM, ParentCacheDriver<E, Discord.Channel>>,
+  makeDriver: Effect.Effect<ParentCacheDriver<E, Discord.Channel>, EM, RM>,
 ): Effect.Effect<
-  DiscordGateway | DiscordREST | RM | Scope.Scope,
-  EM,
   ParentCache<
     E,
     ResponseError | DiscordRESTError,
     ResponseError | DiscordRESTError,
     Discord.Channel
-  >
+  >,
+  EM,
+  DiscordGateway | DiscordREST | RM | Scope.Scope
 > =>
   Effect.gen(function* (_) {
     const driver = yield* _(makeDriver)
@@ -224,11 +220,16 @@ export const channels = <RM, EM, E>(
   })
 
 export const roles = <RM, EM, E>(
-  makeDriver: Effect.Effect<RM, EM, ParentCacheDriver<E, Discord.Role>>,
+  makeDriver: Effect.Effect<ParentCacheDriver<E, Discord.Role>, EM, RM>,
 ): Effect.Effect<
-  DiscordGateway | DiscordREST | RM | Scope.Scope,
+  ParentCache<
+    E,
+    CacheMissError,
+    ResponseError | DiscordRESTError,
+    Discord.Role
+  >,
   EM,
-  ParentCache<E, CacheMissError, ResponseError | DiscordRESTError, Discord.Role>
+  DiscordGateway | DiscordREST | RM | Scope.Scope
 > =>
   Effect.gen(function* (_) {
     const driver = yield* _(makeDriver)

package/src/Cache.ts

@@ -34,36 +34,36 @@ export interface ParentCache<EDriver, EMiss, EPMiss, A> {
   readonly get: (
     parentId: string,
     id: string,
-  ) => Effect.Effect<never, EDriver | EMiss, A>
-  readonly put: (_: A) => Effect.Effect<never, EDriver | EMiss, void>
+  ) => Effect.Effect<A, EDriver | EMiss>
+  readonly put: (_: A) => Effect.Effect<void, EDriver | EMiss>
   readonly update: <R, E>(
     parentId: string,
     id: string,
-    f: (_: A) => Effect.Effect<R, E, A>,
-  ) => Effect.Effect<R, EDriver | EMiss | E, A>
+    f: (_: A) => Effect.Effect<A, E, R>,
+  ) => Effect.Effect<A, EDriver | EMiss | E, R>
   readonly getForParent: (
     parentId: string,
-  ) => Effect.Effect<never, EDriver | EPMiss, ReadonlyMap<string, A>>
-  readonly size: Effect.Effect<never, EDriver, number>
+  ) => Effect.Effect<ReadonlyMap<string, A>, EDriver | EPMiss>
+  readonly size: Effect.Effect<number, EDriver>
   readonly sizeForParent: (
     parentId: string,
-  ) => Effect.Effect<never, EDriver, number>
+  ) => Effect.Effect<number, EDriver>
   readonly set: (
     parentId: string,
     resourceId: string,
     resource: A,
-  ) => Effect.Effect<never, EDriver, void>
+  ) => Effect.Effect<void, EDriver>
   readonly delete: (
     parentId: string,
     resourceId: string,
-  ) => Effect.Effect<never, EDriver, void>
+  ) => Effect.Effect<void, EDriver>
   readonly parentDelete: (
     parentId: string,
-  ) => Effect.Effect<never, EDriver, void>
+  ) => Effect.Effect<void, EDriver>
   readonly refreshTTL: (
     parentId: string,
     resourceId: string,
-  ) => Effect.Effect<never, EDriver, void>
+  ) => Effect.Effect<void, EDriver>
 }
 
 export const makeWithParent = <EOps, EDriver, EMiss, EPMiss, A>({
@@ -74,19 +74,19 @@ export const makeWithParent = <EOps, EDriver, EMiss, EPMiss, A>({
   ops = Stream.empty,
 }: {
   driver: ParentCacheDriver<EDriver, A>
-  ops?: Stream.Stream<never, EOps, ParentCacheOp<A>>
+  ops?: Stream.Stream<ParentCacheOp<A>, EOps>
   id: (
     _: A,
-  ) => Effect.Effect<never, EMiss, readonly [parentId: string, id: string]>
-  onMiss: (parentId: string, id: string) => Effect.Effect<never, EMiss, A>
+  ) => Effect.Effect<readonly [parentId: string, id: string], EMiss>
+  onMiss: (parentId: string, id: string) => Effect.Effect<A, EMiss>
   onParentMiss: (
     parentId: string,
-  ) => Effect.Effect<never, EPMiss, Array<[id: string, resource: A]>>
-}): Effect.Effect<Scope.Scope, never, ParentCache<EDriver, EMiss, EPMiss, A>> =>
+  ) => Effect.Effect<Array<[id: string, resource: A]>, EPMiss>
+}): Effect.Effect<ParentCache<EDriver, EMiss, EPMiss, A>, never, Scope.Scope> =>
   Effect.gen(function* (_) {
     yield* _(
       Stream.runDrain(
-        Stream.tap(ops, (op): Effect.Effect<never, EDriver, void> => {
+        Stream.tap(ops, (op): Effect.Effect<void, EDriver> => {
           switch (op.op) {
             case "create":
             case "update":
@@ -129,7 +129,7 @@ export const makeWithParent = <EOps, EDriver, EMiss, EPMiss, A>({
     const update = <R, E>(
       parentId: string,
       id: string,
-      f: (_: A) => Effect.Effect<R, E, A>,
+      f: (_: A) => Effect.Effect<A, E, R>,
     ) =>
       get(parentId, id).pipe(
         Effect.flatMap(f),
@@ -171,21 +171,21 @@ export const makeWithParent = <EOps, EDriver, EMiss, EPMiss, A>({
   )
 
 export interface Cache<EDriver, EMiss, A> {
-  readonly get: (id: string) => Effect.Effect<never, EDriver | EMiss, A>
-  readonly put: (_: A) => Effect.Effect<never, EDriver, void>
+  readonly get: (id: string) => Effect.Effect<A, EDriver | EMiss>
+  readonly put: (_: A) => Effect.Effect<void, EDriver>
   readonly update: <R, E>(
     id: string,
-    f: (_: A) => Effect.Effect<R, E, A>,
-  ) => Effect.Effect<R, EDriver | EMiss | E, A>
-  readonly size: Effect.Effect<never, EDriver, number>
+    f: (_: A) => Effect.Effect<A, E, R>,
+  ) => Effect.Effect<A, EDriver | EMiss | E, R>
+  readonly size: Effect.Effect<number, EDriver>
   readonly set: (
     resourceId: string,
     resource: A,
-  ) => Effect.Effect<never, EDriver, void>
-  readonly delete: (resourceId: string) => Effect.Effect<never, EDriver, void>
+  ) => Effect.Effect<void, EDriver>
+  readonly delete: (resourceId: string) => Effect.Effect<void, EDriver>
   readonly refreshTTL: (
     resourceId: string,
-  ) => Effect.Effect<never, EDriver, void>
+  ) => Effect.Effect<void, EDriver>
 }
 
 export const make = <EOps, EDriver, EMiss, A>({
@@ -195,14 +195,14 @@ export const make = <EOps, EDriver, EMiss, A>({
   ops = Stream.empty,
 }: {
   driver: CacheDriver<EDriver, A>
-  ops?: Stream.Stream<never, EOps, CacheOp<A>>
+  ops?: Stream.Stream<CacheOp<A>, EOps>
   id: (_: A) => string
-  onMiss: (id: string) => Effect.Effect<never, EMiss, A>
-}): Effect.Effect<Scope.Scope, never, Cache<EDriver, EMiss, A>> =>
+  onMiss: (id: string) => Effect.Effect<A, EMiss>
+}): Effect.Effect<Cache<EDriver, EMiss, A>, never, Scope.Scope> =>
   Effect.gen(function* (_) {
     yield* _(
       Stream.runDrain(
-        Stream.tap(ops, (op): Effect.Effect<never, EDriver, void> => {
+        Stream.tap(ops, (op): Effect.Effect<void, EDriver> => {
           switch (op.op) {
             case "create":
             case "update":
@@ -238,7 +238,7 @@ export const make = <EOps, EDriver, EMiss, A>({
 
     const put = (_: A) => driver.set(id(_), _)
 
-    const update = <R, E>(id: string, f: (_: A) => Effect.Effect<R, E, A>) =>
+    const update = <R, E>(id: string, f: (_: A) => Effect.Effect<A, E, R>) =>
       get(id).pipe(
         Effect.flatMap(f),
         Effect.tap(_ => driver.set(id, _)),

package/src/DiscordConfig.ts

@@ -1,4 +1,4 @@
-import { Tag } from "effect/Context"
+import { GenericTag } from "effect/Context"
 import * as Duration from "effect/Duration"
 import * as Config from "effect/Config"
 import type * as ConfigError from "effect/ConfigError"
@@ -30,7 +30,7 @@ export interface DiscordConfigService {
     readonly identifyRateLimit: readonly [window: number, limit: number]
   }
 }
-export const DiscordConfig = Tag<DiscordConfig, DiscordConfigService>(
+export const DiscordConfig = GenericTag<DiscordConfig, DiscordConfigService>(
   "dfx/DiscordConfig",
 )
 
@@ -64,10 +64,10 @@ export const make = ({
 
 export const layer = (
   opts: MakeOpts,
-): Layer.Layer<never, never, DiscordConfig> =>
+): Layer.Layer<DiscordConfig> =>
   Layer.succeed(DiscordConfig, make(opts))
 
 export const layerConfig = (
   _: Config.Config.Wrap<MakeOpts>,
-): Layer.Layer<never, ConfigError.ConfigError, DiscordConfig> =>
+): Layer.Layer<DiscordConfig, ConfigError.ConfigError> =>
   Layer.effect(DiscordConfig, Effect.map(Config.unwrap(_), make))

package/src/DiscordGateway/DiscordWS.ts

@@ -1,4 +1,4 @@
-import { Tag } from "effect/Context"
+import { GenericTag } from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
 import * as Ref from "effect/Ref"
@@ -12,8 +12,8 @@ export interface OpenOpts {
   url?: string
   version?: number
   encoding?: DiscordWSCodec
-  outbound: Effect.Effect<never, never, Message>
-  onConnecting?: Effect.Effect<never, never, void>
+  outbound: Effect.Effect<Message>
+  onConnecting?: Effect.Effect<void>
 }
 
 export interface DiscordWSCodecService {
@@ -24,7 +24,7 @@ export interface DiscordWSCodecService {
 export interface DiscordWSCodec {
   readonly _: unique symbol
 }
-export const DiscordWSCodec = Tag<DiscordWSCodec, DiscordWSCodecService>(
+export const DiscordWSCodec = GenericTag<DiscordWSCodec, DiscordWSCodecService>(
   "dfx/DiscordGateway/DiscordWS/Codec",
 )
 export const JsonDiscordWSCodecLive = Layer.succeed(DiscordWSCodec, {
@@ -76,7 +76,7 @@ const make = Effect.gen(function* (_) {
 export interface DiscordWS {
   readonly _: unique symbol
 }
-export const DiscordWS = Tag<DiscordWS, Effect.Effect.Success<typeof make>>(
+export const DiscordWS = GenericTag<DiscordWS, Effect.Effect.Success<typeof make>>(
   "dfx/DiscordGateway/DiscordWS",
 )
 export const DiscordWSLive = Layer.provide(

package/src/DiscordGateway/Messaging.ts

@@ -1,4 +1,4 @@
-import { Tag } from "effect/Context"
+import { GenericTag } from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as PubSub from "effect/PubSub"
 import * as Layer from "effect/Layer"
@@ -9,11 +9,11 @@ import * as EffectUtils from "dfx/utils/Effect"
 
 const fromDispatchFactory =
   <R, E>(
-    source: Stream.Stream<R, E, Discord.GatewayPayload<Discord.ReceiveEvent>>,
+    source: Stream.Stream<Discord.GatewayPayload<Discord.ReceiveEvent>, E, R>,
   ) =>
   <K extends keyof Discord.ReceiveEvents>(
     event: K,
-  ): Stream.Stream<R, E, Discord.ReceiveEvents[K]> =>
+  ): Stream.Stream<Discord.ReceiveEvents[K], E, R> =>
     Stream.map(
       Stream.filter(source, p => p.t === event),
       p => p.d! as any,
@@ -23,8 +23,8 @@ const handleDispatchFactory =
   (hub: PubSub.PubSub<Discord.GatewayPayload<Discord.ReceiveEvent>>) =>
   <K extends keyof Discord.ReceiveEvents, R, E, A>(
     event: K,
-    handle: (event: Discord.ReceiveEvents[K]) => Effect.Effect<R, E, A>,
-  ): Effect.Effect<R, E, never> =>
+    handle: (event: Discord.ReceiveEvents[K]) => Effect.Effect<A, E, R>,
+  ): Effect.Effect<never, E, R> =>
     EffectUtils.subscribeForEachPar(hub, _ => {
       if (_.t === event) {
         return handle(_.d as any)
@@ -66,7 +66,8 @@ export const make = Effect.gen(function* (_) {
 export interface Messsaging {
   readonly _: unique symbol
 }
-export const Messaging = Tag<Messsaging, Effect.Effect.Success<typeof make>>(
-  "dfx/DiscordGateway/Messaging",
-)
+export const Messaging = GenericTag<
+  Messsaging,
+  Effect.Effect.Success<typeof make>
+>("dfx/DiscordGateway/Messaging")
 export const MesssagingLive = Layer.scoped(Messaging, make)

package/src/DiscordGateway/Shard/heartbeats.ts

@@ -21,7 +21,7 @@ const payloadOrReconnect = (
 ) =>
   Effect.flatMap(
     Ref.get(ref),
-    (acked): Effect.Effect<never, never, DiscordWS.Message> =>
+    (acked): Effect.Effect<DiscordWS.Message> =>
       acked ? payload(seqRef) : Effect.succeed(Reconnect),
   )
 
@@ -29,7 +29,7 @@ export const send = (
   hellos: Queue.Dequeue<Discord.GatewayPayload>,
   acks: Queue.Dequeue<Discord.GatewayPayload>,
   seqRef: Ref.Ref<Option.Option<number>>,
-  send: (p: DiscordWS.Message) => Effect.Effect<never, never, boolean>,
+  send: (p: DiscordWS.Message) => Effect.Effect<boolean>,
 ) =>
   Effect.flatMap(Ref.make(true), ackedRef => {
     const heartbeats = EffectU.foreverSwitch(

package/src/DiscordGateway/Shard/identify.ts

@@ -41,12 +41,8 @@ export const identifyOrResume = (
   opts: Options,
   ready: Ref.Ref<Option.Option<Discord.ReadyEvent>>,
   seq: Ref.Ref<Option.Option<number>>,
-): Effect.Effect<
-  never,
-  never,
-  | Discord.GatewayPayload<Discord.Identify>
-  | Discord.GatewayPayload<Discord.Resume>
-> =>
+): Effect.Effect<| Discord.GatewayPayload<Discord.Identify>
+| Discord.GatewayPayload<Discord.Resume>> =>
   Effect.map(
     Effect.all([Ref.get(ready), Ref.get(seq)]),
     ([readyEvent, seqNumber]) =>

package/src/DiscordGateway/Shard/invalidSession.ts

@@ -8,5 +8,5 @@ import type * as Discord from "dfx/types"
 export const fromPayload = (
   p: Discord.GatewayPayload,
   latestReady: Ref.Ref<Option.Option<Discord.ReadyEvent>>,
-): Effect.Effect<never, never, Message> =>
+): Effect.Effect<Message> =>
   Effect.as(p.d ? Effect.unit : Ref.set(latestReady, Option.none()), Reconnect)

package/src/DiscordGateway/Shard/utils.ts

@@ -5,10 +5,10 @@ import * as Stream from "effect/Stream"
 import type * as Discord from "dfx/types"
 
 export const opCode =
-  <R, E>(source: Stream.Stream<R, E, Discord.GatewayPayload>) =>
+  <R, E>(source: Stream.Stream<Discord.GatewayPayload, E, R>) =>
   <T = any>(
     code: Discord.GatewayOpcode,
-  ): Stream.Stream<R, E, Discord.GatewayPayload<T>> =>
+  ): Stream.Stream<Discord.GatewayPayload<T>, E, R> =>
     source.pipe(
       Stream.filter((p): p is Discord.GatewayPayload<T> => p.op === code),
     )
@@ -18,7 +18,7 @@ const maybeUpdateRef =
     f: (p: Discord.GatewayPayload) => Option.Option<T>,
     ref: Ref.Ref<Option.Option<T>>,
   ) =>
-  (_: Discord.GatewayPayload): Effect.Effect<never, never, void> =>
+  (_: Discord.GatewayPayload): Effect.Effect<void> =>
     Option.match(f(_), {
       onNone: () => Effect.unit,
       onSome: a => Ref.set(ref, Option.some(a)),
@@ -26,14 +26,10 @@ const maybeUpdateRef =
 
 export const latest = <T>(
   f: (p: Discord.GatewayPayload) => Option.Option<T>,
-): Effect.Effect<
-  never,
-  never,
-  readonly [
-    Ref.Ref<Option.Option<T>>,
-    (_: Discord.GatewayPayload<any>) => Effect.Effect<never, never, void>,
-  ]
-> =>
+): Effect.Effect<readonly [
+  Ref.Ref<Option.Option<T>>,
+  (_: Discord.GatewayPayload<any>) => Effect.Effect<void>,
+]> =>
   Effect.map(
     Ref.make<Option.Option<T>>(Option.none()),
     ref => [ref, maybeUpdateRef(f, ref)] as const,

package/src/DiscordGateway/Shard.ts

@@ -1,5 +1,5 @@
 import * as Chunk from "effect/Chunk"
-import { Tag } from "effect/Context"
+import { GenericTag } from "effect/Context"
 import * as Duration from "effect/Duration"
 import { pipe } from "effect/Function"
 import * as Option from "effect/Option"
@@ -207,7 +207,7 @@ type ShardService = Effect.Effect.Success<typeof make>
 export interface Shard {
   readonly _: unique symbol
 }
-export const Shard = Tag<Shard, ShardService>("dfx/DiscordGateway/Shard")
+export const Shard = GenericTag<Shard, ShardService>("dfx/DiscordGateway/Shard")
 export const ShardLive = Layer.effect(Shard, make).pipe(
   Layer.provide(DiscordWSLive),
   Layer.provide(MesssagingLive),

package/src/DiscordGateway/ShardStore.ts

@@ -1,4 +1,4 @@
-import { Tag } from "effect/Context"
+import { GenericTag } from "effect/Context"
 import * as Option from "effect/Option"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
@@ -11,14 +11,14 @@ export interface ClaimIdContext {
 export interface ShardStoreService {
   claimId: (
     ctx: ClaimIdContext,
-  ) => Effect.Effect<never, never, Option.Option<number>>
-  allClaimed: (totalCount: number) => Effect.Effect<never, never, boolean>
-  heartbeat?: (shardId: number) => Effect.Effect<never, never, void>
+  ) => Effect.Effect<Option.Option<number>>
+  allClaimed: (totalCount: number) => Effect.Effect<boolean>
+  heartbeat?: (shardId: number) => Effect.Effect<void>
 }
 export interface ShardStore {
   readonly _: unique symbol
 }
-export const ShardStore = Tag<ShardStore, ShardStoreService>(
+export const ShardStore = GenericTag<ShardStore, ShardStoreService>(
   "dfx/DiscordGateway/ShardStore",
 )
 

package/src/DiscordGateway/Sharder.ts

@@ -5,7 +5,7 @@ import { ShardStore } from "dfx/DiscordGateway/ShardStore"
 import { DiscordREST, DiscordRESTLive } from "dfx/DiscordREST"
 import { RateLimiter, RateLimiterLive } from "dfx/RateLimit"
 import type * as Discord from "dfx/types"
-import { Tag } from "effect/Context"
+import { GenericTag } from "effect/Context"
 import * as Duration from "effect/Duration"
 import * as Effect from "effect/Effect"
 import { pipe } from "effect/Function"
@@ -47,7 +47,7 @@ const make = Effect.gen(function* (_) {
 
   const totalCount = config.shardCount ?? gateway.shards
   const currentCount = yield* _(Ref.make(0))
-  const claimId = (sharderCount: number): Effect.Effect<never, never, number> =>
+  const claimId = (sharderCount: number): Effect.Effect<number> =>
     pipe(
       store.claimId({
         totalCount,
@@ -59,7 +59,10 @@ const make = Effect.gen(function* (_) {
   const takeConfig = pipe(
     Ref.getAndUpdate(currentCount, _ => _ + 1),
     Effect.flatMap(claimId),
-    Effect.map(id => ({ id, totalCount }) as const),
+    Effect.map(id => (({
+      id,
+      totalCount
+    }) as const)),
   )
 
   const spawner = pipe(
@@ -105,7 +108,7 @@ const make = Effect.gen(function* (_) {
 export interface Sharder {
   readonly _: unique symbol
 }
-export const Sharder = Tag<Sharder, Effect.Effect.Success<typeof make>>(
+export const Sharder = GenericTag<Sharder, Effect.Effect.Success<typeof make>>(
   "dfx/DiscordGateway/Sharder",
 )
 export const SharderLive = Layer.scoped(Sharder, make).pipe(