effect 4.0.0-beta.30 → 4.0.0-beta.32

package/src/SubscriptionRef.ts

@@ -7,7 +7,6 @@ import { PipeInspectableProto } from "./internal/core.ts"
 import * as Option from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import * as PubSub from "./PubSub.ts"
-import * as Ref from "./Ref.ts"
 import * as Semaphore from "./Semaphore.ts"
 import * as Stream from "./Stream.ts"
 import type { Invariant } from "./Types.ts"
@@ -19,7 +18,7 @@ const TypeId = "~effect/SubscriptionRef"
  * @category models
  */
 export interface SubscriptionRef<in out A> extends SubscriptionRef.Variance<A>, Pipeable {
-  readonly backing: Ref.Ref<A>
+  value: A
   readonly semaphore: Semaphore.Semaphore
   readonly pubsub: PubSub.PubSub<A>
 }
@@ -57,7 +56,7 @@ const Proto = {
   toJSON(this: SubscriptionRef<unknown>) {
     return {
       _id: "SubscriptionRef",
-      value: this.backing.ref.current
+      value: this.value
     }
   }
 }
@@ -72,7 +71,7 @@ export const make = <A>(value: A): Effect.Effect<SubscriptionRef<A>> =>
   Effect.map(PubSub.unbounded<A>({ replay: 1 }), (pubsub) => {
     const self = Object.create(Proto)
     self.semaphore = Semaphore.makeUnsafe(1)
-    self.backing = Ref.makeUnsafe(value)
+    self.value = value
     self.pubsub = pubsub
     PubSub.publishUnsafe(self.pubsub, value)
     return self
@@ -131,7 +130,7 @@ export const changes = <A>(self: SubscriptionRef<A>): Stream.Stream<A> => Stream
  * @since 2.0.0
  * @category getters
  */
-export const getUnsafe = <A>(self: SubscriptionRef<A>): A => self.backing.ref.current
+export const getUnsafe = <A>(self: SubscriptionRef<A>): A => self.value
 
 /**
  * Retrieves the current value of the `SubscriptionRef`.
@@ -151,7 +150,7 @@ export const getUnsafe = <A>(self: SubscriptionRef<A>): A => self.backing.ref.cu
  * @since 2.0.0
  * @category getters
  */
-export const get = <A>(self: SubscriptionRef<A>): Effect.Effect<A> => Effect.sync(() => getUnsafe(self))
+export const get = <A>(self: SubscriptionRef<A>): Effect.Effect<A> => Effect.sync(() => self.value)
 
 /**
  * Atomically retrieves the current value and sets a new value, notifying
@@ -223,10 +222,16 @@ export const getAndSet: {
    */
   <A>(self: SubscriptionRef<A>, value: A): Effect.Effect<A>
 } = dual(2, <A>(self: SubscriptionRef<A>, value: A) =>
-  self.semaphore.withPermit(Effect.flatMap(
-    Ref.getAndSet(self.backing, value),
-    (oldValue) => Effect.as(PubSub.publish(self.pubsub, value), oldValue)
-  )))
+  self.semaphore.withPermit(Effect.sync(() => {
+    const current = self.value
+    setUnsafe(self, value)
+    return current
+  })))
+
+const setUnsafe = <A>(self: SubscriptionRef<A>, value: A) => {
+  self.value = value
+  PubSub.publishUnsafe(self.pubsub, value)
+}
 
 /**
  * Atomically retrieves the current value and updates it with the result of
@@ -298,11 +303,11 @@ export const getAndUpdate: {
    */
   <A>(self: SubscriptionRef<A>, update: (a: A) => A): Effect.Effect<A>
 } = dual(2, <A>(self: SubscriptionRef<A>, update: (a: A) => A) =>
-  self.semaphore.withPermit(Effect.suspend(() => {
-    const current = self.backing.ref.current
+  self.semaphore.withPermit(Effect.sync(() => {
+    const current = self.value
     const newValue = update(current)
-    self.backing.ref.current = newValue
-    return Effect.as(PubSub.publish(self.pubsub, newValue), current)
+    setUnsafe(self, newValue)
+    return current
   })))
 
 /**
@@ -387,11 +392,11 @@ export const getAndUpdateEffect: {
   self: SubscriptionRef<A>,
   update: (a: A) => Effect.Effect<A, E, R>
 ) =>
-  self.semaphore.withPermit(Effect.suspend(() => {
-    const current = self.backing.ref.current
-    return Effect.flatMap(update(current), (newValue) => {
-      self.backing.ref.current = newValue
-      return Effect.as(PubSub.publish(self.pubsub, newValue), current)
+  self.semaphore.withPermit(Effect.sync(() => {
+    const current = self.value
+    return Effect.map(update(current), (newValue) => {
+      setUnsafe(self, newValue)
+      return current
     })
   })))
 
@@ -480,14 +485,14 @@ export const getAndUpdateSome: {
   self: SubscriptionRef<A>,
   update: (a: A) => Option.Option<A>
 ) =>
-  self.semaphore.withPermit(Effect.suspend(() => {
-    const current = self.backing.ref.current
+  self.semaphore.withPermit(Effect.sync(() => {
+    const current = self.value
     const option = update(current)
     if (Option.isNone(option)) {
       return Effect.succeed(current)
     }
-    self.backing.ref.current = option.value
-    return Effect.map(PubSub.publish(self.pubsub, option.value), () => current)
+    setUnsafe(self, option.value)
+    return current
   })))
 
 /**
@@ -579,13 +584,11 @@ export const getAndUpdateSomeEffect: {
   update: (a: A) => Effect.Effect<Option.Option<A>, E, R>
 ) =>
   self.semaphore.withPermit(Effect.suspend(() => {
-    const current = self.backing.ref.current
-    return Effect.flatMap(update(current), (option) => {
-      if (Option.isNone(option)) {
-        return Effect.succeed(current)
-      }
-      self.backing.ref.current = option.value
-      return Effect.as(PubSub.publish(self.pubsub, option.value), current)
+    const current = self.value
+    return Effect.map(update(current), (option) => {
+      if (Option.isNone(option)) return current
+      setUnsafe(self, option.value)
+      return current
     })
   })))
 
@@ -671,10 +674,10 @@ export const modify: {
   self: SubscriptionRef<A>,
   modify: (a: A) => readonly [B, A]
 ) =>
-  self.semaphore.withPermit(Effect.suspend(() => {
-    const [b, newValue] = modify(self.backing.ref.current)
-    self.backing.ref.current = newValue
-    return Effect.as(PubSub.publish(self.pubsub, newValue), b)
+  self.semaphore.withPermit(Effect.sync(() => {
+    const [b, newValue] = modify(self.value)
+    setUnsafe(self, newValue)
+    return b
   })))
 
 /**
@@ -765,13 +768,12 @@ export const modifyEffect: {
   self: SubscriptionRef<A>,
   modify: (a: A) => Effect.Effect<readonly [B, A], E, R>
 ): Effect.Effect<B, E, R> =>
-  self.semaphore.withPermit(Effect.suspend(() => {
-    const current = self.backing.ref.current
-    return Effect.flatMap(modify(current), ([b, newValue]) => {
-      self.backing.ref.current = newValue
-      return Effect.as(PubSub.publish(self.pubsub, newValue), b)
+  self.semaphore.withPermit(Effect.suspend(() =>
+    Effect.map(modify(self.value), ([b, newValue]) => {
+      setUnsafe(self, newValue)
+      return b
     })
-  })))
+  )))
 
 /**
  * Atomically modifies the `SubscriptionRef` with a function that computes a
@@ -861,13 +863,11 @@ export const modifySome: {
   self: SubscriptionRef<A>,
   modify: (a: A) => readonly [B, Option.Option<A>]
 ) =>
-  self.semaphore.withPermit(Effect.suspend(() => {
-    const [b, option] = modify(self.backing.ref.current)
-    if (Option.isNone(option)) {
-      return Effect.succeed(b)
-    }
-    self.backing.ref.current = option.value
-    return Effect.as(PubSub.publish(self.pubsub, option.value), b)
+  self.semaphore.withPermit(Effect.sync(() => {
+    const [b, option] = modify(self.value)
+    if (Option.isNone(option)) return b
+    setUnsafe(self, option.value)
+    return b
   })))
 
 /**
@@ -973,16 +973,13 @@ export const modifySomeEffect: {
   self: SubscriptionRef<A>,
   modify: (a: A) => Effect.Effect<readonly [B, Option.Option<A>], E, R>
 ) =>
-  self.semaphore.withPermit(Effect.suspend(() => {
-    const current = self.backing.ref.current
-    return Effect.flatMap(modify(current), ([b, option]) => {
-      if (Option.isNone(option)) {
-        return Effect.succeed(b)
-      }
-      self.backing.ref.current = option.value
-      return Effect.as(PubSub.publish(self.pubsub, option.value), b)
+  self.semaphore.withPermit(Effect.suspend(() =>
+    Effect.map(modify(self.value), ([b, option]) => {
+      if (Option.isNone(option)) return b
+      setUnsafe(self, option.value)
+      return b
     })
-  })))
+  )))
 
 /**
  * Sets the value of the `SubscriptionRef`, notifying all subscribers of the
@@ -1050,11 +1047,10 @@ export const set: {
    * @category setters
    */
   <A>(self: SubscriptionRef<A>, value: A): Effect.Effect<void>
-} = dual(2, <A>(self: SubscriptionRef<A>, value: A) =>
-  self.semaphore.withPermit(Effect.suspend(() => {
-    self.backing.ref.current = value
-    return Effect.asVoid(PubSub.publish(self.pubsub, value))
-  })))
+} = dual(
+  2,
+  <A>(self: SubscriptionRef<A>, value: A) => self.semaphore.withPermit(Effect.sync(() => setUnsafe(self, value)))
+)
 
 /**
  * Sets the value of the `SubscriptionRef` and returns the new value,
@@ -1117,9 +1113,9 @@ export const setAndGet: {
    */
   <A>(self: SubscriptionRef<A>, value: A): Effect.Effect<A>
 } = dual(2, <A>(self: SubscriptionRef<A>, value: A) =>
-  self.semaphore.withPermit(Effect.suspend(() => {
-    self.backing.ref.current = value
-    return Effect.map(PubSub.publish(self.pubsub, value), () => value)
+  self.semaphore.withPermit(Effect.sync(() => {
+    setUnsafe(self, value)
+    return value
   })))
 
 /**
@@ -1188,12 +1184,11 @@ export const update: {
    * @category updating
    */
   <A>(self: SubscriptionRef<A>, update: (a: A) => A): Effect.Effect<void>
-} = dual(2, <A>(self: SubscriptionRef<A>, update: (a: A) => A) =>
-  self.semaphore.withPermit(Effect.suspend(() => {
-    const newValue = update(self.backing.ref.current)
-    self.backing.ref.current = newValue
-    return Effect.asVoid(PubSub.publish(self.pubsub, newValue))
-  })))
+} = dual(
+  2,
+  <A>(self: SubscriptionRef<A>, update: (a: A) => A) =>
+    self.semaphore.withPermit(Effect.sync(() => setUnsafe(self, update(self.value))))
+)
 
 /**
  * Updates the value of the `SubscriptionRef` with the result of applying an
@@ -1265,13 +1260,9 @@ export const updateEffect: {
   self: SubscriptionRef<A>,
   update: (a: A) => Effect.Effect<A, E, R>
 ) =>
-  self.semaphore.withPermit(Effect.suspend(() => {
-    const current = self.backing.ref.current
-    return Effect.flatMap(update(current), (newValue) => {
-      self.backing.ref.current = newValue
-      return Effect.asVoid(PubSub.publish(self.pubsub, newValue))
-    })
-  })))
+  self.semaphore.withPermit(
+    Effect.suspend(() => Effect.map(update(self.value), (newValue) => setUnsafe(self, newValue)))
+  ))
 
 /**
  * Updates the value of the `SubscriptionRef` with the result of applying a
@@ -1334,10 +1325,10 @@ export const updateAndGet: {
    */
   <A>(self: SubscriptionRef<A>, update: (a: A) => A): Effect.Effect<A>
 } = dual(2, <A>(self: SubscriptionRef<A>, update: (a: A) => A) =>
-  self.semaphore.withPermit(Effect.suspend(() => {
-    const newValue = update(self.backing.ref.current)
-    self.backing.ref.current = newValue
-    return Effect.as(PubSub.publish(self.pubsub, newValue), newValue)
+  self.semaphore.withPermit(Effect.sync(() => {
+    const newValue = update(self.value)
+    setUnsafe(self, newValue)
+    return newValue
   })))
 
 /**
@@ -1416,13 +1407,12 @@ export const updateAndGetEffect: {
   self: SubscriptionRef<A>,
   update: (a: A) => Effect.Effect<A, E, R>
 ) =>
-  self.semaphore.withPermit(Effect.suspend(() => {
-    const current = self.backing.ref.current
-    return Effect.flatMap(update(current), (newValue) => {
-      self.backing.ref.current = newValue
-      return Effect.as(PubSub.publish(self.pubsub, newValue), newValue)
+  self.semaphore.withPermit(Effect.suspend(() =>
+    Effect.map(update(self.value), (newValue) => {
+      setUnsafe(self, newValue)
+      return newValue
     })
-  })))
+  )))
 
 /**
  * Optionally updates the value of the `SubscriptionRef` with the result of
@@ -1506,13 +1496,10 @@ export const updateSome: {
   self: SubscriptionRef<A>,
   update: (a: A) => Option.Option<A>
 ) =>
-  self.semaphore.withPermit(Effect.suspend(() => {
-    const option = update(self.backing.ref.current)
-    if (Option.isNone(option)) {
-      return Effect.void
-    }
-    self.backing.ref.current = option.value
-    return Effect.asVoid(PubSub.publish(self.pubsub, option.value))
+  self.semaphore.withPermit(Effect.sync(() => {
+    const option = update(self.value)
+    if (Option.isNone(option)) return
+    setUnsafe(self, option.value)
   })))
 
 /**
@@ -1600,16 +1587,12 @@ export const updateSomeEffect: {
   self: SubscriptionRef<A>,
   update: (a: A) => Effect.Effect<Option.Option<A>, E, R>
 ) =>
-  self.semaphore.withPermit(Effect.suspend(() => {
-    const current = self.backing.ref.current
-    return Effect.flatMap(update(current), (option) => {
-      if (Option.isNone(option)) {
-        return Effect.void
-      }
-      self.backing.ref.current = option.value
-      return Effect.asVoid(PubSub.publish(self.pubsub, option.value))
+  self.semaphore.withPermit(Effect.suspend(() =>
+    Effect.map(update(self.value), (option) => {
+      if (Option.isNone(option)) return
+      setUnsafe(self, option.value)
     })
-  })))
+  )))
 
 /**
  * Optionally updates the value of the `SubscriptionRef` with the result of
@@ -1687,14 +1670,12 @@ export const updateSomeAndGet: {
   self: SubscriptionRef<A>,
   update: (a: A) => Option.Option<A>
 ) =>
-  self.semaphore.withPermit(Effect.suspend(() => {
-    const current = self.backing.ref.current
+  self.semaphore.withPermit(Effect.sync(() => {
+    const current = self.value
     const option = update(current)
-    if (Option.isNone(option)) {
-      return Effect.succeed(current)
-    }
-    self.backing.ref.current = option.value
-    return Effect.as(PubSub.publish(self.pubsub, option.value), option.value)
+    if (Option.isNone(option)) return current
+    setUnsafe(self, option.value)
+    return option.value
   })))
 
 /**
@@ -1777,12 +1758,10 @@ export const updateSomeAndGetEffect: {
   update: (a: A) => Effect.Effect<Option.Option<A>, E, R>
 ) =>
   self.semaphore.withPermit(Effect.suspend(() => {
-    const current = self.backing.ref.current
-    return Effect.flatMap(update(current), (option) => {
-      if (Option.isNone(option)) {
-        return Effect.succeed(current)
-      }
-      self.backing.ref.current = option.value
-      return Effect.as(PubSub.publish(self.pubsub, option.value), option.value)
+    const current = self.value
+    return Effect.map(update(current), (option) => {
+      if (Option.isNone(option)) return current
+      setUnsafe(self, option.value)
+      return option.value
     })
   })))

package/src/Terminal.ts

@@ -3,6 +3,7 @@
  */
 import type * as Cause from "./Cause.ts"
 import type * as Effect from "./Effect.ts"
+import type * as Option from "./Option.ts"
 import type { PlatformError } from "./PlatformError.ts"
 import * as Predicate from "./Predicate.ts"
 import type * as Queue from "./Queue.ts"
@@ -71,7 +72,7 @@ export interface UserInput {
   /**
    * The character read from the user (if any).
    */
-  readonly input: string | undefined
+  readonly input: Option.Option<string>
   /**
    * The key that the user pressed.
    */

package/src/Tracer.ts

@@ -6,6 +6,7 @@ import type { Fiber } from "./Fiber.ts"
 import { constFalse, type LazyArg } from "./Function.ts"
 import type * as core from "./internal/core.ts"
 import type { LogLevel } from "./LogLevel.ts"
+import * as Option from "./Option.ts"
 import * as ServiceMap from "./ServiceMap.ts"
 
 /**
@@ -15,7 +16,7 @@ import * as ServiceMap from "./ServiceMap.ts"
 export interface Tracer {
   span(this: Tracer, options: {
     readonly name: string
-    readonly parent: AnySpan | undefined
+    readonly parent: Option.Option<AnySpan>
     readonly annotations: ServiceMap.ServiceMap<never>
     readonly links: Array<SpanLink>
     readonly startTime: bigint
@@ -241,7 +242,7 @@ export interface Span {
   readonly name: string
   readonly spanId: string
   readonly traceId: string
-  readonly parent: AnySpan | undefined
+  readonly parent: Option.Option<AnySpan>
   readonly annotations: ServiceMap.ServiceMap<never>
   readonly status: SpanStatus
   readonly attributes: ReadonlyMap<string, unknown>
@@ -410,7 +411,7 @@ export class NativeSpan implements Span {
   readonly sampled: boolean
 
   readonly name: string
-  readonly parent: AnySpan | undefined
+  readonly parent: Option.Option<AnySpan>
   readonly annotations: ServiceMap.ServiceMap<never>
   readonly links: Array<SpanLink>
   readonly startTime: bigint
@@ -422,7 +423,7 @@ export class NativeSpan implements Span {
 
   constructor(options: {
     readonly name: string
-    readonly parent: AnySpan | undefined
+    readonly parent: Option.Option<AnySpan>
     readonly annotations: ServiceMap.ServiceMap<never>
     readonly links: Array<SpanLink>
     readonly startTime: bigint
@@ -441,7 +442,7 @@ export class NativeSpan implements Span {
       startTime: options.startTime
     }
     this.attributes = new Map()
-    this.traceId = options.parent?.traceId ?? randomHexString(32)
+    this.traceId = Option.getOrUndefined(options.parent)?.traceId ?? randomHexString(32)
     this.spanId = randomHexString(16)
   }
 

package/src/Trie.ts

@@ -647,10 +647,14 @@ export const toEntriesWithPrefix: {
  *   Trie.insert("she", 2)
  * )
  *
- * assert.deepStrictEqual(Trie.longestPrefixOf(trie, "sell"), undefined)
- * assert.deepStrictEqual(Trie.longestPrefixOf(trie, "sells"), ["sells", 1])
- * assert.deepStrictEqual(Trie.longestPrefixOf(trie, "shell"), ["she", 2])
- * assert.deepStrictEqual(Trie.longestPrefixOf(trie, "shellsort"), ["shells", 0])
+ * const none = Trie.longestPrefixOf(trie, "sell")
+ * const some = Trie.longestPrefixOf(trie, "sells")
+ *
+ * assert.equal(none._tag, "None")
+ * assert.equal(some._tag, "Some")
+ * if (some._tag === "Some") {
+ *   assert.deepStrictEqual(some.value, ["sells", 1])
+ * }
  * ```
  *
  * @since 2.0.0
@@ -672,16 +676,20 @@ export const longestPrefixOf: {
    *   Trie.insert("she", 2)
    * )
    *
-   * assert.deepStrictEqual(Trie.longestPrefixOf(trie, "sell"), undefined)
-   * assert.deepStrictEqual(Trie.longestPrefixOf(trie, "sells"), ["sells", 1])
-   * assert.deepStrictEqual(Trie.longestPrefixOf(trie, "shell"), ["she", 2])
-   * assert.deepStrictEqual(Trie.longestPrefixOf(trie, "shellsort"), ["shells", 0])
+   * const none = Trie.longestPrefixOf(trie, "sell")
+   * const some = Trie.longestPrefixOf(trie, "sells")
+   *
+   * assert.equal(none._tag, "None")
+   * assert.equal(some._tag, "Some")
+   * if (some._tag === "Some") {
+   *   assert.deepStrictEqual(some.value, ["sells", 1])
+   * }
    * ```
    *
    * @since 2.0.0
    * @category getters
    */
-  (key: string): <V>(self: Trie<V>) => [string, V] | undefined
+  (key: string): <V>(self: Trie<V>) => Option<[string, V]>
   /**
    * Returns the longest key/value in the `Trie`
    * that is a prefix of that `key` if it exists, `None` otherwise.
@@ -697,16 +705,20 @@ export const longestPrefixOf: {
    *   Trie.insert("she", 2)
    * )
    *
-   * assert.deepStrictEqual(Trie.longestPrefixOf(trie, "sell"), undefined)
-   * assert.deepStrictEqual(Trie.longestPrefixOf(trie, "sells"), ["sells", 1])
-   * assert.deepStrictEqual(Trie.longestPrefixOf(trie, "shell"), ["she", 2])
-   * assert.deepStrictEqual(Trie.longestPrefixOf(trie, "shellsort"), ["shells", 0])
+   * const none = Trie.longestPrefixOf(trie, "sell")
+   * const some = Trie.longestPrefixOf(trie, "sells")
+   *
+   * assert.equal(none._tag, "None")
+   * assert.equal(some._tag, "Some")
+   * if (some._tag === "Some") {
+   *   assert.deepStrictEqual(some.value, ["sells", 1])
+   * }
    * ```
    *
    * @since 2.0.0
    * @category getters
    */
-  <V>(self: Trie<V>, key: string): [string, V] | undefined
+  <V>(self: Trie<V>, key: string): Option<[string, V]>
 } = TR.longestPrefixOf
 
 /**