Comments on: Fast mutable collections for Haskell: more benchmarks

By: Mark Wong-VanHaren

Mark Wong-VanHaren — Sun, 21 Nov 2010 05:17:10 +0000

I second solrize’s inquiry about an implementation supporting String (Data.ByteString, Data.Text) keys.

Would it be difficult to do? I’d happily implement it myself, if I had any idea how to, not having coded against the FFI. Might someone more clueful than I be willing to mentor me in creating such a wrapper?

(Until them, I’m afraid I’ve resorted to OCaml for those utilities that require a fast hashmap-like store.)

By: solrize

solrize — Mon, 05 Oct 2009 11:43:30 +0000

Sam, certainly, most hash implementations can be defeated with hostile key selection:

http://www.cs.rice.edu/~scrosby/hash/

However, hashing is great for the wide class of applications that only deal with friendly data.

Don, any chance of supporting Judy’s string keys (JudyS and JudyHS types)? Those handle collision resolution and so forth, helping common use cases that aren’t so easy with JudyL by itself.

By: Sam Martin

Sam Martin — Tue, 29 Sep 2009 08:08:33 +0000

Nice work. Have you tested your implementation with less random data? I’d expect most hash maps to perform ok with well distributed keys, but they can fall apart when given some structure.

By: Bob

Bob — Mon, 28 Sep 2009 22:15:02 +0000

Every last time I hear about the wonders of Haskell, I hear one thing – immutable data is wonderful!

As an associated detail, I often also hear things like “the compiler does wonderful optimisations that make immutable data as fast, if not faster, than mutable data.”

If I mention something like “actually, Haskell has lots and lots of mutable state, it just gets isolated into its own sections” then I get told that I’m wrong, and that actually immutable data is perfect and fast.

If it’s a “common misconception” then its one that Haskell fans seem quite fond of.

By: dons00

dons00 — Mon, 28 Sep 2009 05:23:24 +0000

@solrize POSIWID :-)

By: solrize

solrize — Mon, 28 Sep 2009 05:17:56 +0000

Here is a somewhat critical about about judy: http://nothings.org/computer/judy/

By: Max

Max — Mon, 28 Sep 2009 02:27:29 +0000

Is it possible to implement the equivalent of the Judy array library in Haskell and match the performance of C code?

By: Mark

Mark — Sun, 27 Sep 2009 23:41:38 +0000

@Bob: Chris Okasaki’s got that one pretty well covered with “Purely Functional Data Structures”, but sometimes, you get cases where a mutable data structure is exactly what you need. As Don and Manuel pointed out, using those structures in a safe way is what makes Haskell the world’s finest imperative programming language ™.

By: mchakravarty

mchakravarty — Sun, 27 Sep 2009 23:20:42 +0000

I think it is a somewhat common misconception that the intention of Haskell is to eradicate side effects and mutable structures. That is not the case. Effects are fact of (computing) life — we have to deal with them.

However, it is important to control effects. The special feature of Haskell is support for *statically* controlling effects.

By: dons00

dons00 — Sun, 27 Sep 2009 22:36:54 +0000

Bob. I think you’re mischaracterizing the goals of Haskell, one of which is simply to partition pure and impure code — not to disallow impure code.

We just want to keep mutable and pure (that is, code that is parallel race, deadlock and exception-safe by default) separate.