support Refinements in \*Until apis (#672)

.changeset/rich-crabs-obey.md

@@ -0,0 +1,5 @@
+---
+"@effect/io": patch
+---
+
+support Refinements in \*Until apis

docs/modules/Effect.ts.md

@@ -2504,7 +2504,9 @@ Retries this effect until its error satisfies the specified predicate.
 
 ```ts
 export declare const retryUntil: {
+  <E, E2 extends E>(f: Refinement<E, E2>): <R, A>(self: Effect<R, E, A>) => Effect<R, E2, A>
   <E>(f: Predicate<E>): <R, A>(self: Effect<R, E, A>) => Effect<R, E, A>
+  <R, E, A, E2 extends E>(self: Effect<R, E, A>, f: Refinement<E, E2>): Effect<R, E2, A>
   <R, E, A>(self: Effect<R, E, A>, f: Predicate<E>): Effect<R, E, A>
 }
 ```
@@ -4420,7 +4422,9 @@ until the first failure.
 
 ```ts
 export declare const repeatUntil: {
+  <A, B extends A>(f: Refinement<A, B>): <R, E>(self: Effect<R, E, A>) => Effect<R, E, B>
   <A>(f: Predicate<A>): <R, E>(self: Effect<R, E, A>) => Effect<R, E, A>
+  <R, E, A, B extends A>(self: Effect<R, E, A>, f: Predicate<A>): Effect<R, E, B>
   <R, E, A>(self: Effect<R, E, A>, f: Predicate<A>): Effect<R, E, A>
 }
 ```

src/Effect.ts

@@ -1772,7 +1772,9 @@ export const retryOrElse: {
  * @category error handling
  */
 export const retryUntil: {
+  <E, E2 extends E>(f: Refinement<E, E2>): <R, A>(self: Effect<R, E, A>) => Effect<R, E2, A>
   <E>(f: Predicate<E>): <R, A>(self: Effect<R, E, A>) => Effect<R, E, A>
+  <R, E, A, E2 extends E>(self: Effect<R, E, A>, f: Refinement<E, E2>): Effect<R, E2, A>
   <R, E, A>(self: Effect<R, E, A>, f: Predicate<E>): Effect<R, E, A>
 } = _schedule.retryUntil_Effect
 
@@ -3918,7 +3920,9 @@ export const repeatOrElse: {
  * @category repetition / recursion
  */
 export const repeatUntil: {
+  <A, B extends A>(f: Refinement<A, B>): <R, E>(self: Effect<R, E, A>) => Effect<R, E, B>
   <A>(f: Predicate<A>): <R, E>(self: Effect<R, E, A>) => Effect<R, E, A>
+  <R, E, A, B extends A>(self: Effect<R, E, A>, f: Predicate<A>): Effect<R, E, B>
   <R, E, A>(self: Effect<R, E, A>, f: Predicate<A>): Effect<R, E, A>
 } = _schedule.repeatUntil_Effect
 

src/internal/schedule.ts

@@ -7,7 +7,7 @@ import type { LazyArg } from "@effect/data/Function"
 import { constVoid, dual, pipe } from "@effect/data/Function"
 import * as Option from "@effect/data/Option"
 import { pipeArguments } from "@effect/data/Pipeable"
-import type { Predicate } from "@effect/data/Predicate"
+import type { Predicate, Refinement } from "@effect/data/Predicate"
 import type * as Cause from "@effect/io/Cause"
 import * as Clock from "@effect/io/Clock"
 import type * as Effect from "@effect/io/Effect"
@@ -1830,9 +1830,19 @@ const repeatOrElseEffectLoop = <R, E, A extends A0, A0, R1, B, R2, E2, C>(
 
 /** @internal */
 export const repeatUntil_Effect = dual<
-  <A>(f: Predicate<A>) => <R, E>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
-  <R, E, A>(self: Effect.Effect<R, E, A>, f: Predicate<A>) => Effect.Effect<R, E, A>
->(2, (self, f) => repeatUntilEffect_Effect(self, (a) => core.sync(() => f(a))))
+  {
+    <A, B extends A>(f: Refinement<A, B>): <R, E>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, B>
+    <A>(f: Predicate<A>): <R, E>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
+  },
+  {
+    <R, E, A, B extends A>(self: Effect.Effect<R, E, A>, f: Predicate<A>): Effect.Effect<R, E, B>
+    <R, E, A>(self: Effect.Effect<R, E, A>, f: Predicate<A>): Effect.Effect<R, E, A>
+  }
+>(
+  2,
+  <R, E, A>(self: Effect.Effect<R, E, A>, f: Predicate<A>) =>
+    repeatUntilEffect_Effect(self, (a) => core.sync(() => f(a)))
+)
 
 /** @internal */
 export const repeatUntilEffect_Effect: {
@@ -1946,9 +1956,15 @@ const retryOrElse_EffectLoop = <R, E, A, R1, A1, R2, E2, A2>(
 
 /** @internal */
 export const retryUntil_Effect = dual<
-  <E>(f: Predicate<E>) => <R, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
-  <R, E, A>(self: Effect.Effect<R, E, A>, f: Predicate<E>) => Effect.Effect<R, E, A>
->(2, (self, f) =>
+  {
+    <E, E2 extends E>(f: Refinement<E, E2>): <R, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E2, A>
+    <E>(f: Predicate<E>): <R, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
+  },
+  {
+    <R, E, A, E2 extends E>(self: Effect.Effect<R, E, A>, f: Refinement<E, E2>): Effect.Effect<R, E2, A>
+    <R, E, A>(self: Effect.Effect<R, E, A>, f: Predicate<E>): Effect.Effect<R, E, A>
+  }
+>(2, <R, E, A>(self: Effect.Effect<R, E, A>, f: Predicate<E>) =>
   retryUntilEffect_Effect(
     self,
     (e) => core.sync(() => f(e))