effect 2.0.0-next.44 → 2.0.0-next.46

package/src/TReentrantLock.ts

@@ -0,0 +1,224 @@
+/**
+ * @since 2.0.0
+ */
+import type * as Effect from "./Effect"
+import * as internal from "./internal/stm/tReentrantLock"
+import type * as Scope from "./Scope"
+import type * as STM from "./STM"
+import type * as TRef from "./TRef"
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const TReentrantLockTypeId: unique symbol = internal.TReentrantLockTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type TReentrantLockTypeId = typeof TReentrantLockTypeId
+
+/**
+ * A `TReentrantLock` is a reentrant read/write lock. Multiple readers may all
+ * concurrently acquire read locks. Only one writer is allowed to acquire a
+ * write lock at any given time. Read locks may be upgraded into write locks. A
+ * fiber that has a write lock may acquire other write locks or read locks.
+ *
+ * The two primary methods of this structure are `readLock`, which acquires a
+ * read lock in a scoped context, and `writeLock`, which acquires a write lock
+ * in a scoped context.
+ *
+ * Although located in the STM package, there is no need for locks within STM
+ * transactions. However, this lock can be quite useful in effectful code, to
+ * provide consistent read/write access to mutable state; and being in STM
+ * allows this structure to be composed into more complicated concurrent
+ * structures that are consumed from effectful code.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface TReentrantLock extends TReentrantLock.Proto {}
+/**
+ * @internal
+ * @since 2.0.0
+ */
+export interface TReentrantLock {
+  /** @internal */
+  readonly state: TRef.TRef<internal.LockState>
+}
+
+/**
+ * @since 2.0.0
+ */
+export declare namespace TReentrantLock {
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Proto {
+    readonly [TReentrantLockTypeId]: TReentrantLockTypeId
+  }
+}
+
+/**
+ * Acquires a read lock. The transaction will suspend until no other fiber is
+ * holding a write lock. Succeeds with the number of read locks held by this
+ * fiber.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const acquireRead: (self: TReentrantLock) => STM.STM<never, never, number> = internal.acquireRead
+
+/**
+ * Acquires a write lock. The transaction will suspend until no other fibers
+ * are holding read or write locks. Succeeds with the number of write locks
+ * held by this fiber.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const acquireWrite: (self: TReentrantLock) => STM.STM<never, never, number> = internal.acquireWrite
+
+/**
+ * Retrieves the number of acquired read locks for this fiber.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const fiberReadLocks: (self: TReentrantLock) => STM.STM<never, never, number> = internal.fiberReadLocks
+
+/**
+ * Retrieves the number of acquired write locks for this fiber.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const fiberWriteLocks: (self: TReentrantLock) => STM.STM<never, never, number> = internal.fiberWriteLocks
+
+/**
+ * Just a convenience method for applications that only need reentrant locks,
+ * without needing a distinction between readers / writers.
+ *
+ * See `TReentrantLock.writeLock`.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const lock: (self: TReentrantLock) => Effect.Effect<Scope.Scope, never, number> = internal.lock
+
+/**
+ * Determines if any fiber has a read or write lock.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const locked: (self: TReentrantLock) => STM.STM<never, never, boolean> = internal.locked
+
+/**
+ * Makes a new reentrant read/write lock.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make: STM.STM<never, never, TReentrantLock> = internal.make
+
+/**
+ * Obtains a read lock in a scoped context.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const readLock: (self: TReentrantLock) => Effect.Effect<Scope.Scope, never, number> = internal.readLock
+
+/**
+ * Retrieves the total number of acquired read locks.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const readLocks: (self: TReentrantLock) => STM.STM<never, never, number> = internal.readLocks
+
+/**
+ * Determines if any fiber has a read lock.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const readLocked: (self: TReentrantLock) => STM.STM<never, never, boolean> = internal.readLocked
+
+/**
+ * Releases a read lock held by this fiber. Succeeds with the outstanding
+ * number of read locks held by this fiber.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const releaseRead: (self: TReentrantLock) => STM.STM<never, never, number> = internal.releaseRead
+
+/**
+ * Releases a write lock held by this fiber. Succeeds with the outstanding
+ * number of write locks held by this fiber.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const releaseWrite: (self: TReentrantLock) => STM.STM<never, never, number> = internal.releaseWrite
+
+/**
+ * Runs the specified workflow with a lock.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const withLock: {
+  (self: TReentrantLock): <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
+  <R, E, A>(effect: Effect.Effect<R, E, A>, self: TReentrantLock): Effect.Effect<R, E, A>
+} = internal.withLock
+
+/**
+ * Runs the specified workflow with a read lock.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const withReadLock: {
+  (self: TReentrantLock): <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
+  <R, E, A>(effect: Effect.Effect<R, E, A>, self: TReentrantLock): Effect.Effect<R, E, A>
+} = internal.withReadLock
+
+/**
+ * Runs the specified workflow with a write lock.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const withWriteLock: {
+  (self: TReentrantLock): <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
+  <R, E, A>(effect: Effect.Effect<R, E, A>, self: TReentrantLock): Effect.Effect<R, E, A>
+} = internal.withWriteLock
+
+/**
+ * Obtains a write lock in a scoped context.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const writeLock: (self: TReentrantLock) => Effect.Effect<Scope.Scope, never, number> = internal.writeLock
+
+/**
+ * Determines if a write lock is held by some fiber.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const writeLocked: (self: TReentrantLock) => STM.STM<never, never, boolean> = internal.writeLocked
+
+/**
+ * Computes the number of write locks held by fibers.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+export const writeLocks: (self: TReentrantLock) => STM.STM<never, never, number> = internal.writeLocks

package/src/TRef.ts

@@ -0,0 +1,176 @@
+/**
+ * @since 2.0.0
+ */
+
+import type * as Journal from "./internal/stm/stm/journal"
+import type * as TxnId from "./internal/stm/stm/txnId"
+import type * as Versioned from "./internal/stm/stm/versioned"
+import * as internal from "./internal/stm/tRef"
+import type * as Option from "./Option"
+import type * as STM from "./STM"
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const TRefTypeId: unique symbol = internal.TRefTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type TRefTypeId = typeof TRefTypeId
+
+/**
+ * A `TRef<A>` is a purely functional description of a mutable reference that can
+ * be modified as part of a transactional effect. The fundamental operations of
+ * a `TRef` are `set` and `get`. `set` transactionally sets the reference to a
+ * new value. `get` gets the current value of the reference.
+ *
+ * NOTE: While `TRef<A>` provides the transactional equivalent of a mutable
+ * reference, the value inside the `TRef` should be immutable.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface TRef<A> extends TRef.Variance<A> {
+  /**
+   * Note: the method is unbound, exposed only for potential extensions.
+   */
+  modify<B>(f: (a: A) => readonly [B, A]): STM.STM<never, never, B>
+}
+/**
+ * @internal
+ * @since 2.0.0
+ */
+export interface TRef<A> {
+  /** @internal */
+  todos: Map<TxnId.TxnId, Journal.Todo>
+  /** @internal */
+  versioned: Versioned.Versioned<A>
+}
+
+/**
+ * @since 2.0.0
+ */
+export namespace TRef {
+  /**
+   * @since 2.0.0
+   */
+  export interface Variance<A> {
+    readonly [TRefTypeId]: {
+      readonly _A: (_: never) => A
+    }
+  }
+}
+
+/**
+ * @since 2.0.0
+ * @category mutations
+ */
+export const get: <A>(self: TRef<A>) => STM.STM<never, never, A> = internal.get
+
+/**
+ * @since 2.0.0
+ * @category mutations
+ */
+export const getAndSet: {
+  <A>(value: A): (self: TRef<A>) => STM.STM<never, never, A>
+  <A>(self: TRef<A>, value: A): STM.STM<never, never, A>
+} = internal.getAndSet
+
+/**
+ * @since 2.0.0
+ * @category mutations
+ */
+export const getAndUpdate: {
+  <A>(f: (a: A) => A): (self: TRef<A>) => STM.STM<never, never, A>
+  <A>(self: TRef<A>, f: (a: A) => A): STM.STM<never, never, A>
+} = internal.getAndUpdate
+
+/**
+ * @since 2.0.0
+ * @category mutations
+ */
+export const getAndUpdateSome: {
+  <A>(f: (a: A) => Option.Option<A>): (self: TRef<A>) => STM.STM<never, never, A>
+  <A>(self: TRef<A>, f: (a: A) => Option.Option<A>): STM.STM<never, never, A>
+} = internal.getAndUpdateSome
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make: <A>(value: A) => STM.STM<never, never, TRef<A>> = internal.make
+
+/**
+ * @since 2.0.0
+ * @category mutations
+ */
+export const modify: {
+  <A, B>(f: (a: A) => readonly [B, A]): (self: TRef<A>) => STM.STM<never, never, B>
+  <A, B>(self: TRef<A>, f: (a: A) => readonly [B, A]): STM.STM<never, never, B>
+} = internal.modify
+
+/**
+ * @since 2.0.0
+ * @category mutations
+ */
+export const modifySome: {
+  <A, B>(fallback: B, f: (a: A) => Option.Option<readonly [B, A]>): (self: TRef<A>) => STM.STM<never, never, B>
+  <A, B>(self: TRef<A>, fallback: B, f: (a: A) => Option.Option<readonly [B, A]>): STM.STM<never, never, B>
+} = internal.modifySome
+
+/**
+ * @since 2.0.0
+ * @category mutations
+ */
+export const set: {
+  <A>(value: A): (self: TRef<A>) => STM.STM<never, never, void>
+  <A>(self: TRef<A>, value: A): STM.STM<never, never, void>
+} = internal.set
+
+/**
+ * @since 2.0.0
+ * @category mutations
+ */
+export const setAndGet: {
+  <A>(value: A): (self: TRef<A>) => STM.STM<never, never, A>
+  <A>(self: TRef<A>, value: A): STM.STM<never, never, A>
+} = internal.setAndGet
+
+/**
+ * @since 2.0.0
+ * @category mutations
+ */
+export const update: {
+  <A>(f: (a: A) => A): (self: TRef<A>) => STM.STM<never, never, void>
+  <A>(self: TRef<A>, f: (a: A) => A): STM.STM<never, never, void>
+} = internal.update
+
+/**
+ * @since 2.0.0
+ * @category mutations
+ */
+export const updateAndGet: {
+  <A>(f: (a: A) => A): (self: TRef<A>) => STM.STM<never, never, A>
+  <A>(self: TRef<A>, f: (a: A) => A): STM.STM<never, never, A>
+} = internal.updateAndGet
+
+/**
+ * @since 2.0.0
+ * @category mutations
+ */
+export const updateSome: {
+  <A>(f: (a: A) => Option.Option<A>): (self: TRef<A>) => STM.STM<never, never, void>
+  <A>(self: TRef<A>, f: (a: A) => Option.Option<A>): STM.STM<never, never, void>
+} = internal.updateSome
+
+/**
+ * @since 2.0.0
+ * @category mutations
+ */
+export const updateSomeAndGet: {
+  <A>(f: (a: A) => Option.Option<A>): (self: TRef<A>) => STM.STM<never, never, A>
+  <A>(self: TRef<A>, f: (a: A) => Option.Option<A>): STM.STM<never, never, A>
+} = internal.updateSomeAndGet

package/src/TSemaphore.ts

@@ -0,0 +1,129 @@
+/**
+ * @since 2.0.0
+ */
+
+import type * as Effect from "./Effect"
+import * as internal from "./internal/stm/tSemaphore"
+import type * as Scope from "./Scope"
+import type * as STM from "./STM"
+import type * as TRef from "./TRef"
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const TSemaphoreTypeId: unique symbol = internal.TSemaphoreTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type TSemaphoreTypeId = typeof TSemaphoreTypeId
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface TSemaphore extends TSemaphore.Proto {}
+/**
+ * @internal
+ * @since 2.0.0
+ */
+export interface TSemaphore {
+  /** @internal */
+  readonly permits: TRef.TRef<number>
+}
+
+/**
+ * @since 2.0.0
+ */
+export declare namespace TSemaphore {
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Proto {
+    readonly [TSemaphoreTypeId]: TSemaphoreTypeId
+  }
+}
+
+/**
+ * @since 2.0.0
+ * @category mutations
+ */
+export const acquire: (self: TSemaphore) => STM.STM<never, never, void> = internal.acquire
+
+/**
+ * @since 2.0.0
+ * @category mutations
+ */
+export const acquireN: {
+  (n: number): (self: TSemaphore) => STM.STM<never, never, void>
+  (self: TSemaphore, n: number): STM.STM<never, never, void>
+} = internal.acquireN
+
+/**
+ * @since 2.0.0
+ * @category getters
+ */
+export const available: (self: TSemaphore) => STM.STM<never, never, number> = internal.available
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make: (permits: number) => STM.STM<never, never, TSemaphore> = internal.make
+
+/**
+ * @since 2.0.0
+ * @category mutations
+ */
+export const release: (self: TSemaphore) => STM.STM<never, never, void> = internal.release
+
+/**
+ * @since 2.0.0
+ * @category mutations
+ */
+export const releaseN: {
+  (n: number): (self: TSemaphore) => STM.STM<never, never, void>
+  (self: TSemaphore, n: number): STM.STM<never, never, void>
+} = internal.releaseN
+
+/**
+ * @since 2.0.0
+ * @category mutations
+ */
+export const withPermit: {
+  (semaphore: TSemaphore): <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
+  <R, E, A>(self: Effect.Effect<R, E, A>, semaphore: TSemaphore): Effect.Effect<R, E, A>
+} = internal.withPermit
+
+/**
+ * @since 2.0.0
+ * @category mutations
+ */
+export const withPermits: {
+  (semaphore: TSemaphore, permits: number): <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
+  <R, E, A>(self: Effect.Effect<R, E, A>, semaphore: TSemaphore, permits: number): Effect.Effect<R, E, A>
+} = internal.withPermits
+
+/**
+ * @since 2.0.0
+ * @category mutations
+ */
+export const withPermitScoped: (self: TSemaphore) => Effect.Effect<Scope.Scope, never, void> = internal.withPermitScoped
+
+/**
+ * @since 2.0.0
+ * @category mutations
+ */
+export const withPermitsScoped: {
+  (permits: number): (self: TSemaphore) => Effect.Effect<Scope.Scope, never, void>
+  (self: TSemaphore, permits: number): Effect.Effect<Scope.Scope, never, void>
+} = internal.withPermitsScoped
+
+/**
+ * @since 2.0.0
+ * @category unsafe
+ */
+export const unsafeMake: (permits: number) => TSemaphore = internal.unsafeMakeSemaphore