On Tue, 2008-06-10 at 21:38 -0700, Anatoly Yakovenko wrote:
nevermind, i am a little slow today. ghci -lcblas
You should not need to do this manually. The blas package should say
that it needs this library, in which case ghc and ghci will pick it up
automatically. Using ghci -package foo is
Hello
I'm using haddock to my Literate Haskell code, and it runs very well.
I prefer Literate Haskell instead Haskell because old code remain untouched.
It also is possible run latex over my code.
But running lhs2TeX is even better.
However lhs2TeX doesn't proccess with some haddock information.
On Wed, Jun 11, 2008 at 01:23:58AM +0100, Eric Stansifer wrote:
The syntax highlighting file for literate haskell in vim says that its
maintainer is haskell-cafe@haskell.org, so hopefully one of you will
find this relevant.
In literate haskell files, vim optionally highlights the non-code
Hey Brad,
I wrote a blog-post with some curl-examples in there, it's a small
mashup of last.fm and upcoming, check it at
http://tinyurl.com/5d8jx7
Enjoy,
-chris
On 11 jun 2008, at 07:51, brad clawsie wrote:
-BEGIN PGP SIGNED MESSAGE-
Hash: SHA1
in search of some trivial examples
OK, so this is a fairly basic question about list processing.
Several times now, I have found myself wanting to process a list to
produce a new list. However, the way later elements are processed
depends on what the earlier elements are - in other words, this isn't a
simple map.
What is the
andrewcoppin:
OK, so this is a fairly basic question about list processing.
Several times now, I have found myself wanting to process a list to
produce a new list. However, the way later elements are processed
depends on what the earlier elements are - in other words, this isn't a
simple
Am Mittwoch, 11. Juni 2008 20:17 schrieb Andrew Coppin:
So it looks like this can be implemented as a fold or an unfold. But
neither way looks especially easy. Both of these patterns seem to be
more general than necessary; I only want to take 1 element of input and
produce 1 element of
Hey Andrew,
On 11 jun 2008, at 20:17, Andrew Coppin wrote:
According to the theory, anything that consumes a list and produces
a value is some kind of fold. [Assuming it traverses the list in a
sensible order!] So it looks like you could implement this as a
fold. But should that be a
Why is there no mapAccumL' (strict)? Just a library deficiency that we
can remedy or am I missing something?
Don Stewart wrote:
andrewcoppin:
OK, so this is a fairly basic question about list processing.
Several times now, I have found myself wanting to process a list to
produce a new
---
Haskell Weekly News
http://sequence.complete.org/hwn/20080611
Issue 72 - June 11, 2008
---
Welcome to issue 72 of HWN, a newsletter covering
There were a few hiccups in the release of 0.4, so this version is to
make installation go a little smoother for people. There are now
installation instructions (the INSTALL file) and configuration
settings for some common CBLAS (ATLAS, MKL, vecLib, GSL). The default
is now to assume
Lets look at the actual reductions going on. To make the example easier,
I would like to use last instead of your complicated until. It shouldn't
make a difference.
[ winds up doing twice as much work ]
This was also my intuition. I had a function that built up a large
output list by
ieee is a library that provides approximate comparison of floating
point numbers based, NaN-aware minimum and maximum, and a type class
for approximate comparisons.
This version fixes a bug in the comparison implementation for Maybe.
Stephan Friedrichs wrote:
Hello,
I've implemented Chris Okasaki's random-access list[1] which provides
typical list operations (cons, head, tail) in O(1) and yet offers
indexed random-access in O(log n). It's uploaded on hackage[2].
It's still an early version which I'll extend, but
On Wed, 2008-06-11 at 17:18 -0700, Evan Laforge wrote:
Lets look at the actual reductions going on. To make the example easier,
I would like to use last instead of your complicated until. It shouldn't
make a difference.
[ winds up doing twice as much work ]
This was also my intuition.
Definition of f:
f = foldr (+) 0
Types:
0 :: (Num t) = t
foldr (+) 0 :: Num a = [a] - a
f :: [Integer] - Integer
Please remind me, again, of the advantages of f being something different from
the formula defining it.
- Rex Page
___
page:
Definition of f:
f = foldr (+) 0
Types:
0 :: (Num t) = t
foldr (+) 0 :: Num a = [a] - a
f :: [Integer] - Integer
Please remind me, again, of the advantages of f being something different
from the formula defining it.
Overloaded 'constants' take a dictionary as an
17 matches
Mail list logo
