Come ottenere il valore normale da azioni IO in Haskell

Question

Ho la seguente funzione:

get :: Chars -> IO Chars 
get cs = do 
    char <- getChar 
    let (dats, idx) = (curData cs, curIndex cs) 
    let (x,y:xs) = splitAt idx dats 
    let replacement = x ++ (ord char) : xs 
    return $ Chars replacement idx 

e sto volendo ottenere un Chars fuori di esso, non un'azione IO. Ho no idea di come farlo, o se è anche possibile.

Chars è fondamentalmente solo un contenitore con un [Int] chiamato curData e un Int chiamato curIndex. Le specifiche non sono così importanti, voglio solo sapere se c'è un modo per questa funzione di restituire un Chars invece di un IO Chars.

In caso negativo, come si passa questo argomento come argomento a una funzione che accetta uno Chars? Sono un po 'nuovo a Haskell IO, ma non credo di volere che tutte le mie funzioni richiedano Chars come argomenti per prendere invece gli argomenti come IO Chars e quindi estrarli e riconfezionarli. Sembra inutile.

Grazie!

Answer 1

Non è possibile, perché ciò violerebbe referential transparency.

IO in Haskell è stato creato in questo modo esattamente per distinguere tra azioni il cui risultato e gli effetti possono variare a seconda dell'interazione con l'ambiente/utente e le funzioni pure i cui risultati non cambieranno quando li si chiama con gli stessi parametri di input .

Al fine di passare il risultato a una pura funzione di prendere una Chars in ingresso è necessario chiamare la vostra azione IO in un'altra azione IO, associare il risultato con l'operatore <- a una variabile e passarlo alla funzione pura. Esempio Pseudocodice:

myPureFunction :: Chars -> ... 

otherAction :: Chars -> IO() 
otherAction cs = do 
    myChars <- get cs 
    let pureResult = myPureFunction myChars 
    ... 

Se siete nuovi a IO in Haskell, si potrebbe desiderare di avere uno sguardo ai capitoli ingresso e di uscita in Learn You a Haskell for a Great Good! e Real World Haskell.

C'è in realtà un modo per ottenere semplicemente un valore puro da un'azione IO, ma nel tuo caso non dovresti farlo, come stai interagendo con l'ambiente: il modo pericoloso è ok solo quando puoi garantisci che non stai violando la trasparenza referenziale.

Answer 2

È impossibile (mentire, c'è un modo estremamente pericoloso per imbrogliarvi fuori).

Il punto è che se viene eseguito un I/O, il comportamento e il risultato del programma potrebbero non dipendere solo da argomenti espliciti per le funzioni utilizzate, quindi è necessario dichiararlo nel tipo facendolo IO something.

si utilizza il risultato di un IO a azione in una pura funzione legando il risultato in main (o qualcosa chiamato da main) e poi applicare la funzione pura, vincolante il risultato in un let,

cs ::Chars 
cs = undefined 

main = do 
    chars <- get cs 
    let result = pureFunction chars 
    print result 

oppure, se la funzione che si desidera applicare a chars è digitare Chars -> IO b

main = do 
    chars <- get cs 
    doSomething chars