Functional programming for functional scared

Example.swift

extension Style where T: UILabel {
    public func font(_ weight: UIFont.Weight, size: CGFloat) -> Style<T> {
        return with { label in
            label.font = UIFont.systemFont(ofSize: size, weight: weight)
        }
    }

    public func color(_ color: UIColor) -> Style<T> {
        return with { label in
            label.textColor = color
        }
    }

    public func textAlignment(_ alignment: NSTextAlignment) -> Style<T> {
        return with { label in
            label.textAlignment = alignment
        }
    }

    public func numberOfLines(_ numberOfLines: Int) -> Style<T> {
        return with { label in
            label.numberOfLines = numberOfLines
        }
    }

    public func lineBreakMode(_ lineBreakMode: NSLineBreakMode) -> Style<T> {
        return with { label in
            label.lineBreakMode = lineBreakMode
        }
    }
}

Style.swift

public struct Style<T> {
    private let style: (T) -> Void

    private init(style: @escaping (T) -> Void) {
        self.style = style
    }

    @discardableResult
    public func apply(on subjects: T...) -> Style {
        subjects.forEach { style($0) }
        return self
    }

    public static func `for`(_: T.Type) -> Style {
        return .init { _ in }
    }

    private func with(_ other: @escaping (T) -> Void) -> Style<T> {
        return .init { subject in
            self.apply(on: subject)
            other(subject)
        }
    }
}

Usage example:

ler myLabelStyle = Style.for(UILabel.self).color(.red).numberOfLines(0)
let label1: UILabel = .init()
let label2: UILabel = .init()
myLabelStyle.apply(on: label1, label2)