@clayroach/effect 3.19.14-source-capture.6 → 3.19.14-source-capture.8

package/src/internal/stm/tReentrantLock.ts

@@ -1,352 +0,0 @@
-import * as Effect from "../../Effect.js"
-import * as Equal from "../../Equal.js"
-import * as FiberId from "../../FiberId.js"
-import { dual } from "../../Function.js"
-import * as HashMap from "../../HashMap.js"
-import * as Option from "../../Option.js"
-import type * as Scope from "../../Scope.js"
-import type * as STM from "../../STM.js"
-import type * as TReentrantLock from "../../TReentrantLock.js"
-import type * as TRef from "../../TRef.js"
-import * as core from "./core.js"
-import * as tRef from "./tRef.js"
-
-const TReentrantLockSymbolKey = "effect/TReentrantLock"
-
-/** @internal */
-export const TReentrantLockTypeId: TReentrantLock.TReentrantLockTypeId = Symbol.for(
-  TReentrantLockSymbolKey
-) as TReentrantLock.TReentrantLockTypeId
-
-const WriteLockTypeId = Symbol.for("effect/TReentrantLock/WriteLock")
-
-type WriteLockTypeId = typeof WriteLockTypeId
-
-const ReadLockTypeId = Symbol.for("effect/TReentrantLock/ReadLock")
-
-type ReadLockTypeId = typeof ReadLockTypeId
-
-class TReentranLockImpl implements TReentrantLock.TReentrantLock {
-  readonly [TReentrantLockTypeId]: TReentrantLock.TReentrantLockTypeId = TReentrantLockTypeId
-  constructor(readonly state: TRef.TRef<LockState>) {}
-}
-
-/** @internal */
-export interface LockState {
-  /**
-   * Computes the total number of read locks acquired.
-   */
-  readonly readLocks: number
-  /**
-   * Computes the total number of write locks acquired.
-   */
-  readonly writeLocks: number
-  /**
-   * Computes the number of read locks held by the specified fiber id.
-   */
-  readLocksHeld(fiberId: FiberId.FiberId): number
-  /**
-   * Computes the number of write locks held by the specified fiber id.
-   */
-  writeLocksHeld(fiberId: FiberId.FiberId): number
-}
-
-/**
- * This data structure describes the state of the lock when multiple fibers
- * have acquired read locks. The state is tracked as a map from fiber identity
- * to number of read locks acquired by the fiber. This level of detail permits
- * upgrading a read lock to a write lock.
- *
- * @internal
- */
-export class ReadLock implements LockState {
-  readonly [ReadLockTypeId]: ReadLockTypeId = ReadLockTypeId
-  constructor(readonly readers: HashMap.HashMap<FiberId.FiberId, number>) {}
-  get readLocks(): number {
-    return Array.from(this.readers).reduce((acc, curr) => acc + curr[1], 0)
-  }
-  get writeLocks(): number {
-    return 0
-  }
-  readLocksHeld(fiberId: FiberId.FiberId): number {
-    return Option.getOrElse(
-      HashMap.get(this.readers, fiberId),
-      () => 0
-    )
-  }
-  writeLocksHeld(_fiberId: FiberId.FiberId): number {
-    return 0
-  }
-}
-
-/**
- * This data structure describes the state of the lock when a single fiber has
- * a write lock. The fiber has an identity, and may also have acquired a
- * certain number of read locks.
- *
- * @internal
- */
-export class WriteLock implements LockState {
-  readonly [WriteLockTypeId]: WriteLockTypeId = WriteLockTypeId
-  constructor(
-    readonly readLocks: number,
-    readonly writeLocks: number,
-    readonly fiberId: FiberId.FiberId
-  ) {}
-  readLocksHeld(fiberId: FiberId.FiberId): number {
-    return Equal.equals(fiberId)(this.fiberId) ? this.readLocks : 0
-  }
-  writeLocksHeld(fiberId: FiberId.FiberId): number {
-    return Equal.equals(fiberId)(this.fiberId) ? this.writeLocks : 0
-  }
-}
-
-const isReadLock = (lock: LockState): lock is ReadLock => {
-  return ReadLockTypeId in lock
-}
-
-const isWriteLock = (lock: LockState): lock is WriteLock => {
-  return WriteLockTypeId in lock
-}
-
-/**
- * An empty read lock state, in which no fiber holds any read locks.
- */
-const emptyReadLock = new ReadLock(HashMap.empty())
-
-/**
- * Creates a new read lock where the specified fiber holds the specified
- * number of read locks.
- */
-const makeReadLock = (fiberId: FiberId.FiberId, count: number): ReadLock => {
-  if (count <= 0) {
-    return emptyReadLock
-  }
-  return new ReadLock(HashMap.make([fiberId, count]))
-}
-
-/**
- * Determines if there is no other holder of read locks aside from the
- * specified fiber id. If there are no other holders of read locks aside
- * from the specified fiber id, then it is safe to upgrade the read lock
- * into a write lock.
- */
-const noOtherHolder = (readLock: ReadLock, fiberId: FiberId.FiberId): boolean => {
-  return HashMap.isEmpty(readLock.readers) ||
-    (HashMap.size(readLock.readers) === 1 && HashMap.has(readLock.readers, fiberId))
-}
-
-/**
- * Adjusts the number of read locks held by the specified fiber id.
- */
-const adjustReadLock = (readLock: ReadLock, fiberId: FiberId.FiberId, adjustment: number): ReadLock => {
-  const total = readLock.readLocksHeld(fiberId)
-  const newTotal = total + adjustment
-  if (newTotal < 0) {
-    throw new Error(
-      "BUG - TReentrantLock.ReadLock.adjust - please report an issue at https://github.com/Effect-TS/effect/issues"
-    )
-  }
-  if (newTotal === 0) {
-    return new ReadLock(HashMap.remove(readLock.readers, fiberId))
-  }
-  return new ReadLock(HashMap.set(readLock.readers, fiberId, newTotal))
-}
-
-const adjustRead = (self: TReentrantLock.TReentrantLock, delta: number): STM.STM<number> =>
-  core.withSTMRuntime((runtime) => {
-    const lock = tRef.unsafeGet(self.state, runtime.journal)
-    if (isReadLock(lock)) {
-      const result = adjustReadLock(lock, runtime.fiberId, delta)
-      tRef.unsafeSet(self.state, result, runtime.journal)
-      return core.succeed(result.readLocksHeld(runtime.fiberId))
-    }
-    if (isWriteLock(lock) && Equal.equals(runtime.fiberId)(lock.fiberId)) {
-      const newTotal = lock.readLocks + delta
-      if (newTotal < 0) {
-        throw new Error(
-          `Defect: Fiber ${
-            FiberId.threadName(runtime.fiberId)
-          } releasing read locks it does not hold, newTotal: ${newTotal}`
-        )
-      }
-      tRef.unsafeSet(
-        self.state,
-        new WriteLock(newTotal, lock.writeLocks, runtime.fiberId),
-        runtime.journal
-      )
-      return core.succeed(newTotal)
-    }
-    return core.retry
-  })
-
-/** @internal */
-export const acquireRead = (self: TReentrantLock.TReentrantLock): STM.STM<number> => adjustRead(self, 1)
-
-/** @internal */
-export const acquireWrite = (self: TReentrantLock.TReentrantLock): STM.STM<number> =>
-  core.withSTMRuntime((runtime) => {
-    const lock = tRef.unsafeGet(self.state, runtime.journal)
-    if (isReadLock(lock) && noOtherHolder(lock, runtime.fiberId)) {
-      tRef.unsafeSet(
-        self.state,
-        new WriteLock(lock.readLocksHeld(runtime.fiberId), 1, runtime.fiberId),
-        runtime.journal
-      )
-      return core.succeed(1)
-    }
-    if (isWriteLock(lock) && Equal.equals(runtime.fiberId)(lock.fiberId)) {
-      tRef.unsafeSet(
-        self.state,
-        new WriteLock(lock.readLocks, lock.writeLocks + 1, runtime.fiberId),
-        runtime.journal
-      )
-      return core.succeed(lock.writeLocks + 1)
-    }
-    return core.retry
-  })
-
-/** @internal */
-export const fiberReadLocks = (self: TReentrantLock.TReentrantLock): STM.STM<number> =>
-  core.effect<never, number>((journal, fiberId) =>
-    tRef.unsafeGet(
-      self.state,
-      journal
-    ).readLocksHeld(fiberId)
-  )
-
-/** @internal */
-export const fiberWriteLocks = (self: TReentrantLock.TReentrantLock): STM.STM<number> =>
-  core.effect<never, number>((journal, fiberId) =>
-    tRef.unsafeGet(
-      self.state,
-      journal
-    ).writeLocksHeld(fiberId)
-  )
-
-/** @internal */
-export const lock = (self: TReentrantLock.TReentrantLock): Effect.Effect<number, never, Scope.Scope> => writeLock(self)
-
-/** @internal */
-export const locked = (self: TReentrantLock.TReentrantLock): STM.STM<boolean> =>
-  core.zipWith(
-    readLocked(self),
-    writeLocked(self),
-    (x, y) => x || y
-  )
-
-/** @internal */
-export const make: STM.STM<TReentrantLock.TReentrantLock> = core.map(
-  tRef.make<LockState>(emptyReadLock),
-  (readLock) => new TReentranLockImpl(readLock)
-)
-
-/** @internal */
-export const readLock = (self: TReentrantLock.TReentrantLock): Effect.Effect<number, never, Scope.Scope> =>
-  Effect.acquireRelease(
-    core.commit(acquireRead(self)),
-    () => core.commit(releaseRead(self))
-  )
-
-/** @internal */
-export const readLocks = (self: TReentrantLock.TReentrantLock): STM.STM<number> =>
-  core.map(
-    tRef.get(self.state),
-    (state) => state.readLocks
-  )
-
-/** @internal */
-export const readLocked = (self: TReentrantLock.TReentrantLock): STM.STM<boolean> =>
-  core.map(
-    tRef.get(self.state),
-    (state) => state.readLocks > 0
-  )
-
-/** @internal */
-export const releaseRead = (self: TReentrantLock.TReentrantLock): STM.STM<number> => adjustRead(self, -1)
-
-/** @internal */
-export const releaseWrite = (self: TReentrantLock.TReentrantLock): STM.STM<number> =>
-  core.withSTMRuntime((runtime) => {
-    const lock = tRef.unsafeGet(self.state, runtime.journal)
-    if (isWriteLock(lock) && lock.writeLocks === 1 && Equal.equals(runtime.fiberId)(lock.fiberId)) {
-      const result = makeReadLock(lock.fiberId, lock.readLocks)
-      tRef.unsafeSet(self.state, result, runtime.journal)
-      return core.succeed(result.writeLocksHeld(runtime.fiberId))
-    }
-    if (isWriteLock(lock) && Equal.equals(runtime.fiberId)(lock.fiberId)) {
-      const result = new WriteLock(lock.readLocks, lock.writeLocks - 1, runtime.fiberId)
-      tRef.unsafeSet(self.state, result, runtime.journal)
-      return core.succeed(result.writeLocksHeld(runtime.fiberId))
-    }
-    throw new Error(
-      `Defect: Fiber ${FiberId.threadName(runtime.fiberId)} releasing write lock it does not hold`
-    )
-  })
-
-/** @internal */
-export const withLock = dual<
-  (
-    self: TReentrantLock.TReentrantLock
-  ) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <A, E, R>(
-    effect: Effect.Effect<A, E, R>,
-    self: TReentrantLock.TReentrantLock
-  ) => Effect.Effect<A, E, R>
->(2, (effect, self) => withWriteLock(effect, self))
-
-/** @internal */
-export const withReadLock = dual<
-  (self: TReentrantLock.TReentrantLock) => <A, E, R>(
-    effect: Effect.Effect<A, E, R>
-  ) => Effect.Effect<A, E, R>,
-  <A, E, R>(
-    effect: Effect.Effect<A, E, R>,
-    self: TReentrantLock.TReentrantLock
-  ) => Effect.Effect<A, E, R>
->(2, (effect, self) =>
-  Effect.uninterruptibleMask((restore) =>
-    Effect.zipRight(
-      restore(core.commit(acquireRead(self))),
-      Effect.ensuring(
-        effect,
-        core.commit(releaseRead(self))
-      )
-    )
-  ))
-
-/** @internal */
-export const withWriteLock = dual<
-  (self: TReentrantLock.TReentrantLock) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <A, E, R>(effect: Effect.Effect<A, E, R>, self: TReentrantLock.TReentrantLock) => Effect.Effect<A, E, R>
->(2, (effect, self) =>
-  Effect.uninterruptibleMask((restore) =>
-    Effect.zipRight(
-      restore(core.commit(acquireWrite(self))),
-      Effect.ensuring(
-        effect,
-        core.commit(releaseWrite(self))
-      )
-    )
-  ))
-
-/** @internal */
-export const writeLock = (self: TReentrantLock.TReentrantLock): Effect.Effect<number, never, Scope.Scope> =>
-  Effect.acquireRelease(
-    core.commit(acquireWrite(self)),
-    () => core.commit(releaseWrite(self))
-  )
-
-/** @internal */
-export const writeLocked = (self: TReentrantLock.TReentrantLock): STM.STM<boolean> =>
-  core.map(
-    tRef.get(self.state),
-    (state) => state.writeLocks > 0
-  )
-
-/** @internal */
-export const writeLocks = (self: TReentrantLock.TReentrantLock): STM.STM<number> =>
-  core.map(
-    tRef.get(self.state),
-    (state) => state.writeLocks
-  )

package/src/internal/stm/tRef.ts

@@ -1,195 +0,0 @@
-import { dual } from "../../Function.js"
-import * as Option from "../../Option.js"
-import type { Pipeable } from "../../Pipeable.js"
-import { pipeArguments } from "../../Pipeable.js"
-import type * as STM from "../../STM.js"
-import type * as TRef from "../../TRef.js"
-import * as core from "./core.js"
-import * as Entry from "./entry.js"
-import type * as Journal from "./journal.js"
-import type * as TxnId from "./txnId.js"
-import * as Versioned from "./versioned.js"
-
-/** @internal */
-const TRefSymbolKey = "effect/TRef"
-
-/** @internal */
-export const TRefTypeId: TRef.TRefTypeId = Symbol.for(
-  TRefSymbolKey
-) as TRef.TRefTypeId
-
-export const tRefVariance = {
-  /* c8 ignore next */
-  _A: (_: any) => _
-}
-
-/** @internal */
-export class TRefImpl<in out A> implements TRef.TRef<A>, Pipeable {
-  readonly [TRefTypeId] = tRefVariance
-  /** @internal */
-  todos: Map<TxnId.TxnId, Journal.Todo>
-  /** @internal */
-  versioned: Versioned.Versioned<A>
-  constructor(value: A) {
-    this.versioned = new Versioned.Versioned(value)
-    this.todos = new Map()
-  }
-  modify<B>(f: (a: A) => readonly [B, A]): STM.STM<B> {
-    return core.effect<never, B>((journal) => {
-      const entry = getOrMakeEntry(this, journal)
-      const [retValue, newValue] = f(Entry.unsafeGet(entry) as A)
-      Entry.unsafeSet(entry, newValue)
-      return retValue
-    })
-  }
-  pipe() {
-    return pipeArguments(this, arguments)
-  }
-}
-
-/** @internal */
-export const make = <A>(value: A): STM.STM<TRef.TRef<A>> =>
-  core.effect<never, TRef.TRef<A>>((journal) => {
-    const ref = new TRefImpl(value)
-    journal.set(ref, Entry.make(ref, true))
-    return ref
-  })
-
-/** @internal */
-export const get = <A>(self: TRef.TRef<A>) => self.modify((a) => [a, a])
-
-/** @internal */
-export const set = dual<
-  <A>(value: A) => (self: TRef.TRef<A>) => STM.STM<void>,
-  <A>(self: TRef.TRef<A>, value: A) => STM.STM<void>
->(
-  2,
-  <A>(self: TRef.TRef<A>, value: A): STM.STM<void> => self.modify((): [void, A] => [void 0, value])
-)
-
-/** @internal */
-export const getAndSet = dual<
-  <A>(value: A) => (self: TRef.TRef<A>) => STM.STM<A>,
-  <A>(self: TRef.TRef<A>, value: A) => STM.STM<A>
->(2, (self, value) => self.modify((a) => [a, value]))
-
-/** @internal */
-export const getAndUpdate = dual<
-  <A>(f: (a: A) => A) => (self: TRef.TRef<A>) => STM.STM<A>,
-  <A>(self: TRef.TRef<A>, f: (a: A) => A) => STM.STM<A>
->(2, (self, f) => self.modify((a) => [a, f(a)]))
-
-/** @internal */
-export const getAndUpdateSome = dual<
-  <A>(f: (a: A) => Option.Option<A>) => (self: TRef.TRef<A>) => STM.STM<A>,
-  <A>(self: TRef.TRef<A>, f: (a: A) => Option.Option<A>) => STM.STM<A>
->(2, (self, f) =>
-  self.modify((a) =>
-    Option.match(f(a), {
-      onNone: () => [a, a],
-      onSome: (b) => [a, b]
-    })
-  ))
-
-/** @internal */
-export const setAndGet = dual<
-  <A>(value: A) => (self: TRef.TRef<A>) => STM.STM<A>,
-  <A>(self: TRef.TRef<A>, value: A) => STM.STM<A>
->(2, (self, value) => self.modify(() => [value, value]))
-
-/** @internal */
-export const modify = dual<
-  <A, B>(f: (a: A) => readonly [B, A]) => (self: TRef.TRef<A>) => STM.STM<B>,
-  <A, B>(self: TRef.TRef<A>, f: (a: A) => readonly [B, A]) => STM.STM<B>
->(2, (self, f) => self.modify(f))
-
-/** @internal */
-export const modifySome = dual<
-  <A, B>(fallback: B, f: (a: A) => Option.Option<readonly [B, A]>) => (self: TRef.TRef<A>) => STM.STM<B>,
-  <A, B>(self: TRef.TRef<A>, fallback: B, f: (a: A) => Option.Option<readonly [B, A]>) => STM.STM<B>
->(3, (self, fallback, f) =>
-  self.modify((a) =>
-    Option.match(f(a), {
-      onNone: () => [fallback, a],
-      onSome: (b) => b
-    })
-  ))
-
-/** @internal */
-export const update = dual<
-  <A>(f: (a: A) => A) => (self: TRef.TRef<A>) => STM.STM<void>,
-  <A>(self: TRef.TRef<A>, f: (a: A) => A) => STM.STM<void>
->(2, (self, f) => self.modify((a) => [void 0, f(a)]))
-
-/** @internal */
-export const updateAndGet = dual<
-  <A>(f: (a: A) => A) => (self: TRef.TRef<A>) => STM.STM<A>,
-  <A>(self: TRef.TRef<A>, f: (a: A) => A) => STM.STM<A>
->(2, (self, f) =>
-  self.modify((a) => {
-    const b = f(a)
-    return [b, b]
-  }))
-
-/** @internal */
-export const updateSome = dual<
-  <A>(f: (a: A) => Option.Option<A>) => (self: TRef.TRef<A>) => STM.STM<void>,
-  <A>(self: TRef.TRef<A>, f: (a: A) => Option.Option<A>) => STM.STM<void>
->(
-  2,
-  (self, f) =>
-    self.modify((a) => [
-      void 0,
-      Option.match(f(a), {
-        onNone: () => a,
-        onSome: (b) => b
-      })
-    ])
-)
-
-/** @internal */
-export const updateSomeAndGet = dual<
-  <A>(f: (a: A) => Option.Option<A>) => (self: TRef.TRef<A>) => STM.STM<A>,
-  <A>(self: TRef.TRef<A>, f: (a: A) => Option.Option<A>) => STM.STM<A>
->(
-  2,
-  (self, f) =>
-    self.modify((a) =>
-      Option.match(f(a), {
-        onNone: () => [a, a],
-        onSome: (b) => [b, b]
-      })
-    )
-)
-
-/** @internal */
-const getOrMakeEntry = <A>(self: TRef.TRef<A>, journal: Journal.Journal): Entry.Entry => {
-  if (journal.has(self)) {
-    return journal.get(self)!
-  }
-  const entry = Entry.make(self, false)
-  journal.set(self, entry)
-  return entry
-}
-
-/** @internal */
-export const unsafeGet: {
-  (journal: Journal.Journal): <A>(self: TRef.TRef<A>) => A
-  <A>(self: TRef.TRef<A>, journal: Journal.Journal): A
-} = dual<
-  (journal: Journal.Journal) => <A>(self: TRef.TRef<A>) => A,
-  <A>(self: TRef.TRef<A>, journal: Journal.Journal) => A
->(2, <A>(self: TRef.TRef<A>, journal: Journal.Journal) => Entry.unsafeGet(getOrMakeEntry(self, journal)) as A)
-
-/** @internal */
-export const unsafeSet: {
-  <A>(value: A, journal: Journal.Journal): (self: TRef.TRef<A>) => void
-  <A>(self: TRef.TRef<A>, value: A, journal: Journal.Journal): void
-} = dual<
-  <A>(value: A, journal: Journal.Journal) => (self: TRef.TRef<A>) => void,
-  <A>(self: TRef.TRef<A>, value: A, journal: Journal.Journal) => void
->(3, (self, value, journal) => {
-  const entry = getOrMakeEntry(self, journal)
-  Entry.unsafeSet(entry, value)
-  return undefined
-})

package/src/internal/stm/tSemaphore.ts

@@ -1,113 +0,0 @@
-import * as Cause from "../../Cause.js"
-import * as Effect from "../../Effect.js"
-import { dual } from "../../Function.js"
-import type * as Scope from "../../Scope.js"
-import * as STM from "../../STM.js"
-import type * as TRef from "../../TRef.js"
-import type * as TSemaphore from "../../TSemaphore.js"
-import * as core from "./core.js"
-import * as tRef from "./tRef.js"
-
-/** @internal */
-const TSemaphoreSymbolKey = "effect/TSemaphore"
-
-/** @internal */
-export const TSemaphoreTypeId: TSemaphore.TSemaphoreTypeId = Symbol.for(
-  TSemaphoreSymbolKey
-) as TSemaphore.TSemaphoreTypeId
-
-/** @internal */
-class TSemaphoreImpl implements TSemaphore.TSemaphore {
-  readonly [TSemaphoreTypeId]: TSemaphore.TSemaphoreTypeId = TSemaphoreTypeId
-  constructor(readonly permits: TRef.TRef<number>) {}
-}
-
-/** @internal */
-export const make = (permits: number): STM.STM<TSemaphore.TSemaphore> =>
-  STM.map(tRef.make(permits), (permits) => new TSemaphoreImpl(permits))
-
-/** @internal */
-export const acquire = (self: TSemaphore.TSemaphore): STM.STM<void> => acquireN(self, 1)
-
-/** @internal */
-export const acquireN = dual<
-  (n: number) => (self: TSemaphore.TSemaphore) => STM.STM<void>,
-  (self: TSemaphore.TSemaphore, n: number) => STM.STM<void>
->(2, (self, n) =>
-  core.withSTMRuntime((driver) => {
-    if (n < 0) {
-      throw new Cause.IllegalArgumentException(`Unexpected negative value ${n} passed to Semaphore.acquireN`)
-    }
-    const value = tRef.unsafeGet(self.permits, driver.journal)
-    if (value < n) {
-      return STM.retry
-    } else {
-      return STM.succeed(tRef.unsafeSet(self.permits, value - n, driver.journal))
-    }
-  }))
-
-/** @internal */
-export const available = (self: TSemaphore.TSemaphore) => tRef.get(self.permits)
-
-/** @internal */
-export const release = (self: TSemaphore.TSemaphore): STM.STM<void> => releaseN(self, 1)
-
-/** @internal */
-export const releaseN = dual<
-  (n: number) => (self: TSemaphore.TSemaphore) => STM.STM<void>,
-  (self: TSemaphore.TSemaphore, n: number) => STM.STM<void>
->(2, (self, n) =>
-  core.withSTMRuntime((driver) => {
-    if (n < 0) {
-      throw new Cause.IllegalArgumentException(`Unexpected negative value ${n} passed to Semaphore.releaseN`)
-    }
-    const current = tRef.unsafeGet(self.permits, driver.journal)
-    return STM.succeed(tRef.unsafeSet(self.permits, current + n, driver.journal))
-  }))
-
-/** @internal */
-export const withPermit = dual<
-  (semaphore: TSemaphore.TSemaphore) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <A, E, R>(self: Effect.Effect<A, E, R>, semaphore: TSemaphore.TSemaphore) => Effect.Effect<A, E, R>
->(2, (self, semaphore) => withPermits(self, semaphore, 1))
-
-/** @internal */
-export const withPermits = dual<
-  (
-    semaphore: TSemaphore.TSemaphore,
-    permits: number
-  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <A, E, R>(
-    self: Effect.Effect<A, E, R>,
-    semaphore: TSemaphore.TSemaphore,
-    permits: number
-  ) => Effect.Effect<A, E, R>
->(3, (self, semaphore, permits) =>
-  Effect.uninterruptibleMask((restore) =>
-    Effect.zipRight(
-      restore(core.commit(acquireN(permits)(semaphore))),
-      Effect.ensuring(
-        self,
-        core.commit(releaseN(permits)(semaphore))
-      )
-    )
-  ))
-
-/** @internal */
-export const withPermitScoped = (self: TSemaphore.TSemaphore): Effect.Effect<void, never, Scope.Scope> =>
-  withPermitsScoped(self, 1)
-
-/** @internal */
-export const withPermitsScoped = dual<
-  (permits: number) => (self: TSemaphore.TSemaphore) => Effect.Effect<void, never, Scope.Scope>,
-  (self: TSemaphore.TSemaphore, permits: number) => Effect.Effect<void, never, Scope.Scope>
->(2, (self, permits) =>
-  Effect.acquireReleaseInterruptible(
-    core.commit(acquireN(self, permits)),
-    () => core.commit(releaseN(self, permits))
-  ))
-
-/** @internal */
-export const unsafeMakeSemaphore = (permits: number): TSemaphore.TSemaphore => {
-  return new TSemaphoreImpl(new tRef.TRefImpl(permits))
-}