anchor.diff:  let ``Detect if the element is not in the set`` () =
       let actual = fromList [1; 2; 3]
       Assert.That(contains 4 actual, Is.False)
  +    
  +[<Test>]
  +[<Ignore("Remove to run test")>]
  +let ``Empty set is a subset of another empty set`` () =
  +    let left = empty
  +    let right = empty
  +    Assert.That(isSubsetOf left right, Is.True)
  +    
  +[<Test>]
  +[<Ignore("Remove to run test")>]
  +let ``Empty set is a subset of non-empty set`` () =
  +    let left = empty
  +    let right = singleton 1
  +    Assert.That(isSubsetOf left right, Is.True)
  +    
  +[<Test>]
  +[<Ignore("Remove to run test")>]
  +let ``Non-empty set is not a subset of empty set`` () =
  +    let left = singleton 1
  +    let right = empty
  +    Assert.That(isSubsetOf left right, Is.False)
  +    
  +[<Test>]
  +[<Ignore("Remove to run test")>]
  +let ``Set is a subset of set with exact same elements`` () =
  +    let left = fromList [1; 2; 3]
  +    let right = fromList [1; 2; 3]
  +    Assert.That(isSubsetOf left right, Is.True)
  +    
  +[<Test>]
  +[<Ignore("Remove to run test")>]
  +let ``Set is a subset of larger set with same elements`` () =
  +    let left = fromList [1; 2; 3]
  +    let right = fromList [4; 1; 2; 3]
  +    Assert.That(isSubsetOf left right, Is.True)
  +    
  +[<Test>]
  +[<Ignore("Remove to run test")>]
  +let ``Set is not a subset of set that does not contain its elements`` () =
  +    let left = fromList [1; 2; 3]
  +    let right = fromList [4; 1; 3]
  +    Assert.That(isSubsetOf left right, Is.False)
  +        
  +[<Test>]
  +[<Ignore("Remove to run test")>]
  +let ``The empty set is disjoint with itself`` () =
  +    let left = empty
  +    let right = empty
  +    Assert.That(isDisjointFrom left right, Is.True)    
  +    
  +[<Test>]
  +[<Ignore("Remove to run test")>]
  +let ``Empty set is disjoint with non-empty set`` () =
  +    let left = empty
  +    let right = singleton 1
  +    Assert.That(isDisjointFrom left right, Is.True)
  +    
  +[<Test>]
  +[<Ignore("Remove to run test")>]
  +let ``Non-empty set is disjoint with empty set`` () =
  +    let left = singleton 1
  +    let right = empty
  +    Assert.That(isDisjointFrom left right, Is.True)
  +    
  +[<Test>]
  +[<Ignore("Remove to run test")>]
  +let ``Sets are not disjoint if they share an element`` () =
  +    let left = fromList [1; 2]
  +    let right = fromList [2; 3]    
  +    Assert.That(isDisjointFrom left right, Is.False)
  +    
  +[<Test>]
  +[<Ignore("Remove to run test")>]
  +let ``Sets are disjoint if they share no elements`` () =
  +    let left = fromList [1; 2]
  +    let right = fromList [3; 4]
  +    Assert.That(isDisjointFrom left right, Is.True)
  +
  +[<Test>]
  +[<Ignore("Remove to run test")>]
  +let ``Empty sets are equal`` () =
  +    let left = empty
  +    let right = empty
  +    Assert.That((left = right))
  +
  +[<Test>]
  +[<Ignore("Remove to run test")>]
  +let ``Empty set is not equal to non-empty set`` () =
  +    let left = empty
  +    let right = fromList [1; 2; 3]
  +    Assert.That(left <> right)
  +
  +[<Test>]
  +[<Ignore("Remove to run test")>]
  +let ``Non-empty set is not equal to empty set`` () =
  +    let left = fromList [1; 2; 3]
  +    let right = empty
  +    Assert.That(left <> right)
  +
  +[<Test>]
  +[<Ignore("Remove to run test")>]
  +let ``Sets with the same elements are equal`` () =
  +    let left = fromList [1; 2]
  +    let right = fromList [2; 1]
  +    Assert.That((left = right))
  +
  +[<Test>]
  +[<Ignore("Remove to run test")>]
  +let ``Sets with different elements are not equal`` () =
  +    let left = fromList [1; 2; 3]
  +    let right = fromList [1; 2; 4]
  +    Assert.That(left <> right)
   
   [<Test>]
   [<Ignore("Remove to run test")>]
  
positive.code:     let actual = fromList [1; 2; 3] |> insert 3
      let expected = fromList [1; 2; 3]
      Assert.That(actual, Is.EqualTo(expected))
      
  [<Test>]
  [<Ignore("Remove to run test")>]
  let ``Empty set is a subset of another empty set`` () =
      let left = empty
      let right = empty
      Assert.That(isSubsetOf left right, Is.True)
      
  [<Test>]
  [<Ignore("Remove to run test")>]
  let ``Empty set is a subset of non-empty set`` () =
      let left = empty
      let right = singleton 1
      Assert.That(isSubsetOf left right, Is.True)
      
  [<Test>]
  [<Ignore("Remove to run test")>]
  let ``Non-empty set is not a subset of empty set`` () =
      let left = singleton 1
      let right = empty
      Assert.That(isSubsetOf left right, Is.False)
      
  [<Test>]
  [<Ignore("Remove to run test")>]
  let ``Set is a subset of set with exact same elements`` () =
      let left = fromList [1; 2; 3]
      let right = fromList [1; 2; 3]
      Assert.That(isSubsetOf left right, Is.True)
      
  [<Test>]
  [<Ignore("Remove to run test")>]
  let ``Set is a subset of larger set with same elements`` () =
      let left = fromList [1; 2; 3]
      let right = fromList [4; 1; 2; 3]
      Assert.That(isSubsetOf left right, Is.True)
      
  [<Test>]
  [<Ignore("Remove to run test")>]
  let ``Set is not a subset of set that does not contain its elements`` () =
      let left = fromList [1; 2; 3]
      let right = fromList [4; 1; 3]
      Assert.That(isSubsetOf left right, Is.False)
          
  [<Test>]
  [<Ignore("Remove to run test")>]
  let ``The empty set is disjoint with itself`` () =
      let left = empty
      let right = empty
      Assert.That(isDisjointFrom left right, Is.True)    
      
  [<Test>]
  [<Ignore("Remove to run test")>]
  let ``Empty set is disjoint with non-empty set`` () =
      let left = empty
      let right = singleton 1
      Assert.That(isDisjointFrom left right, Is.True)
      
  [<Test>]
  [<Ignore("Remove to run test")>]
  let ``Non-empty set is disjoint with empty set`` () =
      let left = singleton 1
      let right = empty
      Assert.That(isDisjointFrom left right, Is.True)
      
  [<Test>]
  [<Ignore("Remove to run test")>]
  let ``Sets are not disjoint if they share an element`` () =
      let left = fromList [1; 2]
      let right = fromList [2; 3]    
      Assert.That(isDisjointFrom left right, Is.False)
      
  [<Test>]
  [<Ignore("Remove to run test")>]
  let ``Sets are disjoint if they share no elements`` () =
      let left = fromList [1; 2]
      let right = fromList [3; 4]
      Assert.That(isDisjointFrom left right, Is.True)
              
  [<Test>]
  [<Ignore("Remove to run test")>]
  
negative.code:     let left = fromList [1; 3]
      let right = fromList [2; 3]
      let expected = fromList [3; 2; 1]
      Assert.That(union left right = expected)