anchor.diff:                        337.12M
                         6.08M
                         -924.8M ]
  -        equal (List.sum items, 0M)
  +        List.sum items |> equal 0M
   
       testCase "Decimal max precision is kept" <| fun () ->
           let pi = 3.141592653589793238462643383279502884197169399375105820974944592307816406286M
  -        equal (string pi, "3.1415926535897932384626433833")
  +        string pi |> equal "3.1415926535897932384626433833"
   
       testCase "Decimal average precision is kept" <| fun () ->
           let items = [1M; 2M; 5M]
  -        equal (List.average items, 2.6666666666666666666666666667M)
  +        List.average items |> equal 2.6666666666666666666666666667M
   
       testCase "Decimal division precision is kept" <| fun () ->
  -        equal (string (8M / 3M), "2.6666666666666666666666666667")
  +        string (8M / 3M) |> equal "2.6666666666666666666666666667"
   
       testCase "Decimal Infix add works" <| fun () ->
  -        equal (4.0868M + 2.289348M, 6.376148M)
  +        4.0868M + 2.289348M |> equal 6.376148M
   
       testCase "Decimal Infix subtract works" <| fun () ->
  -        equal (4.0868M - 2.289348M, 1.797452M)
  +        4.0868M - 2.289348M |> equal 1.797452M
   
       testCase "Decimal Infix multiply works" <| fun () ->
  -        equal (4.0868M * 2.289348M, 9.3561074064M)
  +        4.0868M * 2.289348M |> equal 9.3561074064M
   
       testCase "Decimal Infix divide works" <| fun () ->
  -        equal (4M / 2M, 2M)
  +        4M / 2M |> equal 2M
   
       testCase "Decimal Infix modulo works" <| fun () ->
  -        equal (4.0868M % 2.289348M, 1.797452M)
  +        4.0868M % 2.289348M |> equal 1.797452M
   
       testCase "Decimal.Add works" <| fun () ->
  -        equal (Decimal.Add(4.0868M, 2.289348M), 6.376148M)
  +        Decimal.Add(4.0868M, 2.289348M) |> equal 6.376148M
   
       testCase "Decimal.Subtract works" <| fun () ->
  -        equal (Decimal.Subtract(4.0868M, 2.289348M), 1.797452M)
  +        Decimal.Subtract(4.0868M, 2.289348M) |> equal 1.797452M
   
       testCase "Decimal.Multiply works" <| fun () ->
  -        equal (Decimal.Multiply(4.0868M, 2.289348M), 9.3561074064M)
  +        Decimal.Multiply(4.0868M, 2.289348M) |> equal 9.3561074064M
   
       testCase "Decimal.Divide works" <| fun () ->
  -        equal (Decimal.Divide(4M, 2M), 2M)
  +        Decimal.Divide(4M, 2M) |> equal 2M
   
       testCase "Decimal.Remainder works" <| fun () ->
  -        equal (Decimal.Remainder(4.0868M, 2.289348M), 1.797452M)
  +        Decimal.Remainder(4.0868M, 2.289348M) |> equal 1.797452M
   
       testCase "Decimal.Negate works" <| fun () ->
  -        equal (Decimal.Negate(4M), -4M)
  +        Decimal.Negate(4M) |> equal -4M
   
       testCase "Decimal Evaluation order is preserved by generated code" <| fun () ->
  -        equal ((4.4567M - 2.2234M) * 2.6492M + 1.2493M, 7.16575836M)
  +        (4.4567M - 2.2234M) * 2.6492M + 1.2493M |> equal 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)
  +        d2 |> equal d
  +        d3 |> equal d
   
       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)
  +        d2 |> equal d
  +        d3 |> equal -d
   
       testCase "Decimal abs works" <| fun () ->
  -        equal (abs -4M, 4M)
  +        abs -4M |> equal 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)
  +        round -12.5M |> equal -12.M
  +        round 1.5M |> equal 2.M
  +        round 1.535M |> equal 2.M
  +        round 1.525M |> equal 2.M
  +        Math.Round 1.425M |> equal 1.M
  +        Math.Round -1.425M |> equal -1.M
  +        Math.Round 1.546M |> equal 2.M
  +        Math.Round -1.546M |> equal -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)
  +        Math.Round(1.426M, 2) |> equal 1.43M
  +        Math.Round(1.426M, 1) |> equal 1.4M
  +        Math.Round(-1.426M, 2) |> equal -1.43M
  +        Math.Round(-1.426M, 1) |> equal -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)
  +        Math.Truncate -12.5M |> equal -12.M
  +        Math.Truncate 1.425M |> equal 1.M
  +        Math.Truncate -1.425M |> equal -1.M
  +        Math.Truncate 1.546M |> equal 1.M
  +        Math.Truncate -1.546M |> equal -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)
  +        ceil 11.25M |> equal 12.M
  +        ceil -11.25M |> equal -11.M
  +        Math.Ceiling 11.25M |> equal 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)
  +        floor 11.75M |> equal 11.M
  +        floor -11.75M |> equal -12.M
  +        Math.Floor 11.25M |> equal 11.M
   
       testCase "Decimal pown works" <| fun () ->
  -        equal (pown 2.2M 3, 10.648M)
  +        pown 2.2M 3 |> equal 10.648M
   
       testCase "Int64 Infix add can be generated" <| fun () ->
  -        equal (4L + 2L, 6L)
  +        4L + 2L |> equal 6L
   
       testCase "Int64 Infix subtract can be generated" <| fun () ->
  -        equal (4L - 2L, 2L)
  +        4L - 2L |> equal 2L
   
       testCase "Int64 Infix multiply can be generated" <| fun () ->
  -        equal (4L * 2L, 8L)
  +        4L * 2L |> equal 8L
   
       testCase "Int64 Infix divide can be generated" <| fun () ->
  -        equal (4L / 2L, 2L)
  +        4L / 2L |> equal 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
  +        5. / 2. |> equal 2.5
  +        5L / 2L |> equal 2L
  +        5L / 3L |> equal 1L
  +        // float 5L / 2. |> equal 2.5 // TODO: Number conversion
   
       testCase "Int64 Infix modulo can be generated" <| fun () ->
  -        equal (4L % 3L, 1L)
  +        4L % 3L |> equal 1L
   
       testCase "Int64 Evaluation order is preserved by generated code" <| fun () ->
  -        equal ((4L - 2L) * 2L + 1L, 5L)
  +        (4L - 2L) * 2L + 1L |> equal 5L
   
       testCase "Int64 Bitwise and can be generated" <| fun () ->
  -        equal (6L &&& 2L, 2L)
  +        6L &&& 2L |> equal 2L
   
       testCase "Int64 Bitwise or can be generated" <| fun () ->
  -        equal (4L ||| 2L, 6L)
  +        4L ||| 2L |> equal 6L
   
       testCase "Int64 Bitwise shift left can be generated" <| fun () ->
  -        equal (4L <<< 2, 16L)
  +        4L <<< 2 |> equal 16L
   
       testCase "Int64 Bitwise shift right can be generated" <| fun () ->
  -        equal (4L >>> 2, 1L)
  +        4L >>> 2 |> equal 1L
   
       testCase "UInt64 Bitwise shift right can be generated" <| fun () -> // See #1482
  -      equal (15210016002388773605UL >>> 33, 1770678907UL)
  +      15210016002388773605UL >>> 33 |> equal 1770678907UL
   
       testCase "Int64 abs works" <| fun () ->
  -        equal (abs -4L, 4L)
  +        abs -4L |> equal 4L
   
       testCase "Big integers addition works" <| fun () ->
           let x = 59823749821707124891298739821798327321028091380980I
           let y = bigint 1L
           let z = 1I
  -        equal(59823749821707124891298739821798327321028091380982I, (x + y + z))
  +        (x + y + z) |> equal 59823749821707124891298739821798327321028091380982I
   
       testCase "BigInt Infix add can be generated" <| fun () ->
  -        equal (4I + 2I, 6I)
  +        4I + 2I |> equal 6I
   
       testCase "BigInt Infix subtract can be generated" <| fun () ->
  -        equal (4I - 2I, 2I)
  +        4I - 2I |> equal 2I
   
       testCase "BigInt Infix multiply can be generated" <| fun () ->
  -        equal (4I * 2I, 8I)
  +        4I * 2I |> equal 8I
   
       testCase "BigInt Infix divide can be generated" <| fun () ->
  -        equal (4I / 2I, 2I)
  +        4I / 2I |> equal 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)
  +        5. / 2. |> equal 2.5
  +        5I / 2I |> equal 2I
  +        5I / 3I |> equal 1I
  +        // float 5I / 2. |> equal 2.5
   
       testCase "BigInt Infix modulo can be generated" <| fun () ->
  -        equal (4I % 3I, 1I)
  +        4I % 3I |> equal 1I
   
       testCase "BigInt.DivRem works" <| fun () -> // See #1744
           let quotient,remainder = bigint.DivRem(5I,2I)
  -        equal(quotient, 2I)
  -        equal(remainder, 1I)
  +        2I |> equal quotient
  +        1I |> equal remainder
   
       testCase "BigInt Evaluation order is preserved by generated code" <| fun () ->
  -        equal ((4I - 2I) * 2I + 1I, 5I)
  +        (4I - 2I) * 2I + 1I |> equal 5I
   
       testCase "BigInt Bitwise and can be generated" <| fun () ->
  -        equal (6I &&& 2I, 2I)
  +        6I &&& 2I |> equal 2I
   
       testCase "BigInt Bitwise or can be generated" <| fun () ->
  -        equal (4I ||| 2I, 6I)
  +        4I ||| 2I |> equal 6I
   
       testCase "BigInt Bitwise xor can be generated" <| fun () ->
  -        equal (6I ^^^ 2I, 4I)
  +        6I ^^^ 2I |> equal 4I
   
       testCase "BigInt Bitwise shift left can be generated" <| fun () ->
  -        equal (4I <<< 2, 16I)
  +        4I <<< 2 |> equal 16I
   
       testCase "BigInt Bitwise shift right can be generated" <| fun () ->
  -        equal (4I >>> 2, 1I)
  +        4I >>> 2 |> equal 1I
   
       testCase "BigInt abs works" <| fun () ->
  -        equal (abs -4I, 4I)
  +        abs -4I |> equal 4I
   
       testCase "abs works" <| fun () ->
  -        equal (abs -4, 4)
  +        abs -4 |> equal 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.)
  +        round -12.5 |> equal -12.
  +        round 1.5 |> equal 2.
  +        round 1.535 |> equal 2.
  +        round 1.525 |> equal 2.
   
       testCase "ceil works" <| fun () ->
  -        equal (ceil 11.25, 12.)
  -        equal (ceil -11.25, -11.)
  -        equal (Math.Ceiling 11.25, 12.)
  +        ceil 11.25 |> equal 12.
  +        ceil -11.25 |> equal -11.
  +        Math.Ceiling 11.25 |> equal 12.
   
       testCase "floor works" <| fun () ->
  -        equal (floor 11.75, 11.)
  -        equal (floor -11.75, -12.)
  -        equal (Math.Floor 11.25, 11.)
  +        floor 11.75 |> equal 11.
  +        floor -11.75 |> equal -12.
  +        Math.Floor 11.25 |> equal 11.
   
       testCase "pown works" <| fun () ->
           pown 2.2 3 |> checkTo3dp 10648.
  
positive.code: let tests =
    testList "Arithmetic" [
      testCase "Infix add can be generated" <| fun () ->
          equal (4 + 2, 6)
  
      testCase "Int32 literal addition is optimized" <| fun () ->
          equal (aLiteral + 7, 12)
          equal (notALiteral + 7, 12)
  
      testCase "Unary negation with negative literal values works" <| fun () ->
          equal(345, -literalNegativeValue)
  
      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)
  
      testCase "Infix subtract can be generated" <| fun () ->
          equal (4 - 2, 2)
  
      testCase "Infix multiply can be generated" <| fun () ->
          equal (4 * 2, 8)
  
      testCase "Infix divide can be generated" <| fun () ->
          equal (4 / 2, 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
  
      testCase "Infix modulo can be generated" <| fun () ->
          equal (4 % 3, 1)
  
      testCase "Evaluation order is preserved by generated code" <| fun () ->
          equal ((4 - 2) * 2 + 1, 5)
  
      testCase "Bitwise and can be generated" <| fun () ->
          equal (6 &&& 2, 2)
  
      testCase "Bitwise or can be generated" <| fun () ->
          equal (4 ||| 2, 6)
  
      testCase "Bitwise shift left can be generated" <| fun () ->
          equal (4 <<< 2, 16)
  
      testCase "Bitwise shift left with unsigned integer works" <| fun () ->
          equal (1u <<< 31, 2147483648u)
  
      testCase "Bitwise OR on large unsigned integer works" <| fun () ->
          equal (0x80000000u ||| 0u, (0x80000000u ||| 0u >>> 0))
  
      testCase "Bitwise AND on large unsigned integer works" <| fun () ->
          equal (0x80000000u &&& 0xffffffffu, (0x80000000u &&& 0xffffffffu >>> 0))
  
      testCase "Bitwise XOR on large unsigned integer works" <| fun () ->
          equal (0x80000000u ^^^ 0u, (0x80000000u ^^^ 0u >>> 0))
  
      testCase "Bitwise Invert on large unsigned integer works" <| fun () ->
          equal ( ~~~0x80000000u, (~~~0x80000000u >>> 0))
  
      testCase "Bitwise shift right can be generated" <| fun () -> // See #1530
          equal (4 >>> 2, 1)
  
      testCase "Zero fill shift right (>>>) for uint32" <| fun () -> // See #646
          equal (0x80000000 >>> 1, -1073741824)
          equal (0x80000000u >>> 1, 1073741824u)
  
      testCase "UInt64 multiplication with 0 returns uint" <| fun () -> // See #1480
          equal (0x0UL * 0x1UL, 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)
  
      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")
  
      testCase "Decimal precision is kept" <| fun () ->
          let items = [ 290.8M
  
negative.code:     testCase "log works" <| fun () ->
          log 232.12 |> checkTo3dp 5447.
          checkTo3dp 1098. (log 3.0)
          log 0.0 |> equal negativeInfinity
          isNaN (log -2.0) |> equal true
          isNaN (log System.Double.NaN) |> equal true
          isNaN (log negativeInfinity) |> equal true
          log positiveInfinity |> equal positiveInfinity
  
      // https://github.com/dotnet/corefx/blob/master/src/System.Runtime.Extensions/tests/System/Math.cs#L239
      testCase "Math.Log(double, double) works" <| fun () ->
          Math.Log(8.0, 2.0) |> equal 3.0
          Math.Log(3.0, 3.0) |> equal 1.0
          Math.Log(14., 3.0) |> checkTo3dp 2402.
          Math.Log(0.0, 3.0) |> equal negativeInfinity
          Math.Log(positiveInfinity, 3.0) |> equal positiveInfinity
          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)) |> equal true
  
      testCase "log10 works" <| fun () ->
          log10 232.12 |> checkTo3dp 2365.
  