C'è un modo migliore per farlo in Haskell?

Question

Ho scritto quanto segue per aiutare i nipoti con il loro lavoro a scuola a casa e per mantenere il lavoro mentale imparando come programmare (pensavo che haskell suonasse fantastico).

main :: IO() 
main = do 
    putStrLn "Please enter the dividend :" 
    inputx <- getLine 
    putStrLn "Please enter the divisor :" 
    inputy <- getLine 
    let x = (read inputx) :: Int 
    let y = (read inputy) :: Int 
    let z = x `div` y 
    let remain = x `mod` y 
    putStrLn ("Result: " ++ show x ++ "/" ++ show y ++ " = " ++ show z ++ " remainder " ++ show remain) 

    putStrLn ("Proof: (" ++ show y ++ " x " ++ show z ++ ") = " ++ show (y * z) ++ " + " ++ show remain ++ " = " ++ show ((y * z) + remain)) 
    putStrLn ("Is this what you had? ") 

È un modo più ordinato/più bello/migliore/più compatto di farlo?

Answer 1

Trarrebbe vantaggio da un principio chiave: separa il tuo codice puro dal tuo IO il più possibile. Ciò consentirà ai tuoi programmi di scalare e mantenere main breif. Un gran numero di let in un grande main non è un approccio molto funzionale e tende a diventare molto più complicato man mano che il codice cresce.

L'utilizzo di un tipo di firma e readLn che è essenzialmente fmap read getLine aiuta a ridurre alcuni cruft. (Se non hai familiarità con fmap, visitare la questione How do functors work in haskell?. fmap è uno strumento molto flessibile in effetti.)

getInts :: IO (Int, Int) 
getInts = do 
    putStrLn "Please enter the dividend :" 
    x <- readLn 
    putStrLn " Please enter the divisor :" 
    y <- readLn 
    return (x,y) 

Ora l'elaborazione. Se dovessi fare di più con questo tipo di dati, o più frequentemente, userei un tipo di record per archiviare il dividendo, il divisore, il quoziente e il resto, quindi tienilo a mente per il futuro, ma qui è un eccesso.

che sto tornando hackishly un elenco piuttosto che una tupla, così posso usare map per show tutti:

sums :: (Int, Int) -> [Int] 
sums (x,y) = [x, y, q, r, y * q, y * q + r] where 
      q = x `div` y 
      r = x `mod` y 

L'ultimo pezzo del puzzle è l'uscita. Ancora una volta preferisco generare questo IO esterno e quindi posso semplicemente scrivere su mapM_ putStrLn in seguito per stampare ogni riga. Preferirei che prendesse il tipo di record, ma sto tollerando un elenco di stringhe come input, dal momento che presumo di avere già show n.

explain :: [String] -> [String] 
explain [x,y,q,r,yq,yq_r] = 
    [ concat ["Result: ", x, "/", y, " = ", q, " remainder ", r] 
    , concat ["Proof: (", y, " x ", q, ") + ", r, " = ", yq, " + ", r, " = ", yq_r] 
    , "Is this what you had? "] 

Ora possiamo scrivere main come

main = do (x,y) <- getInts 
      let ns = map show (sums (x,y)) 
       es = explain ns 
      mapM_ putStrLn es 

o anche più brevemente, convogliando insieme le funzioni explain . map show . sums, e applicando che all'uscita di getInts usando fmap:

main :: IO() 
main = fmap (explain . map show . sums) getInts 
     >>= mapM_ putStrLn 

Si potrebbe notare che ho aggiunto un +r nella prova per rendere = significa sempre =, che è l'uso matematico corretto e il significato di Haskell del mirror per =.