enum VoteType {
    case coffee
    case sport
}

struct VotedItem {
    let type: VoteType
    let name: String
    let number: Int
}

struct TopThreeItemList {
    let items: [VotedItem]

    func topThree(of type: VoteType) -> [VotedItem] {
        let items = self.items.filter { $0.type == .sport }
            .sorted(by: { $0.number < $1.number })
            .reversed().prefix(3)
        return Array(items)
    }
}

let items = [
    VotedItem(type: .sport, name: "Baseball", number: 100),
    VotedItem(type: .sport, name: "Football", number: 200),
    VotedItem(type: .sport, name: "Golf", number: 300),
    VotedItem(type: .sport, name: "Basketball", number: 400),
]

let itemList = TopThreeItemList(items: items)
let topThree = itemList.topThree(of: .sport)

struct WorstThreeItemList {
    let items: [VotedItem]

    func worstThree(of type: VoteType) -> [VotedItem] {
        let items = self.items.filter { $0.type == .sport }
            .sorted(by: { $0.number < $1.number })
            .prefix(3)
        return Array(items)
    }
}

let worstItemList = WorstThreeItemList(items: items)
let worstThree = worstItemList.worstThree(of: .sport)

struct VoteResultAggregator {
    let items: [VotedItem]
    func extract(type:  VoteType, sortedBy: (VotedItem, VotedItem) -> Bool) -> [VotedItem] {
        return self.items.filter { $0.type == type }.sorted(by: sortedBy)
    }
}

let topSportItemList = VoteResultAggregator(items: items)
    .extract(type: .sport, sortedBy: { $0.number > $1.number })
    .prefix(3)

let worstSportItemList = VoteResultAggregator(items: items)
    .extract(type: .sport, sortedBy: { $0.number < $1.number })
    .prefix(3)

struct Aggregator<V> {
    let items: [V]
    func extract(filter: (V) -> Bool, sortedBy: (V, V) -> Bool) -> [V] {
        return self.items.filter(filter).sorted(by: sortedBy)
    }
}

// ある条件のtrue, falseで処理が変わる場合

if 条件がfalseの場合 {
    return
}

// もう一つの処理
...

enum Animal {
    case dog, cat, fish, bird
}

func run(animal: Animal) {
    switch animal {
    case .dog:
        print("dog run")
    case .cat:
        print("cat run")
    default:
        print("I can not run!!!!!")
    }
}

func fly(animal: Animal) {
    switch animal {
    case .bird:
        print("bird fly")
    default:
        print("I can not fly!!!!!")
    }
}

func run(animal: Animal) {
    switch animal {
    case .dog:
        print("dog run")
    case .cat:
        print("cat run")
    case .fish, .bird:
        print("I can not run!!!!!")
    }
}

func fly(animal: Animal) {
    switch animal {
    case .bird:
        print("bird fly")
    case .dog, .cat, .fish:
        print("I can not fly!!!!!")
    }
}

func fly(animal: Animal) {
    switch animal {
    case .bird:
        print("bird fly")
    @unknown default:
        print("I can not fly!!!!!")
    }
}

enum Weapon {
    case sword, arrow, bow
}

func attack(weapon: Weapon?) {
    guard let weapon = weapon else {
        print("hand attack")
        return
    }
    switch weapon {
    case .sword:
        print("sword attack")
    case .arrow:
        print("arrow attack")
    case .bow:
        print("bow attack")
    }
}

func attack(weapon: Weapon?) {

    switch weapon {
    case .sword?:
        print("sword attack")
    case .arrow?:
        print("arrow attack")
    case .bow?:
        print("bow attack")
    case nil:
        print("hand attack")
    }
}

struct Member {
    let id: Int
    var first: String?
    var second: String?    
}

struct Member {
    ...
    var displayName: String {
        var name: String = ""
        if let first = first {
            name += first
        }

        if let second = second {

            if first != nil {
                name += "⭐️"
            }
            name += "\(second)"
        }

        return name
    }
}

let member = MemberName(id: 1, first: "スター", second: "です")
print(member.displayName) // スター⭐️です

let member2 = MemberName(id: 1, first: "スター", second: nil)
print(member2.displayName) // スター

let member3 = MemberName(id: 1, first: nil, second: "です")
print(member3.displayName) // です

let member4 = MemberName(id: 1, first: nil, second: nil)
print(member4.displayName) //

struct Member {
    ...
    var displayName: String {
        var stringArray: [String] = []
        if let first = first {
            stringArray.append(first)
        }

        if let second = second {
            stringArray.append(second)
        }

        return stringArray.joined(separator: "⭐️")
    }
}
let member = MemberName(id: 1, first: "スター", second: "です")
print(member.displayName) // スター⭐️です

let member2 = MemberName(id: 1, first: "スター", second: nil)
print(member2.displayName) // スター

let member3 = MemberName(id: 1, first: nil, second: "です")
print(member3.displayName) // です

let member4 = MemberName(id: 1, first: nil, second: nil)
print(member4.displayName) //

struct Member {
    ...
    var displayName: String {
        switch (first, second) {
        case (let first?, let second?):
            return "\(first)⭐️\(second)"
        case (let first?, nil):
            return "\(first)"
        case (nil, let second?):
            return "\(second)"
        case (nil, nil):
            return ""
        }
    }
}
let member = MemberName(id: 1, first: "スター", second: "です")
print(member.displayName) // スター⭐️です

let member2 = MemberName(id: 1, first: "スター", second: nil)
print(member2.displayName) // スター

let member3 = MemberName(id: 1, first: nil, second: "です")
print(member3.displayName) // です

let member4 = MemberName(id: 1, first: nil, second: nil)
print(member4.displayName) //

func sendInvitation(to name: String) {
    print("\(name)様、せひお越しください!!!")
}

func sendInvitation(to name: String) {
    print("\(name)様、せひお越しください!!!")
}

let member4 = MemberName(id: 1, first: nil, second: nil)
sendInvitation(to: member4.displayName) 

// 様、せひお越しください!!!

enum UserType {
    case normal
    case gold
    case silver
    case bronze
}

struct User {
    let registeredDate: Date
    let needDiscount: Bool
    let userType: UserType
}

enum User {
    case normal(registeredDate: Date, needDiscount: Bool)
    case gold(registeredDate: Date, needDiscount: Bool)
    case silver(registeredDate: Date, needDiscount: Bool)
    case bronze(registeredDate: Date, needDiscount: Bool)
}

func showMessage(for fileExtension: String) {
    switch fileExtension {
    case "jpg":
        print("This is jpg")
    case "png":
        print("This is png")
    case "gif":
        print("This is gif")
    case "bmp":
        print("This is bmp")
    default:
        print("Invalid!!!")
    }
}

showMessage(for: "jpg") // This is jpg

This is jpg

Invalid！！！

enum ImageExtension: String {
    case jpg
    case png
    case gif
    case bmp

    init?(rawValue: String) {
        switch rawValue.lowercased() {
        case "jpg", "jpeg":
            self = .jpg
        case "png":
            self = .png
        case "gif":
            self = .gif
        case "bmp":
            self = .bmp
        default:
            return nil
        }
    }
}

func showMessage(for imageExtension: ImageExtension) {
    switch imageExtension {
    case .jpg:
        print("This is jpg")
    case .png:
        print("This is png")
    case .gif:
        print("This is gif")
    case .bmp:
        print("This is bmp")
    }
}

guard let imageExtension = ImageExtension else {
    // エラー処理
}

showMessage(for: imageExtension) // This is jpg

Bool?

let returned: [String: Any] = [
    "autoLogin": false, "UserId": 1, "canUseSpecial": true]

let canUseSpecial = returned["canUseSpecial"] as? Bool
print(canUseSpecial) // Optional(true)

let canUseSpecial = returned["canUseSpecial"] ?? false
print(canUseSpecial) // false

let canUseSpecial = returned["canUseSpecial"] ?? false

...

if canUserSpecial {
   goToSettingPage()
}

enum UseSpecial: RawRepresentable {
    case enabled
    case disabled
    case notSet

    init(rawValue: Bool?) {
        switch rawValue {
        case true?:
            self = .enabled
        case false?:
            self = .disabled
        default:
            self = .notSet
        }
    }

    var rawValue: Bool? {
        switch self {
        case .enabled:
            return true
        case .disabled:
            return false
        case .notSet:
            return nil
        }
    }    
}


let returned: [String: Any] = ["autoLogin": false, "UserId": 1]
let canUseSpecial = returned["canUseSpecial"] as? Bool
let state = UseSpecial(rawValue: canUseSpecial)
print(state) // notSet

protocol ParkPlayable: Hashable { func play() }

struct Baseball: ParkPlayable {
    func play() { print("Enjoy Baseball!") }
}

struct Football: ParkPlayable {
    func play() { print("Enjoy Football!") }
}

// error: using 'Playable' as a concrete type conforming to protocol 'Hashable' is not supported
var numbers: [Playable: Int] = [:]

struct AnyParkPlayable: ParkPlayable {
    private let _play: () -> Void
    private let _hashable: AnyHashable

    init<S: ParkPlayable>(_ sport: S) {
        self._play = sport.play
        self._hashable = AnyHashable(sport)
    }

    func play() {
        self._play()
    }
}

extension AnyParkPlayable: Hashable {
    func hash(into hasher: inout Hasher) {
        _hashable.hash(into: &hasher)
    }
    static func ==(lhs: AnyParkPlayable, rhs: AnyParkPlayable) -> Bool {
        return lhs._hashable == rhs._hashable
    }
}

// OK
var numbers: [AnyParkPlayable: Int] = [
    AnyParkPlayable(Baseball()): 100,
    AnyParkPlayable(Football()): 200
]

struct Baseball: Hashable {
    func play() { print("Enjoy Baseball!") }
}

struct Football: Hashable {
    func play() { print("Enjoy Football!") }
}

enum ParkPlay: Hashable {
    case baseball(Baseball)
    case football(Football)

    func play() {
        switch self {
        case .baseball(let baseball):
            baseball.play()
        case .football(let football):
            football.play()
        }
    }
}

var numbers: [ParkPlay: Int] = [
    .baseball(Baseball()): 100,
    .football(Football()): 200,
]

print(numbers.values)

protocol Validatable {
    associatedtype Value
    func validate(_ value: Value) -> Bool
}

struct MinLength: Validatable {
    let minLength: Int
    func validate(_ value: String) -> Bool {
        return value.count >= minLength
    }
}

let min3Length = MinLength(minLength: 3)
min3Length.validate("aaa") // true
min3Length.validate("aa") // false

struct Validator<Value> {
    let validate: (Value) -> Bool
}

let min3Length = Validator<String> { string in
    return string.count >= 3
}

min3Length.validate("aaa") // true
min3Length.validate("aa") // false

extension Validator {
    func combine(_ other: Validator) -> Validator<Value> {
        return Validator { value in
            return self.validate(value) && other.validate(value)
        }
    }
}

let min5Length = Validator<String> { string in
    return string.count >= 5
}
let notEmpty = Validator<String> { string in
    return !string.isEmpty
}

let nonEmptyAndMin5 = notEmpty.combine(min5Length)

nonEmptyAndMin5.validate("") // true
nonEmptyAndMin5.validate("aaaaaa") // false

struct Validator<Value> {
    let closure: (Value) throws -> Void
}

struct ValidationError: LocalizedError {
    let message: String
    var errorDescription: String? { return message }
}

func validate(
    _ condition: @autoclosure () -> Bool,
    errorMessage messageExpression: @autoclosure () -> String
    ) throws {
    guard condition() else {
        let message = messageExpression()
        throw ValidationError(message: message)
    }
}

let userNameValidator = Validator<String> { value in
    if value.count < 5 {
        throw ValidationError(message: "５文字以上で入力してください")
    }
}

do {
    try userNameValidator.closure("me")
} catch {
    print(error.localizedDescription) // ５文字以上で入力してください

func validate<T>(_ value: T,
                 using validator: Validator<T>) throws {
    try validator.closure(value)
}

extension Validator where Value == String {
    static var userNumber: Validator {
        return Validator { string in
            try validate(
                !string.isEmpty,
                errorMessage: "文字を入力してください"
            )
            try validate(
                Int(string) != nil,
                errorMessage: "数字のみ入力してください"
            )
        }
    }
}

func showMessageIfValid(with input: String) throws {
    try validate(input, using: .userNumber)
    print("validation ok")
}

do {
    try showMessageIfValid(with: "") // 文字を入力してください
} catch {
    print(error.localizedDescription)
}

do {
    try showMessageIfValid(with: "aaaaaaa") // 数字のみ入力してください
} catch {
    print(error.localizedDescription)
}

func throwError() throws {
    defer { print("後始末します")}
    throw UnbelievableError.unbelievable
}
throwError() // 後始末します

func throwError() throws {
    throw UnbelievableError.unbelievable
    defer { print("後始末します")}
}
throwError() 何も出ない

enum SurprisingError: Error, LocalizedError {
    case fired
    case inTheWater

    var errorDescription: String? {
        switch self {
        case .fired:
            return "バッテリーから火が出た"
        case .inTheWater:
            return "水没！！！"
        }
    }
}

func throwSurprisingError() throws {
    throw SurprisingError.fired
}

do {
    try throwSurprisingError()
} catch {
    print(error.localizedDescription) // バッテリーから火が出た
}

struct Lens<Root, Value> {
    let view: (Root) -> Value
    let update: (Value, Root) -> Root
}

func makeLens<Root, Value>(_ wkp: WritableKeyPath<Root, Value>) -> Lens<Root, Value> { |
    return Lens<Root, Value>(
        view: { root in root[keyPath: wkp] },
        update: { newValue, root in
            var m_root = root
            m_root[keyPath: wkp] = newValue
            return m_root
    })
}

func zip<Root, Value1, Value2>(_ lens1: Lens<Root, Value1>, _ lens2: Lens<Root, Value2>) -> Lens<Root, (Value1, Value2)> {
    return Lens<Root, (Value1, Value2)>(
        view: { root in
            (lens1.view(root), lens2.view(root))
    },
        update: { tuple, root in
            lens2.update(tuple.1, lens1.update(tuple.0, root))
    })
}

extension Lens {
    func modify (_ transformValue: @escaping (Value) -> Value) -> (Root) -> Root { |
        return { root in
            self.update(
                transformValue(self.view(root)),
                root)
        }
    }
}

struct UserInput {
    var name: FullName

    static func lens<Value>(_ wkp: WritableKeyPath<UserInput, Value>) -> Lens<UserInput, Value> {
        return makeLens(wkp)
    }
}

struct FullName {
    var first: String
    var family: String

    static func lens<Value>(_ wkp: WritableKeyPath<FullName, Value>) -> Lens<FullName, Value> {
        return makeLens(wkp)
    }    
}

let nameLens = zip(
    UserInput.lens(\.name.first),
    UserInput.lens(\.name.family)
)

let trimmedName =
    nameLens.modify {
        (
            $0.0.trimmingCharacters(in: CharacterSet(charactersIn: " ")),
            $0.1.trimmingCharacters(in: CharacterSet(charactersIn: " "))
        )
    }


let input = UserInput(name: FullName(first: "   first   ", family: "    family"))
let trimmedInput = trimmedName(input)

print(trimmedInput.name) // FullName(first: "first", family: "family")