effect 4.0.0-beta.100 → 4.0.0-beta.102

package/src/Record.ts

@@ -15,6 +15,7 @@ import * as Equal from "./Equal.ts"
 import type { Equivalence } from "./Equivalence.ts"
 import { dual, identity } from "./Function.ts"
 import type { TypeLambda } from "./HKT.ts"
+import * as InternalRecord from "./internal/record.ts"
 import * as Option from "./Option.ts"
 import * as Reducer from "./Reducer.ts"
 import type { Result } from "./Result.ts"
@@ -285,7 +286,7 @@ export const fromIterableWith: {
     const out: Record<string, B> = empty()
     for (const a of self) {
       const [k, b] = f(a)
-      out[k] = b
+      InternalRecord.assignProperty(out, k, b)
     }
     return out
   }
@@ -317,10 +318,68 @@ export const fromIterableWith: {
  * @category constructors
  * @since 2.0.0
  */
-export const fromIterableBy = <A, K extends string | symbol>(
-  items: Iterable<A>,
-  f: (a: A) => K
-): Record<ReadonlyRecord.NonLiteralKey<K>, A> => fromIterableWith(items, (a) => [f(a), a])
+export const fromIterableBy: {
+  /**
+   * Creates a new record from an iterable, utilizing the provided function to determine the key for each element.
+   *
+   * **Example** (Building a record keyed by iterable values)
+   *
+   * ```ts
+   * import { Record } from "effect"
+   * import * as assert from "node:assert"
+   *
+   * const users = [
+   *   { id: "2", name: "name2" },
+   *   { id: "1", name: "name1" }
+   * ]
+   *
+   * assert.deepStrictEqual(
+   *   Record.fromIterableBy(users, (user) => user.id),
+   *   {
+   *     "2": { id: "2", name: "name2" },
+   *     "1": { id: "1", name: "name1" }
+   *   }
+   * )
+   * ```
+   *
+   * @category constructors
+   * @since 2.0.0
+   */
+  <A, K extends string | symbol>(f: (a: A) => K): (items: Iterable<A>) => Record<ReadonlyRecord.NonLiteralKey<K>, A>
+  /**
+   * Creates a new record from an iterable, utilizing the provided function to determine the key for each element.
+   *
+   * **Example** (Building a record keyed by iterable values)
+   *
+   * ```ts
+   * import { Record } from "effect"
+   * import * as assert from "node:assert"
+   *
+   * const users = [
+   *   { id: "2", name: "name2" },
+   *   { id: "1", name: "name1" }
+   * ]
+   *
+   * assert.deepStrictEqual(
+   *   Record.fromIterableBy(users, (user) => user.id),
+   *   {
+   *     "2": { id: "2", name: "name2" },
+   *     "1": { id: "1", name: "name1" }
+   *   }
+   * )
+   * ```
+   *
+   * @category constructors
+   * @since 2.0.0
+   */
+  <A, K extends string | symbol>(items: Iterable<A>, f: (a: A) => K): Record<ReadonlyRecord.NonLiteralKey<K>, A>
+} = dual(
+  2,
+  <A, K extends string | symbol>(
+    items: Iterable<A>,
+    f: (a: A) => K
+  ): Record<ReadonlyRecord.NonLiteralKey<K>, A> => fromIterableWith(items, (a) => [f(a), a])
+)
 
 /**
  * Builds a record from an iterable of key-value pairs.
@@ -576,7 +635,7 @@ export const get: {
 } = dual(
   2,
   <K extends string | symbol, A>(self: ReadonlyRecord<K, A>, key: NoInfer<K>): Option.Option<A> =>
-    has(self, key) ? Option.some(self[key]) : Option.none()
+    Object.hasOwn(self, key) ? Option.some(self[key]) : Option.none()
 )
 
 /**
@@ -953,7 +1012,7 @@ export const map: {
   <K extends string, A, B>(self: ReadonlyRecord<K, A>, f: (a: A, key: NoInfer<K>) => B): Record<K, B> => {
     const out: Record<K, B> = { ...self } as any
     for (const key of keys(self)) {
-      out[key] = f(self[key], key)
+      InternalRecord.assignProperty(out, key, f(self[key], key))
     }
     return out
   }
@@ -1025,7 +1084,7 @@ export const mapKeys: {
     const out: Record<K2, A> = {} as any
     for (const key of keys(self)) {
       const a = self[key]
-      out[f(key, a)] = a
+      InternalRecord.assignProperty(out, f(key, a), a)
     }
     return out
   }
@@ -1097,7 +1156,7 @@ export const mapEntries: {
     const out = {} as Record<K2, B>
     for (const key of keys(self)) {
       const [k, b] = f(self[key], key)
-      out[k] = b
+      InternalRecord.assignProperty(out, k, b)
     }
     return out
   }
@@ -1170,7 +1229,7 @@ export const filterMap: {
     for (const key of keys(self)) {
       const result = f(self[key], key)
       if (R.isSuccess(result)) {
-        out[key] = result.success
+        InternalRecord.assignProperty(out, key, result.success)
       }
     }
     return out
@@ -1271,7 +1330,7 @@ export const filter: {
     const out: Record<string, A> = empty()
     for (const key of keys(self)) {
       if (predicate(self[key], key)) {
-        out[key] = self[key]
+        InternalRecord.assignProperty(out, key, self[key])
       }
     }
     return out
@@ -1306,7 +1365,7 @@ export const getSomes: <K extends string, A>(
   for (const key of keys(self)) {
     const option = self[key]
     if (Option.isSome(option)) {
-      out[key] = option.value
+      InternalRecord.assignProperty(out, key, option.value)
     }
   }
   return out
@@ -1342,7 +1401,7 @@ export const getFailures = <K extends string, A, E>(
   for (const key of keys(self)) {
     const value = self[key]
     if (R.isFailure(value)) {
-      out[key] = value.failure
+      InternalRecord.assignProperty(out, key, value.failure)
     }
   }
 
@@ -1379,7 +1438,7 @@ export const getSuccesses = <K extends string, A, E>(
   for (const key of keys(self)) {
     const value = self[key]
     if (R.isSuccess(value)) {
-      out[key] = value.success
+      InternalRecord.assignProperty(out, key, value.success)
     }
   }
 
@@ -1471,9 +1530,9 @@ export const partition: {
     for (const key of keys(self)) {
       const e = f(self[key], key)
       if (R.isFailure(e)) {
-        left[key] = e.failure
+        InternalRecord.assignProperty(left, key, e.failure)
       } else {
-        right[key] = e.success
+        InternalRecord.assignProperty(right, key, e.success)
       }
     }
     return [left, right]
@@ -1600,6 +1659,44 @@ export const set: {
   }
 )
 
+/**
+ * Mutates a record by assigning a value to a property.
+ *
+ * **When to use**
+ *
+ * Use when incrementally constructing a new record and copying it for every
+ * property would be unnecessary.
+ *
+ * **Gotchas**
+ *
+ * This function mutates `self`. When `key` is `"__proto__"`, it creates an
+ * own data property instead of changing the object's prototype.
+ *
+ * **Example** (Assigning an external key safely)
+ *
+ * ```ts
+ * import { Record } from "effect"
+ * import * as assert from "node:assert"
+ *
+ * const key: string = "__proto__" // Assume this comes from external input
+ * const value = { polluted: true }
+ *
+ * const unsafe: Record<string, unknown> = {}
+ * unsafe[key] = value
+ * assert.strictEqual(Object.getPrototypeOf(unsafe), value)
+ *
+ * const safe: Record<string, unknown> = {}
+ * Record.assignProperty(safe, key, value)
+ * assert.strictEqual(Object.getPrototypeOf(safe), Object.prototype)
+ * assert.strictEqual(safe[key], value)
+ * ```
+ *
+ * @see {@link set} for an immutable update
+ * @category mutations
+ * @since 4.0.0
+ */
+export const assignProperty: (self: object, key: PropertyKey, value: unknown) => void = InternalRecord.assignProperty
+
 /**
  * Checks whether all the keys and values in one record are also found in another record.
  * Uses the provided equivalence function to compare values.
@@ -2051,14 +2148,14 @@ export const union: {
     const out: Record<string, A | B | C> = empty()
     for (const key of keys(self)) {
       if (has(that, key as any)) {
-        out[key] = combine(self[key], that[key as unknown as K1])
+        InternalRecord.assignProperty(out, key, combine(self[key], that[key as unknown as K1]))
       } else {
-        out[key] = self[key]
+        InternalRecord.assignProperty(out, key, self[key])
       }
     }
     for (const key of keys(that)) {
       if (!has(out, key)) {
-        out[key] = that[key]
+        InternalRecord.assignProperty(out, key, that[key])
       }
     }
     return out
@@ -2142,7 +2239,7 @@ export const intersection: {
     }
     for (const key of keys(self)) {
       if (has(that, key as any)) {
-        out[key] = combine(self[key], that[key as unknown as K1])
+        InternalRecord.assignProperty(out, key, combine(self[key], that[key as unknown as K1]))
       }
     }
     return out
@@ -2222,12 +2319,12 @@ export const difference: {
   const out = {} as Record<K0 | K1, A | B>
   for (const key of keys(self)) {
     if (!has(that, key as any)) {
-      out[key] = self[key]
+      InternalRecord.assignProperty(out, key, self[key])
     }
   }
   for (const key of keys(that)) {
     if (!has(self, key as any)) {
-      out[key] = that[key]
+      InternalRecord.assignProperty(out, key, that[key])
     }
   }
   return out

package/src/References.ts

@@ -124,52 +124,6 @@ export {
   Tracer
 }
 
-/**
- * Context reference for controlling the current concurrency limit. Can be set to "unbounded"
- * for unlimited concurrency or a specific number to limit concurrent operations.
- *
- * **When to use**
- *
- * Use to configure the default concurrency limit for operations that read
- * concurrency from the current context.
- *
- * **Example** (Setting current concurrency)
- *
- * ```ts
- * import { Effect, References } from "effect"
- *
- * const limitConcurrency = Effect.gen(function*() {
- *   // Get current setting
- *   const current = yield* References.CurrentConcurrency
- *   console.log(current) // "unbounded" (default)
- *
- *   // Run with limited concurrency
- *   yield* Effect.provideService(
- *     Effect.gen(function*() {
- *       const limited = yield* References.CurrentConcurrency
- *       console.log(limited) // 10
- *     }),
- *     References.CurrentConcurrency,
- *     10
- *   )
- *
- *   // Run with unlimited concurrency
- *   yield* Effect.provideService(
- *     Effect.gen(function*() {
- *       const unlimited = yield* References.CurrentConcurrency
- *       console.log(unlimited) // "unbounded"
- *     }),
- *     References.CurrentConcurrency,
- *     "unbounded"
- *   )
- * })
- * ```
- *
- * @category references
- * @since 4.0.0
- */
-export const CurrentConcurrency: Context.Reference<number | "unbounded"> = references.CurrentConcurrency
-
 /**
  * Context reference for managing log annotations that are automatically added to all log entries.
  * These annotations provide contextual metadata that appears in every log message.

package/src/Request.ts

@@ -17,6 +17,7 @@ import type * as Exit from "./Exit.ts"
 import { dual } from "./Function.ts"
 import * as core from "./internal/core.ts"
 import * as internalEffect from "./internal/effect.ts"
+import * as InternalRecord from "./internal/record.ts"
 import { hasProperty } from "./Predicate.ts"
 import type * as Types from "./Types.ts"
 
@@ -280,7 +281,7 @@ export const isRequest = (u: unknown): u is Request<unknown, unknown, unknown> =
  * @since 2.0.0
  */
 export const of = <R extends Request<any, any, any>>(): Constructor<R> => (args) =>
-  Object.assign(Object.create(RequestPrototype), args)
+  Object.setPrototypeOf({ ...(args as R) }, RequestPrototype)
 
 /**
  * Creates a constructor function for a tagged Request type. The tag is automatically
@@ -328,10 +329,7 @@ export const tagged = <R extends Request<any, any, any> & { _tag: string }>(
   tag: R["_tag"]
 ): Constructor<R, "_tag"> =>
 (args) => {
-  const request = Object.create(RequestPrototype)
-  if (args) Object.assign(request, args)
-  request._tag = tag
-  return request
+  return Object.setPrototypeOf({ ...(args as R), _tag: tag }, RequestPrototype)
 }
 
 /**
@@ -364,9 +362,9 @@ export const Class: new<A extends Record<string, any>, Success, Error = never, C
   args: Types.Equals<Omit<A, keyof Request<unknown, unknown>>, {}> extends true ? void
     : { readonly [P in keyof A as P extends keyof Request<any, any, any> ? never : P]: A[P] }
 ) => Request<Success, Error, Context> & Readonly<A> = (function() {
-  function Class(this: any, args: any) {
+  function Class(this: object, args: object | undefined) {
     if (args) {
-      Object.assign(this, args)
+      InternalRecord.assignProperties(this, args)
     }
   }
   Class.prototype = RequestPrototype

package/src/Result.ts

@@ -17,6 +17,7 @@ import type { TypeLambda } from "./HKT.ts"
 import type { Inspectable } from "./Inspectable.ts"
 import * as doNotation from "./internal/doNotation.ts"
 import * as option_ from "./internal/option.ts"
+import * as InternalRecord from "./internal/record.ts"
 import * as result from "./internal/result.ts"
 import type { Option } from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
@@ -2847,7 +2848,7 @@ export const all: <const I extends Iterable<Result<any, any>> | Record<string, R
       if (isFailure(e)) {
         return e
       }
-      out[key] = e.success
+      InternalRecord.assignProperty(out, key, e.success)
     }
     return succeed(out)
   }