Loadable

Loadable and reloadable data. Loadable is an extension of RemoteData to include a loading state in the success and failure cases.

Types

type Loadable e a

A Loadable value is either empty, failed, or succeeded, and may be loading or not

type Value e a

= Empty

| Failure e

| Success a

The value of a Loadable, aside from its loading state

Constructors

notAsked : Loadable e a

An empty value that is not loading

loading : Loadable e a

An empty value that is loading

succeed : a -> Loadable e a

A successful value that is not loading

fail : e -> Loadable e a

A failed value that is not loading

Combinators

map : (a -> b) -> Loadable e a -> Loadable e b

Map the value of a Loadable

map (\a -> a + 1) (succeed 1) --> succeed 2


map (\_ -> 0) (fail "error") --> fail "error"

andMap : Loadable e a -> Loadable e (a -> b) -> Loadable e b

Apply a function to the value of a Loadable

succeed (\a -> a + 1) |> andMap (succeed 1) --> succeed 2

andThen : (a -> Loadable e b) -> Loadable e a -> Loadable e b

Should match the semantics of the Monad instance for

ExceptT e (MaybeT (Writer Any))

succeed 1 |> andThen (\a -> succeed (a + 100)) --> succeed 101


succeed 1 |> andThen (\_ -> fail "error") --> fail "error"


fail "error" |> andThen (\_ -> loading) --> fail "error"


notAsked |> andThen (\_ -> loading) --> notAsked


loading |> andThen (\_ -> notAsked) --> loading

combineMap : (a -> Loadable e b) -> List a -> Loadable e (List b)

Combine a list of Loadable values

combineMap succeed [ 1, 2, 3 ]
--> succeed [ 1, 2, 3 ]


let
    odd n =
        modBy 2 n == 1
    failIfOdd n =
        if odd n then
            fail (String.fromInt n)
        else
            succeed n
in
combineMap failIfOdd [ 1, 2, 3 ]
--> fail "1"

fromMaybe : Maybe a -> Loadable e a

Convert a Maybe into a Loadable

fromMaybe (Just 1) --> succeed 1


fromMaybe Nothing --> notAsked

fromResult : Result e a -> Loadable e a

Convert a Result into a Loadable

fromResult (Ok 1) --> succeed 1


fromResult (Err "error") --> fail "error"

toLoading : Loadable e a -> Loadable e a

Set loading to True

toLoading loading --> loading


toLoading notAsked --> loading

toNotLoading : Loadable e a -> Loadable e a

Set loading to False

toNotLoading loading --> notAsked


toNotLoading notAsked --> notAsked

andMapWith : (e -> e -> e) -> Loadable e a -> Loadable e (a -> b) -> Loadable e b

Apply a function to the value of a Loadable, combining the errors.

NOTE: This is intended to be used in a pipeline, with errors accumulating left to right in the pipeline not in the order of arguments to the function. See the examples.

succeed (\a -> a ++ "b")
    |> andMapWith (++) (succeed "a")
    --> succeed "ab"


fail "a"
    |> andMapWith (++) (fail "b")
    --> fail "ab"

combineMapWith : (e -> e -> e) -> (a -> Loadable e b) -> List a -> Loadable e (List b)

Combine a list of Loadable values with a function that combines the errors

combineMapWith (\x _ -> x) == combineMap


let
    odd n =
        modBy 2 n == 1
    failIfOdd n =
        if odd n then
            fail (String.fromInt n)
        else
            succeed n
in
combineMapWith (++) failIfOdd [ 1, 2, 3 ] --> fail "13"

Destructors

withDefault : a -> Loadable e a -> a

Get the success value out of Loadable or a fallback if it's not the success case

withDefault 0 (succeed 1) --> 1


withDefault 0 notAsked --> 0

toMaybe : Loadable e a -> Maybe a

Convert a Loadable to a Maybe

toMaybe (succeed 1) --> Just 1


toMaybe notAsked --> Nothing

toMaybeError : Loadable e a -> Maybe e

Convert a Loadable to a Maybe of the error type

toMaybeError (fail "error") --> Just "error"


toMaybeError notAsked --> Nothing

isLoading : Loadable e a -> Bool

Check if the Loadable is loading

isLoading loading --> True


isLoading notAsked --> False

unwrap :

Loadable e a

-> { value : Value e a

, isLoading : Bool

}

Unwrap a Loadable

unwrap (succeed 1) --> { value = Success 1, isLoading = False }


unwrap notAsked --> { value = Empty, isLoading = False }

value : Loadable e a -> Value e a

Get the value of a Loadable

value (succeed 1) --> Success 1


value notAsked --> Empty

Modules

Loadable