loicdescotte

How to retrieve List("a", "b") from a list of optional values

A very common use case when dealing with options...

Scala

val values = List(Some("a"), None, Some("b")).flatten

Java

loicdescotte

Chunck by chunk

def  transform = Action {
    
     val fileStream: Enumerator[Array[Byte]] = {
         Enumerator.fromFile(new File("data.txt"))
     }
     
     val transfo = Enumeratee.map[Array[Byte]]{byteArray =>  

loicdescotte

interface HasScore {
  score: number;
  // also works with functions instead of properties
}

let player = { score: 0 };

function addPointsToScore(player: HasScore, points: number): void {
    player.score += points;
}

loicdescotte

//example with Generic trait

trait Summable[T] {
  def sumWith(other: T): T
}

implicit class StringSummable(s: String) extends Summable[String]{
  def sumWith(other: String): String = s + other
}

loicdescotte

import cats._
import cats.implicits._

def loadResult[F[_]](implicit F: MonadError[F, Throwable]): F[String] = {
  val resultEitherF: F[Either[Throwable, String]] =  ???
  val resultF: F[String] =  resultEitherF.flatMap(F.fromEither)
  resultF.recoverWith{
    case error => F.pure(error.getMessage)
  }
}

loicdescotte

implicit class AnyEx[T](val v: T) extends AnyVal {
  def |>[U](f: T ⇒ U): U = f(v)
}

//example 
def f(l: List[Int]) = l.filter(x => x >1)
def g(l: List[Int]) = l.filter(x => x <3)

List(1,2,3) |> f |> g //List(2)

loicdescotte

import cats.implicits._

val f = (x: Int) => x+1
val g = (x: Int) => x+2
val h = (x: Int) => x+3

// Cats has an Applicative instance for Function1 so you can traverse/sequence it
val l = List(f, g, h).sequence //l : Function1[Int, List[Int]]

l(1) //List(2, 3, 4)

loicdescotte

//typeclass example

//Note : List already has a sum method working the same way 
//List(1,2,3).sum returns 6
//but this example is simpler

// Monoid = summable + neutral element
trait Monoid[T] {
  def combine(a: T, b: T): T
  def empty: T

loicdescotte

import scala.util._

implicit class EitherLeftOps[L](eithers: Seq[Either[L,_]]){
  def collectLefts: Seq[L] = eithers.collect { 
    case Left(l) => l
  }
}

implicit class EitherRightOps[R](eithers: Seq[Either[_,R]]){
  def collectRights: Seq[R] = eithers.collect { 

loicdescotte

import arrow.core.Either
import arrow.core.Either.Companion.left
import arrow.core.Either.Companion.right
import arrow.core.Option
import arrow.core.Some
import arrow.core.flatMap
import arrow.instances.either.monad.binding
import kotlinx.coroutines.async
import kotlinx.coroutines.delay
import kotlinx.coroutines.runBlocking