anchor.diff:  
   
   let [<Test>] ``struct records support [<CustomEquality>]`` () =
  -    Check.QuickThrowOnFailure <|
  -    fun (i1:int) (i2:int) ->
  -        let sr1 = { C1 = i1; C2 = i2 }
  -        let sr2 = { C1 = i1; C2 = i2 }
  -        (sr1.Equals sr2)      
  +    let i1, i2 = 0, 4
  +    let sr1 = { C1 = i1; C2 = i2 }
  +    let sr2 = { C1 = i1; C2 = i2 }
  +    Assert.IsTrue (sr1.Equals sr2)      
   
   
   let [<Test>] ``struct records support [<CustomComparison>]`` () =
  -    Check.QuickThrowOnFailure <|
  -    fun (i1:int) (i2:int) (k1:int) (k2:int) ->        
  -        let sr1 = { C1 = i1; C2 = i2 }
  -        let sr2 = { C1 = k1; C2 = k2 }
  -        if   sr1 > sr2 then compare sr1 sr2 = 1
  +    let i1,i2,k1,k2 = 0,2,4,8
  +    let sr1 = { C1 = i1; C2 = i2 }
  +    let sr2 = { C1 = k1; C2 = k2 }
  +    Assert.IsTrue
  +       (if   sr1 > sr2 then compare sr1 sr2 = 1
           elif sr1 < sr2 then compare sr1 sr2 = -1
           elif sr1 = sr2 then compare sr1 sr2 = 0
  -        else false
  +        else false)
   
   
   let [<Test>] ``struct records hold [<CustomComparison>] [<CustomEquality>] metadata`` () =
  
positive.code: 
  
  let [<Test>] ``struct records are comparable`` () =
      Check.QuickThrowOnFailure <|
      fun (i1:int) (i2:int) ->
          i1 <> i2 ==>
          let sr1 = { C = i1; D = i2 }
          let sr2 = { C = i1; D = i2 }
          (sr1 = sr2)                    |@ "sr1 = sr2" .&.
          ({ sr1 with C = sr1.D} <> sr2) |@ "{sr1 with C = sr1.D} <> sr2" .&.
          (sr1.Equals sr2)               |@ "sr1.Equals sr2"
  
  
  let [<Test>] ``struct records support pattern matching`` () =
      Check.QuickThrowOnFailure <|
      fun (i1:int) (i2:int) ->
          let sr1 = { C = i1; D = i2 }
          (match sr1 with
          | { C = c; D = d } when c = i1 && d = i2 -> true
          | _ -> false) 
          |@ "with pattern match on struct record" .&.
          (sr1 |> function 
          | { C = c; D = d } when c = i1 && d = i2 -> true
          | _ -> false)
          |@ "function pattern match on struct record"
  
  
  let [<Test>] ``struct records support let binds using `` () =
      Check.QuickThrowOnFailure <|
      fun (i1:int) (i2:int) ->
          let sr1 = { C = i1; D = i2 }
          let { C = c1; D = d2 } as sr2 = sr1
          (sr1 = sr2)          |@ "sr1 = sr2" .&.
          (c1 = i1 && d2 = i2) |@ "c1 = i1 && d2 = i2"
  
  
  let [<Test>] ``struct records support function argument bindings`` () =
      Check.QuickThrowOnFailure <|
      fun (i1:int) (i2:int) ->
          let sr1 = { C = i1; D = i2 }
          let test sr1 ({ C = c1; D = d2 } as sr2) =
              sr1 = sr2 && c1 = i1 && d2 = i2
          test sr1 sr1      
          
          
  [<Struct>]
  
negative.code: 
  
  let [<Test>] ``struct records have correct behaviour with a [<DefaultValue>] on a ref type field`` () =
      let i1, i2 = 0, 4
      let s = { C = i1; D = i2 }
      let r1 = { R2 = s }
      Assert.IsTrue (obj.ReferenceEquals (r1.R1, null)) 
      Assert.IsTrue (r1.R2 = { C = i1; D = i2 })        
  
  
  [<Struct>]
  