Use ResultMap to abstract functor

DataParser.Console/DataParser.Console.fsproj

@@ -9,6 +9,7 @@
     <ItemGroup>
         <Compile Include="Result.fs" />
         <Compile Include="ResultBuilder.fs" />
+        <Compile Include="ResultMap.fs" />
         <Compile Include="Core.fs" />
         <Compile Include="FormatFiles.fs" />
         <Compile Include="DataFiles.fs" />

DataParser.Console/FileRead.fs

@@ -4,6 +4,7 @@ open DataParser.Console.Core
 open DataParser.Console.FormatFiles
 open DataParser.Console.DataFiles
 open System.IO
+open ResultMap
 
 let readAllSpecFiles folderPath =
     let createFormatFileTuple (filePath: string) =
@@ -34,14 +35,17 @@ let readDataFiles folderPath =
             (file, Path.GetFileNameWithoutExtension file)
     }
 
-let mapDataFilePath specs (filePath, fileName) =
-    let getSuccessfulKeys = Set.ofSeq << Map.keys << Map.filter (fun _ -> Result.isOk)
-
-    result {
-        let! DataFileName (dataFileName, _) = parseDataFileName fileName
-        let! dataFileFormat =
-            match Map.tryFind dataFileName specs with
-            | Some formatLines -> Result.bind (flip getDataFileFormat (filePath, fileName)) formatLines
-            | None -> Error [FileFormatNotFound (getSuccessfulKeys specs, dataFileName)]
-        return! parseDataFile dataFileFormat
-    }
+let getDataFileFormats resultMap =
+    let folder (resultMap as ResultMap specs) state (filePath, fileName)  =
+        match parseDataFileName fileName with
+        | Error e -> Map.add filePath (Error e) state
+        | Ok (DataFileName (formatName, _)) ->
+            let r = 
+                match Map.tryFind formatName specs with
+                | Some formatLines ->
+                    Result.bind (flip getDataFileFormat (filePath, fileName)) formatLines
+                | None -> Error [FileFormatNotFound (ResultMap.keys resultMap, formatName)]
+            Map.add filePath r state
+
+    Seq.fold (folder resultMap) Map.empty        
+

DataParser.Console/Program.fs

@@ -1,6 +1,7 @@
 open System
 open DataParser.Console.FileRead
 open DataParser.Console.FileWrite
+open ResultMap
 
 [<Literal>] 
 let specFolderPath = "./specs"
@@ -11,21 +12,27 @@ let dataFolderPath = "./data"
 [<Literal>]
 let outputFolderPath = "./output"
 
-let okHandler = writeOutputFile outputFolderPath
+let okHandler _ = writeOutputFile outputFolderPath
 
-let errorHandler = List.iter (eprintfn "Error occurred during processing: %+A")
+let errorHandler key errors = eprintfn $"Error occurred during processing format: {key}. Error is : %+A{errors}"
 
 printfn "Reading spec files..."
-let specs = readAllSpecFiles specFolderPath
+let specs = ResultMap (readAllSpecFiles specFolderPath)
 
 printfn "Retrieving data files..."
 let dataFiles = readDataFiles dataFolderPath
 
 printfn "Parsing data files..."
-let dataFileParsedResults = Seq.map (mapDataFilePath specs) dataFiles
+let parsedDateFileFormats =
+    dataFiles
+    |> getDataFileFormats specs
+    |> ResultMap
+
+let dataFileParsedResults =
+    ResultMap.bindResult parseDataFile parsedDateFileFormats
 
 printfn "Writing to output..."
-Seq.iter (Result.biFoldMap okHandler errorHandler) dataFileParsedResults
+ResultMap.biIter okHandler errorHandler dataFileParsedResults
 
 printfn "Processing complete. Press Enter to exit."
 ignore <| Console.ReadLine()

DataParser.Console/ResultMap.fs

@@ -0,0 +1,22 @@
+namespace ResultMap
+
+type ResultMap<'TKey, 'TOkValue, 'TErrorValue when 'TKey : comparison> =
+    ResultMap of Map<'TKey, Result<'TOkValue, 'TErrorValue list>>
+
+module ResultMap =
+    let map f (ResultMap x) =
+        x
+        |> Map.map (fun _ -> Result.map f)
+        |> ResultMap
+
+    let bindResult f (ResultMap x) =
+        x
+        |> Map.map (fun _ -> Result.bind f)
+        |> ResultMap
+
+    let keys (ResultMap x) = Set.ofSeq (Map.keys x)
+
+    let biIter f g (ResultMap x) =
+        let go k = function Ok v -> f k v | Error e -> g k e
+        Map.iter go x
+