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