[Haskell-cafe] Using unsafePerformIO safely
hectorg87 at gmail.com
Wed Jun 24 21:56:07 EDT 2009
Thanks for answering so fast.
Yes, GCL == Guarded Command Language... It is for an assigment I have in my
Languages and Machines Course.
About the nicer/Haskellier solution you proposed: If there is a way of
printing right in the moment the Interpreter finds the show instruction then
I don't think the teacher is gonna like this soluttion (I would bet on that)
so, can you (or somebody) explain a little bit better how would the ugly
solution be? As I said earlier, I'm no expert in monads, actually the truth
is that I know almost nothing about monads, so please, explain it to me as
if you are explaining it to a Monads newbie...
Also, can somebody explain me how would it be using the Writer Monad?
remember is for a Monads newbie...
Thanks a lot!
On Thu, Jun 25, 2009 at 6:04 PM, Jochem Berndsen <jochem at functor.nl> wrote:
> 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
> > run an IO operation and continue the interpretation of my program. I
> > to do this using unsafePerformIO and `seq` like is shown below. My
> > is: Is it safe to use it this way? So far it is working great, but I need
> > be sure I'm using it in a "safe" way. Like I said, I'm no expert in
> > and the System.IO.Unsafe documentation says:
> > "
> > *unsafePerformIO* ::
> > IO<
> > -> a
> > This is the "back door" into the
> > IO<
> > allowing
> > IO<
> > to be performed at any time. For this to be safe, the
> > IO<
> > 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
> > 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 at functor.nl
> GPG: 0xE6FABFAB
-------------- next part --------------
An HTML attachment was scrubbed...
More information about the Haskell-Cafe