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])")
    }

sidepelican

import RxSwift
import RxCocoa
import UIKit

extension SharedSequence {
    func assertStartWithEvent(file: StaticString = #file, line: UInt = #line) -> Self {
        let deadline = Observable<Element>.create { observer -> Disposable in
            fatalError("Event didn't come immediately after subscribe.", file: file, line: line)
        }
        .delaySubscription(.nanoseconds(0), scheduler: SharingStrategy.scheduler)

sidepelican

import Foundation

protocol _View {
    static var specialType: Any.Type { get }
}

protocol View: _View {
    associatedtype Body: View
    associatedtype Special
    var body: Body { get }