swhitty

extension Deferred  {

  init<T>(operation: @escaping @Sendable () async -> T) where DeferredPublisher == AsyncDeferredPublisher<T, Never> {
    self.init { AsyncDeferredPublisher(operation: operation)  }
  }

  init<T>(operation: @escaping @Sendable () async throws -> T) where DeferredPublisher == AsyncDeferredPublisher<T, Error> {
    self.init { AsyncDeferredPublisher(operation: operation)  }
  }
}

swhitty

import Foundation

/// @Awaiting wraps optional properties and projects an async function that waits
/// when `wrappedValue` is nil, until some value is set.
///
/// Throws `CancellationError` when task is cancelled.
///
/// ```
///  @Awaiting var name: String?
///  ...

swhitty

import Combine
import RxSwift
import Foundation

extension ObservableType {
    var publisher: RxPublisher<Self> {
        RxPublisher(self)
    }
}

swhitty

import Darwin
import Foundation
import UIKit

@objc
class CGSVGDocument: NSObject { }

var CGSVGDocumentRetain: (@convention(c) (CGSVGDocument?) -> Unmanaged<CGSVGDocument>?) = load("CGSVGDocumentRetain")
var CGSVGDocumentRelease: (@convention(c) (CGSVGDocument?) -> Void) = load("CGSVGDocumentRelease")
var CGSVGDocumentCreateFromData: (@convention(c) (CFData?, CFDictionary?) -> Unmanaged<CGSVGDocument>?) = load("CGSVGDocumentCreateFromData")

swhitty

import Combine
import Foundation

func copyValues<T>(at keyPaths: [PartialKeyPath<T>], from source: T, to destination: inout T) {
    for keyPath in keyPaths.compactMap({ $0 as? any ValueCopyingKeyPath }) {
        keyPath.copyValue(from: source, to: &destination)
    }
}

extension _KeyValueCodingAndObservingPublishing where Self: NSObject {

swhitty

///  .print("🐡") Similar to the Combine variant, but for AsyncSequence.
///
/// ```
/// 🐡: makeAsyncIterator(): AsyncMapSequence<String>
/// 🐡: receive value: (1)
/// 🐡: receive value: (2)
/// 🐡: finished: AsyncMapSequence<String>
/// ```
///

swhitty

extension AsyncSequence where Element: Hashable {

    /// Sequence that emits unique elements once each
    func unique() -> AsyncUniqueSequence<Self> {
        AsyncUniqueSequence(self)
    }
}

/// Sequence that only emits unique elements once.
/// While iterating, all emitted elements are retained within a `Set` to ensure uniqueness of each element emitted.

swhitty

///  .handleEvents(onNext: { print($0) }) Similar to the Combine variant, but for AsyncSequence.
///

public extension AsyncSequence {

    /// Attach event handlers to interation events of the sequence.
    /// - Parameters:
    ///   - onInit: handler called when interator is created
    ///   - onNext: handler called when value is received
    ///   - onCompletion: handler called when sequence competes

swhitty

@_implementationOnly import os

// Backports the Swift interface around os_unfair_lock_t available in recent Darwin platforms
// https://github.com/swhitty/AllocatedLock
//
@available(iOS, deprecated: 16.0, message: "use OSAllocatedUnfairLock directly")
@available(tvOS, deprecated: 16.0, message: "use OSAllocatedUnfairLock directly")
@available(watchOS, deprecated: 9, message: "use OSAllocatedUnfairLock directly")
@available(macOS, deprecated: 13.0, message: "use OSAllocatedUnfairLock directly")
public struct AllocatedLock<State>: @unchecked Sendable {

swhitty

// ThrowingTaskGroup.waitForAll() behaviour was fixed in Swift 5.9
// This backports the Swift 5.9 behaviour to earlier versions
// https://github.com/apple/swift/pull/63016

public extension ThrowingTaskGroup {

  #if compiler(>=5.9)
  @available(*, deprecated, renamed: "waitForAll")
  #endif
  mutating func waitForAllFix() async throws {