@clayroach/effect 3.19.14-source-capture.8 → 3.19.14-source-trace.2

package/src/internal/redacted.ts

@@ -0,0 +1,73 @@
+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

@@ -0,0 +1,171 @@
+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

@@ -0,0 +1,140 @@
+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

@@ -0,0 +1,177 @@
+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

@@ -0,0 +1,76 @@
+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

@@ -0,0 +1,68 @@
+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
+    }
+  }
+}