anchor.diff:      testCase "incr works" <| fun () ->
           let i = ref 5
           incr i
  -        equal(!i, 6)
  +        !i |> equal 6
   
       testCase "decr works" <| fun () ->
           let i = ref 5
           decr i
  -        equal(!i, 4)
  +        !i |> equal 4
   
       testCase "System.Random works" <| fun () ->
           let rnd = System.Random()
           let x = rnd.Next(5)
  -        equal(true, x >= 0 && x < 5)
  +        (x >= 0 && x < 5) |> equal true
   
           let y = rnd.NextDouble()
  -        equal(true, y >= 0.0 && y < 1.0)
  +        (y >= 0.0 && y < 1.0) |> equal true
   
       // Note: Test could fail sometime during life of universe, if it picks all zeroes.
       testCase "System.Random.NextBytes works" <| fun () ->
           let buffer = Array.create 16 0uy // guid-sized buffer
           System.Random().NextBytes(buffer)
  -        equal(buffer = Array.create 16 0uy, false)
  +        buffer = Array.create 16 0uy |> equal false
   
       testCase "Long integers equality works" <| fun () ->
           let x = 5L
           let y = 5L
           let z = 6L
  -        equal(true, (x = y))
  -        equal(false, (y = z))
  -        equal(true, equals y x)
  -        equal(false, equals z x)
  +        (x = y) |> equal true
  +        (y = z) |> equal false
  +        equals y x |> equal true
  +        equals z x |> equal false
   
       testCase "Long integers comparison works" <| fun () ->
           let x = 5L
           let y = 5L
           let z = 6L
  -        equal(0, compare x y)
  -        equal(-1, compare y z)
  -        equal(0, compareTo y x)
  -        equal(1, compareTo z x)
  +        compare x y |> equal 0
  +        compare y z |> equal -1
  +        compareTo y x |> equal 0
  +        compareTo z x |> equal 1
   
       testCase "bigint equality works" <| fun () ->
           let a = 9007199254740992I
           let b = 9007199254740993I
  -        equal(false, (a = b))
  +        (a = b) |> equal false
   
       testCase "Big integers equality works" <| fun () ->
           let x = 59823749821707124891298739821798327321028091380980I
           let y = 59823749821707124891298739821798327321028091380980I
           let z = 59823749821707124891298739821798327321028091380981I
  -        equal(true, (x = y))
  -        equal(false, (y = z))
  -        equal(true, equals y x)
  -        equal(false, equals z x)
  +        (x = y) |> equal true
  +        (y = z) |> equal false
  +        equals y x |> equal true
  +        equals z x |> equal false
   
       testCase "Big integers comparison works" <| fun () ->
           let x = 5I
           let y = 5I
           let z = 6I
  -        equal(0, compare x y)
  -        equal(-1, compare y z)
  -        equal(0, compareTo y x)
  -        equal(1, compareTo z x)
  +        compare x y |> equal 0
  +        compare y z |> equal -1
  +        compareTo y x |> equal 0
  +        compareTo z x |> equal 1
   
       testCase "Big integer to byte array works" <| fun () ->
           // values with high bit both 0 and 1 for different array lengths
  -        equal(32767I.ToByteArray(), [|255uy; 127uy|])
  -        equal(32768I.ToByteArray(), [|0uy; 128uy; 0uy|])
  -        equal(-32768I.ToByteArray(), [|0uy; 128uy|])
  -        equal(-32769I.ToByteArray(), [|255uy; 127uy; 255uy|])
  +        32767I.ToByteArray() |> equal [|255uy; 127uy|]
  +        32768I.ToByteArray() |> equal [|0uy; 128uy; 0uy|]
  +        -32768I.ToByteArray() |> equal [|0uy; 128uy|]
  +        -32769I.ToByteArray() |> equal [|255uy; 127uy; 255uy|]
           // large numbers
  -        equal(111222333444555666777888999I.ToByteArray(), [|231uy; 216uy; 2uy; 164uy; 86uy; 149uy; 8uy; 199uy; 62uy; 0uy; 92uy|])
  -        equal(-111222333444555666777888999I.ToByteArray(), [|25uy; 39uy; 253uy; 91uy; 169uy; 106uy; 247uy; 56uy; 193uy; 255uy; 163uy|])
  +        111222333444555666777888999I.ToByteArray() |> equal [|231uy; 216uy; 2uy; 164uy; 86uy; 149uy; 8uy; 199uy; 62uy; 0uy; 92uy|]
  +        -111222333444555666777888999I.ToByteArray() |> equal [|25uy; 39uy; 253uy; 91uy; 169uy; 106uy; 247uy; 56uy; 193uy; 255uy; 163uy|]
   
       testCase "Big integer from byte array works" <| fun () ->
           // values with high bit both 0 and 1 for different array lengths
  -        equal(Numerics.BigInteger([|255uy; 127uy|]), 32767I)
  -        equal(Numerics.BigInteger([|0uy; 128uy; 0uy|]), 32768I)
  -        equal(Numerics.BigInteger([|0uy; 128uy|]), -32768I)
  -        equal(Numerics.BigInteger([|255uy; 127uy; 255uy|]), -32769I)
  +        Numerics.BigInteger([|255uy; 127uy|]) |> equal 32767I
  +        Numerics.BigInteger([|0uy; 128uy; 0uy|]) |> equal 32768I
  +        Numerics.BigInteger([|0uy; 128uy|]) |> equal -32768I
  +        Numerics.BigInteger([|255uy; 127uy; 255uy|]) |> equal -32769I
           // large numbers
  -        equal(Numerics.BigInteger([|231uy; 216uy; 2uy; 164uy; 86uy; 149uy; 8uy; 199uy; 62uy; 0uy; 92uy|]), 111222333444555666777888999I)
  -        equal(Numerics.BigInteger([|25uy; 39uy; 253uy; 91uy; 169uy; 106uy; 247uy; 56uy; 193uy; 255uy; 163uy|]), -111222333444555666777888999I)
  +        Numerics.BigInteger([|231uy; 216uy; 2uy; 164uy; 86uy; 149uy; 8uy; 199uy; 62uy; 0uy; 92uy|]) |> equal 111222333444555666777888999I
  +        Numerics.BigInteger([|25uy; 39uy; 253uy; 91uy; 169uy; 106uy; 247uy; 56uy; 193uy; 255uy; 163uy|]) |> equal -111222333444555666777888999I
   
       testCase "Member values of decimal type can be compared" <| fun () -> // See #747
  -        equal(true, decimalOne < decimalTwo)
  -        equal(false, decimalOne > decimalTwo)
  +        decimalOne < decimalTwo |> equal true
  +        decimalOne > decimalTwo |> equal false
   
       testCase "Sign operator works" <| fun () -> // See #1311
  -        equal(1, sign 1)
  -        equal(1, sign 34)
  -        equal(1, sign 1L)
  -        equal(1, sign 36L)
  -        equal(1, sign 1.)
  -        equal(1, sign 89)
  -        equal(1, sign 1)
  -        equal(0, sign 0)
  -        equal(0, sign 0L)
  -        equal(0, sign 0.)
  -        equal(-1, sign -1)
  -        equal(-1, sign -56)
  -        equal(-1, sign -1L)
  -        equal(-1, sign -72L)
  -        equal(-1, sign -1.)
  -        equal(-1, sign -89.)
  +        sign 1 |> equal 1
  +        sign 34 |> equal 1
  +        sign 1L |> equal 1
  +        sign 36L |> equal 1
  +        sign 1. |> equal 1
  +        sign 89 |> equal 1
  +        sign 1 |> equal 1
  +        sign 0 |> equal 0
  +        sign 0L |> equal 0
  +        sign 0. |> equal 0
  +        sign -1 |> equal -1
  +        sign -56 |> equal -1
  +        sign -1L |> equal -1
  +        sign -72L |> equal -1
  +        sign -1. |> equal -1
  +        sign -89. |> equal -1
   ]
positive.code:                       337.12M
                        6.08M
                        -924.8M ]
          equal (List.sum items, 0M)
  
      testCase "Decimal max precision is kept" <| fun () ->
          let pi = 3.141592653589793238462643383279502884197169399375105820974944592307816406286M
          equal (string pi, "3.1415926535897932384626433833")
  
      testCase "Decimal average precision is kept" <| fun () ->
          let items = [1M; 2M; 5M]
          equal (List.average items, 2.6666666666666666666666666667M)
  
      testCase "Decimal division precision is kept" <| fun () ->
          equal (string (8M / 3M), "2.6666666666666666666666666667")
  
      testCase "Decimal Infix add works" <| fun () ->
          equal (4.0868M + 2.289348M, 6.376148M)
  
      testCase "Decimal Infix subtract works" <| fun () ->
          equal (4.0868M - 2.289348M, 1.797452M)
  
      testCase "Decimal Infix multiply works" <| fun () ->
          equal (4.0868M * 2.289348M, 9.3561074064M)
  
      testCase "Decimal Infix divide works" <| fun () ->
          equal (4M / 2M, 2M)
  
      testCase "Decimal Infix modulo works" <| fun () ->
          equal (4.0868M % 2.289348M, 1.797452M)
  
      testCase "Decimal.Add works" <| fun () ->
          equal (Decimal.Add(4.0868M, 2.289348M), 6.376148M)
  
      testCase "Decimal.Subtract works" <| fun () ->
          equal (Decimal.Subtract(4.0868M, 2.289348M), 1.797452M)
  
      testCase "Decimal.Multiply works" <| fun () ->
          equal (Decimal.Multiply(4.0868M, 2.289348M), 9.3561074064M)
  
      testCase "Decimal.Divide works" <| fun () ->
          equal (Decimal.Divide(4M, 2M), 2M)
  
      testCase "Decimal.Remainder works" <| fun () ->
          equal (Decimal.Remainder(4.0868M, 2.289348M), 1.797452M)
  
      testCase "Decimal.Negate works" <| fun () ->
          equal (Decimal.Negate(4M), -4M)
  
      testCase "Decimal Evaluation order is preserved by generated code" <| fun () ->
          equal ((4.4567M - 2.2234M) * 2.6492M + 1.2493M, 7.16575836M)
  
      testCase "Decimal constructors work" <| fun () ->
          let d = 1.2493M
          let bits = Decimal.GetBits(d)
          let d2 = Decimal(bits)
          let d3 = Decimal(bits.[0], bits.[1], bits.[2], false, 4uy)
          equal (d, d2)
          equal (d, d3)
  
      testCase "Decimal GetBits works" <| fun () ->
          let d = Decimal([| -1; -1; -2; 0 |])
          let bits = Decimal.GetBits(d)
          let d2 = Decimal(bits)
          let d3 = Decimal(bits.[0], bits.[1], bits.[2], true, 0uy)
          equal (d, d2)
          equal (-d, d3)
  
      testCase "Decimal abs works" <| fun () ->
          equal (abs -4M, 4M)
  
      testCase "Decimal round works" <| fun () ->
          equal (round -12.5M, -12.M)
          equal (round 1.5M, 2.M)
          equal (round 1.535M, 2.M)
          equal (round 1.525M, 2.M)
          equal (Math.Round 1.425M, 1.M)
          equal (Math.Round -1.425M, -1.M)
          equal (Math.Round 1.546M, 2.M)
          equal (Math.Round -1.546M, -2.M)
  
      testCase "Decimal round with digits works" <| fun () ->
          equal(Math.Round(1.426M, 2), 1.43M)
          equal(Math.Round(1.426M, 1), 1.4M)
          equal(Math.Round(-1.426M, 2), -1.43M)
          equal(Math.Round(-1.426M, 1), -1.4M)
  
      testCase "Decimal truncate works" <| fun () ->
          equal(Math.Truncate -12.5M, -12.M)
          equal(Math.Truncate 1.425M, 1.M)
          equal(Math.Truncate -1.425M, -1.M)
          equal(Math.Truncate 1.546M, 1.M)
          equal(Math.Truncate -1.546M, -1.M)
  
      testCase "Decimal ceil works" <| fun () ->
          equal (ceil 11.25M, 12.M)
          equal (ceil -11.25M, -11.M)
          equal (Math.Ceiling 11.25M, 12.M)
  
      testCase "Decimal floor works" <| fun () ->
          equal (floor 11.75M, 11.M)
          equal (floor -11.75M, -12.M)
          equal (Math.Floor 11.25M, 11.M)
  
      testCase "Decimal pown works" <| fun () ->
          equal (pown 2.2M 3, 10.648M)
  
      testCase "Int64 Infix add can be generated" <| fun () ->
          equal (4L + 2L, 6L)
  
      testCase "Int64 Infix subtract can be generated" <| fun () ->
          equal (4L - 2L, 2L)
  
      testCase "Int64 Infix multiply can be generated" <| fun () ->
          equal (4L * 2L, 8L)
  
      testCase "Int64 Infix divide can be generated" <| fun () ->
          equal (4L / 2L, 2L)
  
      testCase "Int64 Integer division doesn't produce floats" <| fun () ->
          equal (5. / 2., 2.5)
          equal (5L / 2L, 2L)
          equal (5L / 3L, 1L)
          // equal (float 5L / 2., 2.5) // TODO: Number conversion
  
      testCase "Int64 Infix modulo can be generated" <| fun () ->
          equal (4L % 3L, 1L)
  
      testCase "Int64 Evaluation order is preserved by generated code" <| fun () ->
          equal ((4L - 2L) * 2L + 1L, 5L)
  
      testCase "Int64 Bitwise and can be generated" <| fun () ->
          equal (6L &&& 2L, 2L)
  
      testCase "Int64 Bitwise or can be generated" <| fun () ->
          equal (4L ||| 2L, 6L)
  
      testCase "Int64 Bitwise shift left can be generated" <| fun () ->
          equal (4L <<< 2, 16L)
  
      testCase "Int64 Bitwise shift right can be generated" <| fun () ->
          equal (4L >>> 2, 1L)
  
      testCase "UInt64 Bitwise shift right can be generated" <| fun () -> // See #1482
        equal (15210016002388773605UL >>> 33, 1770678907UL)
  
      testCase "Int64 abs works" <| fun () ->
          equal (abs -4L, 4L)
  
      testCase "Big integers addition works" <| fun () ->
          let x = 59823749821707124891298739821798327321028091380980I
          let y = bigint 1L
          let z = 1I
          equal(59823749821707124891298739821798327321028091380982I, (x + y + z))
  
      testCase "BigInt Infix add can be generated" <| fun () ->
          equal (4I + 2I, 6I)
  
      testCase "BigInt Infix subtract can be generated" <| fun () ->
          equal (4I - 2I, 2I)
  
      testCase "BigInt Infix multiply can be generated" <| fun () ->
          equal (4I * 2I, 8I)
  
      testCase "BigInt Infix divide can be generated" <| fun () ->
          equal (4I / 2I, 2I)
  
      testCase "BigInt Integer division doesn't produce floats" <| fun () ->
          equal (5. / 2., 2.5)
          equal (5I / 2I, 2I)
          equal (5I / 3I, 1I)
          // equal (float 5I / 2., 2.5)
  
      testCase "BigInt Infix modulo can be generated" <| fun () ->
          equal (4I % 3I, 1I)
  
      testCase "BigInt.DivRem works" <| fun () -> // See #1744
          let quotient,remainder = bigint.DivRem(5I,2I)
          equal(quotient, 2I)
          equal(remainder, 1I)
  
      testCase "BigInt Evaluation order is preserved by generated code" <| fun () ->
          equal ((4I - 2I) * 2I + 1I, 5I)
  
      testCase "BigInt Bitwise and can be generated" <| fun () ->
          equal (6I &&& 2I, 2I)
  
      testCase "BigInt Bitwise or can be generated" <| fun () ->
          equal (4I ||| 2I, 6I)
  
      testCase "BigInt Bitwise xor can be generated" <| fun () ->
          equal (6I ^^^ 2I, 4I)
  
      testCase "BigInt Bitwise shift left can be generated" <| fun () ->
          equal (4I <<< 2, 16I)
  
      testCase "BigInt Bitwise shift right can be generated" <| fun () ->
          equal (4I >>> 2, 1I)
  
      testCase "BigInt abs works" <| fun () ->
          equal (abs -4I, 4I)
  
      testCase "abs works" <| fun () ->
          equal (abs -4, 4)
  
      testCase "round works" <| fun () ->
          equal (round -12.5, -12.)
          equal (round 1.5, 2.)
          equal (round 1.535, 2.)
          equal (round 1.525, 2.)
  
      testCase "ceil works" <| fun () ->
          equal (ceil 11.25, 12.)
          equal (ceil -11.25, -11.)
          equal (Math.Ceiling 11.25, 12.)
  
      testCase "floor works" <| fun () ->
          equal (floor 11.75, 11.)
          equal (floor -11.75, -12.)
          equal (Math.Floor 11.25, 11.)
  
      testCase "pown works" <| fun () ->
          pown 2.2 3 |> checkTo3dp 10648.
  
negative.code:         checkTo3dp 2718. Math.E
  
      testCase "Math.abs works" <| fun () ->
          Math.Abs -4 |> equal 4
  
      testCase "Math.pown works" <| fun () ->
          Math.Pow(2.2, 3.0) |> checkTo3dp 10648.
  