sanichdaniel의 iOS 개발 블로그

WWDC: The Layout Cycle

sanich8355 — Sun, 6 Dec 2020 16:07:48 +0900

The Layout Cycle

Layout은 Black Box일때가 많다.

뷰에 주어진 constraint으로부터 뷰에 프레임이 할당되기까지의 과정에 대해 알아보자

The Layout Cycle

1. Application Run Loop 이 돈다

2. Constraint가 변한다

Constraint 변하는 상황들에는 아래의 예시들이 있다.

1. activate or deactivate

2. setting constant or prioritiy

3. adding or removing views

Constraint change가 발생하면 Layout Engine은 layout을 다시 계산한다

뷰들은 자신의 superview가 layout을 다시 그려야한다고 마킹하다 (superview.setNeedsLayout()을 호출)
이 과정이 deferred layout pass를 스케줄한다.

3. deferred layout pass가 발생한다.

잘못 배치된 뷰들을 재배치해준다.

여기서 layout의 constraint를 업데이트하고 뷰 들의 프레임을 다시 계산한다.

deferred layout pass를 스케줄 하고 싶다면 setNeedsLayout이나 setNeedUpdateConstraints를 호출해주면 된다.

deferred layout pass는 2가지 단계를 거친다.

1. update pass

필요시, constraints를 업데이트한다

시스템은 뷰 계층을 돌며 뷰컨트롤러에 updateViewConstraints를 호출하고 뷰에 updateConstraints를 호출한다.

만약 constraints 업데이트가 느리거나, 뷰가 불필요하게 바뀌는 퍼포먼스 이슈 발생하여 constraints를 일괄적으로 업데이트 하고 싶을때는 이 함수들을 오버라이드 할 수 있다. 하지만 지금까지 작업하며 오버라이드 한적이 한번도 없었고 WWDC나 아래 스택오버플로우 답글에서도 그때그때 컨스트레인트를 업데이트하는것을 추천한다.

2. layout pass

필요시, 뷰의 프레임을 다시 재배치한다.

시스템은 뷰 계층을 돌며 레이아웃이 필요하다고 마킹된 뷰컨트롤러에 viewWillLayoutSubviews를 호출하고, 뷰에 layoutSubviews를 호출한다.

이 함수들을 오버라이드하여 커스텀한 레이아웃을 줄 수 있으나, 레이아웃이 컨스트레인트 자체만으로 표현될수 없을때만 하는게 좋다.

자신의 subtree 바깥의 뷰를 invalidate하지 않는게 좋다

이 과정에서 Layout Engine으로부터 서브뷰의 프레임을 복사해와 서브뷰들이 포지션된다.

출처

developer.apple.com/videos/play/wwdc2015/219/

developer.apple.com/library/archive/documentation/UserExperience/Conceptual/AutolayoutPG/ModifyingConstraints.html

stackoverflow.com/questions/47823639/why-calling-setneedsupdateconstraints-isnt-needed-for-constraint-changes-or-ani\

www.youtube.com/watch?v=xjArhdrqAn8&feature=youtu.be&t=20m00s

nested function (중첩함수)

sanich8355 — Sun, 15 Nov 2020 14:37:15 +0900

마틴 파울러의 리팩토링을 읽다가 리팩토링 기법중 하나인 함수를 추출하기 단원을 읽다가,
함수가 사용되는곳이 한곳에 불과하면 private 함수로 빼는것보다 중첩함수를 사용하는것이 유용하다는 글을 읽었다.
중첩함수를 한번도 사용해본적이 없었기에 공부해보았다.

중첩함수를 처음 보았을때는 낯설어서 못생겼다고 생각을 했었다.

하자만 공부해보니 중첩함수는 가독성과 캡슐화의 측면에서 이점이 있다.

가독성

private 함수는 클래스(또는 파일)에서 접근이 가능하다.

하지만 중첩함수는 해당 함수안에서만 사용된다는것이 보장된다.

public namespace를 줄이려고 private 키워드를 사용하듯, private namespace를 줄이기 위해 중첩함수를 사용해보자.

캡슐화

중첩함수는 소속된 함수의 지역변수에 접근할수 있다.

지역변수들을 인자로 전달할 필요가 없다

조심할점

순환참조!

출처

stackoverflow.com/questions/32968133/what-is-the-practical-use-of-nested-functions-in-swift

WWDC: Better Apps with Value type

sanich8355 — Sun, 25 Oct 2020 17:18:09 +0900

value 타입에 관한 WWDC 영상을 참고하여 새로알게된 사실들을 정리해보았다.

배경지식

value type vs reference type

value type: 값이 복사될때 (할당, 생성, 인자로 넘겨질때) 매번 독립적인 인스턴스를 만든다.

reference type: 값이 복사될때 참조가 복사되고 인스턴스는 공유된다

heap stack 어디 저장되나

Referenct 타입은 heap에 저장되고, 포인터(참조)는 stack에 저장된다.

value type이 class에 포함되거나 closure에 캡쳐되면 heap에 저장된다.

Reference 타입은 항상 heap에 저장, value 타입은 자신이 선언된곳에 저장된다.

Local Reasoning

강의 초반에 Local Reasoning이란 term이 나온다.

Local Reasoning이란 한곳의 코드를 보면, 다른 곳의 코드와 어떻게 상호작용해야하는지 생각할 필요가 없는것을 말한다.

팀에 처음 합류해서 코드를 볼때 아는 건 없고, 어떻게 코드들이 상호작용 되는지 몰라 몹시 혼란스러운 경험이 다들 있을것이다.

Local Reasoning이 잘 되어있으면 처음 합류하는 사람도 이해하기 쉽고, 유지보수 하기가 쉽고, 작성하기 쉽고, 테스트 하기가 쉽다.

Value type for Local Reasoning

1. Different variables are logically distinct

Reference 타입의 경우 인스턴스들은 하나의 데이터를 가지고 있다.

따라서 다른곳에서 값이 수정될수도 있다. 이것은 Local Reasoning을 어렵게 한다.

하지만 Value타입의 경우 각 변수들은 논리적으로 구별된다.

하나의 value type 변수의 값을 mutate 한다고 다른 변수의 값에 영향을 끼치지 않는다.

2. Mutability when you want it

let을 붙여 외부에서 값 수정을 못하게 immutable하게 만들 수 있다.

값을 수정하고 싶을때만 var을 붙여주면 된다.

내부에서 인스턴스 메서드를 통해 값을 수정하려면 mutating 키워드가 필요하다

3. Copy is Cheap

지금까지 value type의 경우 매번 값이 복사되기에 비효율적이어서 커스텀 타입을 만들때 들고있을 변수들의 수가 적은 경우에만 value 타입을 써야한다 라고 잘못 알고 있었다.

하지만 WWDC에 따르면 copy의 값은 constant time이기에 싸다고 한다.

또한 내부적으로 copy-on-write 즉 값이 수정될때 copy가 실제로 일어나기에 더욱 값싸진다.

따라서 value 타입을 쓸수 있는 상황에서는 되도록 value 타입을 쓰자!

expression, statement, literal

sanich8355 — Sat, 24 Oct 2020 16:19:24 +0900

expressions(수식)

값을 리턴하는 코드

let someValue:Int = 12
if true && false {
    print("This is false")
}

여기에 들어간 expression은

let someValue:Int = 12
true && false
"This is false"

statement(문장)

어떠한 작업을 수행하는 모든 문장

Swift에서는 크게 3가지 종류로 statement를 구분한다

expression은 값을 리턴하는 statement라 볼 수 있다

1. simple statements

expression이나 선언

2. compiler control statements

#if

3. control flow staements

if 문, guard문, for 문..

literal

42               // Integer literal
3.14159          // Floating-point literal
"Hello, world!"  // String literal
true             // Boolean literal

literal은 자신만의 타입이 없다.

대신, swift의 타입 추론이 literal의 타입을 추론한다.

만약 적절한 타입정보를 얻을수 없다면, swift는 standard library에 나온 default literal type일것이라 추론한다.

정수형 literal에 대한 default 타입은 Int이고, 소숫점 literal에 대한 default 타입은 Double이다.

nil literal 같은 경우는 타입이 추론될수 없으니 아래와 같은 식은 불가능하다

let a = nil

양방향 타입추론

sanich8355 — Thu, 22 Oct 2020 14:39:22 +0900

Swift의 타입추론은 양방향으로 이루어진다고 한다. 알아보자

Bottom-up 타입 추론

타입 정보가 leaf에서 root으로 전달되는것

var x = 0

literal 0을 보고 x의 타입을 Int로 추론한다. (정수의 literal의 기본 타입은 Int이다.)

leaf인 literal이 root인 변수의 타입을 결정한다.

let age = 26              // age is of type Int
let name = "Toni"         // name is of type String
let pair = (age, name)    // pair is of type (Int, String)

pair 튜플의 타입은 (age, name)의 타입으로부터 결정이 된다.

타입체커는 age, name을 코드에서 찾는다.

즉 root인 pair의 타입은 leaf에 해당하는 age, name의 literal의 타입 정보로부터 전달되는것.

아래 트리는 위의 expression의 AST를 나타낸 것이다.

Abstract Syntax tree: 소스 코드를 컴퓨터가 이해할수 있는 트리구조로 변형시킨것. leaf에 해당하는 age, name으로부터 타입정보가 위로 전달되는것을 확인할수있다.

Top-down 타입 추론

Top-down은 반대로 root에서 leaf로 타입 정보가 전달된다.

4가지 케이스가 있다

1. literal expression

2. Implicit member expression

3. 클로져

4. 함수 호출 expression

Literal Expression

let y: Double = 2     // y is of type Double

정수 literal의 타입은 기본적으로 Int이다.

하지만 명시적으로 Double이라 타입을 적어주면, literal의 타입이 Double로 추론된다

위의 예시에서, root인 y의 타입 정보가 leaf인 literal 2의 타입을 Double 로 결정지었다. (Top - down)

배열 literal도 디폴트 타입이 Array<T>이나 Set이라 명시하면 Set<T> 타입을 얻을수 있다.

let arr = [1, 2, 3]                 // arr is of type Array<Int>
let mySet: Set<Int> = [1, 2, 3]       // set is of type Set<Int>

위 예시에서도 root인 mySet변수에 명시적으로 Set 타입을 주었기에, leaf인 오른쪽 배열 literal의 타입도 Set으로 추론되었다.

Implicit Member Expressions

타입의 멤버를 축약된 방식 dot . 으로 접근하는걸 말한다

enum이나 타입 메서드를 접근할때 사용된다

enum Season {
    case spring
    case summer
    case fall
    case winter
}

var season = Season.summer          // season is of type Season
season = .fall

season = .fall에서

.fall을 축약된 형태로 접근할수 있는것도 season변수의 타입이 Season으로 위에서 결정되었기에 가능한것이다.

root(변수 season)의 타입정보가 leaf(literal .fall)로 전달되었다.

Closures

클로져의 인자 타입과, 리턴 타입을 명시적으로 적어주지 않더라도, 클로져가 사용되는 문맥에서 타입이 자주 추론된다.

아래에서 filter() 함수는 클로져를 인자로 받는다.

클로져의 인자 n의 타입은 numbers 의 타입에 의해 추론된다

let numbers = [1, -2, 3]            // numbers is of type Array<Int>
let positiveNumbers = numbers.filter { n in n >= 0 }
print(positiveNumbers)              // [1, 3]

let numbers = [1.0, -2.0, 3.0]      // numbers is of type Array<Double>
let positiveNumbers = numbers.filter { n in n >= 0 }
print(positiveNumbers)              // [1.0, 3.0]

Overload Resoulution

함수나 operator는 overload될수 있다.

타입체커는 overload에서 어떤 함수를 사용할지 결정할때

함수의 인자의 타입과, 함수가 호출된 문맥을 둘다 확인한다.

func f() -> Int {
    return 2
}

func f() -> String {
    return "test"
}

let x = f()                   // error: ambiguous use of 'f()'
let y: Int = f()              // Overload Resolution picks f: () -> Int
let z: String = f()           // Overload Resolution picks f: () -> String

x의 경우에는 어떤 함수를 사용할지 결정할수 없어 에러가 난다.

하지만 y의 리턴타입은 Int가 와야하기에 첫번째 f() 함수를 사용하도록 결정이된다.

출처

tonisuter.com/

Operator Overloading

sanich8355 — Fri, 16 Oct 2020 20:42:20 +0900

Operator Overloading

Class, struct는 기존에 존재하는 operator에 대한 자신만의 구현을 제공할수 있다.

이것을 operator overloading이라 한다.

operator은 +, -, *, /, %, = 같은 심볼들로 값을 체크하거나, 수정, 합치는데 사용된다

함수를 사용하는것보다 더 간결하게 코드를 표현할수 있을때 사용된다

Equatable 프로토콜 구현이 사실 operator overloading이었다!

출처

www.hackingwithswift.com/example-code/language/how-to-use-operator-overloading

빌드 타임 개선

sanich8355 — Wed, 14 Oct 2020 21:44:16 +0900

빌드 타임이 어디서 오래걸리는지 측정해보았다.
Build Settings의 “Swift Compiler - Custom Flags”, “Other Swift Flags” 에서
-Xfrontend -warn-long-expression-type-checking=<limit> 옵션을 추가해주고 빌드해본 결과
== 비교 연산자를 사용하는곳에서 warning이 많이 나왔다.

비교 연산자 타입추론이 오래 걸리는 이유?

비교 연산자 == 은 수많은 곳에서 overload되는 operator이다. (overload: 같은 이름의 다른 메서드들)

swift standard library에서만 73곳에서 overload되고 있고, 커스텀하게 만든 타입들에서도 자주 overload 된다.

operator는 글로벌 함수처럼 호출되기에, 컴파일러는 모든 ==의 overload를 확인해야한다.

즉 자주 overload 되는 모든 operator들에서는 비교연산자와 같은 퍼포먼스 이슈가 있을것으로 보인다.

개선방안

protocol extension의 메서드로 바꿔주기

extension Equatable {
   func equals(_ object: Self?) -> Bool {
      guard case object = self else { return false }
      return true
   }
}

메서드인 경우 컴파일러가 타입추론하기 훨씬 쉽다.

컴파일러는 메서드가 호출된 base 타입의 overload만 확인하면 되기 때문이다.

또한 내부적으론 패턴매칭을 이용하여 equality를 비교한다.

패턴매칭은 내부적으로 ~= operator을 사용하는데, == 보단 일반적으로 적게 overload되기에 타입추론이 더 빠르다.

출처

forums.swift.org/t/swift-equality-operator-takes-long-time-to-type-check/41226/8

www.swiftbysundell.com/articles/improving-swift-compile-times

www.cocoawithlove.com/blog/2016/07/12/type-checker-issues.html

Pure functions in swift

sanich8355 — Wed, 14 Oct 2020 21:16:50 +0900

Pure function 이란?

1. 같은 인자라면, 같은 리턴 값 (외부에 의존하지 않는다)

2. 사이드 이펙트가 없다

장점

1. 재사용성, 테스트하기 쉬위짐

2. 사이드 이펙트가 적음

함수를 pure하게 만들기

1. 값을 바꾸지 말고, 새로운 값을 리턴하자

extension String {
    mutating func addSuffixIfNeeded(_ suffix: String) {
        guard !hasSuffix(suffix) else {
            return
        }

        append(suffix)
    }
}

아래 함수는 값을 mutate 하기에 pure 하지 않다

mutable 값에만 호출할수 있게되고 더러운 var muate assign 코드가 필요해진다.

var fileName = contentName
fileName.addSuffixIfNeeded(".md")
try save(content, inFileNamed: fileName)

extension String {
    func addingSuffixIfNeeded(_ suffix: String) -> String {
        guard !hasSuffix(suffix) else {
            return self
        }

        return appending(suffix)
    }
}

2. 외부 값에 의존하지 말고, 인자로 받자

func makeFailureHelpText() -> String {
    guard numberOfAttempts < 3 else {
        return "Still can't log you in. Forgot your password?"
    }
    
    return "Invalid username/password. Please try again."
}

func makeFailureHelpText(numberOfAttempts: Int) -> String {
    guard numberOfAttempts < 3 else {
        return "Still can't log you in. Forgot your password?"
    }
    
    return "Invalid username/password. Please try again."
}

Purity 강제하기

value 타입으로 로직을 구성하기

value 타입은 mutating 키워드를 붙이지 않는이상 mutable state를 갖지 못한다.

mutable하게 만드는 과정에서 mutating 키워드를 붙이게 되고, 이것은 pr 리뷰에서 발견이 가능하다!

struct PriceCalculator {
    let shippingCosts: ShippingCostDirectory
    let currency: Currency

    func calculateTotalPrice(for products: [Product],
                             shippingTo region: Region) -> Cost {
        let productCost: Cost = products.reduce(0) { cost, product in
            return cost + product.price
        }

        return productCost.convert(to: currency)
    }
}

출처

www.swiftbysundell.com/articles/pure-functions-in-swift/

www.swiftbysundell.com/articles/functional-networking-in-swift/

Currying

sanich8355 — Wed, 14 Oct 2020 19:35:56 +0900

Currying

여러 인자를 받는 함수를 하나의 인자만 받는 함수들의 시퀀스로 변환하는 것입니다.

변환된 함수는 인자 하나를 받고, 값 대신 함수를 리턴한다. 이 리턴되는 함수는 다음 인자를 입력으로 받는다.

예시 1

func add2(_ x: Int, _ y: Int) -> Int {
    return x + y
}
add2(1, 2) 

func add2Currying(_ x: Int) -> ((Int) -> Int) {
    return { y in
        return x + y
    }
}
add2Currying(1)(2)

예시 2

func curry<A, B, C>(_ fn: @escaping (A, B) -> C) -> (A) -> (B) -> C {
    return { (a: A) in
        return { (b: B) in
            return fn(a, b)
        }
    }
}

enum LogLevel: String {
    case debug
    case error
}

func logMessage(level: LogLevel, message: String) {
    print("[\(level)] \(message)")
}

let logCurried = curry(logMessage)
let debug = logCurried(.debug)

debug("Log debug 1st")
debug("Log debug 2nd")
debug("Log debug 3rd")

사실 우린 알게 모르게 Currying을 쓰고 있었는데, 모든 인스턴스 메서드는 currying 된 타입 메서드다

NSColor.blueColor().shadowWithLevel(1/3)
// 아래처럼 변환 가능
NSColor.shadowWithLevel(NSColor.blueColor())(1/3)

class Adder  {
    func addOne(a: Int) -> Int {
        return a + 1
    }
}
let adder = Adder()

let addOne = Adder.addOne
let instanceMethod = addOne(adder)
print(instanceMethod(4))

커링의 장점

1. 함수의 재사용을 쉽게 만들어 줌 (인자 중 변하지 않는 값은 고정시키고 변하는 값만 지정해서 함수를 실행할 수 있게 해줌)

2. 여러 파라미터를 한번에 받지않고 부분적으로 받은 후 함수의 실행을 늦출 수 있다.

3. 인스턴스를 모르는 상황에서 인스턴스 메서드를 참조 가능하다

출처

jusung.github.io/Currying/

medium.com/@lazysoul/currying-%EC%BB%A4%EB%A7%81-b7af0b2aaef1

일급 시민 함수 - swift

sanich8355 — Wed, 14 Oct 2020 19:17:20 +0900

swift에서 함수는 일급 시민이다라는 말은 여러번 들어보았지만, 정작 일급 시민 개념에 대해 완전히 모르는것 같아 공부해보았다.

일급 시민 (First-class Citizen)

다른 객체들에 일반적으로 적용 가능한 연산을 모두 지원하는 객체를 가리킨다.

1. 함수의 인자로 전달

2. 함수에 의해 리턴

3. 변수에 할당 가능

4. 비교 연산이 가능

일급 함수 (First-class Function)

함수를 일급 시민으로 취급하는것

High Order Function

함수를 인자로 받거나, 함수를 리턴하는 함수

함수가 일급 시민인 언어에서, high order function이 가능하다는것이 보장된다.

-> 함수를 인자로 받거나 리턴할수 있기에

high order function이 가능하다고 함수가 일급시민인것은 아니다

-> 함수의 인자로 함수가 오는것은 특이케이스로 취급된다

아래 예시들에서 어떻게 일급 함수를 사용할지 알아보자

1. 함수의 인자로 전달

let subviews = [button, label, imageView]

subviews.forEach { subview in
    view.addSubview(subview)
}

addSubview 함수를 (UIView) -> Void 타입의 클로져로 생각해보자.

forEach 함수는 (Element) -> Void 타입의 클로져를 인자로 받는다.

따라서 아래처럼 바로 view.addSubview 를 인자로 넘길수 있다.

subviews.forEach(view.addSubview)

조심해야할점은 위 예시처럼 인스턴스 메소드를 클로져처럼 사용하면 인스턴스가 클로져가 살아있는한 메모리상에 같이 남아있게 된다.

위에선 non-escaping 클로져여서 문제가 안되었지만 escaping 클로져에서는 주의

2. 생성자를 인자로 전달

생성자도 일급 시민 함수로 취급할 수 있다

아래 예시에서 생성자를 인자로 전달해보았다

images.map(UIImageView.init)
      .forEach(stackView.addArrangedSubview)

위와 같이 일급 시민 함수를 잘 사용하면 선언적인 코드르 얻을 수 있다.

3. 인스턴스 메서드 참조하기

한 클래스의 static 메서드를 호출하려고 클래스 타입까지만 적었는데도, 인스턴스 메서들이 자동완성으로 뜬다

이것은 버그가 아니라, 인스턴스 메서드 하나마다 대응되는 static 메서드가 생기기 때문이다.

(사실 인스턴스 메서드란, 타입 메서드중 인스턴스를 인자로 받고, 인스턴스에 적용될 함수를 리턴하는 Currying 함수다)

출처: oleb.net/blog/2014/07/swift-instance-methods-curried-functions/

이 static 메서드는 인자로 인스턴스를 받는다.

let closure = UIView.removeFromSuperview(view)

이 기능은 objective-c를 사용하는 target - action을 대체하는데 사용될수있다.

해당 타입의 인스턴스 메서드를 리턴하는 typealias 선언.

typealias Action<Type, Input> = (Type) -> (Input) -> Void

ColorPicker는 target action을 추가할수 있는 함수가 있다. observations 변수에서 액션들을 클로져로 들고 있다.

유저가 색깔을 선택하면 pickedColor 함수가 호출되고, 이 함수 내부에서 observations 어레이들을 실행시킨다

class ColorPicker: UIView {
    private(set) var selectedColor = UIColor.black
    private var observations = [(ColorPicker) -> Void]()

    func addTarget<T: AnyObject>(_ target: T,
                                 action: @escaping Action<T, ColorPicker>) {
        observations.append { [weak target] view in
            guard let target = target else {
                return
            }

            action(target)(view)
        }
    }
    
    func userPickedColor(color: UIColor) {
    	 selectedColor = color
         observations.forEach { $0(self) }
    }
}

* 위 코드는 아래와 같이 리팩토링 가능

observations.append { [weak target] view in
    target.map(action)?(view)
}

이제 뷰컨에서 ColorPicker에 대한 addTarget을 달아주자

class CanvasViewController: UIViewController {
    private var drawingColor = UIColor.black

    func presentColorPicker() {
        let picker = ColorPicker()
        picker.addTarget(self, action: CanvasViewController.colorPicked)
        view.addSubview(picker)
    }

    private func colorPicked(using picker: ColorPicker) {
        drawingColor = picker.selectedColor
    }
}

이제 유저가 피커에서 색깔을 선택할때마다, 뷰컨의 인스턴스 함수 colorPicked 함수가 호출이된다!

출처

www.swiftbysundell.com/articles/first-class-functions-in-swift/