finos / morphir-elm / Morphir.SDK.ResultList

This module contains operations that are specific to lists of results. These operations are very useful for modeling processing pipelines where errors could happen at any point in the pipeline but they should not break the processing itself.


type alias ResultList e a =
List (Result e a)

Type that represents a list that contains a mix of failed and successful records.

Creating

fromList : List a -> ResultList e a

Create a result list from any list.

fromList [ 1, 2, 3 ] == [ Ok 1, Ok 2, Ok 3 ]

Processing

filter : (a -> Basics.Bool) -> ResultList e a -> ResultList e a

Filter a result list retaining all previously failed items.

filter isOdd [ Ok 1, Ok 2, Ok 3 ] == [ Ok 1, Ok 3 ]

filter isOdd [ Err "foo", Ok 2, Ok 3 ] == [ Err "foo", Ok 3 ]

filterOrFail : (a -> Result e Basics.Bool) -> ResultList e a -> ResultList e a

Filter a result list retaining all previously failed items.

divide a =
    if a == 0 then
        Err "division by zero"

    else
        isOdd a

filterOrFail divide [ Ok -1, Ok 0, Err "earlier", Ok 2 ] == [ Ok -1, Err "division by zero", Err "earlier" ]

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

Map a result list retaining all previously failed items.

map double [ Ok 1, Ok 2, Ok 3 ] == [ Ok 2, Ok 4, Ok 6 ]

map isOdd [ Err "foo", Ok 2, Ok 3 ] == [ Err "foo", Ok 4, Ok 6 ]

mapOrFail : (a -> Result e b) -> ResultList e a -> ResultList e b

Map a result list retaining all previously failed items.

divide a =
    if a == 0 then
        Err "division by zero"

    else
        Ok (100 / a)

mapOrFail divide [ Ok -1, Ok 0, Err "earlier" ] == [ Ok -100, Err "division by zero", Err "earlier" ]

Decomposing

errors : ResultList e a -> List e

Extract all errors from the result list.

errors [ Ok 1, Ok 2, Ok 3, Ok 4 ] == []

errors [ Ok 1, Err "foo", Ok 3, Err "bar" ] == [ Err "foo", Err "bar" ]

errors [ Err "foo", Err "bar" ] == [ Err "foo", Err "bar" ]

successes : ResultList e a -> List a

Extract all successes from the result list.

successes [ Ok 1, Ok 2, Ok 3, Ok 4 ] == [ Ok 1, Ok 2, Ok 3, Ok 4 ]

successes [ Ok 1, Err "foo", Ok 3, Err "bar" ] == [ Ok 1, Ok 3 ]

successes [ Err "foo", Err "bar" ] == []

partition : ResultList e a -> ( List e, List a )

Partition a result list into errors and successes.

partition [ Ok 1, Ok 2, Ok 3, Ok 4 ] == ( [], [ Ok 1, Ok 2, Ok 3, Ok 4 ] )

partition [ Ok 1, Err "foo", Ok 3, Err "bar" ] == ( [ Err "foo", Err "bar" ], [ Ok 1, Ok 3 ] )

partition [ Err "foo", Err "bar" ] == ( [ Err "foo", Err "bar" ], [] )

Mapping to single result

keepAllErrors : ResultList e a -> Result (List e) (List a)

Turn a list of results into a single result keeping all errors.

keepFirstError : ResultList e a -> Result e (List a)

Turn a list of results into a single result keeping only the first error.