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

package/src/internal/redacted.ts

@@ -1,73 +0,0 @@
-import * as Equal from "../Equal.js"
-import { pipe } from "../Function.js"
-import { globalValue } from "../GlobalValue.js"
-import * as Hash from "../Hash.js"
-import { NodeInspectSymbol } from "../Inspectable.js"
-import { pipeArguments } from "../Pipeable.js"
-import { hasProperty } from "../Predicate.js"
-import type * as Redacted from "../Redacted.js"
-
-/** @internal */
-const RedactedSymbolKey = "effect/Redacted"
-
-/** @internal */
-export const redactedRegistry = globalValue(
-  "effect/Redacted/redactedRegistry",
-  () => new WeakMap<Redacted.Redacted<any>, any>()
-)
-
-/** @internal */
-export const RedactedTypeId: Redacted.RedactedTypeId = Symbol.for(
-  RedactedSymbolKey
-) as Redacted.RedactedTypeId
-
-/** @internal */
-export const proto = {
-  [RedactedTypeId]: {
-    _A: (_: never) => _
-  },
-  pipe() {
-    return pipeArguments(this, arguments)
-  },
-  toString() {
-    return "<redacted>"
-  },
-  toJSON() {
-    return "<redacted>"
-  },
-  [NodeInspectSymbol]() {
-    return "<redacted>"
-  },
-  [Hash.symbol]<T>(this: Redacted.Redacted<T>): number {
-    return pipe(
-      Hash.hash(RedactedSymbolKey),
-      Hash.combine(Hash.hash(redactedRegistry.get(this))),
-      Hash.cached(this)
-    )
-  },
-  [Equal.symbol]<T>(this: Redacted.Redacted<T>, that: unknown): boolean {
-    return isRedacted(that) && Equal.equals(redactedRegistry.get(this), redactedRegistry.get(that))
-  }
-}
-
-/** @internal */
-export const isRedacted = (u: unknown): u is Redacted.Redacted<unknown> => hasProperty(u, RedactedTypeId)
-
-/** @internal */
-export const make = <T>(value: T): Redacted.Redacted<T> => {
-  const redacted = Object.create(proto)
-  redactedRegistry.set(redacted, value)
-  return redacted
-}
-
-/** @internal */
-export const value = <T>(self: Redacted.Redacted<T>): T => {
-  if (redactedRegistry.has(self)) {
-    return redactedRegistry.get(self)
-  } else {
-    throw new Error("Unable to get redacted value")
-  }
-}
-
-/** @internal */
-export const unsafeWipe = <T>(self: Redacted.Redacted<T>): boolean => redactedRegistry.delete(self)

package/src/internal/ref.ts

@@ -1,171 +0,0 @@
-import type * as Effect from "../Effect.js"
-import * as Effectable from "../Effectable.js"
-import { dual } from "../Function.js"
-import * as MutableRef from "../MutableRef.js"
-import * as Option from "../Option.js"
-import * as Readable from "../Readable.js"
-import type * as Ref from "../Ref.js"
-import * as core from "./core.js"
-
-/** @internal */
-export const RefTypeId: Ref.RefTypeId = Symbol.for("effect/Ref") as Ref.RefTypeId
-
-/** @internal */
-export const refVariance = {
-  /* c8 ignore next */
-  _A: (_: any) => _
-}
-
-class RefImpl<in out A> extends Effectable.Class<A> implements Ref.Ref<A> {
-  commit() {
-    return this.get
-  }
-  readonly [RefTypeId] = refVariance
-  readonly [Readable.TypeId]: Readable.TypeId = Readable.TypeId
-  constructor(readonly ref: MutableRef.MutableRef<A>) {
-    super()
-    this.get = core.sync(() => MutableRef.get(this.ref))
-  }
-  readonly get: Effect.Effect<A>
-  modify<B>(f: (a: A) => readonly [B, A]): Effect.Effect<B> {
-    return core.sync(() => {
-      const current = MutableRef.get(this.ref)
-      const [b, a] = f(current)
-      if ((current as unknown) !== (a as unknown)) {
-        MutableRef.set(a)(this.ref)
-      }
-      return b
-    })
-  }
-}
-
-/** @internal */
-export const unsafeMake = <A>(value: A): Ref.Ref<A> => new RefImpl(MutableRef.make(value))
-
-/** @internal */
-export const make = <A>(value: A): Effect.Effect<Ref.Ref<A>> => core.sync(() => unsafeMake(value))
-
-/** @internal */
-export const get = <A>(self: Ref.Ref<A>) => self.get
-
-/** @internal */
-export const set = dual<
-  <A>(value: A) => (self: Ref.Ref<A>) => Effect.Effect<void>,
-  <A>(self: Ref.Ref<A>, value: A) => Effect.Effect<void>
->(2, <A>(self: Ref.Ref<A>, value: A) => self.modify((): [void, A] => [void 0, value]))
-
-/** @internal */
-export const getAndSet = dual<
-  <A>(value: A) => (self: Ref.Ref<A>) => Effect.Effect<A>,
-  <A>(self: Ref.Ref<A>, value: A) => Effect.Effect<A>
->(2, <A>(self: Ref.Ref<A>, value: A) => self.modify((a): [A, A] => [a, value]))
-
-/** @internal */
-export const getAndUpdate = dual<
-  <A>(f: (a: A) => A) => (self: Ref.Ref<A>) => Effect.Effect<A>,
-  <A>(self: Ref.Ref<A>, f: (a: A) => A) => Effect.Effect<A>
->(2, <A>(self: Ref.Ref<A>, f: (a: A) => A) => self.modify((a): [A, A] => [a, f(a)]))
-
-/** @internal */
-export const getAndUpdateSome = dual<
-  <A>(pf: (a: A) => Option.Option<A>) => (self: Ref.Ref<A>) => Effect.Effect<A>,
-  <A>(self: Ref.Ref<A>, pf: (a: A) => Option.Option<A>) => Effect.Effect<A>
->(2, <A>(self: Ref.Ref<A>, pf: (a: A) => Option.Option<A>) =>
-  self.modify((value): [A, A] => {
-    const option = pf(value)
-    switch (option._tag) {
-      case "None": {
-        return [value, value]
-      }
-      case "Some": {
-        return [value, option.value]
-      }
-    }
-  }))
-
-/** @internal */
-export const setAndGet = dual<
-  <A>(value: A) => (self: Ref.Ref<A>) => Effect.Effect<A>,
-  <A>(self: Ref.Ref<A>, value: A) => Effect.Effect<A>
->(2, <A>(self: Ref.Ref<A>, value: A) => self.modify((): [A, A] => [value, value]))
-
-/** @internal */
-export const modify = dual<
-  <A, B>(f: (a: A) => readonly [B, A]) => (self: Ref.Ref<A>) => Effect.Effect<B>,
-  <A, B>(self: Ref.Ref<A>, f: (a: A) => readonly [B, A]) => Effect.Effect<B>
->(2, (self, f) => self.modify(f))
-
-/** @internal */
-export const modifySome = dual<
-  <B, A>(
-    fallback: B,
-    pf: (a: A) => Option.Option<readonly [B, A]>
-  ) => (self: Ref.Ref<A>) => Effect.Effect<B>,
-  <A, B>(
-    self: Ref.Ref<A>,
-    fallback: B,
-    pf: (a: A) => Option.Option<readonly [B, A]>
-  ) => Effect.Effect<B>
->(3, (self, fallback, pf) =>
-  self.modify((value) => {
-    const option = pf(value)
-    switch (option._tag) {
-      case "None": {
-        return [fallback, value]
-      }
-      case "Some": {
-        return option.value
-      }
-    }
-  }))
-
-/** @internal */
-export const update = dual<
-  <A>(f: (a: A) => A) => (self: Ref.Ref<A>) => Effect.Effect<void>,
-  <A>(self: Ref.Ref<A>, f: (a: A) => A) => Effect.Effect<void>
->(2, <A>(self: Ref.Ref<A>, f: (a: A) => A) => self.modify((a): [void, A] => [void 0, f(a)]))
-
-/** @internal */
-export const updateAndGet = dual<
-  <A>(f: (a: A) => A) => (self: Ref.Ref<A>) => Effect.Effect<A>,
-  <A>(self: Ref.Ref<A>, f: (a: A) => A) => Effect.Effect<A>
->(2, <A>(self: Ref.Ref<A>, f: (a: A) => A) =>
-  self.modify((a): [A, A] => {
-    const result = f(a)
-    return [result, result]
-  }))
-
-/** @internal */
-export const updateSome = dual<
-  <A>(f: (a: A) => Option.Option<A>) => (self: Ref.Ref<A>) => Effect.Effect<void>,
-  <A>(self: Ref.Ref<A>, f: (a: A) => Option.Option<A>) => Effect.Effect<void>
->(2, <A>(self: Ref.Ref<A>, f: (a: A) => Option.Option<A>) =>
-  self.modify(
-    (a): [void, A] => [
-      void 0,
-      Option.match(f(a), {
-        onNone: () => a,
-        onSome: (b) => b
-      })
-    ]
-  ))
-
-/** @internal */
-export const updateSomeAndGet = dual<
-  <A>(pf: (a: A) => Option.Option<A>) => (self: Ref.Ref<A>) => Effect.Effect<A>,
-  <A>(self: Ref.Ref<A>, pf: (a: A) => Option.Option<A>) => Effect.Effect<A>
->(2, <A>(self: Ref.Ref<A>, pf: (a: A) => Option.Option<A>) =>
-  self.modify((value): [A, A] => {
-    const option = pf(value)
-    switch (option._tag) {
-      case "None": {
-        return [value, value]
-      }
-      case "Some": {
-        return [option.value, option.value]
-      }
-    }
-  }))
-
-/** @internal */
-export const unsafeGet = <A>(self: Ref.Ref<A>): A => MutableRef.get((self as RefImpl<A>).ref)

package/src/internal/reloadable.ts

@@ -1,140 +0,0 @@
-import * as Context from "../Context.js"
-import type * as Effect from "../Effect.js"
-import { pipe } from "../Function.js"
-import type * as Layer from "../Layer.js"
-import type * as Reloadable from "../Reloadable.js"
-import type * as Schedule from "../Schedule.js"
-import * as effect from "./core-effect.js"
-import * as core from "./core.js"
-import * as fiberRuntime from "./fiberRuntime.js"
-import * as layer_ from "./layer.js"
-import * as schedule_ from "./schedule.js"
-import * as scopedRef from "./scopedRef.js"
-
-/** @internal */
-const ReloadableSymbolKey = "effect/Reloadable"
-
-/** @internal */
-export const ReloadableTypeId: Reloadable.ReloadableTypeId = Symbol.for(
-  ReloadableSymbolKey
-) as Reloadable.ReloadableTypeId
-
-const reloadableVariance = {
-  /* c8 ignore next */
-  _A: (_: any) => _
-}
-
-/** @internal */
-export const auto = <I, S, E, In, R>(
-  tag: Context.Tag<I, S>,
-  options: {
-    readonly layer: Layer.Layer<I, E, In>
-    readonly schedule: Schedule.Schedule<unknown, unknown, R>
-  }
-): Layer.Layer<Reloadable.Reloadable<I>, E, R | In> =>
-  layer_.scoped(
-    reloadableTag(tag),
-    pipe(
-      layer_.build(manual(tag, { layer: options.layer })),
-      core.map(Context.unsafeGet(reloadableTag(tag))),
-      core.tap((reloadable) =>
-        fiberRuntime.acquireRelease(
-          pipe(
-            reloadable.reload,
-            effect.ignoreLogged,
-            schedule_.schedule_Effect(options.schedule),
-            fiberRuntime.forkDaemon
-          ),
-          core.interruptFiber
-        )
-      )
-    )
-  )
-
-/** @internal */
-export const autoFromConfig = <I, S, E, In, R>(
-  tag: Context.Tag<I, S>,
-  options: {
-    readonly layer: Layer.Layer<I, E, In>
-    readonly scheduleFromConfig: (context: Context.Context<In>) => Schedule.Schedule<unknown, unknown, R>
-  }
-): Layer.Layer<Reloadable.Reloadable<I>, E, R | In> =>
-  layer_.scoped(
-    reloadableTag(tag),
-    pipe(
-      core.context<In>(),
-      core.flatMap((env) =>
-        pipe(
-          layer_.build(auto(tag, {
-            layer: options.layer,
-            schedule: options.scheduleFromConfig(env)
-          })),
-          core.map(Context.unsafeGet(reloadableTag(tag)))
-        )
-      )
-    )
-  )
-
-/** @internal */
-export const get = <I, S>(
-  tag: Context.Tag<I, S>
-): Effect.Effect<S, never, Reloadable.Reloadable<I>> =>
-  core.flatMap(
-    reloadableTag(tag),
-    (reloadable) => scopedRef.get(reloadable.scopedRef)
-  )
-
-/** @internal */
-export const manual = <I, S, In, E>(
-  tag: Context.Tag<I, S>,
-  options: {
-    readonly layer: Layer.Layer<I, E, In>
-  }
-): Layer.Layer<Reloadable.Reloadable<I>, E, In> =>
-  layer_.scoped(
-    reloadableTag(tag),
-    pipe(
-      core.context<In>(),
-      core.flatMap((env) =>
-        pipe(
-          scopedRef.fromAcquire(pipe(layer_.build(options.layer), core.map(Context.unsafeGet(tag)))),
-          core.map((ref) => ({
-            [ReloadableTypeId]: reloadableVariance,
-            scopedRef: ref,
-            reload: pipe(
-              scopedRef.set(ref, pipe(layer_.build(options.layer), core.map(Context.unsafeGet(tag)))),
-              core.provideContext(env)
-            )
-          }))
-        )
-      )
-    )
-  )
-
-/** @internal */
-export const reloadableTag = <I, S>(
-  tag: Context.Tag<I, S>
-): Context.Tag<Reloadable.Reloadable<I>, Reloadable.Reloadable<S>> => {
-  return Context.GenericTag<Reloadable.Reloadable<I>, Reloadable.Reloadable<S>>(`effect/Reloadable<${tag.key}>`)
-}
-
-/** @internal */
-export const reload = <I, S>(
-  tag: Context.Tag<I, S>
-): Effect.Effect<void, unknown, Reloadable.Reloadable<I>> =>
-  core.flatMap(
-    reloadableTag(tag),
-    (reloadable) => reloadable.reload
-  )
-
-/** @internal */
-export const reloadFork = <I, S>(
-  tag: Context.Tag<I, S>
-): Effect.Effect<void, unknown, Reloadable.Reloadable<I>> =>
-  core.flatMap(reloadableTag(tag), (reloadable) =>
-    pipe(
-      reloadable.reload,
-      effect.ignoreLogged,
-      fiberRuntime.forkDaemon,
-      core.asVoid
-    ))

package/src/internal/request.ts

@@ -1,177 +0,0 @@
-import type * as Cause from "../Cause.js"
-import type * as Effect from "../Effect.js"
-import { dual } from "../Function.js"
-import { hasProperty } from "../Predicate.js"
-import type * as Request from "../Request.js"
-import type * as Types from "../Types.js"
-import * as completedRequestMap from "./completedRequestMap.js"
-import * as core from "./core.js"
-import { StructuralPrototype } from "./effectable.js"
-
-/** @internal */
-const RequestSymbolKey = "effect/Request"
-
-/** @internal */
-export const RequestTypeId: Request.RequestTypeId = Symbol.for(
-  RequestSymbolKey
-) as Request.RequestTypeId
-
-const requestVariance = {
-  /* c8 ignore next */
-  _E: (_: never) => _,
-  /* c8 ignore next */
-  _A: (_: never) => _
-}
-
-const RequestPrototype = {
-  ...StructuralPrototype,
-  [RequestTypeId]: requestVariance
-}
-
-/** @internal */
-export const isRequest = (u: unknown): u is Request.Request<unknown, unknown> => hasProperty(u, RequestTypeId)
-
-/** @internal */
-export const of = <R extends Request.Request<any, any>>(): Request.Request.Constructor<R> => (args) =>
-  Object.assign(Object.create(RequestPrototype), args)
-
-/** @internal */
-export const tagged = <R extends Request.Request<any, any> & { _tag: string }>(
-  tag: R["_tag"]
-): Request.Request.Constructor<R, "_tag"> =>
-(args) => {
-  const request = Object.assign(Object.create(RequestPrototype), args)
-  request._tag = tag
-  return request
-}
-
-/** @internal */
-export const Class: new<Success, Error, A extends Record<string, any>>(
-  args: Types.Equals<Omit<A, keyof Request.Request<unknown, unknown>>, {}> extends true ? void
-    : { readonly [P in keyof A as P extends keyof Request.Request<unknown, unknown> ? never : P]: A[P] }
-) => Request.Request<Success, Error> & Readonly<A> = (function() {
-  function Class(this: any, args: any) {
-    if (args) {
-      Object.assign(this, args)
-    }
-  }
-  Class.prototype = RequestPrototype
-  return Class as any
-})()
-
-/** @internal */
-export const TaggedClass = <Tag extends string>(
-  tag: Tag
-): new<Success, Error, A extends Record<string, any>>(
-  args: Types.Equals<Omit<A, keyof Request.Request<unknown, unknown>>, {}> extends true ? void
-    : { readonly [P in keyof A as P extends "_tag" | keyof Request.Request<unknown, unknown> ? never : P]: A[P] }
-) => Request.Request<Success, Error> & Readonly<A> & { readonly _tag: Tag } => {
-  return class TaggedClass extends Class<any, any, any> {
-    readonly _tag = tag
-  } as any
-}
-
-/** @internal */
-export const complete = dual<
-  <A extends Request.Request<any, any>>(
-    result: Request.Request.Result<A>
-  ) => (self: A) => Effect.Effect<void>,
-  <A extends Request.Request<any, any>>(
-    self: A,
-    result: Request.Request.Result<A>
-  ) => Effect.Effect<void>
->(2, (self, result) =>
-  core.fiberRefGetWith(
-    completedRequestMap.currentRequestMap,
-    (map) =>
-      core.sync(() => {
-        if (map.has(self)) {
-          const entry = map.get(self)!
-          if (!entry.state.completed) {
-            entry.state.completed = true
-            core.deferredUnsafeDone(entry.result, result)
-          }
-        }
-      })
-  ))
-
-/** @internal */
-export const completeEffect = dual<
-  <A extends Request.Request<any, any>, R>(
-    effect: Effect.Effect<Request.Request.Success<A>, Request.Request.Error<A>, R>
-  ) => (self: A) => Effect.Effect<void, never, R>,
-  <A extends Request.Request<any, any>, R>(
-    self: A,
-    effect: Effect.Effect<Request.Request.Success<A>, Request.Request.Error<A>, R>
-  ) => Effect.Effect<void, never, R>
->(2, (self, effect) =>
-  core.matchEffect(effect, {
-    onFailure: (error) => complete(self, core.exitFail(error) as any),
-    onSuccess: (value) => complete(self, core.exitSucceed(value) as any)
-  }))
-
-/** @internal */
-export const fail = dual<
-  <A extends Request.Request<any, any>>(
-    error: Request.Request.Error<A>
-  ) => (self: A) => Effect.Effect<void>,
-  <A extends Request.Request<any, any>>(
-    self: A,
-    error: Request.Request.Error<A>
-  ) => Effect.Effect<void>
->(2, (self, error) => complete(self, core.exitFail(error) as any))
-
-/** @internal */
-export const failCause = dual<
-  <A extends Request.Request<any, any>>(
-    cause: Cause.Cause<Request.Request.Error<A>>
-  ) => (self: A) => Effect.Effect<void>,
-  <A extends Request.Request<any, any>>(
-    self: A,
-    cause: Cause.Cause<Request.Request.Error<A>>
-  ) => Effect.Effect<void>
->(2, (self, cause) => complete(self, core.exitFailCause(cause) as any))
-
-/** @internal */
-export const succeed = dual<
-  <A extends Request.Request<any, any>>(
-    value: Request.Request.Success<A>
-  ) => (self: A) => Effect.Effect<void>,
-  <A extends Request.Request<any, any>>(
-    self: A,
-    value: Request.Request.Success<A>
-  ) => Effect.Effect<void>
->(2, (self, value) => complete(self, core.exitSucceed(value) as any))
-
-/** @internal */
-export class Listeners {
-  count = 0
-  observers: Set<(count: number) => void> = new Set()
-  interrupted = false
-  addObserver(f: (count: number) => void): void {
-    this.observers.add(f)
-  }
-  removeObserver(f: (count: number) => void): void {
-    this.observers.delete(f)
-  }
-  increment() {
-    this.count++
-    this.observers.forEach((f) => f(this.count))
-  }
-  decrement() {
-    this.count--
-    this.observers.forEach((f) => f(this.count))
-  }
-}
-
-/**
- * @internal
- */
-export const filterOutCompleted = <A extends Request.Request<any, any>>(requests: Array<A>) =>
-  core.fiberRefGetWith(
-    completedRequestMap.currentRequestMap,
-    (map) =>
-      core.succeed(
-        requests.filter((request) => !(map.get(request)?.state.completed === true))
-      )
-  )

package/src/internal/resource.ts

@@ -1,76 +0,0 @@
-import type * as Effect from "../Effect.js"
-import { identity, pipe } from "../Function.js"
-import type * as Resource from "../Resource.js"
-import type * as Schedule from "../Schedule.js"
-import type * as Scope from "../Scope.js"
-import * as core from "./core.js"
-import * as effectable from "./effectable.js"
-import * as fiberRuntime from "./fiberRuntime.js"
-import * as schedule_ from "./schedule.js"
-import * as scopedRef from "./scopedRef.js"
-
-/** @internal */
-const ResourceSymbolKey = "effect/Resource"
-
-/** @internal */
-export const ResourceTypeId: Resource.ResourceTypeId = Symbol.for(
-  ResourceSymbolKey
-) as Resource.ResourceTypeId
-
-const resourceVariance = {
-  /* c8 ignore next */
-  _E: (_: any) => _,
-  /* c8 ignore next */
-  _A: (_: any) => _
-}
-
-/** @internal  */
-const proto: ThisType<Resource.Resource<any, any>> = {
-  ...effectable.CommitPrototype,
-  commit() {
-    return get(this)
-  },
-  [ResourceTypeId]: resourceVariance
-}
-
-/** @internal */
-export const auto = <A, E, R, Out, R2>(
-  acquire: Effect.Effect<A, E, R>,
-  policy: Schedule.Schedule<Out, unknown, R2>
-): Effect.Effect<Resource.Resource<A, E>, never, R | R2 | Scope.Scope> =>
-  core.tap(manual(acquire), (manual) =>
-    fiberRuntime.acquireRelease(
-      pipe(
-        refresh(manual),
-        schedule_.schedule_Effect(policy),
-        core.interruptible,
-        fiberRuntime.forkDaemon
-      ),
-      core.interruptFiber
-    ))
-
-/** @internal */
-export const manual = <A, E, R>(
-  acquire: Effect.Effect<A, E, R>
-): Effect.Effect<Resource.Resource<A, E>, never, R | Scope.Scope> =>
-  core.flatMap(core.context<R>(), (env) =>
-    pipe(
-      scopedRef.fromAcquire(core.exit(acquire)),
-      core.map((ref) => {
-        const resource = Object.create(proto)
-        resource.scopedRef = ref
-        resource.acquire = core.provideContext(acquire, env)
-        return resource
-      })
-    ))
-
-/** @internal */
-export const get = <A, E>(self: Resource.Resource<A, E>): Effect.Effect<A, E> =>
-  core.flatMap(scopedRef.get(self.scopedRef), identity)
-
-/** @internal */
-export const refresh = <A, E>(self: Resource.Resource<A, E>): Effect.Effect<void, E> =>
-  scopedRef.set(
-    self.scopedRef,
-    core.map(self.acquire, core.exitSucceed)
-  )

package/src/internal/ringBuffer.ts

@@ -1,68 +0,0 @@
-import * as Chunk from "../Chunk.js"
-import { constUndefined } from "../Function.js"
-import * as Option from "../Option.js"
-
-/** @internal */
-export class RingBuffer<out A> {
-  private array: Array<A | undefined>
-  private size = 0
-  private current = 0
-
-  constructor(public readonly capacity: number) {
-    this.array = Array.from({ length: capacity }, constUndefined)
-  }
-
-  head(): Option.Option<A> {
-    return Option.fromNullable(this.array[this.current])
-  }
-
-  lastOrNull(): A | undefined {
-    if (this.size === 0) {
-      return undefined
-    }
-
-    const index = this.current === 0 ? this.array.length - 1 : this.current - 1
-
-    return this.array[index] ?? undefined
-  }
-
-  put(value: A): void {
-    this.array[this.current] = value
-    this.increment()
-  }
-
-  dropLast(): void {
-    if (this.size > 0) {
-      this.decrement()
-      this.array[this.current] = undefined
-    }
-  }
-
-  toChunk(): Chunk.Chunk<A> {
-    const begin = this.current - this.size
-    const newArray = begin < 0
-      ? [
-        ...this.array.slice(this.capacity + begin, this.capacity),
-        ...this.array.slice(0, this.current)
-      ]
-      : this.array.slice(begin, this.current)
-
-    return Chunk.fromIterable(newArray) as Chunk.Chunk<A>
-  }
-
-  private increment(): void {
-    if (this.size < this.capacity) {
-      this.size += 1
-    }
-    this.current = (this.current + 1) % this.capacity
-  }
-
-  private decrement(): void {
-    this.size -= 1
-    if (this.current > 0) {
-      this.current -= 1
-    } else {
-      this.current = this.capacity - 1
-    }
-  }
-}