From 7034619e38ab7584feaae443c92dbd10553d7137 Mon Sep 17 00:00:00 2001 From: Alexander Date: Thu, 14 Jun 2018 21:57:05 +0700 Subject: [PATCH 1/5] ratio eq, eq for sequence --- build.sbt | 12 +++++++++++- project/plugins.sbt | 1 + src/main/scala/fpspeedrun/Eq.scala | 6 ++++++ src/main/scala/fpspeedrun/Ord.scala | 6 +++--- src/main/scala/fpspeedrun/Ratio.scala | 10 +++++++++- src/main/scala/fpspeedrun/syntax.scala | 4 ++-- src/main/scala/main/Day1.scala | 16 ++++++++++++++++ 7 files changed, 48 insertions(+), 7 deletions(-) create mode 100644 project/plugins.sbt create mode 100644 src/main/scala/main/Day1.scala diff --git a/build.sbt b/build.sbt index 0346fab..7a2318a 100644 --- a/build.sbt +++ b/build.sbt @@ -1,3 +1,5 @@ +import scalariform.formatter.preferences._ + name := "fpspeedrun" version := "0.1" @@ -9,4 +11,12 @@ scalacOptions += "-Ypartial-unification" libraryDependencies += "org.typelevel" %% "cats-core" % "1.1.0" libraryDependencies += "org.typelevel" %% "cats-effect" % "1.0.0-RC2" -addCompilerPlugin("org.spire-math" %% "kind-projector" % "0.9.7") \ No newline at end of file +addCompilerPlugin("org.spire-math" %% "kind-projector" % "0.9.7") + +scalariformPreferences := scalariformPreferences.value + .setPreference(DanglingCloseParenthesis, Force) + .setPreference(AlignArguments, true) + .setPreference(AlignParameters, true) + .setPreference(AlignSingleLineCaseStatements, true) + .setPreference(DanglingCloseParenthesis, Force) + .setPreference(FirstParameterOnNewline, Force) diff --git a/project/plugins.sbt b/project/plugins.sbt new file mode 100644 index 0000000..3a8b7aa --- /dev/null +++ b/project/plugins.sbt @@ -0,0 +1 @@ +addSbtPlugin("org.scalariform" % "sbt-scalariform" % "1.8.2") diff --git a/src/main/scala/fpspeedrun/Eq.scala b/src/main/scala/fpspeedrun/Eq.scala index 7343eaa..b323316 100644 --- a/src/main/scala/fpspeedrun/Eq.scala +++ b/src/main/scala/fpspeedrun/Eq.scala @@ -3,3 +3,9 @@ package fpspeedrun trait Eq[T] { def ===(x: T, y: T): Boolean } + +object Eq { + implicit def eqSeq[T: Eq]: Eq[Seq[T]] = (x: Seq[T], y: Seq[T]) => { + x.size == y.size && x.zip(y).forall { case (a, b) => implicitly[Eq[T]].===(a, b) } + } +} diff --git a/src/main/scala/fpspeedrun/Ord.scala b/src/main/scala/fpspeedrun/Ord.scala index 231eec3..efe4b92 100644 --- a/src/main/scala/fpspeedrun/Ord.scala +++ b/src/main/scala/fpspeedrun/Ord.scala @@ -1,13 +1,13 @@ package fpspeedrun import fpspeedrun.Ord.Compare -trait Ord[T] extends Eq[T]{ +trait Ord[T] extends Eq[T] { def compare(x: T, y: T): Compare } -object Ord{ +object Ord { sealed trait Compare - object Compare{ + object Compare { case object LT //less than case object EQ //equals to case object GT //greater than diff --git a/src/main/scala/fpspeedrun/Ratio.scala b/src/main/scala/fpspeedrun/Ratio.scala index bc3fe1b..c0f43dc 100644 --- a/src/main/scala/fpspeedrun/Ratio.scala +++ b/src/main/scala/fpspeedrun/Ratio.scala @@ -1,4 +1,12 @@ package fpspeedrun -final case class Ratio() +final case class Ratio(numerator: Int, denominator: Int) +object Ratio { + implicit val eqRatio = new Eq[Ratio] { + override def ===(x: Ratio, y: Ratio): Boolean = { + x.numerator.toLong * y.denominator.toLong == + x.denominator.toLong * y.numerator.toLong + } + } +} diff --git a/src/main/scala/fpspeedrun/syntax.scala b/src/main/scala/fpspeedrun/syntax.scala index d4f9a19..4a39212 100644 --- a/src/main/scala/fpspeedrun/syntax.scala +++ b/src/main/scala/fpspeedrun/syntax.scala @@ -1,8 +1,8 @@ package fpspeedrun object syntax { - object eq{ - implicit class EqOps[T](val x: T) extends AnyVal{ + object eq { + implicit class EqOps[T](val x: T) extends AnyVal { def ===(y: T)(implicit eq: Eq[T]): Boolean = eq.===(x, y) } } diff --git a/src/main/scala/main/Day1.scala b/src/main/scala/main/Day1.scala new file mode 100644 index 0000000..4a573f2 --- /dev/null +++ b/src/main/scala/main/Day1.scala @@ -0,0 +1,16 @@ +package main + +import fpspeedrun.Ratio +import fpspeedrun.syntax.eq._ +import fpspeedrun.Ratio._ + +object Day1 extends App { + assert(Ratio(1, 2) === Ratio(1, 2)) + assert(!(Ratio(1, 2) === Ratio(1, 3))) + assert(Seq(Ratio(1, 2), Ratio(1, 3)) === Seq(Ratio(1, 2), Ratio(1, 3))) + assert(!(Seq(Ratio(1, 2), Ratio(1, 3)) === Seq(Ratio(1, 2), Ratio(1, 4)))) +} + +object Day1Homework extends App { + +} From 0b13aa7c65f3d1f94d29142adc05a2d39eba0d57 Mon Sep 17 00:00:00 2001 From: Alexander Date: Thu, 14 Jun 2018 21:57:59 +0700 Subject: [PATCH 2/5] sbt build properties --- project/build.properties | 1 + 1 file changed, 1 insertion(+) create mode 100644 project/build.properties diff --git a/project/build.properties b/project/build.properties new file mode 100644 index 0000000..0531343 --- /dev/null +++ b/project/build.properties @@ -0,0 +1 @@ +sbt.version=1.1.2 From 402f6ecfc83a9dd67bc187130906078a4fbc490e Mon Sep 17 00:00:00 2001 From: Alexander Date: Thu, 14 Jun 2018 22:51:54 +0700 Subject: [PATCH 3/5] ord impl --- src/main/scala/fpspeedrun/Eq.scala | 6 +++++- src/main/scala/fpspeedrun/Ord.scala | 27 +++++++++++++++++++++++--- src/main/scala/fpspeedrun/Ratio.scala | 16 +++++++++++---- src/main/scala/fpspeedrun/syntax.scala | 8 +++++++- src/main/scala/main/Day1.scala | 11 +++++++++++ 5 files changed, 59 insertions(+), 9 deletions(-) diff --git a/src/main/scala/fpspeedrun/Eq.scala b/src/main/scala/fpspeedrun/Eq.scala index b323316..dbf7f04 100644 --- a/src/main/scala/fpspeedrun/Eq.scala +++ b/src/main/scala/fpspeedrun/Eq.scala @@ -6,6 +6,10 @@ trait Eq[T] { object Eq { implicit def eqSeq[T: Eq]: Eq[Seq[T]] = (x: Seq[T], y: Seq[T]) => { - x.size == y.size && x.zip(y).forall { case (a, b) => implicitly[Eq[T]].===(a, b) } + val eq = implicitly[Eq[T]] + x.size == y.size && x.zip(y).forall { + case (a, b) => + eq.===(a, b) + } } } diff --git a/src/main/scala/fpspeedrun/Ord.scala b/src/main/scala/fpspeedrun/Ord.scala index efe4b92..9e4c8ad 100644 --- a/src/main/scala/fpspeedrun/Ord.scala +++ b/src/main/scala/fpspeedrun/Ord.scala @@ -3,13 +3,34 @@ import fpspeedrun.Ord.Compare trait Ord[T] extends Eq[T] { def compare(x: T, y: T): Compare + + def ===(x: T, y: T): Boolean = { + compare(x, y) match { + case Compare.EQ => true + case _ => false + } + } } object Ord { sealed trait Compare object Compare { - case object LT //less than - case object EQ //equals to - case object GT //greater than + case object LT extends Compare //less than + case object EQ extends Compare //equals to + case object GT extends Compare //greater than + } + + implicit def ordSeq[T: Ord]: Ord[Seq[T]] = (x: Seq[T], y: Seq[T]) => { + val ord = implicitly[Ord[T]] + x.zip(y) + .find { case (a, b) => ord.compare(a, b) != Compare.EQ } + .map { case (a, b) => ord.compare(a, b) } + .getOrElse { + (x.size, y.size) match { + case (a, b) if a > b => Compare.GT + case (a, b) if a < b => Compare.LT + case (a, b) if a == b => Compare.EQ + } + } } } diff --git a/src/main/scala/fpspeedrun/Ratio.scala b/src/main/scala/fpspeedrun/Ratio.scala index c0f43dc..ea537c7 100644 --- a/src/main/scala/fpspeedrun/Ratio.scala +++ b/src/main/scala/fpspeedrun/Ratio.scala @@ -1,12 +1,20 @@ package fpspeedrun +import fpspeedrun.Ord.Compare + final case class Ratio(numerator: Int, denominator: Int) object Ratio { - implicit val eqRatio = new Eq[Ratio] { - override def ===(x: Ratio, y: Ratio): Boolean = { - x.numerator.toLong * y.denominator.toLong == - x.denominator.toLong * y.numerator.toLong + implicit val eqRatio: Eq[Ratio] = (x: Ratio, y: Ratio) => { + x.numerator.toLong * y.denominator.toLong == + x.denominator.toLong * y.numerator.toLong + } + + implicit val ordRatio: Ord[Ratio] = (x: Ratio, y: Ratio) => { + (x.numerator.toLong * y.denominator.toLong, x.denominator.toLong * y.numerator.toLong) match { + case (a, b) if a > b => Compare.GT + case (a, b) if a == b => Compare.EQ + case (a, b) if a < b => Compare.LT } } } diff --git a/src/main/scala/fpspeedrun/syntax.scala b/src/main/scala/fpspeedrun/syntax.scala index 4a39212..b2780d9 100644 --- a/src/main/scala/fpspeedrun/syntax.scala +++ b/src/main/scala/fpspeedrun/syntax.scala @@ -3,7 +3,13 @@ package fpspeedrun object syntax { object eq { implicit class EqOps[T](val x: T) extends AnyVal { - def ===(y: T)(implicit eq: Eq[T]): Boolean = eq.===(x, y) + def ===(y: T)(implicit ev: Eq[T]): Boolean = implicitly[Eq[T]].===(x, y) + } + } + + object ord { + implicit class OrdOps[T](val x: T) extends AnyVal { + def <>(y: T)(implicit ev: Ord[T]): Ord.Compare = implicitly[Ord[T]].compare(x, y) } } } diff --git a/src/main/scala/main/Day1.scala b/src/main/scala/main/Day1.scala index 4a573f2..34c7237 100644 --- a/src/main/scala/main/Day1.scala +++ b/src/main/scala/main/Day1.scala @@ -1,7 +1,9 @@ package main +import fpspeedrun.Ord.Compare import fpspeedrun.Ratio import fpspeedrun.syntax.eq._ +import fpspeedrun.syntax.ord._ import fpspeedrun.Ratio._ object Day1 extends App { @@ -12,5 +14,14 @@ object Day1 extends App { } object Day1Homework extends App { + assert((Ratio(1, 2) <> Ratio(2, 3)) == Compare.LT) + assert((Ratio(5, 4) <> Ratio(2, 3)) == Compare.GT) + assert((Ratio(5, 4) <> Ratio(5, 4)) == Compare.EQ) + assert((Seq(Ratio(1, 2), Ratio(2, 3)) <> Seq(Ratio(1, 2), Ratio(2, 4))) == Compare.GT) + assert((Seq(Ratio(1, 2), Ratio(2, 4)) <> Seq(Ratio(1, 2), Ratio(2, 3))) == Compare.LT) + + assert((Seq(Ratio(1, 2), Ratio(2, 3), Ratio(2, 3)) <> Seq(Ratio(1, 2), Ratio(2, 3))) == Compare.GT) + assert((Seq(Ratio(1, 2), Ratio(2, 3)) <> Seq(Ratio(1, 2), Ratio(2, 3), Ratio(2, 3))) == Compare.LT) + assert((Seq(Ratio(1, 2), Ratio(2, 3)) <> Seq(Ratio(1, 2), Ratio(2, 3))) == Compare.EQ) } From e10fb58bb557c21d291056a6ea3767723eba6382 Mon Sep 17 00:00:00 2001 From: Alexander Date: Thu, 14 Jun 2018 23:05:27 +0700 Subject: [PATCH 4/5] minor refactors --- src/main/scala/fpspeedrun/Eq.scala | 5 +++-- src/main/scala/fpspeedrun/Ord.scala | 6 +++--- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/src/main/scala/fpspeedrun/Eq.scala b/src/main/scala/fpspeedrun/Eq.scala index dbf7f04..bfbf9c1 100644 --- a/src/main/scala/fpspeedrun/Eq.scala +++ b/src/main/scala/fpspeedrun/Eq.scala @@ -1,15 +1,16 @@ package fpspeedrun +import fpspeedrun.syntax.eq._ + trait Eq[T] { def ===(x: T, y: T): Boolean } object Eq { implicit def eqSeq[T: Eq]: Eq[Seq[T]] = (x: Seq[T], y: Seq[T]) => { - val eq = implicitly[Eq[T]] x.size == y.size && x.zip(y).forall { case (a, b) => - eq.===(a, b) + a === b } } } diff --git a/src/main/scala/fpspeedrun/Ord.scala b/src/main/scala/fpspeedrun/Ord.scala index 9e4c8ad..6d797be 100644 --- a/src/main/scala/fpspeedrun/Ord.scala +++ b/src/main/scala/fpspeedrun/Ord.scala @@ -1,5 +1,6 @@ package fpspeedrun import fpspeedrun.Ord.Compare +import fpspeedrun.syntax.ord._ trait Ord[T] extends Eq[T] { def compare(x: T, y: T): Compare @@ -21,10 +22,9 @@ object Ord { } implicit def ordSeq[T: Ord]: Ord[Seq[T]] = (x: Seq[T], y: Seq[T]) => { - val ord = implicitly[Ord[T]] x.zip(y) - .find { case (a, b) => ord.compare(a, b) != Compare.EQ } - .map { case (a, b) => ord.compare(a, b) } + .find { case (a, b) => (a <> b) != Compare.EQ } + .map { case (a, b) => a <> b } .getOrElse { (x.size, y.size) match { case (a, b) if a > b => Compare.GT From e86b012b099f3beb85df58effe5c98398bcd35cd Mon Sep 17 00:00:00 2001 From: Alexander Date: Fri, 15 Jun 2018 10:15:32 +0700 Subject: [PATCH 5/5] minor refactors --- src/main/scala/fpspeedrun/Ord.scala | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/main/scala/fpspeedrun/Ord.scala b/src/main/scala/fpspeedrun/Ord.scala index 6d797be..e0cdeb4 100644 --- a/src/main/scala/fpspeedrun/Ord.scala +++ b/src/main/scala/fpspeedrun/Ord.scala @@ -23,8 +23,7 @@ object Ord { implicit def ordSeq[T: Ord]: Ord[Seq[T]] = (x: Seq[T], y: Seq[T]) => { x.zip(y) - .find { case (a, b) => (a <> b) != Compare.EQ } - .map { case (a, b) => a <> b } + .collectFirst { case (a, b) if (a <> b) != Compare.EQ => a <> b } .getOrElse { (x.size, y.size) match { case (a, b) if a > b => Compare.GT