[Haskell-cafe] do you have to use fix with forkio?
dmehrtash at gmail.com
Fri Mar 6 03:48:19 EST 2009
a) This chat server implementation doesn't actually close the connection
as a real one would need to do. If you use "forever" is there a way to end
the loop so as to end the connection?
b) In Section 5 of this paper:
Comparing the definition of eSF and e reveals that the primary difference is
> the fixed-point operators they use. e uses Haskell’s built-in fixed-point
> which is equivalent to the standard:
> fix f = f (fix f)
> eSF, on the other hand, is defined in terms of the loop combinator, which
> ties the loop
> tighter than the standard fixed-point operator. In particular, note in
> Figure 6 that
> loop computes the value-level fixed point as z, but re-uses itself in the
> part. This is the key to avoiding the space leak.
My reading is that the fix operator, at least in some cases, causes space
leak. Where as the arrow's loop, which uses "let" model, doesn't have
Question: Do I need to worry about space leak if I am using the fix to
instead of the "let"?
2009/3/5 Luke Palmer <lrpalmer at gmail.com>
> On Thu, Mar 5, 2009 at 6:27 PM, Donn Cave <donn at avvanta.com> wrote:
>> Quoth Jonathan Cast <jonathanccast at fastmail.fm>:
>> > You can certainly use let:
>> > reader <- forkIO $ let loop = do
>> > (nr', line) <- readChan chan'
>> > when (nr /= nr') $ hPutStrLn hdl line
>> > loop
>> > in loop
>> > But the version with fix is clearer (at least to people who have fix in
>> > their vocabulary) and arguably better style.
>> Would you mind presenting the better style argument? To me, the
>> above could not be clearer, so it seems like the version with fix
>> could be only as clear, at best.
> I like using fix when it's simple rather than let, because it tells me the
> purpose of the binding. eg., when I see
> let foo = ...
> Where ... is fairly long, I'm not sure what the purpose of foo is, or what
> its role is in the final computation. It may not be used at all, or passed
> to some modifier function, or I don't know what. Whereas with:
> fix $ \foo -> ...
> I know that whatever ... is, it is what is returne, and the purpose of foo
> is to use that return value in the expression itself.
> I know that it's a simple matter of scanning to the corresponding "in", but
> let can be used for a lot of things, where as fix $ \foo is basically only
> for simple knot-tying. Now, that doesn't say anything about the use of fix
> without an argument (passed to an HOF) or with a tuple as an argument or
> many other cases, which my brain has not chunked nearly as effectively. I
> think fix is best with a single, named argument.
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
-------------- next part --------------
An HTML attachment was scrubbed...
More information about the Haskell-Cafe