New Set[Algebra] API

benchmark/single-source/SetTests.swift

@@ -13,7 +13,7 @@
 import TestsUtils
 
 @inline(never)
-public func run_SetIsSubsetOf(N: Int) {
+public func run_SetIsSubset(of N: Int) {
   let size = 200
 
   SRand()
@@ -28,7 +28,7 @@ public func run_SetIsSubsetOf(N: Int) {
 
   var isSubset = false;
   for _ in 0 ..< N * 5000 {
-    isSubset = set.isSubsetOf(otherSet)
+    isSubset = set.isSubset(of: otherSet)
     if isSubset {
       break
     }
@@ -57,7 +57,7 @@ public func run_SetExclusiveOr(N: Int) {
 
   var xor = Set<Int>()
   for _ in 0 ..< N * 100 {
-    xor = set.exclusiveOr(otherSet)
+    xor = set.symmetricDifference(otherSet)
   }
   sink(&xor)
 }
@@ -99,7 +99,7 @@ public func run_SetIntersect(N: Int) {
 
   var and = Set<Int>()
   for _ in 0 ..< N * 100 {
-    and = set.intersect(otherSet)
+    and = set.intersection(otherSet)
   }
   sink(&and)
 }
@@ -139,7 +139,7 @@ public func run_SetIsSubsetOf_OfObjects(N: Int) {
 
   var isSubset = false;
   for _ in 0 ..< N * 5000 {
-    isSubset = set.isSubsetOf(otherSet)
+    isSubset = set.isSubset(of: otherSet)
     if isSubset {
       break
     }
@@ -168,7 +168,7 @@ public func run_SetExclusiveOr_OfObjects(N: Int) {
 
   var xor = Set<Box<Int>>()
   for _ in 0 ..< N * 100 {
-    xor = set.exclusiveOr(otherSet)
+    xor = set.symmetricDifference(otherSet)
   }
   sink(&xor)
 }
@@ -210,7 +210,7 @@ public func run_SetIntersect_OfObjects(N: Int) {
 
   var and = Set<Box<Int>>()
   for _ in 0 ..< N * 100 {
-    and = set.intersect(otherSet)
+    and = set.intersection(otherSet)
   }
   sink(&and)
 }

stdlib/internal/SwiftExperimental/SwiftExperimental.swift

@@ -66,14 +66,14 @@ infix operator ⊉ { associativity left precedence 130 }
 public func ∖ <
   T, S: Sequence where S.Iterator.Element == T
   >(lhs: Set<T>, rhs: S) -> Set<T> {
-  return lhs.subtract(rhs)
+  return lhs.subtracting(rhs)
 }
 
 /// Assigns the relative complement between `lhs` and `rhs` to `lhs`.
 public func ∖= <
   T, S: Sequence where S.Iterator.Element == T
   >(lhs: inout Set<T>, rhs: S) {
-  lhs.subtractInPlace(rhs)
+  lhs.subtract(rhs)
 }
 
 /// - Returns: The union of `lhs` and `rhs`.
@@ -87,35 +87,35 @@ public func ∪ <
 public func ∪= <
   T, S: Sequence where S.Iterator.Element == T
   >(lhs: inout Set<T>, rhs: S) {
-  lhs.unionInPlace(rhs)
+  lhs.formUnion(rhs)
 }
 
 /// - Returns: The intersection of `lhs` and `rhs`.
 public func ∩ <
   T, S: Sequence where S.Iterator.Element == T
   >(lhs: Set<T>, rhs: S) -> Set<T> {
-  return lhs.intersect(rhs)
+  return lhs.intersection(rhs)
 }
 
 /// Assigns the intersection of `lhs` and `rhs` to `lhs`.
 public func ∩= <
   T, S: Sequence where S.Iterator.Element == T
   >(lhs: inout Set<T>, rhs: S) {
-  lhs.intersectInPlace(rhs)
+  lhs.formIntersection(rhs)
 }
 
 /// - Returns: A set with elements in `lhs` or `rhs` but not in both.
 public func ⨁ <
   T, S: Sequence where S.Iterator.Element == T
   >(lhs: Set<T>, rhs: S) -> Set<T> {
-  return lhs.exclusiveOr(rhs)
+  return lhs.symmetricDifference(rhs)
 }
 
 /// Assigns to `lhs` the set with elements in `lhs` or `rhs` but not in both.
 public func ⨁= <
   T, S: Sequence where S.Iterator.Element == T
   >(lhs: inout Set<T>, rhs: S) {
-  lhs.exclusiveOrInPlace(rhs)
+  lhs.formSymmetricDifference(rhs)
 }
 
 /// - Returns: True if `x` is in the set.
@@ -132,54 +132,54 @@ public func ∉ <T>(x: T, rhs: Set<T>) -> Bool {
 public func ⊂ <
   T, S: Sequence where S.Iterator.Element == T
   >(lhs: Set<T>, rhs: S) -> Bool {
-  return lhs.isStrictSubsetOf(rhs)
+  return lhs.isStrictSubset(of: rhs)
 }
 
 /// - Returns: True if `lhs` is not a strict subset of `rhs`.
 public func ⊄ <
   T, S: Sequence where S.Iterator.Element == T
   >(lhs: Set<T>, rhs: S) -> Bool {
-  return !lhs.isStrictSubsetOf(rhs)
+  return !lhs.isStrictSubset(of: rhs)
 }
 
 /// - Returns: True if `lhs` is a subset of `rhs`.
 public func ⊆ <
   T, S: Sequence where S.Iterator.Element == T
   >(lhs: Set<T>, rhs: S) -> Bool {
-  return lhs.isSubsetOf(rhs)
+  return lhs.isSubset(of: rhs)
 }
 
 /// - Returns: True if `lhs` is not a subset of `rhs`.
 public func ⊈ <
   T, S: Sequence where S.Iterator.Element == T
   >(lhs: Set<T>, rhs: S) -> Bool {
-  return !lhs.isSubsetOf(rhs)
+  return !lhs.isSubset(of: rhs)
 }
 
 /// - Returns: True if `lhs` is a strict superset of `rhs`.
 public func ⊃ <
   T, S: Sequence where S.Iterator.Element == T
   >(lhs: Set<T>, rhs: S) -> Bool {
-  return lhs.isStrictSupersetOf(rhs)
+  return lhs.isStrictSuperset(of: rhs)
 }
 
 /// - Returns: True if `lhs` is not a strict superset of `rhs`.
 public func ⊅ <
   T, S: Sequence where S.Iterator.Element == T
   >(lhs: Set<T>, rhs: S) -> Bool {
-  return !lhs.isStrictSupersetOf(rhs)
+  return !lhs.isStrictSuperset(of: rhs)
 }
 
 /// - Returns: True if `lhs` is a superset of `rhs`.
 public func ⊇ <
   T, S: Sequence where S.Iterator.Element == T
   >(lhs: Set<T>, rhs: S) -> Bool {
-  return lhs.isSupersetOf(rhs)
+  return lhs.isSuperset(of: rhs)
 }
 
 /// - Returns: True if `lhs` is not a superset of `rhs`.
 public func ⊉ <
   T, S: Sequence where S.Iterator.Element == T
   >(lhs: Set<T>, rhs: S) -> Bool {
-  return !lhs.isSupersetOf(rhs)
+  return !lhs.isSuperset(of: rhs)
 }

stdlib/public/SDK/CoreGraphics/CoreGraphics.swift

@@ -245,25 +245,25 @@ public extension CGRect {
   }
 
   @_transparent // @fragile
-  @warn_unused_result(mutable_variant: "unionInPlace")
+  @warn_unused_result(mutable_variant: "formUnion")
   func union(rect: CGRect) -> CGRect {
     return CGRectUnion(self, rect)
   }
 
   @_transparent // @fragile
-  mutating func unionInPlace(rect: CGRect) {
+  mutating func formUnion(rect: CGRect) {
     self = union(rect)
   }
 
   @_transparent // @fragile
-  @warn_unused_result(mutable_variant: "intersectInPlace")
-  func intersect(rect: CGRect) -> CGRect {
+  @warn_unused_result(mutable_variant: "formIntersection")
+  func intersection(rect: CGRect) -> CGRect {
     return CGRectIntersection(self, rect)
   }
 
   @_transparent // @fragile
-  mutating func intersectInPlace(rect: CGRect) {
-    self = intersect(rect)
+  mutating func formIntersection(rect: CGRect) {
+    self = intersection(rect)
   }
 
   @_transparent // @fragile

stdlib/public/SDK/CoreMedia/CMTime.swift

@@ -53,7 +53,7 @@ extension CMTime {
 
   public var isNumeric: Bool {
     return
-      self.flags.intersect([.valid, .impliedValueFlagsMask]) == .valid
+      self.flags.intersection([.valid, .impliedValueFlagsMask]) == .valid
   }
 
   public var hasBeenRounded: Bool {