RemoteData

RemoteData: object

Defined in: Core/RemoteData.ts:31

Type Declaration

apply

apply: <E2, A>(arg) => <B, E1>(remoteData) => RemoteData<E2 | E1, B>

Applies a function wrapped in a RemoteData to a value wrapped in a RemoteData.

Type Parameters

E2

E2 = never

A

A = unknown

Parameters

arg

RemoteData<E2, A>

Returns

<B, E1>(remoteData) => RemoteData<E2 | E1, B>

Example

const add = (a: number) => (b: number) => a + b;
pipe(
  RemoteData.make.success(add),
  RemoteData.apply(RemoteData.make.success(5)),
  RemoteData.apply(RemoteData.make.success(3))
); // Success(8)

chain

chain: <E2, A, B>(transform) => <E1>(remoteData) => RemoteData<E2 | E1, B>

Chains RemoteData computations. If the input is Success, passes the value to transform. Otherwise, propagates the current state.

Type Parameters

E2

E2

A

A

B

B

Parameters

transform

(value) => RemoteData<E2, B>

Returns

<E1>(remoteData) => RemoteData<E2 | E1, B>

See

RemoteData.map to transform the success value without returning a new RemoteData.

Example

pipe(
  RemoteData.make.success(5),
  RemoteData.chain(n => n > 0 ? RemoteData.make.success(n) : RemoteData.make.failure("negative"))
);

filter

filter: {<A, B, E2>(predicate, onFalse): <E1>(remoteData) => RemoteData<E2 | E1, B>; <A, E2>(predicate, onFalse): <E1>(remoteData) => RemoteData<E2 | E1, A>; }

Filters a Success value. When the predicate passes, the value is kept. When it fails, Success becomes Failure using the error produced by onFalse. All other states pass through unchanged.

Call Signature

<A, B, E2>(predicate, onFalse): <E1>(remoteData) => RemoteData<E2 | E1, B>

Type Parameters

A

A

B

B

E2

E2

Parameters

predicate

(value) => value is B

onFalse

(value) => E2

Returns

<E1>(remoteData) => RemoteData<E2 | E1, B>

Call Signature

<A, E2>(predicate, onFalse): <E1>(remoteData) => RemoteData<E2 | E1, A>

Type Parameters

A

A

E2

E2

Parameters

predicate

(value) => boolean

onFalse

(value) => E2

Returns

<E1>(remoteData) => RemoteData<E2 | E1, A>

Example

RemoteData.filter(n => n > 0, n => `${n} is not a valid price`)(RemoteData.make.success(9.99));
// Success(9.99)
RemoteData.filter(n => n > 0, n => `${n} is not a valid price`)(RemoteData.make.success(-1));
// Failure("-1 is not a valid price")
RemoteData.filter(n => n > 0, () => "error")(RemoteData.make.loading()); // Loading

from

from: object

from.Maybe

Maybe: <E>(onNone) => <A>(maybe) => RemoteData<E, A>

Converts a Maybe to a RemoteData. Some becomes Success, None becomes Failure using the onNone error producer.

Type Parameters

E

E

Parameters

onNone

() => E

Returns

<A>(maybe) => RemoteData<E, A>

Example

pipe(Maybe.make.some(user), RemoteData.from.Maybe(() => "not found")); // Success(user)
pipe(Maybe.make.none(), RemoteData.from.Maybe(() => "not found"));     // Failure("not found")

from.Result

Result: <E, A>(result) => RemoteData<E, A>

Converts a Result to a RemoteData. Ok becomes Success, Err becomes Failure.

Type Parameters

E

E

A

A

Parameters

result

Result<E, A>

Returns

RemoteData<E, A>

Example

const result = await Task.Result.tryCatch(() => loadUser(), { onError: String })();
setState(RemoteData.from.Result(result)); // Success(user) or Failure(msg)

getOrElse

getOrElse: <B>(fallback) => <A, E>(remoteData) => B | A

Returns the success value or a default value if the RemoteData is not Success. The default can be a different type, widening the result to A | B.

Type Parameters

B

B

Parameters

fallback

() => B

Returns

<A, E>(remoteData) => B | A

See

RemoteData.match to handle all four lifecycle states.

Example

pipe(RemoteData.make.success(5), RemoteData.getOrElse(() => 0)); // 5
pipe(RemoteData.make.loading(), RemoteData.getOrElse(() => 0)); // 0
pipe(RemoteData.make.loading(), RemoteData.getOrElse(() => null)); // null — typed as number | null

is

is: object

is.failure

failure: <E, A>(remoteData) => remoteData is Failure<E> = isFailure

Type guard that checks if a RemoteData is Failure.

Type Parameters

E

E

A

A

Parameters

remoteData

RemoteData<E, A>

Returns

remoteData is Failure<E>

See

RemoteData.is.success to check if data loaded successfully.

Example

const data = RemoteData.make.failure("Failed");
if (RemoteData.is.failure(data)) {
  console.log(data.error); // "Failed"
}

is.loading

loading: <E, A>(remoteData) => remoteData is Loading = isLoading

Type guard that checks if a RemoteData is Loading.

Type Parameters

E

E

A

A

Parameters

remoteData

RemoteData<E, A>

Returns

remoteData is Loading

Example

const data = RemoteData.make.loading();
if (RemoteData.is.loading(data)) {
  console.log("Data is loading");
}

is.notAsked

notAsked: <E, A>(remoteData) => remoteData is NotAsked = isNotAsked

Type guard that checks if a RemoteData is NotAsked.

Type Parameters

E

E

A

A

Parameters

remoteData

RemoteData<E, A>

Returns

remoteData is NotAsked

Example

const data = RemoteData.make.notAsked();
if (RemoteData.is.notAsked(data)) {
  console.log("Data fetch not initiated");
}

is.success

success: <E, A>(remoteData) => remoteData is Success<A> = isSuccess

Type guard that checks if a RemoteData is Success.

Type Parameters

E

E

A

A

Parameters

remoteData

RemoteData<E, A>

Returns

remoteData is Success<A>

See

RemoteData.is.failure to check if data loading failed.

Example

const data = RemoteData.make.success(42);
if (RemoteData.is.success(data)) {
  console.log(data.value); // 42
}

make

make: object

make.failure

failure: <E>(error) => Failure<E> = makeFailure

Creates a Failure RemoteData with the given error.

Type Parameters

E

E

Parameters

error

E

Returns

Failure<E>

Example

RemoteData.make.failure("Network error"); // Failure("Network error")

make.loading

loading: () => Loading = makeLoading

Creates a Loading RemoteData.

Returns

Loading

Example

RemoteData.make.loading(); // Loading

make.notAsked

notAsked: () => NotAsked = makeNotAsked

Creates a NotAsked RemoteData.

Returns

NotAsked

Example

RemoteData.make.notAsked(); // NotAsked

make.success

success: <A>(value) => Success<A> = makeSuccess

Creates a Success RemoteData with the given value.

Type Parameters

A

A

Parameters

value

A

Returns

Success<A>

Example

RemoteData.make.success(42); // Success(42)

map

map: <A, B>(transform) => <E>(remoteData) => RemoteData<E, B>

Transforms the success value inside a RemoteData.

Type Parameters

A

A

B

B

Parameters

transform

(value) => B

Returns

<E>(remoteData) => RemoteData<E, B>

See

• RemoteData.chain to sequence operations that themselves return a RemoteData.
• RemoteData.mapError to transform the error value instead of the success value.

Example

pipe(RemoteData.make.success(5), RemoteData.map(n => n * 2)); // Success(10)
pipe(RemoteData.make.loading(), RemoteData.map(n => n * 2)); // Loading

mapError

mapError: <E, F>(transform) => <A>(remoteData) => RemoteData<F, A>

Transforms the error value inside a RemoteData.

Type Parameters

E

E

F

F

Parameters

transform

(error) => F

Returns

<A>(remoteData) => RemoteData<F, A>

See

• RemoteData.map to transform the success value instead of the error value.
• RemoteData.chain to sequence operations that return a RemoteData.

Example

pipe(RemoteData.make.failure("oops"), RemoteData.mapError(e => e.toUpperCase())); // Failure("OOPS")

match

match: <E, A, B>(cases) => (remoteData) => B

Pattern matches on a RemoteData, returning the result of the matching case.

Type Parameters

E

E

A

A

B

B

Parameters

cases

failure

(error) => B

loading

() => B

notAsked

() => B

success

(value) => B

Returns

(remoteData) => B

Example

pipe(
  userData,
  RemoteData.match({
    notAsked: () => "Click to load",
    loading: () => "Loading...",
    failure: error => `Error: ${error}`,
    success: user => `Hello, ${user.name}!`
  })
);

recover

recover: <E1, B, E2>(fallback) => <A>(remoteData) => RemoteData<E2, B | A>

Recovers from a Failure state by providing a fallback RemoteData. The fallback can produce a different success type or resolve with a different error type.

Type Parameters

E1

E1

B

B = never

E2

E2 = never

Parameters

fallback

(error) => RemoteData<E2, B>

Returns

<A>(remoteData) => RemoteData<E2, B | A>

See

• RemoteData.getOrElse to extract the success value with a default fallback.
• RemoteData.mapError to transform the error without recovering from it.

Example

pipe(
  RemoteData.make.failure("offline"),
  RemoteData.recover((err) =>
    err === "offline" ? RemoteData.make.success(42) : RemoteData.make.failure(err)
  ),
); // Success(42)

tap

tap: <A>(sideEffect) => <E>(remoteData) => RemoteData<E, A>

Executes a side effect on the success value without changing the RemoteData.

Type Parameters

A

A

Parameters

sideEffect

(value) => void

Returns

<E>(remoteData) => RemoteData<E, A>

See

RemoteData.tapError to perform a side effect on the failure error.

Example

pipe(
  RemoteData.make.success(5),
  RemoteData.tap(n => console.log("Value:", n)),
  RemoteData.map(n => n * 2)
);

tapError

tapError: <E>(sideEffect) => <A>(remoteData) => RemoteData<E, A>

Executes a side effect on the failure error without changing the RemoteData. Useful for logging errors.

Type Parameters

E

E

Parameters

sideEffect

(error) => void

Returns

<A>(remoteData) => RemoteData<E, A>

See

RemoteData.tap to perform a side effect on the success value.

Example

pipe(
  RemoteData.make.failure("not found"),
  RemoteData.tapError(e => console.error("fetch failed:", e)),
  RemoteData.map(render)
);

to

to: object

to.Maybe

Maybe: <E, A>(remoteData) => Maybe<A>

Converts a RemoteData to a Maybe. Success becomes Some, all other states become None.

Type Parameters

E

E

A

A

Parameters

remoteData

RemoteData<E, A>

Returns

Maybe<A>

See

• RemoteData.to.Result to convert to a Result with an error fallback.
• RemoteData.from.Maybe to convert a Maybe into a RemoteData.

Example

RemoteData.to.Maybe(RemoteData.make.success(42)); // Some(42)
RemoteData.to.Maybe(RemoteData.make.loading());   // None
RemoteData.to.Maybe(RemoteData.make.failure("e")); // None

to.Result

Result: <E2>(onNotReady) => <E1, A>(remoteData) => Result<E2 | E1, A>

Converts a RemoteData to a Result. Success becomes Ok, Failure becomes Err. NotAsked and Loading become Err with the provided fallback error.

Type Parameters

E2

E2

Parameters

onNotReady

() => E2

Returns

<E1, A>(remoteData) => Result<E2 | E1, A>

Example

pipe(
  RemoteData.make.success(42),
  RemoteData.to.Result(() => "not loaded")
); // Ok(42)