Use short-circuiting Result.Extra.combineMap

Author: miniBill

src/OpenApi/Types.elm

@@ -91,6 +91,7 @@ import Json.Decode.Extra
 import Json.Decode.Pipeline
 import Json.Encode exposing (Value)
 import Json.Schema.Definitions
+import Result.Extra
 
 
 
@@ -667,8 +668,7 @@ multipleTypesDecoder lst =
         otherList ->
             otherList
                 |> List.sort
-                |> List.map Json.Schema.Definitions.stringToType
-                |> foldResults
+                |> Result.Extra.combineMap Json.Schema.Definitions.stringToType
                 |> Result.map Json.Schema.Definitions.UnionType
                 |> resultToDecoder
 
@@ -700,15 +700,6 @@ failIfEmpty l =
         Json.Decode.succeed l
 
 
-foldResults : List (Result x y) -> Result x (List y)
-foldResults results =
-    results
-        |> List.foldl
-            (\t -> Result.andThen (\r -> t |> Result.map (\a -> a :: r)))
-            (Ok [])
-        |> Result.map List.reverse
-
-
 resultToDecoder : Result String a -> Decoder a
 resultToDecoder res =
     case res of

src/Result/Extra.elm

@@ -0,0 +1,34 @@
+module Result.Extra exposing (combineMap)
+
+{-|
+
+@docs combineMap
+
+-}
+
+
+{-| Map a function producing results on a list
+and combine those into a single result (holding a list).
+Also known as `traverse` on lists.
+
+    combineMap f xs == combine (List.map f xs)
+
+-}
+combineMap : (a -> Result x b) -> List a -> Result x (List b)
+combineMap f ls =
+    combineMapHelp f ls []
+
+
+combineMapHelp : (a -> Result x b) -> List a -> List b -> Result x (List b)
+combineMapHelp f list acc =
+    case list of
+        head :: tail ->
+            case f head of
+                Ok a ->
+                    combineMapHelp f tail (a :: acc)
+
+                Err x ->
+                    Err x
+
+        [] ->
+            Ok (List.reverse acc)