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

19 Aug 2009


      Wow, very nice cleanup! That's really a good way for me to learn, thanks.
Well, my intuition told me that strings and ++ wouldn't work, since what we
want is an infinite list of output strings, and using ++ would result in
(((s1++s2)++s3)++s4)++s5... which is highly inefficient and I think it would
keep the complete output text in memory. Using difference lists results in
right associative concatenation of s1++(s2++(s3++(s4++... which is efficient
and can be garbage collected nicely. At least that's what I guess. I really
would like to get a deeper understanding of all this but that will take lots
of time and study, but if I'm lucky I still have 20 to 40 years to go, so I
won't be bored :-)


On Wed, Aug 19, 2009 at 9:46 PM, David Leimbach  wrote:
...
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 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
...
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 
wrote:
...
I've corrected it.  It still doesn't suffer looping.  :-)
On Wed, Aug 19, 2009 at 10:31 AM, David Leimbach 
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 
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
...
...
...
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@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
...
...
...
...
>> user
>> might be parsed ala parsec, using monadic style, applicative
...
...
...
...
>> 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
...
...
...
...
>> 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
...
...
...
...
>> FRP
>> approaches, because now this is still a bit blurry to me.
>>
>> On Wed, Aug 19, 2009 at 5:43 PM, David Leimbach <
leimy2k@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
>>> 
>>> wrote:
>>>>
>>>> LOL. Maybe we should have that coffee together ;-) at least
>>>> virtually!
>>>> On Wed, Aug 19, 2009 at 5:39 PM, David Leimbach <
leimy2k@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
>>>>> 
>>>>> 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
>>>>>> 
>>>>>> 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
...
...
...
...
>>>>>>> is
>>>>>>> then generated must be in sync with the input.
>>>>>>>
>>>>>>> inp = S $ \s i -> let r = (s `D.append` (i `seq` D.empty),
...
...
...
...
>>>>>>> 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
>>>>>>>  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
>>>>>>>> 
>>>>>>>> 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
>>>>>>>>>  wrote:
>>>>>>>>>>
>>>>>>>>>> Apparently this particular example happens to work on Mac
and
>>>>>>>>>> Linux because of different buffering (thanks Martijn for
...
...
...
...
>>>>>>>>>> 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
>>>>>>>>>>  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
...
...
...
...
>>>>>>>>>>> code, but maybe someone could help me out where to put
On Wed, Aug 19, 2009 at 11:28 AM, Peter Verswyvelen
wrote:
the
style,
the
the
that
head
the
the
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@haskell.org
>>>>>>>>>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>
>>>>>
>>>>
>>>
>>
>
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe@haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
>