pristine:77d030ea6728b2a8f535ad6667fb6f4089b54e1e1ce2531fb5f76ddfc4a980f1
Starting with inventory:
0000004824-7d7c47a87c4f959264ef7c999d0ea5e8635b4bb7fc809b57ce5b68353cd640a5
[TAG 0.8.0 (more or less the final?)
martin.hofmann@uni-bamberg.de**20101012131847] 
hash: 0000002515-447c80a6986b7c2a898a2695f10f4464c5292d53c0682caf5b43ced3e3251422
[make igor2 compile on ghc 7.4.2 and current hackages
Helmut Grohne <grohne@cs.uni-bonn.de>**20131217133624
 Ignore-this: ec4be18819806ae8821ae058e4cccda1
] 
hash: 0000003896-1fdd8740db4c8a699c03585dbcf5a562e934d45647208d2f3fa6424715a1529a
[avoid double definition of Nat in expl/Examples.hs
Helmut Grohne <grohne@cs.uni-bonn.de>**20131217143140
 Ignore-this: 4a73c4a17586a3a1d9e201280eef17a9
 Otherwise invoking igor2 results in:
     Ambiguous occurrence `Nat'
     It could refer to either `Examples.Nat',
                              defined at expl/Examples.hs:13:6
                           or `Generics.Pointless.Functors.Nat',
                              imported from `Generics.Pointless.Functors' at expl/Examples.hs:5:1-34
] 
hash: 0000000610-1c0b5e14fdef067c4d59b62a8c410a0da1130fcd7570535d8df1921c2bf97c93
[update igor2.cabal for more recent versions of cabal
Helmut Grohne <grohne@cs.uni-bonn.de>**20131217143148
 Ignore-this: 6b26bf6b7e4d007d64a5958f95bdba95
] 
hash: 0000001682-ec979c195513aeac819ba03921fb1e0117b64e5355e6b6be084e7ee59d4fbfcd
[work around unhandled runtime error passing by catchError
Helmut Grohne <grohne@cs.uni-bonn.de>**20140108073945
 Ignore-this: 60b21165b086517cb697ed19c7fe368e
] 
hash: 0000001161-70c7f17675a364382a76d4ac3edf7ba0eee6e838e0a36f35e3b90cd2c40dabea
[use throwError where possible
Helmut Grohne <grohne@cs.uni-bonn.de>**20140108091026
 Ignore-this: e06ab5b6869087360b7a19fc56a8c2c4
 Since the use of fail changed in past GHC releases, part of the code base now
 uses throwError instead. The biggest part is the introduction of an Error e
 requirement to many of the functions to be able to use throwError. As a side
 effect of this change, interactive igor2 no longer dies on a syntax error.
] 
hash: 0000014900-c1e298d89ac00cdc3772b59b9082e19b686d5a6941e2396fe0c172cb496c4901
[fix another uncaught fail
Helmut Grohne <grohne@cs.uni-bonn.de>**20140108092959
 Ignore-this: a215ef97092a3d141de75db316f2802f
] 
hash: 0000000838-01f8d44ee7cd6b155a3571e319b891c508f2401fcd2be9cd1626896df44d3a7c
[reenable parsing extensions
Helmut Grohne <grohne@cs.uni-bonn.de>**20140110114952
 Ignore-this: 1dc770984bcc8eaffab0849fa9095a1f
] 
hash: 0000000565-105b8fc2e387b3b2cafc4a4ca670355faed3aa9ec673765da37ca72c903484ee
[fix another uncaught fail
Helmut Grohne <grohne@cs.uni-bonn.de>**20140204143307
 Ignore-this: e32d3f52bc6041088f5f6f88942850e2
] 
hash: 0000000527-523730bf5d4cb608131585fa1a156879670575148e62bf8754a7807176793d72
[deduplicate Data.MySet
Helmut Grohne <grohne@cs.uni-bonn.de>**20140211094700
 Ignore-this: d4f6e2e18181031e7129cef42f1a173e
] 
hash: 0000000739-51c882bb9ccd2c3fb6385c694c0f6a37c394b3aab9c1b1de67fdc1745b123abd
[deduplicate insertAt
Helmut Grohne <grohne@cs.uni-bonn.de>**20140211122006
 Ignore-this: 685bd6abdd8dc1a45a1a71f3720901e3
] 
hash: 0000000385-8e05dc64b477579b73624c31a0d0d3318a9983cb5c7b772f94265bc8367d5eec
[improve documentation and Pretty instance of RatingData
Helmut Grohne <grohne@cs.uni-bonn.de>**20140213132544
 Ignore-this: b89fc2914cc790b48be3084e738d8c23
] 
hash: 0000000916-bb05a1b13765b17990491f626d3230ca1065c16f0cd130ea91282917d97580a8
[also strip qualifications in Pretty Equation instance
Helmut Grohne <grohne@cs.uni-bonn.de>**20140213133500
 Ignore-this: 410bc6a92c74773b2058e54c814eac00
 This makes printing Hypos much nicer in higher verbosity levels.
] 
hash: 0000000354-00e14dde67b6a3be591ed984ee92e512f89466e76d2f02dbb86f24709c2d0146
[improve instance Pretty HSpace
Helmut Grohne <grohne@cs.uni-bonn.de>**20140214152254
 Ignore-this: e6875e88bc3e2b043c0cd9845c4938a7
 
 A HSpace contains each RatingData twice. Once as the priority of the BagHeap
 and once inside the value in Hypo. Thus it is enough to pretty-print the values
 of the BagHeap.
] 
hash: 0000000899-308243e627871b5d563cb4cc25a965aeecb36825ba01fad80441ecc27e7d150e
[fix build with more recent hint or something else
Helmut Grohne <grohne@cs.uni-bonn.de>**20140701122311
 Ignore-this: fc33b4234eb4231ffb3cc485e2252de0
 
 IOInterpreter started exposing build errors:
 
 src/IOInterpreter.hs:52:27:
     No instance for (MonadCatchIO-transformers-0.3.1.0:Control.Monad.CatchIO.MonadCatchIO
                        (InterpreterT IO))
       arising from a use of `catch'
 ...
 src/IOInterpreter.hs:52:35:
     No instance for (Control.Monad.Error.Class.MonadError
                        InterpreterError (InterpreterT IO))
       arising from a use of `handler'
 ...
 
 This likely is due to changes in the hint package (0.4.2.0 at this time). The
 solution involves adding the exceptions package and switching to those
 primitives.
] 
hash: 0000001281-dd5c5d87f0d6cf1d064c940fdd6940f50dca7d228b8c941c9695982dc733ea14
[fix source url for src/Syntax/Type.hs
Helmut Grohne <grohne@cs.uni-bonn.de>**20140225075528
 Ignore-this: 48248ee9fb825c8c28729775a900d4d8
] 
hash: 0000000280-ff5120534b3bf773e15465344d562e4439a925b5d26da3c48f3b23cd78fbc774
[get rid of lift4 and use liftIO instead
Helmut Grohne <grohne@cs.uni-bonn.de>**20140717072357
 Ignore-this: 2afcece0c24cde0f8dcb57a462633bf6
] 
hash: 0000001098-49f271453222ca0bfa51adf615ac457589ef6af62ed2743d9474255f5ad768bb
[simplify isTuple and isAnyTuple without TemplateHaskell
Helmut Grohne <grohne@cs.uni-bonn.de>**20140717084230
 Ignore-this: 3bb9e59d15a53053c78df69001431229
] 
hash: 0000001268-0a1a3c98b94fb9ed877109b121fa277967d86afdeff1c1dea999ac54cda921dd
[Replaced type ELT with newtype ELT; files depending on Logger.hs are still broken.
tobias@goedderz.info**20140716144805
 Ignore-this: 9a0a0c29c5d0558ab4848c597160c9a4
] 
hash: 0000002039-66ddb72d747ac2652cd154bdefa97e5421de49582c64de00cf0cb5915716b9e0
[Resolved conflict
tobias@goedderz.info**20140717092644
 Ignore-this: 36dbd79b41fdeb921460e200e88e5d7d
] 
hash: 0000000409-204899ece931552c44a4a3af8a6e122f276b0c805703261b2ccd59de07309a94
[Fixed usages of lift on LM and ELT types
tobias@goedderz.info**20140717102434
 Ignore-this: 184c6a37204db852f905c6a87ecb9571
] 
hash: 0000001894-1a22c90c42220a514bb392c362753afdb74a9cca88631696bdf275c55b9eb872
[Added a MonadReader instance for ELT
tobias@goedderz.info**20140717105919
 Ignore-this: a5190ce087992c8269c0a52f1cf5d720
] 
hash: 0000000401-3cbb14ac2b65cbee31c7f167e7febce08830cc34b737c479bf7f6184730d592d
[Made some instances polymorphic
tobias@goedderz.info**20140717105948
 Ignore-this: 81593f1f48a3398031208b852ce2237e
] 
hash: 0000000521-f60532494621f3af31a5d4da65d13dae7844912eb39eb48892fc6a17cd61985b
[Added tests
tobias@goedderz.info**20140716121419
 Ignore-this: 2921a28371ef1c3b5dc474a830f9c9a3
] 
hash: 0000064266-d6b3894482e530fd58105d05f4b8277fa615fc955f0d02a0c819813c5f888eaf
[remove unneeded instances in Logger
Helmut Grohne <grohne@cs.uni-bonn.de>**20140717123954
 Ignore-this: bc53f7679628a8ac6efbea0a29ef14ca
] 
hash: 0000001735-4038aa283d7baeceac0ace92de58ee52c6abbbec6ded6a5df0909061f5cfa10c
[add MonadLog class to get rid of llog* and friends
Helmut Grohne <grohne@cs.uni-bonn.de>**20140717145205
 Ignore-this: fe9fdbcb5eba43a5adae97e7df2c1608
] 
hash: 0000016037-218ae33d394913554dbaba816cde2dd9bda33a9a1c66663b5b695de5066cde2f
[add getLogState to Config
Helmut Grohne <grohne@cs.uni-bonn.de>**20140717151308
 Ignore-this: 743617c4ffe196e3b115579c40d78ea1
] 
hash: 0000001039-9ecec939f49288ee7a8bca6f3556919ced7ac1c4cd69d0f52ae0ce47758a34cc
[specialize two "fail" to Nothing
Helmut Grohne <grohne@cs.uni-bonn.de>**20140718092914
 Ignore-this: 3955a278890793b1b646bd1a57d59a02
] 
hash: 0000000528-df669cd8b2ec333032cd75905938770900140bb09897f0a98325c2153ce43074
[Specialized a fail (and return).
tobias@goedderz.info**20140718095606
 Ignore-this: 5e2b780e6099f0c2471e44232e5b49e2
] 
hash: 0000000666-8bcf50c2d8b62939cc30bd49dcef97a36fcf06db572b70cf8626ca13650b4e3d
[Re-added fail error message as a comment
tobias@goedderz.info**20140718114851
 Ignore-this: 7bd7898f3d1e6add6e7c5dd388d1183a
] 
hash: 0000000252-8f19adbd6d202b2eb797922af9e59913c5019e11cea90aaef3bd9effa2f73bf5
[specialize a few fail to Nothing
Helmut Grohne <grohne@cs.uni-bonn.de>**20140718121421
 Ignore-this: 715edd3b015117728a69a73d55858594
] 
hash: 0000001073-a5268901c709466875bd59789790bd540cd5154b99b1cffecd54601cd483d332
[replace our Data.Utils.headM with Data.Maybe.listToMaybe
Helmut Grohne <grohne@cs.uni-bonn.de>**20140718124255
 Ignore-this: 5c5280d571982ca8e29449c27cdeaf22
] 
hash: 0000000759-23416ded3c4774193f8a6c404453d8b04b29e941490debbacef5cb2fc887b34a
[rewrite Data.Util.showAsSet for correct ShowS usage
Helmut Grohne <grohne@cs.uni-bonn.de>**20140721122801
 Ignore-this: 5469d9a1fd070f9cec175326429ef034
 
 While it did use ShowS, it constructed large parts of the result as a String
 and passed that to showString defeating the purpose of ShowS. Rather turn all
 those applications into compositions.
] 
hash: 0000000838-1f9a990afa0f1437bd1e8e2c03a67ad154510adc7242cfe48cca6f889d548b92
[Added a shell script to retry previously unsuccessful tests
tobias@goedderz.info**20140721140808
 Ignore-this: 2a9d1a43af2f371b58f8e90430e54ad5
] 
hash: 0000001048-bf7374e9108fa8fb168b63f576158f74e5d9d954b591233a2a1d8e3b85b73fce
[Parallelized test runs.
tobias@goedderz.info**20140721140855
 Ignore-this: 900c0610aabe48b36854faca73909666
] 
hash: 0000001350-d3e25389a67eb51ef9f0a665278f21c9c9a588616649123d6f03dd7f2f9dfa12
[Added missing escapes to backticks.
tobias@goedderz.info**20140721142801
 Ignore-this: 8d17c513b74da9285a617fdcff325eab
] 
hash: 0000000316-16eff66e3f56d2eb19fc5749babbc72c9e72cfb476b76e1992c5c1872d4a6909
[Parallelized re-testing of failed tests.
tobias@goedderz.info**20140721142946
 Ignore-this: 25604d3c18ac273b2d758d801a0bba63
] 
hash: 0000001798-180f2d3c03d8cb4ae9ffcbd15c7f423f225c79a394ae6b5d12ee63d2098adaa5
[invoke scripts with bash since they are not executable
Helmut Grohne <grohne@cs.uni-bonn.de>**20140721143552
 Ignore-this: 4a834ccdc77b59f1a479ff5bf978d149
] 
hash: 0000000442-36cac8558ea50b969ebb9ae0f0f962842304af7e161794ba1e393076cbefd1cf
[use mktemp rather than tempfile since the former is more widely available
Helmut Grohne <grohne@cs.uni-bonn.de>**20140721143611
 Ignore-this: 90a4124d36eb5fb69c247c05e99d9af3
] 
hash: 0000000270-10086dd5c65d1f169db63585c0c442cbf5be7f66cdcd75720ba175bfd486ce41
[Replaced _dontknow with heur_rating; also added an extensive comment.
tobias@goedderz.info**20140722094604
 Ignore-this: 5ea207170ec2d0c0b13e731f2315be2
] 
hash: 0000001143-894db462e59838627bd74dad3885215c39b028ed1d14af1b0960b48bab38b863
[avoid a comparison in a busy cost centre
Helmut Grohne <grohne@cs.uni-bonn.de>**20140724100835
 Ignore-this: 835757184c64f43db2e3f44fafa48dbc
 
 mergeWith was first checking <= and if that fails ==, so in many cases it was
 invoking compare twice. By invoking compare directly about 5% runtime can be
 saved on some examples.
 
 Note that this patch changes the semantic of GHeap iff the Eq and Ord instances
 for the key do not agree. While this is normally never the case, indeed for
 RatingData these instances do not agree and thus the tree structure changes.
] 
hash: 0000001354-cfd771cdc7970ee0b1a5030decf2c38fb993a1ad224ffb015656c1f1bb8d7234
[let Igor2.RuleDevelopment.Matching.testPat return IM Bool
Helmut Grohne <grohne@cs.uni-bonn.de>**20140724114735
 Ignore-this: c73871cdc84f799e1a443a76bf863449
 
 Formerly it would return IM (Maybe LHS), but element wrapped in the Just
 constructor would always be its last parameter.
] 
hash: 0000001016-e9c50eadf99b7733de12f256ac71d9d1114bd1ec2e59e1e10b5e20376a48767a
[discard unused and strange Ord instances
Helmut Grohne <grohne@cs.uni-bonn.de>**20140724125522
 Ignore-this: c3514f1ea38b3436fc3af1ae3564e799
] 
hash: 0000001163-8be44aeefa632a8441bd247ceb5d1a2c765c89de5bcd2ccb268dac93a989b599
[opportunistically avoid a matchesLhss call
Helmut Grohne <grohne@cs.uni-bonn.de>**20140725132317
 Ignore-this: cdc62af5ed4bdd611df33d0601c11962
] 
hash: 0000000524-d3e9bce481224e5c774f1d778dfa3d91be493dde570b9dcdf5fd52d208dbf651
[rather than returning a [] that happens to be a Subst, return a nullSubst
Helmut Grohne <grohne@cs.uni-bonn.de>**20140725140225
 Ignore-this: 571c1d098fd0cd7fc42306c795b592f6
] 
hash: 0000000305-f3ed0991949b25ca623062a19d7fbf0945fb9892dc95db025b55b692c0ec137b
[wrap type Subst in a newtype
Helmut Grohne <grohne@cs.uni-bonn.de>**20140725144508
 Ignore-this: ef00cc96cc607906fbb5042938ae1268
] 
hash: 0000004326-8ed933d0e43d56c70a26bffd643e17cf3220ce00126e387d194aa005bd9b4346
[convert Subst from association list to Data.Map
Helmut Grohne <grohne@cs.uni-bonn.de>**20140725145341
 Ignore-this: 8a718d762841825b497f1f61cdf687ab
] 
hash: 0000001146-585b774fa3d906f66272f59d7f1484399c692900d4265ca1b1ac6ece7d30cb72
[fix compilation against haskell-src-exts 1.16.0.1
Helmut Grohne <grohne@cs.uni-bonn.de>**20141201100352
 Ignore-this: 1037df002cc460eb7cc78f7b53a0be85
] 
hash: 0000001324-521fb77c61b792ecbaef1c0ea3df7b23b38e2686b959d80e9512673c3e0ee075
[Added convenient igor2 start bash script
tobias@goedderz.info**20141229141441
 Ignore-this: b6ae4a9d023a83cf6247b6320394cde1
] 
hash: 0000000212-560e916d7cbb0aa0f614a14904505ae3a74681574f35580cc53719cf96bc1647
[fix cabal wrapper to work with cabal-install 1.22.0.0
Helmut Grohne <grohne@cs.uni-bonn.de>**20150105130743
 Ignore-this: 97e2c2bd08aa4f7864c3cbdae46bba9a
] 
hash: 0000000267-b785de24fb0a5f2d371e64cb78b92cd2e58ea7d8c38041b711cf7e3a3feb63e2
[Updated test .out files to match the current behaviour
tobias@goedderz.info**20141229145445
 Ignore-this: 7e078cbbab9513e12647732973f44793
] 
hash: 0000008877-97bc1bb9bd08654fbccf689bc873e4ef8e25aac6be3f7b77125a5af921e249d4
[Disallow mtl >=2.2, as it is incompatible with hint and MonadCatchIO-mtl
tobias@goedderz.info**20141229172308
 Ignore-this: e80f1b6a042b90e30097afd26860b851
] 
hash: 0000000323-5c7d6f99a0456312cd929641f67e167033159aaa24f1923c0fa67d630ec4f6b4
[restrict the number of parallel igor runs by the amount of free memory in gb
tobias@goedderz.info**20141229172750
 Ignore-this: 5472cdbb9f44cc7198f1a20cf3276c8
] 
hash: 0000000697-b6d30f62d62c915d720f84e1b546c716aa86c368f85444b38094def6e5f99d13
[drop the --no-notice option from parallel invocation
Helmut Grohne <grohne@cs.uni-bonn.de>**20150105131312
 Ignore-this: 218715fdecc9cecfef75bcf0a5def243
 
 This option is only available to recent versions of GNU parallel. To achieve
 the same effect as --no-notice on newer versions create a file
 ~/.parallel/will-cite.
] 
hash: 0000000499-7a9949a6d6b6a1f298f53ee9c98a3c3edf4e2db96c5b04f2e71902a5c2b8f86a
[avoid O(n^2) in Igor2.Data.IOData.getAll
Helmut Grohne <grohne@cs.uni-bonn.de>**20150108152318
 Ignore-this: 7a76955a185876b64d086ce80b54c4b4
] 
hash: 0000000314-8ef6317d727993e505520925e168f820258062fb9e5c8e07a04dd27c9c176166
[derive Eq for Igor2.Data.Rules.Rules
Helmut Grohne <grohne@cs.uni-bonn.de>**20150108152625
 Ignore-this: 1b7c58685375026a8aeb0fa2e0a68c9e
] 
hash: 0000000378-02067998c91578532b8f5fdcfa04d11758637e61f2a95052d3b8944734841410
[avoid O(n^2) in Igor2.Ppr.patternNotDef
Helmut Grohne <grohne@cs.uni-bonn.de>**20150108152843
 Ignore-this: 1b68a351f4e3a6a5468ae9fbeb65cc89
] 
hash: 0000000343-b865c345690cc4c073b15d174dcd3d1aabec9d9054726bcf1fdb6c4d5afb8252
[improve Syntax.Class.Term.compareSizePairwise
Helmut Grohne <grohne@cs.uni-bonn.de>**20150108153421
 Ignore-this: e62e8777a14e8c3a92368e292e626a70
  * improve aliasing
  * remove unnecessary case
] 
hash: 0000000564-dd5cb772e7b0c222e1059fd25b8a056ff2525aba47d12e3823e61e02c5f1660e
[avoid duplicate partitioning
Helmut Grohne <grohne@cs.uni-bonn.de>**20150108162514
 Ignore-this: ae1ec4df2cbd0b2d11ebdd8fe1db2dc3
 
 In the partitioning step, a hypothesis can be partitioned at multiple
 variables. Different splits can produce the same generalized hypotheses on the
 given iodata. For example, if a function is given two lists and in all examples
 the length of both lists is equal, then splitting on each argument results in
 the same hypotheses. By not returning duplicate hypotheses, work may be saved
 in later iterations of the algorithm. Accordingly, a few tests run in fewer
 iterations and the enjoySport test no longer produces two identical hypotheses
 after this change.
] 
hash: 0000003346-7c576fb95a93c57f4fef9f7a7473ee3a69ed656323bcdcb7b99fa0c2db952999
[run_test.bash: show differences
Helmut Grohne <grohne@cs.uni-bonn.de>**20150113141143
 Ignore-this: 7aa3f4b56af33ce358babf4839b18bba
] 
hash: 0000000246-4873b3c61f7cd8ec18a6c1660e4a3ac412b9ae716a2ac0b9bd00496421c4e4f2
[semantically fix Data.MySet.deleteM
Helmut Grohne <grohne@cs.uni-bonn.de>**20150113142231
 Ignore-this: 449659c021ec64dbdc96c2ca21e21d83
 
 Previously deleteM would either return Just empty or Nothing. Likely, the
 intention was to either return Just a non-empty set or Nothing, but it makes no
 practical difference on known examples.
] 
hash: 0000000543-319d63c467be6b5438bb15a7c32ac7f8b1cf9f8eb554d08159f015a8cd9c7690
[set + simplify for all successful tests
Helmut Grohne <grohne@cs.uni-bonn.de>**20150113152955
 Ignore-this: e7547acbe5e91c1e4403a336d5410934
] 
hash: 0000014302-c6e5a95e24644024580e91225bc624e632d208f702987ad305ce254d12d48a67
[fix use of unbound TVarEs in Igor2.RuleDevelopment.Matching.abduceIO
Helmut Grohne <grohne@cs.uni-bonn.de>**20150115100222
 Ignore-this: 863b7c799f831fcffb6b914d3359d19b
 
 The function would create a substitution s, such that:
 
     apply s (rhs (crul tgt)) == rhs (crul cll)
 
 This substitution is extended to s' by mapping unaffectedvars to wildcards and
 then applied to (lhs (crul tgt)). Unfortunately, variables could only be
 considered unaffected if they occurred in (lhs (crul cll)), so the resulting
 rules could use unbound TVarEs in their rhs.
 
 The domain of the substitution s' should include all variables in (lhs (crul
 tgt)) however. So rather than starting unaffectedvars out from cllvars, we need
 to start with tgtvars!
 
 Even though this change does not affect any of the present tests, it does make
 generalizing
 
     put_last :: [a] -> a -> [a]
     put_last [a']           a = [a]
     put_last [a, b']        b = [a, b]
     put_last [a, b, c']     c = [a, b, c]
     put_last [a, b, c, d']  d = [a, b, c, d]
 
 with background knowledge
 
     init :: [a] -> [a]
     init []     = []
     init [a]    = []
     init (x:xs) = x:init xs
 
 and
 
     snoc :: a -> [a] -> [a]
     snoc x []     = [x]
     snoc x (y:ys) = y:snoc x ys
 
 work. Whereas it would never finish before this change.
] 
hash: 0000002016-70a3a6f879a8a57ef53c0c3181a5310182a2de719e6909c0802965a631fc925f
[Few minor changes for readability.
tobias@goedderz.info**20150114123248
 Ignore-this: 70913a295974b9566170546f7877528c
] 
hash: 0000001042-513889d3b7419d6bbe1cf83cf17d5a8e6787913df958cf9fc921ee71baac8f9b
[drop unused MonadError requirements
Helmut Grohne <grohne@cs.uni-bonn.de>**20150120110711
 Ignore-this: 14d03828161bb5df0d5f839fffed2650
] 
hash: 0000001315-466b392ad2c87267a9d94956029b457f65ea94b7e89f4eb973e078c7a70af94d
[Failure in run_test.bash is now reflected in its return value.
tobias@goedderz.info**20150114145027
 Ignore-this: 850e3b633b66605e8015f592b0aa9be1
] 
hash: 0000000221-f1809079799e36790fc1bc5455f2b6d78695b5b5bd2d25213e6c572e611160b8
[Added a memlimit in run_test.bash
tobias@goedderz.info**20150115092629
 Ignore-this: c1c14923cda74477b69fd13f67986a85
] 
hash: 0000000591-e83903e0334ee176f00c56eeada09a6ca248eb1039cfa7316ba7a3d623547888
[remove unused language extensions
Helmut Grohne <grohne@cs.uni-bonn.de>**20150122122748
 Ignore-this: 8f2921561470caa93a4e9162ecd49d71
 
  * Remove all uses of TypeSynonymInstances.
  * Remove some uses of TemplateHaskell.
] 
hash: 0000001185-cbd6f914c6803ea25dd2bd0ac893fc48375514c20bcd3ca6dd609350cede713c
[remove lots of MonadError constraints
Helmut Grohne <grohne@cs.uni-bonn.de>**20150123124916
 Ignore-this: 51e4f8ff1088b22454cc098cac37251
 
 Some uses of catchError result in a computation that definitely no longer
 transports an error. Still such uses were constrained by MonadError. By
 introducing a safeCatchErrorC function, we can escape from the MonadError into
 a weaker monad and elide these constraints in many places. Since
 safeCatchErrorC forces the MonadError on its first parameter to Either String,
 some of these computations practically change their monad. For instance,
 normalPat was living in the IO monad. Therefore, this change might induce
 semantic changes (for instance due to the use of fail in other places).
] 
hash: 0000007331-0ab29b8c35f570aa772b769da8ef9719e1baf2301d3889558375b777149c05d9
[next fix for Igor2.RuleDevelopment.Matching.abduceIO
Helmut Grohne <grohne@cs.uni-bonn.de>**20150123160840
 Ignore-this: 567d85b19f5a537fd5ae1f20eb79f711
 
 So even after the previous fix, the irrefutable pattern match still can occur.
 When a from a target rhs is substituted to a term of a different type, the type
 of the variable in the resulting substitution is different from the variable in
 tgtvars and thus unaffectedvars can contain it causing a conflict during merge.
 
 The difference really must ignore types.
 
 put_last with background knowledge last triggers the bug.
] 
hash: 0000001279-39615a3ff0af9dc4e3cf9c65bfcd0b7e2f07c4253af63c2dd0ef42d637147398
[replace various Data.Set.fromList with named constructors
Helmut Grohne <grohne@cs.uni-bonn.de>**20150123173834
 Ignore-this: 720d895cc70a9fa52c5a4f0fe8bb10b3
] 
hash: 0000002422-15bdb76aefef369944c14ccc65441d99c06a01a62c3b659e0aef5b4f9a87406f
[define applyAtIndex using applyAtIndexM
Helmut Grohne <grohne@cs.uni-bonn.de>**20150126134004
 Ignore-this: 22e1b19c37a90a409b0c72baf13c6e7f
 
 This removes two uses of "fail" (by reusing the ones from applyAtIndexM).
] 
hash: 0000000653-ab40570ff82ba5a9ca6c810eab574c53a4dd9cdd306d5c53e88ac5a67a6e9cde
[replace Bimap with Map in CallDependencies
Helmut Grohne <grohne@cs.uni-bonn.de>**20150129164445
 Ignore-this: 9b7576a25576413543772764752efac5
 
 The CallDep data structure consists of a graph and a mapping between Nodes and
 Names. The graph already labels its Nodes with Names, so whenever we were doing
 a reverse lookup in the Bimap, we can ask the graph instead. By replacing the
 Bimap with a Map, we no longer keep this correspondence in memory twice.
 
 Measurements show that this simplification speeds up the test suite by 0.3%.
] 
hash: 0000003810-7719bc3dcd0b5fc4e9cbac8823a547a2c33f89456d803cb55c1d4b6e4ffbc97e
[CallDependencies.addNode should return the inserted Node
Helmut Grohne <grohne@cs.uni-bonn.de>**20150129172313
 Ignore-this: 6ff302a288d5181f783f66ab619c6715
 
 Then addFunUnsafe can use the Node instead of guessing that it equals to the
 result of G.noNodes. As long no nodes are removed from the graph, this
 assumption appears to hold (and it holds on our examples).
 
 This change also speeds up igor2 on our testsuite by 0.2%.
] 
hash: 0000000943-6b793d3201f59a35a377b81830b99d7b35155daba1128fc58d25b72e8d364638
[improve performance of annexCandidates
Helmut Grohne <grohne@cs.uni-bonn.de>**20150202102739
 Ignore-this: 1c718bb7f825c270000caa850ebfdc21
 
 Profiling igor2 on the addN test shows that annexCandidates is a cost center.
 While most of the work happens in fgl, a bit of time can be saved by doing less
 work:
  * Increase lazyness by avoiding length (as used by indeg and outdeg).
  * Improve sharing by computing the Context for each node only once.
 
 This commit reduces the time spent on the test suite by 0.3%.
] 
hash: 0000001804-09a4d30e142b2afce2210076fd6e0e880f57e340db1ff6ae21f19602b4e19949
[speed up instance Term Type method equal
Helmut Grohne <grohne@cs.uni-bonn.de>**20150204085407
 Ignore-this: 2da25f070b42b75d00556114790ee226
 
 Every time it would hit an AppT, it would first unfold the whole AppT tree to
 determine that indeed an application sits at the root. By spelling out this
 case avoiding unfoldAppT, we can speed up igor2 on the test suite by 1.8%.
] 
hash: 0000000642-ce50a7cf94f7c8c73899838b2c42614edbbad935a7f441b19980c82a72aa641c
[speed up substitution merge
Helmut Grohne <grohne@cs.uni-bonn.de>**20150206101653
 Ignore-this: eba552d97a4952cfd9368ecbcc46b9f1
 
 Instead of using list intersection which is O(n^2), set intersection which is
 O(n log n) can be used. The conversion to set comes for free as sets and maps
 use the same structure.
 
 Benchmarking the test suite confirms a speedup of 1.5%.
] 
hash: 0000000625-db97290305fedecda644996bf716ffff4a85a465d413dc8cc06bdb8551e53c08
[make sameRoots lazy
Helmut Grohne <grohne@cs.uni-bonn.de>**20150206132236
 Ignore-this: d7eef64b8929f82a820c7e38a7bc300e
 
 I see no reason for it to be strict and the test suite improves by another 0.6%.
] 
hash: 0000000402-4b326bcabe5a2071a89f50cd6ce34357f437e847510601572024ca72f8fc8442
[use named Type constructors where possible
Helmut Grohne <grohne@cs.uni-bonn.de>**20150209143740
 Ignore-this: 1c7aaf02514393e781b57f21cb839a08
 
 ListT -> listT
 ArrowT -> arrowT
] 
hash: 0000001459-0587b71dbe9574f7493f104ff37d46bf963b5444f38b395d4099826250db63ef
[simplify the data type Type
Helmut Grohne <grohne@cs.uni-bonn.de>**20150209153158
 Ignore-this: 7e09228772a1b15bc375449fc28502cf
 
 Remove constructors ArrowT, ListT and TupleT. These can also be represented as
 compositions of AppT and ConT. Re-define their lower-case constructors suitably
 and improve pretty-printing to cover for these cases.
] 
hash: 0000004191-ec4b9db1ca0770f82d822f161dbb037bf6bc87ed2e5c88076616ca706048e289
[repurpose smart constructor tListE to hide TListE
Helmut Grohne <grohne@cs.uni-bonn.de>**20150209155358
 Ignore-this: 23144d6ab70ffe5f2bb0e08a18be208
] 
hash: 0000001043-886ff17f0171b60ce80fe4ceafa7ed554e350488e07c87787fb1504c05353d48
[make isList compatible with the new listT
Helmut Grohne <grohne@cs.uni-bonn.de>**20150210081646
 Ignore-this: 5d197ebbf883dca486d1ed6cb82f0e90
 
 listT was changed to ConT ''[], but isList compares the name stored in the ConT
 against '[]. Unfortunately, ''[] is not the same as '[], so isList would now
 return False all the time. Also fixType should no longer find any '[] in ConT
 as this is never constructed.
] 
hash: 0000000638-72bbbab6e6d055de0c3af5f23f6f323bae0affd097d73d38b40ac34892b1b83e
[simplify the data type TExp
Helmut Grohne <grohne@cs.uni-bonn.de>**20150210090903
 Ignore-this: 7622e77b861f6b69405236fbe6283f81
 
 Remove constructors TListE, TTupE and TInfixE. All of these can be represented
 by combinations of TAppE and TConE. In order to keep this change as invisible
 as possible, the pretty printer gained a fair number of special cases.
 
 Surprisingly this changes the behaviour of igor2 on the test suite. Yet it
 seems to be a net benefit if only in reduction of useless cases.
] 
hash: 0000009572-49474feeaa0fbf37b46641b430acecd1e00f2a8accbe06ef90d240c2ead8550c
[further tweak Term Type instance's equal
Helmut Grohne <grohne@cs.uni-bonn.de>**20150210114800
 Ignore-this: dd96765b7a84dd36ca9a70dd19dd0e32
 
 This function really sits in a busy cost center. By saving one (:) it seems
 that we can save 7% of allocations and 0.4% of runtime.
] 
hash: 0000000467-60fbb0810a7c67ff362e503f6cc030413c70af13c13c304a22782ab08a17aa14
[remove Type from TAppE
Helmut Grohne <grohne@cs.uni-bonn.de>**20150210122759
 Ignore-this: f86abd2fa1dedda4e4d6e835bf63804c
 
 The type of a TAppE is always uniquely determined by the type of its first
 TExp. It also is trivially computable, so there is no point in storing it.
 By computing it on demand we gain 1% in performance.
] 
hash: 0000003343-01a587c61a7bf519384b00c34dcc383a45e2c838da2e2986d3adeae7e3c4c91a
[convert more fail to throwError
Helmut Grohne <grohne@cs.uni-bonn.de>**20150211101130
 Ignore-this: f5a1f6c5580639cc2f621284e7a84bb3
 
 All of these are only reachable when enabling "enhanced". Then they crash igor,
 because they fail in a Monad that is not a MonadError, but they are meant to be
 caught with catchError.
] 
hash: 0000003606-4fd5615ec4fdde6ad9730027530778144a2c0f64c6ad8e5f112531bd9e433a40
[Added :test inputs for most tests.
tobias@goedderz.info**20150211142436
 Ignore-this: f701e3e3dbfc37cde75d07635b029cb3
] 
hash: 0000013675-e99d0a0a997039f805b5beafc0dad265f63fc9b58441fa6f48817c5bde9ebf73
[Simplified RatingData's compare function
tobias@goedderz.info**20150213103351
 Ignore-this: 2264b20136a328b8340213a705004d5
] 
hash: 0000000365-dd99faaaf55ae5d513829365369b72dbfafc9f198a1161784e7da1b78dc82b1b
[fix pretty printing of tuples
Helmut Grohne <grohne@cs.uni-bonn.de>**20150217093201
 Ignore-this: b5627b27363f09333cf6853586ff2245
 
 The pretty printer could cause an rror when a ConT was applied to exactly one
 argument by checking whether its name is tupleTypeName 1. Use isAnyTuple
 instead which does not suffer from this issue.
 
 Thus isAnyTuple should also recognize empty tuple () in order to not regress
 pretty printing here.
 
 Since there is no Name for one-element tuples, the cases covering for these can
 be removed.
] 
hash: 0000001087-d908215182b91943e3110a612e6975da5df97a1f6c5f52d8f5ad2a9fa8dfb18c
[improve instance Pretty TExp
Helmut Grohne <grohne@cs.uni-bonn.de>**20150217102821
 Ignore-this: 794962b96629cd44b0ad4eb737a2f886
] 
hash: 0000000769-6f15bd417476bf14bb82e6cd5fcc8310b7927c103363307d84894cd9ea8cb759
[Added a regression test for a bug introduced while replacing Subst by a Data.Map
tobias@goedderz.info**20150213104721
 Ignore-this: 989de578539492fac02cfedf7c6eea8e
] 
hash: 0000002332-40f349292e2503a41f93ebc3bb718b81ff9693a71676299359829953ce1e7b5b
[Added regression tests to run_tests.bash
tobias@goedderz.info**20150217132739
 Ignore-this: d4828fe4a7b94295fe40cfe5d9e33f73
] 
hash: 0000000573-fffadadc60621f6d8704f99bf675d7ec83890507d4e9b8b07d45c147d72ad19e
[improve pretty printing of wildcards
Helmut Grohne <grohne@cs.uni-bonn.de>**20150217143213
 Ignore-this: e0aa9284e9302ebdeaead04bfd53e064
 
 The current way of transforming TWildEs into TH.Exp, is not valid Haskell as an
 unbound identifier prefixed with a question mark is used. If a wildcard shows
 up in a final hypothesis, it cannot be compiled. Thus changing the
 representation of wildcards to calls of error with the wildcard name attached.
 
 While this is not relevant here, it becomes relevant once igor can create
 hypotheses containing wildcards.
] 
hash: 0000001669-3270131c9e6e5149aaa14394cb1e5b6829f957ddf03f56075a42735cf4a3ca6f
[let AUnify TExp handle wildcards
Helmut Grohne <grohne@cs.uni-bonn.de>**20150217143627
 Ignore-this: 190a64a20dab0ac5886e9b152b43d7f4
 
 This fixes a serious bug in igor. The direct call rule development assumed that
 a variable in a lgg returned from AUnify would not be unifiable on the IO
 examples. Consider the following RHS:
 
  ?p (a wildcard)
  S p
  S p
 
 The antiunifier would return a fresh variable, because one TExp contains a
 wildcard. However the unifier could still unify these TExps. Thus the direct
 call could pick any of these RHS (for example the wildcard), generate a call
 (which works) since the chosen RHS matches with all RHS, insert the call even
 though it could violate an IO Example.
 
 The solution is to handle wildcards in the antiunifier as well. As a
 consequence wildcards can now occur in closed rules and thus final hypotheses.
 Another consequence is that a better (less partitions) solution is found for
 the pepper example.
] 
hash: 0000003914-f874bc929903ec1de13a2825f04f861444cf3b0f4b9095514df0359c293fe071
[add regression test for the antiunifier wildcard handling
Helmut Grohne <grohne@cs.uni-bonn.de>**20150217144343
 Ignore-this: d5dc172c22237d2e1ec43e0c0398da22
] 
hash: 0000005924-8e59101e02f5159c9643219e65b64f27167856acd36f14eae384e29a73f6e82a
[move isWild to Syntax.Expression and export it
Helmut Grohne <grohne@cs.uni-bonn.de>**20150218123031
 Ignore-this: d9df4366f8267a6d03388e43b32621ab
] 
hash: 0000000879-0e79b8acb093554369533115694a16fb90ef46c7e06db6fed219187a085466d7
[fix Subfunction.hs to work with wildcards
Helmut Grohne <grohne@cs.uni-bonn.de>**20150218133926
 Ignore-this: 1e2f0c2ead9bc68e7a5f5ef250ae59b4
 
 Since aunify can now handle wildcards, the subfunction introduction can fail to
 handle it. Consider two examples where one rhs is a wildcard and the other rhs
 is an applied constructor. aunify will now yield an applied constructor.
 abduceIOAt will now fail in fromJust, because the wildcard has no subterms.
 Instead, these subterms need to be generated as new sub-wildcards. Merely
 skipping such IO examples would be wrong, because examples with a wildcard rhs
 still can affect the lhs of a "fuse"d rule.
] 
hash: 0000005326-0a87623521f017f2acd4eeb9a7badf1f17b4e95efaa404f81af98d1aea4b3f7e
[add regression test for subfunction wildcard fix
Helmut Grohne <grohne@cs.uni-bonn.de>**20150218135521
 Ignore-this: 8c1226ad26031ebda54cdd763abb36f9
] 
hash: 0000006645-ef8b0bcba85a9f5cf8ee0f6ead8e2102281412dd76f6ee55d84142966c7e023a
[fix logic inversion in ListCata.mbFilter
Helmut Grohne <grohne@cs.uni-bonn.de>**20150218155226
 Ignore-this: a1e75b56d71c11f9d20700bc1be9a115
 
 mbFilter would (Data.List.)partition the io examples into those where the last
 argument is the rhs and where it shows up in the tail of a cons of the rhs. The
 code assumed that the former ones were the ones where the filter function would
 give True, but this is actually the case where an element is dropped. Running
 igor on the examples evens or zeros clearly shows this logic inversion.
] 
hash: 0000001414-df8b451534a913977670bf684f6c5ad673cba345b1c7a5d1268138b698510e1f
[fix result of ListCata.headTail
Helmut Grohne <grohne@cs.uni-bonn.de>**20150219133852
 Ignore-this: 17b14ad9d0135bcc041c5f9b5a933665
 
 When headTail was given a TExp "[a]", it was returning an returning an
 application of "(:) []" as the tail, but the expected tail actually is "[]".
 This was due to the extraneous "foldTAppE o" in the result. Ultimately, this
 resulted in broken IOs when enabling enhanced.
] 
hash: 0000000879-aea06722b5732db7fbc0708d4aaf12c0f19bc051f48ce75d21c8bcc1bd6d409c
[fix off-by-one in ListCata.mkFoldCall
Helmut Grohne <grohne@cs.uni-bonn.de>**20150219134512
 Ignore-this: 7ff7ba77e0ae1bcf72e4b2f47967629b
 
 mkFoldCall would compute usedVarInd as those indices (into the open rule) that
 are duplicated by the new parameter given by foldr. It would then remove those
 parameters from the IOs generated by abduceIO. However, those parameters have
 the ith parameter already removed. Thus indices larger than i would remove
 unintended arguments or even the head parameter passed by foldr (as can be seen
 when generalizing appenD). Thus indices larger than i need to be decremented.
] 
hash: 0000000938-f2b56bf3c6ac8f1281a544357379df3f9e0f8a6daf583c3621b66d13aa7e5260
[create log files on the fly
Helmut Grohne <grohne@cs.uni-bonn.de>**20150226121856
 Ignore-this: eb96b0b8c4b8b639c7de2a149dac6ab
 
 Previously, igor would collect all log entries and after finishing a synthesis
 output them in one batch. Likely this causes lots of thunks to reference
 unneeded data structures (as prettyfication is lazy) and thus excessive memory
 usage. In fact, a -hd heap profile shows excessive thunks in
 Igor2.Logging.Logger and a -hy heap profile shows excessive Logs.
 
 This change regresses the error handling during log file writing and lets igor
 crash instead.
] 
hash: 0000005708-ac7b26742cf14139a1a8e889e4ec674aa5352c71ab5a1614ae05c51c3888a3b7
[add Applicative instance for ELT
Helmut Grohne <grohne@cs.uni-bonn.de>**20150226130646
 Ignore-this: 2ae530e71bfd3e5531d2d911d181db2e
 
 This is necessary to support the Functor-Applicative-Monad Proposal.
] 
hash: 0000000462-873998e1c5e3c10415a063219a34952e094f9ba998964ad5a060878abb8daad0
[bangify HSpace cntr
Helmut Grohne <grohne@cs.uni-bonn.de>**20150302091640
 Ignore-this: e3995dc17df80879d3554c54603c075c
 
 This parameter consumed considerable memory (>10%) for our failing examples as
 can be seen in various heap profiles (e.g. concaT):
  -hc: incCntr >25%
  -hr: incCntr >25%
  -ht: Int >25%
] 
hash: 0000000417-58c5fb6724d983f8fb57400ce8477f59702e72b48202342d77e1dcd4eb870ab1
[avoid D.Graph.I.run_
Helmut Grohne <grohne@cs.uni-bonn.de>**20150303094310
 Ignore-this: 5ea721392913fbf06bfe9300e0dddd54
 
 This constructs a NodeMap for the graph. It maps node labels to Nodes. Igor2
 already has such a map in its CallDep type. Rather than computing the NodeMap
 on each graph transformation, reuse the information stored in Igor's node map.
 
 This speeds up the test suite by 2%.
 
 It may also solve a space leak in addEdge.
] 
hash: 0000001802-40db8d99736491e997dcf81f3efa5795e2d75ff9ef1c6fe4423b59435d7a1a27
[remove unused MonadPlus from various contexts
Helmut Grohne <grohne@cs.uni-bonn.de>**20150303153735
 Ignore-this: 1e0512fc845058f3ec3fdfce0b325d70
] 
hash: 0000002493-6b6c69845d22b1cfccc921a8c73c9d2af8332e75418dc88d505e4318c0ef66d8
[compute heuristic in a lazy monad
Helmut Grohne <grohne@cs.uni-bonn.de>**20150303155854
 Ignore-this: cbc81498fc2290635af68d023e0c8634
 
 The heuristic is only used for debugging. Thus it should be computed lazily.
 However, it is computed in a strict monad. By swapping the monad for a lazy
 monad using mapReaderT we can gain an 8% speedup on the test suite.
] 
hash: 0000002613-22fb76629600f30ea657b94cde04f7f618815103393d86d4d9b8320c9dab810e
[fix memory leak in "fuse . getAll n"
Helmut Grohne <grohne@cs.uni-bonn.de>**20150305132525
 Ignore-this: 3eb06b5d7b900efec093b755b2d6701d
 
 If the indices in a CovrRule returned from fuse are never computed, the passed
 [CovrRule] must be preserved in memory even though it was already completely
 forced by the lggRules call. Thus the full result of getAll was persisted in
 memory.
 
 Now in this composition the name equality check holds by definition and the
 index list also is trivial, so a targeted implementation of this composition
 can save up to 20% memory for some examples. It also speeds up the test suite
 by 1%.
] 
hash: 0000001906-b1c5d82ff4ed49104f796d461fba42862b224860f5242bdab8fbc2e7e54d7d0a
[Added more eq examples and updated the eq test.
tobias@goedderz.info**20150219123253
 Ignore-this: 8355b4bf6a0037ef6cfd96f36664ee81
 
 Generalising eq resulted in false results due to incomplete examples. This patch
 completes the example set and adds a :test in tests/eq.bat that would trigger
 the previous wrong behaviour.
] 
hash: 0000001666-80c82b59c7a4b6907e5ae3960d0d32bac09e856079acc5208d6771e62c1ddcdd
[Allow for newer versions of mtl
tobias@goedderz.info**20150218133226
 Ignore-this: 55dd69fd3abca821e6c91bc292020b57
] 
hash: 0000000282-103d2821ee87a99d8d47509f7024eb6397b9d928455a3c736c417af694079f70
[Log timeouts separately from other failures in run_railed_test.bash
tobias@goedderz.info**20150305141935
 Ignore-this: a9b09284273d21770a350c668f670e9a
] 
hash: 0000000883-9fe820042639fcb45f714192e3dae92c583606a6b099930a57fe6145c689d875
[add a failing unit test suite
Helmut Grohne <grohne@cs.uni-bonn.de>**20150305162642
 Ignore-this: 7df433961fcd5f12206a7a0df0fb67c3
] 
hash: 0000002104-d170618cdd4e8295e79be3e791c0d689969ef71563e24f71bbdb59a021259223
[improve QC.shrink for Type
Helmut Grohne <grohne@cs.uni-bonn.de>**20150305163451
 Ignore-this: ec1a0c1fca9c1e97015790546ca5b5e8
] 
hash: 0000000341-0adb4ff1c3938e97f817e1639fd60a55e004f7a9c155efa4b40187224266c8f0
[fix lgg on Type
Helmut Grohne <grohne@cs.uni-bonn.de>**20150306100728
 Ignore-this: d102c591f6c07ebd374cae64a27612a2
 
 Consider the lgg of "a" and "Eq b => b". The Eq instance needs to be dropped,
 as "a" is not an instance. Igor would return all available instances for "a"
 and just Eq for "b". The intersection of both would result in just Eq. Worse,
 new Ord instances when there are no restrictions at all.
 
 This fixes the lggTypeAssociative quickcheck test.
] 
hash: 0000000676-ecbfbe3c0e72a1821be4a633be692d7fe99d124846359c7c9e167051370f08be
[Refactored functions on the Igor type not to depend on its number of members (or their order) anymore.
tobias@goedderz.info**20150225084535
 Ignore-this: 530f7ac7ab47ced2819e468f8f5ae219
 
 This makes it simple to add new entries to its constructor.
] 
hash: 0000001968-d7a8152f95bc17249892fece5b99e300d2d1cf21659570f22cf42c31b13396a0
[Restructured makeIOMatrix and its usage.
tobias@goedderz.info**20150226142003
 Ignore-this: 52968b8bc6a407c6a8cd26e088d13c88
 
 - removed the dispensable "Maybe" from makeIOMatrix's return type
 - standardized argument order regarding cll/tgt
 - clarified some comments where cll/tgt where mixed up
] 
hash: 0000004938-74e1844aa8407c95e625cf848150c9e1daa040536e6586864a5a67129b6249d2
[Introduced monadic mapping functions for terms and rules
tobias@goedderz.info**20150213164658
 Ignore-this: 4bc67a627cf248cd9de12fd73d374aa7
] 
hash: 0000001189-c39ccd791c89cf7e1d24b0610830ccb68651a0e17b48ceb4066dfb14e8907e8e
[When adding IOData, give all variables a new, unique name.
tobias@goedderz.info**20150213164747
 Ignore-this: 5fe929e5fcb80e702f15bf790b69731
] 
hash: 0000002505-91ccc41ee336fff92b1620a22de972c0f4fdda3b702eb61925dfdd0932c68e75
[If indirectCall can derive closed helper functions, use only those.
tobias@goedderz.info**20150303093405
 Ignore-this: a3884663790b31b398603381e529f62f
 
 Added a function bestMatchings that can generally compute exactly the same IO
 examples as allMatchings, but prunes all which result in open helper functions
 (which compute the arguments).
 
 This behaviour is scheduled to be refined later.
 
 If bestMatchings' result is not empty it will be used instead of allMatchings'
 result. This results in a shorter running time and, on our current test cases,
 in exactly the same results.
] 
hash: 0000007692-2674761d0d1abf098ac8b65dfa50d19e2b244b93b4fe0a4882572dddd681f488
[Fix divergent use of lggRules
tobias@goedderz.info**20150305151204
 Ignore-this: 8d12709a3b15e52eb55498caef011c05
 
 lggRules was changed in the patch 'If indirectCall can derive closed helper
 functions, use only those.'. However, another call (expecting the old version)
 was introduced in 'fix memory leak in "fuse . getAll n"'.
] 
hash: 0000002639-88cee118d6314d98802695224078d1f1ca11745cab88e5c11719ea8a05fa7e9e
[Reverts the patch 'When adding IOData, give all variables a new, unique name.'
tobias@goedderz.info**20150306122743
 Ignore-this: e530f97f522de4d6e40b01e4484f65fc
 
 It doesn't seem to be possible to avoid duplicate variable names in Igor2
 completely. Therefore, the referenced patch only adds additional runtime and
 complexity without solving a problem.
] 
hash: 0000002388-335cf00b341f42dc89a5de485ea6a8e83d226cedf3ea69bb3998cd7d382d9b9c
[Generalized bestMatchings to return all matchings with a maximal number of closed rules (instead of only closed rules)
tobias@goedderz.info**20150304154357
 Ignore-this: 851c8bb5f9ca8577f0610d2aa83e3af3
] 
hash: 0000001801-79932508fe4085eb6452fd0fa64dd7cb7f29f35974af89862cb362425fc98eaa
[update test suite to match behaviour of improved matching algorithm
Helmut Grohne <grohne@cs.uni-bonn.de>**20150306140248
 Ignore-this: 58cce84fb596e79e75659841480f059b
] 
hash: 0000002943-806e8ba1e926b268d6438c45b97e2b19d677a9cc88a442924663096bdf17b01c
[move tests ack, droP, member, weave to successful
Helmut Grohne <grohne@cs.uni-bonn.de>**20150306141319
 Ignore-this: a426f01c70e3838713fd7caf466fbe4e
 
 weave was initially generating a function that was not defined on the added
 example, so this example ensures that it finds the desired solution.
] 
hash: 0000007938-f1cfab626eac9217800fca00de0f5ac4af208158c7a7a9ad4f898cfb0dc7ca6e
[introduce abbreviations for ConT ''SomeType
Helmut Grohne <grohne@cs.uni-bonn.de>**20150309120412
 Ignore-this: 64a67504fd0dcf02ce0b8c1ef97f933d
 
  * Allows using these constructors in modules that do not enable TH.
  * Simplifies refactoring of the ConT constructor (e.g. adding kinds).
] 
hash: 0000005304-1395f9aa8437a36a0b9fa206cb48b041e53c51f1eee2915ad06d523a0302185f
[quickcheck: improve instance Arbitrary Type
Helmut Grohne <grohne@cs.uni-bonn.de>**20150309120623
 Ignore-this: cf9254a6ad445251e779d554d9449696
 
 Now the generated Types have kind * and they do kind-check now.
] 
hash: 0000003727-9deb5b0ae366af2a2aad1fee4d1cc29ec8d447a1926c7d085e757eec82e3d35d
[quickcheck: generate more and larger tuples
Helmut Grohne <grohne@cs.uni-bonn.de>**20150309130724
 Ignore-this: 1885b465841b9be0ea7e5717abc1b04d
] 
hash: 0000001063-50b35a282393d4f1173d4c3d8f46d56c92cc26aafc83900dd5ea174b46e3d2c1
[quickcheck: fix Type shrinker to be kind-correct
Helmut Grohne <grohne@cs.uni-bonn.de>**20150309130845
 Ignore-this: c9cb1684c03ac2336faed3582c260a0c
] 
hash: 0000000840-59a0babefbb09f520d49a61f86fb621aa0460738bc454acab0390e20b14ce3bf
[quickcheck: lgg must succeed on kind-correct Types
Helmut Grohne <grohne@cs.uni-bonn.de>**20150309130925
 Ignore-this: dcb3317598b2fa191d61e3b3e7da3140
] 
hash: 0000001955-2a7c97cd59925e3367cf5848c07f11c00b3021bfad9d0bbf5764f3bb84cf92ef
[require less monads in fuse
Helmut Grohne <grohne@cs.uni-bonn.de>**20150309135328
 Ignore-this: 48ef64ba7f2ce211f85689bc8d813916
 
 This saves 1% calls to Logger's >>= as a lift can be pulled out of a mapM.
] 
hash: 0000000923-6fb735e9e80249433e4eb078901da17a39d82b9419e3f221fac00b887a2b5561
[force a lazy monad for instance Rateable Hypo
Helmut Grohne <grohne@cs.uni-bonn.de>**20150310095023
 Ignore-this: 86fb83fee165d8cc1c7ac80cd823a4cd
 
 This speeds up the test suite by 3%.
] 
hash: 0000000474-ccf5279231c5027e820ed5fadbef679546e1febdb7a9fbef02667a1894607821
[add new example pow2
Helmut Grohne <grohne@cs.uni-bonn.de>**20150310142123
 Ignore-this: ceb301bd964f7941ceb6b325403df57d
 
 It computes powers of two. This seems to be unsolvable to Igor at this point.
 Introducing an accumulator and replacing all Z with the accumulator lets Igor
 solve this quickly.
] 
hash: 0000000540-e8e99b892b467caa7e14ce93d681c6619bf929ff8577b0ea07f1abb2f4f9b6bd
[turn the Pred type alias into a data type
Helmut Grohne <grohne@cs.uni-bonn.de>**20150311113953
 Ignore-this: eedf2f9f8422b250c9d4cd21fb918a4f
 
 Previously Pred was a Type with a value "AppT (ConT n) t". By turning it into a
 data type. This assumption can be enforced by the compiler.
] 
hash: 0000005385-ee9e204621cb750d7781ddf2f57de6a810c8ddf3a82380051281691385b4d55e
[Re-use partially evaluated lggs to safe some runtime
tobias@goedderz.info**20150304155112
 Ignore-this: 517e0b8416e5450ec6d3181b840de85d
] 
hash: 0000002497-8e93ab3b30ddd9d6a49ec04d32924a02793909796136820ed5f71988a341e9d7
[Added a separate branch-and-bound implementation and used it in bestMatchings
tobias@goedderz.info**20150309155256
 Ignore-this: a6bbb4ba0ba9b82cf6295892e837e2d1
] 
hash: 0000009612-39747c817c852eff6b62694ea530bf13209b3f8874f35750da81447a875cddad
[Updated tests/*.out files to reflect the behaviour of the new branch-and-bound algorithm
tobias@goedderz.info**20150311112654
 Ignore-this: 1a8381ae0fc08ddd9c906e2fa0783929
] 
hash: 0000003318-a58742ce96d56cc64a4eccda6008bdc6e1156d91e3b5df15a72b43dcc48ec9f6
[Added a short documentation on the usage of the branch-and-bound implementation
tobias@goedderz.info**20150311115909
 Ignore-this: b408911a15fe67192cdb3dc62309908e
] 
hash: 0000001146-cf5ea182f809072d6a31d51ec7360dac3e43e781e2ad5452f13c2c30c04a370f
[Allow the usage of "undefined" in I/O examples as a wildcard
tobias@goedderz.info**20150213102412
 Ignore-this: 5c8e31939f80e395830beb342306ca8d
] 
hash: 0000003321-679958aed7ac2b01069dfcf5ccfd3c86a081de6cf4898e08f14aaf420a156dbc
[Merge wildcard and ConT abbreviation patches
tobias@goedderz.info**20150310143111
 Ignore-this: fd9b2c83578a6fa372bb761789c66dd4
] 
hash: 0000000870-249d4435a2ab37f2dd9021253cdcec430ec7ae62f6c761dffd30998d5f8f7fe2
[Removed the code that renamed wildcards uniquely
tobias@goedderz.info**20150311111250
 Ignore-this: 840026c5697c0d6ca621e382953ca285
 
 As it's not possible to avoid duplicate names during unification completely,
 it's pointless to make some variables unique. This greatly simplifies and speeds
 up the introduction of wildcards.
] 
hash: 0000002564-d8c095082ce1744f9655342f9db219b8136aa4cc5918027b063495e4f337fb3e
[Removed RenameStateMonad, a remnant of wildcard renaming.
tobias@goedderz.info**20150311132202
 Ignore-this: d178338808eafe26b7af5f3b68dece3c
] 
hash: 0000000388-369c124f5fe492aead9e0b63fa1ee32ec8e930565d6aa347bbd5cd799071a5db
[Removed :simplify from the fibAdd tests ('cause it's broken)
tobias@goedderz.info**20150311135453
 Ignore-this: 745e7826a656b08283f4e78fe5512f20
] 
hash: 0000000506-a7d4627448c8100a3d59c1a64eebc672ccbadd73073801e6cc262abf808234ad
[fix outdated comment on type Pred
Helmut Grohne <grohne@cs.uni-bonn.de>**20150312121153
 Ignore-this: ec9cec8b71d0a6489b6f7466d0258ad1
] 
hash: 0000000335-138d980cd3decfbd0e29b1bd3bca18a282a704aeec83196b5409ab517828b959
[drop quantified variables from ForallT constructor
Helmut Grohne <grohne@cs.uni-bonn.de>**20150312121258
 Ignore-this: 9834dc0b1822eef8bf61b20c5089f660
 
 Unless enabling RankNTypes (which Igor doesn't do), forall can only occur
 outermost and all free variables in the type are automatically quantified. Thus
 the quantified variables can easily be determined by looking at the Type
 parameter of ForallT. In fact, the only place where this parameter is used
 (besides fixType and quantify) is the pretty printer.
] 
hash: 0000013893-ebd30a0b49dde91316bd46abbb5a452a9390dc9bcd0e281c3709dfded77aab22
[Removed the intermediate "computeMatchings" function
tobias@goedderz.info**20150311144610
 Ignore-this: 13db8345d14d522d42510f25961b5a4b
 
 The branch-and-bound implementation of bestMatchings never returns an empty list
 unless there are no matchings at all, therefore the fallback to allMatchings was
 a noop.
] 
hash: 0000002021-42cefa83d2f83608fb9404efcf6634918f7b9f39f0797b5e8c87b07d02f9c30e
[Consequently used ArgList and FunList throughout Matching.hs, and removed some dead code.
tobias@goedderz.info**20150311150101
 Ignore-this: f037c5c80971ecd43cfe82f25a789d48
] 
hash: 0000004772-5a6a8c4888e8d45abb5fe295a38aff2df1ecd3a98a5b50547990441f0d64d9bf
[Added a bash script to conveniently generate test output files
tobias@goedderz.info**20150311160426
 Ignore-this: 9c0914ab6508c0c21f40318a5bdf4e2
] 
hash: 0000000719-72aa658dba87baa1146f65f08735765322997106a76df9130f562ff97c58cb84
[Renamed InnerNode to BnbNode
tobias@goedderz.info**20150312125749
 Ignore-this: 23a02f3e07bc9798c182e4e139f3f91
] 
hash: 0000000193-5aa9f5044ed007889d9cb4db7ee42338a536cd96c26585fa90d23465c3c7ed9f
[Reuse closed lggs in mkIndirectCall and eliminate constant functions there
tobias@goedderz.info**20150312131506
 Ignore-this: 48be319d8052c1bab274e0312540d85c
] 
hash: 0000004975-bb78d1031e418d0bf98249db5f37650573b9f9ad4188beae5b5d13ff1cb1c6db
[Instead of giving bnb a queue type witness and a node, pass a queue containing the node.
tobias@goedderz.info**20150312131637
 Ignore-this: 5a83470abcb7351857a229b1c3f17f87
 
 In addition, qualified some names and made variable naming more consistent.
] 
hash: 0000003173-fd121947723aa16e49c77f2e20925fd352730f5b53c7bc9814c33214b1743c33
[reduce monad stack in Matching.abduceIO
Helmut Grohne <grohne@cs.uni-bonn.de>**20150312164845
 Ignore-this: a987c1b8daab445bf72a93c24a055de9
 
 Speeds up test suite by 1%.
] 
hash: 0000001272-340f87b1aaa6118bbcd8b1fe18bdefac52e7c069c21be89a4c84dd6314283bfd
[Added a Pretty instance for Subst
tobias@goedderz.info**20150312143558
 Ignore-this: f52cf7e0215c5d33f6ada9d13295e128
] 
hash: 0000000395-f84e41a42dab25731f88eb6874d5da69eef997286c97cd53fc1edce06d24ca7a
[Replaced fail with throwError in Syntax.Class.Subst.merge. Also, qualified merge.
tobias@goedderz.info**20150316105235
 Ignore-this: d58767eafe92ae5da16af2f38ae92fd5
 
 This prevents unintended calls to "error" during unification, where an exception
 should be thrown and caught instead.
] 
hash: 0000002981-0efa1bb094beaf0544b630ec42bd60897ac42fa38afa03c214988975e5d615f1
[resolve conflict between Subst.merge qualification and ForallT parameter change
Helmut Grohne <grohne@cs.uni-bonn.de>**20150316115241
 Ignore-this: 837047792e730296dcf9869f1a57a435
] 
hash: 0000001173-c1d3e118ea3ec6738173af5e47fd2b9e01f0db182a6871877ea74290f1a63eaf
[Adds a new "accum" flag to the UI (which is not yet used).
tobias@goedderz.info**20150311135723
 Ignore-this: 49b691366666278a1f0f836a838624fc
] 
hash: 0000004794-8baff8d52580e525d4e1704d35016b7017202524ced2f5c873c59b4e6ccc4ddc
[Introduced accumulators
tobias@goedderz.info**20150312163840
 Ignore-this: 8fb4545670b3af3bdbd52c36f2382cdf
 
 When some variable-free term occurs in all IO examples of a given rule, it may
 be replaced by an accumulator variable. By setting the +accum parameter, this
 additional step is added to the derivation steps for new hypotheses.
] 
hash: 0000007575-6044863f73cc33b990865f774970df2eff3f89f66c6169aa9d1a55f076446c3b
[Added a bunch of tests for accumulators.
tobias@goedderz.info**20150312164222
 Ignore-this: ca19d136cafa06a37fc7c44696b5201
] 
hash: 0000065394-9df1525bb85c2e9fbd266adbb526d9b79165d5f9961720b9a817a8d5defe8261
[Made verbose output of +accum more readable
tobias@goedderz.info**20150313121218
 Ignore-this: a7a9a2564d83af3544ff43344e949159
] 
hash: 0000000703-ef4e9fe5b86ef29410f85f7a0fb0e4af51445f02d76740e21782b78bb010ca5a
[Removed an obsolete TODO note
tobias@goedderz.info**20150316105903
 Ignore-this: f576ab537b1d71e4c33a97f82f3a8d8a
] 
hash: 0000000221-7066a63a84310d2796f5344b4842eb57313b2a8c087d4ab11953375e537342ec
[Add --gnu to parallel for backwards compatibility with older GNU parallel versions
tobias@goedderz.info**20150317121526
 Ignore-this: 8c94fe88b919735e4b501df6f671aa2
] 
hash: 0000000299-4fc1e7e7de2307cdd2483115dfe128b9adab6ac5d3cdb9a91181438d1f2f40c8
[Changed basename usage for compatibility reasons
tobias@goedderz.info**20150317121922
 Ignore-this: d5ab732c92be9aae21ead53d060851fd
] 
hash: 0000000655-5f3a56423df823a5d26a26f11f5b3b3aa9c9db02776e817ffd17c9ddf20c0a76
[Removed -XInstanceSigs for compatibility with ghc 7.4
tobias@goedderz.info**20150317122429
 Ignore-this: 9ea33ebbabf9caa7839d6a0437c65c73
] 
hash: 0000000377-7532d06eafc041ddb869b291797d429dcd3ecf4584aa30b2c8e7445438ac2033
[Stop depending on the executable bit of igor2, run with sh instead.
tobias@goedderz.info**20150317123255
 Ignore-this: 194c7005da7d25999690e3680f2c8471
] 
hash: 0000001029-418f07a2c76c627dd0780ef7154762422af8b7adb9d2f246969e26380de1aef9
[Added a test for pow2 with accum.
tobias@goedderz.info**20150316130407
 Ignore-this: da3988a509ff33d48117733f2c31ef2d
] 
hash: 0000002012-5efcd70de8a350655bc001335bb7ff9377fa23cd2e01ce6dc51e41e04dd9051e
[quickcheck: new property about match and apply
Helmut Grohne <grohne@cs.uni-bonn.de>**20150325130330
 Ignore-this: ea5aeacb39065d13e825204db726d3f0
] 
hash: 0000000849-24e6db868f70e59d31a9a06620618f83b0ddb2cc1ea0fad2bd41b47c1086f689
[quickcheck: attempt at instance Arbitrary TExp
Helmut Grohne <grohne@cs.uni-bonn.de>**20150325160707
 Ignore-this: 654557a9b90e94001242be8b4f3f85cf
] 
hash: 0000002668-912474522d4ae786e737f73f519a4a736421c139bf8bfdeff2424158f491b604
[implement specialise using match rather than mgu
Helmut Grohne <grohne@cs.uni-bonn.de>**20150326085416
 Ignore-this: e03ffe1eff3e86719bf0a4b39e04a763
 
 When specialise is called, its first parameter is the result type of an
 application obtained from a type signature. Its second parameter is the type of
 a function or constructor looked up from the context. The difference between
 mgu and match here is that we forbid the function type to restrict the result
 type further, which makes sense as the user explicitly requested the result
 type using a type signature.
] 
hash: 0000000843-2cec25f3e77e901bb735cd560b9f5ae7bab806a2cf26d7f1b012546ca38fbfa3
[remove dead methods mgu and unify
Helmut Grohne <grohne@cs.uni-bonn.de>**20150326085742
 Ignore-this: d98f91fb948f90ed82745fbe8d3c368c
] 
hash: 0000003046-1d21652c64086895c60ccc0f95d9971932633cecc897e9bdd6538932452b798b
[speed up instance Term TExp method equal
Helmut Grohne <grohne@cs.uni-bonn.de>**20150327153749
 Ignore-this: ad7565a7b9de1f2ff0ea12e562b0db9b
 
 Speeds up test suite by about 3%. The key here is to spell out the case for
 TAppE and avoid calling sameTy on TAppE as this computes types. Also avoid
 calling subterms on TAppE which would call unfoldTAppE.
] 
hash: 0000001189-bd006f7fdd61908680fa16b0ffbc5dab012b3a469b1b59157fe25482775c81b5
[aunify: vimap lookups do use equal
Helmut Grohne <grohne@cs.uni-bonn.de>**20150330114217
 Ignore-this: a26019c1d52a9fd829b3ab235a32665b
 
 For TExp (==) is equal already, so this change just drops the isWild and makes
 the use of equal explicit.
 
 This is correct, because we never allow wildcards in a LHS. Once they occur in
 a RHS, they do not contribute to a binding but end up in the vimap anyway. They
 therefore need to be ignored during lookups as well.
] 
hash: 0000000639-3877a8848748c595983426f33849158144e4b8246698f691fa9416a770e3d41a
[remove fromVar from class Term
Helmut Grohne <grohne@cs.uni-bonn.de>**20150330143850
 Ignore-this: bfc7bfad917288de9d737111fb84d047
 
 fromVar is prone to error, so replace it with a new method getVar yielding a
 Maybe. Then isVar gains a default implementation. All users of fromVar are
 switched to getVar using a new helper foldTerm.
 
 Note that getVarNames now really returns a unique list unlike the original
 implementation which could collect variables with equal names and different
 types multiple times, but all callers do expect a unique list.
] 
hash: 0000001614-39985446f559382d7306f922f3e6974f92c088ae9bd4f738ba283cdf02450259
[Rename MatchingTypes destructor to stick with the QuickCheck convention
tobias@goedderz.info**20150327121346
 Ignore-this: ff3e5de12ec484e0b128229fc420101b
] 
hash: 0000000227-8a1c4ce36062dd47f451cda186801019ddbd0a0e82d79b6f9d4f2f9ae6c1914c
[Added destructors for BnbNode for better readability and easier addition of fields.
tobias@goedderz.info**20150330095559
 Ignore-this: 2bbe5e121985bb0fdc9bc507042b6165
] 
hash: 0000003034-3d0e121f0150b7bc4c829cf6cb87d4c32f13e5023370ef9c92a6ccf379126aa0
[make sectionType O(1)
Helmut Grohne <grohne@cs.uni-bonn.de>**20150331124443
 Ignore-this: f9a718a1cf4caa2a69a99b61b0963ef2
 
 Previously it would be O(number of arrows) and since it can be called a lot,
 this can become a bottleneck.
] 
hash: 0000000647-d88485056b79cc89545504a00e6b1560db950d61843e8be6beed33beda4c555e
[also make sameSymAtRoot on TExp O(1)
Helmut Grohne <grohne@cs.uni-bonn.de>**20150331130037
 Ignore-this: 6dae246e31beace52ea59ba42bb41308
 
 Saves 2.5% runtime on the test suite.
] 
hash: 0000000399-e1daf0ba50b596092e6da9a296f9969a85259286430994826423aa4f57fa9a72
[Added a Size instance for Type
tobias@goedderz.info**20150326091807
 Ignore-this: d7dad3b1c30bd379d860d0adbc6f6bcb
] 
hash: 0000000448-fca9df2b625d6be953d06570f8ceec467ae700f309f071570984067eb61759d3
[Added a generator for type pairs, of which the right one is more general.
tobias@goedderz.info**20150326174238
 Ignore-this: d8bb9b79eeb6f81db275dae9994715da
 
 This is useful for testing "match", which should succeed iff its right argument
 is more general.
] 
hash: 0000004348-168c262a4c0404fdecc64cc6eb7bde8bc8fa7c3747d13878d5f9db7d07484f83
[Removed a leftover trace and added an explicit import of mapReaderT
tobias@goedderz.info**20150327123838
 Ignore-this: 324452496e57d7f1d458943e446f950c
] 
hash: 0000000328-2558ca7158914893c93c0fc310c83eca79749933e15db5ee0c1d5d91d425aaf4
[Imported all symbols from Syntax explicitly
tobias@goedderz.info**20150327124856
 Ignore-this: f930ce212edb8ebc568adc52545ca243
] 
hash: 0000000569-79907304628ce242914a24e0392bddfbd0111352cf3ebcf12b040ca21ca24720
[Added a TExp pair generator for match.
tobias@goedderz.info**20150327154722
 Ignore-this: 7d9ef689a9f6a36cbe5fd754740c12f9
 
 Both values are derived from the same TExp, but the left one is more special
 (i.e., some nodes are replaced with wildcards) and the right one is more general
 (i.e., some nodes are replaced with variables).
] 
hash: 0000002542-45ef08d9fb71caa0e38570f5375282431fcc79dbea91e593154fdf778f0ef634
[Refactored the MatchingTypes and ~TExps instances to share more code
tobias@goedderz.info**20150327171014
 Ignore-this: 41fbf4a31a1876b2e54f402950d2fd67
] 
hash: 0000003458-1f195bc88d7b931c907208f2455b061931052780a5fdd736d384baebe387f13f
[test symmetry of lgg using quickcheck
Helmut Grohne <grohne@cs.uni-bonn.de>**20150415144415
 Ignore-this: c005da85f8bb93bb4c3998411919dffe
] 
hash: 0000001136-7991923d83f115fd803e98728d17235520ba4ab5bbbd5772f1d26b61f9d6a28d
[QuickCheck: shrink TWildE
Helmut Grohne <grohne@cs.uni-bonn.de>**20150415144457
 Ignore-this: 7d2668e59a7e144507b870c9ee7abd50
] 
hash: 0000000214-dea83db51cf8718cb918cca16e59637ccbd3bf213b4ea398293ceb93add09f76
[add multiplication example IOs
Helmut Grohne <grohne@cs.uni-bonn.de>**20150415151210
 Ignore-this: e00cc3f970a9010048d69d8bd9ec4636
 
 Despite claims that igor2 cannot generate a multiplication function, it can do
 so when enabling accum within 70000 loops.
] 
hash: 0000000756-3935e7da57042b424fe44ba5c375f6c99d0767aa48b801867419cb65c5cb3290
[avoid a liftM in a hot path
Helmut Grohne <grohne@cs.uni-bonn.de>**20150416070712
 Ignore-this: b6c3ebdc3fc1f15a12a1b6411aed26c8
 
 This saves 3% on the first 2000 loops of mult and has little effect on anything
 else.
] 
hash: 0000000412-41f8be838cdf415c6f32cc09e029a8b56f2d9e6454357f5d29328bcd6788544e
[QuickCheck: only pass expressions with matching types to lgg
Helmut Grohne <grohne@cs.uni-bonn.de>**20150417155804
 Ignore-this: ebfb7c3320088dbe4bfc04a3563b56af
 
 It is not clear what the lgg of two wildcards or variables with different types
 should be.
] 
hash: 0000000800-a839fb58001165784635cdfeb2ab497dedfb7af3b320adef2d0c4f388a02b983
[QuickCheck: allow chooseLog to yield 0
Helmut Grohne <grohne@cs.uni-bonn.de>**20150508143725
 Ignore-this: 3e0d74554a56a7e7cdabc437a34cf088
 
 Before this change, chooseLog would always yield numbers >= 1. Thus
 MatchingTExps would replace at least one position with a wildcard and one
 position with a variable. Thus allowing 0 grows the example space.
] 
hash: 0000000562-2af5f5ba49f7ccd087765a7c68fe2f87fdc7f7e2f1e685d0c8aea0b73320c926
[QuickCheck: improve distribution of randomPossWithSubterms
Helmut Grohne <grohne@cs.uni-bonn.de>**20150508144054
 Ignore-this: 38361a0af7fab9999727622b0beeb486
 
 The number of non-overlapping positions in a term (after shuffling) can be
 significantly smaller than the number of leaf terms (its size). Thus
 randomPossWithSubterms would prefer to replace most positions.
 
] 
hash: 0000000737-35eb6742a9b8c16d6ad2dd5fee04e1055a3f4653c3137cc75cd1b7f866a0b443
[add quickcheck test about lgg/match compatibility
Helmut Grohne <grohne@cs.uni-bonn.de>**20150518132934
 Ignore-this: 98796c75cd6caaa43a40bea8143db85e
] 
hash: 0000001190-76db6e19dec2cb5ddfe58e6c26a512ffc1b44c219eddb0e1125123f0af7575c7
[fix Unify instance for TExp to be compatible with AUnify
Helmut Grohne <grohne@cs.uni-bonn.de>**20150519081327
 Ignore-this: 8883fdf62941c69b18aa242b723b8fb5
 
 Consider two TExps. t1 is a wildcard and t2 is a variable. The lgg of those
 will result in a variable t3. Now we expect that match t1 t3 succeeds and that
 applying the resulting substitution on t3 gives something `equal` to t1.
 However, that match previously failed.
 
 Now the question arises whether match t2 t1 should succeed. Previously, it did
 with the empty substitution. Yet, it seems strange to allow replacing a
 variable (t2) with a wildcard (t1) on a rhs as this weakens the specification.
 
 Thus the wildcard position in match is reversed now.
] 
hash: 0000000897-18c3d2f0bae4f4637c27308ecbf7eecdc117a9f1c986093d76e78fc20ed21ba6
[quickcheck: simplify computation of free names
Helmut Grohne <grohne@cs.uni-bonn.de>**20150519090602
 Ignore-this: a2412662051b922e987542b42e05c2a5
] 
hash: 0000001130-57e9925b7cbdccf62b1a8034b9ada3347007988af62b9e5fcc6c09c0578a77df
[add a slow mult integration test using accum
Helmut Grohne <grohne@cs.uni-bonn.de>**20150520092616
 Ignore-this: a2d8f68f9b96143bad1170956e1ef794
 
 Runs an hour or so.
] 
hash: 0000011533-027c0e2e0911b6e8bbe1f7b6fa9f771d18b99b948aa914cd9a181486535ca956
[add predicate anySubterm
Helmut Grohne <grohne@cs.uni-bonn.de>**20150522114730
 Ignore-this: 18fec7b18695ead84368b07b0b760e74
] 
hash: 0000000371-547813439d4619bae660c82ef5410fb45264809806e126f701f4e989f3a84f74
[fix wrong hypotheses generated from direct call
Helmut Grohne <grohne@cs.uni-bonn.de>**20150522115033
 Ignore-this: b902aa608385e9cd9d7b11ba35de6010
 
 In the direct call a small example for the caller is selected. If that example
 happens to have a wildcard on its rhs, the compatibility check always succeeds
 due to the implementation of (==) using equal for TExp. We are assuming
 transitivity here, but (==) isn't transitive. Thus add an extra check that
] 
hash: 0000002542-4fcc19c44488f837be772aea21d88b7ea20ec563aa942563b2ae8029bb3315cf
[add a regression test for direct call missbehaviour
Helmut Grohne <grohne@cs.uni-bonn.de>**20150522115348
 Ignore-this: 780c714e8498c75068ca59d3fad1bc99
] 
hash: 0000004292-c238141f9d4b740d66f343f9d4b0c2bebbccc76119062e64c8548b4277dc702d
[adapt type of allMatchings to match bestMatchings
Helmut Grohne <grohne@cs.uni-bonn.de>**20150902090638
 Ignore-this: bf7c8c9267c3576a15675bcaf0e6f8c1
 
 allMatchings is no longer used, but it serves as documentation for the old way
 of doing things. In the mean time the type of bestMatchings changed, so
 allMatchings was no longer a drop-in replacement.
] 
hash: 0000007090-ef90704f420358da9a26aaef9445530daa47aae9f8eb7216effcb0240c1ca501
[drop dependency on MonadCatchIO-mtl
Helmut Grohne <grohne@cs.uni-bonn.de>**20150908094124
 Ignore-this: fac7d0e3c4facb314faadf88f85ca867
 
 With the fix "fix build with more recent hint or something else", we
 effectively moved from using MonadCatchIO-mtl to using exceptions, but the old
 dependency was not dropped. Drop it now.
] 
hash: 0000000459-e4a803f0d6b8acef43994c37c8a2b4cd257bbda41a0c3532d421955345fef7ca
[make our bestMatchings behaviour opt-out
Helmut Grohne <grohne@cs.uni-bonn.de>**20150909121806
 Ignore-this: 96f9d94b30f4bb78dd509691d483ba00
 
 Due to our tests we converted the RuleDevelopment.Matching to only use
 matchings with an optimal number of closed parameter functions. Add a setting
 "-greedyMtch" to revert to the old behavior to be able to compare the
 improvement.
] 
hash: 0000003343-227438994245458eac34e055d9036445dcc229e8ba41c193429a911a6cf0c88a
[fix compatibility with GHC 7.10
Helmut Grohne <grohne@cs.uni-bonn.de>**20150909123939
 Ignore-this: fb5fb9cbcd4a04e1e22b08f68ec84742
 
 The new Prelude exports (<$>) as part of Functor, but Igor2 uses the same name
 from Text.PrettyPrint.ANSI.Leijen in many places. The simplest way around is to
 hide the new Prelude symbol.
] 
hash: 0000001473-0113937b4110f117651fa5e6cc26f4af1e7775ca08b75f5e1d21cf6a988ee41e
