kakajika

fun <T> lazyFast(operation: () -> T): Lazy<T> = lazy(LazyThreadSafetyMode.NONE) {
    operation()
}

kakajika

class ListDataSource<T>(private val items: List<T>) : PositionalDataSource<T>() {
    override fun loadInitial(params: LoadInitialParams, callback: LoadInitialCallback<T>) {
        callback.onResult(items, 0, items.size)
    }
    override fun loadRange(params: LoadRangeParams, callback: LoadRangeCallback<T>) {
        val start = params.startPosition
        val end = params.startPosition + params.loadSize
        callback.onResult(items.subList(start, end))
    }
}

kakajika

class DeployGateTree : Timber.Tree() {

    override fun log(priority: Int, taf: String?, message: String, t: Throwable?) {
        when (priority) {
            Log.VERBOSE -> DeployGate.logVerbose(message)
            Log.INFO    -> DeployGate.logInfo(message)
            Log.DEBUG   -> DeployGate.logDebug(message)
            Log.WARN    -> DeployGate.logWarn(message)
            Log.ERROR   -> DeployGate.logError(message)
        }

kakajika

import Foundation

extension Array {

    func windowed(size: Int, step: Int = 1, partialWindows: Bool = false) -> [[Element]] {
        let count = self.count
        var index = 0
        var result: [[Element]] = []
        while (index < count) {
            let windowSize = Swift.min(size, count - index)

kakajika

extension ObservableType {
    
    func isEmpty() -> Single<Bool> {
        return self
            .take(1)
            .map { _ in false }
            .ifEmpty(switchTo: Observable.just(true))
            .asSingle()
    }
    

kakajika

extension Sequence {
    
    func associate<K, V>(_ transform: (Element) -> (K, V)) -> [K: V] {
        return self.reduce(into: [:]) { (dict, element) in
            let (key, value) = transform(element)
            dict[key] = value
        }
    }
    
    func associateBy<K>(_ keySelector: (Element) -> K) -> [K: Element] {

kakajika

extension Sequence {
    
    func sumBy(selector: (Element) -> Int) -> Int {
        return self.reduce(into: 0) { (sum, element) in
            sum += selector(element)
        }
    }
    
}

kakajika

extension Sequence {
    
    func zipWith<S2: Sequence>(_ seq2: S2) -> Zip2Sequence<Self, S2> {
        return zip(self, seq2)
    }
    
}

kakajika

extension Unicode.Scalar {
    var width: UInt32 {
        let code = self.value
        if (code >= 0 && code <= 128) {
            return 1
        } else {
            return 2
        }
    }
}

kakajika

import * as React from "react"
import * as Rx from "rxjs"

export class Action<T> {
    constructor(public key: string) {}
}

interface FluxContext {
    dispatch: <T extends any>(action: Action<T>, value: T) => void
}