Anyway, all jokes aside, I am surprised to find Bloom Filter usage very sparse within the general software industry (I am a consultant-of-one running my own company but have large clients in the Fortune 100, start-ups, etc).

The case you presented here for being able to efficiently serialize the filter has notable use in web-application farm environments where sessions and other state table information must be migrated between servers (depending on session management strategy employed). Indeed one challenge I am considering is somehow managing some Bloom Filter construct across a RAIN architecture without sacrificing the small memory footprint and performance advantages that Blooms provide.

Thanks again.

reverse (a:as) = reverse as ++ [a]
reverse [] = reverse []

not be

reverse (a:as) = reverse as ++ [a]
reverse [] = []

?

I concede that on paper both appear to be n log n in the average case.

I sat down with mfp of eigenclass last night and we tried to figure out what was causing the curve in question.

[Edit: The perceived larger than constant-factor difference in the curves seems to have been caused by the trivial implementation starting to cause memory pressure before the other. Unfortunately my last couple of data points didn’t cause this to happen to both implementations. After a set of sufficiently long term runs it is clear they both clearly have n log n behavior. The curse of seeing what you expect to see.]

Analysis: Let T(n) be the time it takes to sort a list with n elements. In the average case, ls and rs have half as many elements as xs, i.e. n/2. Sorting both needs 2*T(n/2) time. Partitioning and concatenation need O(n) time, hence we have

T(n) = 2*T(n/2) + O(n)

which means T(n) = O(n * log n).

On another note, Edward: you could have catered to your odd blog environment with:

(rs,ls) = partition (>a) as

but, it might’ve confused someone.

Still waiting for the tarball of your Comonad/Bifunctor blogs… ;)

C(n) = C(n-1) + n - 1 + 1

which is clearly O(n^2). The “reverse” example thus fails to show anything regarding the cons analysis of qsort. Do you have a real counterexample showing that the analysis under a strict semantics doesn’t work as an upper bound for the non-strict case?