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

Wed Aug 19 13:31:53 EDT 2009

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/327abc95/attachment-0001.html