nrinaudo

------------------------------ MODULE imageaug ------------------------------
EXTENDS Integers, FiniteSets, TLC

CONSTANTS Documents,
          Models,
          MaxRetries,
          NULL
          
ASSUME MaxRetries \in Nat \ {0}
ASSUME Cardinality(Documents) /= 0

nrinaudo

import monocle.macros._
import org.scalacheck._
import scalaz.scalacheck.ScalaCheckBinding._

// Deep hierarchy of product types.
case class Document(author: Author)
case class Author(firstName: String, lastName: String, city: City)
case class City(name: String, country: Country)
case class Country(name: String, continent: Continent)
case class Continent(name: String)

nrinaudo

title	Start independent Futures outside of a for-comprehension
layout	article

When working with independent [Futures][Future], make sure not to initialise them inside a for-comprehension.

Reason

For-comprehension will create a dependency between your [Futures][Future], turning your code synchronous behind your back.

nrinaudo

object Test extends App {
  val benchIterations  = 10
  val warmupIterations = 10
  val repeat           = 100000

  val a = "foo"
  val b = 123

  def benchOne[U](a : => U): Long =
    (0 to repeat).foldLeft(0L) { case (total, _) =>

nrinaudo

import cats._
import cats.instances.all._
import cats.syntax.all._

final case class Configuration()
final case class Database()
final case class HttpServer()

object Test extends App {

nrinaudo

import io.circe._
import io.circe.generic.semiauto._
import org.scalacheck._, derive._

sealed trait Or[+A, +B] extends Product with Serializable
final case class Left[A](a: A) extends Or[A, Nothing]
final case class Right[B](b: B) extends Or[Nothing, B]

object Or {

nrinaudo

object a1 {
  implicit val foo: Int = 1
} 

object a2 {
  implicit val foo: String = "foo"
} 

{
  import a1._, a2._

nrinaudo

case class Foo(a: Int)
class Bar(a: Int, b: Int) extends Foo(a)

// Returns false
new Bar(1, 2) == new Bar(2, 2)

// Returns true!!
new Bar(1, 2) == new Bar(1, 3)

nrinaudo

import org.scalatest.FunSuite
import org.scalatest.prop.GeneratorDrivenPropertyChecks
import java.text.SimpleDateFormat
import java.util.{Date, Locale}
import org.scalacheck._

class Repr extends FunSuite with GeneratorDrivenPropertyChecks {
  implicit val cogenDate: Cogen[Date] = Cogen(_.getTime)
  implicit val formatter = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSz", Locale.ENGLISH)

nrinaudo

markdown: kramdown
highlighter: rouge

collections:
  tut:
    output: true