yakushevichsv

receiveItems { //apparantly the method's declaration is that: receiveItems(completion: ()-> Void)
    //do some processing in completion block
    let items = ...
    DispatchQueue.main.async { [weak self] in 
        // update ui 
        guard let self = self else { return }
        self.items = items
    }
}

yakushevichsv

import UIKit

// MARK: - MainThreadRunnerType
protocol MainThreadRunnerType {
    func runOnMain(_ block: @escaping  () -> Void) // if not on main thread then run block asynchronously
    func runOnMainWeakly<Object: AnyObject, T>(_ obj: Object,
                                               parameter: T,
                                               method: @escaping ((Object) -> (T) -> Void))
    func runOnMainWeakly<Object: AnyObject>(_ obj: Object,
                                            method: @escaping ((Object) -> () -> Void))

yakushevichsv

extension MainThreadRunnerType {
    static func weakify<Object: AnyObject, Input>(_ obj: Object,
                                                  method: @escaping ((Object) -> (Input) -> Void)) -> ((Input) -> Void) {
        return { [weak obj] value in
            guard let obj = obj else { return }
            method(obj)(value)
        }
    }
    
    static func weakify<Object: AnyObject>(_ obj: Object,

yakushevichsv

class Test1: MainThreadRunnerType {
    func displayMessage(_ text: String) {
        debugPrint(text)
    }
    
    func displayMessage(optText: String?) {
        guard let text = optText else { return }
        displayMessage(text)
    }
    

yakushevichsv

import UIView
extension UILabel {
    func markAsMultiline() {
        numberOfLines = 0
        lineBreakMode = .byWordWrapping
    }
}

yakushevichsv

final class Test {
    private let queue: DispatchQueue
    private let queueKey : DispatchSpecificKey<Int>
    private let queueKeyValue: Int
    
    init() {
        let queueKey = DispatchSpecificKey<Int>()
        let queueKeyValue = Int(arc4random())
        
        self.queueKey = queueKey

yakushevichsv

// MARK: - UnfairLock
final class UnfairLock {
    private let unfairLock: os_unfair_lock_t //UnsafeMutablePointer<os_unfair_lock>
    private let unfairValue: os_unfair_lock_s
    
    init() {
        unfairLock = .allocate(capacity: 1)
        unfairValue = .init()
        unfairLock.initialize(to: unfairValue)
    }

yakushevichsv

// MARK: - Atomic
@propertyWrapper struct Atomic<T> {
    private let lock = UnfairLock()
    
    private var value: T
    
    var wrappedValue: T {
        get {
            lock.lock()
            defer {

yakushevichsv

import Foundation

extension Optional {
    var hasValue: Bool {
        if case .some = self {
            return true
        }
        return false
    }
    

yakushevichsv

extension String {
    static let empty = "" // swift 5.5 allows static let constructs in extension
    
  #if DEBUG
    func check() {
        assert(Self.empty == "")
    }
  #endif
}