<div class="gmail_quote">On Thu, Jun 25, 2009 at 11:35 PM, Luke Palmer <span dir="ltr">&lt;<a href="mailto:lrpalmer@gmail.com">lrpalmer@gmail.com</a>&gt;</span> wrote:<br><blockquote class="gmail_quote" style="border-left: 1px solid rgb(204, 204, 204); margin: 0pt 0pt 0pt 0.8ex; padding-left: 1ex;">

<div class="im">On Wed, Jun 24, 2009 at 7:56 PM, Hector Guilarte <span dir="ltr">&lt;<a href="mailto:hectorg87@gmail.com" target="_blank">hectorg87@gmail.com</a>&gt;</span> wrote:<br></div><div class="gmail_quote"><div class="im">

<blockquote class="gmail_quote" style="border-left: 1px solid rgb(204, 204, 204); margin: 0pt 0pt 0pt 0.8ex; padding-left: 1ex;">
Thanks for answering so fast.<br><br>Yes, GCL == Guarded Command Language... It is for an assigment I have in my Languages and Machines Course.<br><br>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&#39;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&#39;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...</blockquote>


</div><div><br>The ugly solution is essentially to write it as an imperative program.  &quot;IO monad&quot; is a fancy word for &quot;imperative programming&quot;.<br><br>I&#39;m beginning to think the best way to teach monads is not to (until the student is essentially begging for them without knowing it), and let them be grown into as the pattern is seen.  So, let&#39;s not use them.<br>


<br>Let&#39;s give the language a semantics of the form Tabla -&gt; ([String], Tabla).  That means that every expression has the meaning of a function which takes a symbol table, and outputs a series of lines and a new symbol table.  This will be the range of your evalInstruccion.<br>


<br>I&#39;ll do the ShowY case and a &quot;Sequence&quot; case for sequencing together multiple instructions, which is important.  The rest should be straightforward from there.<br><br><span style="font-family: courier new,monospace;">evalInstruccion :: Instruccion -&gt; Tabla -&gt; ([String], Tabla)</span><br style="font-family: courier new,monospace;">


<span style="font-family: courier new,monospace;">evalInstruccion (ShowY showY) tabla = ([evalShow showY tabla], tabla)</span><br style="font-family: courier new,monospace;"><span style="font-family: courier new,monospace;">evalInstruccion (Sequence instr1 instr2) tabla =</span><br style="font-family: courier new,monospace;">


<span style="font-family: courier new,monospace;">    let (out1, tabla&#39;)  = evalInstruccion instr1 tabla</span><br style="font-family: courier new,monospace;"><span style="font-family: courier new,monospace;">        (out2, tabla&#39;&#39;) = evalInstruccion instr2 tabla&#39;</span><br style="font-family: courier new,monospace;">


<span style="font-family: courier new,monospace;">    in (out1 ++ out2, tabla&#39;&#39;)</span><br style="font-family: courier new,monospace;"><span style="font-family: courier new,monospace;">...</span><br style="font-family: courier new,monospace;">


<br style="font-family: courier new,monospace;"><span style="font-family: courier new,monospace;">evalShow :: ShowY -&gt; Tabla -&gt; String</span><br style="font-family: courier new,monospace;"><span style="font-family: courier new,monospace;">evalShow = ...</span><br style="font-family: courier new,monospace;">


<br>This pattern can be used for more than lists of strings; it can be used for any &quot;monoid&quot;.  If I were to follow the pattern of your code, the monoid would be IO (), and the operation (instead of (++)) would be (&gt;&gt;).  But there would still be no unsafePerformIO, the semantics of the langauge would be Tabla -&gt; (IO (), Tabla), and we would put build one big IO () to return at the end from the output of the subexpressions.<br>


<br>Does this make sense?<br><br>Luke</div></div></blockquote><div><br>Hi Luke,<br>
<br>
Thanks! Actually,  if I understood well what you proposed, that&#39;s how I first tought of doing it, but with a
[Maybe String] and only append whenever I actually had a (Just string),
but as I said before, I don&#39;t think my teacher is gonna like that
solution since it is not going to print when the interpreter finds the
show instruction in the GCL code, it is gonna wait until it finishes to
interpret the whole code and then print everything. That&#39;s would be ok
with me, but actually in a language point of view that wouldn&#39;t be to
usefull, since trying to debug a program printing flags couldn&#39;t be
done (and I&#39;m not doing a debbuger for it). I know my language is not gonna be used for real, but I&#39;m sure that would be my teacher&#39;s argument to tell me I can&#39;t do it that way. Still, I sent him an e-mail asking if it can be done like that just in case.<br>

<br>If I didn&#39;t understand what you said, can you explain it again please?<br><br>If I did then, does anybody knows how to print on the screen in the moment the show instruction is interpreted that guarantees that my code is gonna be &quot;safe&quot;<br>

<br>Also, nobody has told me why I shouldn&#39;t just use my original solution using unsafePerformIO, is it really bad? is it dangerous? why is it &quot;unsafe&quot;?<br><br><br>once again<br><br>thanks a lot in advance,<br>

<br><br>Hector Guilarte<br><br> </div><blockquote class="gmail_quote" style="border-left: 1px solid rgb(204, 204, 204); margin: 0pt 0pt 0pt 0.8ex; padding-left: 1ex;"><div class="gmail_quote"><div><br><br></div><blockquote class="gmail_quote" style="border-left: 1px solid rgb(204, 204, 204); margin: 0pt 0pt 0pt 0.8ex; padding-left: 1ex;">

<div><div></div><div class="h5"><br>

<br>Also, can somebody explain me how would it be using the Writer Monad? remember is for a Monads newbie...<br><br>Thanks a lot!<br><br>Hector Guilarte<br><br><br><div class="gmail_quote">On Thu, Jun 25, 2009 at 6:04 PM, Jochem Berndsen <span dir="ltr">&lt;<a href="mailto:jochem@functor.nl" target="_blank">jochem@functor.nl</a>&gt;</span> wrote:<br>





<blockquote class="gmail_quote" style="border-left: 1px solid rgb(204, 204, 204); margin: 0pt 0pt 0pt 0.8ex; padding-left: 1ex;"><div>Hector Guilarte wrote:<br>
&gt; I made a GCL compiler using Alex and Happy and now I&#39;m making the<br>
&gt; interpreter to that program. Here&#39;s the deal:<br>
&gt; <br></div></blockquote><blockquote class="gmail_quote" style="border-left: 1px solid rgb(204, 204, 204); margin: 0pt 0pt 0pt 0.8ex; padding-left: 1ex;"><div><br>
&gt; First of all, I&#39;m no expert in the usage of monads. Now:<br>
&gt;<br>
&gt; Whenever a &quot;show&quot; instruction is found in any GCL program while the<br>
&gt; interpretation is being done it is supposed to print on the stdout the<br>
&gt; string or the aritmetic expresion it was called with, so I guessed I need to<br>
&gt; run an IO operation and continue the interpretation of my program. I managed<br>
&gt; to do this using unsafePerformIO and `seq` like is shown below. My question<br>
&gt; is: Is it safe to use it this way? So far it is working great, but I need to<br>
&gt; be sure I&#39;m using it in a &quot;safe&quot; way. Like I said, I&#39;m no expert in monads<br>
&gt; and the System.IO.Unsafe documentation says:<br>
&gt;<br>
&gt; &quot;<br>
&gt; *unsafePerformIO* ::<br>
</div>&gt; IO&lt;<a href="http://www.haskell.org/ghc/docs/latest/html/libraries/base/System-IO.html#t%3AIO" target="_blank">http://www.haskell.org/ghc/docs/latest/html/libraries/base/System-IO.html#t%3AIO</a>&gt;a<br>
<div>&gt; -&gt; a<br>
&gt; This is the &quot;back door&quot; into the<br>
</div>&gt; IO&lt;<a href="http://www.haskell.org/ghc/docs/latest/html/libraries/base/System-IO.html#t%3AIO" target="_blank">http://www.haskell.org/ghc/docs/latest/html/libraries/base/System-IO.html#t%3AIO</a>&gt;monad,<br>






&gt; allowing<br>
&gt; IO&lt;<a href="http://www.haskell.org/ghc/docs/latest/html/libraries/base/System-IO.html#t%3AIO" target="_blank">http://www.haskell.org/ghc/docs/latest/html/libraries/base/System-IO.html#t%3AIO</a>&gt;computation<br>






<div>&gt; to be performed at any time. For this to be safe, the<br>
</div>&gt; IO&lt;<a href="http://www.haskell.org/ghc/docs/latest/html/libraries/base/System-IO.html#t%3AIO" target="_blank">http://www.haskell.org/ghc/docs/latest/html/libraries/base/System-IO.html#t%3AIO</a>&gt;computation<br>






<div>&gt; should be free of side effects and independent of its<br>
&gt; environment.<br>
&gt; &quot;<br>
&gt;<br>
&gt; I don&#39;t know if the IO computation I&#39;m doing is free of side effects and<br>
&gt; independent of its enviroment :s. (is just hPutStr stdout ....)<br>
<br>
</div>Well, writing to the standard output is certainly a side effect. (This<br>
does not mean that you cannot use unsafePerformIO. The compiler,<br>
however, may assume that any value is free from side effects. This means<br>
that you could get, in theory, less or more output from your program<br>
than you want. In this sense it is not &quot;safe&quot;.)<br>
<div><br>
&gt; Also I&#39;ve read something about my code not being executed for sure or<br>
&gt; something like that. Can somebody check the code and tell me if I&#39;m &quot;safe&quot;<br>
&gt; with it?<br>
<br>
</div>It&#39;s &quot;safe&quot; in the sense that it probably won&#39;t blow up your computer.<br>
It may also work. On the other hand, I would not recommend using<br>
unsafePerformIO in this way.<br>
<br>
I see two possibilities for resolving this issue:<br>
* (ugly) run your GCL (Guarded Command Language?) interpreter in the IO<br>
monad, and using &quot;print&quot;/&quot;putStr&quot;/... whenever you encounter a &#39;show&#39;<br>
statement in the GCL program.<br>
* (nicer/Haskellier) adapt your interpreter such that it returns a list<br>
of Strings to output. You have then a purely functional interpreter, and<br>
in the main function of your program you can print this list. This will<br>
be lazily evaluated as the GCL program runs. You now have a very nice<br>
separation of clean, pure code, and impure code in the IO monad (your<br>
&quot;main&quot; function, which can be pretty small in your case). To avoid<br>
boilerplate, you can use the Writer monad, for example, but others may<br>
have better suggestions.<br>
<br>
Kind regards,<br>
<font color="#888888"><br>
--<br>
Jochem Berndsen | <a href="mailto:jochem@functor.nl" target="_blank">jochem@functor.nl</a><br>
GPG: 0xE6FABFAB<br>
</font></blockquote></div><br>
<br></div></div>_______________________________________________<br>
Haskell-Cafe mailing list<br>
<a href="mailto:Haskell-Cafe@haskell.org" target="_blank">Haskell-Cafe@haskell.org</a><br>
<a href="http://www.haskell.org/mailman/listinfo/haskell-cafe" target="_blank">http://www.haskell.org/mailman/listinfo/haskell-cafe</a><br>
<br></blockquote></div><br>
</blockquote></div><br>