effect 4.0.0-beta.4 → 4.0.0-beta.6

package/src/SchemaGetter.ts

@@ -86,11 +86,9 @@
  */
 import * as DateTime from "./DateTime.ts"
 import * as Effect from "./Effect.ts"
-import * as Base64 from "./encoding/Base64.ts"
-import * as Base64Url from "./encoding/Base64Url.ts"
-import * as Hex from "./encoding/Hex.ts"
+import * as Encoding from "./Encoding.ts"
 import * as Option from "./Option.ts"
-import { Class } from "./Pipeable.ts"
+import * as Pipeable from "./Pipeable.ts"
 import * as Predicate from "./Predicate.ts"
 import * as Result from "./Result.ts"
 import type * as Schema from "./Schema.ts"
@@ -136,7 +134,7 @@ import * as Str from "./String.ts"
  * @category model
  * @since 4.0.0
  */
-export class Getter<out T, in E, R = never> extends Class {
+export class Getter<out T, in E, R = never> extends Pipeable.Class {
   readonly run: (
     input: Option.Option<E>,
     options: AST.ParseOptions
@@ -1218,7 +1216,7 @@ export function split<E extends string>(options?: {
  * @since 4.0.0
  */
 export function encodeBase64<E extends Uint8Array | string>(): Getter<string, E> {
-  return transform(Base64.encode)
+  return transform(Encoding.encodeBase64)
 }
 
 /**
@@ -1244,7 +1242,7 @@ export function encodeBase64<E extends Uint8Array | string>(): Getter<string, E>
  * @since 4.0.0
  */
 export function encodeBase64Url<E extends Uint8Array | string>(): Getter<string, E> {
-  return transform(Base64Url.encode)
+  return transform(Encoding.encodeBase64Url)
 }
 
 /**
@@ -1269,7 +1267,7 @@ export function encodeBase64Url<E extends Uint8Array | string>(): Getter<string,
  * @since 4.0.0
  */
 export function encodeHex<E extends Uint8Array | string>(): Getter<string, E> {
-  return transform(Hex.encode)
+  return transform(Encoding.encodeHex)
 }
 
 /**
@@ -1297,7 +1295,7 @@ export function encodeHex<E extends Uint8Array | string>(): Getter<string, E> {
 export function decodeBase64<E extends string>(): Getter<Uint8Array, E> {
   return transformOrFail((input) =>
     Result.mapError(
-      Base64.decode(input),
+      Encoding.decodeBase64(input),
       (e) => new Issue.InvalidValue(Option.some(input), { message: e.message })
     ).asEffect()
   )
@@ -1327,7 +1325,7 @@ export function decodeBase64<E extends string>(): Getter<Uint8Array, E> {
  */
 export function decodeBase64String<E extends string>(): Getter<string, E> {
   return transformOrFail((input) =>
-    Result.match(Base64.decodeString(input), {
+    Result.match(Encoding.decodeBase64String(input), {
       onFailure: (e) => Effect.fail(new Issue.InvalidValue(Option.some(input), { message: e.message })),
       onSuccess: Effect.succeed
     })
@@ -1358,7 +1356,7 @@ export function decodeBase64String<E extends string>(): Getter<string, E> {
  */
 export function decodeBase64Url<E extends string>(): Getter<Uint8Array, E> {
   return transformOrFail((input) =>
-    Result.match(Base64Url.decode(input), {
+    Result.match(Encoding.decodeBase64Url(input), {
       onFailure: (e) => Effect.fail(new Issue.InvalidValue(Option.some(input), { message: e.message })),
       onSuccess: Effect.succeed
     })
@@ -1389,7 +1387,7 @@ export function decodeBase64Url<E extends string>(): Getter<Uint8Array, E> {
  */
 export function decodeBase64UrlString<E extends string>(): Getter<string, E> {
   return transformOrFail((input) =>
-    Result.match(Base64Url.decodeString(input), {
+    Result.match(Encoding.decodeBase64UrlString(input), {
       onFailure: (e) => Effect.fail(new Issue.InvalidValue(Option.some(input), { message: e.message })),
       onSuccess: Effect.succeed
     })
@@ -1420,7 +1418,7 @@ export function decodeBase64UrlString<E extends string>(): Getter<string, E> {
  */
 export function decodeHex<E extends string>(): Getter<Uint8Array, E> {
   return transformOrFail((input) =>
-    Result.match(Hex.decode(input), {
+    Result.match(Encoding.decodeHex(input), {
       onFailure: (e) => Effect.fail(new Issue.InvalidValue(Option.some(input), { message: e.message })),
       onSuccess: Effect.succeed
     })
@@ -1451,7 +1449,7 @@ export function decodeHex<E extends string>(): Getter<Uint8Array, E> {
  */
 export function decodeHexString<E extends string>(): Getter<string, E> {
   return transformOrFail((input) =>
-    Result.match(Hex.decodeString(input), {
+    Result.match(Encoding.decodeHexString(input), {
       onFailure: (e) => Effect.fail(new Issue.InvalidValue(Option.some(input), { message: e.message })),
       onSuccess: Effect.succeed
     })

package/src/SchemaRepresentation.ts

@@ -1698,7 +1698,8 @@ export type Reviver<T> = (declaration: Declaration, recur: (representation: Repr
 
 /**
  * Default {@link Reviver} for {@link toSchema} that handles built-in Effect
- * types (Option, Result, Redacted, Cause, Exit, ReadonlyMap, ReadonlySet,
+ * types (Option, Result, Redacted, Cause, Exit, ReadonlyMap, HashMap,
+ * ReadonlySet,
  * Date, Duration, URL, RegExp, etc.).
  *
  * - Pass as `options.reviver` to {@link toSchema} to reconstruct schemas that
@@ -1723,7 +1724,7 @@ export const toSchemaDefaultReviver: Reviver<Schema.Top> = (s, recur) => {
       case "effect/Redacted":
         return Schema.Redacted(typeParameters[0])
       case "effect/Cause/Failure":
-        return Schema.CauseFailure(typeParameters[0], typeParameters[1])
+        return Schema.CauseReason(typeParameters[0], typeParameters[1])
       case "effect/Cause":
         return Schema.Cause(typeParameters[0], typeParameters[1])
       case "Error":
@@ -1732,6 +1733,8 @@ export const toSchemaDefaultReviver: Reviver<Schema.Top> = (s, recur) => {
         return Schema.Exit(typeParameters[0], typeParameters[1], typeParameters[2])
       case "ReadonlyMap":
         return Schema.ReadonlyMap(typeParameters[0], typeParameters[1])
+      case "effect/HashMap":
+        return Schema.HashMap(typeParameters[0], typeParameters[1])
       case "ReadonlySet":
         return Schema.ReadonlySet(typeParameters[0])
       case "RegExp":

package/src/SchemaTransformation.ts

@@ -82,6 +82,8 @@
  * @since 4.0.0
  */
 
+import * as BigDecimal from "./BigDecimal.ts"
+import * as DateTime from "./DateTime.ts"
 import * as Duration from "./Duration.ts"
 import * as Effect from "./Effect.ts"
 import * as Option from "./Option.ts"
@@ -1136,6 +1138,33 @@ export const urlFromString: Transformation<URL, string> = transformOrFail<URL, s
   encode: (url) => Effect.succeed(url.href)
 })
 
+/**
+ * Decodes a `string` into a `BigDecimal` and encodes a `BigDecimal` back to
+ * its string representation.
+ *
+ * When to use this:
+ * - Parsing decimal number strings from APIs or user input.
+ *
+ * Behavior:
+ * - Decode: calls `BigDecimal.fromString(s)`. Fails with `InvalidValue` if the
+ *   string is not a valid BigDecimal representation.
+ * - Encode: returns `BigDecimal.format(bd)`.
+ *
+ * @since 4.0.0
+ */
+export const bigDecimalFromString: Transformation<BigDecimal.BigDecimal, string> = transformOrFail<
+  BigDecimal.BigDecimal,
+  string
+>({
+  decode: (s) => {
+    const result = BigDecimal.fromString(s)
+    return result === undefined
+      ? Effect.fail(new Issue.InvalidValue(Option.some(s), { message: `Invalid BigDecimal string: ${s}` }))
+      : Effect.succeed(result)
+  },
+  encode: (bd) => Effect.succeed(BigDecimal.format(bd))
+})
+
 /**
  * Decodes a Base64-encoded `string` into a `Uint8Array` and encodes a
  * `Uint8Array` back to a Base64 string.
@@ -1264,3 +1293,78 @@ export const fromURLSearchParams = new Transformation<unknown, URLSearchParams>(
   Getter.decodeURLSearchParams(),
   Getter.encodeURLSearchParams()
 )
+
+/**
+ * @since 4.0.0
+ */
+export const timeZoneOffsetFromNumber: Transformation<DateTime.TimeZone.Offset, number> = transform<
+  DateTime.TimeZone.Offset,
+  number
+>({
+  decode: (n) => DateTime.zoneMakeOffset(n),
+  encode: (tz) => tz.offset
+})
+
+/**
+ * @since 4.0.0
+ */
+export const timeZoneNamedFromString: Transformation<DateTime.TimeZone.Named, string> = transformOrFail<
+  DateTime.TimeZone.Named,
+  string
+>({
+  decode: (s) => {
+    const result = DateTime.zoneMakeNamed(s)
+    return result === undefined
+      ? Effect.fail(new Issue.InvalidValue(Option.some(s), { message: `Invalid IANA time zone: ${s}` }))
+      : Effect.succeed(result)
+  },
+  encode: (tz) => Effect.succeed(tz.id)
+})
+
+/**
+ * @since 4.0.0
+ */
+export const timeZoneFromString: Transformation<DateTime.TimeZone, string> = transformOrFail<
+  DateTime.TimeZone,
+  string
+>({
+  decode: (s) => {
+    const result = DateTime.zoneFromString(s)
+    return result === undefined
+      ? Effect.fail(new Issue.InvalidValue(Option.some(s), { message: `Invalid time zone: ${s}` }))
+      : Effect.succeed(result)
+  },
+  encode: (tz) => Effect.succeed(DateTime.zoneToString(tz))
+})
+
+/**
+ * @since 4.0.0
+ */
+export const dateTimeUtcFromString: Transformation<DateTime.Utc, string> = transformOrFail<
+  DateTime.Utc,
+  string
+>({
+  decode: (s) => {
+    const result = DateTime.make(s)
+    return result === undefined
+      ? Effect.fail(new Issue.InvalidValue(Option.some(s), { message: "Invalid DateTime input" }))
+      : Effect.succeed(DateTime.toUtc(result))
+  },
+  encode: (utc) => Effect.succeed(DateTime.formatIso(utc))
+})
+
+/**
+ * @since 4.0.0
+ */
+export const dateTimeZonedFromString: Transformation<DateTime.Zoned, string> = transformOrFail<
+  DateTime.Zoned,
+  string
+>({
+  decode: (s) => {
+    const result = DateTime.makeZonedFromString(s)
+    return result === undefined
+      ? Effect.fail(new Issue.InvalidValue(Option.some(s), { message: `Invalid zoned DateTime string: ${s}` }))
+      : Effect.succeed(result)
+  },
+  encode: (zoned) => Effect.succeed(DateTime.formatIsoZoned(zoned))
+})

package/src/Semaphore.ts

@@ -0,0 +1,356 @@
+/**
+ * @since 2.0.0
+ */
+import * as Effect from "./Effect.ts"
+import * as internal from "./internal/effect.ts"
+import * as MutableHashMap from "./MutableHashMap.ts"
+import * as Option from "./Option.ts"
+
+/**
+ * @category models
+ * @since 2.0.0
+ * @example
+ * ```ts
+ * import { Effect, Semaphore } from "effect"
+ *
+ * // Create and use a semaphore for controlling concurrent access
+ * const program = Effect.gen(function*() {
+ *   const semaphore = yield* Semaphore.make(2)
+ *
+ *   return yield* semaphore.withPermits(1)(
+ *     Effect.succeed("Resource accessed")
+ *   )
+ * })
+ * ```
+ */
+export interface Semaphore {
+  /**
+   * Adjusts the number of permits available in the semaphore.
+   */
+  resize(permits: number): Effect.Effect<void>
+
+  /**
+   * Runs an effect with the given number of permits and releases the permits
+   * when the effect completes.
+   *
+   * **Details**
+   *
+   * This function acquires the specified number of permits before executing
+   * the provided effect. Once the effect finishes, the permits are released.
+   * If insufficient permits are available, the function will wait until they
+   * are released by other tasks.
+   */
+  withPermits(permits: number): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+
+  /**
+   * Runs an effect with the given number of permits and releases the permits
+   * when the effect completes.
+   *
+   * **Details**
+   *
+   * This function acquires the specified number of permits before executing
+   * the provided effect. Once the effect finishes, the permits are released.
+   * If insufficient permits are available, the function will wait until they
+   * are released by other tasks.
+   */
+  withPermit<A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>
+
+  /**
+   * Runs an effect only if the specified number of permits are immediately
+   * available.
+   *
+   * **Details**
+   *
+   * This function attempts to acquire the specified number of permits. If they
+   * are available, it runs the effect and releases the permits after the effect
+   * completes. If permits are not available, the effect does not execute, and
+   * the result is `Option.none`.
+   */
+  withPermitsIfAvailable(
+    permits: number
+  ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<Option.Option<A>, E, R>
+
+  /**
+   * Acquires the specified number of permits and returns the resulting
+   * available permits, suspending the task if they are not yet available.
+   * Concurrent pending `take` calls are processed in a first-in, first-out manner.
+   */
+  take(permits: number): Effect.Effect<number>
+
+  /**
+   * Releases the specified number of permits and returns the resulting
+   * available permits.
+   */
+  release(permits: number): Effect.Effect<number>
+
+  /**
+   * Releases all permits held by this semaphore and returns the resulting available permits.
+   */
+  releaseAll: Effect.Effect<number>
+}
+
+/**
+ * Unsafely creates a new Semaphore.
+ *
+ * **Previously Known As**
+ *
+ * This API replaces the following from Effect 3.x:
+ *
+ * - `Effect.makeSemaphoreUnsafe`
+ *
+ * @example
+ * ```ts
+ * import { Effect, Semaphore } from "effect"
+ *
+ * const semaphore = Semaphore.makeUnsafe(3)
+ *
+ * const task = (id: number) =>
+ *   semaphore.withPermits(1)(
+ *     Effect.gen(function*() {
+ *       yield* Effect.log(`Task ${id} started`)
+ *       yield* Effect.sleep("1 second")
+ *       yield* Effect.log(`Task ${id} completed`)
+ *     })
+ *   )
+ *
+ * // Only 3 tasks can run concurrently
+ * const program = Effect.all([
+ *   task(1),
+ *   task(2),
+ *   task(3),
+ *   task(4),
+ *   task(5)
+ * ], { concurrency: "unbounded" })
+ * ```
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const makeUnsafe: (permits: number) => Semaphore = internal.makeSemaphoreUnsafe
+
+/**
+ * Creates a new Semaphore.
+ *
+ * **Previously Known As**
+ *
+ * This API replaces the following from Effect 3.x:
+ *
+ * - `Effect.makeSemaphore`
+ *
+ * @example
+ * ```ts
+ * import { Effect, Semaphore } from "effect"
+ *
+ * const program = Effect.gen(function*() {
+ *   const semaphore = yield* Semaphore.make(2)
+ *
+ *   const task = (id: number) =>
+ *     semaphore.withPermits(1)(
+ *       Effect.gen(function*() {
+ *         yield* Effect.log(`Task ${id} acquired permit`)
+ *         yield* Effect.sleep("1 second")
+ *         yield* Effect.log(`Task ${id} releasing permit`)
+ *       })
+ *     )
+ *
+ *   // Run 4 tasks, but only 2 can run concurrently
+ *   yield* Effect.all([task(1), task(2), task(3), task(4)])
+ * })
+ * ```
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make: (permits: number) => Effect.Effect<Semaphore> = internal.makeSemaphore
+
+// -----------------------------------------------------------------------------
+// Partitioned
+// -----------------------------------------------------------------------------
+
+/**
+ * @since 3.19.4
+ * @category models
+ */
+export const PartitionedTypeId: PartitionedTypeId = "~effect/PartitionedSemaphore"
+
+/**
+ * @since 3.19.4
+ * @category models
+ */
+export type PartitionedTypeId = "~effect/PartitionedSemaphore"
+
+/**
+ * A `Partitioned` semaphore controls access to a shared permit pool while
+ * tracking waiters by partition key.
+ *
+ * Waiting permits are distributed across partitions in round-robin order.
+ *
+ * **Previously Known As**
+ *
+ * This API replaces the following from Effect 3.x:
+ *
+ * - `PartitionedSemaphore.PartitionedSemaphore`
+ *
+ * @since 3.19.4
+ * @category models
+ */
+export interface Partitioned<in K> {
+  readonly [PartitionedTypeId]: PartitionedTypeId
+  readonly withPermits: (
+    key: K,
+    permits: number
+  ) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+}
+
+/**
+ * Creates a `Partitioned` semaphore unsafely.
+ *
+ * **Previously Known As**
+ *
+ * This API replaces the following from Effect 3.x:
+ *
+ * - `PartitionedSemaphore.makeUnsafe`
+ *
+ * @since 3.19.4
+ * @category constructors
+ */
+export const makePartitionedUnsafe = <K = unknown>(options: {
+  readonly permits: number
+}): Partitioned<K> => {
+  const maxPermits = Math.max(0, options.permits)
+
+  if (!Number.isFinite(maxPermits)) {
+    return {
+      [PartitionedTypeId]: PartitionedTypeId,
+      withPermits: () => (effect) => effect
+    }
+  }
+
+  let totalPermits = maxPermits
+  let waitingPermits = 0
+
+  type Waiter = {
+    permits: number
+    readonly resume: () => void
+  }
+  const partitions = MutableHashMap.empty<K, Set<Waiter>>()
+
+  const take = (key: K, permits: number) =>
+    Effect.callback<void>((resume) => {
+      if (maxPermits < permits) {
+        resume(Effect.never)
+        return
+      }
+
+      if (totalPermits >= permits) {
+        totalPermits -= permits
+        resume(Effect.void)
+        return
+      }
+
+      const needed = permits - totalPermits
+      const taken = permits - needed
+      if (totalPermits > 0) {
+        totalPermits = 0
+      }
+      waitingPermits += needed
+
+      const waiters = Option.getOrElse(
+        MutableHashMap.get(partitions, key),
+        () => {
+          const set = new Set<Waiter>()
+          MutableHashMap.set(partitions, key, set)
+          return set
+        }
+      )
+
+      const entry: Waiter = {
+        permits: needed,
+        resume: () => {
+          cleanup()
+          resume(Effect.void)
+        }
+      }
+
+      const cleanup = () => {
+        waiters.delete(entry)
+        if (waiters.size === 0) {
+          MutableHashMap.remove(partitions, key)
+        }
+      }
+
+      waiters.add(entry)
+
+      return Effect.sync(() => {
+        cleanup()
+        waitingPermits -= entry.permits
+        if (taken > 0) {
+          releaseUnsafe(taken)
+        }
+      })
+    })
+
+  let iterator = partitions[Symbol.iterator]()
+
+  const releaseUnsafe = (permits: number): void => {
+    while (permits > 0) {
+      if (waitingPermits === 0) {
+        totalPermits += permits
+        return
+      }
+
+      let state = iterator.next()
+      if (state.done) {
+        iterator = partitions[Symbol.iterator]()
+        state = iterator.next()
+        if (state.done) {
+          return
+        }
+      }
+
+      const waiter = state.value[1].values().next().value
+      if (waiter === undefined) {
+        continue
+      }
+
+      waiter.permits -= 1
+      waitingPermits -= 1
+
+      if (waiter.permits === 0) {
+        waiter.resume()
+      }
+
+      permits -= 1
+    }
+  }
+
+  return {
+    [PartitionedTypeId]: PartitionedTypeId,
+    withPermits: (key, permits) => {
+      const takePermits = take(key, permits)
+      return (effect) =>
+        Effect.uninterruptibleMask((restore) =>
+          Effect.flatMap(
+            restore(takePermits),
+            () => Effect.ensuring(restore(effect), Effect.sync(() => releaseUnsafe(permits)))
+          )
+        )
+    }
+  }
+}
+
+/**
+ * Creates a `Partitioned` semaphore.
+ *
+ * **Previously Known As**
+ *
+ * This API replaces the following from Effect 3.x:
+ *
+ * - `PartitionedSemaphore.make`
+ *
+ * @since 3.19.4
+ * @category constructors
+ */
+export const makePartitioned = <K = unknown>(options: {
+  readonly permits: number
+}): Effect.Effect<Partitioned<K>> => Effect.sync(() => makePartitionedUnsafe<K>(options))

package/src/Stream.ts

@@ -20,6 +20,7 @@ import * as internalExecutionPlan from "./internal/executionPlan.ts"
 import * as internal from "./internal/stream.ts"
 import { addSpanStackTrace } from "./internal/tracer.ts"
 import * as Iterable from "./Iterable.ts"
+import * as Latch from "./Latch.ts"
 import type * as Layer from "./Layer.ts"
 import type { LogLevel } from "./LogLevel.ts"
 import * as MutableHashMap from "./MutableHashMap.ts"
@@ -2648,8 +2649,8 @@ export const tapSink: {
     transformPullBracket(
       self,
       Effect.fnUntraced(function*(pull, _, scope) {
-        const upstreamLatch = Effect.makeLatchUnsafe()
-        const sinkLatch = Effect.makeLatchUnsafe()
+        const upstreamLatch = Latch.makeUnsafe()
+        const sinkLatch = Latch.makeUnsafe()
         let chunk: Arr.NonEmptyReadonlyArray<A> | undefined = undefined
         let causeSink: Cause.Cause<E2> | undefined = undefined
         let sinkDone = false
@@ -5341,7 +5342,7 @@ export const zipLatestAll = <T extends ReadonlyArray<Stream<any, any, any>>>(
   fromChannel(Channel.suspend(() => {
     const latest: Array<any> = []
     const emitted = new Set<number>()
-    const readyLatch = Effect.makeLatchUnsafe()
+    const readyLatch = Latch.makeUnsafe()
     return Channel.mergeAll(
       Channel.fromArray(
         streams.map((s, i) =>
@@ -12210,9 +12211,9 @@ export const debounce: {
         let lastArr: Arr.NonEmptyReadonlyArray<A> | undefined
         let cause: Cause.Cause<Cause.Done | E> | undefined
         let emitAtMs = Infinity
-        const pullLatch = Effect.makeLatchUnsafe()
-        const emitLatch = Effect.makeLatchUnsafe()
-        const endLatch = Effect.makeLatchUnsafe()
+        const pullLatch = Latch.makeUnsafe()
+        const emitLatch = Latch.makeUnsafe()
+        const endLatch = Latch.makeUnsafe()
 
         yield* pull.pipe(
           pullLatch.whenOpen,
@@ -13537,7 +13538,7 @@ export const aggregateWithin: {
   fromChannel(Channel.fromTransformBracket(Effect.fnUntraced(function*(_upstream, _, scope) {
     const pull = yield* Channel.toPullScoped(self.channel, _)
 
-    const pullLatch = Effect.makeLatchUnsafe(false)
+    const pullLatch = Latch.makeUnsafe(false)
     const scheduleStep = Symbol()
     const buffer = yield* Queue.make</**
      * Aggregates elements with a sink, emitting each result when the sink completes or the schedule triggers.
@@ -17747,7 +17748,7 @@ export const toReadableStreamWith = dual<
   ): ReadableStream<A> => {
     let currentResolve: (() => void) | undefined = undefined
     let fiber: Fiber.Fiber<void, E> | undefined = undefined
-    const latch = Effect.makeLatchUnsafe(false)
+    const latch = Latch.makeUnsafe(false)
 
     return new ReadableStream<A>({
       start(controller) {

package/src/Struct.ts

@@ -1513,3 +1513,29 @@ export function makeReducer<A>(
   }
   return Reducer.make(combine, initialValue)
 }
+
+/**
+ * Creates a record with the given keys and value.
+ *
+ * **Example** (Creating a record)
+ *
+ * ```ts
+ * import { Struct } from "effect"
+ *
+ * const record = Struct.Record(["a", "b"], "value")
+ * console.log(record) // { a: "value", b: "value" }
+ * ```
+ *
+ * @category Constructors
+ * @since 4.0.0
+ */
+export function Record<const Keys extends ReadonlyArray<string | symbol>, Value>(
+  keys: Keys,
+  value: Value
+): Record<Keys[number], Value> {
+  const out: any = {}
+  for (const key of keys) {
+    out[key] = value
+  }
+  return out
+}