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

package/src/internal/random.ts

@@ -0,0 +1,88 @@
+import * as Chunk from "../Chunk"
+import * as Context from "../Context"
+import type * as Effect from "../Effect"
+import { pipe } from "../Function"
+import * as core from "../internal/core"
+import type * as Random from "../Random"
+import * as PCGRandom from "../Utils"
+
+/** @internal */
+const RandomSymbolKey = "effect/Random"
+
+/** @internal */
+export const RandomTypeId: Random.RandomTypeId = Symbol.for(
+  RandomSymbolKey
+) as Random.RandomTypeId
+
+/** @internal */
+export const randomTag: Context.Tag<Random.Random, Random.Random> = Context.Tag(RandomTypeId)
+/** @internal */
+class RandomImpl implements Random.Random {
+  readonly [RandomTypeId]: Random.RandomTypeId = RandomTypeId
+
+  readonly PRNG: PCGRandom.PCGRandom
+
+  constructor(readonly seed: number) {
+    this.PRNG = new PCGRandom.PCGRandom(seed)
+  }
+
+  next(): Effect.Effect<never, never, number> {
+    return core.sync(() => this.PRNG.number())
+  }
+
+  nextBoolean(): Effect.Effect<never, never, boolean> {
+    return core.map(this.next(), (n) => n > 0.5)
+  }
+
+  nextInt(): Effect.Effect<never, never, number> {
+    return core.sync(() => this.PRNG.integer(Number.MAX_SAFE_INTEGER))
+  }
+
+  nextRange(min: number, max: number): Effect.Effect<never, never, number> {
+    return core.map(this.next(), (n) => (max - min) * n + min)
+  }
+
+  nextIntBetween(min: number, max: number): Effect.Effect<never, never, number> {
+    return core.sync(() => this.PRNG.integer(max - min) + min)
+  }
+
+  shuffle<A>(elements: Iterable<A>): Effect.Effect<never, never, Chunk.Chunk<A>> {
+    return shuffleWith(elements, (n) => this.nextIntBetween(0, n + 1))
+  }
+}
+
+const shuffleWith = <A>(
+  elements: Iterable<A>,
+  nextIntBounded: (n: number) => Effect.Effect<never, never, number>
+): Effect.Effect<never, never, Chunk.Chunk<A>> => {
+  return core.suspend(() =>
+    pipe(
+      core.sync(() => Array.from(elements)),
+      core.flatMap((buffer) => {
+        const numbers: Array<number> = []
+        for (let i = buffer.length; i >= 2; i = i - 1) {
+          numbers.push(i)
+        }
+        return pipe(
+          numbers,
+          core.forEachSequentialDiscard((n) =>
+            pipe(
+              nextIntBounded(n),
+              core.map((k) => swap(buffer, n - 1, k))
+            )
+          ),
+          core.as(Chunk.fromIterable(buffer))
+        )
+      })
+    )
+  )
+}
+
+const swap = <A>(buffer: Array<A>, index1: number, index2: number): Array<A> => {
+  const tmp = buffer[index1]!
+  buffer[index1] = buffer[index2]!
+  buffer[index2] = tmp
+  return buffer
+}
+
+export const make = (seed: number): Random.Random => new RandomImpl(seed)

package/src/internal/ref.ts

@@ -0,0 +1,164 @@
+import type * as Effect from "../Effect"
+import { dual } from "../Function"
+import * as core from "../internal/core"
+import * as MutableRef from "../MutableRef"
+import * as Option from "../Option"
+import { pipeArguments } from "../Pipeable"
+import type * as Ref from "../Ref"
+
+/** @internal */
+export const RefTypeId: Ref.RefTypeId = Symbol.for("effect/Ref") as Ref.RefTypeId
+
+/** @internal */
+export const refVariance = {
+  _A: (_: never) => _
+}
+
+class RefImpl<A> implements Ref.Ref<A> {
+  readonly [RefTypeId] = refVariance
+  constructor(readonly ref: MutableRef.MutableRef<A>) {}
+  modify<B>(f: (a: A) => readonly [B, A]): Effect.Effect<never, never, 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
+    })
+  }
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+/** @internal */
+export const unsafeMake = <A>(value: A): Ref.Ref<A> => new RefImpl(MutableRef.make(value))
+
+/** @internal */
+export const make = <A>(value: A): Effect.Effect<never, never, Ref.Ref<A>> => core.sync(() => unsafeMake(value))
+
+/** @internal */
+export const get = <A>(self: Ref.Ref<A>) => self.modify((a) => [a, a])
+
+/** @internal */
+export const set = dual<
+  <A>(value: A) => (self: Ref.Ref<A>) => Effect.Effect<never, never, void>,
+  <A>(self: Ref.Ref<A>, value: A) => Effect.Effect<never, never, 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<never, never, A>,
+  <A>(self: Ref.Ref<A>, value: A) => Effect.Effect<never, never, 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<never, never, A>,
+  <A>(self: Ref.Ref<A>, f: (a: A) => A) => Effect.Effect<never, never, 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<never, never, A>,
+  <A>(self: Ref.Ref<A>, pf: (a: A) => Option.Option<A>) => Effect.Effect<never, never, 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<never, never, A>,
+  <A>(self: Ref.Ref<A>, value: A) => Effect.Effect<never, never, 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<never, never, B>,
+  <A, B>(self: Ref.Ref<A>, f: (a: A) => readonly [B, A]) => Effect.Effect<never, never, 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<never, never, B>,
+  <A, B>(
+    self: Ref.Ref<A>,
+    fallback: B,
+    pf: (a: A) => Option.Option<readonly [B, A]>
+  ) => Effect.Effect<never, never, B>
+>(3, (self, fallback, pf) =>
+  self.modify((value) => {
+    const option = pf(value)
+    switch (option._tag) {
+      case "None": {
+        return [fallback, value] as const
+      }
+      case "Some": {
+        return option.value
+      }
+    }
+  }))
+
+/** @internal */
+export const update = dual<
+  <A>(f: (a: A) => A) => (self: Ref.Ref<A>) => Effect.Effect<never, never, void>,
+  <A>(self: Ref.Ref<A>, f: (a: A) => A) => Effect.Effect<never, never, 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<never, never, A>,
+  <A>(self: Ref.Ref<A>, f: (a: A) => A) => Effect.Effect<never, never, 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<never, never, void>,
+  <A>(self: Ref.Ref<A>, f: (a: A) => Option.Option<A>) => Effect.Effect<never, never, 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<never, never, A>,
+  <A>(self: Ref.Ref<A>, pf: (a: A) => Option.Option<A>) => Effect.Effect<never, never, 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,164 @@
+import * as Context from "../Context"
+import type * as Effect from "../Effect"
+import { pipe } from "../Function"
+import { globalValue } from "../GlobalValue"
+import * as core from "../internal/core"
+import * as effect from "../internal/core-effect"
+import * as fiberRuntime from "../internal/fiberRuntime"
+import * as _layer from "../internal/layer"
+import * as _schedule from "../internal/schedule"
+import * as scopedRef from "../internal/scopedRef"
+import type * as Layer from "../Layer"
+import type * as Reloadable from "../Reloadable"
+import type * as Schedule from "../Schedule"
+
+/** @internal */
+const ReloadableSymbolKey = "effect/Reloadable"
+
+/** @internal */
+export const ReloadableTypeId: Reloadable.ReloadableTypeId = Symbol.for(
+  ReloadableSymbolKey
+) as Reloadable.ReloadableTypeId
+
+/** @internal */
+const reloadableVariance = {
+  _A: (_: never) => _
+}
+
+/** @internal */
+export const auto = <Out extends Context.Tag<any, any>, In, E, R>(
+  tag: Out,
+  options: {
+    readonly layer: Layer.Layer<In, E, Context.Tag.Identifier<Out>>
+    readonly schedule: Schedule.Schedule<R, unknown, unknown>
+  }
+): Layer.Layer<
+  R | In,
+  E,
+  Reloadable.Reloadable<Context.Tag.Identifier<Out>>
+> =>
+  _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 = <Out extends Context.Tag<any, any>, In, E, R>(
+  tag: Out,
+  options: {
+    readonly layer: Layer.Layer<In, E, Context.Tag.Identifier<Out>>
+    readonly scheduleFromConfig: (context: Context.Context<In>) => Schedule.Schedule<R, unknown, unknown>
+  }
+): Layer.Layer<
+  R | In,
+  E,
+  Reloadable.Reloadable<Context.Tag.Identifier<Out>>
+> =>
+  _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 = <T extends Context.Tag<any, any>>(
+  tag: T
+): Effect.Effect<Reloadable.Reloadable<Context.Tag.Identifier<T>>, never, Context.Tag.Service<T>> =>
+  core.flatMap(
+    reloadableTag(tag),
+    (reloadable) => scopedRef.get(reloadable.scopedRef)
+  )
+
+/** @internal */
+export const manual = <Out extends Context.Tag<any, any>, In, E>(
+  tag: Out,
+  options: {
+    readonly layer: Layer.Layer<In, E, Context.Tag.Identifier<Out>>
+  }
+): Layer.Layer<In, E, Reloadable.Reloadable<Context.Tag.Identifier<Out>>> =>
+  _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 */
+const tagMap = globalValue(
+  Symbol.for("effect/Reloadable/tagMap"),
+  () => new WeakMap<Context.Tag<any, any>, Context.Tag<any, any>>([])
+)
+
+/** @internal */
+export const reloadableTag = <T extends Context.Tag<any, any>>(
+  tag: T
+): Context.Tag<Reloadable.Reloadable<Context.Tag.Identifier<T>>, Reloadable.Reloadable<Context.Tag.Service<T>>> => {
+  if (tagMap.has(tag)) {
+    return tagMap.get(tag)!
+  }
+  const newTag = Context.Tag<
+    Reloadable.Reloadable<Context.Tag.Identifier<T>>,
+    Reloadable.Reloadable<Context.Tag.Service<T>>
+  >()
+  tagMap.set(tag, newTag)
+  return newTag
+}
+
+/** @internal */
+export const reload = <T extends Context.Tag<any, any>>(
+  tag: T
+): Effect.Effect<Reloadable.Reloadable<Context.Tag.Identifier<T>>, unknown, void> =>
+  core.flatMap(
+    reloadableTag(tag),
+    (reloadable) => reloadable.reload()
+  )
+
+/** @internal */
+export const reloadFork = <T extends Context.Tag<any, any>>(
+  tag: T
+): Effect.Effect<Reloadable.Reloadable<Context.Tag.Identifier<T>>, unknown, void> =>
+  core.flatMap(reloadableTag(tag), (reloadable) =>
+    pipe(
+      reloadable.reload(),
+      effect.ignoreLogged,
+      fiberRuntime.forkDaemon,
+      core.asUnit
+    ))

package/src/internal/request.ts

@@ -0,0 +1,137 @@
+import type * as Effect from "../Effect"
+import { dual } from "../Function"
+import * as completedRequestMap from "../internal/completedRequestMap"
+import * as core from "../internal/core"
+import type * as Request from "../Request"
+import * as Data from "./Data"
+
+/** @internal */
+const RequestSymbolKey = "effect/Request"
+
+/** @internal */
+export const RequestTypeId: Request.RequestTypeId = Symbol.for(
+  RequestSymbolKey
+) as Request.RequestTypeId
+
+/** @internal */
+const requestVariance = {
+  _E: (_: never) => _,
+  _A: (_: never) => _
+}
+
+/** @internal */
+export const isRequest = (u: unknown): u is Request.Request<unknown, unknown> =>
+  typeof u === "object" && u != null && RequestTypeId in u
+
+/** @internal */
+export const of = <R extends Request.Request<any, any>>(): Request.Request.Constructor<R> => (args) =>
+  // @ts-expect-error
+  Data.struct({
+    [RequestTypeId]: requestVariance,
+    ...args
+  })
+
+/** @internal */
+export const tagged = <R extends Request.Request<any, any> & { _tag: string }>(
+  tag: R["_tag"]
+): Request.Request.Constructor<R, "_tag"> =>
+(args) =>
+  // @ts-expect-error
+  Data.struct({
+    [RequestTypeId]: requestVariance,
+    _tag: tag,
+    ...args
+  })
+
+/** @internal */
+export const complete = dual<
+  <A extends Request.Request<any, any>>(
+    result: Request.Request.Result<A>
+  ) => (self: A) => Effect.Effect<never, never, void>,
+  <A extends Request.Request<any, any>>(
+    self: A,
+    result: Request.Request.Result<A>
+  ) => Effect.Effect<never, never, 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<R, Request.Request.Error<A>, Request.Request.Success<A>>
+  ) => (self: A) => Effect.Effect<R, never, void>,
+  <A extends Request.Request<any, any>, R>(
+    self: A,
+    effect: Effect.Effect<R, Request.Request.Error<A>, Request.Request.Success<A>>
+  ) => Effect.Effect<R, never, void>
+>(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<never, never, void>,
+  <A extends Request.Request<any, any>>(
+    self: A,
+    error: Request.Request.Error<A>
+  ) => Effect.Effect<never, never, void>
+>(2, (self, error) => complete(self, core.exitFail(error) as any))
+
+/** @internal */
+export const succeed = dual<
+  <A extends Request.Request<any, any>>(
+    value: Request.Request.Success<A>
+  ) => (self: A) => Effect.Effect<never, never, void>,
+  <A extends Request.Request<any, any>>(
+    self: A,
+    value: Request.Request.Success<A>
+  ) => Effect.Effect<never, never, void>
+>(2, (self, value) => complete(self, core.exitSucceed(value) as any))
+
+/** @internal */
+export class Listeners {
+  count = 0
+  observers: Set<(count: number) => void> = new Set()
+  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,64 @@
+import type * as Effect from "../Effect"
+import { identity, pipe } from "../Function"
+import * as core from "../internal/core"
+import * as fiberRuntime from "../internal/fiberRuntime"
+import * as _schedule from "../internal/schedule"
+import * as scopedRef from "../internal/scopedRef"
+import type * as Resource from "../Resource"
+import type * as Schedule from "../Schedule"
+import type * as Scope from "../Scope"
+
+/** @internal */
+const ResourceSymbolKey = "effect/Resource"
+
+/** @internal */
+export const ResourceTypeId: Resource.ResourceTypeId = Symbol.for(
+  ResourceSymbolKey
+) as Resource.ResourceTypeId
+
+/** @internal */
+const cachedVariance = {
+  _E: (_: never) => _,
+  _A: (_: never) => _
+}
+
+/** @internal */
+export const auto = <R, E, A, R2, Out>(
+  acquire: Effect.Effect<R, E, A>,
+  policy: Schedule.Schedule<R2, unknown, Out>
+): Effect.Effect<R | R2 | Scope.Scope, never, Resource.Resource<E, A>> =>
+  core.tap(manual(acquire), (manual) =>
+    fiberRuntime.acquireRelease(
+      pipe(
+        refresh(manual),
+        _schedule.schedule_Effect(policy),
+        core.interruptible,
+        fiberRuntime.forkDaemon
+      ),
+      core.interruptFiber
+    ))
+
+/** @internal */
+export const manual = <R, E, A>(
+  acquire: Effect.Effect<R, E, A>
+): Effect.Effect<R | Scope.Scope, never, Resource.Resource<E, A>> =>
+  core.flatMap(core.context<R>(), (env) =>
+    pipe(
+      scopedRef.fromAcquire(core.exit(acquire)),
+      core.map((ref) => ({
+        [ResourceTypeId]: cachedVariance,
+        scopedRef: ref,
+        acquire: () => core.provideContext(acquire, env)
+      }))
+    ))
+
+/** @internal */
+export const get = <E, A>(self: Resource.Resource<E, A>): Effect.Effect<never, E, A> =>
+  core.flatMap(scopedRef.get(self.scopedRef), identity)
+
+/** @internal */
+export const refresh = <E, A>(self: Resource.Resource<E, A>): Effect.Effect<never, E, void> =>
+  scopedRef.set(
+    self.scopedRef,
+    core.map(self.acquire(), core.exitSucceed)
+  )

package/src/internal/ringBuffer.ts

@@ -0,0 +1,68 @@
+import * as Chunk from "../Chunk"
+import { constUndefined } from "../Function"
+import * as Option from "../Option"
+
+/** @internal */
+export class RingBuffer<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
+    }
+  }
+}