[add a slow mult integration test using accum
Helmut Grohne <grohne@cs.uni-bonn.de>**20150520092616
 Ignore-this: a2d8f68f9b96143bad1170956e1ef794
 
 Runs an hour or so.
] 
<
[When adding IOData, give all variables a new, unique name.
tobias@goedderz.info**20150213164747
 Ignore-this: 5fe929e5fcb80e702f15bf790b69731
] 
[make igor2 compile on ghc 7.4.2 and current hackages
Helmut Grohne <grohne@cs.uni-bonn.de>**20131217133624
 Ignore-this: ec4be18819806ae8821ae058e4cccda1
] 
[Replaced type ELT with newtype ELT; files depending on Logger.hs are still broken.
tobias@goedderz.info**20140716144805
 Ignore-this: 9a0a0c29c5d0558ab4848c597160c9a4
] 
[Fixed usages of lift on LM and ELT types
tobias@goedderz.info**20140717102434
 Ignore-this: 184c6a37204db852f905c6a87ecb9571
] 
[Few minor changes for readability.
tobias@goedderz.info**20150114123248
 Ignore-this: 70913a295974b9566170546f7877528c
] 
[Made some instances polymorphic
tobias@goedderz.info**20140717105948
 Ignore-this: 81593f1f48a3398031208b852ce2237e
] 
[remove unneeded instances in Logger
Helmut Grohne <grohne@cs.uni-bonn.de>**20140717123954
 Ignore-this: bc53f7679628a8ac6efbea0a29ef14ca
] 
[get rid of lift4 and use liftIO instead
Helmut Grohne <grohne@cs.uni-bonn.de>**20140717072357
 Ignore-this: 2afcece0c24cde0f8dcb57a462633bf6
] 
[add MonadLog class to get rid of llog* and friends
Helmut Grohne <grohne@cs.uni-bonn.de>**20140717145205
 Ignore-this: fe9fdbcb5eba43a5adae97e7df2c1608
] 
[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
] 
[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.
] 
[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
] 
[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.
] 
[simplify isTuple and isAnyTuple without TemplateHaskell
Helmut Grohne <grohne@cs.uni-bonn.de>**20140717084230
 Ignore-this: 3bb9e59d15a53053c78df69001431229
] 
[work around unhandled runtime error passing by catchError
Helmut Grohne <grohne@cs.uni-bonn.de>**20140108073945
 Ignore-this: 60b21165b086517cb697ed19c7fe368e
] 
[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.
] 
[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.
] 
[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.
] 
[Updated test .out files to match the current behaviour
tobias@goedderz.info**20141229145445
 Ignore-this: 7e078cbbab9513e12647732973f44793
] 
[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.
] 
[set + simplify for all successful tests
Helmut Grohne <grohne@cs.uni-bonn.de>**20150113152955
 Ignore-this: e7547acbe5e91c1e4403a336d5410934
] 
[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.
] 
[move isWild to Syntax.Expression and export it
Helmut Grohne <grohne@cs.uni-bonn.de>**20150218123031
 Ignore-this: d9df4366f8267a6d03388e43b32621ab
] 
[replace various Data.Set.fromList with named constructors
Helmut Grohne <grohne@cs.uni-bonn.de>**20150123173834
 Ignore-this: 720d895cc70a9fa52c5a4f0fe8bb10b3
] 
[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.
] 
[Added a regression test for a bug introduced while replacing Subst by a Data.Map
tobias@goedderz.info**20150213104721
 Ignore-this: 989de578539492fac02cfedf7c6eea8e
] 
[add regression test for subfunction wildcard fix
Helmut Grohne <grohne@cs.uni-bonn.de>**20150218135521
 Ignore-this: 8c1226ad26031ebda54cdd763abb36f9
] 
[add regression test for the antiunifier wildcard handling
Helmut Grohne <grohne@cs.uni-bonn.de>**20150217144343
 Ignore-this: d5dc172c22237d2e1ec43e0c0398da22
] 
[Adds a new "accum" flag to the UI (which is not yet used).
tobias@goedderz.info**20150311135723
 Ignore-this: 49b691366666278a1f0f836a838624fc
] 
[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.
] 
[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.
] 
> addfile ./tests/slow/mult-accum.bat
hunk ./tests/slow/mult-accum.bat 1
+:load expl/Examples.hs
+:set +accum
+:set +simplify
+:generalise mult
+:test mult on "mult (S (S (S Z))) (S (S (S Z)))"
+:quit
addfile ./tests/slow/mult-accum.out
hunk ./tests/slow/mult-accum.out 1
+
+  .___                   ._ ._             
+  |   | ____  ____ ._____| || |  ._       
+  |   |/ __ \/  _ \|  __ \ || | _| |__ 
+  |   / /_/  ) <_> )  | \/ || |/_   _/   
+  |___\___  /\____/|__|  |_||_|  |_|    
+     /_____/                v0.8
+
+Welcome to IgorII. 
+Running IgorII in batch mode with file: tests/slow/mult-accum.bat
+
+      [1m- - - - START SYNTHESIS WITH - - - -[0m
+
+Targets              'mult'
+Background           <none>
+Simplified           True
+Greedy rule-splitting False
+Accumulators         True
+Enhanced             False
+Use paramorphisms    False
+Compare rec args     AWise
+DumpLog              False
+Debug                False
+Maximal tiers        0
+Maximal loops        -1
+
+      [1m- - - - - - - FINISHED - - - - - - -[0m
+
+             mult         in 63168     loops
+             
+
+                 [1mHYPOTHESIS 1 of 5[0m
+
+mult a0 a1 = fun1 a0 a1 Z
+fun1 _ (Z) a1 = a1
+fun1 a0 (S a1) a2 = fun1 a0 a1 (fun16 a0 (S a1) a2)
+fun16 (Z) (S _) a1 = a1
+fun16 (S a0) (S _) a2 = fun1 (S Z) a0 (S a2)
+
+
+
+                 [1mHYPOTHESIS 2 of 5[0m
+
+mult a0 a1 = fun1 a0 a1 Z
+fun1 _ (Z) a1 = a1
+fun1 a0 (S a1) a2 = fun1 a0 a1 (fun16 a0 (S a1) a2)
+fun16 (Z) (S _) a1 = a1
+fun16 (S a0) (S _) a2 = fun1 a0 (S Z) (S a2)
+
+
+
+                 [1mHYPOTHESIS 3 of 5[0m
+
+mult a0 a1 = fun1 a0 a1 Z
+fun1 _ (Z) a1 = a1
+fun1 a0 (S a1) a2 = fun1 a0 a1 (fun16 a0 (S a1) a2)
+fun16 (Z) (S _) a1 = a1
+fun16 (S a0) (S _) a2 = fun16 a0 (S (S Z)) (S a2)
+
+
+
+                 [1mHYPOTHESIS 4 of 5[0m
+
+mult a0 a1 = fun1 a0 a1 Z
+fun1 _ (Z) a1 = a1
+fun1 a0 (S a1) a2 = fun1 a0 a1 (fun16 a0 (S a1) a2)
+fun16 (Z) (S _) a1 = a1
+fun16 (S a0) (S a1) a2 = fun16 a0 (S a1) (S a2)
+
+
+
+                 [1mHYPOTHESIS 5 of 5[0m
+
+mult a0 a1 = fun1 a0 a1 Z
+fun1 _ (Z) a1 = a1
+fun1 a0 (S a1) a2 = fun1 a0 a1 (fun16 a0 (S a1) a2)
+fun16 (Z) (S _) a1 = a1
+fun16 (S a0) (S _) a2 = fun16 a0 (S Z) (S a2)
+
+Testing 1. hypothesis of: 'mult'
+  mult (S (S (S Z))) (S (S (S Z)))  ==  S (S (S (S (S (S (S (S (S Z))))))))
+
+Testing 2. hypothesis of: 'mult'
+  mult (S (S (S Z))) (S (S (S Z)))  ==  S (S (S (S (S (S (S (S (S Z))))))))
+
+Testing 3. hypothesis of: 'mult'
+  mult (S (S (S Z))) (S (S (S Z)))  ==  S (S (S (S (S (S (S (S (S Z))))))))
+
+Testing 4. hypothesis of: 'mult'
+  mult (S (S (S Z))) (S (S (S Z)))  ==  S (S (S (S (S (S (S (S (S Z))))))))
+
+Testing 5. hypothesis of: 'mult'
+  mult (S (S (S Z))) (S (S (S Z)))  ==  S (S (S (S (S (S (S (S (S Z))))))))
+
+...batch processing finished.
+Bye.