effect 3.16.13 → 3.16.14

package/src/Schema.ts

@@ -7151,8 +7151,8 @@ export const lessThanOrEqualToDate = <S extends Schema.Any>(
 <A extends Date>(self: S & Schema<A, Schema.Encoded<S>, Schema.Context<S>>): filter<S> =>
   self.pipe(
     filter((a: Date) => a <= max, {
-      schemaId: LessThanDateSchemaId,
-      [LessThanDateSchemaId]: { max },
+      schemaId: LessThanOrEqualToDateSchemaId,
+      [LessThanOrEqualToDateSchemaId]: { max },
       title: `lessThanOrEqualToDate(${util_.formatDate(max)})`,
       description: `a date before or equal to ${util_.formatDate(max)}`,
       ...annotations

package/src/index.ts

@@ -1089,6 +1089,21 @@ export * as Pipeable from "./Pipeable.js"
 export * as Pool from "./Pool.js"
 
 /**
+ * This module provides a collection of functions for working with predicates and refinements.
+ *
+ * A `Predicate<A>` is a function that takes a value of type `A` and returns a boolean.
+ * It is used to check if a value satisfies a certain condition.
+ *
+ * A `Refinement<A, B>` is a special type of predicate that not only checks a condition
+ * but also provides a type guard, allowing TypeScript to narrow the type of the input
+ * value from `A` to a more specific type `B` within a conditional block.
+ *
+ * The module includes:
+ * - Basic predicates and refinements for common types (e.g., `isString`, `isNumber`).
+ * - Combinators to create new predicates from existing ones (e.g., `and`, `or`, `not`).
+ * - Advanced combinators for working with data structures (e.g., `tuple`, `struct`).
+ * - Type-level utilities for inspecting predicate and refinement types.
+ *
  * @since 2.0.0
  */
 export * as Predicate from "./Predicate.js"

package/src/internal/channel.ts

@@ -2300,8 +2300,8 @@ const toQueueInternal = <Err, Done, Elem>(
         core.fromEffect(Queue.offer(queue, Either.right(elem))),
         () => toQueueInternal(queue)
       ),
-    onFailure: (cause) => core.fromEffect(pipe(Queue.offer(queue, Either.left(Exit.failCause(cause))))),
-    onDone: (done) => core.fromEffect(pipe(Queue.offer(queue, Either.left(Exit.succeed(done)))))
+    onFailure: (cause) => core.fromEffect(Queue.offer(queue, Either.left(Exit.failCause(cause)))),
+    onDone: (done) => core.fromEffect(Queue.offer(queue, Either.left(Exit.succeed(done))))
   })
 }
 

package/src/internal/core-effect.ts

@@ -2168,6 +2168,7 @@ export const endSpan = <A, E>(span: Tracer.Span, exit: Exit<A, E>, clock: Clock.
       return
     }
     if (core.exitIsFailure(exit) && internalCause.spanToTrace.has(span)) {
+      // https://opentelemetry.io/docs/specs/semconv/registry/attributes/code/#code-stacktrace
       span.attribute("code.stacktrace", internalCause.spanToTrace.get(span)!())
     }
     span.end(timingEnabled ? clock.unsafeCurrentTimeNanos() : bigint0, exit)

package/src/internal/dataSource.ts

@@ -190,20 +190,18 @@ export const eitherWith = dual<
 ) =>
   new core.RequestResolverImpl<C, R | R2>(
     (batch) =>
-      pipe(
-        core.forEachSequential(batch, (requests) => {
-          const [as, bs] = pipe(
-            requests,
-            RA.partitionMap(f)
-          )
-          return zipWithOptions(
-            self.runAll(Array.of(as)),
-            that.runAll(Array.of(bs)),
-            () => void 0,
-            { concurrent: true }
-          )
-        })
-      ),
+      core.forEachSequential(batch, (requests) => {
+        const [as, bs] = pipe(
+          requests,
+          RA.partitionMap(f)
+        )
+        return zipWithOptions(
+          self.runAll(Array.of(as)),
+          that.runAll(Array.of(bs)),
+          () => void 0,
+          { concurrent: true }
+        )
+      }),
     Chunk.make("EitherWith", self, that, f)
   ))
 

package/src/internal/fiberRuntime.ts

@@ -1772,10 +1772,10 @@ const existsLoop = <A, E, R>(
   if (next.done) {
     return core.succeed(false)
   }
-  return pipe(core.flatMap(
+  return core.flatMap(
     f(next.value, index),
     (b) => b ? core.succeed(b) : existsLoop(iterator, index + 1, f)
-  ))
+  )
 }
 
 /* @internal */

package/src/internal/groupBy.ts

@@ -467,20 +467,18 @@ export const groupByKey = dual<
           ),
         onFailure: (cause) => core.fromEffect(Queue.offer(outerQueue, take.failCause(cause))),
         onDone: () =>
-          pipe(
-            core.fromEffect(
-              pipe(
-                Effect.forEach(map.entries(), ([_, innerQueue]) =>
-                  pipe(
-                    Queue.offer(innerQueue, take.end),
-                    Effect.catchSomeCause((cause) =>
-                      Cause.isInterruptedOnly(cause) ?
-                        Option.some(Effect.void) :
-                        Option.none()
-                    )
-                  ), { discard: true }),
-                Effect.zipRight(Queue.offer(outerQueue, take.end))
-              )
+          core.fromEffect(
+            pipe(
+              Effect.forEach(map.entries(), ([_, innerQueue]) =>
+                pipe(
+                  Queue.offer(innerQueue, take.end),
+                  Effect.catchSomeCause((cause) =>
+                    Cause.isInterruptedOnly(cause) ?
+                      Option.some(Effect.void) :
+                      Option.none()
+                  )
+                ), { discard: true }),
+              Effect.zipRight(Queue.offer(outerQueue, take.end))
             )
           )
       })

package/src/internal/sink.ts

@@ -125,19 +125,17 @@ export const collectAllToMap = <In, K>(
   key: (input: In) => K,
   merge: (x: In, y: In) => In
 ): Sink.Sink<HashMap.HashMap<K, In>, In> => {
-  return pipe(
-    foldLeftChunks(HashMap.empty<K, In>(), (map, chunk) =>
-      pipe(
-        chunk,
-        Chunk.reduce(map, (map, input) => {
-          const k: K = key(input)
-          const v: In = pipe(map, HashMap.has(k)) ?
-            merge(pipe(map, HashMap.unsafeGet(k)), input) :
-            input
-          return pipe(map, HashMap.set(k, v))
-        })
-      ))
-  )
+  return foldLeftChunks(HashMap.empty<K, In>(), (map, chunk) =>
+    pipe(
+      chunk,
+      Chunk.reduce(map, (map, input) => {
+        const k: K = key(input)
+        const v: In = pipe(map, HashMap.has(k)) ?
+          merge(pipe(map, HashMap.unsafeGet(k)), input) :
+          input
+        return pipe(map, HashMap.set(k, v))
+      })
+    ))
 }
 
 /** @internal */
@@ -698,7 +696,7 @@ export const contextWithEffect = <R0, A, E, R>(
 export const contextWithSink = <R0, A, In, L, E, R>(
   f: (context: Context.Context<R0>) => Sink.Sink<A, In, L, E, R>
 ): Sink.Sink<A, In, L, E, R0 | R> =>
-  new SinkImpl(channel.unwrap(pipe(Effect.contextWith((context) => toChannel(f(context))))))
+  new SinkImpl(channel.unwrap(Effect.contextWith((context) => toChannel(f(context)))))
 
 /** @internal */
 export const every = <In>(predicate: Predicate<In>): Sink.Sink<boolean, In, In> =>
@@ -1487,7 +1485,7 @@ export const fromQueue = <In>(
         fromQueue
       )
     ) :
-    forEachChunk((input: Chunk.Chunk<In>) => pipe(Queue.offerAll(queue, input)))
+    forEachChunk((input: Chunk.Chunk<In>) => Queue.offerAll(queue, input))
 
 /** @internal */
 export const head = <In>(): Sink.Sink<Option.Option<In>, In, In> =>

package/src/internal/stm/stm.ts

@@ -340,21 +340,19 @@ export const every = dual<
     iterable: Iterable<A>,
     predicate: (a: A) => STM.STM<boolean, E, R>
   ): STM.STM<boolean, E, R> =>
-    pipe(
-      core.flatMap(core.sync(() => iterable[Symbol.iterator]()), (iterator) => {
-        const loop: STM.STM<boolean, E, R> = suspend(() => {
-          const next = iterator.next()
-          if (next.done) {
-            return core.succeed(true)
-          }
-          return pipe(
-            predicate(next.value),
-            core.flatMap((bool) => bool ? loop : core.succeed(bool))
-          )
-        })
-        return loop
+    core.flatMap(core.sync(() => iterable[Symbol.iterator]()), (iterator) => {
+      const loop: STM.STM<boolean, E, R> = suspend(() => {
+        const next = iterator.next()
+        if (next.done) {
+          return core.succeed(true)
+        }
+        return pipe(
+          predicate(next.value),
+          core.flatMap((bool) => bool ? loop : core.succeed(bool))
+        )
       })
-    )
+      return loop
+    })
 )
 
 /** @internal */
@@ -1156,12 +1154,10 @@ export const repeatWhile = dual<
 >(2, (self, predicate) => repeatWhileLoop(self, predicate))
 
 const repeatWhileLoop = <A, E, R>(self: STM.STM<A, E, R>, predicate: Predicate<A>): STM.STM<A, E, R> =>
-  pipe(
-    core.flatMap(self, (a) =>
-      predicate(a) ?
-        repeatWhileLoop(self, predicate) :
-        core.succeed(a))
-  )
+  core.flatMap(self, (a) =>
+    predicate(a) ?
+      repeatWhileLoop(self, predicate) :
+      core.succeed(a))
 
 /** @internal */
 export const replicate = dual<

package/src/internal/stream.ts

@@ -2016,7 +2016,7 @@ export const distributedWith = dual<
                 )
                 return pipe(
                   Deferred.succeed(deferred, (a: A) =>
-                    Effect.map(options.decide(a), (f) => (key: number) => pipe(f(mappings.get(key)!)))),
+                    Effect.map(options.decide(a), (f) => (key: number) => f(mappings.get(key)!))),
                   Effect.as(
                     Array.from(queues) as Types.TupleOf<N, Queue.Dequeue<Exit.Exit<A, Option.Option<E>>>>
                   )
@@ -2143,14 +2143,12 @@ export const distributedWithDynamicCallback = dual<
                     }),
                     Effect.flatMap((ids) => {
                       if (Chunk.isNonEmpty(ids)) {
-                        return pipe(
-                          Ref.update(queuesRef, (map) => {
-                            for (const id of ids) {
-                              map.delete(id)
-                            }
-                            return map
-                          })
-                        )
+                        return Ref.update(queuesRef, (map) => {
+                          for (const id of ids) {
+                            map.delete(id)
+                          }
+                          return map
+                        })
                       }
                       return Effect.void
                     })
@@ -8374,21 +8372,17 @@ export const zipLatestWith: {
                       mergeEither(repeatEffectOption(right)),
                       mapEffectSequential(Either.match({
                         onLeft: (leftChunk) =>
-                          pipe(
-                            Ref.modify(latest, ([_, rightLatest]) =>
-                              [
-                                pipe(leftChunk, Chunk.map((a) => f(a, rightLatest))),
-                                [Chunk.unsafeLast(leftChunk), rightLatest] as const
-                              ] as const)
-                          ),
+                          Ref.modify(latest, ([_, rightLatest]) =>
+                            [
+                              pipe(leftChunk, Chunk.map((a) => f(a, rightLatest))),
+                              [Chunk.unsafeLast(leftChunk), rightLatest] as const
+                            ] as const),
                         onRight: (rightChunk) =>
-                          pipe(
-                            Ref.modify(latest, ([leftLatest, _]) =>
-                              [
-                                pipe(rightChunk, Chunk.map((a2) => f(leftLatest, a2))),
-                                [leftLatest, Chunk.unsafeLast(rightChunk)] as const
-                              ] as const)
-                          )
+                          Ref.modify(latest, ([leftLatest, _]) =>
+                            [
+                              pipe(rightChunk, Chunk.map((a2) => f(leftLatest, a2))),
+                              [leftLatest, Chunk.unsafeLast(rightChunk)] as const
+                            ] as const)
                       })),
                       flatMap(fromChunk)
                     )

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "3.16.13"
+let moduleVersion = "3.16.14"
 
 export const getCurrentVersion = () => moduleVersion