Refactor Result

packages/effect-fc/src/Result.ts

@@ -5,18 +5,16 @@ export const ResultTypeId: unique symbol = Symbol.for("@effect-fc/Result/Result"
 export type ResultTypeId = typeof ResultTypeId
 
 export type Result<A, E = never, P = never> = (
-    | Initial
+    // biome-ignore lint/complexity/noBannedTypes: "{}" is relevant here
+    | (Initial & ({} | WillFetch))
     | Running<P>
     | Final<A, E, P>
-// biome-ignore lint/complexity/noBannedTypes: relevant here
-) & ({} | Optimistic)
+)
 
 export type Final<A, E = never, P = never> = (
     & (Success<A> | Failure<A, E>)
-    // biome-ignore lint/complexity/noBannedTypes: relevant here
-    & ({} | Refreshing<P>)
-    // biome-ignore lint/complexity/noBannedTypes: relevant here
-    & ({} | Optimistic)
+    // biome-ignore lint/complexity/noBannedTypes: "{}" is relevant here
+    & ({} | WillFetch | WillRefresh | Refreshing<P>)
 )
 
 export namespace Result {
@@ -49,13 +47,17 @@ export interface Failure<A, E = never> extends Result.Prototype {
     readonly previousSuccess: Option.Option<Success<A>>
 }
 
-export interface Refreshing<P = never> {
-    readonly refreshing: true
-    readonly progress: P
+export interface WillFetch extends Result.Prototype {
+    readonly willFetch: true
 }
 
-export interface Optimistic {
-    readonly optimistic: true
+export interface WillRefresh extends Result.Prototype {
+    readonly willRefresh: true
+}
+
+export interface Refreshing<P = never> extends Result.Prototype {
+    readonly refreshing: true
+    readonly progress: P
 }
 
 
@@ -111,8 +113,9 @@ export const isInitial = (u: unknown): u is Initial => isResult(u) && u._tag ===
 export const isRunning = (u: unknown): u is Running<unknown> => isResult(u) && u._tag === "Running"
 export const isSuccess = (u: unknown): u is Success<unknown> => isResult(u) && u._tag === "Success"
 export const isFailure = (u: unknown): u is Failure<unknown, unknown> => isResult(u) && u._tag === "Failure"
+export const isWillFetch = (u: unknown): u is WillFetch => isResult(u) && Predicate.hasProperty(u, "willFetch")
+export const isWillRefresh = (u: unknown): u is WillRefresh => isResult(u) && Predicate.hasProperty(u, "willRefresh")
 export const isRefreshing = (u: unknown): u is Refreshing<unknown> => isResult(u) && Predicate.hasProperty(u, "refreshing")
-export const isOptimistic = (u: unknown): u is Optimistic => isResult(u) && Predicate.hasProperty(u, "optimistic")
 
 export const initial: {
     (): Initial
@@ -130,7 +133,21 @@ export const fail = <E, A = never>(
     previousSuccess: Option.fromNullable(previousSuccess),
 }, ResultPrototype)
 
-export const refreshing = <R extends Success<any> | Failure<any, any>, P = never>(
+export const willFetch = <R extends Initial | Final<any, any, any>>(
+    result: R
+): Omit<R, keyof WillFetch> & WillFetch => Object.setPrototypeOf(
+    Object.assign({}, result, { willFetch: true }),
+    Object.getPrototypeOf(result),
+)
+
+export const willRefresh = <R extends Final<any, any, any>>(
+    result: R
+): Omit<R, keyof WillRefresh> & WillRefresh => Object.setPrototypeOf(
+    Object.assign({}, result, { willRefresh: true }),
+    Object.getPrototypeOf(result),
+)
+
+export const refreshing = <R extends Final<any, any, any>, P = never>(
     result: R,
     progress?: P,
 ): Omit<R, keyof Refreshing<Result.Progress<R>>> & Refreshing<P> => Object.setPrototypeOf(
@@ -138,13 +155,6 @@ export const refreshing = <R extends Success<any> | Failure<any, any>, P = never
     Object.getPrototypeOf(result),
 )
 
-export const optimistic = <R extends Success<any> | Failure<any, any>>(
-    result: R
-): Omit<R, keyof Optimistic> & Optimistic => Object.setPrototypeOf(
-    Object.assign({}, result, { optimistic: true }),
-    Object.getPrototypeOf(result),
-)
-
 export const fromExit = <A, E>(
     exit: Exit.Exit<A, E>,
     previousSuccess?: Success<NoInfer<A>>,