anchor.diff:  let tests =
     testList "Arithmetic" [
       testCase "Infix add can be generated" <| fun () ->
  -        equal (4 + 2, 6)
  +        4 + 2 |> equal 6
   
       testCase "Int32 literal addition is optimized" <| fun () ->
  -        equal (aLiteral + 7, 12)
  -        equal (notALiteral + 7, 12)
  +        aLiteral + 7 |> equal 12
  +        notALiteral + 7 |> equal 12
   
       testCase "Unary negation with negative literal values works" <| fun () ->
  -        equal(345, -literalNegativeValue)
  +        -literalNegativeValue |> equal 345
   
       testCase "Unary negation with integer MinValue works" <| fun () ->
  -        equal(-(-128y), System.SByte.MinValue)
  -        equal(-(-32768s), System.Int16.MinValue)
  -        equal(-(-2147483648), System.Int32.MinValue)
  -        equal(-(-9223372036854775808L), System.Int64.MinValue)
  +        -(-128y) |> equal System.SByte.MinValue
  +        -(-32768s) |> equal System.Int16.MinValue
  +        -(-2147483648) |> equal System.Int32.MinValue
  +        -(-9223372036854775808L) |> equal System.Int64.MinValue
   
       testCase "Infix subtract can be generated" <| fun () ->
  -        equal (4 - 2, 2)
  +        4 - 2 |> equal 2
   
       testCase "Infix multiply can be generated" <| fun () ->
  -        equal (4 * 2, 8)
  +        4 * 2 |> equal 8
   
       testCase "Infix divide can be generated" <| fun () ->
  -        equal (4 / 2, 2)
  +        4 / 2 |> equal 2
   
       testCase "Integer division doesn't produce floats" <| fun () ->
  -        equal (5. / 2., 2.5)
  -        equal (5 / 2, 2)
  -        equal (5 / 3, 1)
  -        // equal (float 5 / 2., 2.5) // TODO: Number conversion
  +        5. / 2. |> equal 2.5
  +        5 / 2 |> equal 2
  +        5 / 3 |> equal 1
  +        // float 5 / 2. |> equal 2.5 // TODO: Number conversion
   
       testCase "Infix modulo can be generated" <| fun () ->
  -        equal (4 % 3, 1)
  +        4 % 3 |> equal 1
   
       testCase "Evaluation order is preserved by generated code" <| fun () ->
  -        equal ((4 - 2) * 2 + 1, 5)
  +        (4 - 2) * 2 + 1 |> equal 5
   
       testCase "Bitwise and can be generated" <| fun () ->
  -        equal (6 &&& 2, 2)
  +        6 &&& 2 |> equal 2
   
       testCase "Bitwise or can be generated" <| fun () ->
  -        equal (4 ||| 2, 6)
  +        4 ||| 2 |> equal 6
   
       testCase "Bitwise shift left can be generated" <| fun () ->
  -        equal (4 <<< 2, 16)
  +        4 <<< 2 |> equal 16
   
       testCase "Bitwise shift left with unsigned integer works" <| fun () ->
  -        equal (1u <<< 31, 2147483648u)
  +        1u <<< 31 |> equal 2147483648u
   
       testCase "Bitwise OR on large unsigned integer works" <| fun () ->
  -        equal (0x80000000u ||| 0u, (0x80000000u ||| 0u >>> 0))
  +        0x80000000u ||| 0u |> equal (0x80000000u ||| 0u >>> 0)
   
       testCase "Bitwise AND on large unsigned integer works" <| fun () ->
  -        equal (0x80000000u &&& 0xffffffffu, (0x80000000u &&& 0xffffffffu >>> 0))
  +        0x80000000u &&& 0xffffffffu |> equal (0x80000000u &&& 0xffffffffu >>> 0)
   
       testCase "Bitwise XOR on large unsigned integer works" <| fun () ->
  -        equal (0x80000000u ^^^ 0u, (0x80000000u ^^^ 0u >>> 0))
  +        0x80000000u ^^^ 0u |> equal (0x80000000u ^^^ 0u >>> 0)
   
       testCase "Bitwise Invert on large unsigned integer works" <| fun () ->
  -        equal ( ~~~0x80000000u, (~~~0x80000000u >>> 0))
  +        (~~~0x80000000u >>> 0) |> equal ~~~0x80000000u
   
       testCase "Bitwise shift right can be generated" <| fun () -> // See #1530
  -        equal (4 >>> 2, 1)
  +        4 >>> 2 |> equal 1
   
       testCase "Zero fill shift right (>>>) for uint32" <| fun () -> // See #646
  -        equal (0x80000000 >>> 1, -1073741824)
  -        equal (0x80000000u >>> 1, 1073741824u)
  +        0x80000000 >>> 1 |> equal -1073741824
  +        0x80000000u >>> 1 |> equal 1073741824u
   
       testCase "UInt64 multiplication with 0 returns uint" <| fun () -> // See #1480
  -        equal (0x0UL * 0x1UL, 0x0UL)
  +        0x0UL * 0x1UL |> equal 0x0UL
   
       testCase "Decimal literals can be generated" <| fun () ->
  -        equal (System.Decimal.Zero, 0M)
  -        equal (System.Decimal.One, 1M)
  -        equal (System.Decimal.MinusOne, -1M)
  -        equal (System.Decimal.MaxValue, 79228162514264337593543950335M)
  -        equal (System.Decimal.MinValue, -79228162514264337593543950335M)
  +        0M |> equal System.Decimal.Zero
  +        1M |> equal System.Decimal.One
  +        -1M |> equal System.Decimal.MinusOne
  +        79228162514264337593543950335M |> equal System.Decimal.MaxValue
  +        -79228162514264337593543950335M |> equal System.Decimal.MinValue
   
       testCase "Decimal.ToString works" <| fun () ->
  -        equal (string 001.23456M, "1.23456")
  -        equal (string 1.23456M, "1.23456")
  -        equal (string 0.12345M, "0.12345")
  -        equal (string 0.01234M, "0.01234")
  -        equal (string 0.00123M, "0.00123")
  -        equal (string 0.00012M, "0.00012")
  -        equal (string 0.00001M, "0.00001")
  -        equal (string 0.00000M, "0.00000")
  -        equal (string 0.12300M, "0.12300")
  -        equal (string 0.0M, "0.0")
  -        equal (string 0M, "0")
  -        equal (string 1M, "1")
  -        equal (string -1M, "-1")
  -        equal (string 00000000000000000000000000000.M, "0")
  -        equal (string 0.0000000000000000000000000000M, "0.0000000000000000000000000000")
  -        equal (string 79228162514264337593543950335M, "79228162514264337593543950335")
  -        equal (string -79228162514264337593543950335M, "-79228162514264337593543950335")
  +        string 001.23456M |> equal "1.23456"
  +        string 1.23456M |> equal "1.23456"
  +        string 0.12345M |> equal "0.12345"
  +        string 0.01234M |> equal "0.01234"
  +        string 0.00123M |> equal "0.00123"
  +        string 0.00012M |> equal "0.00012"
  +        string 0.00001M |> equal "0.00001"
  +        string 0.00000M |> equal "0.00000"
  +        string 0.12300M |> equal "0.12300"
  +        string 0.0M |> equal "0.0"
  +        string 0M |> equal "0"
  +        string 1M |> equal "1"
  +        string -1M |> equal "-1"
  +        string 00000000000000000000000000000.M |> equal "0"
  +        string 0.0000000000000000000000000000M |> equal "0.0000000000000000000000000000"
  +        string 79228162514264337593543950335M |> equal "79228162514264337593543950335"
  +        string -79228162514264337593543950335M |> equal "-79228162514264337593543950335"
   
       testCase "Decimal precision is kept" <| fun () ->
           let items = [ 290.8M
  
positive.code:     testCase "log works" <| fun () ->
          log 232.12 |> checkTo3dp 5447.
          checkTo3dp 1098. (log 3.0)
          equal (log 0.0, negativeInfinity)
          equal (isNaN (log -2.0), true)
          equal (isNaN (log System.Double.NaN), true)
          equal (isNaN (log negativeInfinity), true)
          equal (log positiveInfinity, positiveInfinity)
  
      // https://github.com/dotnet/corefx/blob/master/src/System.Runtime.Extensions/tests/System/Math.cs#L239
      testCase "Math.Log(double, double) works" <| fun () ->
          equal (3.0, Math.Log(8.0, 2.0))
          equal (1.0, Math.Log(3.0, 3.0))
          Math.Log(14., 3.0) |> checkTo3dp 2402.
          equal (negativeInfinity, Math.Log(0.0, 3.0))
          equal (positiveInfinity, Math.Log(positiveInfinity, 3.0))
          equal (true, isNaN (Math.Log(-3.0, 3.0)))
          equal (true, isNaN (Math.Log(System.Double.NaN, 3.0)))
          equal (true, isNaN (Math.Log(negativeInfinity, 3.0)))
  
      testCase "log10 works" <| fun () ->
          log10 232.12 |> checkTo3dp 2365.
  
negative.code:     // As per https://github.com/dotnet/corefx/blob/master/src/System.Runtime.Extensions/tests/System/Math.cs#L217
      testCase "sqrt matches .net core implementation" <| fun () ->
          checkTo3dp 1732. (sqrt 3.0)
          sqrt 0.0  |> equal 0.0
          isNaN (sqrt -3.0) |> equal true
          isNaN (sqrt System.Double.NaN) |> equal true
          isNaN (sqrt negativeInfinity) |> equal true
          sqrt positiveInfinity |> equal positiveInfinity
  
      testCase "Double.Parse works with IFormatProvider" <| fun () ->
          // culture compiles to { } for now and it is ignored on the call-site
          let culture = Globalization.CultureInfo.InvariantCulture
          let result = System.Double.Parse("10.5", culture)
          result |> equal 10.5
  
      testCase "Single.Parse works with IFormatProvider" <| fun () ->
          // culture compiles to { } for now and it is ignored on the call-site
          let culture = Globalization.CultureInfo.InvariantCulture
          let result = System.Single.Parse("10.5", culture)
          float result |> equal 10.5
  
      testCase "acos works" <| fun () ->
          acos 0.25 |> checkTo3dp 1318.
  