effect 4.0.0-beta.4 → 4.0.0-beta.40

package/src/unstable/cluster/K8sHttpClient.ts

@@ -121,7 +121,7 @@ export const makeCreatePod = Effect.gen(function*() {
         while: (e) => e._tag === "SchemaError",
         schedule: Schedule.spaced("1 seconds")
       }),
-      Effect.catchIf(
+      Effect.catchFilter(
         (err) =>
           HttpClientError.isHttpClientError(err) && err.reason._tag === "StatusCodeError" &&
             err.reason.response.status === 404
@@ -133,7 +133,7 @@ export const makeCreatePod = Effect.gen(function*() {
     )
     const isPodFound = readPodRaw.pipe(
       Effect.as(true),
-      Effect.catchIf(
+      Effect.catchFilter(
         (err) =>
           HttpClientError.isHttpClientError(err) && err.reason._tag === "StatusCodeError" &&
             err.reason.response.status === 404
@@ -145,7 +145,7 @@ export const makeCreatePod = Effect.gen(function*() {
     const createPod = HttpClientRequest.post(`/v1/namespaces/${namespace}/pods`).pipe(
       HttpClientRequest.bodyJsonUnsafe(spec),
       client.execute,
-      Effect.catchIf(
+      Effect.catchFilter(
         (err) =>
           HttpClientError.isHttpClientError(err) && err.reason._tag === "StatusCodeError" &&
             err.reason.response.status === 409
@@ -156,10 +156,10 @@ export const makeCreatePod = Effect.gen(function*() {
       Effect.tapCause(Effect.logInfo),
       Effect.orDie
     )
-    const deletePod = HttpClientRequest.del(`/v1/namespaces/${namespace}/pods/${name}`).pipe(
+    const deletePod = HttpClientRequest.delete(`/v1/namespaces/${namespace}/pods/${name}`).pipe(
       client.execute,
       Effect.flatMap((res) => res.json),
-      Effect.catchIf(
+      Effect.catchFilter(
         (err) =>
           HttpClientError.isHttpClientError(err) && err.reason._tag === "StatusCodeError" &&
             err.reason.response.status === 404

package/src/unstable/cluster/Message.ts

@@ -3,6 +3,7 @@
  */
 import * as Data from "../../Data.ts"
 import * as Effect from "../../Effect.ts"
+import * as Option from "../../Option.ts"
 import * as Schema from "../../Schema.ts"
 import type { ServiceMap } from "../../ServiceMap.ts"
 import * as Rpc from "../rpc/Rpc.ts"
@@ -36,7 +37,7 @@ export const incomingLocalFromOutgoing = <R extends Rpc.Any>(self: Outgoing<R>):
   return new IncomingRequestLocal({
     envelope: self.envelope,
     respond: self.respond,
-    lastSentReply: undefined
+    lastSentReply: Option.none()
   })
 }
 
@@ -46,7 +47,7 @@ export const incomingLocalFromOutgoing = <R extends Rpc.Any>(self: Outgoing<R>):
  */
 export class IncomingRequest<R extends Rpc.Any> extends Data.TaggedClass("IncomingRequest")<{
   readonly envelope: Envelope.PartialRequest
-  readonly lastSentReply: Reply.Encoded | undefined
+  readonly lastSentReply: Option.Option<Reply.Encoded>
   readonly respond: (reply: Reply.ReplyWithContext<R>) => Effect.Effect<void, MalformedMessage | PersistenceError>
 }> {}
 
@@ -56,7 +57,7 @@ export class IncomingRequest<R extends Rpc.Any> extends Data.TaggedClass("Incomi
  */
 export class IncomingRequestLocal<R extends Rpc.Any> extends Data.TaggedClass("IncomingRequestLocal")<{
   readonly envelope: Envelope.Request<R>
-  readonly lastSentReply: Reply.Reply<R> | undefined
+  readonly lastSentReply: Option.Option<Reply.Reply<R>>
   readonly respond: (reply: Reply.Reply<R>) => Effect.Effect<void, MalformedMessage | PersistenceError>
 }> {}
 
@@ -82,7 +83,7 @@ export type Outgoing<R extends Rpc.Any> = OutgoingRequest<R> | OutgoingEnvelope
 export class OutgoingRequest<R extends Rpc.Any> extends Data.TaggedClass("OutgoingRequest")<{
   readonly envelope: Envelope.Request<R>
   readonly services: ServiceMap<Rpc.Services<R>>
-  readonly lastReceivedReply: Reply.Reply<R> | undefined
+  readonly lastReceivedReply: Option.Option<Reply.Reply<R>>
   readonly rpc: R
   readonly respond: (reply: Reply.Reply<R>) => Effect.Effect<void>
 }> {
@@ -196,7 +197,7 @@ export const deserializeLocal = <Rpc extends Rpc.Any>(
           ...encoded,
           payload
         } as any),
-        lastSentReply: undefined,
+        lastSentReply: Option.none(),
         respond: self.respond
       })
     )

package/src/unstable/cluster/MessageStorage.ts

@@ -6,12 +6,12 @@ import { Clock } from "../../Clock.ts"
 import * as Data from "../../Data.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
+import * as Latch from "../../Latch.ts"
 import * as Layer from "../../Layer.ts"
-import type * as Option from "../../Option.ts"
+import * as Option from "../../Option.ts"
 import type { Predicate } from "../../Predicate.ts"
 import * as Schema from "../../Schema.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
-import * as UndefinedOr from "../../UndefinedOr.ts"
 import type * as Rpc from "../rpc/Rpc.ts"
 import { EntityNotAssignedToRunner, MalformedMessage, type PersistenceError } from "./ClusterError.ts"
 import * as DeliverAt from "./DeliverAt.ts"
@@ -80,7 +80,7 @@ export class MessageStorage extends ServiceMap.Service<MessageStorage, {
       readonly tag: string
       readonly id: string
     }
-  ) => Effect.Effect<Snowflake.Snowflake | undefined, PersistenceError>
+  ) => Effect.Effect<Option.Option<Snowflake.Snowflake>, PersistenceError>
 
   /**
    * For locally sent messages, register a handler to process the replies.
@@ -186,7 +186,7 @@ export declare namespace SaveResult {
   export interface Duplicate<R extends Rpc.Any> {
     readonly _tag: "Duplicate"
     readonly originalId: Snowflake.Snowflake
-    readonly lastReceivedReply: Reply.Reply<R> | undefined
+    readonly lastReceivedReply: Option.Option<Reply.Reply<R>>
   }
 
   /**
@@ -196,7 +196,7 @@ export declare namespace SaveResult {
   export interface DuplicateEncoded {
     readonly _tag: "Duplicate"
     readonly originalId: Snowflake.Snowflake
-    readonly lastReceivedReply: Reply.Encoded | undefined
+    readonly lastReceivedReply: Option.Option<Reply.Encoded>
   }
 
   /**
@@ -239,7 +239,7 @@ export type Encoded = {
    */
   readonly requestIdForPrimaryKey: (
     primaryKey: string
-  ) => Effect.Effect<Snowflake.Snowflake | undefined, PersistenceError>
+  ) => Effect.Effect<Option.Option<Snowflake.Snowflake>, PersistenceError>
 
   /**
    * Retrieves the replies for the specified requests.
@@ -276,7 +276,7 @@ export type Encoded = {
   ) => Effect.Effect<
     Array<{
       readonly envelope: Envelope.Encoded
-      readonly lastSentReply: Reply.Encoded | undefined
+      readonly lastSentReply: Option.Option<Reply.Encoded>
     }>,
     PersistenceError
   >
@@ -290,7 +290,7 @@ export type Encoded = {
   ) => Effect.Effect<
     Array<{
       readonly envelope: Envelope.Encoded
-      readonly lastSentReply: Reply.Encoded | undefined
+      readonly lastSentReply: Option.Option<Reply.Encoded>
     }>,
     PersistenceError
   >
@@ -462,18 +462,18 @@ export const makeEncoded: (encoded: Encoded) => Effect.Effect<
           })
         ),
         Effect.flatMap((result) => {
-          if (result._tag === "Success" || result.lastReceivedReply === undefined) {
+          if (result._tag === "Success" || Option.isNone(result.lastReceivedReply)) {
             return Effect.succeed(result as SaveResult<any>)
           }
           const duplicate = result
           const schema = Reply.Reply(message.rpc)
-          return Schema.decodeEffect(schema)(result.lastReceivedReply).pipe(
+          return Schema.decodeEffect(schema)(result.lastReceivedReply.value).pipe(
             Effect.provideServices(message.services),
             MalformedMessage.refail,
             Effect.map((reply) =>
               SaveResult.Duplicate({
                 originalId: duplicate.originalId,
-                lastReceivedReply: reply
+                lastReceivedReply: Option.some(reply)
               })
             )
           )
@@ -545,7 +545,7 @@ export const makeEncoded: (encoded: Encoded) => Effect.Effect<
   const decodeMessages = (
     envelopes: Array<{
       readonly envelope: Envelope.Encoded
-      readonly lastSentReply: Reply.Encoded | undefined
+      readonly lastSentReply: Option.Option<Reply.Encoded>
     }>
   ) => {
     const messages: Array<Message.Incoming<any>> = []
@@ -654,7 +654,7 @@ export const noop: MessageStorage["Service"] = Effect.runSync(make({
   clearReplies: () => Effect.void,
   repliesFor: () => Effect.succeed([]),
   repliesForUnfiltered: () => Effect.succeed([]),
-  requestIdForPrimaryKey: () => Effect.undefined,
+  requestIdForPrimaryKey: () => Effect.succeedNone,
   unprocessedMessages: () => Effect.succeed([]),
   unprocessedMessagesById: () => Effect.succeed([]),
   resetAddress: () => Effect.void,
@@ -692,7 +692,7 @@ export class MemoryDriver extends ServiceMap.Service<MemoryDriver>()("effect/clu
     const unprocessedWith = (predicate: Predicate<Envelope.Encoded>) => {
       const messages: Array<{
         readonly envelope: Envelope.Encoded
-        readonly lastSentReply: Reply.Encoded | undefined
+        readonly lastSentReply: Option.Option<Reply.Encoded>
       }> = []
       const now = clock.currentTimeMillisUnsafe()
       for (const envelope of unprocessed) {
@@ -706,19 +706,19 @@ export class MemoryDriver extends ServiceMap.Service<MemoryDriver>()("effect/clu
           }
           messages.push({
             envelope,
-            lastSentReply: entry?.replies[entry.replies.length - 1]
+            lastSentReply: Option.fromNullishOr(entry?.replies[entry.replies.length - 1])
           })
         } else {
           messages.push({
             envelope,
-            lastSentReply: undefined
+            lastSentReply: Option.none()
           })
         }
       }
       return messages
     }
 
-    const replyLatch = yield* Effect.makeLatch()
+    const replyLatch = yield* Latch.make()
 
     function repliesFor(requestIds: Array<string>) {
       const replies = Arr.empty<Reply.Encoded>()
@@ -750,9 +750,11 @@ export class MemoryDriver extends ServiceMap.Service<MemoryDriver>()("effect/clu
           if (existing) {
             return SaveResultEncoded.Duplicate({
               originalId: Snowflake.Snowflake(existing.envelope.requestId),
-              lastReceivedReply: existing.replies.length === 1 && existing.replies[0]._tag === "WithExit"
-                ? existing.replies[0]
-                : existing.lastReceivedChunk
+              lastReceivedReply: Option.fromNullishOr(
+                existing.replies.length === 1 && existing.replies[0]._tag === "WithExit"
+                  ? existing.replies[0]
+                  : existing.lastReceivedChunk
+              )
             })
           }
           if (envelope._tag === "Request") {
@@ -796,7 +798,7 @@ export class MemoryDriver extends ServiceMap.Service<MemoryDriver>()("effect/clu
       requestIdForPrimaryKey: (primaryKey) =>
         Effect.sync(() => {
           const entry = requestsByPrimaryKey.get(primaryKey)
-          return UndefinedOr.map(entry?.envelope.requestId, Snowflake.Snowflake)
+          return Option.map(Option.fromNullishOr(entry?.envelope.requestId), Snowflake.Snowflake)
         }),
       repliesFor: (requestIds) => Effect.sync(() => repliesFor(requestIds)),
       repliesForUnfiltered: (requestIds) =>
@@ -807,7 +809,7 @@ export class MemoryDriver extends ServiceMap.Service<MemoryDriver>()("effect/clu
           const now = clock.currentTimeMillisUnsafe()
           const messages = Arr.empty<{
             envelope: Envelope.Encoded
-            lastSentReply: Reply.Encoded | undefined
+            lastSentReply: Option.Option<Reply.Encoded>
           }>()
           for (let index = 0; index < journal.length; index++) {
             const envelope = journal[index]
@@ -822,12 +824,12 @@ export class MemoryDriver extends ServiceMap.Service<MemoryDriver>()("effect/clu
               }
               messages.push({
                 envelope,
-                lastSentReply: entry.replies[entry.replies.length - 1]
+                lastSentReply: Option.fromNullishOr(entry.replies[entry.replies.length - 1])
               })
             } else {
               messages.push({
                 envelope,
-                lastSentReply: undefined
+                lastSentReply: Option.none()
               })
               unprocessed.delete(envelope)
             }
@@ -904,15 +906,12 @@ export const layerMemory: Layer.Layer<
 
 const EnvelopeWithReply: Schema.Struct<
   {
-    readonly envelope: Schema.Codec<
-      Envelope.PartialRequest | Envelope.AckChunk | Envelope.Interrupt,
-      unknown
-    >
-    readonly lastSentReply: Schema.UndefinedOr<Schema.Codec<Reply.Encoded>>
+    readonly envelope: Schema.Decoder<Envelope.PartialRequest | Envelope.AckChunk | Envelope.Interrupt>
+    readonly lastSentReply: Schema.Option<Schema.Codec<Reply.Encoded>>
   }
 > = Schema.Struct({
   envelope: Schema.toCodecJson(Envelope.Partial),
-  lastSentReply: Schema.UndefinedOr(Reply.Encoded)
+  lastSentReply: Schema.Option(Reply.Encoded)
 })
 
 const decodeEnvelopeWithReply = Schema.decodeEffect(EnvelopeWithReply)

package/src/unstable/cluster/Reply.ts

@@ -352,12 +352,15 @@ export const serialize = <R extends Rpc.Any>(
  */
 export const serializeLastReceived = <R extends Rpc.Any>(
   self: OutgoingRequest<R>
-): Effect.Effect<Encoded | undefined, MalformedMessage> => {
-  if (self.lastReceivedReply === undefined) {
-    return Effect.undefined
+): Effect.Effect<Option.Option<Encoded>, MalformedMessage> => {
+  const lastReceivedReply = self.lastReceivedReply
+  if (lastReceivedReply._tag === "None") {
+    return Effect.succeedNone
   }
   const schema = Reply(self.rpc)
   return MalformedMessage.refail(
-    Effect.provideServices(Schema.encodeEffect(schema)(self.lastReceivedReply), self.services)
+    Effect.provideServices(Schema.encodeEffect(schema)(lastReceivedReply.value), self.services)
+  ).pipe(
+    Effect.map(Option.some)
   )
 }

package/src/unstable/cluster/Runner.ts

@@ -93,4 +93,4 @@ export const make = (props: {
   readonly address: RunnerAddress
   readonly groups: ReadonlyArray<string>
   readonly weight: number
-}): Runner => new Runner(props, { disableValidation: true })
+}): Runner => new Runner(props, { disableChecks: true })

package/src/unstable/cluster/RunnerAddress.ts

@@ -63,4 +63,4 @@ export class RunnerAddress extends Schema.Class<RunnerAddress>(TypeId)({
  * @category constructors
  */
 export const make = (host: string, port: number): RunnerAddress =>
-  new RunnerAddress({ host, port }, { disableValidation: true })
+  new RunnerAddress({ host, port }, { disableChecks: true })

package/src/unstable/cluster/RunnerServer.ts

@@ -6,6 +6,7 @@ import type * as Exit from "../../Exit.ts"
 import * as Fiber from "../../Fiber.ts"
 import { constant } from "../../Function.ts"
 import * as Layer from "../../Layer.ts"
+import * as Option from "../../Option.ts"
 import * as Queue from "../../Queue.ts"
 import * as RpcServer from "../rpc/RpcServer.ts"
 import type * as ClusterError from "./ClusterError.ts"
@@ -36,23 +37,19 @@ export const layerHandlers = Runners.Rpcs.toLayer(Effect.gen(function*() {
           ? new Message.IncomingRequest({
             envelope,
             respond: constVoid,
-            lastSentReply: undefined
+            lastSentReply: Option.none()
           })
           : new Message.IncomingEnvelope({ envelope })
       ),
     Effect: ({ persisted, request }) => {
-      let replyEncoded:
-        | Effect.Effect<
-          Reply.Encoded,
-          ClusterError.EntityNotAssignedToRunner
-        >
-        | undefined = undefined
+      let replyEncoded: Option.Option<Effect.Effect<Reply.Encoded, ClusterError.EntityNotAssignedToRunner>> = Option
+        .none()
       let resume = (reply: Effect.Effect<Reply.Encoded, ClusterError.EntityNotAssignedToRunner>) => {
-        replyEncoded = reply
+        replyEncoded = Option.some(reply)
       }
       const message = new Message.IncomingRequest({
         envelope: request,
-        lastSentReply: undefined,
+        lastSentReply: Option.none(),
         respond(reply) {
           resume(Effect.orDie(Reply.serialize(reply)))
           return Effect.void
@@ -89,8 +86,8 @@ export const layerHandlers = Runners.Rpcs.toLayer(Effect.gen(function*() {
       return Effect.andThen(
         sharding.send(message),
         Effect.callback<Reply.Encoded, ClusterError.EntityNotAssignedToRunner>((resume_) => {
-          if (replyEncoded) {
-            resume_(replyEncoded)
+          if (Option.isSome(replyEncoded)) {
+            resume_(replyEncoded.value)
           } else {
             resume = resume_
           }
@@ -103,7 +100,7 @@ export const layerHandlers = Runners.Rpcs.toLayer(Effect.gen(function*() {
         (queue) => {
           const message = new Message.IncomingRequest({
             envelope: request,
-            lastSentReply: undefined,
+            lastSentReply: Option.none(),
             respond(reply) {
               return Effect.flatMap(Reply.serialize(reply), (reply) => {
                 Queue.offerUnsafe(queue, reply)
@@ -191,6 +188,6 @@ export const layerClientOnly: Layer.Layer<
   Layer.provide(RunnerHealth.layerNoop),
   Layer.updateService(ShardingConfig, (config) => ({
     ...config,
-    runnerAddress: undefined
+    runnerAddress: Option.none()
   }))
 )

package/src/unstable/cluster/Runners.ts

@@ -3,7 +3,9 @@
  */
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
+import * as Latch from "../../Latch.ts"
 import * as Layer from "../../Layer.ts"
+import * as Option from "../../Option.ts"
 import * as Queue from "../../Queue.ts"
 import * as RcMap from "../../RcMap.ts"
 import * as Schema from "../../Schema.ts"
@@ -79,7 +81,7 @@ export class Runners extends ServiceMap.Service<Runners, {
    */
   readonly notify: <R extends Rpc.Any>(
     options: {
-      readonly address: RunnerAddress | undefined
+      readonly address: Option.Option<RunnerAddress>
       readonly message: Message.Outgoing<R>
       readonly discard: boolean
     }
@@ -165,8 +167,8 @@ export const make: (options: Omit<Runners["Service"], "sendLocal" | "notifyLocal
         Duplicate: ({ lastReceivedReply, originalId }) => {
           // If the last received reply is an exit, we can just return it
           // as the response.
-          if (lastReceivedReply && lastReceivedReply._tag === "WithExit") {
-            return message.respond(lastReceivedReply.withRequestId(message.envelope.requestId))
+          if (Option.isSome(lastReceivedReply) && lastReceivedReply.value._tag === "WithExit") {
+            return message.respond(lastReceivedReply.value.withRequestId(message.envelope.requestId))
           }
           requestIdRewrites.set(message.envelope.requestId, originalId)
           return afterPersist(
@@ -192,8 +194,8 @@ export const make: (options: Omit<Runners["Service"], "sendLocal" | "notifyLocal
   }
 
   type StorageRequestEntry = {
-    readonly latch: Effect.Latch
-    doneLatch: Effect.Latch | undefined
+    readonly latch: Latch.Latch
+    doneLatch: Latch.Latch | undefined
     readonly messages: Set<Message.OutgoingRequest<any>>
     replies: Array<Reply.Reply<any>>
   }
@@ -204,11 +206,11 @@ export const make: (options: Omit<Runners["Service"], "sendLocal" | "notifyLocal
       let entry = storageRequests.get(message.envelope.requestId)
       if (entry) {
         entry.messages.add(message)
-        entry.doneLatch ??= Effect.makeLatchUnsafe(false)
+        entry.doneLatch ??= Latch.makeUnsafe(false)
         return yield* entry.doneLatch.await
       } else {
         entry = {
-          latch: Effect.makeLatchUnsafe(false),
+          latch: Latch.makeUnsafe(false),
           doneLatch: undefined,
           replies: [],
           messages: new Set([message])
@@ -260,7 +262,7 @@ export const make: (options: Omit<Runners["Service"], "sendLocal" | "notifyLocal
       )
   )
 
-  const storageLatch = Effect.makeLatchUnsafe(false)
+  const storageLatch = Latch.makeUnsafe(false)
   if (storage !== MessageStorage.noop) {
     yield* Effect.gen(function*() {
       const foundRequests = new Set<StorageRequestEntry>()
@@ -340,10 +342,10 @@ export const make: (options: Omit<Runners["Service"], "sendLocal" | "notifyLocal
       return notifyWith(message, (message, duplicate) => {
         if (discard || message._tag === "OutgoingEnvelope") {
           return options.notify(options_)
-        } else if (!duplicate && options_.address) {
+        } else if (!duplicate && Option.isSome(options_.address)) {
           return Effect.catch(
             options.send({
-              address: options_.address,
+              address: options_.address.value,
               message
             }),
             (_) => replyFromStorage(message)
@@ -583,11 +585,11 @@ export const makeRpc: Effect.Effect<
       })
     },
     notify({ address, message }) {
-      if (!address) {
+      if (Option.isNone(address)) {
         return Effect.void
       }
       const envelope = message.envelope
-      return RcMap.get(clients, address).pipe(
+      return RcMap.get(clients, address.value).pipe(
         Effect.flatMap((client) => client.Notify({ envelope })),
         Effect.scoped,
         Effect.ignore

package/src/unstable/cluster/ShardId.ts

@@ -8,7 +8,7 @@ import * as S from "../../Schema.ts"
 
 const TypeId = "~effect/cluster/ShardId"
 
-const constDisableValidation = { disableValidation: true }
+const constDisableChecks = { disableChecks: true }
 
 /**
  * @since 4.0.0
@@ -18,7 +18,7 @@ export const make = (group: string, id: number): ShardId => {
   const key = `${group}:${id}`
   let shardId = shardIdCache.get(key)
   if (!shardId) {
-    shardId = new ShardId({ group, id }, constDisableValidation)
+    shardId = new ShardId({ group, id }, constDisableChecks)
     shardIdCache.set(key, shardId)
   }
   return shardId