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

package/src/SubscriptionRef.ts

@@ -6,8 +6,9 @@ import { dual, identity } from "./Function.ts"
 import { PipeInspectableProto } from "./internal/core.ts"
 import * as Option from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
+import { hasProperty } from "./Predicate.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"
 
@@ -18,8 +19,8 @@ const TypeId = "~effect/SubscriptionRef"
  * @category models
  */
 export interface SubscriptionRef<in out A> extends SubscriptionRef.Variance<A>, Pipeable {
-  readonly backing: Ref.Ref<A>
-  readonly semaphore: Effect.Semaphore
+  value: A
+  readonly semaphore: Semaphore.Semaphore
   readonly pubsub: PubSub.PubSub<A>
 }
 
@@ -29,7 +30,7 @@ export interface SubscriptionRef<in out A> extends SubscriptionRef.Variance<A>,
  */
 export const isSubscriptionRef: (u: unknown) => u is SubscriptionRef<unknown> = (
   u: unknown
-): u is SubscriptionRef<unknown> => typeof u === "object" && u != null && TypeId in u
+): u is SubscriptionRef<unknown> => hasProperty(u, TypeId)
 
 /**
  * The `SynchronizedRef` namespace containing type definitions and utilities.
@@ -56,7 +57,7 @@ const Proto = {
   toJSON(this: SubscriptionRef<unknown>) {
     return {
       _id: "SubscriptionRef",
-      value: this.backing.ref.current
+      value: this.value
     }
   }
 }
@@ -70,8 +71,8 @@ const Proto = {
 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 = Effect.makeSemaphoreUnsafe(1)
-    self.backing = Ref.makeUnsafe(value)
+    self.semaphore = Semaphore.makeUnsafe(1)
+    self.value = value
     self.pubsub = pubsub
     PubSub.publishUnsafe(self.pubsub, value)
     return self
@@ -130,7 +131,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`.
@@ -150,7 +151,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
@@ -222,10 +223,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
@@ -297,11 +304,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
   })))
 
 /**
@@ -386,11 +393,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
     })
   })))
 
@@ -479,14 +486,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
   })))
 
 /**
@@ -578,13 +585,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
     })
   })))
 
@@ -670,10 +675,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
   })))
 
 /**
@@ -764,13 +769,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
@@ -860,13 +864,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
   })))
 
 /**
@@ -972,16 +974,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
@@ -1049,11 +1048,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,
@@ -1116,9 +1114,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
   })))
 
 /**
@@ -1187,12 +1185,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
@@ -1264,13 +1261,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
@@ -1333,10 +1326,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
   })))
 
 /**
@@ -1415,13 +1408,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
@@ -1505,13 +1497,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)
   })))
 
 /**
@@ -1599,16 +1588,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
@@ -1686,14 +1671,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
   })))
 
 /**
@@ -1776,12 +1759,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/SynchronizedRef.ts

@@ -6,6 +6,7 @@ import { dual } from "./Function.ts"
 import { PipeInspectableProto } from "./internal/core.ts"
 import * as Option from "./Option.ts"
 import * as Ref from "./Ref.ts"
+import * as Semaphore from "./Semaphore.ts"
 
 const TypeId = "~effect/SynchronizedRef"
 
@@ -16,7 +17,7 @@ const TypeId = "~effect/SynchronizedRef"
 export interface SynchronizedRef<in out A> extends Ref.Ref<A> {
   readonly [TypeId]: typeof TypeId
   readonly backing: Ref.Ref<A>
-  readonly semaphore: Effect.Semaphore
+  readonly semaphore: Semaphore.Semaphore
 }
 
 const Proto = {
@@ -36,7 +37,7 @@ const Proto = {
  */
 export const makeUnsafe = <A>(value: A): SynchronizedRef<A> => {
   const self = Object.create(Proto)
-  self.semaphore = Effect.makeSemaphoreUnsafe(1)
+  self.semaphore = Semaphore.makeUnsafe(1)
   self.backing = Ref.makeUnsafe(value)
   return self
 }

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)
   }