Bump version and relax deepseq dependency
Disable ropt_plain_output.

The ropt_plain_output was used to disables ansi sequences in the test
log. But it works only for test-framework < 0.5.

In test-framework >= 0.5, ropt_plain_output no longer exists. The line
"ropt_color_mode = Just ColorNever" can be used, but test-framework >= 0.5
detects it is not writing to the terminal and disables ansi sequences by
itself.

It is difficult to compile ropt_plain_output conditionally for
test-framework < 0.5 only (MIN_VERSION_* macros are not defined for
dependencies of tests, conditions in cabal tests do not work for
ghc-7.0). We therefore do not set ropt_plain_output and live with ansi
sequences in test logs produces by test-framework < 0.5.
Int{Set.Map}.delete{Min,Max} doesn't fail on empty.

Make Int{Map,Set}.delete{Min,Max} behave like {Map,Set}.delete{Min,Max}.
* Old behaviour: Int{Set,Map}.delete{Min,Max} empty ==> error
* New behaviour: Int{Set,Map}.delete{Min,Max} empty ==  empty
Unify IntMap.deleteFind{Min,Max} with the Map ...

... counterparts.

The type signature has changed from
  IntMap.deleteFind{Min,Max} :: IntMap a -> (a, IntMap a)
to
  IntMap.deleteFind{Min,Max} :: IntMap a -> ((Key, a), IntMap a)
.
Generalize IntMap.update{Min,Max}[WithKey].

Previously these methods were given an argument of type
  [Key ->] a -> a
Now they are given an argument of type
  [Key ->] a -> Maybe a
That makes them compatible with Map counterparts.
Remove unnecessary methods from Data.Map.Strict.

Remove implementations of mapKeys and mapKeysMonotonic
from Data.Map.Strict module. These methods modify keys only
and even Data.Map.Lazy are strict in keys.
Improve performance of Map.mapKeys[With].

We can manually fuse
  List.map fFirst . toList
    where fFirst (a, b) = (f a, b)
using the right fold as
  foldrWithKey (\k x xs -> (f k, x) : xs) []
Add IntMap.mapKeys* methods.

Add IntMap.mapKeys, mapKeysWith, mapKeysMonotonic.
These functions are present in the Map module and we want IntMap
to be a replacement of Map Int.

The IntMap.mapKeysMonotonic is not as efficient as Map.mapKeysMonotonic
because of the IntMap representation -- the trie structure changes
wildly when the keys changes, even if the ordering of keys is not
altered.

Also, some time complexities were corrected.
Improve tests.

* Test IntMap.mapKeys, mapKeysWith, mapKeysMonotonic, which were just
  added.

* Unify map-properties and intmap-properties as possible, by renaming
  methods and changing comments, so that they are the same in both.
Improve formatting of oneliners.
Add toDescList.

Add toDescList to IntMap, Set and IntSet. Also add
corresponding fusion RULES and tests.

The function is added as community was opposed to removing
toDescList from Map.
Improve {Map,IntMap}.intersection* and its tests.

* Add tests for intersectionWith*.
* Add specific Map.intersection implementation instead of using
  Map.intersectionWithKey.
* Refactor Map.intersectionWithKey implementatioin.
Improve IntMap.fold*.

Improve IntMap.fold* not to do two checks for negative numbers
-- both prefix and mask were tested. Mask tests are enough.
Improve Int{Map,Set}.fold*.

Improve Int{Map,Set}.fold* defitions to be inlinable with
two arguments only.

Otherwise GHC inlined toAscList, toDescList _and after that_ inlined
the fold, resulting in useless code growth.
Improve Int{Set,Map}.fold*.

In the fold definitions, do not call go if the Bin constructor was
matched during the test for negative numbers. Instead, manually inline
that branch of go.

Otherwise GHC optimizer does this for us -- it creates local definition
of that branch of go and calls it. On my machine, it causes >200B growth
of object file, for every fold.
Improve list fusion.

* Allow fusable methods to be converted back to the original call when
  no fusion happens. For that, foldlFB and foldrFB are used, inspired by
  mapFB from Prelude.

* Remove RULES for aliases like toList, assocs, elems, just INLINE them.
Fix Data.Sequence warnings.

As GHC HEAD found out, methods deep, node2, node3 were both
INLINE and SPECIALIZE. Make them INLINE only.

Also the -Wwarn option can be removed.
Improve {Map,IntMap}.fold* tests.
Update .gitignore.
Mark Data.Map.(!) as INLINABLE instead of INLINE.

This should have been done in commit 3f798e33. As mentioned in the
commit log, the chain
  m ! k = find k m
  {-# INLINE (!) #-}
  find k m = ...
  {-# INLINABLE find #-}
results in find not being specialized at the call site of (!).