> streams :: (Int -> Bool, Int -> Bool) -> (Int,Int) ->
>            [(Maybe Int,Maybe Int)]
> streams (p,q) (x,y)
>
>     | p x && p y = (Just x , Just y ) : xs
>     | p x        = (Just x , Nothing) : xs
>     | p y        = (Nothing, Just y ) : xs
>     | otherwise  = xs
>
>     where xs = streams (p,q) ((x+y),(y-x))

Yeap, in fact I thought about it when answering Toms answer.
Doesn't seem good enough in more general cases though,

Like: 

streams :: (Int->Bool, Int->Bool)->(Int, Int)->([Int],[Int])
streams (p,q) (x,y) = (xs',ys')
    where
    (xs,ys) = streams (p,q) ((x+y),(y-x))
    xs' = if p x then x:xs else zs++xs  <-------
    ys' = if q y then y:xs else ys
    zs = some_other_stream <----------


Or:

streams :: (Int->Bool, Int->Bool)->(Int, Int)->([Int],[Int])
streams (p,q) (x,y) = (xs',ys')
    where
    (xs,ys) = streams (p,q) ((x+y),(y-x))
    xs' = if p x then x:xs else zs  -- <------------
    ys' = if q y then y:xs else ws -- <-----------
   zs = ... some other_stream -- <---
   ws= ... yet_another_stream -- <---


> With this setup, I think you can write your own writefile function which
> looks something like:
> I think, but I'm not sure, that this will allow the old stuff to be
> garbage collected.  In practice, you don't get too much useless junk
> generated because we don't append the (Nothing,Nothing) pair to the list
Nice observation, I missed that one since I didn't paired both lists :)
But like I just showed, sometimes paring them may not be a natural approach 
though...

> (erm, "prepend").  But what's more important, I think you only evaluate
> the same amount of each at any given time, thus allowing GC to gobble up
> the old stuff.
Exactly

> An expert might be able to prove me wrong, though, or you could try this
> and profile it and see if it works or not :)
I haven't tested it yet either but seems to me like it should work, in this 
particular example.

I was hoping I could somehow take advantage of the fact that the order in 
which I want to consume the lists doesn't matter. I thought about concurrency 
but it doesn't seem to work.

J.A.


_______________________________________________
Haskell-Cafe mailing list
[EMAIL PROTECTED]
http://www.haskell.org/mailman/listinfo/haskell-cafe

Reply via email to