IORef bezieht sich immer noch auf den alten Wert nach dem Update

Question

Hintergrund

Ich bin ein Schemer lernen Haskell zu lernen. Ich versuche, einen Scheme-Interpreter in C zu implementieren, der chapter 4 von SICP folgt. Es stellt sich heraus, dass die Programmierung direkt in C zu hart ist. Also entscheide ich mich für einen Prototyp in Haskell. Mit Hilfe von Write Yourself a Scheme in 48 Hours habe ich alles außer Variablen, Schließungen und Umgebung implementiert.

Problem

Die Modifikation IORef persistieren nicht zwischen Invokationen von main. Ich erwarte, dass das Programm druckt (Falsch) (True) (True) (True) ... aber tatsächlich druckt es (Falsch) (True) (Falsch) (True) (Falsch) (True) .. .

Streifen-down Version des Codes:

import Data.IORef 

data SCM = Environment (IORef Bool) SCM | Empty'Environment 

global :: IO SCM 
global = Environment <$> newIORef False <*> pure Empty'Environment 

print'' :: SCM -> IO() 
print'' ls = 
    case ls of 
    Empty'Environment -> pure() 
    Environment first rest -> readIORef first >>= putStr . show >> print'' rest 

print' :: SCM -> IO() 
print' ls = putStr "(" *> print'' ls *> putStrLn ")" 

main :: IO() 
main = global >>= 
     \ls -> case ls of 
       Empty'Environment -> pure() 
       Environment first _ -> print' ls *> 
             modifyIORef first (const True) *> 
             print' ls *> 
             main 

Syntax-markierte Version:

Vielen Dank für Ihre Hilfe!

Answer 1

Wir können Ihr Beispiel auf main = (global >>= loop) >> main schneiden. Das Problem ist, dass global keine einzige globale Variable ist, sondern eine IO SCM, eine Aktion, die den globalen Wert erstellt. Lassen Sie uns es umbenennen:

createSCM :: IO SCM 
createSCM = Environment <$> newIORef False <*> pure Empty'Environment 

Jetzt ist der Name näher an der Wahrheit. Wir erstellen ein neues SCM jedes Mal, wenn wir diese Funktion aufrufen. So Ihr Programm funktioniert wie folgt:

main = (createSCM >>= loop) >> main 
    = (createSCM >>= loop) >> (createSCM >>= loop) >> main 
    = (createSCM >>= loop) >> (createSCM >>= loop) >> ... 

Wie Sie sehen können wir neue SCM die ganze Zeit erstellen. Daher erhalten Sie nicht das erwartete Verhalten.

Die Lösung ist einfach. Erstellen Sie Ihre global und loop ausdrücklich:

main = do 
    global <- createSCM 
    let loop = do 
     ... 
     loop 
    loop