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