sidepelican

import SwiftUI

func longlongAsyncFunction() async {
    let id = UUID()
    print("\(id): start")
    do {
        try await withTaskCancellationHandler {
            try await Task.sleep(nanoseconds: 1000 * 1000 * 1000 * 10)
            print("\(id): end")
        } onCancel: {

sidepelican

#if !canImport(ObjectiveC)
import Foundation
import XCTest

// INFO:
//typealias XCTestCaseClosure = (XCTestCase) throws -> Void
//typealias XCTestCaseEntry = (testCaseClass: XCTestCase.Type, allTests: [(String, XCTestCaseClosure)])
func testCase<T: XCTestCase>(_ allTests: [(String, (T) -> () async throws -> Void)]) -> XCTestCaseEntry {
    let tests: [(String, XCTestCaseClosure)] = allTests.map { ($0.0, asyncTest($0.1)) }
    return (T.self, tests)

sidepelican

import Combine

@_functionBuilder
struct FlatMapBuilder {
    static func buildBlock<C: Publisher>(_ component: C) -> C
    {
        component
    }

    static func buildEither<F: Publisher, S: Publisher>(first component: F) -> EitherPublisher<F, S>

sidepelican

sidepelican

import Foundation

public struct Airport: Codable {
    let name: String
    let iata: String
    let icao: String
    let coordinates: [Double]

    public struct Runway: Codable {
        enum Surface: String, Codable {

sidepelican

import DiffableDataSources
import UIKit

class CollectionViewConcatDataSource<SectionIdentifierType: Hashable>: NSObject, UICollectionViewDataSource {
    typealias ItemIdentifierType = AnyHashable
    public typealias SupplementaryViewProvider = (UICollectionView, String, IndexPath) -> UICollectionReusableView?

    private var innerDataSource: CollectionViewDiffableDataSource<SectionIdentifierType, AnyHashable>!
    private var adapterMap: [SectionIdentifierType: DiffableDataSourceSectionAdapterType] = [:]
    var defaultSupplementaryViewProvider: SupplementaryViewProvider? = nil

sidepelican

class A {
    class var className: String { "A" }
    init() {}
    func setup() {
        name = {
            return Self.className
        }
    }
    var name: (() -> String)?
}

sidepelican

extension ObservableType where Element == Void {
    func pagenation<
        Token,
        Source: ObservableConvertibleType,
        PagingElement
        >(
        startWith token: Token,
        selector: @escaping (Token) throws -> Source
    ) -> Observable<(usedToken: Token, PagingElement)>
        where

sidepelican

import Darwin.POSIX.iconv

class Iconv {
    enum Error: Swift.Error {
        case illegalByteSequence
        case invalidArgument
        case invalidResult
        case unknownError(errno: Int32)
    }

sidepelican

use std::marker::PhantomData;

struct T<A> {
    _phantom: PhantomData<A>,
}

impl<U> T<&[U]> {
    fn f(_: &[U]) {
        println!("f(_: &[U])")
    }