Enforce consistent arrow symbols using scalafmt

.scalafmt.conf

@@ -20,3 +20,8 @@ rewrite {
   rules = [SortImports, RedundantBraces]
   redundantBraces.maxLines = 1
 }
+
+rewriteTokens {
+  "⇒": "=>"
+  "←": "<-"
+}

shared/src/main/scala/implicits.scala

@@ -32,27 +32,24 @@ object implicits {
       override def runQuery[A](j: Query[A]): Future[A] = j match {
 
         case Sync(e) =>
-          Future({e.value})
+          Future({ e.value })
 
         case Async(ac, timeout) =>
-
           val p = Promise[A]()
 
           val runnable = new Runnable {
-            def run() : Unit = ac(p.trySuccess, p.tryFailure)
+            def run(): Unit = ac(p.trySuccess, p.tryFailure)
           }
 
           timeout match {
 
             // Handle the case where there is a finite timeout requested
             case finite: FiniteDuration =>
-
               // Timer task that completes the future when the timeout occurs
               // if it didn't complete already
               val timerTask = new TimerTask() {
-                def run() : Unit = {
+                def run(): Unit =
                   p.tryFailure(new TimeoutException())
-                }
               }
 
               // Start the timeout Timer
@@ -61,9 +58,8 @@ object implicits {
               // Execute the user's action
               ec.execute(runnable)
 
-            // No timeout 
+            // No timeout
             case _ =>
-
               // Execute the user's action
               ec.execute(runnable)
           }
@@ -74,6 +70,5 @@ object implicits {
           runQuery(qf).zip(runQuery(qx)).map { case (f, x) => f(x) }
       }
 
-
     }
 }

twitter/jvm/src/main/scala/TwitterFuture.scala

@@ -37,8 +37,8 @@ object implicits {
   ): FetchMonadError[Rerunnable] =
     new FetchMonadError.FromMonadError[Rerunnable] {
       override def runQuery[A](j: Query[A]): Rerunnable[A] = j match {
-        case Sync(e) ⇒ evalToRerunnable(e)
-        case Async(ac, timeout) ⇒
+        case Sync(e) => evalToRerunnable(e)
+        case Async(ac, timeout) =>
           Rerunnable.fromFuture {
             val p: Promise[A] = Promise()
             pool(ac(p setValue _, p setException _))
@@ -48,7 +48,7 @@ object implicits {
               case _ => p
             }
           }
-        case Ap(qf, qx) ⇒
+        case Ap(qf, qx) =>
           runQuery(qf).product(runQuery(qx)) map { case (f, x) => f(x) }
       }
     }
@@ -58,16 +58,16 @@ object implicits {
   ): FetchMonadError[Future] =
     new FetchMonadError.FromMonadError[Future] {
       override def runQuery[A](j: Query[A]): Future[A] = j match {
-        case Sync(e) ⇒ Future(e.value)
-        case Async(ac, timeout) ⇒
+        case Sync(e) => Future(e.value)
+        case Async(ac, timeout) =>
           val p: Promise[A] = Promise()
           pool(ac(p setValue _, p setException _))
           timeout match {
             case _: FiniteDuration =>
               p.raiseWithin(Duration(timeout.length, timeout.unit))(Timer.Nil)
             case _ => p
           }
-        case Ap(qf, qx) ⇒
+        case Ap(qf, qx) =>
           ap(runQuery(qf))(runQuery(qx))
       }
     }

twitter/jvm/src/test/scala/FetchTwitterFutureSpec.scala

@@ -56,7 +56,7 @@ class FetchTwitterFutureSpec extends FlatSpec with Matchers {
   object ArticleAsync extends DataSource[ArticleId, Article] {
     override def name = "ArticleAsync"
     override def fetchOne(id: ArticleId): Query[Option[Article]] =
-      Query.async((ok, fail) ⇒ {
+      Query.async((ok, fail) => {
         ok(Option(Article(id.id, "An article with id " + id.id)))
       })
     override def fetchMany(ids: NonEmptyList[ArticleId]): Query[Map[ArticleId, Article]] =
@@ -71,7 +71,7 @@ class FetchTwitterFutureSpec extends FlatSpec with Matchers {
   implicit object AuthorFuture extends DataSource[AuthorId, Author] {
     override def name = "AuthorFuture"
     override def fetchOne(id: AuthorId): Query[Option[Author]] =
-      Query.async((ok, fail) ⇒ {
+      Query.async((ok, fail) => {
         ok(Option(Author(id.id, "@egg" + id.id)))
       })
     override def fetchMany(ids: NonEmptyList[AuthorId]): Query[Map[AuthorId, Author]] =
@@ -87,8 +87,8 @@ class FetchTwitterFutureSpec extends FlatSpec with Matchers {
   }
   it should "allow for several async datasources to be combined" in {
     val fetch: Fetch[(Article, Author)] = for {
-      art    ← article(1)
-      author ← author(art)
+      art    <- article(1)
+      author <- author(art)
     } yield (art, author)
 
     Await.result(Fetch.run[Future](fetch), 100.milliseconds) shouldEqual (Article(
@@ -122,8 +122,8 @@ class FetchTwitterFutureSpec extends FlatSpec with Matchers {
   }
   it should "allow for several async datasources to be combined" in {
     val fetch: Fetch[(Article, Author)] = for {
-      art    ← article(1)
-      author ← author(art)
+      art    <- article(1)
+      author <- author(art)
     } yield (art, author)
 
     val rr: Rerunnable[(Article, Author)] = Fetch.run[Rerunnable](fetch)