| CARVIEW |
Select Language
HTTP/2 200
date: Mon, 28 Jul 2025 02:46:11 GMT
content-type: text/plain; charset=utf-8
vary: X-PJAX, X-PJAX-Container, Turbo-Visit, Turbo-Frame, X-Requested-With,Accept-Encoding, Accept, X-Requested-With
x-repository-download: git clone https://github.com/radex/swift_stdlib.git
etag: W/"2021d715332fa5fb901ebc5ecc5c0b86"
cache-control: max-age=0, private, must-revalidate
strict-transport-security: max-age=31536000; includeSubdomains; preload
x-frame-options: deny
x-content-type-options: nosniff
x-xss-protection: 0
referrer-policy: no-referrer-when-downgrade
content-security-policy: default-src 'none'; base-uri 'self'; child-src github.githubassets.com github.com/assets-cdn/worker/ github.com/assets/ gist.github.com/assets-cdn/worker/; connect-src 'self' uploads.github.com www.githubstatus.com collector.github.com raw.githubusercontent.com api.github.com github-cloud.s3.amazonaws.com github-production-repository-file-5c1aeb.s3.amazonaws.com github-production-upload-manifest-file-7fdce7.s3.amazonaws.com github-production-user-asset-6210df.s3.amazonaws.com *.rel.tunnels.api.visualstudio.com wss://*.rel.tunnels.api.visualstudio.com objects-origin.githubusercontent.com copilot-proxy.githubusercontent.com proxy.individual.githubcopilot.com proxy.business.githubcopilot.com proxy.enterprise.githubcopilot.com *.actions.githubusercontent.com wss://*.actions.githubusercontent.com productionresultssa0.blob.core.windows.net/ productionresultssa1.blob.core.windows.net/ productionresultssa2.blob.core.windows.net/ productionresultssa3.blob.core.windows.net/ productionresultssa4.blob.core.windows.net/ productionresultssa5.blob.core.windows.net/ productionresultssa6.blob.core.windows.net/ productionresultssa7.blob.core.windows.net/ productionresultssa8.blob.core.windows.net/ productionresultssa9.blob.core.windows.net/ productionresultssa10.blob.core.windows.net/ productionresultssa11.blob.core.windows.net/ productionresultssa12.blob.core.windows.net/ productionresultssa13.blob.core.windows.net/ productionresultssa14.blob.core.windows.net/ productionresultssa15.blob.core.windows.net/ productionresultssa16.blob.core.windows.net/ productionresultssa17.blob.core.windows.net/ productionresultssa18.blob.core.windows.net/ productionresultssa19.blob.core.windows.net/ github-production-repository-image-32fea6.s3.amazonaws.com github-production-release-asset-2e65be.s3.amazonaws.com insights.github.com wss://alive.github.com api.githubcopilot.com api.individual.githubcopilot.com api.business.githubcopilot.com api.enterprise.githubcopilot.com; font-src github.githubassets.com; form-action 'self' github.com gist.github.com copilot-workspace.githubnext.com objects-origin.githubusercontent.com; frame-ancestors 'none'; frame-src viewscreen.githubusercontent.com notebooks.githubusercontent.com; img-src 'self' data: blob: github.githubassets.com media.githubusercontent.com camo.githubusercontent.com identicons.github.com avatars.githubusercontent.com private-avatars.githubusercontent.com github-cloud.s3.amazonaws.com objects.githubusercontent.com release-assets.githubusercontent.com secured-user-images.githubusercontent.com/ user-images.githubusercontent.com/ private-user-images.githubusercontent.com opengraph.githubassets.com copilotprodattachments.blob.core.windows.net/github-production-copilot-attachments/ github-production-user-asset-6210df.s3.amazonaws.com customer-stories-feed.github.com spotlights-feed.github.com objects-origin.githubusercontent.com *.githubusercontent.com; manifest-src 'self'; media-src github.com user-images.githubusercontent.com/ secured-user-images.githubusercontent.com/ private-user-images.githubusercontent.com github-production-user-asset-6210df.s3.amazonaws.com gist.github.com; script-src github.githubassets.com; style-src 'unsafe-inline' github.githubassets.com; upgrade-insecure-requests; worker-src github.githubassets.com github.com/assets-cdn/worker/ github.com/assets/ gist.github.com/assets-cdn/worker/
server: github.com
content-encoding: gzip
accept-ranges: bytes
set-cookie: _gh_sess=goc0XvdHasb3on0bfrt9GInWGWPojSNbJANwBvwl8P5or1W7Tig%2Bd2PVJ5cROvhT8NGJjk7J%2FEWiaSSF3c6g7KQKj9eyrqwWHChYMLJgNE7b7ZfWKVxhdLiy2IUlI77GPxA56U5qo%2FeipXptrn%2FAUod2%2BXAL94XHKoCkMh8p6YbPv2kVcx2Emr3Y8CGHUAAYLEGM0FR4rjKtj4TC0%2FkZnp11XYDR%2FlkPdUfCpXkp6cNw7zusFlgXRdkzwBT2j1nECQnJVZf4LnjAJ0iFUaeBMQ%3D%3D--xViM1OjQHr%2BITql7--azKdJmPFquEIDf4WxFn5JQ%3D%3D; Path=/; HttpOnly; Secure; SameSite=Lax
set-cookie: _octo=GH1.1.1757913285.1753670771; Path=/; Domain=github.com; Expires=Tue, 28 Jul 2026 02:46:11 GMT; Secure; SameSite=Lax
set-cookie: logged_in=no; Path=/; Domain=github.com; Expires=Tue, 28 Jul 2026 02:46:11 GMT; HttpOnly; Secure; SameSite=Lax
content-length: 29099
x-github-request-id: E7A6:1C79A4:12E7F73:1919CE3:6886E473
From 1014c4b251019eabe0056a3d8e90818a9a1b20c3 Mon Sep 17 00:00:00 2001
From: radex
Date: Mon, 9 Feb 2015 22:03:10 +0100
Subject: [PATCH] 6.3 Beta 1
---
stdlib.swift | 2524 +++++++++++++++++++++++++++++++-------------------
1 file changed, 1578 insertions(+), 946 deletions(-)
diff --git a/stdlib.swift b/stdlib.swift
index 9bda599..9cf0338 100644
--- a/stdlib.swift
+++ b/stdlib.swift
@@ -1,229 +1,229 @@
-infix operator | {
+infix operator % {
associativity left
- precedence 140
+ precedence 150
}
-infix operator += {
- associativity right
- precedence 90
- assignment
+infix operator >= {
+ associativity none
+ precedence 130
}
-infix operator ... {
+infix operator ~= {
associativity none
- precedence 135
+ precedence 130
}
-infix operator -= {
- associativity right
- precedence 90
- assignment
+infix operator !== {
+ associativity none
+ precedence 130
}
-infix operator &% {
+infix operator < {
+ associativity none
+ precedence 130
+}
+
+infix operator | {
associativity left
- precedence 150
+ precedence 140
}
-infix operator /= {
- associativity right
- precedence 90
- assignment
+infix operator >> {
+ associativity none
+ precedence 160
}
-infix operator && {
+infix operator ~> {
associativity left
- precedence 120
+ precedence 255
}
-infix operator &* {
- associativity left
- precedence 150
+infix operator != {
+ associativity none
+ precedence 130
}
-infix operator &+ {
- associativity left
- precedence 140
+infix operator > {
+ associativity none
+ precedence 130
}
-infix operator &- {
- associativity left
- precedence 140
+infix operator >>= {
+ associativity right
+ precedence 90
+ assignment
}
-infix operator &/ {
- associativity left
- precedence 150
+infix operator |= {
+ associativity right
+ precedence 90
+ assignment
}
-infix operator === {
+infix operator <= {
associativity none
precedence 130
}
-infix operator ..< {
- associativity none
- precedence 135
+infix operator %= {
+ associativity right
+ precedence 90
+ assignment
}
-infix operator == {
+infix operator << {
associativity none
- precedence 130
+ precedence 160
}
-infix operator ^= {
+infix operator || {
+ associativity left
+ precedence 110
+}
+
+infix operator <<= {
associativity right
precedence 90
assignment
}
-infix operator ^ {
+infix operator / {
associativity left
- precedence 140
+ precedence 150
}
-infix operator ?? {
- associativity right
- precedence 110
+infix operator - {
+ associativity left
+ precedence 140
}
-infix operator ~> {
+infix operator + {
associativity left
- precedence 255
+ precedence 140
}
-infix operator &= {
+infix operator += {
associativity right
precedence 90
assignment
}
-infix operator % {
+infix operator -= {
+ associativity right
+ precedence 90
+ assignment
+}
+
+infix operator ... {
+ associativity none
+ precedence 135
+}
+
+infix operator &% {
associativity left
precedence 150
}
-infix operator & {
+infix operator && {
associativity left
- precedence 150
+ precedence 120
}
-infix operator *= {
+infix operator /= {
associativity right
precedence 90
assignment
}
-infix operator * {
+infix operator &* {
associativity left
precedence 150
}
-infix operator < {
- associativity none
- precedence 130
-}
-
-infix operator + {
+infix operator &+ {
associativity left
precedence 140
}
-infix operator >> {
- associativity none
- precedence 160
-}
-
-infix operator - {
+infix operator &- {
associativity left
precedence 140
}
-infix operator / {
+infix operator &/ {
associativity left
precedence 150
}
-infix operator <<= {
- associativity right
- precedence 90
- assignment
-}
-
-infix operator ~= {
+infix operator === {
associativity none
precedence 130
}
-infix operator >= {
+infix operator ..< {
associativity none
- precedence 130
-}
-
-infix operator || {
- associativity left
- precedence 110
+ precedence 135
}
-infix operator << {
+infix operator == {
associativity none
- precedence 160
+ precedence 130
}
-infix operator |= {
+infix operator ^= {
associativity right
precedence 90
assignment
}
-infix operator <= {
- associativity none
- precedence 130
+infix operator ?? {
+ associativity right
+ precedence 110
}
-infix operator !== {
- associativity none
- precedence 130
+infix operator ^ {
+ associativity left
+ precedence 140
}
-infix operator %= {
+infix operator * {
+ associativity left
+ precedence 150
+}
+
+infix operator &= {
associativity right
precedence 90
assignment
}
-infix operator != {
- associativity none
- precedence 130
-}
-
-infix operator > {
- associativity none
- precedence 130
+infix operator & {
+ associativity left
+ precedence 150
}
-infix operator >>= {
+infix operator *= {
associativity right
precedence 90
assignment
}
-prefix operator - {
+prefix operator ! {
}
-prefix operator ~ {
+prefix operator + {
}
-prefix operator -- {
+prefix operator ~ {
}
-prefix operator ++ {
+prefix operator - {
}
-prefix operator + {
+prefix operator -- {
}
-prefix operator ! {
+prefix operator ++ {
}
postfix operator ++ {
@@ -238,98 +238,106 @@ prefix func !(a: Bool) -> Bool
/// Return the result of inverting `a`\ 's logic value
prefix func !(a: T) -> Bool
-func !=(lhs: Int, rhs: Int) -> Bool
-
-func !=(lhs: T?, rhs: T?) -> Bool
-func !=(lhs: T?, rhs: _OptionalNilComparisonType) -> Bool
+/// Returns true if the arrays do not contain the same elements.
+func !=(lhs: _UnitTestArray, rhs: _UnitTestArray) -> Bool
-func !=(lhs: UInt, rhs: UInt) -> Bool
-func !=(lhs: Int64, rhs: Int64) -> Bool
+/// Returns true if the arrays do not contain the same elements.
+func !=(lhs: [T], rhs: [T]) -> Bool
-func !=(lhs: UInt64, rhs: UInt64) -> Bool
+func !=(lhs: UInt8, rhs: UInt8) -> Bool
-func !=(lhs: Int32, rhs: Int32) -> Bool
+func !=(lhs: Int8, rhs: Int8) -> Bool
-func !=(lhs: UInt32, rhs: UInt32) -> Bool
+func !=(lhs: UInt16, rhs: UInt16) -> Bool
func !=(lhs: Int16, rhs: Int16) -> Bool
-func !=(lhs: UInt16, rhs: UInt16) -> Bool
+func !=(lhs: UInt32, rhs: UInt32) -> Bool
-func !=(lhs: Int8, rhs: Int8) -> Bool
+func !=(lhs: Int32, rhs: Int32) -> Bool
-func !=(lhs: UInt8, rhs: UInt8) -> Bool
+func !=(lhs: T, rhs: T) -> Bool
func !=(lhs: _OptionalNilComparisonType, rhs: T?) -> Bool
-func !=(lhs: T, rhs: T) -> Bool
+func !=(lhs: T?, rhs: _OptionalNilComparisonType) -> Bool
+func !=(lhs: T?, rhs: T?) -> Bool
-/// Returns true if the arrays do not contain the same elements.
-func !=(lhs: ContiguousArray, rhs: ContiguousArray) -> Bool
+func !=(lhs: [Key : Value], rhs: [Key : Value]) -> Bool
/// Returns true if the arrays do not contain the same elements.
func !=(lhs: Slice, rhs: Slice) -> Bool
+func !=(lhs: Int, rhs: Int) -> Bool
+
+func !=(lhs: UInt, rhs: UInt) -> Bool
+
/// Returns true if the arrays do not contain the same elements.
-func !=(lhs: [T], rhs: [T]) -> Bool
+func !=(lhs: ContiguousArray, rhs: ContiguousArray) -> Bool
-func !=(lhs: [Key : Value], rhs: [Key : Value]) -> Bool
+func !=(lhs: Int64, rhs: Int64) -> Bool
+
+func !=(lhs: UInt64, rhs: UInt64) -> Bool
func !==(lhs: AnyObject?, rhs: AnyObject?) -> Bool
-func %(lhs: UInt32, rhs: UInt32) -> UInt32
+func %(lhs: UInt8, rhs: UInt8) -> UInt8
-func %(lhs: Int16, rhs: Int16) -> Int16
+func %(lhs: Int8, rhs: Int8) -> Int8
func %(lhs: UInt16, rhs: UInt16) -> UInt16
-func %(lhs: Int8, rhs: Int8) -> Int8
+func %(lhs: Int16, rhs: Int16) -> Int16
-func %(lhs: UInt8, rhs: UInt8) -> UInt8
+func %(lhs: UInt32, rhs: UInt32) -> UInt32
+func %(lhs: Int32, rhs: Int32) -> Int32
-/// Divide `lhs` and `rhs`, returning the remainder and trapping in case of
-/// arithmetic overflow (except in -Ounchecked builds).
-func %(lhs: T, rhs: T) -> T
+func %(lhs: UInt64, rhs: UInt64) -> UInt64
-func %(lhs: Float80, rhs: Float80) -> Float80
+func %(lhs: Int64, rhs: Int64) -> Int64
-func %(lhs: Double, rhs: Double) -> Double
+func %(lhs: Int, rhs: Int) -> Int
func %(lhs: Float, rhs: Float) -> Float
-func %(lhs: Int, rhs: Int) -> Int
+func %(lhs: Double, rhs: Double) -> Double
-func %(lhs: Int32, rhs: Int32) -> Int32
+func %(lhs: Float80, rhs: Float80) -> Float80
-func %(lhs: UInt64, rhs: UInt64) -> UInt64
-func %(lhs: Int64, rhs: Int64) -> Int64
+/// Divide `lhs` and `rhs`, returning the remainder and trapping in case of
+/// arithmetic overflow (except in -Ounchecked builds).
+func %(lhs: T, rhs: T) -> T
func %(lhs: UInt, rhs: UInt) -> UInt
func %=(inout lhs: Float, rhs: Float)
-func %=(inout lhs: Double, rhs: Double)
-
-func %=(inout lhs: Float80, rhs: Float80)
-
/// remainder `lhs` and `rhs` and store the result in `lhs`, trapping in
/// case of arithmetic overflow (except in -Ounchecked builds).
func %=(inout lhs: T, rhs: T)
-func &(lhs: UInt32, rhs: UInt32) -> UInt32
+func %=(inout lhs: Float80, rhs: Float80)
+
+func %=(inout lhs: Double, rhs: Double)
+
+func &(lhs: UInt8, rhs: UInt8) -> UInt8
+
+func &(lhs: Int8, rhs: Int8) -> Int8
func &(lhs: UInt16, rhs: UInt16) -> UInt16
func &(lhs: Int16, rhs: Int16) -> Int16
+func &(lhs: UInt32, rhs: UInt32) -> UInt32
+
func &(lhs: Int32, rhs: Int32) -> Int32
func &(lhs: UInt64, rhs: UInt64) -> UInt64
@@ -340,14 +348,8 @@ func &(lhs: UInt, rhs: UInt) -> UInt
func &(lhs: Int, rhs: Int) -> Int
-func &(lhs: Bool, rhs: Bool) -> Bool
-
func &(a: T, b: T) -> T
-func &(lhs: UInt8, rhs: UInt8) -> UInt8
-
-func &(lhs: Int8, rhs: Int8) -> Int8
-
/// remainder `lhs` and `rhs`, silently discarding any overflow.
func &%(lhs: T, rhs: T) -> T
@@ -375,22 +377,8 @@ func &-(lhs: T, rhs: T) -> T
/// divide `lhs` and `rhs`, silently discarding any overflow.
func &/(lhs: T, rhs: T) -> T
-func &=(inout lhs: Bool, rhs: Bool)
-
-func &=(inout lhs: UInt8, rhs: UInt8)
-
-func &=(inout lhs: Int8, rhs: Int8)
-
-func &=(inout lhs: UInt16, rhs: UInt16)
-
func &=(inout lhs: Int16, rhs: Int16)
-func &=(inout lhs: UInt32, rhs: UInt32)
-
-func &=(inout lhs: Int32, rhs: Int32)
-
-func &=(inout lhs: UInt64, rhs: UInt64)
-
func &=(inout lhs: T, rhs: T)
func &=(inout lhs: Int, rhs: Int)
@@ -399,36 +387,48 @@ func &=(inout lhs: UInt, rhs: UInt)
func &=(inout lhs: Int64, rhs: Int64)
-func *(lhs: UInt32, rhs: UInt32) -> UInt32
+func &=(inout lhs: UInt64, rhs: UInt64)
-func *(lhs: Int32, rhs: Int32) -> Int32
+func &=(inout lhs: Int32, rhs: Int32)
-func *(lhs: UInt64, rhs: UInt64) -> UInt64
+func &=(inout lhs: UInt32, rhs: UInt32)
-func *(lhs: Int64, rhs: Int64) -> Int64
+func &=(inout lhs: UInt16, rhs: UInt16)
-func *(lhs: UInt, rhs: UInt) -> UInt
+func &=(inout lhs: Int8, rhs: Int8)
-func *(lhs: Int, rhs: Int) -> Int
+func &=(inout lhs: UInt8, rhs: UInt8)
-func *(lhs: Float, rhs: Float) -> Float
+func *(lhs: Int32, rhs: Int32) -> Int32
-func *(lhs: Double, rhs: Double) -> Double
+func *(lhs: UInt8, rhs: UInt8) -> UInt8
-func *(lhs: Float80, rhs: Float80) -> Float80
+func *(lhs: Int8, rhs: Int8) -> Int8
+
+func *(lhs: UInt16, rhs: UInt16) -> UInt16
+
+func *(lhs: Int16, rhs: Int16) -> Int16
/// Multiply `lhs` and `rhs`, returning a result and trapping in case of
/// arithmetic overflow (except in -Ounchecked builds).
func *(lhs: T, rhs: T) -> T
-func *(lhs: Int16, rhs: Int16) -> Int16
+func *(lhs: UInt64, rhs: UInt64) -> UInt64
-func *(lhs: UInt16, rhs: UInt16) -> UInt16
+func *(lhs: Float80, rhs: Float80) -> Float80
-func *(lhs: Int8, rhs: Int8) -> Int8
+func *(lhs: Double, rhs: Double) -> Double
-func *(lhs: UInt8, rhs: UInt8) -> UInt8
+func *(lhs: Float, rhs: Float) -> Float
+
+func *(lhs: Int, rhs: Int) -> Int
+
+func *(lhs: UInt, rhs: UInt) -> UInt
+
+func *(lhs: Int64, rhs: Int64) -> Int64
+
+func *(lhs: UInt32, rhs: UInt32) -> UInt32
func *=(inout lhs: UInt8, rhs: UInt8)
@@ -454,51 +454,45 @@ func *=(inout lhs: Float, rhs: Float)
func *=(inout lhs: Double, rhs: Double)
+func *=(inout lhs: Float80, rhs: Float80)
+
/// multiply `lhs` and `rhs` and store the result in `lhs`, trapping in
/// case of arithmetic overflow (except in -Ounchecked builds).
func *=(inout lhs: T, rhs: T)
-func *=(inout lhs: Float80, rhs: Float80)
-
-prefix func +(x: Double) -> Double
-
-func +(lhs: Float, rhs: Float) -> Float
-
func +(lhs: Int, rhs: UnsafePointer) -> UnsafePointer
-prefix func +(x: Float) -> Float
+func +(lhs: T.Stride, rhs: T) -> T
-func +(lhs: UnsafePointer, rhs: Int) -> UnsafePointer
+func +(lhs: UInt8, rhs: UInt8) -> UInt8
-func +(lhs: Int, rhs: Int) -> Int
+func +(lhs: Int8, rhs: Int8) -> Int8
-func +(lhs: UInt, rhs: UInt) -> UInt
+func +(lhs: UInt16, rhs: UInt16) -> UInt16
-func +(lhs: Int64, rhs: Int64) -> Int64
+func +(lhs: Int16, rhs: Int16) -> Int16
-func +(lhs: UInt64, rhs: UInt64) -> UInt64
+func +(lhs: UInt32, rhs: UInt32) -> UInt32
-func +(lhs: Int, rhs: UnsafeMutablePointer) -> UnsafeMutablePointer
+func +(lhs: Int32, rhs: Int32) -> Int32
-func +(lhs: UnsafeMutablePointer, rhs: Int) -> UnsafeMutablePointer
+func +(lhs: UInt64, rhs: UInt64) -> UInt64
-func +(lhs: Int32, rhs: Int32) -> Int32
+func +(lhs: Int64, rhs: Int64) -> Int64
-func +(lhs: UInt32, rhs: UInt32) -> UInt32
+func +(lhs: UInt, rhs: UInt) -> UInt
-func +(lhs: Int16, rhs: Int16) -> Int16
+func +(lhs: Int, rhs: Int) -> Int
-func +(lhs: UInt16, rhs: UInt16) -> UInt16
+prefix func +(x: Float) -> Float
-func +(lhs: Int8, rhs: Int8) -> Int8
+func +(lhs: Float, rhs: Float) -> Float
-func +(lhs: UInt8, rhs: UInt8) -> UInt8
+prefix func +(x: Double) -> Double
func +(lhs: Double, rhs: Double) -> Double
-func +(lhs: String, rhs: String) -> String
-
prefix func +(x: Float80) -> Float80
func +(lhs: Float80, rhs: Float80) -> Float80
@@ -510,106 +504,117 @@ func +(lhs: T, rhs: T) -> T
prefix func +(x: T) -> T
-func +(lhs: C, rhs: S) -> C
-
-func +(lhs: S, rhs: C) -> C
+func +(lhs: C, rhs: S) -> C
-func +(lhs: T.Stride, rhs: T) -> T
+func +(lhs: S, rhs: C) -> C
-func +(lhs: C, rhs: S) -> C
+func +(lhs: C, rhs: S) -> C
func +(lhs: EC1, rhs: EC2) -> EC1
-func +(lhs: T, rhs: T.Stride) -> T
+func +(lhs: UnsafePointer, rhs: Int) -> UnsafePointer
-prefix func ++(inout x: Int8) -> Int8
+func +(lhs: Int, rhs: UnsafeMutablePointer) -> UnsafeMutablePointer
-prefix func ++(inout x: Int16) -> Int16
+func +(lhs: UnsafeMutablePointer, rhs: Int) -> UnsafeMutablePointer
-postfix func ++(inout x: T) -> T
+func +(lhs: String, rhs: String) -> String
-prefix func ++(inout x: T) -> T
+func +(lhs: T._DisallowMixedSignArithmetic, rhs: T) -> T
-postfix func ++(inout lhs: Float80) -> Float80
+func +(lhs: T, rhs: T._DisallowMixedSignArithmetic) -> T
-prefix func ++(inout rhs: Float80) -> Float80
+func +(lhs: T, rhs: T.Stride) -> T
-postfix func ++(inout lhs: Double) -> Double
+postfix func ++(inout lhs: Float) -> Float
prefix func ++(inout rhs: Double) -> Double
-postfix func ++(inout lhs: Float) -> Float
+prefix func ++(inout x: UInt8) -> UInt8
-prefix func ++(inout rhs: Float) -> Float
+postfix func ++(inout x: UInt8) -> UInt8
-postfix func ++(inout x: Int) -> Int
+prefix func ++(inout x: Int8) -> Int8
-prefix func ++(inout x: Int) -> Int
+postfix func ++(inout x: Int8) -> Int8
-postfix func ++(inout x: UInt) -> UInt
+prefix func ++(inout x: UInt16) -> UInt16
-prefix func ++(inout x: UInt) -> UInt
+postfix func ++(inout x: UInt16) -> UInt16
-postfix func ++(inout x: Int64) -> Int64
+prefix func ++(inout x: Int16) -> Int16
-prefix func ++(inout x: Int64) -> Int64
+postfix func ++(inout x: Int16) -> Int16
-postfix func ++(inout x: UInt64) -> UInt64
+prefix func ++(inout x: UInt32) -> UInt32
-prefix func ++(inout x: UInt64) -> UInt64
+postfix func ++(inout x: UInt32) -> UInt32
-postfix func ++(inout x: Int32) -> Int32
+prefix func ++(inout rhs: Float80) -> Float80
+
+postfix func ++(inout lhs: Float80) -> Float80
+
+prefix func ++(inout x: T) -> T
+
+postfix func ++(inout x: T) -> T
prefix func ++(inout x: Int32) -> Int32
-postfix func ++(inout x: UInt32) -> UInt32
+postfix func ++(inout x: Int32) -> Int32
-prefix func ++(inout x: UInt32) -> UInt32
+prefix func ++(inout x: UInt64) -> UInt64
-postfix func ++(inout x: Int16) -> Int16
+postfix func ++(inout x: UInt64) -> UInt64
-postfix func ++(inout x: UInt16) -> UInt16
+prefix func ++(inout x: Int64) -> Int64
-prefix func ++(inout x: UInt16) -> UInt16
+postfix func ++(inout x: Int64) -> Int64
-postfix func ++(inout x: Int8) -> Int8
+prefix func ++(inout x: UInt) -> UInt
-prefix func ++(inout x: UInt8) -> UInt8
+postfix func ++(inout x: UInt) -> UInt
-postfix func ++(inout x: UInt8) -> UInt8
+prefix func ++(inout x: Int) -> Int
+
+postfix func ++(inout x: Int) -> Int
+
+prefix func ++(inout rhs: Float) -> Float
+
+postfix func ++(inout lhs: Double) -> Double
/// Extend `lhs` with the elements of `rhs`
-func +=(inout lhs: ContiguousArray, rhs: S)
+func +=(inout lhs: Slice, rhs: C)
-func +=(inout lhs: UnsafePointer, rhs: Int)
+func +=(inout lhs: UInt, rhs: UInt)
/// Extend `lhs` with the elements of `rhs`
-func +=(inout lhs: ContiguousArray, rhs: C)
+func +=(inout lhs: [T], rhs: S)
-func +=(inout lhs: UnsafeMutablePointer, rhs: Int)
-func +=(inout lhs: String, rhs: String)
+/// Extend `lhs` with the elements of `rhs`
+func +=(inout lhs: [T], rhs: C)
-func +=(inout lhs: T, rhs: T.Stride)
+/// Extend `lhs` with the elements of `rhs`
+func +=(inout lhs: _UnitTestArray, rhs: S)
-/// add `lhs` and `rhs` and store the result in `lhs`, trapping in
-/// case of arithmetic overflow (except in -Ounchecked builds).
-func +=(inout lhs: T, rhs: T)
-func +=(inout lhs: Float80, rhs: Float80)
+/// Extend `lhs` with the elements of `rhs`
+func +=(inout lhs: _UnitTestArray, rhs: C)
-func +=(inout lhs: Double, rhs: Double)
-func +=(inout lhs: Float, rhs: Float)
+/// Append the elements of rhs to lhs
+func +=(inout lhs: _ContiguousArrayBuffer, rhs: C)
-func +=(inout lhs: Int, rhs: Int)
-func +=(inout lhs: UInt, rhs: UInt)
+/// Append rhs to lhs
+func +=(inout lhs: _ContiguousArrayBuffer, rhs: T)
-func +=(inout lhs: Int64, rhs: Int64)
+func +=(inout lhs: UInt8, rhs: UInt8)
+
+func +=(inout lhs: Int8, rhs: Int8)
/// Extend `lhs` with the elements of `rhs`
@@ -617,185 +622,204 @@ func +=(inout lhs: Slice, rhs: S)
/// Extend `lhs` with the elements of `rhs`
-func +=(inout lhs: Slice, rhs: C)
-
-func +=(inout lhs: UInt64, rhs: UInt64)
-
-func +=(inout lhs: Int32, rhs: Int32)
+func +=(inout lhs: ContiguousArray, rhs: S)
-func +=(inout lhs: UInt32, rhs: UInt32)
+func +=(inout lhs: UInt16, rhs: UInt16)
func +=(inout lhs: Int16, rhs: Int16)
+func +=(inout lhs: UInt32, rhs: UInt32)
-/// Extend `lhs` with the elements of `rhs`
-func +=(inout lhs: [T], rhs: S)
+func +=(inout lhs: Int32, rhs: Int32)
+func +=(inout lhs: UInt64, rhs: UInt64)
-/// Extend `lhs` with the elements of `rhs`
-func +=(inout lhs: [T], rhs: C)
+func +=(inout lhs: Int64, rhs: Int64)
+func +=(inout lhs: UnsafePointer, rhs: Int)
-/// Append the elements of rhs to lhs
-func +=(inout lhs: _ContiguousArrayBuffer, rhs: C)
+func +=(inout lhs: UnsafeMutablePointer, rhs: Int)
/// Append rhs to lhs
-func +=(inout lhs: _ContiguousArrayBuffer, rhs: T)
+func +=(inout lhs: _UnitTestArrayBuffer, rhs: T)
-func +=(inout lhs: UInt16, rhs: UInt16)
-func +=(inout lhs: UInt8, rhs: UInt8)
+/// Extend `lhs` with the elements of `rhs`
+func +=(inout lhs: ContiguousArray, rhs: C)
-func +=(inout lhs: Int8, rhs: Int8)
+func +=(inout lhs: Int, rhs: Int)
-func -(lhs: UInt64, rhs: UInt64) -> UInt64
+func +=(inout lhs: Float, rhs: Float)
-prefix func -(x: Float) -> Float
+func +=(inout lhs: Double, rhs: Double)
-func -(lhs: Int32, rhs: Int32) -> Int32
+func +=(inout lhs: Float80, rhs: Float80)
-func -(lhs: Int64, rhs: Int64) -> Int64
-func -(lhs: UInt, rhs: UInt) -> UInt
+/// add `lhs` and `rhs` and store the result in `lhs`, trapping in
+/// case of arithmetic overflow (except in -Ounchecked builds).
+func +=(inout lhs: T, rhs: T)
-func -(lhs: UnsafePointer, rhs: UnsafePointer) -> Int
+func +=(inout lhs: T, rhs: T.Stride)
-func -(lhs: UInt32, rhs: UInt32) -> UInt32
+func +=(inout lhs: T, rhs: T._DisallowMixedSignArithmetic)
-func -(lhs: Int16, rhs: Int16) -> Int16
+func +=(inout lhs: String, rhs: String)
-func -(lhs: UInt16, rhs: UInt16) -> UInt16
-func -(lhs: Int8, rhs: Int8) -> Int8
+/// Append the elements of rhs to lhs
+func +=(inout lhs: _UnitTestArrayBuffer, rhs: C)
-func -(lhs: UInt8, rhs: UInt8) -> UInt8
+func -(lhs: UInt, rhs: UInt) -> UInt
-func -(lhs: UnsafePointer, rhs: Int) -> UnsafePointer
+func -(lhs: Int, rhs: Int) -> Int
-func -(lhs: UnsafeMutablePointer, rhs: UnsafeMutablePointer) -> Int
+prefix func -(x: Float) -> Float
-func -(lhs: UnsafeMutablePointer, rhs: Int) -> UnsafeMutablePointer
+func -(lhs: Float, rhs: Float) -> Float
-func -(lhs: T, rhs: T) -> T.Stride
+prefix func -(x: Double) -> Double
-func -(lhs: T, rhs: T.Stride) -> T
+func -(lhs: Double, rhs: Double) -> Double
-prefix func -(x: T) -> T
+prefix func -(x: Float80) -> Float80
+
+func -(lhs: Float80, rhs: Float80) -> Float80
/// Subtract `lhs` and `rhs`, returning a result and trapping in case of
/// arithmetic overflow (except in -Ounchecked builds).
func -(lhs: T, rhs: T) -> T
-func -(lhs: Float80, rhs: Float80) -> Float80
+func -(lhs: Int64, rhs: Int64) -> Int64
-prefix func -(x: Float80) -> Float80
+func -(lhs: UInt64, rhs: UInt64) -> UInt64
-func -(lhs: Double, rhs: Double) -> Double
+func -(lhs: Int32, rhs: Int32) -> Int32
-prefix func -(x: Double) -> Double
+prefix func -(x: T) -> T
-func -(lhs: Float, rhs: Float) -> Float
+func -(lhs: T, rhs: T.Stride) -> T
-func -(lhs: Int, rhs: Int) -> Int
+func -(lhs: T, rhs: T) -> T.Stride
-prefix func --(inout rhs: Float) -> Float
+func -(lhs: T, rhs: T._DisallowMixedSignArithmetic) -> T
-postfix func --(inout x: UInt) -> UInt
+func -(lhs: UInt8, rhs: UInt8) -> UInt8
-postfix func --(inout lhs: Float) -> Float
+func -(lhs: T, rhs: T) -> T._DisallowMixedSignArithmetic
-prefix func --(inout x: UInt) -> UInt
+func -(lhs: UnsafeMutablePointer, rhs: Int) -> UnsafeMutablePointer
-prefix func --(inout rhs: Double) -> Double
+func -(lhs: UnsafeMutablePointer, rhs: UnsafeMutablePointer) -> Int
-postfix func --(inout x: Int64) -> Int64
+func -(lhs: UnsafePointer, rhs: Int) -> UnsafePointer
-prefix func --(inout x: Int64) -> Int64
+func -(lhs: Int8, rhs: Int8) -> Int8
-postfix func --(inout lhs: Double) -> Double
+func -(lhs: UInt16, rhs: UInt16) -> UInt16
-postfix func --(inout x: UInt64) -> UInt64
+func -(lhs: Int16, rhs: Int16) -> Int16
-prefix func --(inout rhs: Float80) -> Float80
+func -(lhs: UInt32, rhs: UInt32) -> UInt32
-prefix func --(inout x: UInt8) -> UInt8
+func -(lhs: UnsafePointer, rhs: UnsafePointer) -> Int
-postfix func --(inout lhs: Float80) -> Float80
+prefix func --(inout x: Int64) -> Int64
-postfix func --(inout x: UInt8) -> UInt8
+postfix func --(inout x: UInt64) -> UInt64
prefix func --(inout x: UInt64) -> UInt64
-prefix func --(inout x: Int8) -> Int8
-
-postfix func --(inout x: Int) -> Int
-
postfix func --(inout x: Int32) -> Int32
prefix func --(inout x: Int32) -> Int32
-postfix func --(inout x: T) -> T
+postfix func --(inout x: UInt32) -> UInt32
-prefix func --(inout x: T) -> T
+prefix func --(inout x: UInt32) -> UInt32
-postfix func --(inout x: UInt32) -> UInt32
+postfix func --(inout x: Int16) -> Int16
-postfix func --(inout x: Int8) -> Int8
+prefix func --(inout x: Int16) -> Int16
+
+postfix func --(inout x: UInt16) -> UInt16
prefix func --(inout x: UInt16) -> UInt16
-prefix func --(inout x: UInt32) -> UInt32
+postfix func --(inout x: Int8) -> Int8
-postfix func --(inout x: UInt16) -> UInt16
+postfix func --(inout x: UInt8) -> UInt8
-prefix func --(inout x: Int16) -> Int16
+prefix func --(inout x: UInt8) -> UInt8
-postfix func --(inout x: Int16) -> Int16
+postfix func --(inout x: Int64) -> Int64
-prefix func --(inout x: Int) -> Int
+prefix func --(inout x: UInt) -> UInt
-func -=(inout lhs: UInt64, rhs: UInt64)
+postfix func --(inout x: UInt) -> UInt
+
+prefix func --(inout x: Int8) -> Int8
+
+postfix func --(inout x: Int) -> Int
+
+prefix func --(inout rhs: Float) -> Float
+
+postfix func --(inout lhs: Float) -> Float
+
+prefix func --(inout rhs: Double) -> Double
+
+postfix func --(inout lhs: Double) -> Double
+
+prefix func --(inout rhs: Float80) -> Float80
+
+postfix func --(inout lhs: Float80) -> Float80
+
+prefix func --(inout x: T) -> T
-func -=(inout lhs: Int64, rhs: Int64)
+postfix func --(inout x: T) -> T
-func -=(inout lhs: UInt8, rhs: UInt8)
+prefix func --(inout x: Int) -> Int
func -=(inout lhs: Int8, rhs: Int8)
func -=(inout lhs: UInt16, rhs: UInt16)
-func -=(inout lhs: UnsafePointer, rhs: Int)
+func -=(inout lhs: Int16, rhs: Int16)
+
+func -=(inout lhs: UInt32, rhs: UInt32)
func -=(inout lhs: Int32, rhs: Int32)
-func -=(inout lhs: UnsafeMutablePointer, rhs: Int)
+func -=(inout lhs: UInt64, rhs: UInt64)
-func -=(inout lhs: T, rhs: T.Stride)
+func -=(inout lhs: Int64, rhs: Int64)
+func -=(inout lhs: UInt, rhs: UInt)
-/// subtract `lhs` and `rhs` and store the result in `lhs`, trapping in
-/// case of arithmetic overflow (except in -Ounchecked builds).
-func -=(inout lhs: T, rhs: T)
+func -=(inout lhs: Int, rhs: Int)
-func -=(inout lhs: UInt32, rhs: UInt32)
+func -=(inout lhs: Float, rhs: Float)
-func -=(inout lhs: Int16, rhs: Int16)
+func -=(inout lhs: Double, rhs: Double)
func -=(inout lhs: Float80, rhs: Float80)
-func -=(inout lhs: Double, rhs: Double)
-func -=(inout lhs: Float, rhs: Float)
+/// subtract `lhs` and `rhs` and store the result in `lhs`, trapping in
+/// case of arithmetic overflow (except in -Ounchecked builds).
+func -=(inout lhs: T, rhs: T)
-func -=(inout lhs: UInt, rhs: UInt)
+func -=(inout lhs: T, rhs: T.Stride)
-func -=(inout lhs: Int, rhs: Int)
+func -=(inout lhs: T, rhs: T._DisallowMixedSignArithmetic)
+func -=(inout lhs: UnsafeMutablePointer, rhs: Int)
-/// Returns a closed interval from `start` through `end`
-func ...(start: T, end: T) -> ClosedInterval
+func -=(inout lhs: UnsafePointer, rhs: Int)
+
+func -=(inout lhs: UInt8, rhs: UInt8)
/// Forms a closed range that contains both `start` and `end`.
@@ -807,33 +831,22 @@ func ...(start: Pos, end: Pos) ->
func ...(minimum: Pos, maximum: Pos) -> Range
+/// Returns a closed interval from `start` through `end`
+func ...(start: T, end: T) -> ClosedInterval
+
+
/// Forms a half-open range that contains `start`, but not
/// `end`. Requires: `start <= end`
func ..<(start: Pos, end: Pos) -> Range
-/// Forms a half-open range that contains `minimum`, but not
-/// `maximum`.
-func ..<(minimum: Pos, maximum: Pos) -> Range
-
-
/// Returns a half-open interval from `start` to `end`
func ..<(start: T, end: T) -> HalfOpenInterval
-func /(lhs: Float, rhs: Float) -> Float
-
-func /(lhs: Double, rhs: Double) -> Double
-
-func /(lhs: Float80, rhs: Float80) -> Float80
-
-
-/// Divide `lhs` and `rhs`, returning a result and trapping in case of
-/// arithmetic overflow (except in -Ounchecked builds).
-func /(lhs: T, rhs: T) -> T
-
-func /(lhs: Int, rhs: Int) -> Int
-func /(lhs: Int64, rhs: Int64) -> Int64
+/// Forms a half-open range that contains `minimum`, but not
+/// `maximum`.
+func ..<(minimum: Pos, maximum: Pos) -> Range
func /(lhs: UInt64, rhs: UInt64) -> UInt64
@@ -841,50 +854,65 @@ func /(lhs: Int32, rhs: Int32) -> Int32
func /(lhs: UInt32, rhs: UInt32) -> UInt32
+func /(lhs: Int64, rhs: Int64) -> Int64
+
func /(lhs: Int16, rhs: Int16) -> Int16
func /(lhs: UInt16, rhs: UInt16) -> UInt16
+func /(lhs: UInt, rhs: UInt) -> UInt
+
+func /(lhs: Int, rhs: Int) -> Int
+
+func /(lhs: Float, rhs: Float) -> Float
+
func /(lhs: Int8, rhs: Int8) -> Int8
func /(lhs: UInt8, rhs: UInt8) -> UInt8
-func /(lhs: UInt, rhs: UInt) -> UInt
+func /(lhs: Double, rhs: Double) -> Double
-func /=(inout lhs: Float, rhs: Float)
+func /(lhs: Float80, rhs: Float80) -> Float80
-func /=(inout lhs: Double, rhs: Double)
-func /=(inout lhs: Float80, rhs: Float80)
+/// Divide `lhs` and `rhs`, returning a result and trapping in case of
+/// arithmetic overflow (except in -Ounchecked builds).
+func /(lhs: T, rhs: T) -> T
+
+func /=(inout lhs: Float, rhs: Float)
/// divide `lhs` and `rhs` and store the result in `lhs`, trapping in
/// case of arithmetic overflow (except in -Ounchecked builds).
func /=(inout lhs: T, rhs: T)
-func <(lhs: UnicodeScalar, rhs: UnicodeScalar) -> Bool
+func /=(inout lhs: Float80, rhs: Float80)
-func <(lhs: UInt, rhs: UInt) -> Bool
+func /=(inout lhs: Double, rhs: Double)
func <(lhs: String, rhs: String) -> Bool
-func <(lhs: UnsafeMutablePointer, rhs: UnsafeMutablePointer) -> Bool
+func <(lhs: String.Index, rhs: String.Index) -> Bool
+func <(lhs: String.UTF16View.Index, rhs: String.UTF16View.Index) -> Bool
-/// Compare two Strideables
-func <(x: T, y: T) -> Bool
+func <(lhs: String.UnicodeScalarView.Index, rhs: String.UnicodeScalarView.Index) -> Bool
+
+func <(lhs: UnicodeScalar, rhs: UnicodeScalar) -> Bool
+
+func <(lhs: UnsafeMutablePointer, rhs: UnsafeMutablePointer) -> Bool
func <(lhs: UnsafePointer, rhs: UnsafePointer) -> Bool
func <(lhs: Bit, rhs: Bit) -> Bool
-func <(lhs: Character, rhs: Character) -> Bool
-
func <(lhs: DictionaryIndex, rhs: DictionaryIndex) -> Bool
-func <(lhs: UInt8, rhs: UInt8) -> Bool
-func <(lhs: Int8, rhs: Int8) -> Bool
+/// Compare two Strideables
+func <(x: T, y: T) -> Bool
+
+func <(lhs: ObjectIdentifier, rhs: ObjectIdentifier) -> Bool
func <(lhs: T?, rhs: T?) -> Bool
@@ -894,45 +922,49 @@ func <(lhs: Int16, rhs: Int16) -> Bool
func <(lhs: UInt32, rhs: UInt32) -> Bool
-func <(lhs: Float80, rhs: Float80) -> Bool
-
-func <(lhs: Double, rhs: Double) -> Bool
-
-func <(lhs: Float, rhs: Float) -> Bool
+func <(lhs: UInt8, rhs: UInt8) -> Bool
func <(lhs: Int32, rhs: Int32) -> Bool
+func <(lhs: Character, rhs: Character) -> Bool
+
func <(lhs: UInt64, rhs: UInt64) -> Bool
-func <(lhs: String.Index, rhs: String.Index) -> Bool
+func <(lhs: Int8, rhs: Int8) -> Bool
-func <(lhs: String.UnicodeScalarView.Index, rhs: String.UnicodeScalarView.Index) -> Bool
+func <(lhs: SetIndex, rhs: SetIndex) -> Bool
-func <(lhs: Int, rhs: Int) -> Bool
+func <(lhs: Float80, rhs: Float80) -> Bool
func <(lhs: Int64, rhs: Int64) -> Bool
-func <<(lhs: Int64, rhs: Int64) -> Int64
+func <(lhs: UInt, rhs: UInt) -> Bool
-func <<(lhs: UInt64, rhs: UInt64) -> UInt64
+func <(lhs: Double, rhs: Double) -> Bool
+
+func <(lhs: Int, rhs: Int) -> Bool
+
+func <(lhs: Float, rhs: Float) -> Bool
func <<(lhs: UInt8, rhs: UInt8) -> UInt8
-func <<(lhs: UInt, rhs: UInt) -> UInt
+func <<(lhs: Int8, rhs: Int8) -> Int8
-func <<(lhs: Int32, rhs: Int32) -> Int32
+func <<(lhs: UInt16, rhs: UInt16) -> UInt16
func <<(lhs: UInt32, rhs: UInt32) -> UInt32
-func <<(lhs: Int, rhs: Int) -> Int
+func <<(lhs: Int32, rhs: Int32) -> Int32
-func <<(lhs: Int16, rhs: Int16) -> Int16
+func <<(lhs: UInt64, rhs: UInt64) -> UInt64
-func <<(lhs: Int8, rhs: Int8) -> Int8
+func <<(lhs: Int64, rhs: Int64) -> Int64
-func <<(lhs: UInt16, rhs: UInt16) -> UInt16
+func <<(lhs: UInt, rhs: UInt) -> UInt
-func <<=(inout lhs: UInt, rhs: UInt)
+func <<(lhs: Int, rhs: Int) -> Int
+
+func <<(lhs: Int16, rhs: Int16) -> Int16
func <<=(inout lhs: UInt8, rhs: UInt8)
@@ -942,29 +974,31 @@ func <<=(inout lhs: UInt16, rhs: UInt16)
func <<=(inout lhs: Int16, rhs: Int16)
-func <<=(inout lhs: Int, rhs: Int)
-
func <<=(inout lhs: UInt32, rhs: UInt32)
-func <<=(inout lhs: Int64, rhs: Int64)
+func <<=(inout lhs: Int32, rhs: Int32)
func <<=(inout lhs: UInt64, rhs: UInt64)
-func <<=(inout lhs: Int32, rhs: Int32)
+func <<=(inout lhs: Int64, rhs: Int64)
-func <=(lhs: UInt, rhs: UInt) -> Bool
+func <<=(inout lhs: UInt, rhs: UInt)
-func <=(lhs: Int64, rhs: Int64) -> Bool
+func <<=(inout lhs: Int, rhs: Int)
+
+func <=(lhs: T, rhs: T) -> Bool
+
+func <=(lhs: T?, rhs: T?) -> Bool
func <=(lhs: Int, rhs: Int) -> Bool
-func <=(lhs: UInt64, rhs: UInt64) -> Bool
+func <=(lhs: UInt, rhs: UInt) -> Bool
-func <=(lhs: Int32, rhs: Int32) -> Bool
+func <=(lhs: Int64, rhs: Int64) -> Bool
-func <=(lhs: T?, rhs: T?) -> Bool
+func <=(lhs: UInt64, rhs: UInt64) -> Bool
-func <=(lhs: T, rhs: T) -> Bool
+func <=(lhs: Int32, rhs: Int32) -> Bool
func <=(lhs: UInt32, rhs: UInt32) -> Bool
@@ -976,101 +1010,115 @@ func <=(lhs: Int8, rhs: Int8) -> Bool
func <=(lhs: UInt8, rhs: UInt8) -> Bool
-func ==(lhs: UnsafePointer, rhs: UnsafePointer) -> Bool
-
-func ==(x: ObjectIdentifier, y: ObjectIdentifier) -> Bool
+func ==(lhs: UInt8, rhs: UInt8) -> Bool
-func ==(lhs: UnsafeMutablePointer, rhs: UnsafeMutablePointer) -> Bool
+func ==(lhs: UInt, rhs: UInt) -> Bool
-func ==(lhs: Bit, rhs: Bit) -> Bool
+func ==(lhs: Int, rhs: Int) -> Bool
-func ==(lhs: UnicodeScalar, rhs: UnicodeScalar) -> Bool
+func ==(lhs: Float, rhs: Float) -> Bool
-func ==(lhs: Int32, rhs: Int32) -> Bool
+func ==(lhs: Double, rhs: Double) -> Bool
func ==(lhs: [Key : Value], rhs: [Key : Value]) -> Bool
+func ==(lhs: Int64, rhs: Int64) -> Bool
-func ==(lhs: DictionaryIndex, rhs: DictionaryIndex) -> Bool
+func ==(lhs: FloatingPointClassification, rhs: FloatingPointClassification) -> Bool
-func ==(lhs: Range, rhs: Range) -> Bool
+func ==(lhs: UInt64, rhs: UInt64) -> Bool
-func ==(a: T, b: T) -> Bool
+func ==(lhs: Int32, rhs: Int32) -> Bool
-func ==(lhs: Character, rhs: Character) -> Bool
+func ==(lhs: UInt32, rhs: UInt32) -> Bool
+
+func ==(lhs: Set, rhs: Set) -> Bool
func ==(lhs: T?, rhs: _OptionalNilComparisonType) -> Bool
-func ==(lhs: T?, rhs: T?) -> Bool
+func ==(lhs: _ConcatenateBidirectionalIndex, rhs: _ConcatenateBidirectionalIndex) -> Bool
+func ==(lhs: _ConcatenateForwardIndex, rhs: _ConcatenateForwardIndex) -> Bool
-/// Two `ClosedInterval`\ s are equal if their `start` and `end` are
-/// equal
-func ==(lhs: ClosedInterval, rhs: ClosedInterval) -> Bool
+func ==(a: T, b: T) -> Bool
-func ==(lhs: CFunctionPointer, rhs: CFunctionPointer) -> Bool
+func ==(lhs: _OptionalNilComparisonType, rhs: T?) -> Bool
+func ==(lhs: Bit, rhs: Bit) -> Bool
-/// Two `HalfOpenInterval`\ s are equal if their `start` and `end` are
-/// equal
-func ==(lhs: HalfOpenInterval, rhs: HalfOpenInterval