Wie kann ich IO-Befehle wiederholt in Haskell ausführen?

Question

Ich habe eine Funktion blabla in Haskell, die ein Int nimmt und gibt einen String zurück:

blabla :: Int -> [Char] 

Ich möchte ein, dass die Methode wiederholt laufen for-Schleife, so etwas wie dieses:

for i := 1 to 25 do begin 
    write(i); 
    write(": "); 
    writeln(blabla(i)); 
end; 

Does Haskell haben eine For-Loop-Funktion?

Answer 1

Es gibt eine forM_ Funktion im Control.Monad-Modul, das für die Schleife in imperativen Programmiersprachen auf ein ähnlich ist:

import Control.Monad (forM_) 

blabla :: Int -> String 
blabla = show 

main = forM_ [1..25] $ \i -> do 
    putStr (show i) 
    putStr ": " 
    putStrLn (blabla i) 

Allerdings würde ich Sie raten, aus solchen Imperativ Artcode zu. Zum Beispiel kann der gleiche Code prägnanter geschrieben werden als:

import Control.Monad (mapM_) 

blabla :: Int -> String 
blabla = show 

main = mapM_ (\i -> putStrLn $ show i ++ ": " ++ blabla i) [1..25] 

Hoffnung, die hilft.

Answer 2

Sie denken immer noch prozesstechnisch. Versuchen Sie, eher in Listen als in Schleifen zu denken.

Dann, was Sie wollen, ist eine Liste wie folgt aus: [1,f(1),2,f(2),3,f(3)...,n,f(n)]

Hier map das Bild eintritt. Wenn Sie eine Funktion f hatten und diese auf eine Liste [1,2,3...,n] anwenden wollten, verwenden Sie map f [1..n].

Was Sie wollen, ist eine Funktion, die eine Zahl nimmt i und wendet eine Funktion f darauf, antwortet dann mit [i,f(i)] oder vielleicht ein Tupel (i,f(i)). Sie erstellen diese Funktion und ordnen sie Ihrer Liste zu.

Und natürlich müssen Sie diese erste Liste erstellen, um auf - diese Liste von [1..n] zu arbeiten.

Ein weiterer Ansatz ist es, eine Liste Verständnis zu verwenden:

forloop n = [(x,f x)|x <- [1..n] ] 

(Anmerkung: Ich habe keinen Haskell Compiler mit mir jetzt, also muss ich später den letzten Teil überprüfen ich glaube, es sollte wie vorgestellt arbeiten.).

Answer 3

Ich glaube, ich habe es selbst:

blablaOutput :: [Int] -> IO() 
blablaOutput (x:xs) = do 
    putStrLn (blabla x) 
    blablaOutput xs 
blablaOutput _ = putStrLn "That's all, folks!" 

main = blablaOutput [0..25] 

Sicher nicht sehr funktional in den Mitteln der funktionalen Programmierung, aber es funktioniert.

Answer 4

Auf eine Tasse Tee zu trinken, ich das beste Ergebnis bekam, denke ich:

blablaResults = map (\x -> show x ++ ":" ++ blabla x) [0..25] 

main = putStrLn $ unlines blablaResults