Lookup values inside a Cassava-ingested CSV - haskell

Question

I successfully read in a CSV using Cassava (http://hackage.haskell.org/package/cassava) with this:
getData = do
csvData <- BL.readFile "data.csv"
case decodeByName csvData of
Left err -> putStrLn err
Right (_, v) -> V.forM_ v $ \ p ->
putStrLn $ col1 p ++ "," ++ col2 p ++ "," ++ (show $ col3 p) ++ "," ++ (show $ col4 p) ++ "," ++ (show $ col5 p) ++ "," ++ col6 p ++ "," ++ (show $ col7 p) ++ "," ++ (show $ col8 p) ++ "," ++ (show $ col9 p) ++ "," ++ (show $ col10 p)
What I actually need to do is use the values in col3 as keys to find values in col10.
Someone suggested that I use Map from Data.Map (https://hackage.haskell.org/package/containers-0.4.0.0/docs/Data-Map.html) for this, but I'm not sure how to approach this.
Everything I have tried so far has not worked. I assume you enter the Map inside the Right case, along the lines of:
Right (_, v) -> Map (V.forM_ v) ???
But I am stuck on how to proceed. Would appreciate any suggestions. Ideally, I would want to modify getData so that it is getData keyToFetch = ... -- and that keyToFetch would be used in the Map.

Answer 1

Yes, it is probably a good idea to use Data.Map to find values in col10 using values in col3 as keys.
As we have little data about col3, col10 and the exact data type you are using, I will resort to adapting the decodebyName example in the Cassava documentation to the idea of generating a map object. The example is based on a very simple {name, salary} type of record.
The two branches of the case of construct have to return a common type, in our case a Data.Map object instead of an IO () action. Fortunately, the error function is flexible enough that it can pretend to be of the appropriate type.
This would give this sort of code:
{-# LANGUAGE OverloadedStrings #-}
import Control.Applicative
import qualified Data.ByteString.Lazy as BL
import Data.Csv
import qualified Data.Vector as V
import qualified Data.Map as M
import Control.Monad (forM_)
data Person = Person
{ name :: !String
, salary :: !Int
} deriving (Show, Ord, Eq) -- need that for Map objects
instance FromNamedRecord Person where
parseNamedRecord r = Person <$> r .: "name" <*> r .: "salary"
-- build a map object:
makeMap :: V.Vector Name -> V.Vector Person -> M.Map String Int
makeMap hdr pvec =
-- with name and salary playing the role of col3 and col10:
let pls = V.toList pvec -- get a list
zls = zip (map name pls) (map salary pls)
in M.fromList zls
showRecord :: String -> Int -> String
showRecord name salary = name ++ " earns " ++ (show salary) ++ " dollars"
main :: IO ()
main = do
csvData <- BL.readFile "salaries.csv"
let ma = case decodeByName csvData of
Left errMsg -> error $ "decodeByName failed: " ++ errMsg
Right (hdr, pvec) -> makeMap hdr pvec
-- print out the Map object:
putStrLn $ "Contents of map object:"
putStrLn $ show ma
putStrLn $ ""
forM_ (M.toList ma) (\(n,s) -> putStrLn $ showRecord n s)
let sal1 = M.lookup "John Doe" ma
putStrLn $ "sal1 = " ++ (show sal1)
--
Execution:
Contents of map object:
fromList [("Jane Doe",60000),("John Doe",50000)]
Jane Doe earns 60000 dollars
John Doe earns 50000 dollars
sal1 = Just 50000
Note that I have to use plain lists extensively, as for some reason there is no direct route from vectors to maps, something discussed already in this SO question.