effect 4.0.0-beta.30 → 4.0.0-beta.32

package/src/ServiceMap.ts

@@ -446,6 +446,7 @@ export interface ServiceMap<in Services> extends Equal.Equal, Pipeable, Inspecta
     readonly _Services: Types.Contravariant<Services>
   }
   readonly mapUnsafe: ReadonlyMap<string, any>
+  mutable: boolean
 }
 
 /**
@@ -467,10 +468,11 @@ export interface ServiceMap<in Services> extends Equal.Equal, Pipeable, Inspecta
 export const makeUnsafe = <Services = never>(mapUnsafe: ReadonlyMap<string, any>): ServiceMap<Services> => {
   const self = Object.create(Proto)
   self.mapUnsafe = mapUnsafe
+  self.mutable = false
   return self
 }
 
-const Proto: Omit<ServiceMap<never>, "mapUnsafe"> = {
+const Proto: Omit<ServiceMap<never>, "mapUnsafe" | "mutable"> = {
   ...PipeInspectableProto,
   [TypeId]: {
     _Services: (_: never) => _
@@ -676,11 +678,10 @@ export const add: {
   self: ServiceMap<Services>,
   key: Key<I, S>,
   service: Types.NoInfer<S>
-): ServiceMap<Services | I> => {
-  const map = new Map(self.mapUnsafe)
-  map.set(key.key, service)
-  return makeUnsafe(map)
-})
+): ServiceMap<Services | I> =>
+  withMapUnsafe(self, (map) => {
+    map.set(key.key, service)
+  }))
 
 /**
  * @since 4.0.0
@@ -705,15 +706,14 @@ export const addOrOmit: {
   self: ServiceMap<Services>,
   key: Key<I, S>,
   service: Option.Option<Types.NoInfer<S>>
-): ServiceMap<Services | I> => {
-  const map = new Map(self.mapUnsafe)
-  if (service._tag === "None") {
-    map.delete(key.key)
-  } else {
-    map.set(key.key, service.value)
-  }
-  return makeUnsafe(map)
-})
+): ServiceMap<Services | I> =>
+  withMapUnsafe(self, (map) => {
+    if (service._tag === "None") {
+      map.delete(key.key)
+    } else {
+      map.set(key.key, service.value)
+    }
+  }))
 
 /**
  * Get a service from the context that corresponds to the given key, or
@@ -1253,9 +1253,9 @@ export const merge: {
 } = dual(2, <Services, R1>(self: ServiceMap<Services>, that: ServiceMap<R1>): ServiceMap<Services | R1> => {
   if (self.mapUnsafe.size === 0) return that as any
   if (that.mapUnsafe.size === 0) return self as any
-  const map = new Map(self.mapUnsafe)
-  that.mapUnsafe.forEach((value, key) => map.set(key, value))
-  return makeUnsafe(map)
+  return withMapUnsafe(self, (map) => {
+    that.mapUnsafe.forEach((value, key) => map.set(key, value))
+  })
 })
 
 /**
@@ -1333,16 +1333,14 @@ export const mergeAll = <T extends Array<unknown>>(
 export const pick = <S extends ReadonlyArray<Key<any, any>>>(
   ...services: S
 ) =>
-<Services>(self: ServiceMap<Services>): ServiceMap<Services & Service.Identifier<S[number]>> => {
-  const map = new Map<string, any>()
-  const keySet = new Set(services.map((key) => key.key))
-  self.mapUnsafe.forEach((value, key) => {
-    if (keySet.has(key)) {
-      map.set(key, value)
-    }
+<Services>(self: ServiceMap<Services>): ServiceMap<Services & Service.Identifier<S[number]>> =>
+  withMapUnsafe(self, (map) => {
+    const keySet = new Set(services.map((key) => key.key))
+    map.forEach((_, key) => {
+      if (keySet.has(key)) return
+      map.delete(key)
+    })
   })
-  return makeUnsafe(map)
-}
 
 /**
  * @example
@@ -1373,11 +1371,65 @@ export const pick = <S extends ReadonlyArray<Key<any, any>>>(
 export const omit = <S extends ReadonlyArray<Key<any, any>>>(
   ...keys: S
 ) =>
-<Services>(self: ServiceMap<Services>): ServiceMap<Exclude<Services, Service.Identifier<S[number]>>> => {
-  const map = new Map(self.mapUnsafe)
-  for (let i = 0; i < keys.length; i++) {
-    map.delete(keys[i].key)
+<Services>(self: ServiceMap<Services>): ServiceMap<Exclude<Services, Service.Identifier<S[number]>>> =>
+  withMapUnsafe(self, (map) => {
+    for (let i = 0; i < keys.length; i++) {
+      map.delete(keys[i].key)
+    }
+  })
+
+/**
+ * Perform a series of mutations on a `ServiceMap`. Prevents unnecessary copying
+ * of the underlying map when multiple mutations are needed.
+ *
+ * @since 4.0.0
+ * @category Utils
+ */
+export const mutate: {
+  /**
+   * Perform a series of mutations on a `ServiceMap`. Prevents unnecessary copying
+   * of the underlying map when multiple mutations are needed.
+   *
+   * @since 4.0.0
+   * @category Utils
+   */
+  <Services, B>(f: (serviceMap: ServiceMap<Services>) => ServiceMap<B>): <Services>(self: ServiceMap<Services>) => ServiceMap<B>
+  /**
+   * Perform a series of mutations on a `ServiceMap`. Prevents unnecessary copying
+   * of the underlying map when multiple mutations are needed.
+   *
+   * @since 4.0.0
+   * @category Utils
+   */
+  <Services, B>(
+    self: ServiceMap<Services>,
+    f: (serviceMap: ServiceMap<Services>) => ServiceMap<B>
+  ): ServiceMap<B>
+} = dual(
+  2,
+  <Services, B>(self: ServiceMap<Services>, f: (serviceMap: ServiceMap<Services>) => ServiceMap<B>): ServiceMap<B> => {
+    const next = makeUnsafe</**
+     * Perform a series of mutations on a `ServiceMap`. Prevents unnecessary copying
+     * of the underlying map when multiple mutations are needed.
+     *
+     * @since 4.0.0
+     * @category Utils
+     */
+    Services>(new Map(self.mapUnsafe))
+    next.mutable = true
+    const result = f(next)
+    result.mutable = false
+    return result
   }
+)
+
+const withMapUnsafe = <Services, B>(self: ServiceMap<Services>, f: (map: Map<string, any>) => void): ServiceMap<B> => {
+  if (self.mutable) {
+    f(self.mapUnsafe as any)
+    return self as any
+  }
+  const map = new Map(self.mapUnsafe)
+  f(map)
   return makeUnsafe(map)
 }
 

package/src/Stream.ts

@@ -3817,7 +3817,7 @@ export const merge: {
     } | undefined
   ): Stream<A | A2, E | E2, R | R2>
 } = dual(
-  2,
+  (args) => isStream(args[0]) && isStream(args[1]),
   <A, E, R, A2, E2, R2>(
     self: Stream<A, E, R>,
     that: Stream<A2, E2, R2>,

package/src/String.ts

@@ -10,6 +10,7 @@ import * as Equ from "./Equivalence.ts"
 import { dual } from "./Function.ts"
 import * as readonlyArray from "./internal/array.ts"
 import * as number from "./Number.ts"
+import * as Option from "./Option.ts"
 import * as order from "./Order.ts"
 import type * as Ordering from "./Ordering.ts"
 import type { Refinement } from "./Predicate.ts"
@@ -534,15 +535,15 @@ export const endsWith = (searchString: string, position?: number) => (self: stri
   self.endsWith(searchString, position)
 
 /**
- * Returns the character code at the specified index, or `undefined` if the index is out of bounds.
+ * Returns the character code at the specified index, or `None` if the index is out of bounds.
  *
  * **Example**
  *
  * ```ts
  * import { String } from "effect"
  *
- * String.charCodeAt("abc", 1) // 98
- * String.charCodeAt("abc", 4) // undefined
+ * String.charCodeAt("abc", 1) // Option.some(98)
+ * String.charCodeAt("abc", 4) // Option.none()
  * ```
  *
  * @category elements
@@ -550,43 +551,41 @@ export const endsWith = (searchString: string, position?: number) => (self: stri
  */
 export const charCodeAt: {
   /**
-   * Returns the character code at the specified index, or `undefined` if the index is out of bounds.
+   * Returns the character code at the specified index, or `None` if the index is out of bounds.
    *
    * **Example**
    *
    * ```ts
    * import { String } from "effect"
    *
-   * String.charCodeAt("abc", 1) // 98
-   * String.charCodeAt("abc", 4) // undefined
+   * String.charCodeAt("abc", 1) // Option.some(98)
+   * String.charCodeAt("abc", 4) // Option.none()
    * ```
    *
    * @category elements
    * @since 2.0.0
    */
-  (index: number): (self: string) => number | undefined
+  (index: number): (self: string) => Option.Option<number>
   /**
-   * Returns the character code at the specified index, or `undefined` if the index is out of bounds.
+   * Returns the character code at the specified index, or `None` if the index is out of bounds.
    *
    * **Example**
    *
    * ```ts
    * import { String } from "effect"
    *
-   * String.charCodeAt("abc", 1) // 98
-   * String.charCodeAt("abc", 4) // undefined
+   * String.charCodeAt("abc", 1) // Option.some(98)
+   * String.charCodeAt("abc", 4) // Option.none()
    * ```
    *
    * @category elements
    * @since 2.0.0
    */
-  (self: string, index: number): number | undefined
+  (self: string, index: number): Option.Option<number>
 } = dual(
   2,
-  (self: string, index: number): number | undefined => {
-    const out = self.charCodeAt(index)
-    return isNaN(out) ? undefined : out
-  }
+  (self: string, index: number): Option.Option<number> =>
+    Option.filter(Option.some(self.charCodeAt(index)), (charCode) => !isNaN(charCode))
 )
 
 /**
@@ -607,23 +606,54 @@ export const charCodeAt: {
 export const substring = (start: number, end?: number) => (self: string): string => self.substring(start, end)
 
 /**
- * A `pipe`-able version of the native `charAt` method.
+ * Returns the character at the specified index, or `None` if the index is out of bounds.
  *
  * **Example**
  *
  * ```ts
  * import { pipe, String } from "effect"
  *
- * pipe("abc", String.at(1)) // "b"
- * pipe("abc", String.at(4)) // undefined
+ * pipe("abc", String.at(1)) // Option.some("b")
+ * pipe("abc", String.at(4)) // Option.none()
  * ```
  *
  * @category elements
  * @since 2.0.0
  */
-export const at = (index: number) => (self: string): string | undefined => {
-  return self.charAt(index)
-}
+export const at: {
+  /**
+   * Returns the character at the specified index, or `None` if the index is out of bounds.
+   *
+   * **Example**
+   *
+   * ```ts
+   * import { pipe, String } from "effect"
+   *
+   * pipe("abc", String.at(1)) // Option.some("b")
+   * pipe("abc", String.at(4)) // Option.none()
+   * ```
+   *
+   * @category elements
+   * @since 2.0.0
+   */
+  (index: number): (self: string) => Option.Option<string>
+  /**
+   * Returns the character at the specified index, or `None` if the index is out of bounds.
+   *
+   * **Example**
+   *
+   * ```ts
+   * import { pipe, String } from "effect"
+   *
+   * pipe("abc", String.at(1)) // Option.some("b")
+   * pipe("abc", String.at(4)) // Option.none()
+   * ```
+   *
+   * @category elements
+   * @since 2.0.0
+   */
+  (self: string, index: number): Option.Option<string>
+} = dual(2, (self: string, index: number): Option.Option<string> => Option.fromUndefinedOr(self.at(index)))
 
 /**
  * Returns the character at the specified index, or `None` if the index is out of bounds.
@@ -633,8 +663,8 @@ export const at = (index: number) => (self: string): string | undefined => {
  * ```ts
  * import { pipe, String } from "effect"
  *
- * pipe("abc", String.charAt(1)) // "b"
- * pipe("abc", String.charAt(4)) // undefined
+ * pipe("abc", String.charAt(1)) // Option.some("b")
+ * pipe("abc", String.charAt(4)) // Option.none()
  * ```
  *
  * @category elements
@@ -649,14 +679,14 @@ export const charAt: {
    * ```ts
    * import { pipe, String } from "effect"
    *
-   * pipe("abc", String.charAt(1)) // "b"
-   * pipe("abc", String.charAt(4)) // undefined
+   * pipe("abc", String.charAt(1)) // Option.some("b")
+   * pipe("abc", String.charAt(4)) // Option.none()
    * ```
    *
    * @category elements
    * @since 2.0.0
    */
-  (index: number): (self: string) => string | undefined
+  (index: number): (self: string) => Option.Option<string>
   /**
    * Returns the character at the specified index, or `None` if the index is out of bounds.
    *
@@ -665,40 +695,68 @@ export const charAt: {
    * ```ts
    * import { pipe, String } from "effect"
    *
-   * pipe("abc", String.charAt(1)) // "b"
-   * pipe("abc", String.charAt(4)) // undefined
+   * pipe("abc", String.charAt(1)) // Option.some("b")
+   * pipe("abc", String.charAt(4)) // Option.none()
    * ```
    *
    * @category elements
    * @since 2.0.0
    */
-  (self: string, index: number): string | undefined
+  (self: string, index: number): Option.Option<string>
 } = dual(
   2,
-  (self: string, index: number): string | undefined => {
-    const out = self.charAt(index)
-    return isNonEmpty(out) ? out : undefined
-  }
+  (self: string, index: number): Option.Option<string> => Option.filter(Option.some(self.charAt(index)), isNonEmpty)
 )
 
 /**
- * A `pipe`-able version of the native `codePointAt` method.
+ * Returns the Unicode code point at the specified index, or `None` if the index is out of bounds.
  *
  * **Example**
  *
  * ```ts
  * import { pipe, String } from "effect"
  *
- * pipe("abc", String.codePointAt(1)) // 98
- * pipe("abc", String.codePointAt(10)) // undefined
+ * pipe("abc", String.codePointAt(1)) // Option.some(98)
+ * pipe("abc", String.codePointAt(10)) // Option.none()
  * ```
  *
  * @category elements
  * @since 2.0.0
  */
-export const codePointAt = (index: number) => (self: string): number | undefined => {
-  return self.codePointAt(index)
-}
+export const codePointAt: {
+  /**
+   * Returns the Unicode code point at the specified index, or `None` if the index is out of bounds.
+   *
+   * **Example**
+   *
+   * ```ts
+   * import { pipe, String } from "effect"
+   *
+   * pipe("abc", String.codePointAt(1)) // Option.some(98)
+   * pipe("abc", String.codePointAt(10)) // Option.none()
+   * ```
+   *
+   * @category elements
+   * @since 2.0.0
+   */
+  (index: number): (self: string) => Option.Option<number>
+  /**
+   * Returns the Unicode code point at the specified index, or `None` if the index is out of bounds.
+   *
+   * **Example**
+   *
+   * ```ts
+   * import { pipe, String } from "effect"
+   *
+   * pipe("abc", String.codePointAt(1)) // Option.some(98)
+   * pipe("abc", String.codePointAt(10)) // Option.none()
+   * ```
+   *
+   * @category elements
+   * @since 2.0.0
+   */
+  (self: string, index: number): Option.Option<number>
+} = dual(2, (self: string, index: number): Option.Option<number> => Option.fromUndefinedOr(self.codePointAt(index)))
 
 /**
  * Returns the index of the first occurrence of a substring, or `None` if not found.
@@ -708,17 +766,15 @@ export const codePointAt = (index: number) => (self: string): number | undefined
  * ```ts
  * import { pipe, String } from "effect"
  *
- * pipe("abbbc", String.indexOf("b")) // 1
- * pipe("abbbc", String.indexOf("z")) // undefined
+ * pipe("abbbc", String.indexOf("b")) // Option.some(1)
+ * pipe("abbbc", String.indexOf("z")) // Option.none()
  * ```
  *
  * @category searching
  * @since 2.0.0
  */
-export const indexOf = (searchString: string) => (self: string): number | undefined => {
-  const out = self.indexOf(searchString)
-  return out >= 0 ? out : undefined
-}
+export const indexOf = (searchString: string) => (self: string): Option.Option<number> =>
+  Option.filter(Option.some(self.indexOf(searchString)), number.isGreaterThanOrEqualTo(0))
 
 /**
  * Returns the index of the last occurrence of a substring, or `None` if not found.
@@ -728,17 +784,15 @@ export const indexOf = (searchString: string) => (self: string): number | undefi
  * ```ts
  * import { pipe, String } from "effect"
  *
- * pipe("abbbc", String.lastIndexOf("b")) // 3
- * pipe("abbbc", String.lastIndexOf("d")) // undefined
+ * pipe("abbbc", String.lastIndexOf("b")) // Option.some(3)
+ * pipe("abbbc", String.lastIndexOf("d")) // Option.none()
  * ```
  *
  * @category searching
  * @since 2.0.0
  */
-export const lastIndexOf = (searchString: string) => (self: string): number | undefined => {
-  const out = self.lastIndexOf(searchString)
-  return out >= 0 ? out : undefined
-}
+export const lastIndexOf = (searchString: string) => (self: string): Option.Option<number> =>
+  Option.filter(Option.some(self.lastIndexOf(searchString)), number.isGreaterThanOrEqualTo(0))
 
 /**
  * Compares two strings according to the current locale.
@@ -768,14 +822,15 @@ export const localeCompare =
  * ```ts
  * import { pipe, String } from "effect"
  *
- * pipe("hello", String.match(/l+/)) // ["ll"]
- * pipe("hello", String.match(/x/)) // null
+ * pipe("hello", String.match(/l+/)) // Option.some(["ll"])
+ * pipe("hello", String.match(/x/)) // Option.none()
  * ```
  *
  * @category searching
  * @since 2.0.0
  */
-export const match = (regExp: RegExp | string) => (self: string): RegExpMatchArray | null => self.match(regExp)
+export const match = (regExp: RegExp | string) => (self: string): Option.Option<RegExpMatchArray> =>
+  Option.fromNullOr(self.match(regExp))
 
 /**
  * It is the `pipe`-able version of the native `matchAll` method.
@@ -896,9 +951,9 @@ export const replaceAll = (searchValue: string | RegExp, replaceValue: string) =
  * ```ts
  * import { String } from "effect"
  *
- * String.search("ababb", "b") // 1
- * String.search("ababb", "/abb/") // 2
- * String.search("ababb", "d") // undefined
+ * String.search("ababb", "b") // Option.some(1)
+ * String.search("ababb", /abb/) // Option.some(2)
+ * String.search("ababb", "d") // Option.none()
  * ```
  *
  * @category searching
@@ -913,15 +968,15 @@ export const search: {
    * ```ts
    * import { String } from "effect"
    *
-   * String.search("ababb", "b") // 1
-   * String.search("ababb", "/abb/") // 2
-   * String.search("ababb", "d") // undefined
+   * String.search("ababb", "b") // Option.some(1)
+   * String.search("ababb", /abb/) // Option.some(2)
+   * String.search("ababb", "d") // Option.none()
    * ```
    *
    * @category searching
    * @since 2.0.0
    */
-  (regExp: RegExp | string): (self: string) => number | undefined
+  (regExp: RegExp | string): (self: string) => Option.Option<number>
   /**
    * Searches for a match between a regular expression and the string.
    *
@@ -930,21 +985,19 @@ export const search: {
    * ```ts
    * import { String } from "effect"
    *
-   * String.search("ababb", "b") // 1
-   * String.search("ababb", "/abb/") // 2
-   * String.search("ababb", "d") // undefined
+   * String.search("ababb", "b") // Option.some(1)
+   * String.search("ababb", /abb/) // Option.some(2)
+   * String.search("ababb", "d") // Option.none()
    * ```
    *
    * @category searching
    * @since 2.0.0
    */
-  (self: string, regExp: RegExp | string): number | undefined
+  (self: string, regExp: RegExp | string): Option.Option<number>
 } = dual(
   2,
-  (self: string, regExp: RegExp | string): number | undefined => {
-    const out = self.search(regExp)
-    return out >= 0 ? out : undefined
-  }
+  (self: string, regExp: RegExp | string): Option.Option<number> =>
+    Option.filter(Option.some(self.search(regExp)), number.isGreaterThanOrEqualTo(0))
 )
 
 /**