effect 4.0.0-rc.112 → 4.0.0-rc.113

package/src/SchemaTransformation.ts

@@ -13,6 +13,7 @@
  */
 
 import * as BigDecimal from "./BigDecimal.ts"
+import * as ByteSize from "./ByteSize.ts"
 import * as DateTime from "./DateTime.ts"
 import * as Duration from "./Duration.ts"
 import * as Effect from "./Effect.ts"
@@ -48,7 +49,7 @@ import * as SchemaIssue from "./SchemaIssue.ts"
  *   `Middleware<E, T, ...>`.
  *
  * Typically constructed indirectly via `Schema.middlewareDecoding` or
- * `Schema.middlewareEncoding` rather than instantiating this class directly.
+ * `Schema.middlewareEncoding` rather than by using `new Middleware` directly.
  *
  * **Example** (Creating a middleware that falls back on decode failure)
  *
@@ -68,7 +69,35 @@ import * as SchemaIssue from "./SchemaIssue.ts"
  * @category models
  * @since 4.0.0
  */
-export class Middleware<in out T, in out E, RDE, RDT, RET, REE> {
+export interface Middleware<in out T, in out E, RDE, RDT, RET, REE> {
+  readonly _tag: "Middleware"
+  readonly decode: (
+    effect: Effect.Effect<Option.Option<E>, SchemaIssue.Issue, RDE>,
+    options: SchemaAST.ParseOptions
+  ) => Effect.Effect<Option.Option<T>, SchemaIssue.Issue, RDT>
+  readonly encode: (
+    effect: Effect.Effect<Option.Option<T>, SchemaIssue.Issue, RET>,
+    options: SchemaAST.ParseOptions
+  ) => Effect.Effect<Option.Option<E>, SchemaIssue.Issue, REE>
+  flip(): Middleware<E, T, RET, REE, RDE, RDT>
+}
+
+/**
+ * Constructs schema middleware from its decode and encode functions.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const Middleware: new<T, E, RDE, RDT, RET, REE>(
+  decode: (
+    effect: Effect.Effect<Option.Option<E>, SchemaIssue.Issue, RDE>,
+    options: SchemaAST.ParseOptions
+  ) => Effect.Effect<Option.Option<T>, SchemaIssue.Issue, RDT>,
+  encode: (
+    effect: Effect.Effect<Option.Option<T>, SchemaIssue.Issue, RET>,
+    options: SchemaAST.ParseOptions
+  ) => Effect.Effect<Option.Option<E>, SchemaIssue.Issue, REE>
+) => Middleware<T, E, RDE, RDT, RET, REE> = class<in out T, in out E, RDE, RDT, RET, REE> {
   readonly _tag = "Middleware"
   readonly decode: (
     effect: Effect.Effect<Option.Option<E>, SchemaIssue.Issue, RDE>,
@@ -134,13 +163,31 @@ const TypeId = "~effect/SchemaTransformation/Transformation"
  *
  * @see {@link make} — construct from `{ decode, encode }` getters
  * @see {@link transform} — construct from pure functions
- * @see {@link transformOrFail} — construct from effectful functions
+ * @see {@link transformEffect} — construct from effectful functions
  * @see {@link Middleware} — effect-pipeline-level alternative
  *
  * @category models
  * @since 4.0.0
  */
-export class Transformation<in out T, in out E, RD = never, RE = never> {
+export interface Transformation<in out T, in out E, RD = never, RE = never> {
+  readonly [TypeId]: typeof TypeId
+  readonly _tag: "Transformation"
+  readonly decode: SchemaGetter.Getter<T, E, RD>
+  readonly encode: SchemaGetter.Getter<E, T, RE>
+  flip(): Transformation<E, T, RE, RD>
+  compose<T2, RD2, RE2>(other: Transformation<T2, T, RD2, RE2>): Transformation<T2, E, RD | RD2, RE | RE2>
+}
+
+/**
+ * Constructs a bidirectional schema transformation from its decode and encode getters.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const Transformation: new<T, E, RD = never, RE = never>(
+  decode: SchemaGetter.Getter<T, E, RD>,
+  encode: SchemaGetter.Getter<E, T, RE>
+) => Transformation<T, E, RD, RE> = class<in out T, in out E, RD = never, RE = never> {
   readonly [TypeId] = TypeId
   readonly _tag = "Transformation"
   readonly decode: SchemaGetter.Getter<T, E, RD>
@@ -223,7 +270,7 @@ export function isTransformation(u: unknown): u is Transformation<any, any, unkn
  * ```
  *
  * @see {@link transform} — simpler constructor from pure functions
- * @see {@link transformOrFail} — constructor from effectful functions
+ * @see {@link transformEffect} — constructor from effectful functions
  * @see {@link Transformation}
  *
  * @category constructors
@@ -240,8 +287,7 @@ export const make = <T, E, RD = never, RE = never>(options: {
 }
 
 /**
- * Creates a `Transformation` from effectful decode and encode functions that
- * can fail with `Issue`.
+ * Creates a `Transformation` from effectful decode and encode functions.
  *
  * **When to use**
  *
@@ -262,7 +308,7 @@ export const make = <T, E, RD = never, RE = never>(options: {
  * const DateFromString = Schema.String.pipe(
  *   Schema.decodeTo(
  *     Schema.Date,
- *     SchemaTransformation.transformOrFail({
+ *     SchemaTransformation.transformEffect({
  *       decode: (s, options) => {
  *         const d = new Date(s)
  *         return isNaN(d.getTime())
@@ -283,13 +329,13 @@ export const make = <T, E, RD = never, RE = never>(options: {
  * @category transforming
  * @since 3.10.0
  */
-export function transformOrFail<T, E, RD = never, RE = never>(options: {
+export function transformEffect<T, E, RD = never, RE = never>(options: {
   readonly decode: (e: E, options: SchemaAST.ParseOptions) => Effect.Effect<T, SchemaIssue.Issue, RD>
   readonly encode: (t: T, options: SchemaAST.ParseOptions) => Effect.Effect<E, SchemaIssue.Issue, RE>
 }): Transformation<T, E, RD, RE> {
   return new Transformation(
-    SchemaGetter.transformOrFail(options.decode),
-    SchemaGetter.transformOrFail(options.encode)
+    SchemaGetter.transformEffect(options.decode),
+    SchemaGetter.transformEffect(options.encode)
   )
 }
 
@@ -325,7 +371,7 @@ export function transformOrFail<T, E, RD = never, RE = never>(options: {
  * Schema.decodeSync(CentsFromDollars)(2.5) // => 250
  * ```
  *
- * @see {@link transformOrFail} — for fallible or effectful transformations
+ * @see {@link transformEffect} — for fallible or effectful transformations
  * @see {@link transformOptional} — for transformations that handle missing keys
  * @see {@link passthrough} — when no conversion is needed
  *
@@ -970,7 +1016,7 @@ export const dateFromMillis: Transformation<globalThis.Date, number> = new Trans
  * @category transforming
  * @since 4.0.0
  */
-export const durationFromString: Transformation<Duration.Duration, string> = transformOrFail<
+export const durationFromString: Transformation<Duration.Duration, string> = transformEffect<
   Duration.Duration,
   string
 >({
@@ -986,7 +1032,7 @@ export const durationFromString: Transformation<Duration.Duration, string> = tra
         ),
       onSome: Effect.succeed
     }),
-  encode: (duration) => Effect.succeed(globalThis.String(duration))
+  encode: (duration) => Effect.succeed(String(duration))
 })
 
 /**
@@ -1020,7 +1066,7 @@ export const durationFromString: Transformation<Duration.Duration, string> = tra
  * @category transforming
  * @since 4.0.0
  */
-export const durationFromNanos: Transformation<Duration.Duration, bigint> = transformOrFail({
+export const durationFromNanos: Transformation<Duration.Duration, bigint> = transformEffect({
   decode: (i) => Effect.succeed(Duration.nanos(i)),
   encode: (a, options) =>
     Option.match(Duration.toNanos(a), {
@@ -1071,6 +1117,83 @@ export const durationFromMillis: Transformation<Duration.Duration, number> = tra
   encode: (a) => Duration.toMillis(a)
 })
 
+/**
+ * Decodes a string into a `ByteSize` and encodes it as an exact string.
+ *
+ * @category transforming
+ * @since 4.0.0
+ */
+export const byteSizeFromString: Transformation<ByteSize.ByteSize, string> = transformEffect({
+  decode: (input, options) =>
+    Option.match(ByteSize.fromInput(input), {
+      onNone: () =>
+        Effect.fail(
+          new SchemaIssue.InvalidValue(
+            { expected: "a valid ByteSize string" },
+            input,
+            options
+          )
+        ),
+      onSome: Effect.succeed
+    }),
+  encode: (byteSize) => Effect.succeed(`${byteSize} ${byteSize === BigInt(1) ? "byte" : "bytes"}`)
+})
+
+/**
+ * Decodes a non-negative bigint byte count into a `ByteSize`.
+ *
+ * @category transforming
+ * @since 4.0.0
+ */
+export const byteSizeFromBigInt: Transformation<ByteSize.ByteSize, bigint> = transformEffect({
+  decode: (input, options) =>
+    Option.match(ByteSize.fromInput(input), {
+      onNone: () =>
+        Effect.fail(
+          new SchemaIssue.InvalidValue(
+            { expected: "a non-negative bigint byte count" },
+            input,
+            options
+          )
+        ),
+      onSome: Effect.succeed
+    }),
+  encode: (byteSize) => Effect.succeed(ByteSize.toBigInt(byteSize))
+})
+
+/**
+ * Decodes a non-negative safe-integer byte count into a `ByteSize`.
+ *
+ * @category transforming
+ * @since 4.0.0
+ */
+export const byteSizeFromNumber: Transformation<ByteSize.ByteSize, number> = transformEffect({
+  decode: (input, options) =>
+    Option.match(ByteSize.fromInput(input), {
+      onNone: () =>
+        Effect.fail(
+          new SchemaIssue.InvalidValue(
+            { expected: "a non-negative safe-integer byte count" },
+            input,
+            options
+          )
+        ),
+      onSome: Effect.succeed
+    }),
+  encode: (byteSize, options) =>
+    Option.match(ByteSize.toNumber(byteSize), {
+      onNone: () =>
+        Effect.fail(
+          new SchemaIssue.InvalidValue(
+            { expected: "a ByteSize representable as a safe integer" },
+            byteSize,
+            options
+          )
+        ),
+      onSome: Effect.succeed
+    })
+})
+
 type JsonError = {
   message: string
   name?: string
@@ -1400,12 +1523,12 @@ export function optionFromOptional<T>(): Transformation<Option.Option<T>, T | un
  * ```
  *
  * @see {@link numberFromString}
- * @see {@link transformOrFail}
+ * @see {@link transformEffect}
  *
  * @category transforming
  * @since 4.0.0
  */
-export const urlFromString: Transformation<URL, string> = transformOrFail<URL, string>({
+export const urlFromString: Transformation<URL, string> = transformEffect<URL, string>({
   decode: (s, options) =>
     URL.canParse(s)
       ? Effect.succeed(new URL(s))
@@ -1437,7 +1560,7 @@ export const urlFromString: Transformation<URL, string> = transformOrFail<URL, s
  * @category transforming
  * @since 4.0.0
  */
-export const bigDecimalFromString: Transformation<BigDecimal.BigDecimal, string> = transformOrFail<
+export const bigDecimalFromString: Transformation<BigDecimal.BigDecimal, string> = transformEffect<
   BigDecimal.BigDecimal,
   string
 >({
@@ -1803,7 +1926,7 @@ export const timeZoneOffsetFromNumber: Transformation<DateTime.TimeZone.Offset,
  * @category transforming
  * @since 4.0.0
  */
-export const timeZoneNamedFromString: Transformation<DateTime.TimeZone.Named, string> = transformOrFail<
+export const timeZoneNamedFromString: Transformation<DateTime.TimeZone.Named, string> = transformEffect<
   DateTime.TimeZone.Named,
   string
 >({
@@ -1844,7 +1967,7 @@ export const timeZoneNamedFromString: Transformation<DateTime.TimeZone.Named, st
  * @category transforming
  * @since 4.0.0
  */
-export const timeZoneFromString: Transformation<DateTime.TimeZone, string> = transformOrFail<
+export const timeZoneFromString: Transformation<DateTime.TimeZone, string> = transformEffect<
   DateTime.TimeZone,
   string
 >({
@@ -1885,7 +2008,7 @@ export const timeZoneFromString: Transformation<DateTime.TimeZone, string> = tra
  * @category transforming
  * @since 4.0.0
  */
-export const dateTimeUtcFromString: Transformation<DateTime.Utc, string> = transformOrFail<
+export const dateTimeUtcFromString: Transformation<DateTime.Utc, string> = transformEffect<
   DateTime.Utc,
   string
 >({
@@ -1925,7 +2048,7 @@ export const dateTimeUtcFromString: Transformation<DateTime.Utc, string> = trans
  * @category transforming
  * @since 4.0.0
  */
-export const dateTimeZonedFromString: Transformation<DateTime.Zoned, string> = transformOrFail<
+export const dateTimeZonedFromString: Transformation<DateTime.Zoned, string> = transformEffect<
   DateTime.Zoned,
   string
 >({

package/src/ScopedCache.ts

@@ -972,6 +972,10 @@ export const invalidateWhen: {
               if (self.state._tag === "Closed") {
                 return effect.succeed(false)
               } else if (f(value)) {
+                const current = MutableHashMap.get(self.state.map, key)
+                if (Option.isNone(current) || current.value !== entry) {
+                  return effect.succeed(false)
+                }
                 MutableHashMap.remove(self.state.map, key)
                 return effect.as(Scope.close(entry.scope, effect.exitVoid), true)
               }
@@ -1100,7 +1104,7 @@ export const refresh: {
         MutableHashMap.set(self.state.map, key, entry)
         yield* checkCapacity(fiber, self.state.map, self.capacity)
       }
-      const exit = yield* effect.exit(restore(Scope.provide(self.lookup(key), scope)))
+      const exit = yield* effect.exit(effect.suspend(() => restore(Scope.provide(self.lookup(key), scope))))
       Deferred.doneUnsafe(deferred, exit)
       // @ts-ignore async gap
       if (self.state._tag === "Closed") {
@@ -1116,6 +1120,7 @@ export const refresh: {
       if (!newEntry) {
         const oentry = MutableHashMap.get(self.state.map, key)
         MutableHashMap.set(self.state.map, key, entry)
+        yield* checkCapacity(fiber, self.state.map, self.capacity)
         if (Option.isSome(oentry)) {
           yield* Scope.close(oentry.value.scope, effect.exitVoid)
         }
@@ -1152,11 +1157,13 @@ const invalidateAllImpl = <Key, A, E>(
   parent: Fiber.Fiber<unknown, unknown>,
   map: MutableHashMap.MutableHashMap<Key, Entry<A, E>>
 ): Effect.Effect<void> => {
+  // Detach the batch before finalizers can reenter the cache.
+  const entries = Array.from(MutableHashMap.values(map))
+  MutableHashMap.clear(map)
   const fibers = Arr.empty<Fiber.Fiber<unknown, unknown>>()
-  for (const [, entry] of map) {
+  for (const entry of entries) {
     fibers.push(effect.forkUnsafe(parent as any, Scope.close(entry.scope, effect.exitVoid), true, true))
   }
-  MutableHashMap.clear(map)
   return effect.fiberAwaitAll(fibers)
 }
 

package/src/Sink.ts

@@ -21,6 +21,7 @@ import * as Exit from "./Exit.ts"
 import type * as Filter from "./Filter.ts"
 import type { LazyArg } from "./Function.ts"
 import { constant, constFalse, constTrue, constVoid, dual, identity, pipe } from "./Function.ts"
+import * as Count from "./internal/count.ts"
 import * as internalStream from "./internal/stream.ts"
 import * as Option from "./Option.ts"
 import { type Pipeable, pipeArguments } from "./Pipeable.ts"
@@ -322,7 +323,7 @@ export const fromTransform = <In, A, E, R, L = never>(
  *   Channel.pipeTo(Sink.toChannel(Sink.sum))
  * )
  *
- * await Effect.runPromise(Channel.runDone(channel)) // => [6]
+ * await Effect.runPromise(Channel.runDrain(channel)) // => [6]
  * ```
  *
  * @category constructors
@@ -821,6 +822,10 @@ export const foldArray = <S, In, E = never, R = never>(
  *
  * **Details**
  *
+ * Finite fractional values of `max` are rounded down. If `max` is `NaN` or
+ * non-positive, the sink completes with the initial state without consuming
+ * input.
+ *
  * If the sink stops in the middle of a pulled array, the remaining elements
  * from that array are returned as leftovers.
  *
@@ -831,14 +836,17 @@ export const foldUntil = <S, In, E = never, R = never>(
   s: LazyArg<S>,
   max: number,
   f: (s: S, input: In) => Effect.Effect<S, E, R>
-): Sink<S, In, In, E, R> =>
-  fold<readonly [S, number], In, E, R>(
+): Sink<S, In, In, E, R> => {
+  const count = Count.normalize(max)
+  if (count === 0) return sync(s)
+  return fold<readonly [S, number], In, E, R>(
     () => [s(), 0],
-    (tuple) => tuple[1] < max,
-    ([output, count], input) => Effect.map(f(output, input), (s) => [s, count + 1] as const)
+    (tuple) => tuple[1] < count,
+    ([output, consumed], input) => Effect.map(f(output, input), (s) => [s, consumed + 1] as const)
   ).pipe(
     map((tuple) => tuple[0])
   )
+}
 
 /**
  * A sink that returns whether all elements satisfy the specified predicate.
@@ -1353,32 +1361,34 @@ export const mapLeftover: {
  *
  * **Details**
  *
- * If `n` is less than or equal to zero, the sink completes with an empty array.
- * If more elements are pulled than needed, the remaining elements from the same
- * array are returned as leftovers.
+ * Finite fractional values of `n` are rounded down. If `n` is `NaN` or
+ * non-positive, the sink completes with an empty array. If more elements are
+ * pulled than needed, the remaining elements from the same array are returned
+ * as leftovers.
  *
  * @category constructors
  * @since 2.0.0
  */
-export const take = <In>(n: number): Sink<Array<In>, In, In> =>
-  fromTransform((upstream) => {
+export const take = <In>(n: number): Sink<Array<In>, In, In> => {
+  const count = Count.normalize(n)
+  return fromTransform((upstream) => {
     const taken: Array<In> = []
-    if (n <= 0) {
+    if (count === 0) {
       return Effect.succeed([taken] as const)
     }
     let leftover: NonEmptyReadonlyArray<In> | undefined = undefined
     return upstream.pipe(
       Effect.flatMap((arr) => {
-        if (taken.length + arr.length <= n) {
+        if (taken.length + arr.length <= count) {
           taken.push(...arr)
-          if (taken.length === n) {
+          if (taken.length === count) {
             return Cause.done()
           }
           return Effect.void
         }
         for (let i = 0; i < arr.length; i++) {
           taken.push(arr[i])
-          if (taken.length === n) {
+          if (taken.length === count) {
             if ((i + 1) < arr.length) {
               leftover = arr.slice(i + 1) as any
             }
@@ -1391,6 +1401,7 @@ export const take = <In>(n: number): Sink<Array<In>, In, In> =>
       Pull.catchDone(() => Effect.succeed([taken, leftover] as const))
     )
   })
+}
 
 /**
  * Runs this sink until it yields a result, then uses that result to create
@@ -1483,7 +1494,12 @@ export const flatMap: {
             return upstream
           }),
           scope
-        )
+        ).pipe(Effect.map((end): End<A1, L | L1> => {
+          if (!leftover) {
+            return end
+          }
+          return [end[0], end[1] ? [...end[1], ...leftover] : leftover]
+        }))
     )
   }))