renamed Eq alias

added some tests

Author: Oleg Nizhnik

Diff for: build.sbt

@@ -1,15 +1,18 @@
 name := "fpspeedrun"
 
-version := "0.1"
+version := "mainrun-3"
 
 scalaVersion := "2.12.6"
 
-scalacOptions += "-Ypartial-unification"
-
 libraryDependencies += "org.typelevel" %% "cats-core" % "1.1.0"
 libraryDependencies += "org.typelevel" %% "cats-effect" % "1.0.0-RC2"
 libraryDependencies += "com.github.mpilquist" %% "simulacrum" % "0.12.0"
 
+libraryDependencies += "org.scalatest" %% "scalatest" % "3.0.5" % "test"
+libraryDependencies += "org.scalacheck" %% "scalacheck" % "1.14.0" % "test"
+
 addCompilerPlugin("org.spire-math" %% "kind-projector" % "0.9.7")
-addCompilerPlugin("org.scalamacros" % "paradise" % "2.1.0" cross CrossVersion.full)
+addCompilerPlugin("org.scalamacros" % "paradise" % "2.1.0" cross CrossVersion.patch)
+
+
 

Diff for: compiler.sbt

@@ -0,0 +1,50 @@
+//source https://tpolecat.github.io/2017/04/25/scalac-flags.html
+
+scalacOptions ++= Seq(
+  "-deprecation",                      // Emit warning and location for usages of deprecated APIs.
+  "-encoding", "utf-8",                // Specify character encoding used by source files.
+  "-explaintypes",                     // Explain type errors in more detail.
+  "-feature",                          // Emit warning and location for usages of features that should be imported explicitly.
+  "-language:existentials",            // Existential types (besides wildcard types) can be written and inferred
+  "-language:experimental.macros",     // Allow macro definition (besides implementation and application)
+  "-language:higherKinds",             // Allow higher-kinded types
+  "-language:implicitConversions",     // Allow definition of implicit functions called views
+  "-unchecked",                        // Enable additional warnings where generated code depends on assumptions.
+  "-Xcheckinit",                       // Wrap field accessors to throw an exception on uninitialized access.
+// too brute for students
+//  "-Xfatal-warnings",                  // Fail the compilation if there are any warnings.
+  "-Xfuture",                          // Turn on future language features.
+  "-Xlint:adapted-args",               // Warn if an argument list is modified to match the receiver.
+  "-Xlint:by-name-right-associative",  // By-name parameter of right associative operator.
+  "-Xlint:constant",                   // Evaluation of a constant arithmetic expression results in an error.
+  "-Xlint:delayedinit-select",         // Selecting member of DelayedInit.
+  "-Xlint:doc-detached",               // A Scaladoc comment appears to be detached from its element.
+  "-Xlint:inaccessible",               // Warn about inaccessible types in method signatures.
+  "-Xlint:infer-any",                  // Warn when a type argument is inferred to be `Any`.
+  "-Xlint:missing-interpolator",       // A string literal appears to be missing an interpolator id.
+  "-Xlint:nullary-override",           // Warn when non-nullary `def f()' overrides nullary `def f'.
+  "-Xlint:nullary-unit",               // Warn when nullary methods return Unit.
+  "-Xlint:option-implicit",            // Option.apply used implicit view.
+  "-Xlint:package-object-classes",     // Class or object defined in package object.
+  "-Xlint:poly-implicit-overload",     // Parameterized overloaded implicit methods are not visible as view bounds.
+  "-Xlint:private-shadow",             // A private field (or class parameter) shadows a superclass field.
+  "-Xlint:stars-align",                // Pattern sequence wildcard must align with sequence component.
+  "-Xlint:type-parameter-shadow",      // A local type parameter shadows a type already in scope.
+  "-Xlint:unsound-match",              // Pattern match may not be typesafe.
+  "-Yno-adapted-args",                 // Do not adapt an argument list (either by inserting () or creating a tuple) to match the receiver.
+  "-Ypartial-unification",             // Enable partial unification in type constructor inference
+  "-Ywarn-dead-code",                  // Warn when dead code is identified.
+  "-Ywarn-extra-implicit",             // Warn when more than one implicit parameter section is defined.
+  "-Ywarn-inaccessible",               // Warn about inaccessible types in method signatures.
+  "-Ywarn-infer-any",                  // Warn when a type argument is inferred to be `Any`.
+  "-Ywarn-nullary-override",           // Warn when non-nullary `def f()' overrides nullary `def f'.
+  "-Ywarn-nullary-unit",               // Warn when nullary methods return Unit.
+  "-Ywarn-numeric-widen",              // Warn when numerics are widened.
+  "-Ywarn-unused:implicits",           // Warn if an implicit parameter is unused.
+  "-Ywarn-unused:imports",             // Warn if an import selector is not referenced.
+  "-Ywarn-unused:locals",              // Warn if a local definition is unused.
+  "-Ywarn-unused:params",              // Warn if a value parameter is unused.
+  "-Ywarn-unused:patvars",             // Warn if a variable bound in a pattern is unused.
+  "-Ywarn-unused:privates",            // Warn if a private member is unused.
+  "-Ywarn-value-discard",              // Warn when non-Unit expression results are unused.
+)

Diff for: src/main/scala/fpspeedrun/Eq.scala

@@ -8,7 +8,7 @@ trait Eq[T] {
   @op("===", alias = true)
   def equal(x: T, y: T): Boolean
 
-  @op("!==")
+  @op("=/=")
   def notEqual(x: T, y: T): Boolean = ! equal(x, y)
 }
 

Diff for: src/main/scala/fpspeedrun/Iso.scala

@@ -11,8 +11,12 @@ object Iso {
     def value: T
   }
 
-  trait WrapperIso[T, F[x] <: Wrapper[x]] extends Iso[T, F[T]] {
-    override def unwrap(b: F[T]): T = b.value
+  trait WrapperCompanion[F[x] <: Wrapper[x]]{
+    def apply[T](x: T): F[T]
+    implicit def wrapperIso[T]: Iso[T, F[T]] = new Iso[T, F[T]]{
+      override def wrap(a: T): F[T] = apply(a)
+      override def unwrap(b: F[T]): T = b.value
+    }
   }
 }
 

Diff for: src/main/scala/fpspeedrun/Semigroup.scala

@@ -1,9 +1,8 @@
 package fpspeedrun
-import fpspeedrun.Iso.{Wrapper, WrapperIso}
+import fpspeedrun.Iso.{Wrapper, WrapperCompanion}
 import simulacrum.{op, typeclass}
 import syntax.num._
 
-
 @typeclass
 trait Semigroup[T] {
   @op("|+|", alias = true)
@@ -12,33 +11,28 @@ trait Semigroup[T] {
 
 object Semigroup extends StdSemigroupInstances
 
-
 final case class Sum[T](value: T) extends AnyVal with Wrapper[T]
 
-object Sum{
+object Sum extends WrapperCompanion[Sum] {
   implicit def sumSemigroup[T: Num]: Semigroup[Sum[T]] = (x, y) => Sum(x.value + y.value)
-  implicit def iso[A]: WrapperIso[A, Sum] = Sum(_)
 }
 
 final case class Prod[T](value: T) extends AnyVal with Wrapper[T]
 
-object Prod {
+object Prod extends WrapperCompanion[Prod] {
   implicit def prodSemigroup[T: Num]: Semigroup[Prod[T]] = (x, y) => Prod(x.value * y.value)
-  implicit def iso[A]: WrapperIso[A, Prod] = Prod(_)
 }
 
 final case class First[T](value: T) extends AnyVal with Wrapper[T]
 
-object First {
+object First extends WrapperCompanion[First] {
   implicit def firstSemigroup[T]: Semigroup[First[T]] = (x, _) => x
-  implicit def iso[A]: WrapperIso[A, First] = First(_)
 }
 
 final case class Last[T](value: T) extends AnyVal with Wrapper[T]
 
-object Last {
+object Last extends WrapperCompanion[Last] {
   implicit def lastSemigroup[T]: Semigroup[Last[T]] = (_, y) => y
-  implicit def iso[A]: WrapperIso[A, Last] = Last(_)
 }
 
 trait StdSemigroupInstances extends StdMonoidInstances[Semigroup]

Diff for: src/main/scala/fpspeedrun/syntax/package.scala

@@ -1,7 +1,6 @@
 package fpspeedrun.syntax
 import fpspeedrun._
 
-
 object eq extends Eq.ToEqOps
 
 object ord extends Ord.ToOrdOps
@@ -21,6 +20,7 @@ object frac extends Frac.ToFracOps
 object ratio {
   implicit class RatioOps[T](val x: T) extends AnyVal {
     def \\(y: T)(implicit int: Integ[T]): Ratio[T] = Ratio.make(x, y)
+    def toRatio(implicit int: Integ[T]): Ratio[T] = Ratio.make(x, int.one)
   }
 }
 

Diff for: src/test/scala/fpspeedrun/RatioGenerators.scala

@@ -0,0 +1,12 @@
+package fpspeedrun
+import org.scalacheck.Arbitrary
+import Arbitrary.arbitrary
+import syntax.ratio._
+
+trait RatioGenerators {
+  implicit def arbitraryRatio[T: Arbitrary : Integ]: Arbitrary[Ratio[T]] =
+    Arbitrary(for {
+      numerator <- arbitrary[T]
+      denominator <- arbitrary[T]
+    } yield numerator \\ denominator)
+}

Diff for: src/test/scala/fpspeedrun/SemigroupSuite.scala

@@ -0,0 +1,104 @@
+package fpspeedrun
+
+import org.scalatest.{Matchers, WordSpec}
+import org.scalatest.prop.PropertyChecks
+import syntax.semigroup._
+import syntax.ratio._
+import syntax.num._
+
+class SemigroupSuite extends WordSpec with Matchers with PropertyChecks {
+  "list optional reducing" when {
+    "reducing strings" should {
+      "reduce empty list" in {
+        List.empty[String].reduceOpt shouldBe None
+      }
+      "reduce non empty list" in {
+        forAll((x : String, xs: List[String]) =>
+          (x :: xs).reduceOpt shouldBe Some((x :: xs).mkString))
+      }
+    }
+
+    "reducing ints" when {
+      "adding" should {
+        "reduce empty list" in {
+          List.empty[Int].reduceOptVia[Sum] shouldBe None
+        }
+        "reduce non-empty list" in {
+          forAll((x: Int, xs: List[Int]) =>
+            (x :: xs).reduceOptVia[Sum] shouldBe Some(x + xs.sum))
+        }
+      }
+
+      "multiplying" should {
+        "reduce empty list" in {
+          List.empty[Int].reduceOptVia[Prod] shouldBe None
+        }
+        "reduce non-empty list" in {
+          forAll((x: Int, xs: List[Int]) =>
+            (x :: xs).reduceOptVia[Prod] shouldBe Some(x * xs.product))
+        }
+      }
+
+      "searching leftmost" should {
+        "reduce empty list" in {
+          List.empty[Int].reduceOptVia[First] shouldBe None
+        }
+        "reduce non-empty list" in {
+          forAll((x: Int, xs: List[Int]) =>
+            (x :: xs).reduceOptVia[First] shouldBe Some(x))
+        }
+      }
+
+      "searching rightmost" should {
+        "reduce empty list" in {
+          List.empty[Int].reduceOptVia[Last] shouldBe None
+        }
+        "reduce non-empty list" in {
+          forAll((x: Int, xs: List[Int]) =>
+            (x :: xs).reduceOptVia[Last] shouldBe Some((x :: xs).last))
+        }
+      }
+    }
+
+    "reducing ratios" when {
+      "fractions are integers" should {
+        "sum numerators" in {
+          forAll((xs: List[Int]) =>
+            xs.map(_.toRatio).reduceOptVia[Sum] shouldBe xs.reduceOption(_ + _).map(_.toRatio)
+          )
+        }
+
+        "multiply numerators" in {
+          forAll((xs: List[Int]) =>
+            xs.map(_.toRatio).reduceOptVia[Prod] shouldBe xs.reduceOption(_ * _).map(_.toRatio)
+          )
+        }
+      }
+      "facing arbitrary fractions" should {
+        "sum fractions" in {
+          forAll((xs: List[Ratio[BigInt]]) =>
+            xs.reduceOptVia[Sum] shouldBe xs.reduceOption(_ + _)
+          )
+        }
+
+        "multiply fractions" in {
+          forAll((xs: List[Ratio[BigInt]]) =>
+            xs.reduceOptVia[Prod] shouldBe xs.reduceOption(_ * _)
+          )
+        }
+
+        "find leftmost fraction" in {
+          forAll((xs: List[Ratio[BigInt]]) =>
+            xs.reduceOptVia[First] shouldBe xs.headOption
+          )
+        }
+
+        "find rightmost fraction" in {
+          forAll((xs: List[Ratio[BigInt]]) =>
+            xs.reduceOptVia[Last] shouldBe xs.lastOption
+          )
+        }
+      }
+    }
+  }
+}

Diff for: src/test/scala/fpspeedrun/package.scala

@@ -0,0 +1 @@
+package object fpspeedrun extends RatioGenerators