milseman

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) {

milseman

State of String: ABI, Performance, Ergonomics, and You!

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

milseman

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'
  }

milseman

// 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 }

milseman

Character Properties

• Proposal: TBD
• Authors: Michael Ilseman, Tony Allevato
• Review Manager: TBD
• Status: TBD
• Implementation: apple/swift#15880

Introduction

@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.

milseman

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) -> ())

milseman

let str1 = "a\u{1680}b"
let str2 = "a\u{0020}b"
print(str1) // "a b"
print(str2) // "a b"

milseman

print("start")

public var i = 0

// @inline(never)
// public func blackHole<T>(_ x: T) {
//   i += 1  
// }
@inline(never)

milseman

var i = 0
while i <= 0x4_0000 { 
  let size = malloc_size(malloc(i+1)) 
  print(" \(i+1) => \(size) (\(size - i))") 
  i = size 
}

64-bit MacOS:

milseman

extension String.Index {
    /// Creates a new index at the specified UTF-16 code unit offset
  ///
  /// - Parameter offset: An offset in UTF-16 code units.
  public init(offset: Int, within utf16: String.UTF16View) {
    let (start, end) = (utf16.startIndex, utf16.endIndex)
    guard offset >= 0,
          let idx = utf16.index(start, offsetBy: offset, limitedBy: end)
    else {
      self = end