Écrire un scala idiomatique

Qui suis je ?

• Benoit Lemoine
• Développeur fullstack chez Captain Dash
• @benoit_lemoine

Idiomes

Scala : Fonctionnel vs Objet

null c'est nul

Fonction renvoyant null

def maMethod(param:String): String = {
  if(param.length == 0) {
     null
  } else {
    "{" + param + "}"
  }
}						
					

def maMethod(param:String): Option[String] = {
  if(param.length == 0) {
    None
  } else {
    Some("{" + param + "}")
  }
}						
					

Client pouvant consommer null

val str:String = monService.methodePouvantRenvoyerNull()

val len = if(str != null) str.length else 0
					

val str:Option[String] = Option(monService.methodePouvantRenvoyerNull)

val len = str.map(_.length).getOrElse(0)
					

Bannir .get

val myOption:Option[String] = None

myOption.get //NoSuchElementException
myOption.getOrElse("da")
myOption.orElse( Some("test"))
					

Éviter le pattern matching inutile

myOption match {
  case Some(value) => Some(value.length)
  case None => None
}						
					

myOption.map(_.length)				
					

myOption match {
  case Some(value) => Some(value)
  case None => Some("une nouvelle valeur")
}						
					

myOption.orElse(Some("une nouvelle valeur"))				
					

Eviter les options inutiles

• Option[List[T]] ~ List[T]
  • None ~ Some(Nil)
• List[Option[T]] -> List[T]
  • maListDoption.flatten

Exemple pratique

//Very Very Bad
case class User(id:Long, name:String)
val u = User.save(User(null, "new User"))

//Good
case class User(id:Option[Long], name:String)
val u = User.save(User(None, "new User"))

//Better
case class User(id:Long, name:String)
case class TemporaryUser(name:String)

val u = User.save(TemporaryUser("new User"))						
					

//Best
case class UserId(id:Long) extends AnyVal
case class User(id:UserId, name:String)
					

Try

def strToInt(str:String): Option[Int] = try {
  Some(str.toInt)
} catch {
  case NumberFormatException => None
}

def strToInt(str:String):Option[Int] = Try(str.toInt).toOption

Try

Try(uneFonctionPouvantRenvoyerDesExceptions()) match {
  case Success(v) => "my value" + v
  case Failure(e:IllegalArgumentException) => "IllegalArgument"
  case Failure(NonFatal(e)) => e.getMessage
}	

Either

def strToInt(str:String): Either[String, Int] = Try(str.toInt) match {
  case Success(i) => Right(i)
  case Failure(e) => Left(e.getMessage)
}

val maybeN1: Either[String, Int] = strToInt("a")
val maybeN2: Either[String, Int] = strToInt("b")


val sum: Either[String, Int] = for(
  n1 <- maybeN1.right;
  n2 <- maybeN2.right
) yield (n1 + n2)

Try / Either / Option

• Try :
  • Si un traitement peut échouer avec une exception
  • Essayer de ne pas le renvoyer
• Either :
  • Right est la valeur valide, Left l'erreur
  • Si un traitement peut échouer avec un message ou un objet d'erreur
  • Try[T] ~ Either[Throwable, T]
• Option :
  • Si un traitement peut renvoyer une valeur ou non
  • Ne pas utiliser si avec un NullObject

Les Futures

Ne pas bloquer !

def monActionDeController(id:Long) = Action {
  val maybeEventualUser:Future[Option[User]] = User.byId(id)
  val maybeUser = Await.result(maybeEventualUser, 5 seconds)
  maybeUser match {
    case Some(user) => Ok(user)
    case None => NotFound(s"user $id not found")
  }
}

def monActionDeController(id:Long) = Action.async {
  val maybeEventualUser:Future[Option[User]] = User.byId(id)
  maybeEventualUser.map { 
      case Some(user) => Ok(user)
      case None => NotFound(s"user $id not found")
  }
}

Tests - ScalaTest

//trait Eventually - quand on a pas la main sur la Future
val xs = 1 to 125
val it = xs.iterator
eventually { it.next should be (3) }

//trait ScalaFutures - quand on reçoit la Future
whenReady(result) { s =>
  s should be ("hello")
}	

Immutabilité

var sum = 0
var count = 0
val words = List("une","liste","de","mots")

for(w <- words) {
  sum += w.length
  count += 1
}

val mean = sum / count

val sum = words.map(_.length).sum
val count = words.length
val mean = sum / count

For comprehension

val maybeId:Option[Long] = Some(1)
val maybeUser:Option[User] = maybeId.flatMap(User.byId)
val maybeClassified:Option[Classified] = maybeUser
  .filter(_.isCustomer)
  .flatMap(Classified.byUser)

val maybeClassified:Option[Classified] = for(
  id <- maybeId;
  user <- User.byId(id);
  classified <- Classified.byUser(user) if user.isCustomer
) yield classified	

Pas de return

def contains(el:Long, l:List[Long]): Boolean = {
  l.foreach { listElement =>
    if(listElement == el)
      return true
  }
  return false
}

// Pour la démo, fold
def contains(el:Long, l:List[Long]): Boolean = l.foldLeft(false) { 
  (result, listElement) => result || (listElement == el)	
}

// Pour la démo, récursion 
def contains(el:Long, l:List[Long]): Boolean = l match {
  case Nil => false
  case listElement :: t = (listElement == el) || contains(el, t)
}

// Dans le vrai monde
def contains(el:Long, l:List[Long]): Boolean = l.contains(el) 

Tuple

val tuple = (2, 4, 5)

val somme = tuple._1 + tuple._2 + tuple._3

val tuple = (2, 4, 5)

val somme = tuple match {
  case (a, b, c) => a + b + c
}

Case class

class Parent {
  case class Animal(name:String)

  def isDonald(a:Animal):Boolean = Animal("donald") == a
}

val aDonald =  p.Animal("donald")
p.isDonald(aDonald) // true

val anotherDonald = new Parent().Animal("donald")
p.isDonald(anotherDonald) // ne compile pas	

Algebraic Data Type - enum

sealed trait Planet
object Planet {	
  case object Mercury extends Planet
  case object Venus extends Planet
  case object Jupiter extends Planet
  case object Saturne extends Planet
}

import Planet._
def isGiant(p:Planet):Boolean = p match {
  case (Mercury | Venus) => false
  case (Jupiter | Saturne) => true
}

Algebraic Data Type

sealed trait Permission
object Permission {
  case object AccessDenied extends Permission
  case class AccessPermited(id:Long) extends Permission
}

import Permission._
def hasAccess(p:Permission, searchedId:Long): Boolean = p match {
  case AccessDenied => false
  case AccessPermited(id) => id == searchedId 
}

//Attention à 
def hasAccess(p:Permission, searchedId:Long): Boolean = p match {
  case AccessDenied => false
  case a:AccessPermited => a.id == searchedId 
}

Pattern matching

val myBool:Boolean = true
val r:String = myBool match {
  case true => "Vrai"
  case false => "Faux"
}

val r:String = if(myBool) "Vrai" else "Faux"

Injection de dépendance

trait MyService {
  def myMethod():String = "call to my method"
}
object MyService extends MyService

trait MyController {
  this: Controller => 

  def myService:MyService

  def myAction = Action { Ok(myService.myMethod())}
}

object MyController extends Controller with MyController {
  lazy val myService = MyService
}

Injection de dépendance

//Dans les tests
class ControllerUnderTest(val myService:MyService) 
    extends Controller with MyController

val controller = new ControllerUnderTest(mockService)

Pour aller plus loin... Scalaz

• Either right-biased : \/
• Either avec accumulation des Left : Validation
• Option sans .get : Maybe
• List ne pouvant être vide : NonEmptyList
• etc.

Conclusion

Les signatures doivent expliquer ce que fait votre fonction

• Un traitement asynchrone : Future[_].
• Un traitement pouvant comporter une erreur : Try[_], Either[_,_]
• Un traitement pouvant ou non renvoyer un résultat : Option[_]

Conclusion

• Il faut connaitre les API de collection au dela de foreach, map et filter
• Si c'est illisible ; c'est probablement faux

Questions ?