View typeclassExample.scala
//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
trait Summable[T] {
def sum(a: T, b: T): T
}
View implicitClassExtendingGenericTrait.scala
//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
}
View structural_typing.ts
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;
}
View composeFutureOfNullable.kt
@Test
fun combineNullable() {
fun giveInt(x: Int):Int? = x+1
fun giveInt2(x: Int):Int? = x+2
fun combine(x: Int): Int? = giveInt(x)?.let { giveInt2(it) }
assertEquals(combine(1),4)
}
View optionalFlatten.md

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

View observe.js
var names = ['joe', 'bob'];
Object.observe(names, function(changes){
changes.forEach(function(change) {
console.log(change.type, change.name)
});
console.log("names",names);
});
View ConstructorDI.scala
class PrintService {
def print = println("I'm a real service")
}
trait Services {
val printService = new PrintService()
// put your other services here
}
//for example, a Play controller
View futureError.scala
val f: Future[Int] = Future {
if(math.random < 0.5) 1 else throw new Exception("Oh no")
} recover {
case ex:Exception => {
println(ex.getMessage)
-1
}
}
f map println
View xmlParsing.scala
//val xmlNode = xml.XML.loadFile("xxx")
val xmlNode =
<persons>
<person age="30">
<name>bob</name>
</person>
<person age="40">
<name>joe</name>
</person>
View streamFile.md

Chunck by chunk

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