On Fri, Oct 12, 2007 at 01:27:11AM +0200, Udo Stenzel wrote:
> - Rename 'base' ASAP and especially before GHC 6.8 comes out, call it
> 'foundation' or something else. If you want to keep the name 'base',
> make sure Cabal considers 'base-2.x' a different library than
> 'base-3.x'.
> - Provid
On Oct 11, 2007, at 4:33 PM, apfelmus wrote:
...
So, the idea is to use a "local gödel numbering" and uniquely
number the and only the trees that are actually constructed (no
collisions, but few in numbers). In other words, every new tree
created gets the gödel number size collection + 1
Don Stewart wrote:
> Since you're not using ghc 6.8, you should use binary 0.3 :)
That was PC for "sorry, GHC 6.6 is no longer supported and don't even
ask about 6.4"
The other day I tried to install the tar library on a GHC 6.4. It's
nearly impossible. The old base library gets in the way of i
Simon Peyton-Jones wrote:
For various applications (including identifying common sub-expressions,
> and version tracking in GHC), I'd like a Haskell library that supports
> simple fingerprint operations.
Note that for CSE and hash-consing, there is a no-collision yet very
efficient way of fin
> One example of such an minusFP (not recommended) is (foldr xor 0):
Obviously I meant that FP = foldr xor 0. minusFP would be a simple
unfolding of this.
Dan Weston wrote:
I am zero training in cryptography, but I would think that if in
addition to
FP(as ++ bs) = FP(bs) `plusFPFlipped` F
I am zero training in cryptography, but I would think that if in
addition to
FP(as ++ bs) = FP(bs) `plusFPFlipped` FP(as)
(I think the flipped plusFP def is more intuitive)
there also existed a minusFP for all f and x such that
FP(bs) = FP(as ++ bs) `minusFP` FP(as)
then that might facil
On Thu, 2007-10-11 at 12:28 +0100, Simon Peyton-Jones wrote:
> Interesting! The associativity property is the kind of thing I was after.
> Except that I don't really care if FP(as ++ bs) = FP(as) `plusFP` FP(bs). I
> only care that the latter is robust in the sense of having low probabilty of
Hi,
I am writing translations of Haskell to specification languages. I was
wondering whether
there already exist a representation of Haskell syntax that, in
contrast with standard
abstract syntax, is "light" on structure (few data-types, few
constructors) and has no
dictionary parameters.
Interesting! The associativity property is the kind of thing I was after.
Except that I don't really care if FP(as ++ bs) = FP(as) `plusFP` FP(bs). I
only care that the latter is robust in the sense of having low probabilty of
collision. So the Rabin scheme does more than I really need (which
If compositionality is important, at least Rabin's fingerprints are
worth considering: http://citeseer.ist.psu.edu/broder93some.html
They have the neat property that the fingerprint of a concatenation of
strings can be cheaply computed from the fingerprints of the
constituents. I think this effect
Hi Simon,
> We are all familiar with the idea of an MD5 checksum, which provides a
> reliable "fingerprint" for a file, usually 128 bits or so. If the file
> changes, the fingerprint is (almost) certain to do so too. There are lots of
> techniques: CRC, shar?, MD5, etc.
I believe the basic o
Dear Haskellers
Here's a challenge.
We are all familiar with the idea of an MD5 checksum, which provides a reliable
"fingerprint" for a file, usually 128 bits or so. If the file changes, the
fingerprint is (almost) certain to do so too. There are lots of techniques:
CRC, shar?, MD5, etc.
Fo
12 matches
Mail list logo
