RemoteData

RemoteData: object

Defined in: Core/RemoteData.ts:30

Type Declaration

ap

ap: <E, A>(arg) => <B>(data) => RemoteData<E, B>

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

Type Parameters

E

E

A

A

Parameters

arg

RemoteData<E, A>

Returns

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

Example

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

chain

chain: <E2, A, B>(f) => <E1>(data) => RemoteData<E2 | E1, B>

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

Type Parameters

E2

E2

A

A

B

B

Parameters

f

(a) => RemoteData<E2, B>

Returns

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

Example

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

filter

filter: <E, A>(pred, onFalse) => (data) => RemoteData<E, 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.

Type Parameters

E

E

A

A

Parameters

pred

(a) => boolean

onFalse

(a) => E

Returns

(data) => RemoteData<E, 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

fold

fold: <E, A, B>(onFailure, onNotAsked, onLoading, onSuccess) => (data) => B

Extracts the value from a RemoteData by providing handlers for all four cases.

Type Parameters

E

E

A

A

B

B

Parameters

onFailure

(e) => B

onNotAsked

() => B

onLoading

() => B

onSuccess

(a) => B

Returns

(data) => B

Example

pipe(
  userData,
  RemoteData.fold(
    e => `Error: ${e}`,
    () => "Not asked",
    () => "Loading...",
    value => `Got: ${value}`
  )
);

from

from: object

from.Maybe

Maybe: <E>(onNone) => <A>(data) => 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>(data) => 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>(data) => RemoteData<E, A>

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

Type Parameters

E

E

A

A

Parameters

data

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>(defaultValue) => <E, A>(data) => 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

defaultValue

() => B

Returns

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

Example

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

is

is: object

is.failure

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

Type guard that checks if a RemoteData is Failure.

Type Parameters

E

E

A

A

Parameters

data

RemoteData<E, A>

Returns

data is Failure<E>

Example

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

is.loading

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

Type guard that checks if a RemoteData is Loading.

Type Parameters

E

E

A

A

Parameters

data

RemoteData<E, A>

Returns

data is Loading

Example

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

is.notAsked

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

Type guard that checks if a RemoteData is NotAsked.

Type Parameters

E

E

A

A

Parameters

data

RemoteData<E, A>

Returns

data is NotAsked

Example

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

is.success

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

Type guard that checks if a RemoteData is Success.

Type Parameters

E

E

A

A

Parameters

data

RemoteData<E, A>

Returns

data is Success<A>

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>(f) => <E>(data) => RemoteData<E, B>

Transforms the success value inside a RemoteData.

Type Parameters

A

A

B

B

Parameters

f

(a) => B

Returns

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

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>(f) => <A>(data) => RemoteData<F, A>

Transforms the error value inside a RemoteData.

Type Parameters

E

E

F

F

Parameters

f

(e) => F

Returns

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

Example

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

match

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

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

Type Parameters

E

E

A

A

B

B

Parameters

cases

failure

(e) => B

loading

() => B

notAsked

() => B

success

(a) => B

Returns

(data) => B

Example

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

recover

recover: <E, B>(fallback) => <A>(data) => RemoteData<E, B | A>

Recovers from a Failure state by providing a fallback RemoteData. The fallback can produce a different success type, widening the result to RemoteData<E, A | B>.

Type Parameters

E

E

B

B

Parameters

fallback

(e) => RemoteData<E, B>

Returns

<A>(data) => RemoteData<E, B | A>

tap

tap: <E, A>(f) => (data) => RemoteData<E, A>

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

Type Parameters

E

E

A

A

Parameters

f

(a) => void

Returns

(data) => RemoteData<E, A>

Example

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

tapError

tapError: <E, A>(f) => (data) => RemoteData<E, A>

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

Type Parameters

E

E

A

A

Parameters

f

(e) => void

Returns

(data) => RemoteData<E, A>

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>(data) => Maybe<A>

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

Type Parameters

E

E

A

A

Parameters

data

RemoteData<E, A>

Returns

Maybe<A>

to.Result

Result: <E>(onNotReady) => <A>(data) => Result<E, 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

E

E

Parameters

onNotReady

() => E

Returns

<A>(data) => Result<E, A>

Example

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