IanKeen

let source = PassthroughSubject<Int, Error>()
let other = PassthroughSubject<String, Error>()

let subscription = source.withLatestFrom(other).assertNoFailure().sink(receiveValue: { value in
    print(value)
})

source.send(1)
other.send("hello")
source.send(2)

IanKeen

@propertyWrapper
struct AppStorage<Value>: DynamicProperty {
    let key: String
    let defaultValue: Value

    init(wrappedValue defaultValue: Value, _ key: String) {
        self.key = key
        self.defaultValue = defaultValue
        self._wrappedValue = State(wrappedValue: UserDefaults.standard.object(forKey: key) as? Value ?? defaultValue)
    }

IanKeen

public struct DictionaryKeyPathError: Error, CustomStringConvertible {
    public enum FragmentError: Error {
        case valueMissing
        case valueMismatch(expected: Any.Type, received: Any.Type, value: Any)
    }

    public let path: [Any]
    public let error: FragmentError

    public var description: String {

IanKeen

/// A collection that returns the current element as well as the previous and next elements when available
public struct NeighborSequence<Base: Sequence>: Sequence {
    public typealias Element = (previous: Base.Element?, current: Base.Element, next: Base.Element?)
    
    private let base: Base
    
    fileprivate init(_ base: Base) {
        self.base = base
    }
    

IanKeen

extension Result where Failure == Error {
    public enum ResultError: Error {
        case invalidState
    }

    /// Convenience initalizer for creating a `Result` from an
    /// Objective-C based optional set of parameters.
    ///
    /// For example a common pattern in Objective-C is for the callback block
    /// to be structured using all optional parameters, such as: `(Data?, Error?) -> Void`

IanKeen

extension Array where Element: CodingKey {
    var keyPath: String {
        return map { $0.intValue == nil ? $0.stringValue : "[\($0.intValue!)]" }
            .joined(separator: ".")
            .replacingOccurrences(of: ".[", with: "[")
    }
}

IanKeen

struct User: Equatable {
    var firstName: String
    var lastName: String
}

@main
struct MyApp: App {
    @State var value = User(firstName: "", lastName: "")
    @State var showEdit = false

IanKeen

@main
struct MyApp: App {
    enum Sheet { case first, second }
  
    @State var sheet: Sheet? = nil
  
    var body: some Scene {
        WindowGroup {
            VStack {
                Button("First") { sheet = .first }

IanKeen

import Combine

@propertyWrapper
public struct Input<T> {
    public struct SendProxy {
        private let send: (T) -> Void

        fileprivate init(_ send: @escaping (T) -> Void) {
            self.send = send
        }

IanKeen

extension Publisher {
    func asResult() -> AnyPublisher<Result<Output, Failure>, Never> {
        return map(Result.success)
            .catch { Just(Result.failure($0)) }
            .eraseToAnyPublisher()
    }
}

extension Publisher {
    func values<S, F: Error>() -> AnyPublisher<S, Never> where Output == Result<S, F>, Failure == Never {