darrarski

import UIKit

struct SketchShadow {
    let color: UIColor?
    let x: CGFloat
    let y: CGFloat
    let blur: CGFloat
    let spread: CGFloat
}

darrarski

import UIKit

struct ScrollPageController {

    func pageOffset(for offset: CGFloat, velocity: CGFloat, in pageOffsets: [CGFloat]) -> CGFloat? {
        let pages = pageOffsets.enumerated().reduce([Int: CGFloat]()) {
            var dict = $0
            dict[$1.0] = $1.1
            return dict
        }

darrarski

import RxCocoa

extension Driver {
    func unwrap<T>() -> Driver<T> where E == T? {
        // swiftlint:disable:next force_unwrapping
        return filter { $0 != nil }.map { $0! }.asDriver(onErrorDriveWith: .empty())
    }
}

darrarski

opt_in_rules:
  - file_name
  - empty_count
  - sorted_imports
  - force_unwrapping
  - operator_usage_whitespace
  - number_separator
  - switch_case_on_newline
  - implicit_return
  - overridden_super_call

darrarski

# OS X
*.DS_Store
*.swp
.Trashes

# Xcode
*.pbxuser
!default.pbxuser
*.mode1v3
!default.mode1v3

darrarski

Keybase proof

I hereby claim:

• I am darrarski on github.
• I am darrarski (https://keybase.io/darrarski) on keybase.
• I have a public key whose fingerprint is DBDD 81D8 99ED 9772 2D28 86D0 F759 CCF6 8E12 6988

To claim this, I am signing this object:

darrarski

import Combine

public final class CustomPublisher<Output, Failure>: Publisher where Failure: Error {

    public init(subscribe subscribeClosure: @escaping (AnySubscriber<Output, Failure>) -> Subscription) {
        self.subscribeClosure = subscribeClosure
    }

    public func receive<S>(subscriber: S) where S: Combine.Subscriber, S.Input == Output, S.Failure == Failure {
        let subscription = subscribeClosure(AnySubscriber(subscriber))

darrarski

import Combine

extension Publisher {

    func materialize() -> Result<[Output], Failure> {
        var values = [Output]()
        var result: Result<[Output], Failure>!
        let semaphore = DispatchSemaphore(value: 0)
        let subscription = sink(receiveCompletion: { completion in
            switch completion {

darrarski

extension ObservableType {
    func retry(_ maxAttemptCount: Int = 1, when: @escaping (Error) -> Observable<Void>) -> Observable<E> {
        return retryWhen { errorObservable -> Observable<Void> in
            var retries = maxAttemptCount
            return errorObservable.flatMap { error -> Observable<Void> in
                guard retries > 0 else { return Observable.error(error) }
                retries -= 1
                return when(error)
            }
        }

darrarski

import Foundation

public protocol JSONEncodable: Encodable {
  static var keyEncodingStrategy: JSONEncoder.KeyEncodingStrategy { get }
  static var dateEncodingStrategy: JSONEncoder.DateEncodingStrategy { get }
  static var dataEncodingStrategy: JSONEncoder.DataEncodingStrategy { get }
  static var nonConformingFloatEncodingStrategy: JSONEncoder.NonConformingFloatEncodingStrategy { get }

  func toJSON() throws -> Data
}