pre-commit

src/main/scala/gs/fizzbuzz/Condition.scala

@@ -12,7 +12,10 @@ object Condition:
   def apply[F[_]: Applicative, Input](
     comparison: Input,
     operator: Monoid[Input]
-  )(using CanEqual[Input, Input]): Condition[F, Input] =
+  )(
+    using
+    CanEqual[Input, Input]
+  ): Condition[F, Input] =
     new DefaultCondition[F, Input](comparison, operator)
 
   def forInt[F[_]: Applicative](
@@ -31,19 +34,26 @@ object Condition:
     new Monoid[Int] {
       override def empty: Int = 0
 
-      override def combine(x: Int, y: Int): Int = op(x, y)
+      override def combine(
+        x: Int,
+        y: Int
+      ): Int = op(x, y)
     }
 
   private def makeLongMonoid(op: (Long, Long) => Long): Monoid[Long] =
     new Monoid[Long] {
       override def empty: Long = 0
 
-      override def combine(x: Long, y: Long): Long = op(x, y)
+      override def combine(
+        x: Long,
+        y: Long
+      ): Long = op(x, y)
     }
 
   def noop[F[_]: Applicative, Input]: Condition[F, Input] = new Noop[F, Input]
 
   final class Noop[F[_]: Applicative, Input] extends Condition[F, Input]:
+
     override def matches(input: Input): F[Boolean] =
       Applicative[F].pure(false)
 

src/main/scala/gs/fizzbuzz/DefaultCondition.scala

@@ -6,7 +6,10 @@ import cats.Monoid
 final class DefaultCondition[F[_]: Applicative, Input](
   val comparison: Input,
   val operator: Monoid[Input]
-)(using CanEqual[Input, Input]) extends Condition[F, Input]:
+)(
+  using
+  CanEqual[Input, Input]
+) extends Condition[F, Input]:
 
   override def matches(input: Input): F[Boolean] =
     Applicative[F].pure(

src/main/scala/gs/fizzbuzz/DefaultFizzBuzz.scala

@@ -1,24 +1,21 @@
 package gs.fizzbuzz
 
-import cats.syntax.all.*
 import cats.FlatMap
+import cats.syntax.all.*
 
 class DefaultFizzBuzz[F[_]: FlatMap, Input](
   val fizzCondition: Condition[F, Input],
   val buzzCondition: Condition[F, Input]
 ) extends FizzBuzz[F, Input]:
+
   def evaluate(input: Input): F[Result] =
     for
       fizz <- fizzCondition.matches(input)
       buzz <- buzzCondition.matches(input)
     yield
-      if fizz && buzz then
-        Result.FizzBuzz
-      else if fizz then
-        Result.Fizz
-      else if buzz then
-        Result.Buzz
-      else
-        Result.Unmatched
+      if fizz && buzz then Result.FizzBuzz
+      else if fizz then Result.Fizz
+      else if buzz then Result.Buzz
+      else Result.Unmatched
 
 end DefaultFizzBuzz

src/main/scala/gs/fizzbuzz/FizzBuzz.scala

@@ -1,8 +1,8 @@
 package gs.fizzbuzz
 
-import fs2.Pipe
 import cats.Applicative
 import cats.FlatMap
+import fs2.Pipe
 
 trait FizzBuzz[F[_], Input]:
   def evaluate(input: Input): F[Result]
@@ -14,7 +14,8 @@ object FizzBuzz:
   def apply[F[_]: FlatMap, Input](
     fizzCondition: Condition[F, Input],
     buzzCondition: Condition[F, Input]
-  ): FizzBuzz[F, Input] = new DefaultFizzBuzz[F, Input](fizzCondition, buzzCondition)
+  ): FizzBuzz[F, Input] =
+    new DefaultFizzBuzz[F, Input](fizzCondition, buzzCondition)
 
   def forInt[F[_]: FlatMap: Applicative](
     fizz: Int,
@@ -37,6 +38,7 @@ object FizzBuzz:
   def noop[F[_]: Applicative, Input]: FizzBuzz[F, Input] = new Noop[F, Input]
 
   final class Noop[F[_]: Applicative, Input] extends FizzBuzz[F, Input]:
+
     override def evaluate(input: Input): F[Result] =
       Applicative[F].pure(Result.Unmatched)
 

src/main/scala/gs/fizzbuzz/Main.scala

@@ -1,15 +1,19 @@
 package gs.fizzbuzz
 
+import cats.effect.ExitCode
 import cats.effect.IO
 import cats.effect.IOApp
-import cats.effect.ExitCode
 
 object Main extends IOApp:
+
   override def run(args: List[String]): IO[ExitCode] =
     val fb = FizzBuzz.forLong[IO](
       fizz = 3,
       buzz = 5,
-      f = (x, y) => x % y
+      f = (
+        x,
+        y
+      ) => x % y
     )
 
     for
@@ -21,5 +25,4 @@ object Main extends IOApp:
       _   <- IO.println(ex2)
       _   <- IO.println(ex3)
       _   <- IO.println(ex4)
-    yield
-      ExitCode.Success
+    yield ExitCode.Success