Update changelog for v3.10.2.2 release
[packages/hoopl.git] / changelog.md
1 # Changelog for [`hoopl` package](http://hackage.haskell.org/package/hoopl)
2
3 ## 3.10.2.2 *Feb 2017*
4   This release includes non-API changes.
5
6  - Use cabal builtin options to enable test coverage
7
8  - Move up the constraints of base and containers
9
10  - Refactor the references of the fold family functions to their equivalant foldr functions.
11
12  - Drop the support for 7.0.1
13
14  - Fix a bug that drops out dominators when joined DPATHs have non-shared nodes in the middle.
15
16
17 ## 3.10.2.1 *Dec 2015*
18   This release includes only non-functional changes.
19
20  - Rewrite Applicative/Monad instances into normal-form
21
22  - Relax the upper bound constraint of base to include 4.9
23
24  - Replace `#if CABAL` macro by no CPP at all
25
26  - Wrap redudant wild card pattens in conditional compilation 
27
28  - Prefix unused type variables with underscores. 
29
30 ## 3.10.2.0 *Aug 2015*
31
32  - Add #if CABAL macro to several hoopl source files such that the Cabal generated macro is not included when building in ghci
33
34  - Change the test code (testing/*) to compare the converted graphs against the expected graphs in AST form 
35
36  - Update the cabal file to run tests and generate a test coverage report 
37  
38  - Unhide gSplice of Hoopl.Graph
39
40  - Expose Showing of Hoopl.Show
41
42  - Some fixes of testing
43
44 ## 3.10.1.0 *Apr 2015*
45
46  - Re-export runWithFuel from Compiler.Hoopl.
47
48  - Remove redundant constraints
49
50 ## 3.10.0.2  *Dec 2014*
51
52  - Add support for `base-4.8.0.0` package version
53
54  - Mark a few modules as Safe rather than Trustworthy
55
56 ## 3.10.0.1  *Mar 2014*
57
58   - Remove UTF8 character from hoopl.cabal to workaround issue
59     in GHC 7.8.1's build system
60
61 ## 3.10.0.0  *Mar 2014*
62
63   - Bundled with GHC 7.8.1
64
65   - Define `Functor` and `Applicative` instances for
66      - `SimpleUniqueMonad`
67      - `CheckingFuelMonad`
68      - `InfiniteFuelMonad`
69      - `UniqueMonadT`
70      - `VM` (not exported)
71
72   - Update to Cabal format 1.10
73
74 ## 3.9.0.0
75
76 Lots of API changes; mainly a new API for working with Blocks
77
78 ### Summary of refactorings:
79
80    - `Compiler.Hoopl.Block` contains the `Block` datatype and all the
81      operations on Blocks.  It seemed like a good idea to collect all
82      this stuff together in one place.
83
84    - `Compiler.Hoopl.Graph` now has the operations on Graphs.
85
86    - `Compiler.Hoopl.Util` and `Compiler.Hoopl.GraphUtil` are no more; their
87      contents have been moved to other homes.  (and a bit of duplicated
88      functionality has been removed).
89
90    - I removed the newtypes around `Unique` and `Label`, these are now just
91      type synonyms.  The newtype wrappers were costing some performance in
92      GHC, because in cases like `mapToList` the newtype isn't optimised away.
93
94      This change might be controversial.  Feel free to complain.
95
96 ### Other changes:
97
98    - Optimisations to the Dataflow algorithms.  I'm not actually using
99      this implementation of Dataflow in GHC any more, instead I have a
100      local copy specialised to our monad, for speed.  Nevertheless I've
101      put some of the optimisations I'm using in the GHC version into the
102      generic library version too.
103
104 ### Summary of API changes:
105
106 #### Added
107
108   - `IsMap(mapInsertWith, mapFromListWith)`
109
110   - `mapGraphBlocks`
111     (was previously called `graphMapBlocks`, and not exported)
112
113   - `mapBlock'`
114     (strict version of `mapBlock`)
115
116   - New API for working with Blocks:
117
118     ```haskell
119       -- ** Predicates on Blocks
120     , isEmptyBlock
121  
122       -- ** Constructing blocks
123     , emptyBlock, blockCons, blockSnoc
124     , blockJoinHead, blockJoinTail, blockJoin, blockJoinAny
125     , blockAppend
126  
127       -- ** Deconstructing blocks
128     , firstNode, lastNode, endNodes
129     , blockSplitHead, blockSplitTail, blockSplit, blockSplitAny
130  
131       -- ** Modifying blocks
132     , replaceFirstNode, replaceLastNode
133  
134       -- ** Converting to and from lists
135     , blockToList, blockFromList
136  
137       -- ** Maps and folds
138     , mapBlock, mapBlock', mapBlock3'
139     , foldBlockNodesF, foldBlockNodesF3
140     , foldBlockNodesB, foldBlockNodesB3
141     ```
142
143 #### Removed
144
145   - `mapMaybeO`, `mapMaybeC`
146     (no need: we have `Functor` instances)
147
148   - Block constructors are no longer exported
149     (use the block API instead)
150
151   - `blockToNodeList`, `blockToNodeList'`, `blockToNodeList''`, `blockToNodeList'''`
152     (use the block API instead)
153
154   - `tfFoldBlock`, `ScottBlock`, `scottFoldBlock`, `fbnf3`,
155     `BlockResult(..)`, `lookupBlock`,
156     (I don't know what any of these are for, if they're still important
157     we could reinstate)
158
159 #### Changed
160
161   - Compiler.Hoopl.GHC is now Compiler.Hoopl.Internals and exports some
162     more stuff.
163
164   - Label is not a newtype; type Label = Unique
165   - Unique is not a newtype: type Unique = Int
166     (these newtypes were adding overhead)
167
168   - blockMapNodes3 is now mapBlock3'
169
170   - Lots of internal refactoring and tidying up
171
172 ## 3.8.7.4
173
174   - Re-export runWithFuel as per Justin Bailey
175
176 ## 3.8.7.3
177
178   - Uploaded to Hackage by Ian Lynagh; appears to contain updates
179     that use Safe Haskell if GHC >= 7.2 (thanks David Terei)
180
181 ## 3.8.7.2
182
183   - Version changed with no record of update; never uploaded to Hackage
184
185 ## 3.8.7.1
186
187   - Eliminate warning about nonexhaustive pattern match (thanks Edward Yang)
188
189 ## 3.8.7.0
190
191   - Works with GHC 7 (thanks Edward Yang)
192   - `cabal sdist` now sort of works (and is added to validate)
193
194 ## 3.8.6.0
195
196   - Matches the camera-ready Haskell'10 paper
197
198 ## 3.8.1.0
199
200   - Major reorganization per simonpj visit to Tufts 20 April 2010
201     Collections
202
203 ## 3.7.13.1
204
205   - Added function to fold over nodes in graph.
206
207 ## 3.7.13.0
208
209   - Pointed type replaces WithTop and WithBot, which are now synonyms.
210
211 ## 3.7.12.3
212
213 ### Interface changes
214
215 The type of AGraph is now abstract.
216 It is now recommended to create AGraphs with just three functions:
217
218     <*>          concatenation
219     |*><*|       splicing at a closed point
220     addBlocks    add C/C blocks out of line
221
222 There are new utility functions in modules Util and XUtil, all
223 exported by Compiler.Hoopl.  Here's a selection:
224
225     -- | A utility function so that a transfer function for a first
226     -- node can be given just a fact; we handle the lookup.  This
227     -- function is planned to be made obsolete by changes in the dataflow
228     -- interface.
229     firstXfer :: Edges n => (n C O -> f -> f) -> (n C O -> FactBase f -> f)
230     firstXfer xfer n fb = xfer n $ fromJust $ lookupFact fb $ entryLabel n
231
232     -- | This utility function handles a common case in which a transfer function
233     -- produces a single fact out of a last node, which is then distributed
234     -- over the outgoing edges.
235     distributeXfer :: Edges n => (n O C -> f -> f) -> (n O C -> f -> FactBase f)
236     distributeXfer xfer n f = mkFactBase [ (l, xfer n f) | l <- successors n ]
237
238     -- | This utility function handles a common case in which a transfer function
239     -- for a last node takes the incoming fact unchanged and simply distributes
240     -- that fact over the outgoing edges.
241     distributeFact :: Edges n => n O C -> f -> FactBase f
242
243     -- | Function 'graphMapBlocks' enables a change of representation of blocks,
244     -- nodes, or both.  It lifts a polymorphic block transform into a polymorphic
245     -- graph transform.  When the block representation stabilizes, a similar
246     -- function should be provided for blocks.
247     graphMapBlocks :: forall block n block' n' e x .
248                       (forall e x . block n e x -> block' n' e x)
249                    -> (Graph' block n e x -> Graph' block' n' e x)
250
251     postorder_dfs :: Edges (block n) => Graph' block n O x -> [block n C C]
252
253 There are quite a few other variations related to depth-first traversal.
254
255
256 There is a new module Compiler.Hoopl.Pointed, which uses GADTs to
257 enable you to add a Top or Bot element to a lattice, or both, all
258 using the same type.  (Types `WithBot` and `WithTop` in XUtil,
259 exported by Compiler.Hoopl, do similar jobs, but I think they are
260 inferior.  Your opinion is solicited.)
261
262 I added a function showGraph to print Graphs.  Right now it requires a
263 polymorphic node-showing function as argument. When we change the
264 Block representation we may get enough static type information that we
265 can simply have an instance declaration for
266
267     instance (Show n C O, Show n O O, Show n O C) => Show (Graph n e x)
268
269 At present, I don't see how to achieve such a declaration.
270
271 John added new functions `debugFwdJoins` and `debugBwdJoins` to extend
272 passes with debugging information.
273
274 We added primed versions of the analyzeAndRewrite functions, which
275 operate on Graph, not Body.  Recommended, at least for first-timers.
276
277 Not all maps keyed by Label are FactBases, so there is now a new set
278 of names of functions to manipulate LabelMaps that do not contain
279 dataflow facts.
280
281 ### Implementation changes
282
283 Split pass and rewrite-function combinators into Compiler.Hoopl.Combinators.
284
285 Changed order of blocks for forward and backward analysis.
286 These changes have not been tested, because we don't have a true
287 regression suite yet.
288
289 Graph and Body types now have more polymorphic variants Graph' and Body'.
290
291 Lots of experiments with zippers.
292
293 ### Changes ahead
294
295 ForwardTransfer will become an abstract type, and clients will have
296 two ways to create ForwardTransfers: as now, with a single,
297 polymorphic transfer function; or with a triple of monomorphic
298 transfer functions.  The implementation will use monomorphic
299 functions, which will enable more useful combinators on passes,
300 including adding more debugging information and enabling us to combine
301 passes.
302
303 Perhaps we should provide splicing and `addBlocks` on Graph?
304
305 Change of block representation to have three monomorphic unit
306 constructors and one polymorphic concatenation constructor.
307
308 Graph body to be represented by a finite map; add functions to check
309 for duplicate labels.
310
311 ## 3.7.12.1
312
313   - Added a bunch of zipper experiments.
314   - Existing clients should not be affected.
315
316 ## 3.7.12.0
317
318   - More expressive debugging support
319   - retract arfGraph and normalization; export analyzeAndRewriterFwd'
320
321 ## 3.7.11.1
322
323   - Expose arfGraph and normalization functions
324
325 ## 3.7.11.0
326
327   - Debugging support
328
329 ## 3.7.8.0
330
331   - Rationalized AGraph splicing functions.
332
333 ## 3.7.7.0
334
335   - Restrict clients so they see much less, including hiding
336     the value constructors for Body.