ch07 apples and oranges

Chapter07.scala

package fp_tdd

import cats.Apply
import cats.syntax.apply._
import org.scalacheck.Prop.forAll
import org.scalacheck.{Gen, Prop, Properties}

object Chapter07 extends Properties("Ch07") {
  // ======== TODO ========
  // $5 + 10 CHF = $10 if rate is 2:1
  // Money rounding?
  // hashCode
  // Equal null
  // Equal object
  // Dollar/Farnc duplication
  // Common times
  // Currency
  // ======== DONE ========
  // 1. $5 * 2 = $10
  // 2. Dollar side effect
  // 2. times -> `*`
  // 3. Equality
  // 5. 5CHF * 2 = 10CHF
  // 6. Common equals
  // 7. Compare Francs to Dollars

// product code -------------------------------------------------------------------
  trait Money {
    protected val amount: Int
    override def equals(a: Any): Boolean =
      a.asInstanceOf[Money].amount == amount && this.getClass == a.getClass
  }
  class Dollar(protected val amount: Int) extends Money {
    def *(multiplier: Int): Dollar = Dollar(amount * multiplier)
  }
  object Dollar { def apply(amount: Int) = new Dollar(amount) }
  class Franc(protected val amount: Int) extends Money {
    def *(multiplier: Int): Franc = Franc(amount * multiplier)
  }
  object Franc { def apply(amount: Int) = new Franc(amount) }

// test code --------------------------------------------------------------------
  val intGen:  Gen[Int]             = Gen.chooseNum(-1000000, 1000000)
  implicit val dollars: Gen[Dollar] = intGen.map(Dollar.apply)
  implicit val consGen: Gen[Int => Money] = Gen.oneOf(Dollar(_:Int): Money, Franc(_:Int): Money)

  def double[G[_]: Apply, A](ga: G[A]): G[(A, A)]    = (ga, ga).mapN((_, _))
  def triple[G[_]: Apply, A](ga: G[A]): G[(A, A, A)] = (ga, ga, ga).mapN((_, _, _))
  implicit val genApply: Apply[Gen] = new Apply[Gen] {
    override def ap[A, B](gf: Gen[A => B])(ga: Gen[A]): Gen[B] = gf flatMap ga.map
    override def map[A, B](ga: Gen[A])(f: A => B): Gen[B]      = ga map f
  }
  implicit val unique3: Gen[(Dollar, Dollar, Dollar)] =
    triple(dollars).suchThat { case (a, b, c) => a != b && b != c && c != a }

// properties -------------------------------------------------------------------
  property("$0 * x = $0") = forAll { (x: Int) =>
    Dollar(0) * x == Dollar(0)
  }
  property("$1 * x = $x") = forAll { (x: Int) =>
    Dollar(1) * x == Dollar(x)
  }
  property("$a * b = $b * a") = forAll { (a: Int, b: Int) =>
    Dollar(a) * b == Dollar(b) * a
  }
  property("($a * b) * c = $a * (b * c)") = forAll { (a: Int, b: Int, c: Int) =>
    (Dollar(a) * b) * c == Dollar(a) * (b * c)
  }

  property("$a == $b <=> a == b") = forAll { (a: Int, b: Int) =>
    (Dollar(a) == Dollar(b)) == (a == b)
  }
  property("$a == $b <=> $a.equals($b)") = forAll(double(dollars)) { case (a, b) =>
    (a equals b) == (a == b)
  }
  property("equals is reflexive") = forAll(dollars) { (a) =>
    a equals a
  }
  property("equals is symmetric") = forAll(double(dollars)) { case (a, b) =>
    (a equals b) == (b equals a)
  }
  property("equals is transitive") = forAll( for {
    oneOf3 <- unique3.map { case (a, b, c)=> Gen.oneOf(a, b, c) }
    x      <- oneOf3
    y      <- oneOf3.suchThat(_ equals x)
    z      <- oneOf3.retryUntil(_ equals y)
  } yield (x, z)) { case ((x, z)) => x equals z }

  property("5 CHF * 2 = 10 CHF") = Prop {
    Franc(5) * 2 == Franc(10)
  }

  property("(m1 == m2) == (m1.getClass == m2.getClass)") = forAll(double(consGen), intGen) { case ((c1, c2), n) =>
    val m1 = c1(n)
    val m2 = c2(n)
    (m1 == m2) == (m1.getClass == m2.getClass)
  }
}