| let str1 = "a\u{1680}b" | |
| let str2 = "a\u{0020}b" | |
| print(str1) // "a b" | |
| print(str2) // "a b" |
| protocol ESI { | |
| // Interpolate a segment | |
| mutating func addSegment<T>(_ t: T) | |
| // Interpolate a literal | |
| mutating func addLiteral(_ s: String) | |
| // Compiler will produce closure to pass to this init. Closure will consist | |
| // of calls to writeSegment and writeLiteral | |
| init(performingInterpolation: (inout Self) -> ()) |
@allevato (a co-author here) proposed Add Unicode Properties to Unicode.Scalar, which exposes Unicode properties from the Unicode Character Database. These are Unicode expert/enthusiast oriented properties that give a finer granularity of control and answer highly-technical and specific Unicody enquiries.
| // Eat/seek/peek | |
| extension Collection where SubSequence == Self, Element: Equatable { | |
| mutating func eat() -> Element { | |
| defer { self = self.dropFirst() } | |
| return peek() | |
| } | |
| mutating func eat(_ n: Int) -> SubSequence { | |
| let (pre, rest) = self.seek(n) | |
| defer { self = rest } |
| struct S1 { | |
| var stored: UInt? | |
| init(_ x: UInt) { | |
| if x > 42 { | |
| self.init(_big: x) | |
| return | |
| } | |
| self.stored = x // <--- error: 'self' used before 'self.init' call or assignment to 'self' | |
| } |
Hello, I’ve been working on implementing, optimizing, and improving String in preparation for ABI stability, and I thought I’d share the current status of String in Swift 5 and some potential directions to go. This is the product of conversations with open source contributors and my colleagues on the Swift standard library team at Apple.
The primary area of focus is stabilizing String’s ABI, but we’d be remiss if we couldn’t also fit in performance and ergonomic improvements. String’s ergonomics in particular is one area where we think the status quo is woefully inadequate, and over half of this email is devoted to that topic. At the end, there’s a section about a community initiative that we hope can help users of String as well as guide future development.
(Note: I’m sending this to swift-dev because much of the contents revolve around implementation concerns. I’ll also cross-reference on swift-evolution and swift-users. See also the [StringManife
| extension String { | |
| public func _compareStringLinux(_ rhs: String) -> Int { | |
| // Fast lexigraphic comparison of (composed) pre-normalized prefixes | |
| var lhsCore = self._core | |
| var rhsCore = rhs._core | |
| let minCount = Swift.min(lhsCore.count, rhsCore.count) | |
| for idx in 0..<minCount { | |
| // Detect when pre-normalization ends: Quick check if next code unit might be combining | |
| if idx+1 < minCount && (lhsCore[idx+1] >= 0x300 || rhsCore[idx+1] >= 0x300) { |