¿Cómo conseguir el valor normal de la acción IO en Haskell

Question

tengo la siguiente función:

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 

y estoy deseando conseguir un Chars fuera de él, no una acción IO. Tengo no idea de cómo hacer esto, o si es posible.

Chars es básicamente un contenedor con un [Int] llamado curData y un Int llamado curIndex. Los detalles no son tan importantes, solo quiero saber si hay una forma para que esta función devuelva un Chars en lugar de un IO Chars.

Si no, ¿cómo paso esto como argumento a una función que toma un Chars? Soy algo nuevo para Haskell IO, pero no creo que quiera que todas mis funciones tomen Chars como argumentos para tener que tomar IO Chars como argumentos, y luego extraerlos y volver a empaquetarlos. Parece innecesario

Gracias!

Answer 1

No se puede, porque eso violaría referential transparency.

IO en Haskell se hace exactamente para distinguir entre acciones cuyos resultados y efectos pueden variar dependiendo de la interacción con el entorno/usuario y funciones puras cuyos resultados no van a cambiar cuando los llames con los mismos parámetros de entrada .

Con el fin de pasar el resultado a una pura función de tomar una Chars de entrada que tiene que llamar a su acción IO en otra acción IO, unir el resultado con el operador <- a una variable y pasarlo a su función pura. Pseudocódigo ejemplo:

myPureFunction :: Chars -> ... 

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

Si eres nuevo en IO en Haskell, puede que desee echar un vistazo a los capítulos de entrada y salida en Learn You a Haskell for a Great Good! y Real World Haskell.

En realidad, hay una forma de obtener un valor puro de una acción IO, pero en su caso no debería hacerlo, ya que está interactuando con el medio ambiente: la forma insegura está bien solo cuando puede garantizar que no está violando la transparencia referencial.

Answer 2

Es imposible (miento, hay una manera extremadamente insegura de engañar para salir de allí).

El punto es que si se realiza alguna E/S, el comportamiento y el resultado de su programa pueden no depender solo de argumentos explícitos para las funciones utilizadas, por lo que debe declararse en el tipo con IO something.

utiliza el resultado de una acción IO a en una pura función uniéndose el resultado en main (o algo que se llama a partir main) y luego aplicar la función pura, vinculante el resultado en un let,

cs ::Chars 
cs = undefined 

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

o, si la función que desea aplicar a chars tiene tipo Chars -> IO b

main = do 
    chars <- get cs 
    doSomething chars