haskell / critbit Goto Github PK

Documentation states that Empty allowed only as a root of the tree. Both performance and functions (e. g. binarySetOpWithKey) depends on this invariant. But, now it is not checked by tests at all.

Unfortunately, there is no way to write such check function using public API only.

AFAIU there are two ways to solve this problem:

1. Make one of the API functions (e.g. toList) to check this. This check will cost just a one call on the root tree.
2. Provide special check function in the API.

I think first variant is better.

member is marked INLINABLE while notMember is marked INLINE, despite both habing essentially identical structure. Other things that are INLINE while similar functions are INLINABLE: foldlWithKeyWith, foldrWithKeyWith (in these cases I would expect the API wrapper functions to be INLINE and the longer core function INLINABLE, if anything), updateExtremity.

Functions missing any such pragma that I think may want one: null, empty, elems, assocs, keys, unionWith, unionWithKey, unions, unionsWith, intersectionWithKey, map, mapKeys, toAscList, toDescList, filter.

Is there some reason to these decisions that I have overlooked?

In the definition of delete,

go (Leaf lk _) cont
   | k == lk = cont Empty

becomes

go (Leaf lk lv) cont
  | k == lk = case f k lv of
                Just lv' -> cont (Leaf lk lv')
                Nothing  -> cont Empty

since - unlike with Data.Map - we don't rebalance the tree on a deletion. Then delete = updateWithKey (const (const Nothing)).

Hopefully this isn't too hard on GHC. I'll look at this unless someone else is interested.

I am currently implementing unionWithKey.

Current imlementation of split and splitLookup is invalid.

Call split "bb" $ fromList [("aa", 1), ("ac", 2), ("ad", 3)] returns (fromList [("aa",1),("ac",2)],fromList [("ad",3)]) instead of (fromList [("aa",1),("ac",2), ("ad",3)],fromList []).

The same arguments demonstrate bug in splitLookup.

Are you planning a strict implementation of the functions ?

haskell-platform 2012.4.0.0 has text == 0.11.2.3
https://github.com/haskell/haskell-platform/blob/master/haskell-platform.cabal#L91

Changing the requirement to >= 0.11.2.3 appears to build and pass tests just fine here.

The benchmarks don't build with 2012.4.0.0 for at least the following reasons:

• Need to do import Prelude hiding (catch)
• System.Environment.lookupEnv isn't present, so need to implement it in terms of getEnv
• Data.Map.lookupGT isn't present, so I guess that benchmark needs to be ignored
• No instance for (NFData B.ByteString), which is easy to define (since they're strict) but I don't know what commotion it would cause with a newer version of bytestring

import System.Environment (getEnv)
lookupEnv :: String -> IO (Maybe String)
lookupEnv name = (Just <$> getEnv name) `catch` \(_::IOError) -> return Nothing
instance NFData B.ByteString

Hi,

Would it be possible to add critbit on Stackage ?

Or would it be better if it is added by another package maintainer, one that uses it as a dependency ?

Cheers,

As reported by criterion.

critbit:

benchmarking bytestring/alter/critbit
mean: 587.6628 ns
std dev: 25.92060 ns

map:

benchmarking bytestring/alter/map
mean: 481.7831 ns
std dev: 13.77285 ns

Hoping that @archblob can take a look.

Or get the key of specified position

From what I understand, and if I'm not mistaken, the complexity of union is O(n*log m) where n is the size of the second map and m the size of the first one.
Can't we do better ? I've tried to implement the difference function and I have not found a way to do it better.

I applied #8 even though it had a couple of bugs, because I hope that @archblob will have a good time fixing the bug.

See ae06352 for new tests that are simpler than the originals and that correctly expose the bugs.

The instructions say to 'git clone git://github.com/bos/critbit'. Should we not fork and clone our own repository?