Simon Peyton-Jones wrote:
A String is a [Char] and a Char is a heap object. So
a file represented as a string takes a massive 20 bytes/char
(12 for the cons cell, 8 for the Char cell). Then it's all sucked
through several functions.
It's entirely possible, though, that the biggest
If Posix.runProcess really is supposed "our candidate for the high-level OS-independent
primitive" (see documentation), it would help if there was a documented way of using it
with pipes. The problem is that runProcess takes handles as arguments, while the
obvious
function, createPipe, returns
Reducing the 46M reported on the shootout without changing the
program would be interesting. An easy way for improvement
would be to share characters and small integers like is done in Hugs.
This would mean the initial list of characters would be reduced from
40M to 24M, so the total should
[Apologies for multiple copies of this announcement]
**
*** Last call for papers - extended deadline: March 12, 2001 ***
**
I ran into a difference between GHC and Hugs. The following code:
f (P p) ~(P q) = P (\ k - \inp - let (((pv, (qv, r)), m), st) =
p (q k) inp
in (((pv qv , r ), m), st))
runs fine with Hugs but blows up with GHC, whereas:
f (P p) ~(P q) = P (\ k
Thu, 1 Mar 2001 12:25:33 +0100, S. Doaitse Swierstra [EMAIL PROTECTED] pisze:
From the Haskell manual I understand that pattern matching in "let"'s
should be done lazily, so the addition of a collection of ~'s should
not make a difference.
Toplevel ~ in let doesn't change anything. But
Thanks for the prompt reply. Hugs apparently is more lazy and
performs all the matching lazily, and that really makes a difference
in my case.
Doaitse
At 8:11 AM -0800 3/2/01, Simon Peyton-Jones wrote:
Strange. You don't supply a complete program, so it's hard to
test.
Nevertheless, the
Dear all, I haven't got a reply from hugs-bugs,
so I'll see if anyone here can answer the question.
class foo a b | a |- b where foo :: a - b - Int
instance foo Int Float where foo x y = 0
instance foo [a] [b] where foo [x] [y] = foo x y
g x y = (foo [x] y) + (foo [y] x)
It is my conjecture
Strange. You don't supply a complete program, so it's hard to
test.
Nevertheless, the Haskell Report (Sect 3.12) specifies that
a let adds a single twiddle. Thus
let (x, (y,z)) = e in b
means
let x = case e of (x,(y,z)) - x
y = case e of (x,(y,z)) - y
