Skip to content

[StdLib][RFC][DNM] Add isIdentical Methods for Quick Comparisons to Array, ArraySlice, and ContiguousArray #82438

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Draft
wants to merge 2 commits into
base: main
Choose a base branch
from
Draft

[StdLib][RFC][DNM] Add isIdentical Methods for Quick Comparisons to Array, ArraySlice, and ContiguousArray #82438

Show file tree
Hide file tree
Changes from 1 commit
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
0ccbcec
[stdlib] array identical
vanvoorden Jun 23, 2025
8fa9379
[stdlib] array identical aeic
vanvoorden Jun 25, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
30 changes: 30 additions & 0 deletions stdlib/public/core/Array.swift
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2136,3 +2136,33 @@ internal struct _ArrayAnyHashableBox<Element: Hashable>
}

extension Array: @unchecked Sendable where Element: Sendable { }

extension Array {
/// Returns a boolean value indicating whether this array is identical to
/// `other`.
///
/// Two array values are identical if there is no way to distinguish between
/// them.
///
/// Comparing arrays this way includes comparing (normally) hidden
/// implementation details such as the memory location of any underlying
/// array storage object. Therefore, identical arrays are guaranteed to
/// compare equal with `==`, but not all equal arrays are considered
/// identical.
///
/// - Performance: O(1)
@backDeployed(before: SwiftStdlib 6.3)
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I would prefer this (and everything else in this PR) to be @_alwaysEmitIntoClient instead.

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

@Azoy TBH… I have zero experience with either option. From reading through SE-0376 it sounds like backDeployed came with some advantages:

While @_alwaysEmitIntoClient can be used to back deploy APIs, there are some drawbacks to using it. Since a copy of the function is always emitted, there is code size overhead for every client even if the client's deployment target is new enough that the library API would always be available at runtime. Additionally, if the implementation of the API were to change in order to improve performance, fix a bug, or close a security hole then the client would need to be recompiled against a new SDK before users benefit from those changes.

I don't see much discussion in that proposal over when a library maintainer would still prefer _alwaysEmitIntoClient.

I did find this discussion from @lorentey:

#75433 (comment)

It sounds like one issue here was that debugDescription was used to conform to a protocol. Our isIdentical function here would not be used to conform to a protocol. It sounds like that might make safer shipping backDeployed?

But we did leave a FIXME comment:

e39613b

That we eventually want to make this backDeployed.

Hmm… would you have any more specific ideas why we prefer _alwaysEmitIntoClient here for these changes?

Copy link
Contributor

@Azoy Azoy Jun 24, 2025 •
edited
Loading

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Because @backDeployed commits this as the stdlib's ABI vs. @_aEIC which does not. If we find we need to replace this in the future with some more generalized thing or such, we pay the price of having to maintain this forever instead of just being able to update the definition. @_aEIC is the best attribute in my opinion because it is the "pay for what you use" attribute both for the stdlib and the client. The stdlib doesn't have to take the code size hit (unless it started using it in its own opaque implementation) or the ABI hit, and clients don't pay for anything unless they use it themselves or use something that uses it.

There's also the fact that @backDeployed introduces a runtime availability check for some configurations which does have a performance cost vs. @_aEIC which does not.

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

@Azoy SGTM. I'll make the changes and push a new commit. Thanks!

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

@Azoy would you have any opinion about #82055 and #82439? Same tradeoff for preferring aEIC on those?

public func isIdentical(to other: Self) -> Bool {
let lhsCount = self.count
if lhsCount != other.count {
return false
}

// Test referential equality.
if unsafe lhsCount == 0 || self._buffer.identity == other._buffer.identity {
return true
}

return false
}
}
30 changes: 30 additions & 0 deletions stdlib/public/core/ArraySlice.swift
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1586,3 +1586,33 @@ extension ArraySlice {
}
}
#endif

extension ArraySlice {
/// Returns a boolean value indicating whether this array is identical to
/// `other`.
///
/// Two array values are identical if there is no way to distinguish between
/// them.
///
/// Comparing arrays this way includes comparing (normally) hidden
/// implementation details such as the memory location of any underlying
/// array storage object. Therefore, identical arrays are guaranteed to
/// compare equal with `==`, but not all equal arrays are considered
/// identical.
///
/// - Performance: O(1)
@backDeployed(before: SwiftStdlib 6.3)
public func isIdentical(to other: Self) -> Bool {
let lhsCount = self.count
if lhsCount != other.count {
return false
}

// Test referential equality.
if unsafe lhsCount == 0 || self._buffer.identity == other._buffer.identity {
return true
}

return false
}
}
20 changes: 20 additions & 0 deletions stdlib/public/core/ContiguousArray.swift
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1495,3 +1495,23 @@ extension ContiguousArray {

extension ContiguousArray: @unchecked Sendable
where Element: Sendable { }

extension ContiguousArray {
/// Returns a boolean value indicating whether this array is identical to
/// `other`.
///
/// Two array values are identical if there is no way to distinguish between
/// them.
///
/// Comparing arrays this way includes comparing (normally) hidden
/// implementation details such as the memory location of any underlying
/// array storage object. Therefore, identical arrays are guaranteed to
/// compare equal with `==`, but not all equal arrays are considered
/// identical.
///
/// - Performance: O(1)
@backDeployed(before: SwiftStdlib 6.3)
public func isIdentical(to other: Self) -> Bool {
self._buffer.identity == other._buffer.identity
}
}