bedingte Standard-Handle-Umleitung in Haskell

Question

Ich möchte eine Datei lesen, verarbeiten und die Ergebnisse in eine andere Datei schreiben; Der Name der Eingabedatei muss über ein Konsolenargument angegeben werden. Der Name der Ausgabedatei wird aus dem Namen der Eingabedatei generiert.

Der Haken ist, ich will es transparent "fail over" zu stdin/stdout, wenn keine Argumente geliefert werden; Im Wesentlichen, falls ein Dateiname angegeben wird, leite ich stdin/stdout zu den entsprechenden Dateinamen um, so dass ich interact transparent verwenden kann, egal ob der Dateiname angegeben wurde oder nicht.

Hier ist der Code zusammen mit Dummy-Ausgang in einem überflüssigen else gehackt. Was wird die richtige, idiomatische Form sein, es zu tun?

Es könnte wahrscheinlich etwas mit Control.Monad ist zu tun, wenn oder Wache, wie es in einer ähnlichen Frage erwähnt, aber vielleicht jemand schon schrieb.

import System.IO 
import Data.Char(toUpper) 
import System.Environment 
import GHC.IO.Handle 

main :: IO() 
main = do 
     args <- getArgs 
     if(not $ null args) then 
     do 
      print $ "working with "++ (head args) 
      finHandle <- openFile (head args) ReadMode --open the supplied input file 
      hDuplicateTo finHandle stdin --bind stdin to finName's handle 
      foutHandle <- openFile ((head args) ++ ".out") WriteMode --open the output file for writing 
      hDuplicateTo foutHandle stdout --bind stdout to the outgoing file 
     else print "working through stdin/redirect" --get to know 
     interact ((++) "Here you go---\n" . map toUpper) 

Answer 1

Es gibt nichts ganz Besonderes interact - hier ist seine Definition:

interact  :: (String -> String) -> IO() 
interact f  = do s <- getContents 
         putStr (f s) 

Wie wäre es damit so etwas wie:

import System.Environment 
import Data.Char 

main = do 
    args <- getArgs 
    let (reader, writer) = 
     case args of 
      []   -> (getContents, putStr) 
      (path : _) -> let outpath = path ++ ".output" 
         in (readFile path, writeFile outpath) 
    contents <- reader 
    writer (process contents) 

process :: String -> String 
process = (++) "Here you go---\n" . map toUpper 

auf den Zeilenbefehl Basierend Argumente, die wir gesetzt reader und writer zu den IO-Aktionen, die die Eingabe lesen und die Ausgabe schreiben.

Answer 2

Dies scheint ziemlich idiomatischen mir schon. Die einzige Notiz, die ich habe, ist head zu vermeiden, da es eine unsichere Funktion ist (es kann einen Laufzeitfehler verursachen). In diesem Fall ist es ziemlich einfach, dies zu tun, indem Sie case zum Mustervergleich verwenden.

main :: IO() 
main = do 
    args <- getArgs 
    case args of 
    fname:_ -> do 
     print $ "working with " ++ fname 
     finHandle <- openFile fname ReadMode 
     hDuplicateTo finHandle stdin 
     foutHandle <- openFile (fname ++ ".out") WriteMode 
     hDuplicateTo foutHandle stdout 
    [] -> do 
     print "working through stdin/redirect" 
    interact ((++) "Here you go---\n" . map toUpper)