fteychene

import org.jetbrains.kotlin.gradle.tasks.KotlinCompile

plugins {
    kotlin("jvm") version "1.3.21"
    kotlin("kapt") version "1.3.21"
}

repositories {
    mavenCentral()
}

hoc081098

import UIKit
import PlaygroundSupport

protocol Weakifiable: AnyObject { }

extension NSObject: Weakifiable { }

extension Weakifiable {
  func weakify(_ block: @escaping (Self) -> Void) -> () -> Void {
    { [weak self] in self.map(block) }

hoc081098

@file:Suppress("RedundantSuspendModifier")

import arrow.core.Either
import arrow.core.computations.either
import arrow.fx.coroutines.parTraverseEitherN
import kotlinx.coroutines.delay
import java.io.IOException
import kotlin.time.ExperimentalTime
import kotlin.time.TimeSource

pakoito

Advanced Functional Programming with Scala - Notes

Copyright © 2017 Fantasyland Institute of Learning. All rights reserved.

1. Mastering Functions

A function is a mapping from one set, called a domain, to another set, called the codomain. A function associates every element in the domain with exactly one element in the codomain. In Scala, both domain and codomain are types.

val square : Int => Int = x => x * x

alexbezhan

Scala with Futures:

import java.util.UUID
import scala.concurrent.Future

trait User {
    def isAdmin: Boolean
    def id: UUID

kaeawc

codecov:
  branch: master
  bot: null

coverage:
  precision: 2
  round: down
  range: "70...100"

  status:

manuelvicnt

// IMPORTANT! READ THIS FIRST
// Assisted Injection doesn't work with @HiltViewModel or @ViewModelInject
// Read more about the issue here: https://github.com/google/dagger/issues/2287
//
//
// AssistedInject and Hilt working together in v2.28-alpha times
// Example of a ViewModel using AssistedInject injected in a Fragment by Hilt
// As AssistedInject isn't part of Dagger yet, we cannot use in
// conjuction with @ViewModelInject

mminer

import Foundation

func format(bytes: Double) -> String {
    guard bytes > 0 else {
        return "0 bytes"
    }

    // Adapted from http://stackoverflow.com/a/18650828
    let suffixes = ["bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"]
    let k: Double = 1000

kakajika

protocol ScopeFunc {}
extension ScopeFunc {
    @inline(__always) func apply(block: (Self) -> ()) -> Self {
        block(self)
        return self
    }
    @inline(__always) func letIt<R>(block: (Self) -> R) -> R {
        return block(self)
    }
}

jegnux

extension Result {
    public func `catch`(_ handler: () throws -> Success) -> Result<Success, Error> {
        flatMapError { _ in
            .init { try handler() }
        }
    }

    public func `catch`(_ handler: (Failure) throws -> Success) -> Result<Success, Error> {
        flatMapError { error in
            .init { try handler(error) }