[Haskell-cafe] Re: Where do I put the seq?

Wed Aug 19 15:46:18 EDT 2009

Very cool!
I am still wondering what the significance of the DList is with this though,
or why it was needed to begin with.

Dave

On Wed, Aug 19, 2009 at 12:28 PM, Ryan Ingram <ryani.spam at gmail.com> wrote:

> Added a new version (tested, works with infinite loops, no early output,
> etc.)
>
> http://hpaste.org/fastcgi/hpaste.fcgi/view?id=8316#a8343
>
> I'll put up a short write-up after lunch.
>
>  -- ryan
>
> On Wed, Aug 19, 2009 at 11:28 AM, Peter Verswyvelen<bugfact at gmail.com>
> wrote:
> > The cleaned up code didn't seem to work for me, it printed everything
> before
> > asking input again.
> > But I added a patch that looks like it supports looping, but I don't
> > understand exactly what is going on :-)
> > I added the "delay" function which makes appending to the output less
> > strict.
> > Note that in this version I add a delay to each right argument of >>=,
> but
> > one could also do it manually
> > On Wed, Aug 19, 2009 at 7:37 PM, David Leimbach <leimy2k at gmail.com>
> wrote:
> >>
> >> I've corrected it.  It still doesn't suffer looping.  :-)
> >>
> >> On Wed, Aug 19, 2009 at 10:31 AM, David Leimbach <leimy2k at gmail.com>
> >> wrote:
> >>>
> >>> Doesn't seem to compile.
> >>> I nearly never use case statements in my code, so I'm not really sure
> >>> what's going on.
> >>> neat2.hs:14:39: parse error on input `='
> >>> Dave
> >>> On Wed, Aug 19, 2009 at 10:23 AM, Ryan Ingram <ryani.spam at gmail.com>
> >>> wrote:
> >>>>
> >>>> I posted a reply to your paste with a stricter version of S and some
> >>>> cleanup.
> >>>>
> >>>> Untested, though I believe it should work without "seq".
> >>>>
> >>>> "case" provides all the strictness you need, I think!
> >>>>
> >>>>  -- ryan
> >>>>
> >>>> On Wed, Aug 19, 2009 at 9:28 AM, Peter Verswyvelen<bugfact at gmail.com>
> >>>> wrote:
> >>>> > Expect more bugs with this though :-) Just found out that looping
> does
> >>>> > not
> >>>> > work, it hangs, e.g.
> >>>> >
> >>>> > test = do
> >>>> >   out "Enter your first name:"
> >>>> >   fstName <- inp
> >>>> >   out "Enter your second name:"
> >>>> >   sndName <- inp
> >>>> >   out ("Welcome "++fstName++" "++sndName)
> >>>> >   out "Goodbye!"
> >>>> >   test
> >>>> >
> >>>> > Doesn't seem to work :-) Back to the drawing board.
> >>>> >
> >>>> > On Wed, Aug 19, 2009 at 5:55 PM, Peter Verswyvelen <
> bugfact at gmail.com>
> >>>> > wrote:
> >>>> >>
> >>>> >> Not at all, use it for whatever you want to :-)
> >>>> >> I'm writing this code because I'm preparing to write a bunch of
> >>>> >> tutorials
> >>>> >> on FRP, and I first wanted to start with simple console based FRP,
> >>>> >> e.g.
> >>>> >> making a little text adventure game, where the input/choices of the
> >>>> >> user
> >>>> >> might be parsed ala parsec, using monadic style, applicative style,
> >>>> >> and
> >>>> >> arrows, and then doing the same with FRP frameworks like Yampa,
> >>>> >> Elera,
> >>>> >> Reactive, etc...
> >>>> >> After that I would start writing tutorials that use OpenGL, making
> >>>> >> some
> >>>> >> very simple games, again with the above approaches, and ending with
> a
> >>>> >> conversion of a very old game of mine (Zarathrusta written in
> >>>> >> assembler from
> >>>> >> 1991, which was based on Thrust from 1986, converted by myself in
> C++
> >>>> >> to
> >>>> >> PocketPC as G-Pod, and so I would like to make a version in Haskell
> >>>> >> that
> >>>> >> runs on the iPhone :-)
> >>>> >> This of course is a lot of work, and I would like to put this on
> the
> >>>> >> Haskell wiki or a blog or something, so others can contribute and
> >>>> >> comment. I
> >>>> >> would like to show real examples that explain the shortcomings of
> the
> >>>> >> FRP
> >>>> >> approaches, because now this is still a bit blurry to me.
> >>>> >>
> >>>> >> On Wed, Aug 19, 2009 at 5:43 PM, David Leimbach <leimy2k at gmail.com
> >
> >>>> >> wrote:
> >>>> >>>
> >>>> >>> This Monad you've created is quite excellent.  I was trying to do
> >>>> >>> something like this about a year ago, to make the input and output
> >>>> >>> handling
> >>>> >>> of an interactive bowling score card work nicely.  I kept running
> >>>> >>> into
> >>>> >>> issues, and did not believe that seq was going to do the trick.
> >>>> >>>  Nice work!
> >>>> >>> This is a very useful monad I think, it could be called "Prompter"
> >>>> >>> or
> >>>> >>> something to that effect.
> >>>> >>> Do you mind if I use it in some of my code?
> >>>> >>> Dave
> >>>> >>>
> >>>> >>> On Wed, Aug 19, 2009 at 8:42 AM, Peter Verswyvelen
> >>>> >>> <bugfact at gmail.com>
> >>>> >>> wrote:
> >>>> >>>>
> >>>> >>>> LOL. Maybe we should have that coffee together ;-) at least
> >>>> >>>> virtually!
> >>>> >>>> On Wed, Aug 19, 2009 at 5:39 PM, David Leimbach <
> leimy2k at gmail.com>
> >>>> >>>> wrote:
> >>>> >>>>>
> >>>> >>>>> Argh... I too have been up too late :-).  I edited THE WRONG
> FILE!
> >>>> >>>>>  No
> >>>> >>>>> wonder your change didn't take effect!  :-/
> >>>> >>>>> Time for coffee I suppose.
> >>>> >>>>>
> >>>> >>>>> On Wed, Aug 19, 2009 at 8:38 AM, David Leimbach
> >>>> >>>>> <leimy2k at gmail.com>
> >>>> >>>>> wrote:
> >>>> >>>>>>
> >>>> >>>>>> This doesn't seem to be working for me interactively though on
> a
> >>>> >>>>>> Mac.
> >>>> >>>>>>  I still get "Welcome" before I've entered text.
> >>>> >>>>>>
> >>>> >>>>>> On Wed, Aug 19, 2009 at 8:25 AM, Peter Verswyvelen
> >>>> >>>>>> <bugfact at gmail.com>
> >>>> >>>>>> wrote:
> >>>> >>>>>>>
> >>>> >>>>>>> I fixed it myself but it's really tricky :-)
> >>>> >>>>>>> http://hpaste.org/fastcgi/hpaste.fcgi/view?id=8316#a8330
> >>>> >>>>>>> The idea is, that when the input is requested, the output that
> >>>> >>>>>>> is
> >>>> >>>>>>> then generated must be in sync with the input.
> >>>> >>>>>>>
> >>>> >>>>>>> inp = S $ \s i -> let r = (s `D.append` (i `seq` D.empty),
> head
> >>>> >>>>>>> i) in
> >>>> >>>>>>> (tail i, r)
> >>>> >>>>>>>
> >>>> >>>>>>>
> >>>> >>>>>>> I first had
> >>>> >>>>>>>
> >>>> >>>>>>> inp = S $ \s i -> let r = (i `seq` s, head i) in (tail i, r)
> >>>> >>>>>>>
> >>>> >>>>>>> But that was too eager, since i syncs the input not with the
> >>>> >>>>>>> output,
> >>>> >>>>>>> but with the function that will generate the output.
> >>>> >>>>>>>
> >>>> >>>>>>>
> >>>> >>>>>>>
> >>>> >>>>>>>
> >>>> >>>>>>>
> >>>> >>>>>>>
> >>>> >>>>>>>
> >>>> >>>>>>> Okay, now I can sleep again :-)
> >>>> >>>>>>>
> >>>> >>>>>>>
> >>>> >>>>>>>
> >>>> >>>>>>>
> >>>> >>>>>>>
> >>>> >>>>>>>
> >>>> >>>>>>>
> >>>> >>>>>>>
> >>>> >>>>>>>
> >>>> >>>>>>>
> >>>> >>>>>>> On Wed, Aug 19, 2009 at 5:12 PM, Peter Verswyvelen
> >>>> >>>>>>> <bugfact at gmail.com> wrote:
> >>>> >>>>>>>>
> >>>> >>>>>>>> Thanks, but that doesn't really matter in my example, my code
> >>>> >>>>>>>> is
> >>>> >>>>>>>> just buggy, and I'm not sure why. For example if I change my
> >>>> >>>>>>>> test function
> >>>> >>>>>>>> so that it outputs lines only, then it still prints Welcome
> >>>> >>>>>>>> first before
> >>>> >>>>>>>> asking for input.
> >>>> >>>>>>>> See
> >>>> >>>>>>>> e.g.
> http://hpaste.org/fastcgi/hpaste.fcgi/view?id=8316#a8328
> >>>> >>>>>>>> On Wed, Aug 19, 2009 at 5:00 PM, David Leimbach
> >>>> >>>>>>>> <leimy2k at gmail.com>
> >>>> >>>>>>>> wrote:
> >>>> >>>>>>>>>
> >>>> >>>>>>>>> Try LineBuffering.
> >>>> >>>>>>>>> I do linewise stuff with interact a lot.  You'll find stuff
> >>>> >>>>>>>>> like
> >>>> >>>>>>>>> unlines . lines
> >>>> >>>>>>>>> may help too.  In fact I just wrote a blog post about this.
> >>>> >>>>>>>>> http://leimy9.blogspot.com
> >>>> >>>>>>>>> I'm trying to write some interactive code to automate
> working
> >>>> >>>>>>>>> with
> >>>> >>>>>>>>> serial console controlled power strips, so I need to either
> >>>> >>>>>>>>> use Expect
> >>>> >>>>>>>>> (yuck) or do my own thing.
> >>>> >>>>>>>>> Dave
> >>>> >>>>>>>>>
> >>>> >>>>>>>>> On Wed, Aug 19, 2009 at 7:35 AM, Peter Verswyvelen
> >>>> >>>>>>>>> <bugfact at gmail.com> wrote:
> >>>> >>>>>>>>>>
> >>>> >>>>>>>>>> Apparently this particular example happens to work on Mac
> and
> >>>> >>>>>>>>>> Linux because of different buffering (thanks Martijn for
> the
> >>>> >>>>>>>>>> help!)
> >>>> >>>>>>>>>> To make sure we have no buffering at all, the main function
> >>>> >>>>>>>>>> should
> >>>> >>>>>>>>>> be:
> >>>> >>>>>>>>>>
> >>>> >>>>>>>>>> main = do
> >>>> >>>>>>>>>>   hSetBuffering stdout NoBuffering
> >>>> >>>>>>>>>>   hSetBuffering stdin NoBuffering
> >>>> >>>>>>>>>>   test
> >>>> >>>>>>>>>>
> >>>> >>>>>>>>>> Now I think it should also be incorrect on Unix systems.
> >>>> >>>>>>>>>> I guess the way I'm concatenating the strings is not
> correct,
> >>>> >>>>>>>>>> not
> >>>> >>>>>>>>>> sure.
> >>>> >>>>>>>>>> I would like to use a graphical tool to show the graph
> >>>> >>>>>>>>>> reduction
> >>>> >>>>>>>>>> step by step, to get a better understanding of the laziness
> &
> >>>> >>>>>>>>>> strictness.
> >>>> >>>>>>>>>> Does such a tool exist? I know people often say this is not
> >>>> >>>>>>>>>> usable because
> >>>> >>>>>>>>>> the amount of information is too much, but I used to be an
> >>>> >>>>>>>>>> assembly language
> >>>> >>>>>>>>>> programmer so I still would like to give it a try :-)
> >>>> >>>>>>>>>>
> >>>> >>>>>>>>>>
> >>>> >>>>>>>>>> On Wed, Aug 19, 2009 at 1:07 PM, Peter Verswyvelen
> >>>> >>>>>>>>>> <bugfact at gmail.com> wrote:
> >>>> >>>>>>>>>>>
> >>>> >>>>>>>>>>> In an attempt to get a deeper understanding of several
> >>>> >>>>>>>>>>> monads
> >>>> >>>>>>>>>>> (State, ST, IO, ...) I skimmed over some of the research
> >>>> >>>>>>>>>>> papers (but didn't
> >>>> >>>>>>>>>>> understand all of it, I lack the required education) and
> >>>> >>>>>>>>>>> decided to write a
> >>>> >>>>>>>>>>> little program myself without using any prefab monad
> >>>> >>>>>>>>>>> instances that should
> >>>> >>>>>>>>>>> mimic the following:
> >>>> >>>>>>>>>>> main = do
> >>>> >>>>>>>>>>>   putStrLn "Enter your name:"
> >>>> >>>>>>>>>>>   x <- getLine
> >>>> >>>>>>>>>>>   putStr "Welcome "
> >>>> >>>>>>>>>>>   putStrLn x
> >>>> >>>>>>>>>>>   putStrLn "Goodbye!"
> >>>> >>>>>>>>>>> But instead of using IO, I wanted to make my own pure
> monad
> >>>> >>>>>>>>>>> that
> >>>> >>>>>>>>>>> gets evaluated with interact, and does the same.
> >>>> >>>>>>>>>>> However, I get the following output:
> >>>> >>>>>>>>>>> Enter your name:
> >>>> >>>>>>>>>>> Welcome ......
> >>>> >>>>>>>>>>> So the Welcome is printed too soon.
> >>>> >>>>>>>>>>> This is obvious since my monad is lazy, so I tried to put
> a
> >>>> >>>>>>>>>>> seq
> >>>> >>>>>>>>>>> at some strategic places to get the same behavior as IO.
> But
> >>>> >>>>>>>>>>> I completely
> >>>> >>>>>>>>>>> failed doing so, either the program doesn't print anything
> >>>> >>>>>>>>>>> and asks input
> >>>> >>>>>>>>>>> first, or it still prints too much output.
> >>>> >>>>>>>>>>> Of course I could just use ST, State, transformers, etc,
> but
> >>>> >>>>>>>>>>> this
> >>>> >>>>>>>>>>> is purely an exercise I'm doing.
> >>>> >>>>>>>>>>> So, I could re-read all papers and look in detail at all
> the
> >>>> >>>>>>>>>>> code, but maybe someone could help me out where to put the
> >>>> >>>>>>>>>>> seq or what to do
> >>>> >>>>>>>>>>> :-)
> >>>> >>>>>>>>>>> The code is
> >>>> >>>>>>>>>>> at http://hpaste.org/fastcgi/hpaste.fcgi/view?id=8316
> >>>> >>>>>>>>>>> Oh btw, the usage of DList here might not be needed;
> >>>> >>>>>>>>>>> intuitively
> >>>> >>>>>>>>>>> it felt like the correct thing to do, but when it comes to
> >>>> >>>>>>>>>>> Haskell, my
> >>>> >>>>>>>>>>> intuition is usually wrong ;-)
> >>>> >>>>>>>>>>> Thanks a lot,
> >>>> >>>>>>>>>>> Peter Verswyvelen
> >>>> >>>>>>>>>>
> >>>> >>>>>>>>>>
> >>>> >>>>>>>>>> _______________________________________________
> >>>> >>>>>>>>>> Haskell-Cafe mailing list
> >>>> >>>>>>>>>> Haskell-Cafe at haskell.org
> >>>> >>>>>>>>>> http://www.haskell.org/mailman/listinfo/haskell-cafe
> >>>> >>>>>>>>>>
> >>>> >>>>>>>>>
> >>>> >>>>>>>>
> >>>> >>>>>>>
> >>>> >>>>>>
> >>>> >>>>>
> >>>> >>>>
> >>>> >>>
> >>>> >>
> >>>> >
> >>>> >
> >>>> > _______________________________________________
> >>>> > Haskell-Cafe mailing list
> >>>> > Haskell-Cafe at haskell.org
> >>>> > http://www.haskell.org/mailman/listinfo/haskell-cafe
> >>>> >
> >>>> >
> >>>
> >>
> >
> >
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://www.haskell.org/pipermail/haskell-cafe/attachments/20090819/ae29fd01/attachment-0001.html