IanKeen

import Foundation

extension Decodable {
    public static func empty() throws -> Self {
        return try Self(from: EmptyDecoder())
    }
}

private class EmptyDecoder: Decoder {
    let codingPath: [CodingKey] = []

IanKeen

@propertyWrapper
struct Derived<Value> {
    var wrappedValue: Value {
        get { fatalError() }
        set { fatalError() }
    }

    private let getter: (Any) -> Value
    private let setter: (Any, Value) -> Void

IanKeen

@propertyWrapper
struct Redraw<Value> {
    var wrappedValue: Value

    init(wrappedValue: Value) {
        self.wrappedValue = wrappedValue
    }

    static subscript<Instance: UIView>(
        _enclosingInstance instance: Instance,

IanKeen

import XCTest

@_functionBuilder
struct Test<T> {
    var data: T
    var given: given<T>
    var when: when<T>
    var then: then<T>

    func execute() {

IanKeen

public protocol KeyPathComponent { }

extension String: KeyPathComponent { }
extension Int: KeyPathComponent { }

public protocol KeyPathAccessible {
    func value<T>(at component: KeyPathComponent) -> T?
}

extension KeyPathAccessible {

IanKeen

import SwiftUI

extension Array {
    func chunk(size: Int) -> [[Element]] {
        return stride(from: 0, to: count, by: size).map {
            return Array(self[$0..<Swift.min($0 + size, count)])
        }
    }
}

IanKeen

import UIKit

open class TextView: UITextView {
    // MARK: - Public Properties
    public var autoSizing: Bool = false {
        didSet { redraw() }
    }
    public var minimumLines: Int = 1 {
        didSet { redraw() }
    }

IanKeen

public typealias LosslessStringCodable = LosslessStringConvertible & Codable

public struct Value<T: LosslessStringCodable>: Codable {
    private let type: LosslessStringCodable.Type
    
    public var value: T
    
    public init(from decoder: Decoder) throws {
        do {
            self.value = try T.init(from: decoder)

IanKeen

public struct DecodingRoutine<T: Decodable> {
    let decode: (Decoder) throws -> T?
}

extension DecodingRoutine {
    public static func `default`(_ value: T) -> DecodingRoutine {
        return .init { _ in value }
    }
}

IanKeen

import Foundation

class DictionaryDecoder {
    init() { }
    
    func decode<T: Decodable>(_ type: T.Type, from data: [String: Any]) throws -> T {
        let decoder = _Decoder(codingPath: [], source: data)
        return try T(from: decoder)
    }
}