<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Jaeyoung An on Medium]]></title>
        <description><![CDATA[Stories by Jaeyoung An on Medium]]></description>
        <link>https://medium.com/@jaeyoungan?source=rss-5b33de1fbe00------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*Krl04t87RAsLyKfBO1qlqg@2x.jpeg</url>
            <title>Stories by Jaeyoung An on Medium</title>
            <link>https://medium.com/@jaeyoungan?source=rss-5b33de1fbe00------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 04:42:15 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@jaeyoungan/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[What’s new in Swift 6.2]]></title>
            <link>https://jaeyoungan.medium.com/whats-new-in-swift-6-2-29f60d805152?source=rss-5b33de1fbe00------2</link>
            <guid isPermaLink="false">https://medium.com/p/29f60d805152</guid>
            <category><![CDATA[whats-new]]></category>
            <category><![CDATA[swift]]></category>
            <dc:creator><![CDATA[Jaeyoung An]]></dc:creator>
            <pubDate>Wed, 30 Jul 2025 03:28:49 GMT</pubDate>
            <atom:updated>2025-08-07T05:05:16.349Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/750/0*wYLlxbuhqCICeiX1.png" /></figure><h3><strong>[SE-0458] Opt-in Strict Memory Safety Checking</strong></h3><p>메모리 안전성을 엄격하게 검사하는 모드가 도입되어 컴파일러가 memory-unsafe 한 API 및 구문에 대해 경고한다. 이 모드는 -strict-memory-safety 컴파일러 플래그를 통해 활성화할 수 있다.</p><pre>func evilMalloc(size: Int) -&gt; Int {<br>  // use of global function &#39;malloc&#39; involves unsafe type &#39;UnsafeMutableRawPointer&#39;<br>  return Int(bitPattern: malloc(size))<br>}</pre><p>이러한 경고는 StrictMemorySafety에 속하며, unsafe 키워드를 통해 숨길 수 있다.</p><pre>func evilMalloc(size: Int) -&gt; Int {<br>  return unsafe Int(bitPattern: malloc(size)) // no warning<br>}</pre><h3><strong>[SE-0419] Swift Backtrace API</strong></h3><p>Backtrace는 call stack을 출력해서 호출되었던 함수들을 순차적으로 나타내어 런타임 에러가 발생한 지점을 추적할 수 있다. 현재는 iOS, macOS 플랫폼에서 Thread.callStackSymbols로 확인할 수 있다.</p><pre>let backtrace = Thread.callStackSymbols<br>for line in backtrace {<br>  print(line)<br>  // 0   MyAppName     0x0000000101234567 main + 42<br>  // 1   libdyld.dylib 0x0000000187654321 start + 1<br>  // 2   UIKitCore     0x0000000198765432 -[UIApplication _run] + 0x100<br>  // ...<br>}</pre><p>Swift 6.2는 Runtime 모듈이 도입되어 macOS와 Linux에서 Backtrace를 생성할 수 있다.</p><pre>import Runtime<br><br>func foo() {<br>  // Without symbols<br>  let backtrace = try! Backtrace.capture()<br><br>  print(backtrace)<br><br>  // With symbol lookup<br>  let symbolicated = backtrace.symbolicated()!<br><br>  print(symbolicated)<br>}</pre><h3><strong>Ambiguity Handling in Unavailable Contexts</strong></h3><p>컴파일러는 잠재적으로 사용할 수 없는 선언에 대한 참조를 하지 않는다.</p><pre>struct A {}<br>struct B {}<br><br>func potentiallyAmbiguous(_: A) {}<br><br>@available(macOS, *)<br>func potentiallyAmbiguous(_: B) {}<br><br>@available(macOS, unavailable)<br>func unavailableOnMacOS() {<br>  potentiallyAmbiguous(.init()) // error: ambiguous use of &#39;init()&#39;<br>}</pre><p>Swift 6.2 이전의 컴파일러는 potentiallyAmbiguous(.init()) 코드에서 컴파일 에러가 발생한다. unavailableOnMacOS 함수는 macOS 플랫폼에서만 호출할 수 있어서 potentiallyAmbiguous(_: B) 함수가 호출되기를 기대하지만 컴파일러는 potentiallyAmbiguous(_: A) 함수도 고려하기 때문이다.</p><p>Swift 6.2 컴파일러는 더 이상 잠재적으로 사용할 수 없는 선언에 대한 참조를 진단하지 않는다. 따라서 potentiallyAmbiguous(.init())에서 컴파일 에러가 발생하지 않고 potentiallyAmbiguous(_: B) 함수가 호출된다.</p><h3><strong>[SE-0451] Raw identifiers</strong></h3><p>식별자를 만드는 데 사용할 수 있는 범위(변수, 함수, 열거헝 케이스 등의 이름)가 확장되어 Backtick(`) 안에 원하는 이름을 지정할 수 있다.</p><pre>@Test<br>func `square returns x * x`() {<br>  #expect(square(4) == 4 * 4)<br>}<br><br>`square returns x * x`()</pre><p>이러한 명명법은 식별자의 이름이 숫자인 경우에 유용하다. Swift 6.2 이전에는 식별자를 만드는 데 사용할 수 있는 범위가 좁아서 HTTPStatus.error404와 같은 이름을 사용하여 코드베이스가 복잡해지는 문제가 있지만, Swift 6.2 이후에는 개선되었다.</p><pre>enum HTTPStatus {<br>  case `200`<br>  case `404`<br>  case `500`<br>}<br><br>func handle(status: HTTPStatus) {<br>  switch status {<br>  case .`200`:<br>    // ..<br>  case .`404`:<br>    // ..<br>  case .`500`:<br>    // ..<br>  }<br>}</pre><p>이는 FFI (Foreign Function Interface, 외부 언어의 함수를 호출하기 위한 인터페이스) 혹은 코드 생성에 의해 도입된 외부 식별자에도 사용될 수 있다. 예를 들어, 리소스에 대한 접근자를 생성하는 도구는 raw identifier를 사용하여 리소스 이름과 직적 매핑하여 복잡성을 줄일 수 있다.</p><pre>extension UIImage {<br>  static var `10.circle`: UIImage { ... }<br>}</pre><p>Raw identifier는 Swift Testing에서 가장 유용하게 사용된다. Swift 6.2 이전에는 @Test 안에 테스트 함수에 대한 설명을 적었다면, Swift 6.2 이후에는 테스트 함수의 이름을 Raw identifier로 선언할 수 있다.</p><pre>import Testing<br><br>@Test(&quot;Strip HTML tags from string&quot;)<br>func stripHTMLTagsFromString() { ... }<br><br>@Test<br>func `Strip HTML tags from string`() { ... }</pre><p>또한 Raw identifier는 +, — 와 같은 연산자 문자를 포함할 수 있지만, 연산자 문자만 포함할 수는 없다.</p><pre>@Test<br>func `square returns x * x`() {<br>  #expect(square(4) == 4 * 4)<br>}</pre><h3><strong>[SE-0477] Default Value in String Interploations</strong></h3><p>Swift 6.2 이전에는 Optional 타입의 값이 nil인 경우 ?? 연산자를 사용하여 기본값을 제공했다.</p><pre>let name: String? = nil<br>print(&quot;Hello, \(name ?? &quot;new friend&quot;)!&quot;)</pre><p>Swift 6.2 이후에는 ?? 연산자 대신에 default 파라미터에 기본값을 제공할 수 있다.</p><pre>print(&quot;Hello, \(name, default: &quot;new friend&quot;)!&quot;)</pre><p>이러한 보간법은 Optional과 다른 타입의 기본값을 제공할 때 유용하다. 예를 들어, ?? 연산자를 사용하면 다른 타입의 기본값을 제공할 수 없다.</p><pre>var age: Int? = nil<br>print(&quot;Age: \(age ?? &quot;Unknown&quot;)&quot;) // X</pre><p>반면에 새로운 보간법은 age의 값이 nil일 경우, 다른 타입의 기본값을 제공할 수 있다.</p><pre>print(&quot;Age: \(age, default: &quot;Unknown&quot;)&quot;)</pre><h3><strong>[SE-0459] Add </strong><strong>Collection conformances for </strong><strong>enumerated()</strong></h3><p>Swift 6.2 이후에는 EnumeratedSequence 타입이 Collection 프로토콜을 준수한다. 따라서 EnumeratedSequence 타입이 prefix, suffix, map, filter 등 Collection API를 사용할 수 있다.</p><pre>let array = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]<br>let item = array.enumerated()[1]<br>print(item) // Prints (offset: 1, element: &quot;b&quot;)</pre><p>또한 index로 접근할 수 있어서 성능상 이점도 있다.</p><pre>(1000..&lt;2000).enumerated().dropFirst(n)</pre><p>Swift 6.2 이전에는 첫 번째 요소부터 n번째 요소까지 순차적으로 탐색하여 선형 시간(O(n)) 작업이였지만, Swift 6.2 이후부터는 요소에 바로 접근할 수 있어서 상수 시간(O(1)) 작업이다.</p><h3><strong>[SE-0479] Method and Initializer Key Paths</strong></h3><p>메서드와 이니셜라이저를 KeyPath로 참조할 수 있다.</p><pre>struct Greeter {<br>  func greet(name: String) -&gt; String {<br>    &quot;Hello, \(name)!&quot;<br>  }<br>}<br><br>let method = \Greeter.greet<br>let greeting = Greeter()[keyPath: method](&quot;Swift&quot;)</pre><p>Greeter 타입의 greet 함수에 대한 KeyPath를 정의하고, 이를 keyPath 파라미터에 전달할 수 있다. 메서드 뿐만 아니라 이니셜라이저도 KeyPath로 참조할 수 있다.</p><pre>struct Person {<br>  var name: String<br>  var age: Int<br>}<br><br>let person = \Person.init(name:age:)<br>Person.self[keyPath: person](&quot;Riley&quot;, 30)</pre><p>이러한 KeyPath 표현식은 인수가 포함되거나 포함되지 않는 두 가지 형태로 참조할 수 있다.</p><pre>struct Calculator {<br>  func square(of number: Int) -&gt; Int {<br>    return number * number * multiplier<br>  }<br><br>  init(multiplier: Int) {<br>    self.multiplier = multiplier<br>  }<br>}<br><br>let squareWithoutArgs: KeyPath&lt;Calculator, (Int) -&gt; Int&gt; = \Calculator.square<br>let squareWithArgs: KeyPath&lt;Calculator, Int&gt; = \Caculator.square(of: 3)</pre><p>만약 멤버가 정적 메서드, 클래스 메서드와 같이 메타 타입인 경우, Type을 포함해야 한다.</p><pre>struct Calculator {<br>  static func add(_ a: Int, _ b: Int) -&gt; Int {<br>    return a + b<br>  }<br>}<br><br>let addKeyPath: KeyPath&lt;Calculator.Type, Int&gt; = \Caculator.Type.add(4, 5)</pre><p>또한 고차 함수와 같이 클로저가 예상되는 표현식에서 사용할 수 있다.</p><pre>struct Calculator {<br>  func power(of base: Int, exponent: Int) -&gt; Int {<br>    return Int(pow(Double(base), Double(exponent)))<br>  }<br>}<br><br>let calculators = [Calculators(), Calculator()]<br>let results = calculators.map(\.power(of: 2, exponent: 3)</pre><h3><strong>[SE-0481] </strong><strong>weak let</strong></h3><p>Swift는 weak를 사용하여 객체가 destroyed 될 때, 변수 값이 nil로 변경된 것처럼 보이게 한다. 따라서 let 대신 var 키워드로 약한 참조를 선언했다. 이로 인해서 <a href="https://github.com/swiftlang/swift-evolution/blob/main/proposals/0302-concurrent-value-and-concurrent-closures.md">sendability checking</a>과 불필요한 friction이 발생한다.</p><pre>final class C: Sendable {}<br><br>final class VarUser: Sendable {<br>  // error: stored property &#39;ref1&#39; of &#39;Sendable&#39;-conforming class &#39;VarUser&#39; is mutable<br>  weak var ref1: C?<br>}</pre><p>현재 weak stored property가 있는 클래스는 Sendable이 될 수 없다. 왜냐하면 var는 변경 가능해야 하지만, Sendable 클래스에서는 변경 가능한 property가 허용되지 않기 때문이다.</p><p>이러한 경우 약한 참조를 변경 불가능하게 허용하면 해결되지만 Swift 6.2 이전에는 허용되지 않는다. Swift 6.2 이후에는 property를 생성한 후에는 값을 변경할 수 없지만 destroyed 될 수 있도록 weak let을 허용한다.</p><pre>final class User: Sendable {<br>  let id = UUID()<br>}<br><br>final class Session: Sendable {<br>  weak let user: User?<br><br>  init(user: User?) {<br>    self.user = user<br>  }<br>}</pre><p>User, Session 클래스는 다음과 같이 사용할 수 있다.</p><pre>var user: User? = User()<br>let session = Session(user: user)<br>print(session.user?.id ?? &quot;No ID&quot;)<br><br>user = nil<br>print(session.user?.id ?? &quot;No ID&quot;)</pre><p>또한 let으로 선언했기 때문에 새로운 값을 다시 할당할 수 없다.</p><pre>session.user? = User()<br>session.user = nil</pre><h3><strong>[SE-0453] </strong><strong>InlineArray, a fixed-size array</strong></h3><p>Swift에서 배열은 순서가 있는 목록에 항목을 넣을 때 사용된다. 하지만 고정된 크기가 아니라 heap에 할당된 확장 가능한 구조이며, 이는 경우에 따라 불필요한 비용이 발생한다.</p><p>차선책으로 튜플을 사용할 수 있지만, 배열의 subscription 특성을 사용할 수 없어서 동적 인덱싱이나 반복을 허용하지 않기 때문에 매우 제한적이다.</p><pre>func complexAlgorithm() {<br>  let elements = (first, second, third, fourth)<br><br>  for i in 0..&lt;4 {<br>    // error: cannot access element using subscript for tuple types<br>    // &#39;(Int, Int, Int, Int)&#39;; use &#39;.&#39; notation instead<br>    compute(elements[i])<br>  }<br>}</pre><p>Swift 6.2는 튜플의 고정된 크기와 배열의 subscription 특성을 결합한 InlineArray 타입을 도입한다. 이는 상황에 따라 적절한 할당 패턴을 사용하여, 대부분의 경우 스택에 할당되지만, class property로 선언되었다면 heap에 할당된다.</p><pre>func complexAlgorithm() {<br>  // This is a stack allocation, no &#39;malloc&#39;s or reference counting here!<br>  let elements: InlineArray&lt;4, Int&gt; = [1, 2, 3, 4]<br>}</pre><p>InlineArray는 Sequence와 Collection 모두 준수하지 않으므로, 만약 배열을 순회하려면 indices를 사용해야 한다.</p><pre>for i in elements.indices {<br>  compute(elements[i]) // OK<br>}</pre><h3>[SE-0483] InlineArray Type Sugar</h3><p>InlineArray 타입에 대한 단축 구문이 추가된다. 새로운 구문은 배열의 크기와 요소의 타입을 나타내고, of를 구분 기호로 사용한다.</p><pre>let fiveIntegers: [Int] = .init(reapting: 99, count: 5)<br><br>/// Sugar<br>let fiveIntegers: [5 of Int] = .init(reapting: 99)</pre><p>또한 일반적인 구문에 적용할 수 있는 모든 규칙이 적용된다.</p><pre>// Nesting<br>let fiveByFive: [5 of [5 of Int]] = .init(repeating: .init(repeating: 99))<br><br>// Inference from context:<br>let fiveIntegers: [5 of _] = .init(repeating: 99)<br>let fourBytes: [_ of Int8] = [1, 2, 3, 4]<br>let fourIntegers: [_ of _] = [1, 2, 3, 4]<br><br>// Use on rhs<br>let fiveDoubles = [5 of _](repeating: 1.23)</pre><h3><strong>[SE-0448] Regex lookbehind assertions</strong></h3><p>정규식 문법 중 Lookbehind를 지원한다.</p><ul><li>(?&lt;=Y)X : X if after Y</li><li>(?&lt;!Y)X : X if not after Y</li></ul><pre>&quot;abc&quot;.firstMatch(of: /a(?&lt;=a)bc/)  // matches &quot;abc&quot;<br>&quot;abc&quot;.firstMatch(of: /a(?&lt;=b)c/)   // no match<br>&quot;abc&quot;.firstMatch(of: /a(?&lt;=.)./)   // matches &quot;ab&quot;<br>&quot;abc&quot;.firstMatch(of: /ab(?&lt;=a)c/)  // no match<br>&quot;abc&quot;.firstMatch(of: /ab(?&lt;=.a)c/) // no match<br>&quot;abc&quot;.firstMatch(of: /ab(?&lt;=a.)c/) // mathces &quot;abc&quot;</pre><h3><strong>[SE-0446] Nonescapable Types</strong></h3><p>@escaping은 클로저가 함수 외부에서 실행될 수 있어서 힙에 저장되기 때문에 스택보다 더 많은 리소스를 사용한다. Swift 6.2는 함수의 범위를 벗어날 수 없는 non-escapable 타입을 도입하여, 클로저를 더욱 안전하게 사용할 수 있다.</p><pre>struct NotEscapable: ~Escapable {<br>  ...<br>}<br><br>func f() -&gt; NotEscapable {<br>  let ne = NotEscapable()<br>  borrowingFunc(ne) // OK to pass to borrowing function<br>  let another = ne // OK to make local copies<br>  globalVar = ne // Cannot assign ~Escapable type to a global var<br>  return ne // Cannot return ~Escapable type<br>}</pre><p>non-escapable으로 선언된 NotEscapable 타입을 globalVar = ne와 return ne와 같이 f 함수 외부로 할당하거나 반환할 수 없다. 이는 함수 외부로 벗어날 수 없도록 컴파일 타임에 보장할 수 있고, 런타임에 <a href="https://en.wikipedia.org/wiki/Escape_analysis">Escape analysis</a>를 하지 않아서 성능상 이점도 있다.</p><p>또한 escapable 클로저는 외부의 mutable state를 캡처 할 수 있는데, 다른 코드에서 이 값에 접근할 수 있기 때문에 data racing 문제가 발생할 수 있다.</p><pre>var x = 10<br><br>func captureEscapable(_ fn: @escaping () -&gt; Void) {<br>  fn()<br>  fn()<br>}<br><br>captureEscapable {<br>  x += 1<br>}</pre><p>반면에 non-escapable은 mutable state에 대한 캡처는 허용되지만, scope가 제한되어 있으므로 다른 코드에서 동시에 접근할 수 없기 때문에 메모리 안전성이 높다.</p><h3>[SE-0452] Integer Generic Parameters</h3><p>Swift 6.2는 Generic 타입을 Int 타입의 매개변수화하는 기능이 추가된다.</p><pre>struct Vector&lt;let count: Int, Element&gt; { ... }</pre><p>이는 특정 입력 또는 출력 크기를 갖는 연산의 표현이나, inline storage의 고정된 크기를 나타내는 등 타입에 대한 정보에 정수를 포함시킬 수 있다.</p><pre>struct Matrix4x4 {<br>  var matrix: Vector&lt;4, Vector&lt;4, Double&gt;&gt;<br>}<br><br>// 아래와 같이 인스턴스화할 수 있다.<br>struct Matrix&lt;let columns: Int, let rows: Int&gt; {<br>  var matrix: Vector&lt;columns, Vector&lt;rows, Double&gt;&gt;<br>}</pre><p>매개변수화된 columns와 rows는 Matrix의 정적 상수 멤버가 된다.</p><pre>public struct Matrix&lt;let columns: Int, let rows: Int&gt; {<br>  // 아래와 같이 암묵적으로 정적 상수 멤버를 갖는다.<br>  // public static var columns: Int { get }<br>  // public static var rows: Int { get }<br>}<br><br>let matrix = Matrix&lt;4, 3&gt;<br>print(matrix.columns) // prints 4<br>print(matrix.rows)    // prints 3</pre><p>또한 일반적인 Generic 함수와 같이 호출자가 제공한 값에서 타입을 추론한다.</p><pre>func matmul&lt;let a: Int, let b: Int, let c: Int&gt;(<br>  _ l: Matrix&lt;a, b&gt;,<br>  _ r: Matrix&lt;b, c&gt;<br>) -&gt; Matrix&lt;a, c&gt; { ... }<br><br>let m1 = Matrix&lt;4, 2&gt;(...)<br>let m2 = MAtrix&lt;2, 5&gt;(...)<br>let m3 = matmul(m1, m2) // a = 4, b = 2, c = 5, result type is Matrix&lt;4, 5&gt;</pre><h3><strong>[SE-0474] Yielding accessors</strong></h3><p>Swift의 get과 set 본문은 기존 메서드처럼 동작하는데, 값을 읽고 쓰기 위해서는 복사본을 생성해야 한다. 이는 Swift 5.9에 추가된 non-copyable 타입에서는 사용할 수 없는 문제가 있다.</p><p>Swift 6.2는 yielding 접근자가 추가되어서, 복사본을 생성하지 않고 호출자에게 값에 대한 접근을 제공한다. 이는 non-copyable에 필수적이며, copyable 타입에서도 성능 향상에 도움이 된다.</p><h4>yielding borrow</h4><p>복사본을 생성하지 않고 값을 빌려온다. 읽기 전용 접근자로, get을 추가적으로 제공할 수 없다.</p><pre>struct UniqueString: ~Copyable ( ... }<br><br>struct UniqueBorrow: ~Copyable { <br>  var x: UniqueString<br><br>  var property: UniqueString {<br>    yielding borrow {<br>      yield x<br>    }<br>  }<br>}</pre><p>property가 호출되면 self를 빌려온 후, yield에 도달할 때까지 실행된다. 그리고 yield에 도달하면 일시 중단되어 반환된 값을 호출자에게 다시 빌려준다. 호출자가 값에 대한 접근을 마치면 접근자의 실행이 재개된다. 접근자는 yield 후 중단된 지점에서 계속 실행된다.</p><h4>yielding mutate</h4><p>복사본을 생성하지 않고 값을 변경할 수 있다. 쓰기 전용 접근자로, set을 추가적으로 제공할 수 없다.</p><pre>struct GetMutate {<br>  var x: String = &quot;👋🏽 Hello&quot;<br><br>  var property: String {<br>    get { print(&quot;Getting&quot;, x); return x }<br>    yielding mutate {<br>      print(&quot;Yielding&quot;, x)<br>      yield &amp;x<br>      print(&quot;Post yield&quot;, x)<br>    }<br>  }<br>}<br><br>var getMutate = GetMutate()<br>getMutate.property.append(&quot;, 🌍!&quot;)<br>// prints:<br>// Yielding 👋🏽 Hello<br>// Post yield 👋🏽 Hello, 🌍!</pre><p>호출자에게 변경 가능한 접근을 허용하기 때문에 inout과 유사하게 &amp;을 사용하여 yield &amp;x 전달한다. 실행이 완전히 끝날 때까지 값의 소유권을 유지하기 때문에 안전하게 작업을 수행할 수 있다.</p><p>yielding borrow 접근자와 달리, set을 추가적으로 제공할 수 있다. 전체 값을 재할당하는 경우에는 set 접근자가 적절할 수 있다.</p><pre>struct GetMutate {<br>  var x: String = &quot;👋🏽 Hello&quot;<br><br>  var property: String {<br>    get { x }<br>    yielding mutate { yield &amp;x }<br>    set { print(&quot;Setting&quot;, newValue); x = newValue }<br>  }<br>}<br><br>var getSetMutate = GetSetMutate()<br>getSetMutate.property = &quot;Hi 🌍, &#39;sup?&quot;<br>// prints:<br>// Setting Hi 🌍, &#39;sup?</pre><h3><strong>[SE-0469] </strong><strong>Task Naming</strong></h3><p>Swift Concurrency 이전 세대의 동시성 기술에서는 디버거가 작업을 식별할 수 있도록 일종의 레이블을 사용한다. 예를 들어, DispatchQueue는 초기화 시 label에 문자열 타입의 이름을 지정할 수 있다.</p><pre>let rootQueue = DispatchQueue(label: &quot;org.alamofire.session.rootQueue&quot;)</pre><p>하지만 Swift Concurrency의 Task 타입은 이름을 지정할 수 있는 기능이 없어서, 외부에서 시스템을 확인할 때 작업을 식별하는 데 어려움을 겪을 수 있다. Task 타입의 이름을 지정할 수 있을 때 얻는 이점을 살펴보자.</p><pre>let getUsers = Task {<br>  await users.get(accountID))<br>}</pre><p>getUsers와 같이 이름을 지정하지 않은 Task를 디버깅 할 때, 어떤 accountID에 해당하는 사용자인지 파악하기 어렵다.</p><pre>let getUsers = Task(&quot;Get Users for \(accountID)&quot;) {<br>  await users.get(accountID)<br>}</pre><p>위와 같이 Task를 식별할 수 있는 이름을 지정하면 디버거는 문제가 발생한 accountID가 정확히 무엇인지 보여줄 수 있다.</p><h3>[SE-0480] Warning Control Settings for SwiftPM</h3><p>SwiftPM에서 경고를 처리하는 방식을 제어하기 위해 unsafeFlags를 사용한다.</p><pre>.target(<br>  name: &quot;Target&quot;,<br>  swiftSettings: [<br>    .unsafeFlags([&quot;-warnings-as-errors&quot;])<br>  ]<br>)</pre><p>하지만 unsafeFlags는 툴체인 마다 사용하는 방식에 차이가 있어 컴파일러에 종속적이며, 외부에서 플래그를 재정의 할 수 있어서 안정성이 낮은 단점이 있다.</p><p>Swift 6.2는 SwiftPM에 새로운 설정을 추가하여, 툴체인 혹은 플랫폼에 맞게 처리할 수 있고, 일부 API는 unsafeFlags와 같이 문자열을 직접 입력하지 않고 안전한 타입으로 제공한다.</p><pre>.target(<br>  name: &quot;Library&quot;,<br>  swiftSettings: [<br>    .treatAllWarnings(as: .error),<br>    .treatWarning(&quot;DeprecatedDeclaration&quot;, as: .warning),<br>  ],<br>  cSettings: [<br>    .enableWarning(&quot;all&quot;),<br>    .disableWarning(&quot;unused-function&quot;),<br>    .treatAllWarnings(as: .error),<br>    .treatWarning(&quot;unused-variable&quot;, as: .warning),<br>  ],<br>  cxxSettings: [<br>    .enableWarning(&quot;all&quot;),<br>    .disableWarning(&quot;unused-function&quot;),<br>    .treatAllWarnings(as: .error),<br>    .treatWarning(&quot;unused-variable&quot;, as: .warning),<br>  ]<br>)</pre><p>현재 C/C++의 경고 그룹에 대한 이름(unused-function, unused-variable)은 <a href="https://gcc.gnu.org/onlinedocs/gcc-3.4.4/gcc/Warning-Options.html?utm_source=chatgpt.com">GCC Warning Options</a> 문서에서 확인할 수 있지만, Swift 경고 그룹에 대한 이름은 확인할 수 없다. 따라서 자동 완성으로 입력할 수 있도록 안전한 타입을 향후 지원할 것이다.</p><h3>[SE-0447] Span: Safe Access to Contiguous Storage</h3><p>연속 메모리에 안전하게 접근할 수 있는 타입이 추가되었다. 이전에는 연속 메모리(Array, ArraySlice, ContiguousArray 등)의 내부 버퍼에 접근하려면 withUnsafeBufferPointer를 사용했다.</p><pre>array.withUnsafeBufferPointer { pointer in <br>  for i in 0..&lt;pointer.count {<br>    print(pointer[i])<br>  }<br>}</pre><p>이는 안전하지 않은 메모리에 접근하기 때문에 위험 부담이 있다. 또한 버퍼에 대한 사용이 끝나면 포인트가 더 이상 유효하지 않으므로 <a href="https://cwe.mitre.org/data/definitions/416.html">use-after-free</a>가 발생할 수 있다.</p><p>Swift 6.2는 연속 메모리에 있는 값에 대한 로컬 처리를 위해 안전하고 성능이 좋은 Span 타입이 추가된다.</p><pre>@frozen<br>public struct Span&lt;Element: ~Copyable&gt;: Copyable, ~Escapable { ... }</pre><p>Span의 선언부를 보면 ~Escapable을 준수하고 있어서 scope 외부에서 사용할 수 없으므로, 메모리가 해제된 후 참조될 수 없다. 이는 <a href="https://cwe.mitre.org/data/definitions/416.html">use-after-free</a>를 방지할 수 있다.</p><pre>let array = [1, 2, 3]<br>let span: Span&lt;Int&gt; = array.span<br>for i in 0..&lt;span.count {<br>  print(span[i])<br>}</pre><p>또한 Span.Element는 ~Copyable로 제한되어, Span과 동일한 수명을 가진다. 즉, Span은 ~Copyable, ~Escapable의 조합으로 연속 메모리에 안전하게 접근할 수 있다.</p><h4>Generic buffer</h4><p>Swift는 Array, ArraySlice, ContiguousArray, InlineArray, C++ stp::span 등 다양한 연속 메모리 타입이 존재하지만, 각 버퍼를 처리하기 위해서 타입별로 overload를 하거나, withUnsafeBufferPointer를 사용했다.</p><pre>func applyGrayScale&lt;T: Collection&gt;(_ buffer: T) where T.Element == RGBA {<br>  buffer.withContiguousStorageIfAvailable { pointer in <br>    for i in 0..&lt;pointer.count {<br>      ...<br>    }<br>  }<br>}<br><br>func applyGrayScale(_ array: [RGBA]) { ... }<br>func applyGrayScale(_ slice: ArraySlice&lt;RGBA&gt;) { ... }<br>func applyGrayScale(_ inline: InlineArray&lt;RGBA&gt;) { ... }</pre><p>이러한 불편함은 Span과 Generic 타입을 사용하여, 범용적으로 버퍼를 처리하는 함수를 작성하여 해소할 수 있다.</p><pre>func applyGrayScale(_ pixels: Span&lt;RGBA&gt;) { ... }<br>applyGrayScale(image.pixels.span)<br>applyGrayScale(inlinePixels.span)</pre><h3>[SE-0456] Add Span-providing Properties to Standard Library Types</h3><h3>[SE-0464] UTF8Span: Safe UTF-8 Processing Over Contiguous Bytes</h3><h3>[SE-0467] MutableSpan and MutableRawSpan: delegate mutations of contiguous memory</h3><h3>[SE-0465] Standard Library Primitives for Nonescapable Types</h3><h3><strong>[SE-0462] Task Priority Escalation APIs</strong></h3><p>Swift Concurrency의 Task는 자동으로 부모-자식 관계를 형성하고 자식 Task는 부모의 특성을 상속받지만, 자식 Task는 생성 시 명시적으로 우선순위를 설정하면 부모 Task와 다를 수 있다.</p><p>이때 부모 Task가 더 높은 우선순위에서 자식 Task가 완료될 때까지 대기하는 경우, 우선순위 역전 문제를 방지하기 위해 자식 Task의 우선순위가 상향 조정되는 Escalation이 이루어진다.</p><p>이러한 Escalation은 자동으로 실행되며, 개발자가 임의로 조정할 수 없다. 하지만 완전히 구조화되지 않은 Task생성을 방지할 수 없다. 예를 들어, <a href="https://github.com/apple/swift-async-algorithms/">swift-async-algorithms</a> 프로젝트의 <a href="https://github.com/apple/swift-async-algorithms/blob/4c3ea81f81f0a25d0470188459c6d4bf20cf2f97/Sources/AsyncAlgorithms/AsyncAlgorithms.docc/Guides/Merge.md">merge</a> 연산이 있다. (구조화란, async let 혹은 TaskGroup을 사용하여 부모 Task와 명확환 생명 주기 관계를 갖는 걸 의미한다.)</p><pre>struct AsyncMergeSequenceIterator: AsyncIterator {<br>  struct State {<br>    var task: Task&lt;Void, any Error&gt;? // unstructured upstream consumer task<br>    var buffer: Deque&lt;Element&gt;<br>    var upstreamContinuations: [UnsafeContinuation&lt;Void, Error&gt;]<br>    var downstreamContinuation: UnsafeContinuation&lt;Element?, Error?&gt;<br>  }<br>}<br><br>let state = Mutext&lt;State&gt;(State())<br><br>func next() async throws {<br>  self.state.withLock { state in <br>    if state.task == nil {<br>      state.task = Task {<br>        // 1<br>      }<br>    }<br>  }<br><br>  if let element = self.state.withLock { $0.buffer.popFirst() } { <br>    return element<br>  } else {<br>    // We are handling cancellation here and need to handle task escalation here as well<br>    try await withTaskCancellationHandler {<br>      // HERE: need to handle priority escalation and boot `state.task`<br>      try await withCheckedContinuation { continuation in <br>        self.state.withLock { $0.consumerContinuation = continuation }<br>      }<br>    }<br>  } onCancel: { <br>    // trigger cancellation of tasks and fail continuations<br>  }<br>}</pre><p>만약 Continuation을 중단하고 재개하려고 할 때, 현재 요소를 반복(iterate) 중인 Upstream Task가 완료되어야 Downstream의 next()가 완료될 수 있다. 이때, withTaskCancellationHandler 블록 내부에서 해당 Upstream Task의 우선순위를 높여야 한다.</p><p>Swift 6.2는 코드 블록 내에서 우선순위를 조정하는 API와, 다른 Task의 우선순위를 높이는 API를 제공한다.</p><h4>withTaskPriorityEscalationHandler</h4><pre>public func withTaskPriorityEscalationHandler&lt;T, E&gt;(<br>  operation: () async throws(E) -&gt; T,<br>  onPriorityEscalated handler: @Sendable (TaskPriority) -&gt; Void,<br>  isolation: isolated (any Actor)? = #isolation<br>) async throws(E) -&gt; T</pre><p>Task의 우선순위가 변경되면 onPriorityEscalated 클로저가 호출되어, 새로운 우선순위에 대해 반응할 수 있다.</p><h4>escalatePriority</h4><pre>extension Task {<br>  public static func escalatePriority(of task: Task, to newPriority: TaskPriority)<br>}<br><br>extension UnsafeCurrentTask {<br>  public static func escalatePriority(of task: UnsafeCurrentTask, to newPriority: TaskPriority)<br>}</pre><p>특정 Task를 원하는 우선순위로 조정한다. 일반적으로 개발자는 수동으로 Escalation 하는 것에 의존해서는 안 되지만, merge와 같이 구조화되지 않은 Task를 <em>propagate </em>해야하는 상황에서 사용할 수 있다.</p><h3><strong>[SE-0472] Starting tasks synchronously from caller context</strong></h3><p>Swft Concurrency의 Task는 호출하는 컨텍스트를 즉시 상속하지 않고, 실제 작업이 시작되기 전에 스케줄링 된다. 이러한 초기 지연은 최소한의 작업만 수행하는 경우 낭비일 수 있고, UI 작업과 같이 빠른 응답 시간이 중요한 경우 UX 저하를 초래할 수 있다.</p><p>Swift 6.2는 스케줄링 우선순위에 의존하지 않고 호출 직후 Task가 수행됨을 보장하는 API가 추가된다.</p><pre>// 현재 스레드: T1<br>func synchronous() {<br>  // 즉시 실행, T1<br>  let task: Task&lt;Void, Never&gt; = Task.immediate {<br>    // 동기 호출, T1 (1)<br>    guard keepRunning() else { return }<br>    // 중단 가능 지점, T1 (2)<br>    await noSuspension()<br>    // 중단 발생 (3)<br>    await suspend()<br>    // 중단 후 재개, T2 (5)<br>  }<br>  // 중단 후 실행, T1 (4)<br>}</pre><p>immediate 함수로 생성된 Task는 호출하는 실행자(executor) 혹은 스레드의 스케줄링 지연 없이 즉시 실행되어, 잠재적인 중단 지점(noSuspension)이 있어도 실제로 중단되지 않는다면 현재 스레드에서 동기 실행된다.</p><p>또한 구조화된 TaskGroup도 addImmediateTask를 호출하여 즉시 실행하려는 Task를 추가할 수 있다.</p><h3>[SE-0473] Clock Epochs</h3><p>Swift 5.7에 추가된 <a href="https://developer.apple.com/documentation/swift/clock">Clock</a>은 시간 측정 및 sleep 기능을 제공하는 프로토콜로, 용도에 따라 ContinuousClock, SuspendingClock, WallClock 타입을 사용할 수 있다.</p><pre>import Foundation<br><br>func measureExecutionTime(using clock: ContinuousClock) {<br>  let start = clock.now<br><br>  _ = (1...1_000_000).reduce(0, +)<br><br>  let end = clock.now<br>  let _ = clock.duration(from: start, to: end)<br>}</pre><p>DispatchTime, Task.sleep, Timer와 비교하면 Clock은 프로토콜이므로, 테스트 시 Mock 객체를 주입할 수 있고, 시간 연산의 일관성을 유지할 수 있다.</p><p>Swift 6.2는 SuspendingClock과 ContinuousClock에 정확한 시작 시점(0으로 간주되는 시간)에 대한 property가 추가된다.</p><pre>extension ContinuousClock {<br>  public var systemEpoch: Instant { get }<br>}<br><br>extension SuspendingClock {<br>  public var systemEpoch: Instant { get }<br>}</pre><p>Apple, Linux, Windows를 포함한 대부분의 플랫폼에서 systemEpoch는 부팅 시간에 설정되므로, 시스템의 가동 시간이나 활성 시간을 연산할 수 있다.</p><pre>let continuousClock = ContinuousClock()<br>let uptime = clock.now - clock.systemEpoch<br><br>let suspendingClock = SuspendingClock()<br>let activeTime = clock.now - clock.systemEpoch</pre><p>하지만 개인정보 보호 혹은 가동 시간(uptime) 개념이 특정 플랫폼에는 명확하게 적용되지 않으므로 모든 플랫폼에서 이를 보장할 수는 없다.</p><h3>[SE-0457] Expose attosecond representation of Duration</h3><p>Swift 5.7에 추가된 <a href="https://developer.apple.com/documentation/Swift/Duration">Duration</a>은 정확하고 안전한 단위로, 기존 TimeInterval 보다 정밀하고 명확한 시간 간격을 표현할 수 있다.</p><pre>let duration1: Duration = .milliseconds(100)<br>let duration2: Duration = .milliseconds(200)<br>let total = duration1 + duration2<br><br>if total == .milliseconds(300) {<br>  // ...<br>}</pre><p>현재 Duration으로 나노초(10⁻⁹s)까지 표현할 수 있는데, Swift 6.2는 아토초(10⁻¹⁸s)를 표현할 수 있는 타입이 추가된다.</p><pre>Duration.housrs(1)<br>Duration.minutes(1)<br>Duration.seconds(1)<br>Duration.milliseconds(1)  // 10⁻³s<br>Duration.microseconds(1)  // 10⁻⁶s<br>Duration.nanoseconds(1)   // 10⁻⁹s</pre><h3>[SE-0463] Import Objective-C completion handler parameters as @Sendable</h3><p>Swift 6.2 이전에는 performOperation 함수를 Swift 코드에서 사용하려면 경고를 해결하기 위해서 wrapping 했다.</p><pre>actor A {<br>  func f() {<br>    performOperation(&quot;Task&quot;) { result, error in <br>      // Closure parameter `completionHandler` is not Sendable<br>      // self.handle(result, error)<br><br>      Task { @Sendable in <br>        self.handle(result, error)<br>      }<br>    }<br>  }<br>}</pre><p>Swift 6.2는 Objective-C importing 규칙을 변경하여, completion handler 파라미터가 기본적으로 @Sendable이 되도록 한다.</p><pre>// Objective-C<br>- (void)performOperation:(NSString * _Nonnull)operation<br>  completionHandler:(void (^ _Nullable)(NSString * _Nullable, NSError * _Nullable)completionHandler;<br><br>// Swift<br>@preconcurrency<br>func perform(<br>  operation: String,<br>  completionHandler: @Sendable @escaping ((String?, Error?) -&gt; Void)?<br>)</pre><p>이는 Swift 6가 <a href="https://developer.apple.com/documentation/swift/adoptingswift6">Strict concurrency checking</a>를 도입하면서, Actor-isolated 코드에서 Objective-C의 not-sendable completion handler를 호출하면 런타임에 발생하는 오류를 방지하고, Swift 6 migration의 부담을 덜어준다.</p><h3>[SE-0470] Global-actor isolated conformances</h3><p>Swift 6.2 이전에는 다음과 같이 Equatable.==을 구현하면 컴파일 에러가 발생한다.</p><pre>@MainActor<br>class Model: Equatable {<br>  var name: String<br><br>  init(name: String) {<br>    self.name = name<br>  }<br><br>  // error: main-actor-isolated static func `==` cannot satisfy<br>  // non-isolated requirement `Equatable.==`.<br>  static func ==(lhs: Model, rhs: Model) -&gt; Bool {<br>    lhs.name == rhs.name<br>  }<br>}</pre><p>왜냐하면 Model은 @MainActor로 지정하여 모든 멤버 함수 및 property가 main actor에 격리되지만, Equatable.==는 actor 격리 없이 동기적으로 호출되기 때문이다. 이를 해결하려면 MainActor.assumeIsolated로 wrapping 하여, main actor에서만 고려된다는 것을 명시해야 한다.</p><pre>nonisolated static func ==(lhs: Model, rhs: Model) -&gt; Bool {<br>  MainActor.assumeIsolated {<br>    lhs.name == rhs.name<br>  }<br>}</pre><p>Swift 6.2는 프로토콜을 특정 global actor(@MainActor)에서 사용될 때만 적용할 수 있어서 더 쉽게 해결할 수 있다.</p><pre>@MainActor<br>class Model: @MainActor Equatable {<br>  ...<br><br>  static func ==(lhs: Model, rhs: Model) -&gt; Bool {<br>    lhs.name == rhs.name<br>  }<br>}</pre><h3>[SE-0371] Isolated synchronous deinit</h3><pre>@MainActor<br>class Database {<br>  func close() {<br>    // ...<br>  }<br><br>  deinit {<br>    close()<br>  }<br>}</pre><p>Database 타입은 @MainActor로 선언되어 main actor에 격리된다. 따라서 데이터베이스의 사용을 마치면 main actor에서 close 해야한다. 하지만 Swift 6.2 이전에는 기본적으로 deinit가 지정된 actor에 격리되지 않으므로, 개발자가 nil을 할당하여 ARC에 의해 deinit이 호출되도록 하였다.</p><pre>await database.close()<br>database = nil</pre><p>Swift 6.2는 actor에 격리할 수 있도록 isolated deinit을 지원한다.</p><pre>@MainActor<br>class Database {<br>  func close() {<br>    // ...<br>  }<br><br>  isolated deinit {<br>    close()<br>  }<br>}</pre><h3>[SE-0461] Run nonisolated async functions on the caller’s actor by default</h3><pre>class NotSendable {<br>  func performSync() { ... }<br>  func performAsync() async { ... }<br>}<br><br>actor A {<br>  let x: NotSendable<br><br>  func call() async {<br>    x.performSync()<br>    await x.performAsync()<br>  }<br>}</pre><p>현재 non-isolated 비동기 함수는 Global Concurrent Queue(이하 GCQ)에서 실행된다. 따라서 call 함수 내부에서 performSync와 performAsync 함수를 순차적으로 실행하면 실행자가 A -&gt; GCQ -&gt; A 순서로 전환된다. 이때 실행자간 이동으로 인해 성능이 저하될 수 있다.</p><p>이러한 부하를 줄이기 위해 Swift 6.2는 non-isolated 비동기 함수를 특정 actor에서 실행하는 키워드를 추가하여, 함수가 실행되는 위치를 세밀하게 제어하는 기능을 제공한다.</p><pre>class NotSendable {<br>  func performSync() { ... }<br><br>  nonisolated(nonsending)<br>  func performAsync() async { ... }<br>}</pre><p>이전과 달리 call 함수 내부에서 performAsync 함수는 GCQ가 아닌 A actor에서 실행되므로, 실행자간 이동이 줄어들어 성능이 향상될 수 있다.</p><h3>[SE-0475] Transactional Observation of Values</h3><p>@Observable은 지정된 타입의 property가 변화할 때, 이를 관찰하고 있는 옵저버에 전달하는 매크로다.</p><pre>@Observable<br>final class Person {<br>  var firstName: String<br>  var lastName: String<br><br>  var name: String { firstName + &quot; &quot; + lastName }<br><br>  init(firstName: String, lastName: String) {<br>    self.firstName = firstName<br>    self.lastName = lastName<br>  }<br>}</pre><p>이는 SwiftUI에 최적화되어, 변경 사항을 화면에 즉시 반영할 수 있지만, 그 외에는 변경 사항을 동기적, 단발성으로만 감지할 수 있다.</p><pre>let person = Person(firstName: &quot;John&quot;, lastName: &quot;Doe&quot;)<br>let observer = withObservationTracking {<br>  // ...<br>} onChange: {<br>  // ...<br>}</pre><p>onChange가 호출된 후 다시 옵저버를 등록해야 하므로, 반응형 스트림을 구성하기 어렵다. 따라서 @Observable은 SwiftUI와 연결되는 코드가 아니라면 주로 사용되지 않았다.</p><p>Swift 6.2는 Observation을 더 포괄적인 모듈로 확장하여 @Observable 값이 변경될 때, 새로운 값을 방출하는 AsyncSequence를 제공하는 Observations 타입을 제공한다.</p><pre>let greetings = Observations {<br>  if let pet = person.pet {<br>    return &quot;Hello \(person.name) and \(pet.name)&quot;<br>  } else {<br>    return &quot;Hello \(person.name)&quot;<br>  }<br>}</pre><h3><strong>[ST-0008] Exit tests</strong></h3><pre>func eat(_ taco: consuming Taco) {<br>  precondition(taco.isDelicious, &quot;Tasty tacos only!&quot;)<br>}</pre><p>isDelicious 값이 false라면 precondition 충돌이 발생하여 테스트가 중단되기 때문에, isDelicious가 false인 타코에 대해 확인하는 테스트를 작성하는 데 어려움이 있다.</p><pre>await #expect(processExitsWith: .failure) {<br>  var taco = Taco()<br>  taco.isDelicious = false<br>  eat(taco)<br>}</pre><p>Swift 6.2는 Swift Testing에 precondition 혹은 다른 critical failure (fatalError, assert 등)을 테스트 할 수 있는 기능이 추가되어, 지정된 충돌이 발생하는지 테스트 할 수 있다.</p><h3><strong>[ST-0009] Attachments</strong></h3><p>XCTest는 테스트 중 생성된 문자열, 이미지 등 데이터를 테스트 결과에 포함시킬 수 있는 XCTAttachment를 제공한다.</p><pre>class ..Tests: XCTestCase {<br>  func testScreenshot() {<br>    let app = XCUIApplication()<br>    app.launch()<br>    let screenshot = app.windows.firstMatch.screenshot()<br>    let attachment = XCTAttachment(screenshot: screenshot)<br>    attachment.lifetime = .keepAlways<br>    add(attachment)<br>  }<br>  <br>  func test..() throws {<br>    let customer = Customer(firstName: &quot;first&quot;, lastName: &quot;last&quot;)<br>    let json = try JSONEncoder().encode(customer)<br>    let attachment = XCTAttachment(data: json, uniformTypeIdentifier: UTType.json.identifier)<br>    attachment.lifetime = .keepAlways<br>    add(attachment)<br>  }<br>}</pre><p>XCTAttachment는 디버깅과 테스트 결과를 Xcode에 맞춰서 시각화 한다. 특히 CI와 같은 원격 환경에서 테스트가 실패하면, 원인이 무엇인지 파악하기 어려운 점을 보완한다.</p><p>Swift 6.2는 이 기능을 Swift Testing에 추가하고 Xcode 뿐만 아니라, VS Code와 같은 도구에서 새로운 첨부 파일을 생성하고 처리하는 데 필요한 인프라를 제공한다. 또한 테스트 결과에 원하는 형태로 첨부하기 위해 Attachable 타입을 정의할 수 있다.</p><pre>import Foundation<br>import Testing<br><br>struct User: Codable, Attachable {<br>  var id = UUID()<br>  var name: String<br>}<br><br>func newUser() -&gt; User {<br>  User(name: &quot;James&quot;)<br>}<br><br>@Test <br>func defaultNewUserNameIsCorrect() {<br>  let result = newUser()<br>  #expect(result.name == &quot;James&quot;)<br><br>  Attachment.record(result, named: &quot;User&quot;)<br>}</pre><p>다만, 첨부 파일은 주로 디버깅에 사용되기 때문에 테스트가 통과하면 첨부 파일을 디스크에 저장할 필요가 없을 가능성이 높다.XCTAttachment는 lifetime의 값을 설정하여 첨부 파일의 수명을 결정할 수 있는데, Swift Testing의 Attachment는 아직 지원하지 않는다. lifetime의 기본값은 deleteOnSuccess이므로 Swift Testing도 이를 따를 것으로 생각된다.</p><h3><strong>[ST-0010] Public API to evaluate </strong><strong>ConditionTrait</strong></h3><p>Swift Testing은 @Test 매크로에서 테스트 함수가 실행되기 위한 조건을 설정할 수 있다.</p><pre>@Test(&quot;Ice cream is cold&quot;, .enabled(if: Season.current == .summer))<br>func isCold() async throws { ... }</pre><p>만약 외부(비테스트 함수 혹은 타사 라이브러리 등)에서 직접 조건을 평가하려면 ConditionTrait 객체를 정의하여 prepare(for:) 내부에서 이루어져야 한다.</p><pre>struct IcecreamSeasonConditionTrait: ConditionTrait {<br>  func prepare(for test: Test) async throws {<br>    if Season.current == .summer {<br>      test.isEnabled = true<br>    } else {<br>      test.isEnabled = false<br>    }<br>  }<br>}</pre><p>Swift 6.2는 비테스트 함수 내부에서 ConditionTrait를 정의하고 evaluate를 호출하여 테스트 함수와 동일한 조건을 평가할 수 있다.</p><pre>func checkForSmokeTest() async throws {<br>  let trait = ConditionTrait.enabled(if: Season.current == .summer)<br><br>  if try await trait.evaluate() {<br>    ...<br>  } else {<br>    ...<br>  }<br>}</pre><h3>[ST-0011] Issue Handling Traits</h3><p>Swift Testing은 테스트의 결과값을 확인할 수 있는 #expect 매크로를 제공한다. 하지만 expectation이 실패하였을 때, 이를 처리하는 방법을 사용자 지정 할 수 없다.</p><p>개발자는 테스트 중 발생한 issue를 수정, 보완 또는 필터링하기 위해 사용자 지정 로직을 사용할 필요가 있다. 이를 통해 더욱 유연한 테스트 접근 방식을 구축하고, 복잡한 테스트 시나리오에서 명확성을 향상시킬 수 있다.</p><h4>compactMapIssues</h4><p>테스트에서 기록된 issue에 정보를 추가할 수 있다. 특정 issue에 대한 보충 정보를 추가하거나, 관련된 문서의 링크를 주석으로 추가할 수 있다.</p><pre>@Test(.compactMapIssues { issue in <br>  var issue = issue<br>  issue.comments.append(&quot;Checking whether two literals are equal&quot;)<br>  return issue<br>})<br>func literalComparisons() {<br>  #expect(1 == 1)      // ✅<br>  #expect(2 == 3)      // ❌ Will invoke issue handler<br>  #expect(&quot;a&quot; == &quot;b&quot;)  // ❌ Will invoke issue handler again<br>}</pre><h4>IssueHandlingTrait</h4><p>특정 issue를 처리하는 방법을 사용자 지정할 수 있다. 아래 예시는 .filterIssues를 사용하여 특정 기준을 만족하는 warning issue를 suppress(억제)하는 방법을 나타낸다.</p><pre>extension Trait where Self == IssueHandlingTrait {<br>  static var ignoreSensitiveWarnings: Self {<br>    .filterIssues { issue in <br>      let description = String(describing: issue)<br><br>      // Note: `Issue.severity` has been pitched but not accepted.<br>      return issue.severity &lt;= .warning &amp;&amp; SensitiveTerms.all.contains { description.contains($0) }<br>    }<br>  }<br>}<br><br>@Test(.ignoreSensitiveWarnings) func exampleA() { ... }</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=29f60d805152" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Strategy Pattern]]></title>
            <link>https://jaeyoungan.medium.com/strategy-pattern-912efb1ac2c7?source=rss-5b33de1fbe00------2</link>
            <guid isPermaLink="false">https://medium.com/p/912efb1ac2c7</guid>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[strategy-pattern]]></category>
            <dc:creator><![CDATA[Jaeyoung An]]></dc:creator>
            <pubDate>Mon, 07 Apr 2025 09:11:31 GMT</pubDate>
            <atom:updated>2025-04-07T11:52:44.245Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tWLQ3yV5CKfadSXWbhXUsA.png" /></figure><p>전략 패턴은 여러 알고리즘을 하나의 인터페이스로 추상화하고, 런타임에 사용할 전략을 교체할 수 있도록 구조화하는 방법입니다. 이 패턴을 적용하면 복잡한 분기 없이도 조건에 따라서 유연하게 처리할 수 있습니다. 본 글에서는 전략 패턴이 필요한 상황과 구조적 이점을 소개하고, 실제 사례를 통해 활용하는 방법을 살펴보겠습니다.</p><h3>What</h3><p>전략 패턴은 객체의 동작을 상황에 따라 교체해야 할 때 사용하는 디자인 패턴입니다. 주요 목적은 동일한 문제를 해결하는 다양한 알고리즘을 정의하고 상호 교환되도록 구조화하는 데 있으며, 일반적으로 세 가지 구성 요소로 이루어집니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/650/1*twTTnXVouSsbfHhJWuDPSA.png" /><figcaption>Wikipedia</figcaption></figure><ol><li>Interface: 알고리즘이 수행해야 할 동작 정의</li><li>Strategies: Interface를 따라서 구체적인 동작 구현</li><li>Context: Interface를 참조하여 정의된 동작 실행</li></ol><p>파일을 정렬할 때 이름순, 날짜순, 크기순 중에서 원하는 정렬 방식을 선택할 수 있습니다. 정렬이라는 동작은 동일하지만, 사용자가 선택한 방식에 따라 내부 동작이 바뀌어야 합니다. 이때 전략 패턴을 사용해서 정렬 기능을 하나의 인터페이스로 추상화하고, 정렬 방식을 각각 독립적으로 구현한 뒤 상황에 따라 교체할 수 있습니다. 아래는 전략 패턴의 예시 코드입니다.</p><pre>protocol SortingStrategy {<br>  func sort(_ data: [Int]) -&gt; [Int]<br>}<br><br>struct BubbleSort: SortingStrategy {<br>  func sort(_ data: [Int]) -&gt; [Int] {<br>    var result = data<br>    let n = result.count<br>    <br>    for i in 0..&lt;n {<br>      for j in 0..&lt;n-i-1 {<br>        if result[j] &gt; result[j + 1] {<br>          result.swapAt(j, j + 1)<br>        }<br>      }<br>    }<br><br>    return result<br>  }<br>}<br><br>struct QuickSort: SortingStrategy {<br>  func sort(_ data: [Int]) -&gt; [Int] {<br>    func _sort(_ data: [Int]) -&gt; [Int] {<br>      guard data.count &gt; 1 else { return data }<br>      let pivot = data[data.count / 2]<br>      let less = data.filter { $0 &lt; pivot }<br>      let equal = data.filter { $0 == pivot }<br>      let greater = data.filter { $0 &gt; pivot }<br>      return _sort(less) + equal + _sort(greater)<br>    }<br><br>    return _sort(data)<br>  }<br>}<br><br>struct SortingContext {<br>  var strategy: SortingStrategy<br>    <br>  func sort(_ data: [Int]) -&gt; [Int] {<br>    strategy.sort(data)<br>  }<br>}<br><br>let data = [5, 2, 8, 1, 3]<br>let bubble = SortingContext(strategy: BubbleSort())<br>let quick = SortingContext(strategy: QuickSort())</pre><p>이처럼 전략 패턴은 실행 시점에 동작을 교체할 수 있거나, 조건문이 반복되면서 코드가 복잡해질 때 구조적으로 정리하는 데 적합한 설계입니다.</p><h3>Use cases</h3><pre>func log(_ message String, toConsole: Bool) {<br>  if toConsole {<br>    print(&quot;[Console] \(message)&quot;)<br>  } else {<br>    Crashlytics.crashlytics().log(message)<br>  }<br>}</pre><p>log는 toConsole 파라미터 값에 따라서 콘솔 혹은 메모장에 로깅합니다. 이때 Analytics, Mixpanel에 로깅하는 기능을 추가하면 매우 복잡해집니다.</p><pre>func log(<br>  _ message: String, <br>  toConsole: Bool, <br>  toCrashlytics: Bool, <br>  toAnalytics: Bool, <br>  toMixpanel: Bool) <br>{<br>  if toConsole {<br>    print(&quot;[Console] \(message)&quot;)<br>  }<br><br>  if toCrashlytics {<br>    Crashlytics.crashlytics().log(message)<br>  }<br><br>  if toAnalytics {<br>    Analytics.logEvent(message, parameters: nil)<br>  }<br><br>  if toMixpanel {<br>    Mixpanel.mainInstance().track(event: message, properties: nil)<br>  }<br>}</pre><p>log 함수에 너무 많은 책임이 있고 조건문이 남용되고 있습니다. 그리고 새로운 로그 방식이 추가될수록 더 심각해집니다. 이때 전략 패턴을 사용해서 해결해 봅시다.</p><pre>protocol LoggerInterface {<br>  func log(_ message: String)<br>}<br><br>struct ConsoleLogger: LoggerInterface {<br>  func log(_ message: String) {<br>    print(&quot;[Console] \(message)&quot;)<br>  }<br>}<br><br>struct AnalyticsLogger: LoggerInterface {<br>  func log(_ message: String) {<br>    Analytics.logEvent(message, parameters: nil)<br>  }<br>}<br><br>struct MixpanelLogger: LoggerInterface {<br>  func log(_ message: String) {<br>    Mixpanel.mainInstance().track(event: message, properties: nil)<br>  }<br>}<br><br>struct LoggerContext {<br>  private let strategies: [LoggerInterface]<br>  <br>  func log(_ message: String) {<br>    strategies.forEach { $0.log(message) }<br>  }<br>}<br><br>let logger = LoggerContext(strategies: [<br>  ConsoleLogger(),<br>  CrashlyticsLogger()<br>])</pre><p>만약 Sentinel 플랫폼이 추가되면 LoggerInterface에 따라서 SentinelLogger를 구현하고 LoggerContext의 strategies 파라미터에 추가하면 됩니다. 이와 같이 전략 패턴을 사용함으로써 조건문과 파라미터가 남발되었던 로그 시스템을 개선했습니다.</p><p>Swift의 표준 라이브러리에서도 전략 패턴을 사용하고 있습니다.</p><pre>public enum DateDecodingStrategy {<br>  case deferredToDate<br>  case secondsSince1970<br>  case millisecondsSince1970<br>  case iso8601<br>  case formatted(DateFormatter)<br>  case custom((Decoder) throws -&gt; Date)<br>}</pre><p>디코딩 동작(알고리즘)을 캡슐화하고 실행 시점에 교체할 수 있게 만들었습니다.</p><pre>let decoder = JSONDecoder()<br>decoder.dateDecodingStrategy = .iso8601<br><br>let json = #&quot;{&quot;key&quot;: &quot;value&quot;}&quot;#.data(using: .utf8)!<br>let decode = try decoder.decode(Model.self, from: json)</pre><p>이는 앞서 설명한 공통 인터페이스를 정의하는 전략 패턴과는 약간의 차이점이 있지만 목적과 의도는 동일합니다.</p><h3>Then</h3><p>전략 패턴은 코드의 유연성을 높여주는 디자인 패턴입니다. 동작을 분리하고 실행 시점에 교체 가능하도록 만들어줌으로써 복잡한 조건문 없이도 다양한 기능을 유연하게 설계할 수 있습니다.</p><p>전략 패턴을 학습하면서 익숙하다고 느낀 것이 있습니다. 바로 Swift의 POP(Protocol Oriented Programming) 입니다. 프로토콜로 전략을 정의하고 , 구조체나 클래스가 이를 채택하여 구체적인 동작을 구현하는 POP의 개념과 전략 패턴이 잘 어울립니다. 따라서 단순히 디자인 패턴 중 하나가 아닌 POP를 실천하는 하나의 도구가 될 수 있습니다.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=912efb1ac2c7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What’s new in Swift 6.1]]></title>
            <link>https://jaeyoungan.medium.com/whats-new-in-swift-6-1-d02532434558?source=rss-5b33de1fbe00------2</link>
            <guid isPermaLink="false">https://medium.com/p/d02532434558</guid>
            <category><![CDATA[whats-new]]></category>
            <category><![CDATA[swift]]></category>
            <dc:creator><![CDATA[Jaeyoung An]]></dc:creator>
            <pubDate>Tue, 11 Mar 2025 07:33:42 GMT</pubDate>
            <atom:updated>2025-03-11T23:41:08.958Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/750/1*gFGfEvbklo6b3VXYJHDhaA.png" /></figure><h4>[<a href="https://github.com/swiftlang/swift/pull/78389">#78389</a>] ExistentialAny 오류</h4><p>기존에는 ExistentialAny 기능을 활성화하면 박싱된 프로토콜 타입(existential types)에 대한 <a href="https://github.com/swiftlang/swift-evolution/blob/main/proposals/0335-existential-any.md">any 구문</a>이 강제 적용되었으며, 위반 시 오류가 발생했다. Swift 6.1에서는 이러한 오류가 경고로 완화됐다.</p><pre>protocol Shape {<br>  func draw()<br>}<br><br>struct Circle: Shape {<br>  func draw() { print(&quot;Drawing Circle&quot;) }<br>}<br><br>struct Renderer {<br>  var shape: Shape // warning<br>}</pre><p>추후 업데이트에서 다시 오류로 변경될 수 있으며, -Werror ExistentialAny 플래그를 사용하면 경고를 다시 오류로 처리할 수 있다.</p><h4>[<a href="https://github.com/swiftlang/swift-evolution/blob/main/proposals/0444-member-import-visibility.md">SE-0444</a>] Member import visibility</h4><p>Swift 6.1부터 MemberImportVisibility 기능이 활성화되면 직접 가져오지 않은 모듈의 멤버를 사용할 수 없다.</p><pre>let recipe = &quot;2 slices of bread, 1.5 tbs peanut butter&quot;.parse()<br>// error: instance method &#39;parse()&#39; is inaccessible due to missing import of<br>//        defining module &#39;RecipeKit&#39;<br>// note:  add import of module &#39;RecipeKit&#39;</pre><p>이제 RecipeKit 모듈을 명시적으로 import해야 parse() 메서드를 사용할 수 있다. 이를 통해 불명확한 모듈 의존성을 방지하고 코드의 명확성을 높이는 효과를 얻을 수 있다.</p><h4>[<a href="https://github.com/swiftlang/swift-evolution/blob/main/proposals/0442-allow-taskgroup-childtaskresult-type-to-be-inferred.md">SE-0442</a>] TaskGroup 타입 추론</h4><p>Swift 6.1부터 withTaskGroup을 사용할 때, 자식 태스크의 반환 타입을 명시적으로 지정하지 않아도 자동으로 추론된다.</p><pre>// await withTaskGroup(of: Int.self) { group in<br>await withTaskGroup { group in<br>  group.addTask { 12 }<br>  return await group.next()<br>}</pre><h4>비활성 코드 블록의 SourceKit</h4><p>Swift 6.1부터 SourceKit은 조건부 컴파일 블록에서 비활성 코드에 대한 정보 제공을 중단한다.</p><pre>#if DEBUG<br>extension MyType: CustomDebugStringConvertible {<br>  var debugDescription: String { ... }<br>}<br>#endif</pre><p>위 코드에서 DEBUG가 설정되지 않았다면 SourceKit은 MyType의 debugDescription에 대한 정보를 제공하지 않는다. SourceKit 의존성이 있는 경우 SourceKit-LSP 또는 swift-syntax를 사용하면 특정 빌드 설정과 관계없이 구문 분석이 가능하다.</p><h4>Objective-C init Swift 네이밍 수정</h4><p>NS_SWIFT_NAME 매크로를 사용해서 Objective-C API를 다른 이름으로 Swift로 가져올 수 있다. (<a href="https://developer.apple.com/documentation/swift/renaming-objective-c-apis-for-swift">Renaming Objective-C APIs for Swift</a>)</p><pre>NS_SWIFT_NAME(Sandwich.Preferences)<br>@interface SandwichPreferences : NSObject<br>@property BOOL includesCrust NS_SWIFT_NAME(isCrusty);<br>@end<br><br>@interface Sandwich : NSObject<br>@end</pre><pre>var preferences = Sandwich.Preferences()<br>preferences.isCrusty = true</pre><p>이전 Swift 버전에서는 Objective-C의 -init... 메서드가 Swift에서 잘못된 기본 이름으로 가져와지는 문제가 있었다. Swift 6.1부터는 이러한 메서드의 잘못된 Swift 네이밍을 감지하고, Swift의 기본 네이밍 규칙을 따르도록 자동으로 수정한다.</p><h4>Projected value 초기화 수정</h4><p>Property Wrapper는 기본적으로 wrappedValue 값으로 관리하지만 별도의 변형되거나 추가된 값인 projectedValue를 제공할 수 있다.</p><pre>@propertyWrapper<br>struct ExampleWrapper {<br>  var wrappedValue: Int<br>  <br>  var projectedValue: String {<br>    &quot;현재 값: \\(wrappedValue)&quot;<br>  }<br>}</pre><p>이전에는 인수와 매개변수의 타입이 정확히 일치하면 projectedValue 초기화가 생략되는 오류가 있었다. Swift 6.1에서는 projectedValue가 필요한 경우 자동으로 초기화될 수 있도록 개선됐다.</p><pre>struct Binding {<br>  init(projectedValue: Self) { ... }<br>}<br><br>func checkValue(@Binding value: Int) {}<br><br>func use(v: Binding&lt;Int&gt;) {<br>  checkValue($value: v)<br>}</pre><p>위 코드에서 checkValue를 호출할 때, Swift 컴파일러가 Binding(projectedValue:)로 변환하지 못하고 생략하는 오류가 발생했지만 Swift 6.1부터는 정상적으로 변환된다.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d02532434558" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What’s new in Swift 6]]></title>
            <link>https://jaeyoungan.medium.com/whats-new-in-swift-6-2b909d48575d?source=rss-5b33de1fbe00------2</link>
            <guid isPermaLink="false">https://medium.com/p/2b909d48575d</guid>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[whats-new]]></category>
            <dc:creator><![CDATA[Jaeyoung An]]></dc:creator>
            <pubDate>Sat, 17 Aug 2024 10:07:38 GMT</pubDate>
            <atom:updated>2024-08-19T22:37:28.254Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/750/1*ioeHIkeYr_OYGFQlNTul8Q.png" /></figure><h4><a href="https://github.com/swiftlang/swift-evolution/blob/main/proposals/0409-access-level-on-imports.md">[SE-0409]</a> Access-level modifiers on import declarations</h4><p>SE-0409는 import에서 접근 제어자를 사용할 수 있는 기능을 제안합니다.</p><pre>// 명시할 수 있는 접근 제어자는 총 5가지이며 `open`은 사용할 수 없습니다.<br>public import PublicDependency<br>internal import InternalDependency<br>fileprivate imoport DependencyPrivateToThisFile<br>private import OhterDependencyPrivateToThisFile<br>package import PackageDependecy</pre><p>이때 라이브러리의 기능을 동일한 접근 제어에 해당하는 곳에서만 사용할 수 있습니다.</p><pre>internal import DatabaseAdapter<br><br>// O<br>internal func internalFunc() -&gt; DatabaseAdapter.Entry { ... }<br><br>// error: function cannot be declared public because its result uses an internal type<br>public func publicFunc() -&gt; DatabaseAdapter.Entry { ... }</pre><p>그렇다면 Swift 6.0 이전의 import는 어떻게 될까요? 이들은 모두 기본적으로 public이 적용됩니다.</p><pre>// ..&lt;Swift 6.0<br>import DatabaseAdapter<br><br>// Swift 6.0<br>public import DatabaseAdapter</pre><h4><a href="https://github.com/swiftlang/swift-evolution/blob/main/proposals/0270-rangeset-and-collection-operations.md">[SE-0270]</a> Add Collection Operations on Noncontiguous Elements</h4><p>Swift 6.0 이전에는 collection 내의 그룹을 참조할 때 Range&lt;Index&gt; 타입을 사용했습니다. 하지만 collection 내의 불연속적인 위치를 참조하는 API를 제공하지 않습니다. 예를 들어, Swift 6.0 이전에서 collection 내에 짝수들의 index를 구하는 코드입니다:</p><pre>var numbers = Array(1...15)<br><br>var indicesOfEvens: [Int] = []<br>for (index, number) in numbers.enumerated() {<br>  if number.isMultiple(of: 2) {<br>    indicesOfEvens.append(index)<br>  }<br>}<br>print(indicesOfEvens) // [1, 3, 5, 7, 9, 11, 13]</pre><p>또한 짝수, 홀수 순서로 collection을 재배치하는 코드입니다.</p><pre>var evenNumbers: [Int] = []<br>var otherNumbers: [Int] = []<br>for number in numbers {<br>  if number.isMultiple(of: 2) {<br>    evenNumbers.append(number)<br>  } else {<br>    otherNumbers.append(number)<br>  }<br>}<br>numbers = evenNumbers + otherNumbers<br>print(numbers) // [2, 4, 6, 8, 10, 12, 14, 1, 3, 5, 7, 9, 11, 13, 15]</pre><p>연산이 복잡해질수록 처리하는 과정이 번거로워집니다. 이를 해결하기 위해 SE-0270은 RangeSet 타입을 추가해서 collection 내의 연속되지 않은 위치를 참조하는 API를 제안합니다.</p><pre>var numbers = Array(1...15)<br><br>// 모든 짝수의 index<br>let indicesOfEvens = numbers.indices(where: { $0.isMultiple(of: 2) })<br><br>// 모든 짝수의 합<br>let sumOfEvens = numbers[indicesOfEvens].reduce(0, +) // 54<br><br>// 짝수, 홀수 순서로 재배치<br>let rangeOfEvens = numbers.moveSubranges(indicesOfEvens, to: numbers.startIndex)<br>// numbers == [2, 4, 6, 8, 10, 12, 14, 1, 3, 5, 7, 9, 11, 13, 15]<br>// numbers[rangeOfEvens] == [2, 4, 6, 8, 10, 12, 14]</pre><h4><a href="https://github.com/swiftlang/swift-evolution/blob/main/proposals/0220-count-where.md">[SE-0220]</a> count(where:)</h4><p>Swift 6.0 이전에는 배열에서 특정 조건을 만족하는 요소의 개수를 구하기 위해 filter + count 구문을 사용했습니다:</p><pre>[1, 2, 3, -1, -2].filter({ $0 &gt; 0 }).count // 3</pre><p>SE-0220은 filter + count 구문을 단순화한 count(where:)을 제안합니다.</p><pre>[1, 2, 3, -1, -2].count(where: { $0 &gt; 0}) // 3</pre><h4><a href="https://github.com/swiftlang/swift-evolution/blob/main/proposals/0425-int128.md">[SE-0425]</a> 128-bit Integer Types</h4><p>Swift 6.0 이전에는 정수를 나타내는 자료형으로 Int, Int8, Int16, Int32, Int64, UInt8, UInt16, UInt32, UInt64가 있습니다. <a href="https://github.com/swiftlang/swift-evolution/blob/main/proposals/0425-int128.md">SE-0425</a>는 128비트가 64비트 만큼 일반적으로 사용되지 않지만 표준 라이브러리에 추가하는 것이 합리적이므로, Int128과 UInt128 타입을 추가하자고 제안합니다.</p><h4>정수 자료형</h4><p>앞에 U는 signed, unsigned를 나타내고 뒤에 숫자는 비트를 의미합니다. 예를 들어, Int8은 signed로 부호가 있어서 음수와 양수를 모두 나타낼 수 있고, 8비트를 사용해서 -128 ~ 127 범위의 숫자를 표현할 수 있습니다.</p><pre>let min = Int8.min // -128(10000000)<br>let max = Int8.max // 127(01111111)</pre><p>Int와 같이 비트가 명시되어 있지 않으면 시스템 아키텍처에 따라서 지정됩니다. 예를 들어, 32비트에서는 Int32로, 64비트에서는 Int64로 지정됩니다.</p><h4><a href="https://github.com/swiftlang/swift-evolution/blob/main/proposals/0427-noncopyable-generics.md">[SE-0427]</a> Noncopyable Generics</h4><p>SE-0427는 Swift 6.0의 모든 struct, class, enum, protocol, generic type parameter는 ~Copyable을 명시적으로 사용하지 않는 한 자동으로 Copyable 프로토콜을 채택합니다. 그래서 copyable을 Optional 및 generic과 함께 사용할 수 없는 문제가 개선됐습니다.</p><pre>struct FileDescriptor: ~Copyable {<br>  // Swift 5.9 error: cannot form a Optional&lt;FileDescriptor&gt;<br>  // Swift 6.0 O<br>  init?(fileName: String) { ... }<br>}</pre><h4>[SE-0432] <a href="https://github.com/swiftlang/swift-evolution/blob/main/proposals/0432-noncopyable-switch.md">Noncopyble Switch</a></h4><p>Swift 5.9에서 추가된 <a href="https://github.com/anjaeyoung26/Whats-new-in-Swift/blob/main/swift5.9/noncopyable-structs-and-enums.md">noncopyable</a> 타입의 switch 피연산자는 consume과 함께 사용해야 합니다.</p><pre>enum Lunch: ~Copyable {<br>  case soup<br>  case salad<br>  case sandwich<br>}<br><br>let lunch = Lunch.soup<br><br>switch consume lunch {<br>case .soup:<br>  break<br>case .salad:<br>  break<br>case .sandwich:<br>  break<br>}<br><br>use(lunch) // error: lunch consumed by `switch`<br><br>// `if let` 혹은 `if case`도 동일하지만 본문에서는 `switch` 구문과 관련된 개선 사항으로 제외합니다.<br>let x: Optional = getValue()<br>if let y = consume x { ... }<br>use(y) // error: x consumed by `if let`</pre><p>이는 noncopyable enum의 표현력을 심각하게 제한하므로, SE-0432는 noncopyable의 패턴 매치가 consume 해야 한다는 제한을 해제하고 case 블록에서 패턴을 매칭하는 동안 소유권을 가져오는(borrowing) 동작을 하도록 제안합니다. 따라서 noncopyable enum의 값을 consume 하지 않고 switch와 패턴 매칭을 할 수 있습니다:</p><pre>func isSoup(_ lunch: borrowing Lunch) -&gt; Bool {<br>  switch lunch {<br>    case .soup: true<br>    default: false<br>  }<br>}</pre><h4><a href="https://github.com/swiftlang/swift-evolution/blob/main/proposals/0408-pack-iteration.md">[SE-0408]</a> Pack Iteration</h4><p>Swift 5.9에서 서로 다른 타입의 매개변수를 허용하는 함수를 작성할 수 있게 value and type parameter packs가 추가됐습니다. (<a href="https://github.com/anjaeyoung26/Whats-new-in-Swift/blob/main/swift5.9/value-and-type-parameter-packs.md">SE-0393</a>) 예를 들어, 아래와 같은 함수를 작성할 수 있습니다:</p><pre>let numbers = [0, 1, 2]<br>let names = [&quot;antoine&quot;, &quot;Maaike&quot;, &quot;Sep&quot;]<br>let collections = [numbers, names]<br><br>func eachFirstGeneric&lt;T: Collection&gt;(collections: [T]) -&gt; [T.Element?] {<br>  collections.map(\.first)<br>}<br>// 컴파일 에러<br>print(eachFirstGeneric(collections: [numbers, names]))<br><br>func eachFirst&lt;each T: Collection&gt;(_ item: repeat each T) -&gt; (repeat (each T).Element?) {<br>  return (repeat (each item).first)<br>}<br>// Prints 0<br>print(eachFirst(collections: [numbers, names]))</pre><p>이는 리스트 연산에서 short-circuiting을 허용하지 않아서 부자연스러운 부분이 있습니다. 우선 short-circuiting란, 결과가 정해지면 bool 표현식의 evaluate가 중지되는 동작을 의미합니다. 아래의 if 조건문에서 isHungry 값이 false이므로 다음 조건인 isFoodAvailable의 값을 확인하지 않는데, 이를 short-circuiting라고 합니다.</p><pre>let isHungry = false<br>let isFoodAvailable = true<br>if isHungry &amp;&amp; isFoodAvailable {<br>  eatFoods()<br>}</pre><p>하지만 value parameter packs는 리스트 연산에서 모든 요소를 evaluate하기 때문에 short-circuiting을 허용하지 않습니다. 따라서 evaluate를 중지하는 유일한 방법은 패턴 표현식을 throw하는 함수/클로저로 표시하고 do/catch 구문에서 에러를 catch해서 반환하는 것인데, 이는 부자연스러운 코드로 보입니다.</p><pre>struct NotEqual: Error {}<br><br>func == &lt;each Element: Equatable&gt;(lhs: (repeat each Element), rhs: (repeat each Element)) -&gt; Bool {<br>  // Local throwing function for operating over each element of a pack expansion.<br>  func isEqual&lt;T: Equatable&gt;(_ left: T, _ right: T) throws {<br>    if left == right {<br>      return<br>    }<br>    <br>    throw NotEqual()<br>  }<br><br>  // Do-catch statement for short-circuiting as soon as two tuple elements are not equal.<br>  do {<br>    repeat try isEqual(each lhs, each rhs)<br>  } catch {<br>    return false<br>  }<br><br>  return true<br>}</pre><p>이를 해결하기 위해 SE-0408은 for-in 구문에서 parameter packs를 반복하도록 허용합니다.</p><pre>func == &lt;each Element: Equatable&gt;(lhs: (repeat each Element), rhs: (repeat each Element)) -&gt; Bool {<br>  for (left, right) in repeat (each lhs, each rhs) {<br>    guard left == right else { return false }<br>  }<br>  return true<br>}</pre><h4><a href="https://github.com/swiftlang/swift-evolution/blob/main/proposals/0429-partial-consumption.md">[SE-0429]</a> Partial Consumption</h4><p>SE-0429는 noncopyable 타입을 부분적으로 consume 할 수 있도록 제안합니다. 예를 들어, Swift 5.9는 아래의 코드에서 컴파일 에러가 발생합니다:</p><pre>struct Unique: ~Copyable {...}<br>struct Pair: ~Copyable {<br>  let first: Unique<br>  let second: Unique<br>}<br><br>extension Pair {<br>  consuming func swap() -&gt; Pair {<br>    return Pair(<br>      first: second, // error: cannot partially consume &#39;self&#39;<br>      second: first // error: cannot partially consume &#39;self&#39;<br>    )<br>  }<br>}</pre><p>swap 함수는 또 다른 Pair를 반환한 뒤 deinit을 호출합니다. 하지만 Pair 타입에는 first, second 필드를 deinit하는 동작이 정의되어 있지 않습니다. 따라서 swap 함수가 종료되고 Pair는 자신을 consume 할 수 없습니다.</p><p>하지만 Swift 6.0은 deinit-less 집합체(Pair)에 있는 noncopyable 필드(first, second)가 개별적으로 consume 되는 것을 허용해서 swap 함수는 컴파일 에러를 발생시키지 않습니다. 이는 deinit-less에만 허용하기 때문에 Pair의 deinit을 정의한다면 더 이상 유효하지 않습니다.</p><h4><a href="https://github.com/swiftlang/swift-evolution/blob/main/proposals/0413-typed-throws.md">[SE-0413]</a> Typed throws</h4><p>Swift 6.0 이전의 throws는 Result, Task에 비해 적은 정보를 전달합니다:</p><pre>enum CatError: Error {<br>  case sleeps<br>  case sitsAtTree<br>}<br><br>func callCat() -&gt; Result&lt;Cat, CatError&gt;<br>func callFutureCat() -&gt; Task&lt;Cat, CatError&gt;<br>func callCatOrThrow() throws -&gt; Cat</pre><p>Result와 Task는 반환하는 에러의 타입을 명시할 수 있지만 throws는 불가능합니다. 따라서 Result 혹은 Task가 throws로 변환되면 타입에 대한 정보를 잃습니다:</p><pre>func callAndFeedCat1() -&gt; Result&lt;Cat, CatError&gt; <br>  do {<br>    return Result.success(try callCatOrThrow())<br>  } catch {<br>    // callCatOrThrow가 CatError 타입의 에러를 반환하지 않기 때문에 컴파일 에러가 발생합니다.<br>    return Result.failure(error)<br>  }<br>}<br><br>func callAndFeedCat2() -&gt; Result&lt;Cat, CatError&gt; {<br>  do {<br>    return Result.success(try callCatOrThrow())<br>  } catch let error as CatError {<br>    return Result.failure(error)<br>  } catch {<br>    // callAndFeedCat2는 CatError 타입의 에러를 반환하기 때문에 컴파일러가 완전성을 확인할 수 없어서 컴파일 에러가 발생합니다. <br>    // 이때 에러가 catch 됐지만 반환할 수 없어서 모호해집니다.<br>    return Result.failure(error)<br>  }<br>}</pre><p>이를 개선하고자 SE-0413은 특정 타입의 에러를 throw할 수 있는 기능을 제안합니다:</p><pre>func callCat() throws(CatError) -&gt; Cat {<br>  if Int.random(in: 0..&lt;24) &lt; 20 {<br>    throw .sleeps<br>  }<br>}</pre><p>이러면 throws가 타입에 대한 정보를 가지고 있으므로 Result로 쉽게 변환할 수 있습니다:</p><pre>func callAndFeedCat1() -&gt; Result&lt;Cat, CatError&gt; {<br>  do {<br>    return Result.success(try callCat())<br>  } catch {<br>    // 에러가 `CatError` 타입이므로 컴파일 에러가 발생하지 않습니다.<br>    return Result.failure(error)<br>  }<br>}</pre><p>Throwing any Error or Never</p><p>아래의 throws(any Error)는 untyped throws와 동일합니다.</p><pre>func throwsAnything() throws(any Error) { ... }<br>func throwsAnything() throws { ... }</pre><p>또한 throws(Never)는 non-throwing와 동일합니다.</p><pre>func throwsNothing() throws(Never) { ... }<br>func throwsNothing() { ... }</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2b909d48575d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What’s new in Swift 5.9]]></title>
            <link>https://jaeyoungan.medium.com/whats-new-in-swift-5-9-cff29ad212e6?source=rss-5b33de1fbe00------2</link>
            <guid isPermaLink="false">https://medium.com/p/cff29ad212e6</guid>
            <category><![CDATA[whats-new]]></category>
            <category><![CDATA[swift]]></category>
            <dc:creator><![CDATA[Jaeyoung An]]></dc:creator>
            <pubDate>Sat, 17 Aug 2024 09:54:28 GMT</pubDate>
            <atom:updated>2024-08-18T07:09:51.972Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/750/1*ioeHIkeYr_OYGFQlNTul8Q.png" /></figure><h4><a href="https://github.com/swiftlang/swift-evolution/blob/main/proposals/0374-clock-sleep-for.md">[SE-0374]</a> Add sleep(for:) to Clock</h4><p>기존의 Clock은 미래의 instant까지 sleep 하는 방법을 제공했다.</p><pre>func sleep(until deadline: Instant, tolerance: Instant.Duration?) async throws</pre><p>하지만 일정 duration 동안 sleep 하는 기능을 제공하지 않아서 불편함을 야기한다. 우선 Clock 이전의 Task를 사용하는 코드를 살펴보자:</p><pre>class FeatureModel: ObservableObject {<br>  @Published var message: String?<br>  func onAppear() async {<br>    do {<br>      try await Task.sleep(until: .now.advanced(by: .seconds(5)))<br>      self.message = &quot;Welcome!&quot;<br>    } catch {}<br>  }<br>}<br><br>let model = FeatureModel()<br><br>XCTAssertEqual(model.message, nil)<br>await model.onAppear()<br><br>// Waits for 5 seconds<br>XCTAssertEqual(model.message, &quot;Welcome!&quot;)</pre><p>FeatureModel의 동작을 테스트하려면 실제로 5초를 기다려서 결과를 확인해야 한다. 이러한 문제는 Task.sleep을 Clock로 대체해도 해결할 수 없었다. 왜냐하면 Clock은 existential type을 주입받아서 self.clock.now 프로퍼티에 접근할 수 없기 때문이다.</p><pre>class FeatureModel: ObservableObject {<br>  @Published var message: String?<br>  let clock: any Clock&lt;Duration&gt;<br><br>  func onAppear() async {<br>    do {<br>      try await self.clock.sleep(until: self.clock.now.advanced(by: .seconds(5))) // X<br>      self.message = &quot;Welcome!&quot;<br>    } catch {}<br>  }<br>}</pre><p>이는 Swift 5.9에서 추가된 Clock의 sleep(for:) 메서드로 해결할 수 있다.</p><pre>extension Clock {<br><br>  public func sleep(<br>    for duration: Duration,<br>    tolerance: Duration? = nil<br>  ) async throws {<br>    try await self.sleep(until: self.now.advanced(by: duration), tolerance: tolerance)<br>  }<br>}<br><br>class FeatureModel: ObservableObject {<br>  @Published var message: String?<br>  let clock: any Clock&lt;Duration&gt;<br><br>  func onAppear() async {<br>    do {<br>      try await self.clock.sleep(for: .seconds(5)) // O<br>      self.message = &quot;Welcome!&quot;<br>    } catch {}<br>  }<br>}</pre><h4><a href="https://github.com/swiftlang/swift-evolution/blob/main/proposals/0390-noncopyable-structs-and-enums.md">[SE-0390]</a> Noncopyable structs and enums</h4><p>Swift의 모든 타입은 복사할 수 있다. 즉, 하나의 인스턴스를 변수에 대입하거나 함수의 매개변수로 넘겨서 인스턴스를 복사할 수 있다. 클래스의 인스턴스는 초기화할 때 고유 ID를 가지며, 인스턴스에 대한 참조만 복사돼서 고유한 리소스를 나타낼 수 있다. 따라서 모든 클래스의 인스턴스는 하나의 주소를 가리키고 있어서 공유 소유권이 요구된다.</p><p>만약 둘 이상의 스레드에서 동시에 자원에 접근한다면 결과에 영향을 줄 수 있는 Race condition이 발생할 수 있고, 이를 안전하게 사용하기 위해 추가적인 오버헤드도 발생한다. <a href="https://github.com/apple/swift-evolution/blob/main/proposals/0390-noncopyable-structs-and-enums.md">SE-0390</a>는 복사할 수 없는 타입을 나타내는 ~Copyable 프로토콜로 고유한 소유권을 가진 리소스를 정의하는 매커니즘을 제안한다. 아래는 ~Copyable 프로토콜을 채택한 User 구조체이다:</p><pre>struct User: ~Copyable {<br>  var name: String<br>}</pre><p>‘복사할 수 없다’가 어떤 의미인지 살펴보자:</p><pre>func createUser() {<br>  let newUser = User(name: &quot;Anonymous&quot;)<br><br>  var userCopy = newUser<br>  print(userCopy.name)<br>}<br><br>createUser()</pre><p>위 코드에서 User 타입의 인스턴스를 생성하고 userCopy 변수에 대입했다. User는 noncopyable 타입이므로, userCopy 변수에 대입할 때 인스턴스를 복사하지 않고 소유권을 넘긴다. 이후 newUser는 더 이상 사용할 수 없다.</p><pre>print(newUser.name) // 컴파일 에러</pre><h4><a href="https://github.com/swiftlang/swift-evolution/blob/main/proposals/0377-parameter-ownership-modifiers.md">[SE-0377]</a> borrowing and consuming parameter ownership modifiers</h4><h4>borrowing</h4><p>SE-0377은 noncopyable 타입을 어떤 방식으로 사용할지 정하는 modifier를 소개한다. 우선 borrowing 부터 살펴보자.</p><pre>func createAndGreetUser() {<br>  let newUser = User(name: &quot;Anonymous&quot;)<br>  greet(newUser)<br>  print(&quot;Goodbye, \(newUser.name)&quot;)<br>}<br><br>func greet(_ user: borrowing User) {<br>  print(&quot;Hello, \(user.name)!&quot;)<br>}<br><br>createAndGreetUser()</pre><p>borrowing은 현재 소유자로부터 값의 소유권을 빼앗지 않는다. 따라서 greet 함수 내에서 user 매개변수의 값을 변경하는 것이 허용되지 않고 read-only 권한만 얻는다.</p><pre>let f: (borrowing Foo) -&gt; Void = { a in a.foo() }<br>borrowing func foo() { }<br>...</pre><p>메서드의 매개변수 뿐만 아니라 메서드 자체에도 borrowing modifier를 사용할 수 있다. borrowing 메서드는 self 매개변수의 소유권을 빌려서 사용한다.</p><h4>consuming</h4><p>consuming modifier는 noncopyable 타입의 소유권을 가져와서 사용한다.</p><pre>func createAndGreetUser() {<br>  let newUser = User(name: &quot;Anonymous&quot;)<br>  greet(newUser)<br>  print(&quot;Goodbye, \(newUser.name)&quot;) // 컴파일 에러<br>}<br><br>func greet(_ user: consuming User) {<br>  print(&quot;Hello, \(user.name)!&quot;)<br>}<br><br>createAndGreetUser()</pre><p>위 코드에서 print 구문은 컴파일 에러가 발생한다. 왜냐하면 greet 함수에서 newUser에 대한 소유권을 가져가서 더 이상 사용할 수 없기 때문이다. 그리고 greet 함수는 소유권을 가져왔으므로 user의 값을 변경하는 것이 허용된다.</p><pre>let f: (consuming Foo) -&gt; Void = { a in a.foo() }<br>consuming func foo() { }<br><br>func foo(f: consuming () -&gt; ()) { } // X</pre><p>consuming modifier도 메서드에 붙일 수 있지만 borrowing과 다르게 nonescaping 클로저에는 붙일 수 없다. nonescaping 클로저는 항상 borrowing하게 동작하기 때문이다.</p><h4><a href="https://github.com/swiftlang/swift-evolution/blob/main/proposals/0380-if-switch-expressions.md">[SE-0380]</a> if and switch expressions</h4><p>Swift 5.9부터 if/else 및 switch 문을 표현식으로 사용할 수 있다. Swift 5.9 이전에는 복잡한 조건으로 변수를 초기화하려면 3항식을 사용했다:</p><pre>let bullet =<br>  isRoot &amp;&amp; (count == 0 || !willExpand) ? &quot;&quot;<br>    : count == 0     ? &quot;- &quot;<br>    : maxDeptch &lt;= 0 ? &quot;▹ &quot; : &quot;▿ &quot;</pre><p>Swift 5.9의 if 표현식은 훨씬 친숙하게 만들어준다:</p><pre>let bullet =<br>  if isRoot &amp;&amp; (count == 0 || !willExpand) { &quot;&quot; }<br>  else if count == 0 { &quot;- &quot; }<br>  else if maxDepth &lt;= 0 { &quot;▹ &quot; }<br>  else { &quot;▿ &quot; }</pre><p>글로벌 변수나 저장 프로퍼티를 초기화할 때도 유용하다. 이전에는 초기화할 때 조건이 필요하다면 클로저를 사용했다:</p><pre>let attributedName = {<br>  if let displayName, !displayName.isEmpty {<br>    AttributedString(markdown: displayName)<br>  } else {<br>    &quot;Untitled&quot;<br>  }<br>}<br><br>// Swift 5.9<br>let attributedName =<br>  if let displayName, !displayName.isEmpty {<br>    AttributedString(markdown: displayName)<br>  } else {<br>    &quot;Untitled&quot;<br>  }</pre><p>Swift 5.9의 switch 표현식은 아래와 같이 사용할 수 있다:</p><pre>let result = switch score {<br>  case 0...60: &quot;Fail&quot;<br>  case 61...70: &quot;Good&quot;<br>  case 71...80: &quot;Great&quot;<br>  case 81...100: &quot;Excellent&quot;<br>  default: &quot;Unknown&quot;<br>}</pre><h4><a href="https://github.com/swiftlang/swift-evolution/blob/main/proposals/0393-parameter-packs.md">[SE-0393]</a>, <a href="https://github.com/swiftlang/swift-evolution/blob/main/proposals/0398-variadic-types.md">[SE-0398]</a>, <a href="https://github.com/swiftlang/swift-evolution/blob/main/proposals/0399-tuple-of-value-pack-expansion.md">[SE-0399]</a> Parameter Packs</h4><p>Swift 5.9 이전에는 동일한 동작을 하더라도 매개변수의 개수가 다르다면 메서드를 overload 했다:</p><pre>func eachFirst&lt;T&gt;(<br>  _ item: T<br>) -&gt; T?<br><br>func eachFirst&lt;T1, T2&gt;(<br>  _ item1: T1,<br>  _ item2: T2<br>) -&gt; (T1?, T2?)<br><br>func eachFirst&lt;T1, T2, T3&gt;(<br>  _ item1: T1,<br>  _ item2: T2,<br>  _ item3: T3<br>) -&gt; (T1?, T2?, T3?)</pre><p>이는 코드가 중복되는 문제점이 있다. 이러한 반복을 줄이기 위해 배열을 사용할 수 있지만, 만약 타입이 다르다면 컴파일 에러가 발생한다:</p><pre>func eachFirst&lt;T: Collection&gt;(collections: [T]) -&gt; [T.Element?] {<br>  collections.map(\.first)<br>}<br><br>let numbers = [0, 1, 2]<br>let names = [&quot;Antoine&quot;, &quot;Maaike&quot;, &quot;Sep&quot;]<br>print(eachFirst(collections: [numbers, names])) <br>// Confliciting arguments to generic parameter &#39;T&#39; (&#39;[String]&#39; vs &#39;[Int]&#39;)</pre><p>이는 Swift 5.9의 Parameter packs로 해결할 수 있다. Parameter packs는 generic과 비슷해 보이지만 여러 타입의 item을 사용할 수 있게 한다.</p><pre>func eachFirst&lt;each T: Collection&gt;(_ item: repeat each T) -&gt; (repeat (each T).Element?) {<br>  return (repeat (each item).first)<br>}<br><br>let numbers = [0, 1, 2]<br>let names = [&quot;Antoine&quot;, &quot;Maaike&quot;, &quot;Sep&quot;]<br>print(eachFirst(collections: [numbers, names])) // O</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cff29ad212e6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What’s new in Swift 5.8]]></title>
            <link>https://jaeyoungan.medium.com/whats-new-in-swift-5-8-b479e1d609e6?source=rss-5b33de1fbe00------2</link>
            <guid isPermaLink="false">https://medium.com/p/b479e1d609e6</guid>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[whats-new]]></category>
            <dc:creator><![CDATA[Jaeyoung An]]></dc:creator>
            <pubDate>Fri, 16 Aug 2024 09:18:05 GMT</pubDate>
            <atom:updated>2024-08-18T07:09:33.093Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/750/1*kj-7RtPj5xWFZJkIg3UtrA.png" /></figure><h4><a href="https://github.com/swiftlang/swift-evolution/blob/main/proposals/0376-function-back-deployment.md">[SE-0376]</a> @backDeployed</h4><p>@backDeployed는 새로운 기능을 이전 OS 버전에서도 소급해서 사용할 수 있도록 합니다. 예를 들어, 아래와 같은 API를 제공하는 ToasterKit 프레임워크가 있습니다.</p><pre>@available(toasterOS 1.0, *)<br>public struct BreadSlice { ... }<br><br>@available(toasterOS 1.0, *)<br>public struct Toast { ... }<br><br>@available(toasterOS 1.0, *)<br>public struct Toaster {<br>  public func makeToast(_ slice: BreadSlice) -&gt; Toast<br>}</pre><p>그리고 새로운 API를 추가해서 ToasterKit 2.0 버전을 배포했습니다.</p><pre>extension Toaster {<br>  @available(toasterOS 2.0, *)<br>  public func makeBatchOfToast(_ slices: [BreadSlice]) -&gt; [Toast] {<br>    var toast: [Toast] = []<br>    for slice in slices {<br>      toast.append(makeToast(slice))<br>    }<br>    return toast<br>  }<br>}</pre><p>새로운 API는 toasterOS 2.0 버전에서만 사용할 수 있어서, toasterOS 1.0과 호환되는 앱을 배포하고 채택하려는 개발자는 조건부로 호출해야 합니다.</p><pre>let slices: [BreadSlice] = ...<br>if #available(toasterOS 2.0, *) {<br>  let toast = toaster.makeBatchOfToast(slices)<br>  // ...<br>} else {<br>  // ... do something else, like reimplement makeBatchOfToast(_:)<br>}</pre><p>클라이언트가 새로운 API를 사용하려면 ToasterKit의 2.0 버전으로 업데이트 하거나 ToasterKit의 작성자가 해당 API를 이전 버전에 다시 배포하고, 이를 클라이언트가 채택해야 합니다. 이때 toasterOS 1.0과 호환되는 앱에서 makeBatchOfToast를 어떻게 호출할까요?</p><pre>let toast = toaster.makeBatchOfToast(slices)</pre><p>컴파일러는 @backDeployed 호출을 발견하면 파라미터(slices)를 함수의 라이브러리 복사본이나 함수의 폴백 복사본으로 전달하는 대신 Thunk를 생성하고 호출합니다. 즉, 컴파일러의 동작은 아래와 같은 코드를 실행합니다.</p><pre>extension Toaster {<br>  func makeBatchOfToast_thunk(_ breadSlices: [BreadSlice]) -&gt; [Toast] {<br>    if #available(toasterOS 2.0, *) {<br>      return makeBatchOfToast(breadSlices) // call the original<br>    } else {<br>      return makeBatchOfToast_fallback(breadSlices) // call local copy<br>    }<br>  }<br><br>  func makeBatchOfToast_fallback(_ breadSlices: [BreadSlice]) -&gt; [Toast] {<br>    // ... copy of function body from ToastKit<br>  }<br>}</pre><p>표면적으로 @backDeployed는 함수, 메서드, Subscripts, 연산 프로퍼티에만 적용할 수 있고 새로운 유형을 사용해야 하는 코드에는 작동하지 않습니다.</p><h4><a href="https://github.com/swiftlang/swift-evolution/blob/main/proposals/0365-implicit-self-weak-capture.md">[SE-0365]</a> Implicit self</h4><p>Swift 5.8 부터 weak self 캡처가 unwrapped된 곳에서 self를 암시적으로 허용합니다. 예를 들어, 아래 코드에서 weak self로 캡처하지만 자기 자신을 unwrapped 하는 클로저를 나타냅니다.</p><pre>import Foundation<br><br>class TimerController {<br>  var timer: Timer?<br>  var fireCount = 0<br>    <br>  init() {<br>    timer = Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { [weak self] timer in<br>      guard let self else { return }<br>      print(&quot;Timer has fired \(fireCount) times&quot;)<br>      fireCount += 1<br>    }<br>  }<br>}</pre><p>위 코드를 Swift 5.8 이전 버전에서 실행하면 fireCount 프로퍼티를 참조하려면 self를 명시하라는 에러가 표시됩니다.하지만 Swift 5.8에서는 self를 명시하지 않아도 됩니다.</p><h4><a href="https://github.com/swiftlang/swift-evolution/blob/main/proposals/0274-magic-file.md">[SE-0274]</a> Concise magic file names</h4><p>#file은 현재 Swift 파일의 경로를 출력하는 리터럴 입니다. 이 경로에는 루트 디렉토리가 포함됩니다.</p><pre>print(#file) // /Users/anjaeyoung/Desktop/MyApp/ContentView.swift</pre><p><a href="https://github.com/apple/swift-evolution/blob/main/proposals/0274-magic-file.md">SE-0274</a>는 불필요하게 긴 경로를 공개하지 않도록 리터럴의 변경을 제안합니다. Swift 5.8 버전부터 #file 리터럴은 Swift 파일의 전체 경로가 아닌 모듈/파일 이름의 형식입니다.</p><pre>MyApp/ContentView.swift</pre><p>Swift 5.8 이전 버전과 같이 Swift 파일의 전체 경로를 출력하려면 #filePath 리터럴을 사용합니다.</p><pre>print(#filePath)</pre><p>하지만 이를 Swift 5.8 버전에서 활성화 하려면 별도의 플래그를 추가해야 합니다. 자세한 내용은 다음 항목을 확인해주세요.</p><h4><a href="https://github.com/swiftlang/swift-evolution/blob/main/proposals/0362-piecemeal-future-features.md">[SE-0362] Piecemeal adoption of upcoming language improvements</a></h4><p>Swift 6은 Swift 4.x ~ 5.x와 같은 이전 버전에서 기본적으로 활성화 할 수 없었던 많은 개선 사항이 있다. 이러한 개선 사항은 Swift 6 이전 버전의 컴파일러에서 이미 구현되었지만 사용자가 액세스할 수 없으며, Swift 6가 릴리즈 되기 전까지 그대로 유지된다.</p><p>하지만 충분한 소스 호환성을 가지고 있어서<strong> Swift 5.8은 개선 사항들을 더 빨리 제공하려고 한다.</strong> 그러면 개발자는 Swift 4.x ~ 5.x 버전에서 Swift 6으로 수월하게 마이그레이션 할 수 있고 <strong>Swift 6가 릴리즈 될 때까지 기다리지 않고</strong> 개선 사항의 이점들을 얻을 수 있다.</p><p>Xcode의 Other Swift Flags 항목에 -enable-upcoming-feature-{Feature Identifier} 플래그를 추가해서 Swift 6에서 추가되는 기능을 Swift 5.8에서 먼저 사용할 수 있다. 하지만 Swift 6의 모든 기능을 사용할 수 없고 아래의 몇 가지 기능만 해당된다. 각 기능은 식별자를 통해서 플래그에 추가할 수 있다.</p><ul><li><a href="https://github.com/swiftlang/swift-evolution/blob/main/proposals/0274-magic-file.md">[SE-0274]</a> ConciseMagicFile</li><li><a href="https://github.com/apple/swift-evolution/blob/main/proposals/0286-forward-scan-trailing-closures.md">[SE-0286] </a>ForwardTrailingClosures</li><li><a href="https://github.com/apple/swift-evolution/blob/main/proposals/0335-existential-any.md">[SE-0335] </a>ExistentialAny</li><li><a href="https://github.com/apple/swift-evolution/blob/main/proposals/0337-support-incremental-migration-to-concurrency-checking.md">[SE-0337] </a>StrictConcurrency</li><li><a href="https://github.com/apple/swift-evolution/blob/main/proposals/0352-implicit-open-existentials.md">[SE-0352] </a>ImplicitOpenExistentials</li><li><a href="https://github.com/apple/swift-evolution/blob/main/proposals/0354-regex-literals.md">[SE-0354] </a>BareSlashRegexLiterals</li></ul><p>만약 Concise magic file names를 활성화하려면 -enable-upcoming-feature-ConciseMagicFile 플래그를 추가한다. 또한 새 기능을 채택할 때 코드에서 활성화되어 있는지 확인할 수 있다.</p><pre>#if compiler(&gt;=5.7) &amp;&amp; hasFeature(BareSlashRegexLiterals)<br>let regex = /.../<br>#else<br>let regex = try NSRegularExpression(pattern: &quot;...&quot;)<br>#endif</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b479e1d609e6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Modularzation with XCFramework]]></title>
            <link>https://jaeyoungan.medium.com/xcframework%EB%A5%BC-%ED%86%B5%ED%95%9C-%EB%AA%A8%EB%93%88%ED%99%94-7f5d36ccbcee?source=rss-5b33de1fbe00------2</link>
            <guid isPermaLink="false">https://medium.com/p/7f5d36ccbcee</guid>
            <category><![CDATA[xcframework]]></category>
            <category><![CDATA[modularization]]></category>
            <dc:creator><![CDATA[Jaeyoung An]]></dc:creator>
            <pubDate>Fri, 10 Mar 2023 17:50:33 GMT</pubDate>
            <atom:updated>2024-08-16T03:21:06.789Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MNew02hFYxti93gt3pjfyg.png" /></figure><p>XCFramework는 WWDC19의 <a href="https://developer.apple.com/videos/play/wwdc2019/416/">Binary Frameworks in Swift</a> 세션에서 공개된 새로운 포멧으로 여러 프레임워크를 묶어 배포할 수 있다. Xcode 11 버전부터 지원되며 Xcode가 지원하는 모든 플랫폼(iOS, macOS, tvOS, watchOS)에서 사용할 수 있다. 이번 포스팅은 XCFramework가 만들어진 계기와 XCFramework를 이용해 모듈화하는 방법에 대해 알아본다.</p><h3>만들어진 계기</h3><p>기존에는 멀티 플랫폼을 지원하기 위해서 Universal Framework를 생성했다. Universal Framework는 모든 디바이스에서 필요한 아키텍처를 포함해서 Fat Framework 라고도 한다. 만약 시뮬레이터에서 x86_64, 디바이스에서 arm64 아키텍처가 필요하다면 두 아키텍처를 Universal Framework에 포함시켜야 한다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/665/1*BHAgJK3HjacFeUP4BQrvBQ.png" /></figure><p>만약 시뮬레이터는 x86_64 아키텍처만 필요해도 arm64 아키텍처가 포함된다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/511/1*rcowLrdETnsf0kA1UdhD_w.png" /></figure><p>Fat Framework는 용량이 커질뿐만 아니라 필요하지 않은 아키텍처는 앱을 배포할 때 제외시켜야 한다. 이러한 문제는 XCFramework를 사용해서 해결할 수 있다. XCFramework는 각각의 아키텍처를 분리하고 필요한 아키텍처로 빌드한다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/430/1*YpNU6XeJifHqi4m7_GUzDg.png" /></figure><h3>프레임워크 생성</h3><p>[iOS] - Framework 프로젝트를 생성한다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*5YGopQajrHMoiWgH.png" /></figure><p>각각 public, internal, private 접근 제한자를 가진 함수를 정의하자.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*rhMUyWdE3IKQtKef.png" /></figure><h3>아카이브</h3><p>터미널에 아래와 같이 입력해서 iOS 타겟을 아카이브 한다.</p><pre>xcodebuild archive \<br>-sdk iphoneos \<br>-scheme SampleFramework \<br>-archivePath &quot;./build/ios.xcarchive&quot; \<br>SKIP_INSTALL=NO \<br>BUILD_LIBRARY_FOR_DISTRIBUTION=YES</pre><ul><li><strong>sdk</strong> : 아카이브 할 타겟이다. 터미널에서 xcodebuild -showsdks 명령어로 목록을 확인할 수 있다.</li><li><strong>scheme</strong> : 아카이브 할 프로젝트의 스키마이다. 터미널에서 xcodebuild -list -project SampleFramework.xcodeproj 명령어로 프로젝트의 타겟, 스키마를 확인할 수 있다.</li><li><strong>archivePath</strong> : 아카이브 한 바이너리 파일이 저장될 위치이다. 아카이브가 성공하면 프로젝트의 루트 디렉토리에 생성된 build 서브 디렉토리에 바이너리 파일이 저장된다. 만약 build 서브 디렉토리가 없어도 자동으로 생성된다.</li><li><strong>SKIP-INSTALL</strong> : YES일 경우 설치하지 않고 빌드만 수행한다. NO일 경우 &amp;DSTROOT 경로에 설치한다. 자세한 내용은 <a href="https://developer.apple.com/library/archive/documentation/DeveloperTools/Reference/XcodeBuildSettingRef/1-Build_Setting_Reference/build_setting_ref.html#//apple_ref/doc/uid/TP40003931-CH3-SW36:~:text=Xcode.501/SharedPrecompiledHeaders-,SKIP_INSTALL,-Description:">여기</a>에서 확인할 수 있다.</li><li><strong>BUILD_LIBRARY_FOR_DISTRIBUTION</strong> : 클라이언트와 프레임워크의 바이너리 호환성을 유지하면서 프레임워크의 기능을 변경, 개선하는 유연성을 위해 YES로 설정할 것을 권장한다. 해당 내용은 WWDC19의 Binary Frameworks in Swift 세션에서 확인할 수 있다.</li></ul><p>아카이브가 성공했다면 ** ARCHIVE SUCCEEDED **가 보인다. 그리고 -archivePath 를 설정한대로 루트 디렉토리에 build 서브 디렉토리가 생겼다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*xg4fExppdiqLTKlS.png" /></figure><p>build 디렉토리에ios.xcarchive라는 바이너리 파일이 생성됐다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*icjuBE4LxmPPPeAk.png" /></figure><p>이제 시뮬레이터 타겟도 마찬가지로 아카이브 해보자.</p><pre>xcodebuild archive \<br>-scheme SampleFramework \<br>-archivePath &quot;./build/ios_sim.xcarchive&quot; \<br>-sdk iphonesimulator \<br>SKIP_INSTALL=NO \<br>BUILD_LIBRARY_FOR_DISTRIBUTION=YES</pre><p>build 디렉토리에 ios_sim.xcarchive라는 바이너리 파일이 생성됐다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*C4m-5tQ7ieR7cVqj.png" /></figure><h3>XCFramework 생성</h3><p>XCFramework를 생성하기 위해 터미널에 아래와 같이 입력한다.</p><pre>xcodebuild -create-xcframework \<br>-framework &quot;./build/ios.xcarchive/Products/Library/Frameworks/SampleFramework.framework&quot; \<br>-framework &quot;./build/ios_sim.xcarchive/Products/Library/Frameworks/SampleFramework.framework&quot; \<br>-output &quot;./build/SampleFramework.xcframework&quot;</pre><p>명령어를 살펴보면 iOS와 시뮬레이터 타겟을 아카이브 했던 바이너리 파일을 포함시켜 XCFramework를 생성한다. xcodebuild 명령어가 완료되면 build 디렉토리에 XCFramework가 생성된 것을 확인할 수 있다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*D5G9hG-UMRWa07mH.png" /></figure><h3>XCFramework Embedding</h3><p>생성한 XCFramework를 클라이언트 프로젝트에서 사용해보자. 클라이언트 프로젝트에 XCFramework 파일을 드래그 앤 드롭으로 추가한다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/520/0*sLndH43FxRaxEFDh.png" /></figure><p>Dynamic Framework이므로 Embed &amp; Sign으로 설정한다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*V6hy8TzlTlaopHpy.png" /></figure><p>클라이언트 프로젝트의 [Build Phase] — [Link Binary With Libraries]에서 프레임워크가 링킹된 것을 확인할 수 있다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*8v4IIRQbez-yvh5A.png" /></figure><p>클라이언트 프로젝트를 빌드하면 프레임워크를 Import 해서 기능을 사용할 수 있다. 프레임워크의 구현대로 public 함수만 사용할 수 있으며, internal과 private 함수는 사용할 수 없다.</p><pre>import SampleFramework<br>import UIKit<br><br>final class ViewController: UIViewController {<br>  override func viewDidLoad() {<br>    super.viewDidLoad()<br>    publicFunction()<br>  }<br>}</pre><p>클라이언트 프로젝트에서 프레임워크에 대한 내용을 살펴보면 internalFunction과 privateFunction 의 구현체는 숨겨져 있다.</p><pre>import Foundation<br>import SampleFramework.Swift<br>import _Concurrency<br>import _StringProcessing<br><br>//<br>// SampleFramework.h<br>// SampleFramework<br>//<br>// Created by .. by on 2023/02/23.<br>//<br><br>//! Project version number for SampleFramework.<br>public var SampleFrameworkVersionNumber: Double<br>public func publicFunction()</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7f5d36ccbcee" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Setup Kakao Login on iOS]]></title>
            <link>https://jaeyoungan.medium.com/%EC%B9%B4%EC%B9%B4%EC%98%A4%ED%86%A1-%EB%A1%9C%EA%B7%B8%EC%9D%B8-1-%EC%A4%80%EB%B9%84-11f8357f2a52?source=rss-5b33de1fbe00------2</link>
            <guid isPermaLink="false">https://medium.com/p/11f8357f2a52</guid>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[kakaotalk]]></category>
            <dc:creator><![CDATA[Jaeyoung An]]></dc:creator>
            <pubDate>Sun, 09 Oct 2022 19:03:09 GMT</pubDate>
            <atom:updated>2024-08-16T03:27:51.383Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/534/1*u0eGyZTHoVs-lnqTG4tHLw.png" /></figure><p>카카오톡은 한국인이 가장 많이 사용하는 앱으로, 한국에서 서비스하는 앱은 카카오톡 로그인을 많이 지원하고 있습니다. 이번 포스팅은 카카오톡 로그인을 도입하기 전에 고려해야할 사항과 프로젝트 설정에 대해 알아보려고 합니다.</p><h3>운영 정책</h3><p>카카오 서비스를 이용하기 전에 우리의 서비스가 카카오의 <a href="https://developers.kakao.com/terms/latest/ko/site-policies#prohibited-content">운영 정책</a>에 위반되지 않는 서비스인지 확인해야 합니다. 개발이 진행되고 있을 때 카카오의 운영 정책과 우리의 서비스에 이슈가 생긴다면 말짱 도루묵이니 꼭 살펴보시길 바랍니다.</p><h3>사용자 정보 제공</h3><p>우리는 사용자의 카카오톡 계정에 저장되어 있는 정보 중에서 앱에서 필요한 정보를 제공받을 수 있습니다. 하지만 모든 정보를 받을 순 없습니다. 모든 항목은 사용자의 동의가 필요하지만 동의하지 않으면 서비스를 이용할 수 없는 <strong>필수 동의 항목</strong>과 동의하지 않아도 서비스를 이용할 수 있는 <strong>선택 동의 항목</strong>이 있습니다. 또한 서비스에서 필요한 시점에 동의를 받는 <strong>이용 중 동의 항목</strong>도 있습니다. <a href="https://developers.kakao.com/docs/latest/ko/kakaologin/prerequisite#scope"><strong>링크</strong></a>에서 동의 항목을 확인할 수 있습니다.</p><p>사용자의 전화번호와 같이 비즈앱 등록을 해야 필수 동의 항목으로 설정할 수 있는 항목이 있으니, 위 링크를 꼭 참고하시길 바랍니다. [내 애플리케이션] &gt; [카카오 로그인] &gt; [동의 항목] &gt; [개인정보]에서 동의 항목을 설정할 수 있습니다.</p><h3>디자인 가이드</h3><p>카카오톡 로그인을 제공하기 위해서는 로그인 화면에 버튼을 추가해야겠죠? 카카오톡 로그인도 애플 로그인과 마찬가지로 <a href="https://developers.kakao.com/docs/latest/ko/kakaologin/design-guide"><strong>디자인 가이드</strong></a>가 존재합니다.</p><p>디자인 가이드에서는 완성형/축약형 버튼에 대한 리소스도 제공합니다. png 파일 형태로 다운로드를 할 수 있으니 커스텀 버튼을 구현하지 않고 편리하게 이미지를 사용할 수 있습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*tWPjdIrGHaSfvICxrIT-gg.png" /><figcaption>완성형</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/60/1*zdmvm11L7swX8d75tOJJTw.png" /><figcaption>축약형</figcaption></figure><p>애플 로그인과 마찬가지로 디자인 가이드에서 제공하는 리소스를 사용하는 것을 권장하지만 서비스에 따라 폰트나 심볼의 크기 등을 유동적으로 조정할 수 있습니다. 색상, 문구에 대한 규정을 준수하면 카카오 고유의 이미지를 해치지 않는 범위 내에서 커스터마이징 할 수 있습니다.</p><h3>iOS 앱 등록</h3><p>우선 <a href="https://developers.kakao.com/console/app">카카오 콘솔</a>에서 애플리케이션을 추가하고, iOS 플랫폼을 등록합니다. iOS 플랫폼을 등록할 때 <strong>앱스토어 ID</strong>는 앱스토어 커넥트의 앱 정보에서 Apple ID를 입력하면 됩니다. 자세한 등록 방법은 <a href="https://developers.kakao.com/docs/latest/ko/getting-started/app#platform"><strong>링크</strong></a>에서 확인할 수 있습니다.</p><h3>카카오 로그인 활성화</h3><p>애플리케이션 제품 설정에서 카카오 로그인을 활성화 합니다. 카카오 로그인이 활성화되어 있지 않은 경우 카카오 로그인 요청 시 KOE004 에러가 발생합니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*D5lzl8AlmM8tSYZp.png" /></figure><h3>SDK 설치</h3><p><a href="https://developers.kakao.com/docs/latest/ko/ios/getting-started#module"><strong>링크</strong></a>에서는 카카오 SDK에서 제공하는 모듈의 종류와 설치 방법에 대해서 설명합니다. 현재 SDK는 CocoaPods와 Swift Package Manager를 통해 설치할 수 있습니다. 서비스에서 사용하고 있는 의존성 관리 도구에 따라 설치하면 됩니다.</p><p>카카오 SDK는 기능에 따라 여러 개의 모듈로 분리되어 있습니다. 물론 편안하게 통합 모듈을 설치해도 되지만 만약 서비스에서 카카오 로그인만 사용하고 싶다면 다른 모듈은 굳이 설치하지 않아도 되겠죠?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*zbQEB2mwdy-sYGLq.png" /></figure><p><a href="https://developers.kakao.com/docs/latest/ko/getting-started/sdk-ios#apply-sdk:~:text=%EC%95%84%EB%9E%98%EB%8A%94%20%EB%AA%A8%EB%93%88%20%EC%A0%95%EB%B3%B4%EC%9E%85%EB%8B%88%EB%8B%A4.%20%EA%B0%81%20%EB%AA%A8%EB%93%88%EC%9D%80%20%EC%9D%98%EC%A1%B4%ED%95%98%EB%8A%94%20%EB%AA%A8%EB%93%88%EC%9D%84%20%EC%9E%90%EB%8F%99%EC%9C%BC%EB%A1%9C%20%ED%95%A8%EA%BB%98%20%EC%84%A4%EC%B9%98%ED%95%98%EB%AF%80%EB%A1%9C%2C%20%ED%95%84%EC%9A%94%ED%95%9C%20%EB%AA%A8%EB%93%88%EB%A7%8C%20%EC%B2%B4%ED%81%AC%ED%95%98%EC%97%AC%20%EC%84%A4%EC%B9%98%ED%95%B4%EB%8F%84%20SDK%EA%B0%80%20%EC%A0%95%EC%83%81%20%EB%8F%99%EC%9E%91%ED%95%A9%EB%8B%88%EB%8B%A4.">모듈 정보</a>를 확인하면 KakaoSDKUser, KakaoSDKAuth.. 왠지 두 모듈을 설치해야 한다는 느낌이 듭니다. 하지만 <a href="https://developers.kakao.com/docs/latest/ko/getting-started/sdk-ios#select-module-dependency">모듈간 의존성</a> 그래프에 따라 KakaoSDKUser를 설치 시 KakaoSDKAuth을 자동으로 설치하는 것을 알 수 있습니다.</p><h3>프로젝트 설정</h3><p>이제 AppDelegate에서 SDK를 초기화 합니다. SDK를 초기화하기 위해서는 앱 키가 필요한데, 콘솔의 [내 애플리케이션] &gt; [요약 정보] 에서 <strong>네이티브 앱 키</strong>를 확인합니다. 그리고 AppDelegate에서 SDK를 초기화하기 위한 코드를 추가합니다.</p><pre>KakaoSDK.initSDK(appKey: &quot;97f....&quot;)</pre><p>이제 서비스에서 제공할 카카오톡 로그인 방식을 결정해야 합니다. 어떤 로그인 방식을 지원하는지에 따라 추가적인 작업이 필요하기 때문입니다. 우선 카카오톡 로그인 방식에는 두 가지가 있습니다.</p><ol><li><strong>카카오계정으로 로그인 :</strong> OS의 기본 웹 브라우저를 통해 로그인을 진행합니다. 사용자가 웹 브라우저에서 카카오계정 정보를 직접 입력하는 단계를 거치기 때문에 카카오톡이 설치되어 있지 않거나 지원하지 않는 디바이스에서 사용하길 권장하고 있습니다.</li><li><strong>카카오톡으로 로그인 :</strong> 디바이스에 설치되어 있는 카카오톡을 실행시켜 로그인을 진행합니다. 사용자가 카카오계정 정보를 직접 입력하지 않아도 간편하게 로그인할 수 있습니다.</li></ol><p>서비스의 사용자 로그인 동선을 고려해서 어떤 방법이 적합한지 판단합니다. KakaoSDKUser 모듈에서 제공하는 디바이스의 카카오톡 설치 여부를 판단할 수 있는 기능을 사용해서 적절한 동선을 구현할 수 있습니다.</p><pre>UserApi.isKakaoTalkLoginAvailable()</pre><p>디바이스에 카카오톡이 설치돼 있다면 카카오톡으로 로그인을, 설치돼 있지 않다면 카카오계정으로 로그인 하도록 구현하는게 Best라고 생각합니다.</p><h3>카카오톡으로 로그인</h3><p>만약 서비스에서 카카오톡으로 로그인을 지원하기 위해서는 두 가지를 추가적으로 설정해야 합니다.</p><ul><li><strong>앱 실행 허용 목록에 추가 :</strong> Info.plist에 LSApplicationQueriesSchemes 키를 추가하고 kakaokompassauth를 항목으로 추가합니다. 이는 앱에서 카카오톡을 실행할 수 있도록 하는 카카오톡의 URL 스키마입니다. 자세한 내용은 <a href="https://developers.kakao.com/docs/latest/ko/getting-started/sdk-ios#set-up-plist">앱 실행 허용 목록</a>을 참고합니다.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*yIZrZccEe-4JCfW0.png" /></figure><ul><li><strong>URL Schemes 설정 :</strong> 카카오 계정을 통한 인증과 카카오톡 메시지를 통한 앱 실행을 위해 설정합니다. Info.plist &gt; [URL Types] &gt; [URL Schemes] 항목에 kakao${NATIVE_APP_KEY} 형식으로 등록합니다. 예를 들어, 네이티브 앱 키가 “1234”라면 kakao1234 라고 등록합니다.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*QiJ3_BtrLYNkEgtX.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=11f8357f2a52" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Image caching of Kingfisher]]></title>
            <link>https://jaeyoungan.medium.com/kingfisher-1-%EC%BA%90%EC%8B%B1-c45a54505d22?source=rss-5b33de1fbe00------2</link>
            <guid isPermaLink="false">https://medium.com/p/c45a54505d22</guid>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[kingfisher]]></category>
            <category><![CDATA[image-caching]]></category>
            <dc:creator><![CDATA[Jaeyoung An]]></dc:creator>
            <pubDate>Wed, 27 Apr 2022 11:45:37 GMT</pubDate>
            <atom:updated>2024-08-16T06:00:01.730Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*P_Z-jcbazn6349NIQ4z3wg.png" /></figure><p><a href="https://github.com/onevcat/Kingfisher">Kingfisher</a>는 Github에서 20k 스타를 받은 iOS의 대표적인 이미지 캐싱 라이브러리 입니다. Kingfisher의 동작 과정을 알고 싶어서 공부할 겸 포스팅 해봅니다. 우선 이미지 캐싱의 개념을 알아봅시다!</p><h3>이미지 캐싱이란</h3><p>리모트 혹은 로컬 URL에서 이미지를 다운로드 한 뒤 메모리나 디스크에 이미지를 저장하고, 동일한 URL로 이미지를 다운로드 할 때 저장소에서 이미지를 가져와서 사용합니다. 매번 다운로드를 해서 이미지를 가져오는 것보다 리소스를 효율적으로 사용할 수 있습니다.</p><h4>캐시 관리는 어떻게 할까요?</h4><p>메모리, 디스크 모두 저장 공간이 제한적이고 디스크는 앱이 종료돼도 데이터가 남아있어 적절히 관리해야 합니다. 일반적으로 캐시의 만료 날짜를 설정하고 캐시에 접근할 때마다 날짜를 갱신합니다. 그리고 일정 기간동안 캐시에 접근하지 않아 만료되면 캐시를 제거합니다. Kingfisher에서도 이러한 방법으로 캐시를 관리하며 사용자가 직접 만료 날짜를 설정하지 않으면 메모리 캐시의 경우 5분, 디스크 캐시의 경우 7일 뒤 만료됩니다.</p><h4><strong>캐싱됐는지 어떻게 판단할까요?</strong></h4><p>일반적으로 각 캐시는 키를 가지고 있습니다. 이미지의 URL과 같이 고유한 값을 캐시의 키로 저장하고 이후에 동일한 키를 가진 캐시가 있다면 캐싱된 데이터를 가져옵니다.</p><h4><strong>만약 이미지가 변경된다면?</strong></h4><p>예를 들어, 서버로부터 받은 사용자의 프로필 이미지 URL에서 이미지를 다운로드 한 뒤 URL을 캐시의 키로 사용한다고 가정해 봅시다. 만약 사용자가 프로필 사진을 변경한다면 변경된 이미지를 받아야 하지만 URL은 동일하기 때문에 기존에 캐싱된 이미지를 다시 가져옵니다. 이때 리소스가 변경된 것을 알리기 위해 Etag 헤더를 사용하거나 새로운 URL을 전달합니다.</p><h3>Kingfisher 핵심 타입</h3><ul><li><strong>Source</strong>는 Kingfisher에서 전반적으로 사용되는 타입으로 이미지를 어떤 방식으로 받아오고 캐싱 할지를 나타냅니다.</li><li><strong>Resource</strong>는 캐시의 키와 이미지를 다운로드 할 수 있는 URL을 가진 프로토콜 입니다. 프로토콜을 준수하는 매개변수를 넘기고 이미지를 다운로드 할 수 있는 URL이 파일 주소라면 로컬에서, 아니면 네트워크를 통해서 이미지를 받도록 Source 타입의 내부 케이스로 변환됩니다. Resource의 구현부를 살펴봅시다!</li></ul><pre>public protocol Resource {<br>  var cacheKey: String { get }<br>  var downloadURL: URL { get }<br>}<br><br>extension Resource {<br>  public func convertToSource() -&gt; Source {<br>    return downloadURL.isFileURL ?<br>      .provider(LocalFileImageDataProvider(fileURL: downloadURL, cacheKey: cacheKey)) :<br>      .network(self)<br>  }<br>}</pre><p>Kingfisher 내에서 URL 타입이 Resource 프로토콜을 준수하고 있습니다. 그래서 우리에게 익숙한 imageView.kf.setImage(with: url)과 같이 사용할 수 있습니다. 이때 cacheKey는 URL의 absoluteString, downloadURL은 URL 자체가 됩니다.</p><pre>extension URL: Resource {<br>  public var cacheKey: String { return absoluteString }<br>  public var downloadURL: URL { return self }<br>}</pre><p>또한 ImageResource 타입을 사용하면 URL의 absoluteString이 아닌 원하는 캐시의 키를 사용할 수 있습니다.</p><pre>public struct ImageResource: Resource {<br>  public init(downloadURL: URL, cacheKey: String? = nil) {<br>    self.downloadURL = downloadURL<br>    self.cacheKey = cacheKey ?? downloadURL.absoluteString<br>  }<br><br>  public let cacheKey: String<br>  public let downloadURL: URL<br>}</pre><h3>Kingfisher 이미지 캐싱</h3><p>Kingfisher에서 사용되는 Resource와 Source 타입에 대해 알아봤습니다. 이제 어떻게 이미지를 다운로드 하고 캐싱 하는지 살펴보겠습니다. 모든 옵션은 기본 값이며 URL을 매개변수로 사용하는 과정입니다.</p><ol><li>kf<strong> 프로퍼티를 통해서 </strong>setImage(with resource:)<strong> 함수를 호출합니다.</strong></li></ol><pre>imageView.kf.setImage(with: url)</pre><p><strong>2.</strong> url.absoluteString<strong>을 캐시의 키로 사용하여 캐싱 여부를 확인합니다.</strong></p><pre>let loadedFromCache = retrieveImageFromCache(<br>  source: source,<br>  context: context,<br>  completionHandler: completionHandler)<br><br>if loadedFromCache {<br>  return nil<br>}</pre><p>retrieveImageFromCache는 메모리, 디스크 순으로 캐싱되어 있는지 확인하고 데이터를 가져옵니다. 만약 캐싱된 값이 있다면 클로저를 실행하고 nil을 반환합니다. 하지만 캐싱된 값이 없다면 loadAndCacheImage를 통해 이미지를 다운로드 한 뒤 캐싱합니다. 근데 왜 메모리, 디스크 순으로 확인을 할까요?</p><p><a href="https://github.com/onevcat/Kingfisher#:~:text=your%20next%20app.-,Features,-Asynchronous%20image%20downloading">README의 Features</a>를 보면 <em>Multiple-layer hybrid cache for both memory and disk.</em> 라고 명시되어 있는데 메모리와 디스크 모두를 위한 다중 계층 하이브리드 캐시, 이는 <strong>메모리와 디스크 서로의 단점을 보완</strong>하기 위해서 라고 합니다. 메모리는 속도가 빠르지만 앱이 종료되면 저장된 데이터가 사라집니다. 디스크는 속도가 느리지만 앱이 종료돼도 데이터가 남아있습니다.</p><p>처음 이미지를 다운로드 할 때 메모리와 디스크에 캐싱하고 다시 이미지를 불러올 때 속도가 빠른 메모리에서 가져옵니다. 그리고 앱이 종료돼서 메모리에 있는 이미지가 사라질 때 디스크에 있는 이미지를 가져오고 다시 메모리에 저장합니다. 이처럼 메모리와 디스크의 장점을 적절히 이용합니다. 상세한 저장 과정은 MemoryStorage와 DiskStorage를 살펴보시기 바랍니다.</p><p><strong>3.</strong> <strong>캐싱된 값이 없다면 </strong>loadAndCacheImage<strong>에서 이미지를 다운로드 하고 이미지를 메모리와 디스크에 저장합니다.</strong></p><pre>return loadAndCacheImage(<br>  source: source,<br>  context: context,<br>  completionHandler: completionHandler)?.value</pre><p>1번 과정에서 네트워크 혹은 로컬에서 이미지를 받을 지 정해져 있습니다. loadAndCacheImage에서 네트워크는 URLSession, 로컬은 Data(contentsOf:)로 이미지를 다운로드 하고 메모리와 디스크에 이미지를 저장합니다.</p><p>참고</p><p><a href="https://github.com/onevcat/Kingfisher">GitHub - onevcat/Kingfisher: A lightweight, pure-Swift library for downloading and caching images from the web.</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c45a54505d22" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Refactoring with Alamofire advanced usage]]></title>
            <link>https://jaeyoungan.medium.com/alamofire-%ED%99%9C%EC%9A%A9%EA%B8%B0-8bf5274fbaf?source=rss-5b33de1fbe00------2</link>
            <guid isPermaLink="false">https://medium.com/p/8bf5274fbaf</guid>
            <category><![CDATA[alamofire]]></category>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[urlrequest]]></category>
            <category><![CDATA[router]]></category>
            <dc:creator><![CDATA[Jaeyoung An]]></dc:creator>
            <pubDate>Mon, 03 Jan 2022 06:40:28 GMT</pubDate>
            <atom:updated>2024-08-16T07:17:02.315Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dfdw97dXRHH5m4GIzCWAMA.png" /></figure><p><strong>Alamofire</strong>는 Foundation 프레임워크의 <a href="https://developer.apple.com/documentation/foundation/url_loading_system/">URL Loading System</a>을 기반으로 구축돼서 HTTP 네트워킹과 관련된 다양한 기능들을 편리한 인터페이스로 제공하는 라이브러리입니다. Swift 레포지토리 중에서 <a href="https://github.com/vsouza/awesome-ios">awesome-ios</a> 다음으로 많은 36,000개의 Star를 받았고 수 백명의 개발자가 기여하고 있는 신뢰있는 라이브러리입니다.</p><p>이번 포스팅은 <a href="https://github.com/Alamofire/Alamofire/blob/master/Documentation/Usage.md#using-alamofire">Alamofire Basic Usage</a>를 사용하여 작성한 하나의 네트워킹 요청 함수의 문제점을 파악하고, 이를 세 가지 <a href="https://github.com/Alamofire/Alamofire/blob/master/Documentation/AdvancedUsage.md">Alamofire Advanced Usage</a>를 사용해서 개선하는 내용입니다.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a4cd583ff325185b63b6c9e0d433eae5/href">https://medium.com/media/a4cd583ff325185b63b6c9e0d433eae5/href</a></iframe><p><a href="https://github.com/Alamofire/Alamofire/blob/master/Documentation/Usage.md#using-alamofire">Alamofire Basic Usage</a>를 사용하여 작성한 네트워킹 요청 함수입니다. 위 함수만 보면 문제가 없지만 모든 네트워킹 요청 함수가 동일한 구조라면 몇 가지 문제가 발생합니다.</p><h4>가독성</h4><p>HTTP 헤더 혹은 쿼리 파라미터의 수가 많아지거나 조건에 따른 값을 설정해야 하는 등 함수의 구현부가 길어진다면 구조를 파악하기 어렵습니다.</p><h4>디버깅</h4><p>네트워킹 요청이 의도한 대로 보내졌는지, 원하는 응답을 받았는지 확인하기 위해 필요한 값을 추출하는 과정이 있습니다. 이는 대부분의 네트워킹 요청 함수에서 필요하므로 중복된 코드가 발생합니다. 함수로 구현하여 코드의 길이를 줄일 수 있지만 <a href="https://github.com/Alamofire/Alamofire/blob/master/Documentation/AdvancedUsage.md">Alamofire Advanced Usage</a>를 사용하면 더 효과적으로 개선할 수 있습니다.</p><h4>유지보수</h4><p>만약 토큰 저장소가 키체인에서 다른 곳으로 변경되거나 혹은 API의 v1이 폐지되고 v2가 릴리즈 된다면 어떻게 될까요? 모든 네트워킹 요청 함수의 URL에서 v1을 v2로 변경하고 KeychainService를 OtherStorageService로 대체해야 합니다. 이는 불필요한 시간이 소요될 뿐만 아니라 휴먼 에러를 야기할 수 있습니다. 따라서 중앙 집중식으로 구성하여 보다 편리하게 유지 보수할 수 있는 환경을 만들어야 합니다.</p><h3>URLRequestConvertible</h3><p>URLRequestConvertible은 각 네트워킹 요청의 경로 및 구성 요소를 정의하는 라우터를 구현함으로써 네트워킹 요청 부분을 캡슐화하여 API 구조를 쉽게 설계할 수 있습니다.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d02dfa8f7230373929a2c6b4758095fd/href">https://medium.com/media/d02dfa8f7230373929a2c6b4758095fd/href</a></iframe><p>각 네트워킹 요청 함수에서 변경해야할 부분을 찾지 않고 라우터 내부에서 변경하면 됩니다. 아래와 같이 Router를 적용하면 어떤 API를 사용하고 있는지, 어떤 값이 필요한지 파악하기 쉬워집니다.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/bc154ea54c9da02b1cfd83d0fdc0954e/href">https://medium.com/media/bc154ea54c9da02b1cfd83d0fdc0954e/href</a></iframe><p>만약 사용하는 API의 개수가 많아져서 관리가 힘들어지면 용도에 따라 더 작은 라우터로 분리하는 것을 공식 문서에서 권장하고 있습니다.</p><p>하지만 라우터를 분리하면서 따라오는 아쉬움이 있습니다. Authorization 헤더에 토큰을 설정하거나 오픈 API의 클라이언트 ID를 설정하는 등 모든 네트워킹 요청을 하기 전에 필요한 과정이 변경된다면 모든 라우터에서 추가・수정해야 합니다. 이는 RequestAdapter 를 통해 개선할 수 있습니다.</p><h3><strong>RequestAdapter</strong></h3><p>RequestAdapter는 네트워킹 요청 전에 필요한 사전 작업을 수행합니다. 예를 들어, 모든 네트워킹 요청에 Authorization 헤더가 포함될 때 사용하기 적절합니다.</p><p>이를 적용하기 위해서는 커스텀 세션을 생성해야 하는데, 세션을 초기화할 때 RequestAdapter와 RequestRetrier 프로토콜로 구성된 RequestInterceptor를 주입해야 합니다. RequestInterceptor의 Extension에 기본 동작이 구현되어 있어서 필요한 기능만 커스텀 합니다.</p><pre>public protocol RequestInterceptor: RequestAdapter, RequestRetrier {}<br><br>extension RequestInterceptor {<br>    public func adapt(_ urlRequest: URLRequest, <br>                      for session: Session, <br>                      completion: @escaping (Result&lt;URLRequest, Error&gt;) -&gt; Void) {<br>        completion(.success(urlRequest))<br>    }<br><br>    public func retry(_ request: Request,<br>                      for session: Session,<br>                      dueTo error: Error,<br>                      completion: @escaping (RetryResult) -&gt; Void) {<br>        completion(.doNotRetry)<br>    }<br>}</pre><p>RequestInterceptor 프로토콜을 준수하는 클래스를 작성합니다.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/995449b9829a0d9bb706a9e9ef0176ca/href">https://medium.com/media/995449b9829a0d9bb706a9e9ef0176ca/href</a></iframe><p>네트워킹 요청하기 전에 adapt 함수를 거쳐서 URLRequest를 변경 혹은 검사합니다. 위와 같이 저장된 토큰이 없으면 실패로 처리하거나 토큰을 갱신할 수 있습니다.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f0f3f9fd13e300fccf85c8379259c75e/href">https://medium.com/media/f0f3f9fd13e300fccf85c8379259c75e/href</a></iframe><p>어댑터가 포함된 Interceptor를 주입해서 커스텀 세션을 사용합니다.</p><h3>EventMonitor</h3><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c89651716388eb29cb80173d618bdb16/href">https://medium.com/media/c89651716388eb29cb80173d618bdb16/href</a></iframe><p>getProducts 는 네트워킹 응답을 디버깅하기 위해 DataResponse에서 필요한 값을 추출합니다. 이는 getProducts 뿐만 아니라 모든 네트워킹 요청 함수에서 필요합니다. 하지만 모든 함수에 추가한다면 많은 중복 코드가 발생합니다. 이를 EventMonitor로 개선할 수 있습니다.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/03484abe310f4a0420dab4e1b1e00e86/href">https://medium.com/media/03484abe310f4a0420dab4e1b1e00e86/href</a></iframe><p>EventMonitor는 Alamofire 내 URLSessionDelegate, URLSessionTaskDelegate, URLSessionDownloadDelegate의 수 많은 이벤트를 관찰할 수 있습니다. 그리고 관찰하고 있는 이벤트를 전달하기 위해 DispatchQueue 가 필요합니다. 기본적으로 메인 큐를 사용하지만 공식 문서에서는 성능을 위해 별도의 직렬 큐(Serial Queue)를 사용하길 권장하고 있습니다.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/68bd86ab76154df1e2b4875fab844dcc/href">https://medium.com/media/68bd86ab76154df1e2b4875fab844dcc/href</a></iframe><p>정상적으로 네트워킹 요청과 응답이 이루어졌는지 EventMonitor 프로토콜의 두 가지 메소드를 이용해서 살펴봅시다.</p><h4>요청</h4><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/96cb1573bb38da4dd27ab21874ee3955/href">https://medium.com/media/96cb1573bb38da4dd27ab21874ee3955/href</a></iframe><p>requestDidResume(_ request:)은 네트워킹 요청이 시작될 때 트리거 됩니다. 트리거 된 URLRequest에서 원하는 값을 추출할 수 있습니다. 취향에 맞는 포멧으로 출력하여 디버깅 합니다.</p><h4>응답</h4><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8cf26122026f29d29e2630bd13851568/href">https://medium.com/media/8cf26122026f29d29e2630bd13851568/href</a></iframe><p>request&lt;Value&gt;(_ request:didParseResponse:)는 네트워킹 요청에 대한 응답을 받았을 때 트리거 됩니다. 트리거 된 DataResponse에서 원하는 값을 추출할 수 있습니다. RequestAdapter와 마찬가지로 커스텀 세션을 생성해서 주입할 수 있습니다.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f7a3d6f70b58fcbcbf4890bbb99f2bbd/href">https://medium.com/media/f7a3d6f70b58fcbcbf4890bbb99f2bbd/href</a></iframe><p>참고</p><p><a href="https://github.com/Alamofire/Alamofire">GitHub - Alamofire/Alamofire: Elegant HTTP Networking in Swift</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8bf5274fbaf" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>