e51dbe25d790f2eaa2701fcfaee2866194505e28
[packages/containers.git] / changelog.md
1 # Changelog for [`containers` package](http://github.com/haskell/containers)
2
3 ## 0.5.8.1
4
5   * Remove all attempts to support nhc98 and any versions of GHC
6     before 7.0.
7
8   * Integrate benchmarks with Cabal. (Thanks, Gabriel Gonzalez!)
9   
10   * Make Cabal report required extensions properly, and stop using
11     default extensions. Note that we do *not* report extensions conditionally enabled
12     based on GHC version, as doing so would lead to a maintenance nightmare
13     with no obvious benefits.
14
15   * Use `BangPatterns` throughout to reduce noise. This extension
16     is now *required* to compile `containers`.
17
18   * Add `alterF` for `Data.Map` and `Data.IntMap`.
19
20   * Make `Data.Map.Strict.traverseWithKey` force result values before
21     installing them in the new map.
22
23   * Add `Empty`, `:<|`, and `:|>` pattern synonyms for `Data.Sequence`.
24
25   * Add (!?), `lookup`, `chunksOf`, `cycleTaking`, `insertAt`, `deleteAt`, `intersperse`,
26     `foldMapWithIndex`, and `traverseWithIndex` for `Data.Sequence`.
27
28   * Make `splitAt` in `Data.Sequence` strict in its arguments. Previously,
29     it returned a lazy pair.
30
31   * Derive `Generic` and `Generic1` for `Data.Tree`.
32
33   * Add `foldTree` for `Data.Tree`.
34
35   * Slightly optimize `replicateA` and `traverse` for `Data.Sequence`.
36   
37   * Substantially speed up `splitAt` and (consequently) `zipWith` for
38     `Data.Sequence` by building the result sequences eagerly and rearranging
39     code to avoid allocating unnecessary intermediate structures. The
40     improvements are greatest for small sequences, but large even for long
41     ones. Reimplement `take` and `drop` to avoid building trees only to discard them.
42
43   * Add rewrite rules to fuse `fmap` with `reverse` for `Data.Sequence`.
44
45   * Speed up `adjust` for `Data.Map`.
46
47   * Remove non-essential laziness in `Data.Map.Lazy` implementation.
48
49   * Speed up deletion and alteration functions for `Data.IntMap`.
50
51   * Improve QuickCheck properties taking arbitrary functions by using
52     `Test.QuickCheck.Function.Fun` instead of evil `Show` instances
53     for functions.
54
55 ## 0.5.7.1  *Dec 2015*
56
57   * Planned to bundle with GHC 8.0.1.
58
59   * Add `IsString` instance to `Data.Sequence`.
60
61   * Define `Semigroup` instances for `Data.Map`, `Data.Set`, `Data.IntMap`,
62     `Data.IntSet` and `Data.Sequence`.
63
64 ## 0.5.6.2  *Dec 2014*
65
66   * Bundled with GHC 7.10.1.
67
68   * Add role annotations for `Data.Map` and `Data.Set`.
69
70   * Add `IsList` instances for `Data.Map`, `Data.Set`, `Data.IntMap` and
71     `Data.IntSet`.
72
73   * Several performance improvements for `Data.Sequence`.
74
75   * Add `Data.Sequence.fromFunction` and `Data.Sequence.fromArray`.
76
77 ## 0.5.4.0  *Jan 2014*
78
79   * Bundled with GHC 7.8.1.
80
81   * The `Data.Map.fromList` and `Data.Set.fromList` now use linear-time
82     algorithm if the input is sorted, without need to call `fromDistinctAscList`.
83
84   * Implement indexing operations (`lookupIndex`, `findIndex`, `elemAt`,
85     `deletaAt`) for `Data.Set` too.
86
87   * Add `Applicative` and `Alternative` instances for `Data.Sequence`.
88
89   * Add `foldMapWithKey` to `Data.Map` and `Data.IntMap`.
90
91   * Implement poly-kinded `Typeable`.
92
93   * Add `Functor` instance for `Data.Graph.SCC`.
94
95   * Add `Data.Map.splitRoot` and `Data.Set.splitRoot`.
96
97 ## 0.5.0.0  *May 2012*
98
99   * Bundled with GHC 7.6.1.
100
101   * Major improvements since last release:
102     * a clearer distinction between value-lazy and value-strict containers,
103     * performance improvements across the board,
104     * a big internal clean-up, and
105     * new functions for e.g. merging, updating, and searching containers.
106
107   * While the old `Data.Map` and
108     `Data.IntMap` modules will continue to exist for the foreseeable future, we've
109     abandoned the practice of having the strict and lazy versions of each
110     function distinguished by an apostrophe. The distinction is instead made at
111     the module level, by introducing four new modules:
112     * Data.Map.Strict
113     * Data.Map.Lazy
114     * Data.IntMap.Strict
115     * Data.IntMap.Lazy
116
117     This split has three benefits:
118     * It makes the choice between value-strict and value-lazy containers
119       more declarative; you pick once at import time, instead of having to
120       remember to use the strict or lazy versions of a function every time
121       you modify the container.
122     * It alleviates a common source of performance issues, by forcing the
123       user to think about the strictness properties upfront. For example,
124       using insertWith instead of insertWith' is a common source of
125       containers-related performance bugs.
126     * There are fewer functions per module, making it easier to get an
127       overview of each module.
128
129   * Note that the types used in the strict and lazy APIs are the same, so
130     you can still use the same container in a "mixed" manner, if needed.
131
132   * The `Data.IntSet` representation changed to store small sets using
133     bits in an `Word`. Larger sets are stored as a collection of such
134     dense small sets, connected together by a prefix trie.
135
136 ## 0.4.2.1  *Feb 2012*
137
138   * Bundled with GHC 7.4.1.
139
140   * `Data.Map now exports `foldr`, `foldr'`, `foldl` and `foldl'`.
141
142   * `Data.Set now exports `foldr`, `foldr'`, `foldl` and `foldl'`.
143
144   * `Data.IntMap now exports `foldr`, `foldr'`, `foldl`, `foldl'`, `foldrWithKey`, `foldrWithKey'`, `foldlWithKey` and `foldlWithKey'`.
145
146   * `Data.IntSet now exports `foldr`, `foldr'`, `foldl` and `foldl'`.
147
148   * `Data.Map.foldWithKey` is no longer deprecated, although it is expected to be deprecated again in the future.
149
150   * There are now `NFData` instance for `Data.Map.Map`, `Data.Set.Set`, `Data.IntMap.IntMap`, `Data.IntSet.IntSet` and `Data.Tree.Tree`.
151
152 ## 0.4.1.0  *Aug 2011*
153
154   * Bundled with GHC 7.2.1.
155
156   * `Data.Map` now exports new functions `foldrWithKey'` and `foldlWithKey'`, which are strict variants of `foldrWithKey` and `foldlWithKey` respectively.
157
158   * `Data.IntMap` now exports new functions `insertWith'` and `insertWithKey'`, which are strict variants of `insertWith` and `insertWithKey` respectively.
159
160 ## 0.4.0.0  *Nov 2010*
161
162   * Bundled with GHC 7.0.1.
163
164   * Strictness is now more consistent, with containers being strict in their elements even in singleton cases.
165
166   * There is a new function `insertLookupWithKey'` in `Data.Map`.
167
168   * The `foldWithKey` function in `Data.Map` has been deprecated in favour of `foldrWithKey`.
169
170 ## 0.3.0.0  *Dec 2009*
171
172   * Bundled with GHC 6.12.1.
173
174   * `mapAccumRWithKey` has been added to `Data.IntMap`.
175
176   * A `Traversable` instance has been added to `Data.IntMap.IntMap`.
177
178   * The types of `Data.IntMap.intersectionWith` and `Data.IntMap.intersectionWithKey` have been changed from
179     `intersectionWith :: (a -> b -> a) -> IntMap a -> IntMap b -> IntMap a`
180     `intersectionWithKey :: (Key -> a -> b -> a) -> IntMap a -> IntMap b -> IntMap a`
181     to
182     `intersectionWith :: (a -> b -> c) -> IntMap a -> IntMap b -> IntMap c`
183     `intersectionWithKey :: (Key -> a -> b -> c) -> IntMap a -> IntMap b -> IntMap c`
184
185   * The types of `Data.IntMap.findMin` and `Data.IntMap.findMax` have been changed from
186     `findMin :: IntMap a -> a`
187     `findMax :: IntMap a -> a`
188     to
189     `findMin :: IntMap a -> (Int,a)`
190     `findMax :: IntMap a -> (Int,a)`
191
192   * `Data.Map` now exports `mapAccumRWithKey`, `foldrWithKey`, `foldlWithKey` and `toDescList`.
193
194   * `Data.Sequence` now exports `replicate`, `replicateA`, `replicateM`, `iterateN`, `unfoldr`, `unfoldl`, `scanl`, `scanl1`, `scanr`, `scanr1`, `tails`, `inits`, `takeWhileL`, `takeWhileR`, `dropWhileL`, `dropWhileR`, `spanl`, `spanr`, `breakl`, `breakr`, `partition`, `filter`, `sort`, `sortBy`, `unstableSort`, `unstableSortBy`, `elemIndexL`, `elemIndicesL`, `elemIndexR`, `elemIndicesR`, `findIndexL`, `findIndicesL`, `findIndexR`, `findIndicesR`, `foldlWithIndex`, `foldrWithIndex`, `mapWithIndex`, `zip`, `zipWith`, `zip3`, `zipWith3`, `zip4` and `zipWith4`.
195
196 ## 0.2.0.0  *Nov 2008*
197
198   * Bundled with GHC 6.10.1.
199
200   * Various result type now use `Maybe` rather than allowing any `Monad`.
201
202 ## 0.1.0.0  *Nov 2007*
203
204   * Bundled with GHC 6.8.1.
205
206   * Initial split off from GHC base.