anchor.diff:      /// Test after-elimination of Booleans.
       [<TestCaseSource("AfterBools")>]
       member x.``After-elimination of Booleans should operate correctly`` b =
  -        (afterSubs OptimiserTests.AfterArithSubs OptimiserTests.AfterBoolSubs).BSub b 
  +        (afterSubs OptimiserTests.AfterArithSubs OptimiserTests.AfterBoolSubs)
  +            .BSub b
   
       /// Test cases for discovering Boolean after-before pairs.
       static member BoolAfterDiscoveries =
  
positive.code:             .SetName("Simplify !false as a tautology")
            TestCaseData(BAnd [BTrue; BTrue; BNot BFalse; bEq BFalse BFalse])
              .Returns(BTrue)
              .SetName("Simplify true&&true&&!false&&false==false as a tautology")
            TestCaseData(BImplies (BFalse, bEq BTrue BFalse))
              .Returns(BTrue)
              .SetName("Simplify false=>true==false as a tautology")
            TestCaseData(BNot BTrue)
              .Returns(BFalse)
              .SetName("Simplify !true as a contradiction")
            TestCaseData(BAnd [BTrue; BFalse; BNot BFalse; bEq BFalse BFalse])
              .Returns(BFalse)
              .SetName("Simplify true&&false&&!false&&false==false as a contradiction")
            TestCaseData(BImplies (BTrue, bEq BTrue BFalse))
              .Returns(BFalse)
              .SetName("Simplify true=>true==false as a contradiction") 
            TestCaseData(BImplies ((bAfter "s"), BFalse))
              .Returns(BNot (bAfter "s"))
              .SetName("Simplify =>False into a Negation") 
            TestCaseData(BImplies ((bAfter "s"), BTrue))
              .Returns(BTrue)
              .SetName("Simplify =>True into a True") 
            TestCaseData(BImplies (BGt ((aAfter "s"), (aAfter "t")), BFalse))
              .Returns(BLe ((aAfter "s"), (aAfter "t" )))
              .SetName("Simplify =>False wrapped around a > into <=") 
            TestCaseData(BImplies (BTrue, (bAfter "s")))
              .Returns((bAfter "s"))
              .SetName("Simplify True=>s into s") 
            TestCaseData(BImplies (BFalse, (bAfter "s")))
              .Returns(BTrue)
              .SetName("Simplify False=>s into True") 
              ]
  
       /// Test Boolean simplification
  
negative.code: 
      /// Test discovery of Boolean before-after pairs.
      [<TestCaseSource("BoolAfterDiscoveries")>]
      member x.``Boolean before-after pairs should be found correctly`` b =
          b |> findBoolAfters |> Map.ofList
  
      /// Test cases for substituting afters in a func.
      static member AfterFuncs =
          [ TestCaseData({ Name = "foo"
                           Params = [ AExpr (aAfter "serving")
                                      BExpr (bAfter "flag") ] })
              .Returns({ Name = "foo"
                         Params = [ AExpr (AAdd [aBefore "serving"; AInt 1L])
                                    BExpr (BNot (bBefore "flag")) ] })
              .SetName("Substitute afters in a func with all-after params") ]
  
      /// Test substitution of afters in funcs.
      [<TestCaseSource("AfterFuncs")>]
      member x.``Afters in func params should be substituted correctly`` f =
          let sub = afterSubs OptimiserTests.AfterArithSubs
                              OptimiserTests.AfterBoolSubs
          subExprInVFunc sub f
  
      /// Test cases for simplification.
  