在Haskell与IO monad斗争

Question

So i've got two files with the following content:

File 1:
    Tom 965432145  
    Bill 932121234

File 2:
      Steve 923432323  
      Tom 933232323

and i want to merge them and write the resulting output to a file named 'out.txt'. i wrote this function to deal with duplicates (when the same name appears more than once, it choses what number goes into the final file).

the function is called choosing:

choosing :: [String] −> Int −> Int −> Int
choosing ("Name_of_person":_) num1 _ = num1 
choosing _ num1 num2
        | num2 ‘div‘ 100000000 == 2 = num2
        | otherwise = num1

Here's my attempt at this:

import System.IO
import Data.Char

choosing :: [String] −> Int −> Int −> Int
choosing name num1 _ = num1
choosing _ num1 num2
  | num2 `div` 100000000 == 2 = num2
  | otherwise = num1

main :: IO ()
main = do 
   in1 <- openFile "in1.txt" ReadMode
   in2 <- openFile "in2.txt" ReadMode
   out <- openFile "out.txt" WriteMode
   processData in1 in2 out
   hClose in1
   hClose in2
   hClose out



processData :: Handle -> Handle -> Handle -> IO ()
processData in1 in2 out =
    do ineof <- hIsEOF in1
       ineof2 <- h2IsEOF in2
        if ineof && ineof2
            then return ()
            else do inpStr <- hGetLine in1
                    inp2Str <- h2GetLine in2
                    num1Int <- num1GetNumber in1
                    num2Int <- num2GetNumber in2
                    if inpStr = inp2Str 
                        then PutStrLn out (impStr choosing inpStr num1Int num2Int )
                        else PutStrLn out (inpStr num1Int)
                             PutStrLn out (inp2Str num2Int)
                             processData in1 in2 out

However this kinda of makes sense to me, it doesn't compile and after a while trying to debug this i'm now starting to think there's some serious mistakes here, so i would really appreciate your help on this.

Here's my attempt at something simpler first:

import System.IO
import Data.Char


choosing name num1 _ = num1
choosing _ num1 num2
  | num2 `div` 100000000 == 2 = num2
  | otherwise = num1

main :: IO ()
main = do 
   in1 <- openFile "in1.rtf" ReadMode
   in2 <- openFile "in2.rtf" ReadMode
   out <- openFile "out.rtf" WriteMode
   mainloop in1 out
   mainloop in2 out
   hClose in1
   hClose in2
   hClose out


mainloop :: Handle -> Handle -> IO ()
mainloop _ out =
  do ineof <- hIsEOF in
     if ineof
       then return ()
       else do inpStr <- hGetLine in
               hPutStrLn out (inpStr)
               mainloop in out

but it's not working either...

UPDATED:

So basically i've been trying to solve my problem, with all the tips i got, i managed to do this:

import System.IO
import Data.Char

- Main function to run the program

main = do
  entries1 <- fmap parseEntries $ readFile "in1.txt"
  entries2 <- fmap parseEntries $ readFile "in2.txt"
  writeFile "out.txt" $ serializeEntries $ mergeEntries entries1 entries2

- Function to deal with duplicates

choosing name num1 _ = num1
choosing _ num1 num2
  | num2 `div` 100000000 == 2 = num2
  | otherwise = num1

- Function to read a line from a file into a tuple
Now i need help making this function 'cover' the whole file, and not just one line of it.

parseLine :: String -> (String, Int)
parseLine xs = (\(n:i:_) -> (n, read i)) (words xs)


- A function that receives entries, merges them into a single string so that it can be writen to a file.

import Data.Char

tupleToString :: (Int, Char) -> [Char]
tupleToString x = (intToDigit.fst) x:(snd x):[]

tuplesToStrings [] = []
tuplesToStrings (x:xs) = tupleToString x : tuplesToStrings xs

tuplesToString xs = (concat . tuplesToStrings) xs

Answer 1

I think the problem is that your thinking too imperative. In Haskell you usually split your solution in small blocks, and each block does only one thing. It's much easier to reason about one small block, and it's also easier to reuse that block in other parts. For example, here's how I would breakdown the code for this problem:

parseEntries :: String -> [(String, Int)]

A function that receives the content of a file and parses the entries. It the case of the content of in1.txt it would return [("Tom", 965432145), ("Bill", 932121234)]

---

mergeEntries :: [(String, Int)] -> [(String, Int)] -> [(String, Int)]

A function that receives entries from two files and merges them.

---

serializeEntries :: [(String, Int)] -> String

A function that receives entries, merges them into a single string so that it can be writen to a file.

---

Having defined these functions, main becomes as simple as this:

main = do
  entries1 <- fmap parseEntries $ readFile "in1.txt"
  entries2 <- fmap parseEntries $ readFile "in2.txt"
  writeFile "out.txt" $ serializeEntries $ mergeEntries entries1 entries2

Answer 2

Answering to your updated code:

1. Now that you have a function to parse a line, parseEntries is easy. Use the lines function to split the content by lines, then map parseLine to each line.

2. tuplesToStrings could be writen much simpler as tuplesToStrings = map tupleToString

3. I don't see how tuplesToString will help you. Its type doesn't match the type returned by parseLine ( parseLine returns a list of (String, Int) while tuplesToString expects a list of (Int, Char) ). And it doesn't even insert spaces between words or between lines. Here's a possible implementation for serializeEntries (using Text.Printf module):

   serializeEntries entries = concatMap (uncurry $ printf "%s %d\\n") entries