Hello, I made a GCL compiler using Alex and Happy and now I'm making the interpreter to that program. Here's the deal: First of all, I'm no expert in the usage of monads. Now: Whenever a "show" instruction is found in any GCL program while the interpretation is being done it is supposed to print on the stdout the string or the aritmetic expresion it was called with, so I guessed I need to run an IO operation and continue the interpretation of my program. I managed to do this using unsafePerformIO and `seq` like is shown below. My question is: Is it safe to use it this way? So far it is working great, but I need to be sure I'm using it in a "safe" way. Like I said, I'm no expert in monads and the System.IO.Unsafe documentation says: " *unsafePerformIO* :: IOhttp://www.haskell.org/ghc/docs/latest/html/libraries/base/System-IO.html#t%...a -> a This is the "back door" into the IOhttp://www.haskell.org/ghc/docs/latest/html/libraries/base/System-IO.html#t%...monad, allowing IOhttp://www.haskell.org/ghc/docs/latest/html/libraries/base/System-IO.html#t%...computation to be performed at any time. For this to be safe, the IOhttp://www.haskell.org/ghc/docs/latest/html/libraries/base/System-IO.html#t%...computation should be free of side effects and independent of its environment. " I don't know if the IO computation I'm doing is free of side effects and independent of its enviroment :s. (is just hPutStr stdout ....) Also I've read something about my code not being executed for sure or something like that. Can somebody check the code and tell me if I'm "safe" with it? Thanks a lot! Here's the code: -- Tabla is my Symbol Table of the program being interpreted evalInstruccion:: Instruccion -> Tabla -> Tabla evalInstruccion (ShowY showY) tabla = myRunIO (evalShow showY tabla) evalInstruccion _ tabla = tabla -- There are many other Instructions here missing wich are not relevant to my question {-# NOINLINE myRunIO #-} myRunIO:: (Tabla, IO()) -> Tabla myRunIO tupla = ((unsafePerformIO (snd tupla)) `seq` (fst tupla)) -- Here's the unsafePerformIO.... Am I safe? evalShow:: ShowY -> Tabla -> (Tabla, IO()) evalShow (ShowS string) tabla = (tabla,(hPutStr stdout string)) evalShow (ShowE expr) tabla = (tabla,(hPutStr stdout (show (evalExpr expr tabla)))) -- Don't worry about evalExpr, it works and returns an Int
(Also taking this to the -cafe) Hector Guilarte wrote:
I made a GCL compiler using Alex and Happy and now I'm making the interpreter to that program. Here's the deal:
First of all, I'm no expert in the usage of monads. Now:
Whenever a "show" instruction is found in any GCL program while the interpretation is being done it is supposed to print on the stdout the string or the aritmetic expresion it was called with, so I guessed I need to run an IO operation and continue the interpretation of my program. I managed to do this using unsafePerformIO and `seq` like is shown below. My question is: Is it safe to use it this way? So far it is working great, but I need to be sure I'm using it in a "safe" way. Like I said, I'm no expert in monads and the System.IO.Unsafe documentation says:
" *unsafePerformIO* ::
IOhttp://www.haskell.org/ghc/docs/latest/html/libraries/base/System-IO.html#t%...a
-> a This is the "back door" into the
IOhttp://www.haskell.org/ghc/docs/latest/html/libraries/base/System-IO.html#t%...monad,
allowing
IOhttp://www.haskell.org/ghc/docs/latest/html/libraries/base/System-IO.html#t%...computation
to be performed at any time. For this to be safe, the
IOhttp://www.haskell.org/ghc/docs/latest/html/libraries/base/System-IO.html#t%...computation
should be free of side effects and independent of its environment. "
I don't know if the IO computation I'm doing is free of side effects and independent of its enviroment :s. (is just hPutStr stdout ....)
Well, writing to the standard output is certainly a side effect. (This does not mean that you cannot use unsafePerformIO. The compiler, however, may assume that any value is free from side effects. This means that you could get, in theory, less or more output from your program than you want. In this sense it is not "safe".)
Also I've read something about my code not being executed for sure or something like that. Can somebody check the code and tell me if I'm "safe" with it?
It's "safe" in the sense that it probably won't blow up your computer. It may also work. On the other hand, I would not recommend using unsafePerformIO in this way. I see two possibilities for resolving this issue: * (ugly) run your GCL (Guarded Command Language?) interpreter in the IO monad, and using "print"/"putStr"/... whenever you encounter a 'show' statement in the GCL program. * (nicer/Haskellier) adapt your interpreter such that it returns a list of Strings to output. You have then a purely functional interpreter, and in the main function of your program you can print this list. This will be lazily evaluated as the GCL program runs. You now have a very nice separation of clean, pure code, and impure code in the IO monad (your "main" function, which can be pretty small in your case). To avoid boilerplate, you can use the Writer monad, for example, but others may have better suggestions. Kind regards, -- Jochem Berndsen | jochem@functor.nl GPG: 0xE6FABFAB
participants (2)
-
Hector Guilarte -
Jochem Berndsen