wotjd

import Foundation
import Moya

struct AsyncRequestError: Error { 
    // TODO: add Description
}

extension MoyaProvider {
    // method #1 - using AsyncThrowingStream
    func request(_ target: Target) async throws -> Response {

wotjd

protocol AProtocol {
  func callAsFunction()
}

class AClass: AProtocol {
  func callAsFunction() { print("hi there") }
}

let a: any AProtocol = AClass()
a() // prints "hi there"

wotjd

import SwiftUI

struct SampleView: View {
  @State presentsSheet = false
  
  var body: some View {
    Button { presentsSheet.toggle() } label: { Text("Toggle Sheet") }
      .uiKitSheet(
        isPresented: $presentsSheet,
        onDismiss: { print("dismissed!") },

wotjd

import Combine

extension Publisher {
  func makeHot() -> AnyPublisher<Output, Failure> {
    let subject = PassthroughSubject<Void, Never>()
    let publisher = map(Result.success)
      .catch { Just(.failure($0)) }
      .prefix(untilOutputFrom: subject)
      .makeConnectable()
    let connection = publisher.connect()

wotjd

import UIKit

extension UICollectionViewCompositionalLayout {
  static func waterfall(
    columnCount: Int,
    interItemSpacing: CGFloat = 0,
    lineSpacing: CGFloat = 0,
    itemCountProvider: @escaping (Int) -> Int,
    itemSizeProvider: @escaping (IndexPath) -> CGSize,
    sectionConfigurator: @escaping (inout NSCollectionLayoutSection) -> Void = { _ in },

wotjd

import Foundation
import Combine

// shareWhileConnected using Combine Proof of Concept
extension Publisher {
  func shareWhileConnected() -> Publishers.ShareWhileConnected<Self, PassthroughSubject<Output, Failure>> {
    .init(upstream: self)
  }
}

wotjd

import AuthenticationServices
import Combine
import CombineCocoa

extension ASAuthorizationController {
  private var delegateProxy: AuthorizationControllerDelegateProxy {
    .createDelegateProxy(for: self)
  }
  
  var didCompleteWithAuthroizationPublisher: AnyPublisher<ASAuthorization, Never> {

wotjd

import Foundation

extension AsyncStream {
  init(
    _ elementType: Element.Type = Element.self,
    bufferingPolicy limit: AsyncStream<Element>.Continuation.BufferingPolicy = .unbounded,
    _ build: @escaping (AsyncStream<Element>.Continuation) async -> Void
  ) {
    self = AsyncStream(elementType, bufferingPolicy: limit) { continuation in
      Task { await build(continuation) }

wotjd

import SwiftUI

// MARK: DeepLink
final class DeepLink {
  private let url: URL
  
  private lazy var pathComponents = self.paths
  
  private var paths: [String] {
    [self.url.host].compact() + self.url.pathComponents.dropFirst()

wotjd

// poor arrow function expression implementation like javascript's using infix operator and closure

precedencegroup ArrowFunctionExpressionPrecedence {
  associativity: left
  higherThan: BitwiseShiftPrecedence
}

infix operator =>: ArrowFunctionExpressionPrecedence
infix operator ==>: ArrowFunctionExpressionPrecedence