eamelink

Recursion and Trampolines in Scala

Recursion is beautiful. As an example, let's consider this perfectly acceptable example of defining the functions even and odd in Scala, whose semantics you can guess:

def even(i: Int): Boolean = i match {
  case 0 => true
  case _ => odd(i - 1)
}

def odd(i: Int): Boolean = i match {

eamelink

import scala.concurrent.Future

object either {

// Scala standard library Either is sometimes used to distinguish between 'failure' and 'success' state. Like these two methods:
def getUser(id: String): Either[String, User] = ???
def getPreferences(user: User): Either[String, Preferences] = ???

// The Right side contains the success value by convention, because right is right, right?

eamelink

import play.api.libs.iteratee._
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent._
import scala.concurrent.duration._
import play.api.libs.concurrent.Promise

object iteratees {

  // Implicit conversion to add 'await' to a Future
  implicit class WFuture[A](val inner: Future[A]) extends AnyVal {

eamelink

import scala.concurrent._
import scala.concurrent.duration._
import scala.concurrent.ExecutionContext.Implicits.global

// Experiment with and without the `blocking` call in this program!
object Test extends App {

  val x = Future.traverse(1 to 30){ i =>
    Future {
      println("Starting #" + i)

eamelink

// Can we implement `dependentTasks` in a functional way?
// Is it a terrible idea to implement this? Why?
def dependentTasks: (String => Task[String], String => Task[String]) = ???

val (f1, f2) = dependentTasks
val t1 = f1("foo")
val t2 = f2("bar")

assert(t1.unsafeRun == "foo-bar")
assert(t2.unsafeRun == "bar-foo")

eamelink

import cats.data.Coproduct
import cats.free.Inject

object CoproductInject {
  trait A[T]
  trait B[T]
  trait C[T]

  type Two[T] = Coproduct[A, B, T]

eamelink

trait ElasticSearchComponent {
  val esClient: EsClient
}

trait ElasticSearchIndex { self: ElasticSearchComponent =>

  def findAll() = esClient.doAQueryForAll()
  
}

eamelink

package controllers

import play.api.libs.concurrent.Execution.Implicits.defaultContext
import play.api.libs.iteratee.{ Concurrent, Iteratee }
import play.api.libs.ws.{ ResponseHeaders, WS }
import play.api.mvc.{ Action, Controller, SimpleResult }
import scala.concurrent.Promise

object Application extends Controller {

eamelink

import scalaz._
import scalaz.Scalaz._

object Test extends App{
  trait Zero[A] {
    def zero: A
  }
  
  implicit class RichDisjunction[A, B](value: A \/ B) {
    def withFilter(p: B => Boolean)(implicit za: Zero[A]): A \/ B = value match {

eamelink

/*
* bar is not a real field: after the lazy val bork is initialized,
* 'bar' is set to null.
*
* It's a normal field when we make bork a def, add 'val' or 'var' to bar or make it a case class.
* It's not a field at all when we make bork a val.
*/

class MyClass(param: String) {
    lazy val field = param