MemoryLayout<Int8>.size   // 1바이트
Int8.max      //  127    ( 2^7 -1)
Int8.min      // -128    (-2^7)

MemoryLayout<UInt8>.size     // 1바이트
UInt8.max     //  255     ( 2^8 -1)
UInt8.min     //    0

MemoryLayout<Int>.size     // 8바이트
// 64비트 컴퓨터 기준
// 63 = 2^8 - 1 (부호 비트)
Int.max       //  9223372036854775807   ( 2^63 -1)
Int.min       // -9223372036854775808   (-2^63 )

var doorCheck = 0
var passwordCheck = 0

func doorCodeChecking() -> Bool {
    doorCheck += 1
    print(#function)
    return true
}

func passwordCodeChecking() -> Bool {
    passwordCheck += 1
    print(#function)
    return true
}

// ---------- 첫번째 케이스 ---------- 
if doorCodeChecking() && passwordCodeChecking() && false || true && doorCodeChecking() && passwordCodeChecking() {
    // 조건문에 대한 코드
}
print("Door: \(doorCheck), Password: \(passwordCheck)")

//-> Door: 2, Password: 2

// ---------- 두번째 케이스 ---------- 
doorCheck = 0
passwordCheck = 0

if doorCodeChecking() && false && passwordCodeChecking() || doorCodeChecking() || passwordCodeChecking() {
    // 조건문에 대한 코드
}
print("Door: \(doorCheck), Password: \(passwordCheck)")

// -> Door: 2, Password: 0

// ---------- 세번째 케이스 ---------- 
doorCheck = 0
passwordCheck = 0

if doorCodeChecking() || passwordCodeChecking() && doorCodeChecking() || false && passwordCodeChecking() {
    // 조건문에 대한 코드
}
print("Door: \(doorCheck), Password: \(passwordCheck)")

// -> Door: 1, Password: 0

// -------- 수정된 세번째 케이스 -------- 
doorCheck = 0
passwordCheck = 0

let doorResult1 = doorCodeChecking()
let passwordResult1 = passwordCodeChecking()
let doorResult2 = doorCodeChecking()
let passwordResult2 = passwordCodeChecking()

if doorResult1 || passwordResult1 && doorResult1 || false && passwordResult2 {
    // 조건문에 대한 코드
}
print("Door: \(doorCheck), Password: \(passwordCheck)")

// -> Door: 2, Password: 2

// 1) 연산자 (위치) 선언
postfix operator <++  // 후치 연산자
prefix operator ++> // 전치 연산자

// 2) 연산자의 실제 정의
extension Int {
	// 후치 연산자
	static postfix func <++(number: inout Int) {
		number += 1
	}
	// 전치 연산자
	static prefix func ++>(number: inout Int) {
		number += 1
	}
}

// 커스텀 연산자의 사용
var a = 0
++>a      // +1
a<++      // +1
print(a)  //  2

// 1) 우선순위 그룹의 선언 (우선순위, 결합성 설정)
precedencegroup MyPrecedence {
    higherThan: AdditionPrecedence
    lowerThan: MultiplicationPrecedence
    associativity: left  // 결합성 : left / right / none
}

// 2) (전역의 범위에서) 정의하려는 연산자를 선언하고, 우선순위 그룹을 지정
// 단항 -> 전치(prefix), 후치(postfix) / 이항 -> infix

// "우선 순위와 결합성"을 지정은 새로운 우선순위 그룹을 선언하거나, 이미 존재하는 우선 순위 그룹을 사용하는 것도 가능
// 우선순위 그룹을 지정하지 않으면 "DefaultPrecedence"라는 기본 그룹에 속하게 됨
// 삼항연산자보다 한단계 높은 우선순위가 되며, 결합성은 none설정되어 다른 연산자와 결합 사용은 불가능

infix operator +-: MyPrecedence

// 3) 연산자의 실제 정의
// 해당 연산자를 구현하려는 타입에서 타입메서드로 연산자 내용을 직접 구현
extension Vector2D {
    static func +- (left: Vector2D, right: Vector2D) -> Vector2D {
        return Vector2D(x: left.x + right.x, y: left.y - right.y)
    }
}

// 커스텀 연산자의 사용
let firstVector = Vector2D(x: 1.0, y: 2.0)
let secondVector = Vector2D(x: 3.0, y: 4.0)
let plusMinusVector = firstVector +- secondVector

print(plusMinusVector)   // Vector2D(x: 4.0, y: -2.0)