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