Всем привет! 

На связи iOS Broadcast и сегодня хочется пойти немного перпендикулярно общим тенденциям и рассмотреть не самые новые фишки языка, а то что уже есть, но редко используется.

3 моих любимых Proposal:

• SE-0195 Dynamic Member Lookup

• SE-0216 Dynamic callable

• SE-0253 CallAsFunction

Когда они только начали обсуждаться, было не понятно, нужны ли они. Но раз за разом после их выхода появлялись рабочие задачи, в которых без них никуда.

Если вам интересно следить за самыми последними новостями iOS разработки и получать подборку интересных статей по этой тематике, тогда вам стоит подписаться на Телеграм-канал iOS Broadcast

Начнем с со старичков@dynamicCallable и @dynamicMemberLookup . Исходя из мотивационной секции proposal, они были добавлены для интеропа с динамическими языками, такими как Python, JavaScript. Но их использование этим не ограничивается.

Dynamic member lookup

@dynamicMemberLookup c нами еще со swift 4.2 и позволяет динамически генерировать свойства у структур или классов, обращаясь к ним на самом деле через subscript.

Например:

struct Channel {
    let title: String
}

@dynamicMemberLookup
struct Author {
    let name: String
    let channel: Channel

    subscript<T>(dynamicMember keyPath: KeyPath<Channel, T>) -> T {
        return channel[keyPath: keyPath]
    }
}

let channel = Channel(title: "iOS Broadcast")
let author = Author(name: "Andrey Zonov", channel: channel)

print(author.title) // iOS Broadcast

В данном примере видно, что у структуры автора нет свойства title, но мы смогли к нему обратиться. Где это может быть полезно в жизни? 

Если вы используете Combine, то я надеюсь знаете, что методы sink и assign(to:on:) захватывает сильную ссылку. Чтобы оставить код читаемым и функциональным, я использую простую обертку

titleRequest = generator
    .randomTitlePublisher()
    .assign(to: \.obj.label.text, on: Unowned(obj: self))

struct Unowned<Object: AnyObject> {
    unowned var obj: Object
}

titleRequest = generator
    .randomTitlePublisher()
    .assign(to: \.label.text, onWeak: self)

extension Publisher where Failure == Never {
    
    func assign<Root: AnyObject>(
        to keyPath: ReferenceWritableKeyPath<Root, Output>,
        onWeak object: Root
    ) -> AnyCancellable {
        sink { [weak object] value in
            object?[keyPath: keyPath] = value
        }
    }
}

titleRequest = generator
    .randomTitlePublisher()
    .sink(receiveValue: weak(self, ViewController.assignTitleToLabel))

func weak<T: AnyObject, Argument>(_ obj: T, _ block: @escaping (T) -> (Argument) -> Void) -> (Argument) -> Void {
    { [weak obj] a in
        obj.map(block)?(a)
    }
}

Которая позволяет при вызове не захватывать сильной ссылкой self . Но в этом кейсе все портит obj, и от него можно избавиться как раз с помощью @dynamicMemberLookup

titleRequest = generator
    .randomTitlePublisher()
    .assign(to: \.label.text, on: Unowned(obj: self))

@dynamicMemberLookup
struct Unowned<Object: AnyObject> {
  
    unowned var obj: Object
    
    subscript<T>(dynamicMember keyPath: KeyPath<Object, T>) -> T {
        obj[keyPath: keyPath]
    }
}

И это только один из примеров снижения когнитивной нагрузки ваших API для конечных пользователей.

Dynamic callable

@dynamicCallable в Swift позволяет динамически вызывать методы, используя упрощенный синтаксис, добавляя синтаксический сахар в наши API.

Например:

@dynamicCallable
final class Conversation {
  
    private var messages = Set<String?>()
    
    @discardableResult
    func dynamicallyCall(withKeywordArguments args: KeyValuePairs<String, String>) -> Bool {
        for (key, value) in args {
            switch key {
            case "send":
                return messages.insert(value).inserted
            case "delete":
                messages.remove(key)
                return true
            case "contains":
                return messages.contains(value)
            default:
                return false
            }
        }
        return false
    }
}

let сonversation = Conversation()
сonversation(contains: "Привет!") // false
сonversation(send: "Привет!") // true
сonversation(contains: "Привет!") // true
сonversation(delete: "Привет!") // true
сonversation(test: "") // false

В отрыве это кажется не очень нужным, но, к примеру, если вы хотите сделать DSL для сборки URL можно сделать следующее:

@dynamicMemberLookup
@dynamicCallable
class Dsl<UrlsType> {
    
    private let urls: UrlsType
    private var components: [String] = []
    
    init(_ urls: UrlsType) {
        self.urls = urls
    }
    
    subscript(dynamicMember keyPath: KeyPath<UrlsType, String>) -> Dsl {
        components.append(urls[keyPath: keyPath])
        return self
    }
    
    func dynamicallyCall(withArguments args: [String]) -> Dsl {
        components.append(contentsOf: args)
        return self
    }
    
    func make(replacements: [String: String] = [:]) -> String {
        components.joined(separator: "/")
    }
}

Использовать это можно следующим образом:

struct ProfileUrls {
    
    let user = "user"
    let posts = "posts"
}

let dsl = Dsl(ProfileUrls())
let url = dsl.user.posts("123").make() // user/posts/123

Это решение может помочь не ошибиться при конструировании URL, если у вас еще не прикручена кодогенерация по контрактам OpenAPI. К тому же его легко покрыть тестами.

Сall as function

И последнее по порядку, но не по важности, это callAsFunction. Опять же, синтаксический сахар, который приравнивает вызов () к вызову callAsFunction. Например:

struct RandomGenerator {
    func callAsFunction() -> Int {
        .random(in: 0...100)
    }
}

let generator = RandomGenerator()
print(generator())// 58
print(generator())// 46

Универсальный DSL

Эти подходы можно использовать для создания DSL поверх UIKit в стиле SwiftUI:

@dynamicMemberLookup
public struct DSL<T> {
  
    let obj: T

    public subscript<Value>(dynamicMember keyPath: WritableKeyPath<T, Value>) -> (Value) -> DSL<T> {
        { [obj] value in
            var object = obj
            object[keyPath: keyPath] = value
            return DSL(obj: object)
        }
    }

    public subscript<Value>(dynamicMember keyPath: WritableKeyPath<T, Value>) -> (Value) -> T {
        { [obj] value in
            var object = obj
            object[keyPath: keyPath] = value
            return object
        }
    }
}

public protocol DSLCompatible {
  
    associatedtype DSLType
    var dsl: DSL<DSLType> { get }
}

extension DSLCompatible {
  
    public var dsl: DSL<Self> {
        DSL(obj: self)
    }
}

extension NSObject: DSLCompatible {}

После чего можно обращаться ко всем свойствам любого UIKit элемента за счет ротового класса NSObject у них всех:

let label: UILabel = UILabel()
    .dsl
    .text("Привет")
    .font(.preferredFont(forTextStyle: .largeTitle))
    .textAlignment(.center)
    .textColor(.blue)

Заключение

Начиная с версии 4.2, Swift становится более интероперабельным с динамическими языками, что приносит нам множество возможностей, все они доступны нам уже давно. Что же нас ждет с приходом макросов ????! Главное применять эти фичи языка там, где это действительно требуется, а не искать, где бы их применить.

Поделитесь в комментариях, в каких задачах вы используете эти фишки языка и в какой комбинации.