Builder design pattern exploration

Builder.swift

import UIKit

struct PackingList {
    let heavyCoat: Int
    let rainJacket: Int
    let pullover: Int
    let activewearCoat: Int
    let thermalUnderwear: Int
    let leggins: Int
    let darkJean: Int
    let sweater: Int
    let waterproofSnowBoots: Int
    let socks: Int
    let mittens: Int
    let beanie: Int
    let sunglass: Int
    let hat: Int
    let bathingSuit: Int
    let sunscreen: Int
    let handSanitizer: Int
}

extension PackingList {
    class Builder {
        enum Weather {
            case summer
            case winter
        }

        private var heavyCoat: Int = 0
        private var rainJacket: Int = 0
        private var pullover: Int = 0
        private var activewearCoat: Int = 0
        private var thermalUnderwear: Int = 0
        private var leggins: Int = 0
        private var darkJean: Int = 0
        private var sweater: Int = 0
        private var waterproofSnowBoots: Int = 0
        private var socks: Int = 0
        private var mittens: Int = 0
        private var beanie: Int = 0
        private var sunglass: Int = 0
        private var hat: Int = 0
        private var bathingSuit: Int = 0
        private var sunscreen: Int = 0
        private var handSanitizer: Int = 0

        func set(heavyCoat: Int) -> Builder {
            self.heavyCoat = heavyCoat
            return self
        }

        func set(rainJacket: Int) -> Builder {
            self.rainJacket = rainJacket
            return self
        }

        func set(pullover: Int) -> Builder {
            self.pullover = pullover
            return self
        }

        func set(activewearCoat: Int) -> Builder {
            self.activewearCoat = activewearCoat
            return self
        }

        func set(thermalUnderwear: Int) -> Builder {
            self.thermalUnderwear = thermalUnderwear
            return self
        }

        func set(leggins: Int) -> Builder {
            self.leggins = leggins
            return self
        }

        func set(darkJean: Int) -> Builder {
            self.darkJean = darkJean
            return self
        }

        func set(sweater: Int) -> Builder {
            self.sweater = sweater
            return self
        }

        func set(waterproofSnowBoots: Int) -> Builder {
            self.waterproofSnowBoots = waterproofSnowBoots
            return self
        }

        func set(socks: Int) -> Builder {
            self.socks = socks
            return self
        }

        func set(mittens: Int) -> Builder {
            self.mittens = mittens
            return self
        }

        func set(beanie: Int) -> Builder {
            self.beanie = beanie
            return self
        }

        func set(sunglass: Int) -> Builder {
            self.sunglass = sunglass
            return self
        }

        func set(sunscreen: Int) -> Builder {
            self.sunscreen = sunscreen
            return self
        }

        func set(hat: Int) -> Builder {
            self.hat = hat
            return self
        }

        func set(bathingSuit: Int) -> Builder {
            self.bathingSuit = bathingSuit
            return self
        }

        func set(handSanitizer: Int) -> Builder {
            self.handSanitizer = handSanitizer
            return self
        }


        private func packForSummer() {
            self.set(heavyCoat: 0)
                .set(rainJacket: 1)
                .set(pullover: 0)
                .set(activewearCoat: 1)
                .set(thermalUnderwear: 0)
                .set(leggins: 0)
                .set(darkJean: 1)
                .set(sweater: 0)
                .set(waterproofSnowBoots: 0)
                .set(socks: 3)
                .set(mittens: 0)
                .set(beanie: 0)
                .set(sunglass: 1)
                .set(hat: 1)
                .set(bathingSuit: 1)
                .set(sunscreen: 1)
                .set(handSanitizer: 1)
        }

        private func packForWinter() {
            self.set(heavyCoat: 1)
                .set(rainJacket: 1)
                .set(pullover: 2)
                .set(activewearCoat: 1)
                .set(thermalUnderwear: 3)
                .set(leggins: 1)
                .set(darkJean: 1)
                .set(sweater: 2)
                .set(waterproofSnowBoots: 1)
                .set(socks: 3)
                .set(mittens: 1)
                .set(beanie: 2)
                .set(sunglass: 1)
                .set(hat: 0)
                .set(bathingSuit: 0)
                .set(sunscreen: 1)
                .set(handSanitizer: 1)
        }

        func pack(for weather: Weather = .summer) {
            switch weather {
            case .summer:
                self.packForSummer()
            case .winter:
                self.packForWinter()
            }
        }

        func build() -> PackingList {
            let packingList = PackingList(heavyCoat: self.heavyCoat,
                                          rainJacket: self.rainJacket,
                                          pullover: self.pullover,
                                          activewearCoat: self.activewearCoat,
                                          thermalUnderwear: self.thermalUnderwear,
                                          leggins: self.leggins,
                                          darkJean: self.darkJean,
                                          sweater: self.sweater,
                                          waterproofSnowBoots: self.waterproofSnowBoots,
                                          socks: self.socks,
                                          mittens: self.mittens,
                                          beanie: self.beanie,
                                          sunglass: self.sunglass,
                                          hat: self.hat,
                                          bathingSuit: self.bathingSuit,
                                          sunscreen: self.sunscreen,
                                          handSanitizer: self.handSanitizer)
            return packingList
        }
    }
}

let summerBuilder = PackingList.Builder()
summerBuilder.pack(for: .summer)
let summerPackingList = summerBuilder.build()
assert(summerPackingList.bathingSuit == 1)

let customSummerBuilder = PackingList.Builder()
customSummerBuilder.pack(for: .summer)
customSummerBuilder.set(bathingSuit: 2)
let customSummerPackingList = customSummerBuilder.build()
assert(customSummerPackingList.bathingSuit == 2)

let winterBuilder = PackingList.Builder()
winterBuilder.pack(for: .winter)
let winterPackingList = winterBuilder.build()
assert(winterPackingList.bathingSuit == 0)