@phill101 Homework2

src/main/scala/fpspeedrun/Eq.scala

@@ -37,5 +37,11 @@ object Eq extends StdEqInstances {
 }
 
 trait StdEqInstances extends StdOrdInstances[Eq]{
-  implicit def eitherEq[A: Eq, B: Eq]: Eq[Either[A, B]] = ???
+  import syntax.eq._
+  implicit def eitherEq[A: Eq, B: Eq]: Eq[Either[A, B]] =
+    (x: Either[A, B], y: Either[A, B]) => (x, y) match {
+      case (Left(a), Left(b)) => a === b
+      case (Right(a), Right(b)) => a === b
+      case _ => false
+    }
 }

src/main/scala/fpspeedrun/Monoid.scala

@@ -21,19 +21,30 @@ object Monoid extends StdMonoidInstances[Monoid] {
 final case class Endo[A](run: A => A) extends AnyVal
 
 object Endo{
-  implicit def endoMonoid[A]: Monoid[Endo[A]] = ???
+  implicit def endoMonoid[A]: Monoid[Endo[A]] = new Monoid[Endo[A]] {
+    override def empty: Endo[A] = Endo[A](identity)
+    override def combine(x: Endo[A], y: Endo[A]): Endo[A] = Endo[A](y.run compose x.run)
+  }
 }
 
 final case class Sum[T](value: T) extends AnyVal with Wrapper[T]
 
 object Sum extends WrapperCompanion[Sum] {
-  implicit def sumMonoid[T: Num]: Monoid[Sum[T]] = ???
+  implicit def sumMonoid[T: Num]: Monoid[Sum[T]] = new Monoid[Sum[T]] {
+    import syntax.num._
+    override def empty: Sum[T] = Sum(zero)
+    override def combine(x: Sum[T], y: Sum[T]): Sum[T] = Sum(x.value + y.value)
+  }
 }
 
 final case class Prod[T](value: T) extends AnyVal with Wrapper[T]
 
 object Prod extends WrapperCompanion[Prod] {
-  implicit def prodMonoid[T: Num]: Monoid[Prod[T]] = ???
+  implicit def prodMonoid[T: Num]: Monoid[Prod[T]] = new Monoid[Prod[T]] {
+    import syntax.num._
+    override def empty: Prod[T] = Prod(one)
+    override def combine(x: Prod[T], y: Prod[T]): Prod[T] = Prod(x.value * y.value)
+  }
 }
 
 
@@ -48,5 +59,8 @@ trait StdMonoidInstances[TC[x] >: Monoid[x]] {
     override def combine(x: List[A], y: List[A]): List[A] = x ::: y
   }
 
-  final implicit def vectorMonoid[A]: TC[Vector[A]] = ???
+  final implicit def vectorMonoid[A]: TC[Vector[A]] = new Monoid[Vector[A]] {
+    override def empty: Vector[A] = Vector.empty
+    override def combine(x: Vector[A], y: Vector[A]): Vector[A] = x ++ y
+  }
 }

src/main/scala/fpspeedrun/Ord.scala

@@ -71,5 +71,14 @@ object Ord extends StdOrdInstances[Ord] {
 
 trait StdOrdInstances[TC[t] >: Ord[t]] extends StdNumInstances[TC]{
   final implicit val stringOrd: TC[String] = byOrdering
-  final implicit def optionOrd[A: Ord]: TC[Option[A]] = ???
+  final implicit def optionOrd[A: Ord]: TC[Option[A]] = new Ord[Option[A]] {
+    import syntax.ord._
+    override def compare(x: Option[A], y: Option[A]): Compare =
+      (x, y) match {
+        case (None, None)         => EQ
+        case (Some(_), None)      => GT
+        case (None, Some(_))      => LT
+        case (Some(xv), Some(yv)) => xv <=> yv
+      }
+  }
 }

src/main/scala/fpspeedrun/ZipList.scala

@@ -1,5 +1,12 @@
 package fpspeedrun
 
+import syntax.semigroup._
+import syntax.integ._
+import syntax.num._
+import syntax.ord._
+import syntax.frac._
+import syntax.eq._
+
 trait ZipList[A] {
   def value: Either[A, List[A]]
 
@@ -25,17 +32,46 @@ object ZipList {
   def apply[A](list: List[A]): ZipList[A] = Finite(list)
   def repeat[A](value: A): ZipList[A] = Repeat(value)
 
-  implicit def zipListSemigroup[A: Semigroup]: Semigroup[ZipList[A]] = ???
+  def zlCompare[A : Ord](x: ZipList[A], y: ZipList[A]): Ord.Compare = (x.value, y.value) match {
+    case (Left(a), Left(b)) => a <=> b
+    case (Right(xs), Left(b)) => xs <=> List.fill(xs.size)(b)
+    case (Left(a), Right(xs)) => List.fill(xs.size)(a) <=> xs
+    case (Right(xs), Right(ys)) => xs <=> ys
+  }
 
-  implicit def zipListMonoid[A: Monoid]: Monoid[ZipList[A]] = ???
+  implicit def zipListSemigroup[A: Semigroup]: Semigroup[ZipList[A]] =
+    (x: ZipList[A], y: ZipList[A]) => x.zipWith(y)(_ |+| _)
 
-  implicit def zipListEq[A: Eq]: Eq[ZipList[A]] = ???
+  implicit def zipListMonoid[A: Monoid]: Monoid[ZipList[A]] = new Monoid[ZipList[A]] {
+    override def empty: ZipList[A] = Finite(List())
+    override def combine(x: ZipList[A], y: ZipList[A]): ZipList[A] = x.zipWith(y)(_ |+| _)
+  }
 
-  implicit def zipListOrd[A: Ord]: Ord[ZipList[A]] = ???
+  implicit def zipListEq[A: Eq]: Eq[ZipList[A]] = (x: ZipList[A], y: ZipList[A]) => x.value === y.value
 
-  implicit def zipListNum[A: Num]: Num[ZipList[A]] = ???
+  implicit def zipListOrd[A: Ord]: Ord[ZipList[A]] = (x: ZipList[A], y: ZipList[A]) => zlCompare(x, y)
 
-  implicit def zipListInteg[A: Integ]: Integ[ZipList[A]] = ???
+  implicit def zipListNum[A: Num]: Num[ZipList[A]] = new Num[ZipList[A]] {
+    override def times(x: ZipList[A], y: ZipList[A]): ZipList[A] = x.zipWith(y)(_ * _)
+    override def plus(x: ZipList[A], y: ZipList[A]): ZipList[A] = x.zipWith(y)(_ + _)
+    override def fromInt(x: Int): ZipList[A] = fromInt(x)
+    override def compare(x: ZipList[A], y: ZipList[A]): Ord.Compare = zlCompare(x, y)
+  }
 
-  implicit def zipListFrac[A: Frac]: Frac[ZipList[A]] = ???
+  implicit def zipListInteg[A: Integ]: Integ[ZipList[A]] = new Integ[ZipList[A]] {
+    override def quotRem(x: ZipList[A], y: ZipList[A]): (ZipList[A], ZipList[A]) =
+      (x.zipWith(y)(_ / _), x.zipWith(y)(_ % _))
+    override def times(x: ZipList[A], y: ZipList[A]): ZipList[A] = x.zipWith(y)(_ * _)
+    override def plus(x: ZipList[A], y: ZipList[A]): ZipList[A] = x.zipWith(y)(_ + _)
+    override def fromInt(x: Int): ZipList[A] = fromInt(x)
+    override def compare(x: ZipList[A], y: ZipList[A]): Ord.Compare = zlCompare(x, y)
+  }
+
+  implicit def zipListFrac[A: Frac]: Frac[ZipList[A]] = new Frac[ZipList[A]] {
+    override def div(x: ZipList[A], y: ZipList[A]): ZipList[A] = x.zipWith(y)(_ / _)
+    override def times(x: ZipList[A], y: ZipList[A]): ZipList[A] = x.zipWith(y)(_ * _)
+    override def plus(x: ZipList[A], y: ZipList[A]): ZipList[A] = x.zipWith(y)(_ + _)
+    override def fromInt(x: Int): ZipList[A] = fromInt(x)
+    override def compare(x: ZipList[A], y: ZipList[A]): Ord.Compare = zlCompare(x, y)
+  }
 }

src/main/scala/fpspeedrun/syntax/package.scala

@@ -48,13 +48,13 @@ object semigroup extends Semigroup.ToSemigroupOps {
 }
 
 object monoid extends Monoid.ToMonoidOps{
-  def empty[T: Monoid]: T = ???
+  def empty[T: Monoid]: T = Monoid[T].empty
 
   implicit class ListOps[A](val xs: List[A]) extends AnyVal{
-    def foldAll(implicit mon: Monoid[A]): A = ???
+    def foldAll(implicit mon: Monoid[A]): A = xs.fold(empty)(mon.combine)
 
-    def foldMap[B: Monoid](f: A => B): B = ???
+    def foldMap[B: Monoid](f: A => B): B = xs.foldLeft(empty) { case (acc, next) => Monoid[B].combine(acc, f(next)) }
 
-    def foldVia[F[_]](implicit iso: Iso[A, F[A]], mon: Monoid[F[A]]): A = ???
+    def foldVia[F[_]](implicit iso: Iso[A, F[A]], mon: Monoid[F[A]]): A = iso.unwrap( xs.map(iso.wrap).foldAll )
   }
 }