dfx 0.93.0 → 0.95.0

package/src/Cache/prelude.ts

@@ -139,30 +139,28 @@ export const guilds = <RM, EM, E>(
   EM,
   RM | DiscordGateway | DiscordREST | Scope.Scope
 > =>
-  Effect.gen(function* (_) {
-    const driver = yield* _(makeDriver)
-    const gateway = yield* _(DiscordGateway)
-    const rest = yield* _(DiscordREST)
+  Effect.gen(function* () {
+    const driver = yield* makeDriver
+    const gateway = yield* DiscordGateway
+    const rest = yield* DiscordREST
 
-    return yield* _(
-      make({
-        driver,
-        id: _ => _.id,
-        ops: ops({
-          id: (g: Discord.Guild) => g.id,
-          create: Stream.map(gateway.fromDispatch("GUILD_CREATE"), g => ({
-            ...g,
-            channels: [],
-            roles: [],
-            emojis: [],
-            members: [],
-          })),
-          update: gateway.fromDispatch("GUILD_UPDATE"),
-          remove: Stream.map(gateway.fromDispatch("GUILD_DELETE"), a => a.id),
-        }),
-        onMiss: id => rest.getGuild(id).json,
+    return yield* make({
+      driver,
+      id: _ => _.id,
+      ops: ops({
+        id: (g: Discord.Guild) => g.id,
+        create: Stream.map(gateway.fromDispatch("GUILD_CREATE"), g => ({
+          ...g,
+          channels: [],
+          roles: [],
+          emojis: [],
+          members: [],
+        })),
+        update: gateway.fromDispatch("GUILD_UPDATE"),
+        remove: Stream.map(gateway.fromDispatch("GUILD_DELETE"), a => a.id),
       }),
-    )
+      onMiss: id => rest.getGuild(id).json,
+    })
   })
 
 export const channels = <RM, EM, E>(
@@ -177,45 +175,43 @@ export const channels = <RM, EM, E>(
   EM,
   DiscordGateway | DiscordREST | RM | Scope.Scope
 > =>
-  Effect.gen(function* (_) {
-    const driver = yield* _(makeDriver)
-    const gateway = yield* _(DiscordGateway)
-    const rest = yield* _(DiscordREST)
+  Effect.gen(function* () {
+    const driver = yield* makeDriver
+    const gateway = yield* DiscordGateway
+    const rest = yield* DiscordREST
 
-    return yield* _(
-      makeWithParent({
-        driver,
-        id: _ => Effect.succeed([_.guild_id!, _.id]),
-        ops: opsWithParent({
-          id: (a: Discord.Channel) => a.id,
-          fromParent: Stream.map(gateway.fromDispatch("GUILD_CREATE"), g => [
-            g.id,
-            g.channels.concat(g.threads),
-          ]),
-          create: Stream.merge(
-            gateway.fromDispatch("CHANNEL_CREATE"),
-            gateway.fromDispatch("THREAD_CREATE"),
-          ).pipe(Stream.map(c => [c.guild_id!, c])),
-          update: Stream.merge(
-            gateway.fromDispatch("CHANNEL_UPDATE"),
-            gateway.fromDispatch("THREAD_UPDATE"),
-          ).pipe(Stream.map(c => [c.guild_id!, c])),
-          remove: Stream.merge(
-            gateway.fromDispatch("CHANNEL_DELETE"),
-            gateway.fromDispatch("THREAD_DELETE"),
-          ).pipe(Stream.map(a => [a.guild_id!, a.id])),
-          parentRemove: Stream.map(
-            gateway.fromDispatch("GUILD_DELETE"),
-            g => g.id,
-          ),
-        }),
-        onMiss: (_, id) => rest.getChannel(id).json,
-        onParentMiss: guildId =>
-          rest
-            .getGuildChannels(guildId)
-            .json.pipe(Effect.map(a => a.map(a => [a.id, a]))),
+    return yield* makeWithParent({
+      driver,
+      id: _ => Effect.succeed([_.guild_id!, _.id]),
+      ops: opsWithParent({
+        id: (a: Discord.Channel) => a.id,
+        fromParent: Stream.map(gateway.fromDispatch("GUILD_CREATE"), g => [
+          g.id,
+          g.channels.concat(g.threads),
+        ]),
+        create: Stream.merge(
+          gateway.fromDispatch("CHANNEL_CREATE"),
+          gateway.fromDispatch("THREAD_CREATE"),
+        ).pipe(Stream.map(c => [c.guild_id!, c])),
+        update: Stream.merge(
+          gateway.fromDispatch("CHANNEL_UPDATE"),
+          gateway.fromDispatch("THREAD_UPDATE"),
+        ).pipe(Stream.map(c => [c.guild_id!, c])),
+        remove: Stream.merge(
+          gateway.fromDispatch("CHANNEL_DELETE"),
+          gateway.fromDispatch("THREAD_DELETE"),
+        ).pipe(Stream.map(a => [a.guild_id!, a.id])),
+        parentRemove: Stream.map(
+          gateway.fromDispatch("GUILD_DELETE"),
+          g => g.id,
+        ),
       }),
-    )
+      onMiss: (_, id) => rest.getChannel(id).json,
+      onParentMiss: guildId =>
+        rest
+          .getGuildChannels(guildId)
+          .json.pipe(Effect.map(a => a.map(a => [a.id, a]))),
+    })
   })
 
 export const roles = <RM, EM, E>(
@@ -230,47 +226,45 @@ export const roles = <RM, EM, E>(
   EM,
   DiscordGateway | DiscordREST | RM | Scope.Scope
 > =>
-  Effect.gen(function* (_) {
-    const driver = yield* _(makeDriver)
-    const gateway = yield* _(DiscordGateway)
-    const rest = yield* _(DiscordREST)
+  Effect.gen(function* () {
+    const driver = yield* makeDriver
+    const gateway = yield* DiscordGateway
+    const rest = yield* DiscordREST
 
-    return yield* _(
-      makeWithParent({
-        driver,
-        id: _ =>
-          Effect.fail(
-            new CacheMissError({ cacheName: "RolesCache/id", id: _.id }),
-          ),
-        ops: opsWithParent({
-          id: (a: Discord.Role) => a.id,
-          fromParent: Stream.map(gateway.fromDispatch("GUILD_CREATE"), g => [
-            g.id,
-            g.roles,
-          ]),
-          create: Stream.map(gateway.fromDispatch("GUILD_ROLE_CREATE"), r => [
-            r.guild_id,
-            r.role,
-          ]),
-          update: Stream.map(gateway.fromDispatch("GUILD_ROLE_UPDATE"), r => [
-            r.guild_id,
-            r.role,
-          ]),
-          remove: Stream.map(gateway.fromDispatch("GUILD_ROLE_DELETE"), r => [
-            r.guild_id,
-            r.role_id,
-          ]),
-          parentRemove: Stream.map(
-            gateway.fromDispatch("GUILD_DELETE"),
-            g => g.id,
-          ),
-        }),
-        onMiss: (_, id) =>
-          Effect.fail(new CacheMissError({ cacheName: "RolesCache", id })),
-        onParentMiss: guildId =>
-          rest
-            .getGuildRoles(guildId)
-            .json.pipe(Effect.map(_ => _.map(role => [role.id, role]))),
+    return yield* makeWithParent({
+      driver,
+      id: _ =>
+        Effect.fail(
+          new CacheMissError({ cacheName: "RolesCache/id", id: _.id }),
+        ),
+      ops: opsWithParent({
+        id: (a: Discord.Role) => a.id,
+        fromParent: Stream.map(gateway.fromDispatch("GUILD_CREATE"), g => [
+          g.id,
+          g.roles,
+        ]),
+        create: Stream.map(gateway.fromDispatch("GUILD_ROLE_CREATE"), r => [
+          r.guild_id,
+          r.role,
+        ]),
+        update: Stream.map(gateway.fromDispatch("GUILD_ROLE_UPDATE"), r => [
+          r.guild_id,
+          r.role,
+        ]),
+        remove: Stream.map(gateway.fromDispatch("GUILD_ROLE_DELETE"), r => [
+          r.guild_id,
+          r.role_id,
+        ]),
+        parentRemove: Stream.map(
+          gateway.fromDispatch("GUILD_DELETE"),
+          g => g.id,
+        ),
       }),
-    )
+      onMiss: (_, id) =>
+        Effect.fail(new CacheMissError({ cacheName: "RolesCache", id })),
+      onParentMiss: guildId =>
+        rest
+          .getGuildRoles(guildId)
+          .json.pipe(Effect.map(_ => _.map(role => [role.id, role]))),
+    })
   })

package/src/Cache.ts

@@ -78,30 +78,28 @@ export const makeWithParent = <EOps, EDriver, EMiss, EPMiss, A>({
     parentId: string,
   ) => 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<void, EDriver> => {
-          switch (op.op) {
-            case "create":
-            case "update":
-              return driver.set(op.parentId, op.resourceId, op.resource)
+  Effect.gen(function* () {
+    yield Stream.runDrain(
+      Stream.tap(ops, (op): Effect.Effect<void, EDriver> => {
+        switch (op.op) {
+          case "create":
+          case "update":
+            return driver.set(op.parentId, op.resourceId, op.resource)
 
-            case "delete":
-              return driver.delete(op.parentId, op.resourceId)
+          case "delete":
+            return driver.delete(op.parentId, op.resourceId)
 
-            case "parentDelete":
-              return driver.parentDelete(op.parentId)
-          }
-        }),
-      ),
+          case "parentDelete":
+            return driver.parentDelete(op.parentId)
+        }
+      }),
+    ).pipe(
       Effect.tapErrorCause(_ => Effect.logError("ops error, restarting", _)),
       Effect.retry(retryPolicy),
       Effect.forkScoped,
       Effect.interruptible,
     )
-    yield* _(
-      driver.run,
+    yield driver.run.pipe(
       Effect.tapErrorCause(_ =>
         Effect.logError("cache driver error, restarting", _),
       ),
@@ -194,28 +192,26 @@ export const make = <EOps, EDriver, EMiss, A>({
   id: (_: A) => string
   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<void, EDriver> => {
-          switch (op.op) {
-            case "create":
-            case "update":
-              return driver.set(op.resourceId, op.resource)
+  Effect.gen(function* () {
+    yield Stream.runDrain(
+      Stream.tap(ops, (op): Effect.Effect<void, EDriver> => {
+        switch (op.op) {
+          case "create":
+          case "update":
+            return driver.set(op.resourceId, op.resource)
 
-            case "delete":
-              return driver.delete(op.resourceId)
-          }
-        }),
-      ),
+          case "delete":
+            return driver.delete(op.resourceId)
+        }
+      }),
+    ).pipe(
       Effect.tapErrorCause(_ => Effect.logError("ops error, restarting", _)),
       Effect.retry(retryPolicy),
       Effect.forkScoped,
       Effect.interruptible,
     )
 
-    yield* _(
-      driver.run,
+    yield driver.run.pipe(
       Effect.tapErrorCause(_ =>
         Effect.logError("cache driver error, restarting", _),
       ),

package/src/DiscordGateway/DiscordWS.ts

@@ -40,8 +40,8 @@ export const JsonDiscordWSCodecLive = Layer.succeed(DiscordWSCodec, {
   decode: p => JSON.parse(typeof p === "string" ? p : decoder.decode(p)),
 })
 
-const make = Effect.gen(function* (_) {
-  const encoding = yield* _(DiscordWSCodec)
+const make = Effect.gen(function* () {
+  const encoding = yield* DiscordWSCodec
 
   const connect = ({
     onConnecting,
@@ -49,22 +49,19 @@ const make = Effect.gen(function* (_) {
     url = "wss://gateway.discord.gg/",
     version = 10,
   }: OpenOpts) =>
-    Effect.gen(function* (_) {
-      const urlRef = yield* _(
-        Ref.make(`${url}?v=${version}&encoding=${encoding.type}`),
+    Effect.gen(function* () {
+      const urlRef = yield* Ref.make(
+        `${url}?v=${version}&encoding=${encoding.type}`,
       )
       const setUrl = (url: string) =>
         Ref.set(urlRef, `${url}?v=${version}&encoding=${encoding.type}`)
-      const messages = yield* _(Queue.unbounded<Discord.GatewayPayload>())
-      const socket = yield* _(
-        Socket.makeWebSocket(Ref.get(urlRef), {
-          closeCodeIsError: _ => true,
-          openTimeout: 5000,
-        }),
-      )
-      const write = yield* _(socket.writer)
-      yield* _(
-        outbound,
+      const messages = yield* Queue.unbounded<Discord.GatewayPayload>()
+      const socket = yield* Socket.makeWebSocket(Ref.get(urlRef), {
+        closeCodeIsError: _ => true,
+        openTimeout: 5000,
+      })
+      const write = yield* socket.writer
+      yield outbound.pipe(
         Effect.flatMap(_ => {
           if (_ === Reconnect) {
             return Effect.zipRight(
@@ -79,8 +76,7 @@ const make = Effect.gen(function* (_) {
         Effect.forkScoped,
         Effect.interruptible,
       )
-      yield* _(
-        onConnecting,
+      yield onConnecting.pipe(
         Effect.zipRight(
           socket.runRaw(_ => {
             const message = encoding.decode(_)

package/src/DiscordGateway/Messaging.ts

@@ -32,19 +32,15 @@ const handleDispatchFactory =
       return Effect.void as any
     })
 
-export const make = Effect.gen(function* (_) {
-  const hub = yield* _(
-    Effect.acquireRelease(
-      PubSub.unbounded<Discord.GatewayPayload<Discord.ReceiveEvent>>(),
-      PubSub.shutdown,
-    ),
+export const make = Effect.gen(function* () {
+  const hub = yield* Effect.acquireRelease(
+    PubSub.unbounded<Discord.GatewayPayload<Discord.ReceiveEvent>>(),
+    PubSub.shutdown,
   )
 
-  const sendQueue = yield* _(
-    Effect.acquireRelease(
-      Queue.unbounded<Discord.GatewayPayload<Discord.SendEvent>>(),
-      Queue.shutdown,
-    ),
+  const sendQueue = yield* Effect.acquireRelease(
+    Queue.unbounded<Discord.GatewayPayload<Discord.SendEvent>>(),
+    Queue.shutdown,
   )
   const send = (payload: Discord.GatewayPayload<Discord.SendEvent>) =>
     sendQueue.offer(payload)

package/src/DiscordGateway/Shard.ts

@@ -30,17 +30,17 @@ const enum Phase {
   Connected,
 }
 
-export const make = Effect.gen(function* (_) {
-  const { gateway, token } = yield* _(DiscordConfig)
-  const limiter = yield* _(RateLimiter)
-  const dws = yield* _(DiscordWS)
-  const { hub, sendQueue } = yield* _(Messaging)
+export const make = Effect.gen(function* () {
+  const { gateway, token } = yield* DiscordConfig
+  const limiter = yield* RateLimiter
+  const dws = yield* DiscordWS
+  const { hub, sendQueue } = yield* Messaging
 
   const connect = (shard: [id: number, count: number]) =>
-    Effect.gen(function* (_) {
-      const outboundQueue = yield* _(Queue.unbounded<Message>())
-      const pendingQueue = yield* _(Queue.unbounded<Message>())
-      const phase = yield* _(Ref.make(Phase.Connecting))
+    Effect.gen(function* () {
+      const outboundQueue = yield* Queue.unbounded<Message>()
+      const pendingQueue = yield* Queue.unbounded<Message>()
+      const phase = yield* Ref.make(Phase.Connecting)
       const setPhase = (p: Phase) =>
         Effect.zipLeft(
           Ref.set(phase, p),
@@ -92,7 +92,7 @@ export const make = Effect.gen(function* (_) {
         Effect.zipRight(setPhase(Phase.Connecting)),
       )
 
-      const socket = yield* _(dws.connect({ outbound, onConnecting }))
+      const socket = yield* dws.connect({ outbound, onConnecting })
 
       const isReady = Option.liftPredicate(
         (
@@ -101,11 +101,11 @@ export const make = Effect.gen(function* (_) {
           p.op === Discord.GatewayOpcode.DISPATCH && p.t === "READY",
       )
 
-      const [latestReady, updateLatestReady] = yield* _(
-        Utils.latest(p => Option.map(isReady(p), p => p.d!)),
+      const [latestReady, updateLatestReady] = yield* Utils.latest(p =>
+        Option.map(isReady(p), p => p.d!),
       )
-      const [latestSequence, updateLatestSequence] = yield* _(
-        Utils.latest(p => Option.fromNullable(p.s)),
+      const [latestSequence, updateLatestSequence] = yield* Utils.latest(p =>
+        Option.fromNullable(p.s),
       )
       const maybeUpdateUrl = (p: Discord.GatewayPayload) =>
         Option.match(
@@ -117,22 +117,17 @@ export const make = Effect.gen(function* (_) {
           },
         )
 
-      const hellos = yield* _(
-        Effect.acquireRelease(
-          Queue.unbounded<Discord.GatewayPayload>(),
-          Queue.shutdown,
-        ),
+      const hellos = yield* Effect.acquireRelease(
+        Queue.unbounded<Discord.GatewayPayload>(),
+        Queue.shutdown,
       )
-      const acks = yield* _(
-        Effect.acquireRelease(
-          Queue.unbounded<Discord.GatewayPayload>(),
-          Queue.shutdown,
-        ),
+      const acks = yield* Effect.acquireRelease(
+        Queue.unbounded<Discord.GatewayPayload>(),
+        Queue.shutdown,
       )
 
       // heartbeats
-      yield* _(
-        Heartbeats.send(hellos, acks, latestSequence, heartbeatSend),
+      yield Heartbeats.send(hellos, acks, latestSequence, heartbeatSend).pipe(
         Effect.forkScoped,
         Effect.interruptible,
       )
@@ -188,16 +183,14 @@ export const make = Effect.gen(function* (_) {
           }),
         )
 
-      yield* _(
-        Queue.take(sendQueue),
+      yield Queue.take(sendQueue).pipe(
         Effect.tap(send),
         Effect.forever,
         Effect.forkScoped,
         Effect.interruptible,
       )
 
-      yield* _(
-        socket.take,
+      yield socket.take.pipe(
         Effect.flatMap(onPayload),
         Effect.forever,
         Effect.forkScoped,

package/src/DiscordGateway/Sharder.ts

@@ -20,16 +20,15 @@ const claimRepeatPolicy = Schedule.spaced("3 minutes").pipe(
   Schedule.passthrough,
 ) as Schedule.Schedule<Option.Some<number>, Option.Option<number>>
 
-const make = Effect.gen(function* (_) {
-  const store = yield* _(ShardStore)
-  const rest = yield* _(DiscordREST)
-  const { gateway: config } = yield* _(DiscordConfig)
-  const limiter = yield* _(RateLimiter)
-  const shard = yield* _(Shard)
-  const currentShards = yield* _(Ref.make(HashSet.empty<RunningShard>()))
+const make = Effect.gen(function* () {
+  const store = yield* ShardStore
+  const rest = yield* DiscordREST
+  const { gateway: config } = yield* DiscordConfig
+  const limiter = yield* RateLimiter
+  const shard = yield* Shard
+  const currentShards = yield* Ref.make(HashSet.empty<RunningShard>())
 
-  const gateway = yield* _(
-    rest.getGatewayBot(),
+  const gateway = yield* rest.getGatewayBot().pipe(
     Effect.flatMap(r => r.json),
     Effect.catchAll(() =>
       Effect.succeed<Discord.GetGatewayBotResponse>({
@@ -46,7 +45,7 @@ const make = Effect.gen(function* (_) {
   )
 
   const totalCount = config.shardCount ?? gateway.shards
-  const currentCount = yield* _(Ref.make(0))
+  const currentCount = yield* Ref.make(0)
   const claimId = (sharderCount: number): Effect.Effect<number> =>
     pipe(
       store.claimId({
@@ -81,12 +80,11 @@ const make = Effect.gen(function* (_) {
     Effect.forever,
   )
 
-  yield* _(
-    Effect.replicateEffect(
-      spawner,
-      gateway.session_start_limit.max_concurrency,
-      { concurrency: "unbounded", discard: true },
-    ),
+  yield Effect.replicateEffect(
+    spawner,
+    gateway.session_start_limit.max_concurrency,
+    { concurrency: "unbounded", discard: true },
+  ).pipe(
     Effect.scoped,
     Effect.catchAllCause(Effect.logError),
     Effect.ensuring(Ref.set(currentShards, HashSet.empty())),

package/src/DiscordGateway.ts

@@ -30,9 +30,9 @@ export interface DiscordGateway {
 
 export const DiscordGateway = GenericTag<DiscordGateway>("dfx/DiscordGateway")
 
-export const make = Effect.gen(function* (_) {
-  const sharder = yield* _(Sharder)
-  const messaging = yield* _(Messaging)
+export const make = Effect.gen(function* () {
+  const sharder = yield* Sharder
+  const messaging = yield* Messaging
 
   return DiscordGateway.of({
     [TypeId]: TypeId,

package/src/DiscordREST.ts

@@ -42,12 +42,12 @@ export class DiscordRESTError extends TypeIdError(
   }
 }
 
-const make = Effect.gen(function* (_) {
-  const { rest, token } = yield* _(DiscordConfig)
+const make = Effect.gen(function* () {
+  const { rest, token } = yield* DiscordConfig
 
-  const http = yield* _(Http.client.Client)
-  const store = yield* _(RateLimitStore)
-  const { maybeWait } = yield* _(RateLimiter)
+  const http = yield* Http.client.Client
+  const store = yield* RateLimitStore
+  const { maybeWait } = yield* RateLimiter
 
   const globalRateLimit = maybeWait(
     "dfx.rest.global",
@@ -56,7 +56,7 @@ const make = Effect.gen(function* (_) {
   )
 
   // Invalid route handling (40x)
-  const badRoutesRef = yield* _(Ref.make(HashSet.empty<string>()))
+  const badRoutesRef = yield* Ref.make(HashSet.empty<string>())
   const tenMinutes = Duration.toMillis(Duration.minutes(10))
   const addBadRoute = (route: string) =>
     Effect.logDebug("bad route").pipe(